diff --git a/ViTPose/ckpts/vitpose-s-coco_25.pth b/ViTPose/ckpts/vitpose-s-coco_25.pth new file mode 100644 index 0000000000000000000000000000000000000000..b388f7c568ae761d7ce71d2a9d581def5ba51e21 --- /dev/null +++ b/ViTPose/ckpts/vitpose-s-coco_25.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5af7cbeb123e2a60bf25d981d4b89dab281f3fca18b7956b49a7a685b6311bfe +size 97235808 diff --git a/ViTPose/easy_ViTPose/.dockerignore b/ViTPose/easy_ViTPose/.dockerignore new file mode 100644 index 0000000000000000000000000000000000000000..d356bb0721723c1a13b595679470de7c6da96e98 --- /dev/null +++ b/ViTPose/easy_ViTPose/.dockerignore @@ -0,0 +1,2 @@ +Dockerfile +models diff --git a/ViTPose/easy_ViTPose/.gitignore b/ViTPose/easy_ViTPose/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..1c0ef98423142c03faa4d622ae37e92d974a050a --- /dev/null +++ b/ViTPose/easy_ViTPose/.gitignore @@ -0,0 +1,13 @@ +**/*.pt +**/*.pth +**/*.onnx +**/__pycache__ +**/coco/ +.DS_Store +runs +ckpts +annotations +examples +outputs +.ipynb_checkpoints +easy_ViTPose.egg-info diff --git a/ViTPose/easy_ViTPose/.ipynb_checkpoints/README-checkpoint.md b/ViTPose/easy_ViTPose/.ipynb_checkpoints/README-checkpoint.md new file mode 100644 index 0000000000000000000000000000000000000000..0aa9c2b96eacf4eee861c8ecaeee61556ae5f0c6 --- /dev/null +++ b/ViTPose/easy_ViTPose/.ipynb_checkpoints/README-checkpoint.md @@ -0,0 +1,275 @@ +# easy_ViTPose +

+ easy_ViTPose +

+ +## Accurate 2d human and animal pose estimation + + + Open In Colab + + +### Easy to use SOTA `ViTPose` [Y. Xu et al., 2022] models for fast inference. +We provide all the VitPose original models, converted for inference, with single dataset format output. + +In addition to that we also provide a Coco-25 model, trained on the original coco dataset + feet https://cmu-perceptual-computing-lab.github.io/foot_keypoint_dataset/ +Finetuning is not currently supported, you can check de43d54cad87404cf0ad4a7b5da6bacf4240248b and previous commits for a working state of `train.py` + +> [!WARNING] +> Ultralytics `yolov8` has issue with wrong bounding boxes when using `mps`, upgrade to latest version! (Works correctly on 8.2.48) + +## Results +![resimg](https://github.com/JunkyByte/easy_ViTPose/assets/24314647/51c0777f-b268-448a-af02-9a3537f288d8) + +https://github.com/JunkyByte/easy_ViTPose/assets/24314647/e9a82c17-6e99-4111-8cc8-5257910cb87e + +https://github.com/JunkyByte/easy_ViTPose/assets/24314647/63af44b1-7245-4703-8906-3f034a43f9e3 + +(Credits dance: https://www.youtube.com/watch?v=p-rSdt0aFuw ) +(Credits zebras: https://www.youtube.com/watch?v=y-vELRYS8Yk ) + +## Features +- Image / Video / Webcam support +- Video support using SORT algorithm to track bboxes between frames +- Torch / ONNX / Tensorrt inference +- Runs the original VitPose checkpoints from [ViTAE-Transformer/ViTPose](https://github.com/ViTAE-Transformer/ViTPose) +- 4 ViTPose architectures with different sizes and performances (s: small, b: base, l: large, h: huge) +- Multi skeleton and dataset: (AIC / MPII / COCO / COCO + FEET / COCO WHOLEBODY / APT36k / AP10k) +- Human / Animal pose estimation +- cpu / gpu / metal support +- show and save images / videos and output to json + +We run YOLOv8 for detection, it does not provide complete animal detection. You can finetune a custom yolo model to detect the animal you are interested in, +if you do please open an issue, we might want to integrate other models for detection. + +### Benchmark: +You can expect realtime >30 fps with modern nvidia gpus and apple silicon (using metal!). + +### Skeleton reference +There are multiple skeletons for different dataset. Check the definition here [visualization.py](https://github.com/JunkyByte/easy_ViTPose/blob/main/easy_ViTPose/vit_utils/visualization.py). + +## Installation and Usage +> [!IMPORTANT] +> Install `torch>2.0 with cuda / mps support` by yourself. +> also check `requirements_gpu.txt`. + +```bash +git clone git@github.com:JunkyByte/easy_ViTPose.git +cd easy_ViTPose/ +pip install -e . +pip install -r requirements.txt +``` + +### Download models +- Download the models from [Huggingface](https://huggingface.co/JunkyByte/easy_ViTPose) +We provide torch models for every dataset and architecture. +If you want to run onnx / tensorrt inference download the appropriate torch ckpt and use `export.py` to convert it. +You can use `ultralytics` `yolo export` command to export yolo to onnx and tensorrt as well. + +#### Export to onnx and tensorrt +```bash +$ python export.py --help +usage: export.py [-h] --model-ckpt MODEL_CKPT --model-name {s,b,l,h} [--output OUTPUT] [--dataset DATASET] + +optional arguments: + -h, --help show this help message and exit + --model-ckpt MODEL_CKPT + The torch model that shall be used for conversion + --model-name {s,b,l,h} + [s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H] + --output OUTPUT File (without extension) or dir path for checkpoint output + --dataset DATASET Name of the dataset. If None it"s extracted from the file name. ["coco", "coco_25", + "wholebody", "mpii", "ap10k", "apt36k", "aic"] +``` + +### Run inference +To run inference from command line you can use the `inference.py` script as follows: +```bash +$ python inference.py --help +usage: inference.py [-h] [--input INPUT] [--output-path OUTPUT_PATH] --model MODEL [--yolo YOLO] [--dataset DATASET] + [--det-class DET_CLASS] [--model-name {s,b,l,h}] [--yolo-size YOLO_SIZE] + [--conf-threshold CONF_THRESHOLD] [--rotate {0,90,180,270}] [--yolo-step YOLO_STEP] + [--single-pose] [--show] [--show-yolo] [--show-raw-yolo] [--save-img] [--save-json] + +optional arguments: + -h, --help show this help message and exit + --input INPUT path to image / video or webcam ID (=cv2) + --output-path OUTPUT_PATH + output path, if the path provided is a directory output files are "input_name + +_result{extension}". + --model MODEL checkpoint path of the model + --yolo YOLO checkpoint path of the yolo model + --dataset DATASET Name of the dataset. If None it"s extracted from the file name. ["coco", "coco_25", + "wholebody", "mpii", "ap10k", "apt36k", "aic"] + --det-class DET_CLASS + ["human", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", + "animals"] + --model-name {s,b,l,h} + [s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H] + --yolo-size YOLO_SIZE + YOLOv8 image size during inference + --conf-threshold CONF_THRESHOLD + Minimum confidence for keypoints to be drawn. [0, 1] range + --rotate {0,90,180,270} + Rotate the image of [90, 180, 270] degress counterclockwise + --yolo-step YOLO_STEP + The tracker can be used to predict the bboxes instead of yolo for performance, this flag + specifies how often yolo is applied (e.g. 1 applies yolo every frame). This does not have any + effect when is_video is False + --single-pose Do not use SORT tracker because single pose is expected in the video + --show preview result during inference + --show-yolo draw yolo results + --show-raw-yolo draw yolo result before that SORT is applied for tracking (only valid during video inference) + --save-img save image results + --save-json save json results +``` + +You can run inference from code as follows: +```python +import cv2 +from easy_ViTPose import VitInference + +# Image to run inference RGB format +img = cv2.imread('./examples/img1.jpg') +img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + +# set is_video=True to enable tracking in video inference +# be sure to use VitInference.reset() function to reset the tracker after each video +# There are a few flags that allows to customize VitInference, be sure to check the class definition +model_path = './ckpts/vitpose-s-coco_25.pth' +yolo_path = './yolov8s.pth' + +# If you want to use MPS (on new macbooks) use the torch checkpoints for both ViTPose and Yolo +# If device is None will try to use cuda -> mps -> cpu (otherwise specify 'cpu', 'mps' or 'cuda') +# dataset and det_class parameters can be inferred from the ckpt name, but you can specify them. +model = VitInference(model_path, yolo_path, model_name='s', yolo_size=320, is_video=False, device=None) + +# Infer keypoints, output is a dict where keys are person ids and values are keypoints (np.ndarray (25, 3): (y, x, score)) +# If is_video=True the IDs will be consistent among the ordered video frames. +keypoints = model.inference(img) + +# call model.reset() after each video + +img = model.draw(show_yolo=True) # Returns RGB image with drawings +cv2.imshow('image', cv2.cvtColor(img, cv2.COLOR_RGB2BGR)); cv2.waitKey(0) +``` +> [!NOTE] +> If the input file is a video [SORT](https://github.com/abewley/sort) is used to track people IDs and output consistent identifications. + +### OUTPUT json format +The output format of the json files: + +``` +{ + "keypoints": + [ # The list of frames, len(json['keypoints']) == len(video) + { # For each frame a dict + "0": [ # keys are id to track people and value the keypoints + [121.19, 458.15, 0.99], # Each keypoint is (y, x, score) + [110.02, 469.43, 0.98], + [110.86, 445.04, 0.99], + ], + "1": [ + ... + ], + }, + { + "0": [ + [122.19, 458.15, 0.91], + [105.02, 469.43, 0.95], + [122.86, 445.04, 0.99], + ], + "1": [ + ... + ] + } + ], + "skeleton": + { # Skeleton reference, key the idx, value the name + "0": "nose", + "1": "left_eye", + "2": "right_eye", + "3": "left_ear", + "4": "right_ear", + "5": "neck", + ... + } +} +``` + +## Finetuning +Finetuning is possible but not officially supported right now. If you would like to finetune and need help open an issue. +You can check `train.py`, `datasets/COCO.py` and `config.yaml` for details. + +--- + +## Evaluation on COCO dataset +1. Download COCO dataset images and labels + - 2017 Val images [5K/1GB]: http://images.cocodataset.org/zips/val2017.zip
+ The extracted directory looks like this: + ``` + val2017/ + ├── 000000000139.jpg + ├── 000000000285.jpg + ├── 000000000632.jpg + └── ... + ``` + - 2017 Train/Val annotations [241MB]: http://images.cocodataset.org/annotations/annotations_trainval2017.zip
+ The extracted directory looks like this: + ``` + annotations/ + ├── person_keypoints_val2017.json + ├── person_keypoints_train2017.json + └── ... + ``` + +2. Run the following command: + + ```bash + + $ python evaluation_on_coco.py + + Command line arguments: + --model_path: Path to the pretrained ViT Pose model + + --yolo_path: Path to the YOLOv8 model + + --img_folder_path: Path to the directory containing COCO val images (/val2017 extracted in step 1). + + --annFile: Path to json file for COCO keypoints for val set (annotations/person_keypoints_val2017.json extracted in step 1) + ``` + +--- + + +## Docker +The system may be built in a container using Docker. This is intended to demonstrate container-wise inference, adapt it to your own needs by changing models and skeletons: + +`docker build . -t easy_vitpose` + +The image is based on NVIDIA's PyTorch image, which is 20GB large. +If you have a compatible GPU set up with [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html), +ViTPose will run with hardware acceleration. + +To test an example, create a folder called `cats` with a picture of a cat as `image.jpg`. +Run `./models/download.sh` to fetch the large yolov8 and ap10k ViTPose models. Then run inference using the following command (replace with the correct `cats` and `models` paths): + +`docker run --gpus all --rm -it --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 -v ./models:/models -v ~/cats:/cats easy_vitpose python inference.py --det-class cat --input /cats/image.jpg --output-path /cats --save-img --model /models/vitpose-l-ap10k.onnx --yolo /models/yolov8l.pt` + +The result image may be viewed in your `cats` folder. + +## TODO: +- refactor finetuning (currently not available) +- benchmark and check bottlenecks of inference pipeline +- parallel batched inference +- other minor fixes +- yolo version for animal pose, check https://github.com/JunkyByte/easy_ViTPose/pull/18 +- solve cuda exceptions on script exit when using tensorrt (no idea how) +- add infos about inferred informations during inference, better output of inference status (device etc) +- check if is possible to make colab work without runtime restart + +Feel free to open issues, pull requests and contribute on these TODOs. + +## Reference +Thanks to the VitPose authors and their official implementation [ViTAE-Transformer/ViTPose](https://github.com/ViTAE-Transformer/ViTPose). +The SORT code is taken from [abewley/sort](https://github.com/abewley/sort) diff --git a/ViTPose/easy_ViTPose/.ipynb_checkpoints/colab_demo-checkpoint.ipynb b/ViTPose/easy_ViTPose/.ipynb_checkpoints/colab_demo-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..9f20c6fa82688cbfbf03c2e7d99f4eeb0c8cbb07 --- /dev/null +++ b/ViTPose/easy_ViTPose/.ipynb_checkpoints/colab_demo-checkpoint.ipynb @@ -0,0 +1,997 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "b0761f32610c4765a82cfc8f901356d9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8e20ffed38024ab5bfa8361f28852e00", + "IPY_MODEL_9954b2e0034a4106b9c00c89ac237a3d", + "IPY_MODEL_473dfcf611e54451a7de2f0950af81d3" + ], + "layout": "IPY_MODEL_3c60a788ecc6475884b62055bc167d0c" + } + }, + "8e20ffed38024ab5bfa8361f28852e00": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56b99433062f47b19081f8185b2f5f39", + "placeholder": "​", + "style": "IPY_MODEL_e81b426b15744848a783320254ecce8b", + "value": "Downloading (…)pose-b-wholebody.pth: 100%" + } + }, + "9954b2e0034a4106b9c00c89ac237a3d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e1b06389ec174ee088dba83724828e43", + "max": 360153207, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_43ba777eb879488b8f2ee4b98484f3b1", + "value": 360153207 + } + }, + "473dfcf611e54451a7de2f0950af81d3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_818cd9a4336c481688d42ea88292b181", + "placeholder": "​", + "style": "IPY_MODEL_65ecee0429774fcaad1f4ace595ec518", + "value": " 360M/360M [00:09<00:00, 36.8MB/s]" + } + }, + "3c60a788ecc6475884b62055bc167d0c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56b99433062f47b19081f8185b2f5f39": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e81b426b15744848a783320254ecce8b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e1b06389ec174ee088dba83724828e43": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43ba777eb879488b8f2ee4b98484f3b1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "818cd9a4336c481688d42ea88292b181": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65ecee0429774fcaad1f4ace595ec518": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# easy_ViTPose demo\n", + "Be sure to enable GPU runtime" + ], + "metadata": { + "id": "m7kiw4g_5L9d" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "FL7NZhO6vsFQ", + "outputId": "6d4ba0a0-3a83-48bc-e9f0-a75688ff85f7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'easy_ViTPose'...\n", + "remote: Enumerating objects: 815, done.\u001b[K\n", + "remote: Counting objects: 100% (231/231), done.\u001b[K\n", + "remote: Compressing objects: 100% (121/121), done.\u001b[K\n", + "remote: Total 815 (delta 176), reused 134 (delta 110), pack-reused 584\u001b[K\n", + "Receiving objects: 100% (815/815), 8.98 MiB | 14.97 MiB/s, done.\n", + "Resolving deltas: 100% (483/483), done.\n", + "Requirement already satisfied: certifi==2023.7.22 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 1)) (2023.7.22)\n", + "Requirement already satisfied: charset-normalizer==3.2.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 2)) (3.2.0)\n", + "Collecting coloredlogs==15.0.1 (from -r requirements.txt (line 3))\n", + " Downloading coloredlogs-15.0.1-py2.py3-none-any.whl (46 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting contourpy==1.1.1 (from -r requirements.txt (line 4))\n", + " Downloading contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (301 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m301.7/301.7 kB\u001b[0m \u001b[31m7.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: cycler==0.11.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 5)) (0.11.0)\n", + "Collecting ffmpeg==1.4 (from -r requirements.txt (line 6))\n", + " Downloading ffmpeg-1.4.tar.gz (5.1 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting filelock==3.12.4 (from -r requirements.txt (line 7))\n", + " Downloading filelock-3.12.4-py3-none-any.whl (11 kB)\n", + "Collecting filterpy==1.4.5 (from -r requirements.txt (line 8))\n", + " Downloading filterpy-1.4.5.zip (177 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m178.0/178.0 kB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: flatbuffers==23.5.26 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 9)) (23.5.26)\n", + "Requirement already satisfied: fonttools==4.42.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 10)) (4.42.1)\n", + "Collecting humanfriendly==10.0 (from -r requirements.txt (line 11))\n", + " Downloading humanfriendly-10.0-py2.py3-none-any.whl (86 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna==3.4 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 12)) (3.4)\n", + "Requirement already satisfied: imageio==2.31.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 13)) (2.31.3)\n", + "Collecting importlib-resources==6.1.0 (from -r requirements.txt (line 14))\n", + " Downloading importlib_resources-6.1.0-py3-none-any.whl (33 kB)\n", + "Requirement already satisfied: Jinja2==3.1.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 15)) (3.1.2)\n", + "Requirement already satisfied: kiwisolver==1.4.5 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 16)) (1.4.5)\n", + "Requirement already satisfied: lazy_loader==0.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 17)) (0.3)\n", + "Requirement already satisfied: MarkupSafe==2.1.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 18)) (2.1.3)\n", + "Collecting matplotlib==3.8.0 (from -r requirements.txt (line 19))\n", + " Downloading matplotlib-3.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (11.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.6/11.6 MB\u001b[0m \u001b[31m42.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath==1.3.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 20)) (1.3.0)\n", + "Requirement already satisfied: networkx==3.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 21)) (3.1)\n", + "Collecting numpy==1.26.0 (from -r requirements.txt (line 22))\n", + " Downloading numpy-1.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m53.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting onnx==1.14.1 (from -r requirements.txt (line 23))\n", + " Downloading onnx-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.6/14.6 MB\u001b[0m \u001b[31m37.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting onnxruntime==1.16.0 (from -r requirements.txt (line 24))\n", + " Downloading onnxruntime-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.2/6.2 MB\u001b[0m \u001b[31m83.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: opencv-python==4.8.0.76 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 25)) (4.8.0.76)\n", + "Requirement already satisfied: packaging==23.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 26)) (23.1)\n", + "Collecting pandas==2.1.1 (from -r requirements.txt (line 27))\n", + " Downloading pandas-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.3/12.3 MB\u001b[0m \u001b[31m23.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting Pillow==10.0.1 (from -r requirements.txt (line 28))\n", + " Downloading Pillow-10.0.1-cp310-cp310-manylinux_2_28_x86_64.whl (3.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m86.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting protobuf==4.24.3 (from -r requirements.txt (line 29))\n", + " Downloading protobuf-4.24.3-cp37-abi3-manylinux2014_x86_64.whl (311 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m311.6/311.6 kB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: psutil==5.9.5 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 30)) (5.9.5)\n", + "Requirement already satisfied: py-cpuinfo==9.0.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 31)) (9.0.0)\n", + "Requirement already satisfied: pyparsing==3.1.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 32)) (3.1.1)\n", + "Requirement already satisfied: python-dateutil==2.8.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 33)) (2.8.2)\n", + "Requirement already satisfied: pytz==2023.3.post1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 34)) (2023.3.post1)\n", + "Requirement already satisfied: PyWavelets==1.4.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 35)) (1.4.1)\n", + "Requirement already satisfied: PyYAML==6.0.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 36)) (6.0.1)\n", + "Requirement already satisfied: requests==2.31.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 37)) (2.31.0)\n", + "Collecting scikit-image==0.21.0 (from -r requirements.txt (line 38))\n", + " Downloading scikit_image-0.21.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m103.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy==1.11.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 39)) (1.11.2)\n", + "Requirement already satisfied: seaborn==0.12.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 40)) (0.12.2)\n", + "Requirement already satisfied: six==1.16.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 41)) (1.16.0)\n", + "Requirement already satisfied: sympy==1.12 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 42)) (1.12)\n", + "Collecting tifffile==2023.9.18 (from -r requirements.txt (line 43))\n", + " Downloading tifffile-2023.9.18-py3-none-any.whl (222 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m222.1/222.1 kB\u001b[0m \u001b[31m27.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tqdm==4.66.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 44)) (4.66.1)\n", + "Collecting typing_extensions==4.8.0 (from -r requirements.txt (line 45))\n", + " Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", + "Collecting tzdata==2023.3 (from -r requirements.txt (line 46))\n", + " Downloading tzdata-2023.3-py2.py3-none-any.whl (341 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m341.8/341.8 kB\u001b[0m \u001b[31m39.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ultralytics==8.0.184 (from -r requirements.txt (line 47))\n", + " Downloading ultralytics-8.0.184-py3-none-any.whl (618 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m618.0/618.0 kB\u001b[0m \u001b[31m49.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting urllib3==2.0.5 (from -r requirements.txt (line 48))\n", + " Downloading urllib3-2.0.5-py3-none-any.whl (123 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m123.8/123.8 kB\u001b[0m \u001b[31m16.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting zipp==3.17.0 (from -r requirements.txt (line 49))\n", + " Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", + "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.10/dist-packages (from ultralytics==8.0.184->-r requirements.txt (line 47)) (2.0.1+cu118)\n", + "Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from ultralytics==8.0.184->-r requirements.txt (line 47)) (0.15.2+cu118)\n", + "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (2.0.0)\n", + "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (3.27.4.1)\n", + "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (16.0.6)\n", + "Building wheels for collected packages: ffmpeg, filterpy\n", + " Building wheel for ffmpeg (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ffmpeg: filename=ffmpeg-1.4-py3-none-any.whl size=6082 sha256=63fd12aaeb6b7d5e017e908717004872b0a428f7a3569bb4eaa2f8b5590554be\n", + " Stored in directory: /root/.cache/pip/wheels/8e/7a/69/cd6aeb83b126a7f04cbe7c9d929028dc52a6e7d525ff56003a\n", + " Building wheel for filterpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for filterpy: filename=filterpy-1.4.5-py3-none-any.whl size=110459 sha256=dfa6f7c452d0b1fa6c545b911843b9b7b0bfed0aa3ba4d95fcbc000a336f1ed9\n", + " Stored in directory: /root/.cache/pip/wheels/0f/0c/ea/218f266af4ad626897562199fbbcba521b8497303200186102\n", + "Successfully built ffmpeg filterpy\n", + "Installing collected packages: ffmpeg, zipp, urllib3, tzdata, typing_extensions, protobuf, Pillow, numpy, importlib-resources, humanfriendly, filelock, tifffile, pandas, onnx, contourpy, coloredlogs, scikit-image, onnxruntime, matplotlib, filterpy, ultralytics\n", + " Attempting uninstall: zipp\n", + " Found existing installation: zipp 3.16.2\n", + " Uninstalling zipp-3.16.2:\n", + " Successfully uninstalled zipp-3.16.2\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 2.0.4\n", + " Uninstalling urllib3-2.0.4:\n", + " Successfully uninstalled urllib3-2.0.4\n", + " Attempting uninstall: typing_extensions\n", + " Found existing installation: typing_extensions 4.5.0\n", + " Uninstalling typing_extensions-4.5.0:\n", + " Successfully uninstalled typing_extensions-4.5.0\n", + " Attempting uninstall: protobuf\n", + " Found existing installation: protobuf 3.20.3\n", + " Uninstalling protobuf-3.20.3:\n", + " Successfully uninstalled protobuf-3.20.3\n", + " Attempting uninstall: Pillow\n", + " Found existing installation: Pillow 9.4.0\n", + " Uninstalling Pillow-9.4.0:\n", + " Successfully uninstalled Pillow-9.4.0\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.23.5\n", + " Uninstalling numpy-1.23.5:\n", + " Successfully uninstalled numpy-1.23.5\n", + " Attempting uninstall: importlib-resources\n", + " Found existing installation: importlib-resources 6.0.1\n", + " Uninstalling importlib-resources-6.0.1:\n", + " Successfully uninstalled importlib-resources-6.0.1\n", + " Attempting uninstall: filelock\n", + " Found existing installation: filelock 3.12.2\n", + " Uninstalling filelock-3.12.2:\n", + " Successfully uninstalled filelock-3.12.2\n", + " Attempting uninstall: tifffile\n", + " Found existing installation: tifffile 2023.8.30\n", + " Uninstalling tifffile-2023.8.30:\n", + " Successfully uninstalled tifffile-2023.8.30\n", + " Attempting uninstall: pandas\n", + " Found existing installation: pandas 1.5.3\n", + " Uninstalling pandas-1.5.3:\n", + " Successfully uninstalled pandas-1.5.3\n", + " Attempting uninstall: contourpy\n", + " Found existing installation: contourpy 1.1.0\n", + " Uninstalling contourpy-1.1.0:\n", + " Successfully uninstalled contourpy-1.1.0\n", + " Attempting uninstall: scikit-image\n", + " Found existing installation: scikit-image 0.19.3\n", + " Uninstalling scikit-image-0.19.3:\n", + " Successfully uninstalled scikit-image-0.19.3\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.7.1\n", + " Uninstalling matplotlib-3.7.1:\n", + " Successfully uninstalled matplotlib-3.7.1\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "cupy-cuda11x 11.0.0 requires numpy<1.26,>=1.20, but you have numpy 1.26.0 which is incompatible.\n", + "google-colab 1.0.0 requires pandas==1.5.3, but you have pandas 2.1.1 which is incompatible.\n", + "numba 0.56.4 requires numpy<1.24,>=1.18, but you have numpy 1.26.0 which is incompatible.\n", + "tensorflow 2.13.0 requires numpy<=1.24.3,>=1.22, but you have numpy 1.26.0 which is incompatible.\n", + "tensorflow 2.13.0 requires typing-extensions<4.6.0,>=3.6.6, but you have typing-extensions 4.8.0 which is incompatible.\n", + "tensorflow-metadata 1.14.0 requires protobuf<4.21,>=3.20.3, but you have protobuf 4.24.3 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed Pillow-10.0.1 coloredlogs-15.0.1 contourpy-1.1.1 ffmpeg-1.4 filelock-3.12.4 filterpy-1.4.5 humanfriendly-10.0 importlib-resources-6.1.0 matplotlib-3.8.0 numpy-1.26.0 onnx-1.14.1 onnxruntime-1.16.0 pandas-2.1.1 protobuf-4.24.3 scikit-image-0.21.0 tifffile-2023.9.18 typing_extensions-4.8.0 tzdata-2023.3 ultralytics-8.0.184 urllib3-2.0.5 zipp-3.17.0\n", + "Obtaining file:///content/easy_ViTPose\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Installing collected packages: easy-ViTPose\n", + " Running setup.py develop for easy-ViTPose\n", + "Successfully installed easy-ViTPose-1.0\n", + "Collecting huggingface_hub\n", + " Downloading huggingface_hub-0.17.2-py3-none-any.whl (294 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m294.9/294.9 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (3.12.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (2023.6.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (2.31.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (4.66.1)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (6.0.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (4.8.0)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (23.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (2.0.5)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (2023.7.22)\n", + "Installing collected packages: huggingface_hub\n", + "Successfully installed huggingface_hub-0.17.2\n" + ] + } + ], + "source": [ + "!git clone https://github.com/JunkyByte/easy_ViTPose.git\n", + "!cd easy_ViTPose/ && pip install -r requirements.txt && pip install -e .\n", + "!pip install huggingface_hub" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Restart the runtime (runtime -> restart runtime) to update installed packages versions" + ], + "metadata": { + "id": "YzHXdqtHGTab" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Download the models" + ], + "metadata": { + "id": "JxMDvPYF57pH" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Choose model and run this cell\n", + "\n", + "MODEL_SIZE = 'b' #@param ['s', 'b', 'l', 'h']\n", + "YOLO_SIZE = 's' #@param ['s', 'n']\n", + "DATASET = 'wholebody' #@param ['coco_25', 'coco', 'wholebody', 'mpii', 'aic', 'ap10k', 'apt36k']\n", + "ext = '.pth'\n", + "ext_yolo = '.pt'" + ], + "metadata": { + "cellView": "form", + "id": "0NyCRDB46ric" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "from huggingface_hub import hf_hub_download\n", + "MODEL_TYPE = \"torch\"\n", + "YOLO_TYPE = \"torch\"\n", + "REPO_ID = 'JunkyByte/easy_ViTPose'\n", + "FILENAME = os.path.join(MODEL_TYPE, f'{DATASET}/vitpose-' + MODEL_SIZE + f'-{DATASET}') + ext\n", + "FILENAME_YOLO = 'yolov8/yolov8' + YOLO_SIZE + ext_yolo\n", + "\n", + "print(f'Downloading model {REPO_ID}/{FILENAME}')\n", + "model_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME)\n", + "yolo_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME_YOLO)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "b0761f32610c4765a82cfc8f901356d9", + "8e20ffed38024ab5bfa8361f28852e00", + "9954b2e0034a4106b9c00c89ac237a3d", + "473dfcf611e54451a7de2f0950af81d3", + "3c60a788ecc6475884b62055bc167d0c", + "56b99433062f47b19081f8185b2f5f39", + "e81b426b15744848a783320254ecce8b", + "e1b06389ec174ee088dba83724828e43", + "43ba777eb879488b8f2ee4b98484f3b1", + "818cd9a4336c481688d42ea88292b181", + "65ecee0429774fcaad1f4ace595ec518" + ] + }, + "id": "DIophLL45ls7", + "outputId": "496ed38e-724b-4698-9daa-5613e1b51914" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading model JunkyByte/easy_ViTPose/torch/wholebody/vitpose-b-wholebody.pth\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Downloading (…)pose-b-wholebody.pth: 0%| | 0.00/360M [00:00" + ], + "image/png": "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\n", + "image/jpeg": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#@title Custom image\n", + "from google.colab import files\n", + "import numpy as np\n", + "from PIL import Image\n", + "from urllib.request import urlopen\n", + "import matplotlib.pyplot as plt\n", + "from vit_utils.visualization import draw_points_and_skeleton, joints_dict\n", + "\n", + "img = np.array(Image.open(list(files.upload().keys())[0]), dtype=np.uint8)\n", + "\n", + "frame_keypoints = model.inference(img)\n", + "img = model.draw(show_yolo=True)\n", + "\n", + "from google.colab.patches import cv2_imshow\n", + "cv2_imshow(img[..., ::-1])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 872 + }, + "id": "Q_Y16sT4xFDD", + "outputId": "4b737319-fff9-4847-bea4-ae8dd51ee5cd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving img1.jpg to img1.jpg\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAMeCAIAAAC7oKS7AAEAAElEQVR4nOz9e9CuyXUXhv7W6vfbe899RhpLsi62Zcm6gAnYhACRwQeHImATKlQcDPzhJGUHyrHLxqYqFYcDsalyQookZUOA1ME+JJwKqeAAJ2UwJ4k5IECxIQYjW9YVWZZk3UYjjTSay579vb3W+WNdenX3834j+1zqVKGn9nzzvs/7PN2rV69br15rNb3nQ39bVVW1q6oqEQGwvwDZB1UFFACxSif7HJc9yUQKgMR/IiKhbMdaGB+IRst2R+NhIhIRuy8DErBIfTHfza8F7PFZVesolgESUQIG6lCOn0Y7qhRACpXLgAQg8CEwMxHJObtQAAz158kHlT3aY0wnVZV5dMsz9aowx4c6ZSBav/beVZWo5btEZP0ioALEnm+NE06Dyh4jtDr8BaoFt0RExDmPRA62TcfhfF26mE8xUoPQx967MDMzJahEnAAws900qIhIkZM7UKeqDR1ANC4AFJ0UwB2QBrp0YJuv6gSV1sozGFjqzlgOFQBVyekGwNa40MYIXFFNMRAAqoOPRLrdNGQDYObWWu89YbPumJmZz9KjnRyCqGrjgh/lS1OcY+Q2ISF/HQSsDKDFjJz1PMgDTSmGoONd4yAUtq3AG9PZzKqqiA8w0ZWzEKRDAEiNblWgIj1BZh5sTmgxBOImy1hyyKQA0EDMLGTk4sPkA0p23hkjtV7g+CdNBNrQzkEhLN1+YiISvVuHWT7nSKeuA/K2QtMTUS3BM/Ynp/PkewWIm+YkEhHDxJ0o3arAFJHSFiBZYxpMABYIq3wjHnSVH4qgadjYDeBKinFvEk1ySV+o1Leyn/P5nC0MAUjCS88AKKQiAGUmCn4xXE1iJ2lYcY+ImBvAULbfAVKVAK8D0MCTiwX1xo3+C2XaJA4yYOZUScbR9lbXGGYqOqLB6AXz9vl04jqtGlK9NI46tOZSLtqJ+Wc4BWrpCMBJXWsmKKvqetGLXEPbfDqddSihqHOs4mnthaYGFwpLusm/WuTvpUtn9XYEdnlYxhwsP8XXA8be7xSoHLFsk4GD54t4PW7zEOYdPwfDuWyyjAdIjkaBpOOCc65i4ri1Ff4qslcJHrCNzyYgdpidD0fLi5Lb7U427RyGZlgAEAA0JtHuqzC7ZQgFmqIDLFACAxIGHQMKgqpyvLgN5EBDH2BqHaPA2ISUwDoZbViwVeyMlj+JXAcVjUdT5CHMrwSpkFzOCFNQgoojLXlnEUzZjvTEsKHInwwj1VF0VjSQQombIZ9AO64CkvoTV3kabGTrDrNO2i4l7HVVJRpvujZdSXogpOIqjeyVVt12ghJJSNs67bVNVCZVrg3VZqtZwHxy0aFuUwEg4rIKmlrYdXAOdzyseROtGWxzO0VSLWhMmo9GG6EDjfi0DISZAKjk5GY7AxuDt3dUKEMVtLG/MhHnnRjvdGcSFIeNb19tHmfsGSW3SS37xRdgP+7lxscohxPc16rR//m0gyOKzftFxtafrOW2NTOBV9qRam2g0PPyWn6W0s4qX7frhDBPLs1QGYNbwflLHZsEtblytkUtgXGgHWvLl1QjETUgO8vZwlCK68i2FvhIJK1DO3xmh7PO4g3NhnB3RaKq3dQ1T1Z8dm3r2NrmBYHyIiZFfesCeKlCTFx2w5wW90ZpmSbJNfcyGwQHhoiqGuFSWMfZbzUsFpMZR1dZAYT2D30MqIiCBOTLx5uvvQsi8okBTOSRnlQlaJ0AsvZdk62cOouJIt/T0DnsuqCxmefM5bWJPGUCEUxnhsFETd2R41NjODYrZJ4XNodK9pW0oao86MRHRURk7q5JXyCE+6oJojvK5qd3uFIv2yOsrnZnimJVDYeF2RCpTqBi0kuZGClbXFU0IqoLzUX3EEG1m7moiStM/DLeFbJmDcM2EWH6VHMqLIwZHX6vGDjxjCTW6xuqxvBkYywtxaQTgHTe6JG3yVGxXNba5GsJk8Casike8JDEhA5sBCGNZW6SloJYMVRX0BiBiEhoOO2mzpVTNSSkqy2H7mZH0aaOkyGfq5KqdtIggEPBvnBHQDItgcoUDQvD2os5KpxudiYXELyXNLUPRY0ZapSsp2q+LrY1FbDJEx/Fcg+pgmksqI5lfrmkmKRrF3Pjw6Y5lM8Vq0QbxNu1AHbarQ33AVYzeTRrWyfHBgrF60i6J38U2EweHS/ak0trGl6nwwFUeXo4zoVnTKAAMNLZSTOfX7ExCGjC+ABgBRvESkphxkaXkpRNtWUtPrvd9qqSdF05lScva2udZbHMdltfnl/0QTLzhpObLMjEw6H1s9vLNqLYblixYUIudHkO1hflhuTaaZh6C5zU3GCIxuvUxC0AJOGZY/FbY5ln0io4HL20JwCn3Nrm0SRdgxLIpkCQTfkSNt6Ai/BswRpr0NDaSmAVhSpUTj6h4Q5OSdFOgZ/5/ujG2yc3lCcyG8YTnevz5bogv7gBmBeKZjEY302O1hjg0ZLDV+STYsirSD3z5QThjQ2asTqqD6TGHRQ4KVpatgYWOwaiTl1E4MnkWhdXrg0Vk+CzSaeQjGmWEbSBrHHTDeHYU150mH1lQ6TWNZXOjy0iTsKNN6HRJNumWsi0AA2OA1ETKJVmw661f5thpAAgq8/Ap57cGDUEMYwlyeyYxJWBVMdYDZoGANRdwh+Ma5InwQVxcxekYa+nwVdaoGVVRrrS/yGhjsZtb0jc2nCVWuzUoWTDcFlke+WFvZdF1B+J6MnmuPHJ8cxiri023GLoozB+sWunNk+FaEBEstgFhtZicxwiVFWd5MrbdfPmxeyv49HWcaZg2t5d7Z79Q7E2jidysT8uQZKjqAb1YnCIdmjs+ZfFRHWN1oGkCzev1BzZ146cQy2+XwsSAMQmj+5OvAV1y8QdeiZQVqUbPHXH0RVeLNBXg+/S6FSVNPfm87H0TJpEJmIGpW1eJ7RaAMtmMEVbkl9iyEKxA62z1auq5wGmSUxDC0tHUn+16nx8mgEZDWTWifNUiBwXdh4LNfp0072jExORbRjZrrCC0PhOwulGmwCqTDCTBGbABJdfklkcrvKNtI4Ni+rcri9qmFiMyYJMBvTna5ABTRwRl1sSO8yqqlARgQI0LemV3LJR8RUzxqS4xW9k2XyPIUfHlanL8Bf4xw3Mj5O7EBfnv1btNXbQvOuCOlWIbUj7vr6qgoR5dd35QHy7L5l0bm0zB1VptkjsqxCdjoWHMlSV3GAgaipEs1jYcTVrRwc3uktwyw2lxTjdlNwF/a1cXVaVaC99tkvkcLTHV7FCYM7IC88JNjZZNTHZDuC6xoNTTnfKWbeWSHVqqngBLyhi/3/YH3zwGArSaFuKVH23cHe+tXzFxCk3KfchZdLamJqYCUu1eD7qdKqyP39sOu3mwm4c7aAjLSbFvvXw+V8x2WYQsMmusi4woWxPro2v8rSYBcvQVuApOMJdl8cqNlbw6iLB3WUDz+t49Xjv4BJaVKXuHRKlqa6bvYS6BiJfW6sekVpeNf6xXtVSpIlmdjlCpXG/Ex1R/bWuosISSM9Hrk6kTs2A05BAK2M0nThcVRlNVcm3BqZ2iEBS7QypM49Y7MbzDBMYYGIK4EWVCQLisPJHF+TmCHZHepduUZ+hGp0Ima4qGgHkT5VWcxbEg0ZHRKrPL59iog9WcgeCO1kg2jFwRcpwtNpesWLBZnA49iZUp941FCUx2MNjo02iL/YfVP3FRqSAuANsNdAP+WUztgZUXZXNvDF+JRDgNwupy/DdRC9uASd5HytpInJRgLpj1W4W34cwh2JbNVMhTtF5e3DXFqb8DH4aGwFcDfob7LMxOh6mf+4+IchAb4xdUF8/HA6570bV9ICa8yTNnUE8+dglnZ3G2fbMTTaHP7n55cvXumhvTh0sBahB8EjJcwTkDfI2R3EEpZTV2oSHMu/HJpF7IgjgkNWYdhgr2c83pu5OBZY9rnG4FihWkHZ7h2k3IBLWxdTwm5sIiEZG+7ZkKD9Vaf7iS/+U+yl2D4GczTSqJKUqsffmjVdRlW0u/Q4sEaBuul4SG1UfXJJ3c+PDSVBf2bckSvu6T3/Za8+fbMdUZpzQvDA6gB9Hs1/jNi4bQyvSFiIhIsJVUEXhakDFd/HDRrTF/eCcBZ6R7VJur6JBwkEC28MI/Je9ZIa69NQOt3gsjWKxNuxNmxZThlRW5PZiS5czgSyNSHKHaJanjRvNkeaxFtn1CggM6dU9YMMgIopMEBCpb8Rko/7/0q3UHZ9DIbWMmmjM+xwveQ5S8bYq2JWPKgLr12pFAYbVnr9mzJQRLM9AqqqKTVyBVtO8Zj2QG/PXyLqjKlIpQ/KGeeqsHnv/quqGqVFv+LoIJpQ44NQiV4+9idNFMu+nSB1IqOR0zMAiUR0VKpi6WwceOHajREjYW179rzeL03qtEtANt/wuPicRdGyQ79J10Kftpt2oZS8p5hW2uR34ekaP5DZH/tGw3jCj7pCAU5FX1M0Ai5PXpXjLo+uSNsxpWrcsIJuvd2onI8BMNQTTQbQv41pHUdprRBI0vHR0ukmRuNtCaVLJumggIirKnUyuSWSpVFd8bZyO5qb+TUkRX1fps6uoFf5AxyWlSNUYGngZUTxD1ZUeVzzSRYqvdJyGwganpFauXbjLd2e5bdSLrNyA0QK+lmdS0I93UTit4qmCcSiaqwwqqKM6ifF1rK1NCBKR5XTVpoYa0zT4JPYjQERKBLRYFAa5NuQWwAIPt0yvLQMj6rm3ohaGEQ16pkAuCGzXRpl6JBOSakf4ospqn1ITKNQdG5phc6Qe8GHOZI50a8ve5NCUW5Ihs3g67axHXRAMj7r/FHhOugqcuxRVNZuG8jEAILG1VyqweXtoYG/x1A7yEEdEOFwAMwTZiI1C5a3rh0uKKkdqcFq6b4W5oNog6WHUYMIAsOtLrKxE25aWNyJhiHucwY0wD0hGK75LwmvXTmNp6C/WxiX5Zm0SYQlVVkzufWMUC4OITHVRFWKzHlaOxrA2PAqNSIGm2oETyqRusjQb8WZtJ09Ls9imezDRwSVhl0+whb2+6gs9shRnyXMAdhk+xUIi7zAU0yZqvBTPTwriRa/EszFsaNLFo3BgMy16J1EX9DMeWwQyM4tcb66gYTDtsNUe97879hbAYE5ynXZC6nXq6VLWiT/Bp9gDFguYV8vXD9Gm6rSuNoYIgnGRq1BVy5vfOmUAc4KzaG7KOPRDExMpJwoydSIcfUPBcEaYc7QJIgW5V7MuCHatab4NHfHh1vNVdx967j5GKCUIJOqCTpeWB4lnP3S8eWhhDQHDEKbnSHeEC4Vcfl4DDSBEaCS8n+w3YQARqQwZHYGBzrSLHWDzzq6HnCKZPA5P0gqhxJhKBHvuErxx2RSobG170kS2puGwbprvVY9aGrESPqHwD5AlK4hImaHaTWa5yqFlM4IjDqkFqsY0qaKlyWJhAelYkcC4DmwQQHwlclZ04AxuoT81BEH6il1wR2ThulBTCIEYhFjJqSpRuNNVwU3D46yqXhahsL0PQZovkHWad9CVAkkhRIYoJSkeO4PM12o2D2mueZbmGWcLzw1LV22WiiE4LgLA1z69iEWyI8798xEb6MgQaWOnzFFt04gsuZFTZhVlCiZHaDYZgNYMGRu7Y0nEls0+XRj06NUAMKyxFOIDG/awJcUat4557Eru/bIN+Nw66arGpBGNob5jorgmNFWGm4k2FlFheKZKrqkGBnezowlHhQ/VKLGjqt09Ur73IxYjpL1RU/XEGW5UTQrEwiPoGMQE7ewrSbX5VJyBM3BnmfBkpRnI2JnL9UzIKetuGI7q0dYxKWkcULWhe5eUANkpEUmn6G0iFaciN5fHsuooI8/1ESspJIWwSNcuaforiTszPN/w2sATADEEIgJ3X4EgBY49L/lF0zqeNow48WPCRIxd0FMZAmCQiBCZb0wTD4pzjYYxMlaoB7cmwwwjrN7GSFkCi5cqkZhDm5m6YKs2cXbpjfYBACihjCk5VeGF8huLJSlJ3rUoNJ2iHHpa0zny9O3XbvIZIjKQxPU4WH0TS2L32r7lS5NynaW2w2D3MwA4DclcZ/q9bv7MWWZNV0r4cHVKUooN3QxeD0IdIB1k6Hn7SRDzVno+XFloQlemESqj2NFegAttKXNiW/Mo3gsAsfg2YVqrKumUQKclSZ8HMQJQsKmHrA1QhjPg3w2OgdKiI12bxgjhcsqmzx4Y8iuxW8ZYXVZUkbaQ2Q7J4XRnvz5cM0kNjUhqDHmxpYkeN7gtCPTC1ttyxcOBhKKvc3gLt+Ly6i0q+SlCRLoqJcXkBPKmxJfjySMwplN0F0SuoUMZ0L7ys44v4SWzeIa8i7Hk+GSkNxd0LfNbMZAqU1VBqlKrtnRVIooFNEla7Vr2Mnw4fj8tEiPUqdMd+aV3UbUItrRjkk4kek9xrzmxALLSTEzHxEqqx/QmEBUFWImgHVZLDbAsYtUscdZjb8KyunrgVgLzPRhoWAiqPTKlbR5s448AzoVNDCRR1yvkA11bbYIYd0zELNiLvTVx8SI2S0sWIyyavk9VBB5QIniCFyZAMu/M5i+cUr7wgDtgoBph5O7qcpPah0yDbof6Q3cDL2ds7jjHe4AfQrgAyTSB7bgREXSSe1Zxh5lpsisOZKCm+86/28Jv27wjwTC4a2sSNpyNfA31UC1eXCILzi3i2u+fEnqU6VRVpWsKj9hEjsP1Z1dPke14lTVqb2nc74sbjLHKgAq81FKUIQoFbYhed55i5Cb4lsRdABnIXXc3hYkV63gBNL4KJNqvGU+ez5hbIIaAUXdoQeB0SZTS8/AynhLB1fgxr7H0I23F3B/C0VykoeYxPGPK5ojKyXDcJSZBo5gBdHbauwEBQCl8SMPEM+aYuCfJeBbc89ToUHkDnmHBKpFtK1AI1qIvh6sQqr4flfEBA+0i9mLsWK0O2NCUFwuLzQ/PP5V4SVVVPTt1kYQfeJr0+mGXmwuFhDieEsmGgZLPlw+H9lOy8PwriG1db2RmTGQRf6iLT7doK2Zidz9UYjdJTMDw0q0pD3WAM251+qSqsShI+Ce+1lzDhM84eDC7izTIsFFCUFZNbz/x2E7xHY0R5Mu8I3PyscZP/tjpdBCsPRFLmFPBPaO4gsK2kMyaZFCHKtBG7ivcuhM3Dsf+t1goBlaKjZH0QRl6THi+wAtJDpK0/ILrh2oRDzUatlQMj5wYYwWbGMvuDjjIgTrUghn2O8nMRYKmPT1nUen0hqpqV6tnk9zkemFqULVWIZhkRZcO0BwyqcSqksyS0Z1aMJA2h/tFbKWQAp1d9LUlGDNDK6qonAauOfYDwUVEGlG3Cu0yFwopE1Fj+6YeqCrH0ngBfrILKcMM8t5kMC2SjdwjOCt90Kn38/KCfWCwRbKbXhx4D92RnYVKmRhy0gpF8wDueAi1Oo8CEPRKgmZtEBHT5F8dXVB4WdHJI9Prlb4HCYEyAZbPFQRX/TRWOUNDYCjy+CkZb9qZdi3olUlYywoRsVcsKhqrWWI2e1ZVY1N/kLUTUN7XsdVDtJbunt9dV3JE8DQBh7NWiDPGS+TIETuMoYd/asaSV1uCT7KLVLPrfR1vVoIxbO5MOQiTLPC9MJ0SXjiEtYQpTK49V0B1lWEJ+gX/RxhGi7VhHzooww8Xwbca1tXgW36d4XMrltxvxFSSHdzmjdeqeMr53ZADl3TuVMjgQafJ6NjSbciJNrcz5iwVVRIDoZxaoITYO9iGk4rN4Q94IjpFy2MwDhjywZxwfTFAdZSjNsrs86SE6jXjwzY6o4/uW5NDCplIEaFh4GomitdKU3kxAJFzDr9OaM5I6m/beo4JFWgKE9sUOMUvGsZWD0KAKS7SseiKWte7GVGR7h5gVWXSJQZWFUQatS46CrFlNqY9H0ZMyo3B9oxY4VSDo/aCXrqj/DCOR6jwasGbDDRaOzsz5ueFH8cr6KIymWVb7EWMERWf2bhY+UBHu3rItgwTZM5yECnL7CrzsyNVDaFEqudiAGkiFxj7hsuoOfdn9SCieWF2AOfzud7MZ85HMZRIQ7BGLNnxC9XgKFtmc52egxLVFZgdQnJvDZ3qmQsV1iiaYHbKOF8gUpsoVWC8OMnZY4PDVqg2VbY3UXWkKAChYfWb0mLyqsbrrBgAkQWnIwov1bNm9Nh4aZ65vEQkNtpzeQFA2SgmRk1EFDWJJnQhdGqVQcEBRDTyAOM929IQnEN1TXgDChHrIAjCValImM1R5Acm2t2Y8BWwuEBJeh0pajNB23thp/eUHYvIK4w6fS0mFxC7sO6lUHu4qkYXuDZPLlC2YyA0UuAKNYeWGsvZePjFDI7Q63t0LVDnbruKHJH0SJdf+0Kf8K1At72wCkpK/BhnmxRWEzQ1ffcghD51J9mKP6VbPiDSYtZOgKqQOnuWkBTvi1BqP2gkajkqyDIxGo1ld6H1C1ia0R+22oze+FtdfPcGfR5FiGPi0zp9otI1bNCC4UwDtgD2c7lfH8vts17BL2PhhezrVQfVRQCLXUOddNXYW3CHfCPSGpzOxqcpynsM2YNtV6iUGKRZLSZ3lqUbf3HWOTS/TtTBtKmzRU7qlWJZFJUW9wRg0U408BPPDFY13BZx4WCLHjNUREJE9kCIO9NHi94yw+VQpzAbtXed3Z/7TC0w0OwQ7eas1RBHNjRB6jUlzNsiU7731h2HAopui16L1mzgTVPcFq1HWM6Qis1fK6yPEY4bszhJAJsFAuniv4y/voXq9FPk/CidN2JEFuGDsC9VpwU2xtu7GeD667QUdBrMqT1H5SFR0WT2Wt3pVSjUztJYUVVHFo0JIAXmU17q5fMhRESz9e39qJrLyFZpcJCieLD1UiDn8neoUIfTfbkSIZPBCUyAHUVDkYo4WCg3Jo4EUdZzFiIinnavEj/sKtFpJoNXAozEtlGwr31p4Cs6ZtLyTVOFu+sgZscHTmRbVABG4QoLZW8ECry554aOSpKnIEChvPx1DxbeKSQfHr8S0ZphnyLS4B/JO4oe0oFCPvK25z0ZHIfWRoWqDCTz34qc8s0UwBaV5d3B+NFUvps9Hj5AEa7pzgALSxzL3wHnzMDWsnsaglNj+gmQCFdNpWSCoGW93XF0y44TIlL3NJhEkep3TGgPrhLbEbLJjF2zQKmQtClaq6FqnnyLG4sYlqplU+7HGj26cEXb5Trk49hdBRAeO3/auybSsbbj0clkr1gvocAi5G9hdVVhZlsZAhZ5LKJnUCFU61dARF1fIIqgzTHFQpaG7QI7Iy0yvXa9lBuBzqocOjJ+6ESN6WSOHFULhJco/BCPhf3hMeG1E23B17m1bfArUPGGqWTLhXo8S22nvCgMkflQMcjs4YCv8rGcBpLc1JRtjGXLY2rw4qWom4lucMRKxs1r8Rj33bpetkhSu0UaueurPJSR224lA5gKP+ZPRNT1nLUifSCs6oXxF4vZSdr+VTljcrGAae9OimMOIQpVVExYayp7U0yW0wRhmRe7mWfO5a+namVrMUwU3QOA/Tq08cuKuciRGadmF+vwVvnhCFcAKANiohf2UrWGgoFxez7RNv2dbE+2uCCzfId5ShTxQuR4G3Da3QaAuKqZ2ZeljAimi3EBxSyYLCYvfWFP27FVGc7pqsLVq9fS8YVRZI1ql6EMAADiR3ap5bnVIbi3c5n1Oh2pkvN+a6Tqwc95imlWCUs+qQ0m6eyzXKkqp6bSff2KKdAnTgYOf5pqhPpzA8ATY7PCYtOyhnXl0iYyBZpoWOyYL53No10axgOUxKCqWcs8txnnd6d2KuZxdJ1VCMRLzwrycHGmrTXVA94mqhiuTJEuXKnPy9iPsLbChvYdFotN6a5hNNMcQMX8Kop4vWopJ1VNF/agk2ITqyrhFoASiuGSWiahSUkkE0Im2RcVLzKczeT1VJwNw1WWJ1+UYqMARO+VwUxGcxU79ZqgIjH1fz7bVs7wyybBE52JGlGrbn9LwKlRJIYDKiXgqkAQFVazYFTRMcxBCb9VGlnXqh3lrDuiEZxnO5/wuoMAoHaAi4QGNbpSBgTKHlPigqtEAFwwQBXXmAYV9319OIS/+tk364q8SpgURAVv5ikXHdCagjzX+Sqv1DkdaQpdz6V2nJLFgaoikhsw1iEO7xgUxb5y2rvxVvZaoxmwxXAsKFK1mD+34eIZVh2eoVpxcZE2Vc7X4QfPm+mf6+oIjIWRE41R5NAwguurf3FRB4sKqAybMJzq0zmdRCTmD9NB6yZjr6ge0ig1jxFHhGWCmyiCAykNiDx1sIEsF8Im/l5YGyg1G5iHL2Hx4QzV5dJEsl9nOVf8w8d4ZHSXpabj1Wfd+TPiDFjVjeGYsPT2JxhpDFDC3Oe9tKSJ8ASwqqQ3G6A8fdt+zeFY9HLioYYe57jmoXVbgUULOc9+nDGBSGic+t07EYmIAeC6H13LpsauTQ8pXucD4uvAiQiYEWJRujLmN0zvWl3UcNJqF9hobydCBLMd0WcrsiPhHHdc9w0X4sEk1uDPZPJFMi5XCRKa3mLOIZfhkGZ0OjPPyJzqu5ROr2OypAprK5WtqskmcfK7w2VzoaqGbYElcHq0jrfpJjKWrq3F6WsQzDAxF+szNeXQXqKqSoNUjEdEpPe+JcGNAPOM4ch2oH4WcAHVZZr69kosMIR8SUfTwi4VTKU0FAubmTMMQt3+k6IMRh6vRWWBuqX5k+//Os7NmN0KbwtFWviK7XN345rEKRSpcQW4DgvSHBXDLRTCI+elmwNb1eEx9J18XFHlRbtJpz5OJ5AazL4f0und4RrbZXYSFoPDSat6zccrDDYCSJKwZ8S2YNBRSvKoqup1Im22PDz9vkBr2QpnKWFbgII6gUfIQZyB5/BkVsiorSUYngDbJm48+Gvy3OwGx4I3TRkCW1KzGbLSxWS10VhrLVX7whpwKp0wmSvVusU2e4U5ed/ddq7RMg1+1Z61x0T4sjZInXVq7VZoBfcr2FtN2MwOkbOIKCQQl+UxbP5ijxkgIitXVfs2cLlBlQnNuQ6cNXhyEOJ7+bfNjeilqIlMozc6uXjxpv24aKWTigUfxmENEeSqvp8TlbVMpSEDhgv3Qiy8y5YGTs0EEPzIBucNC5cjImKlkHZmdYXBSNarKQ8GWfnKTGeyvdkMp09FKCJ9NlqnZU3Oa9u2ZkJNTqI/f5XOyrZMGlGci/yykCs3a7xsgbhvM/b4Tyd3yRZKIlMAVRZnSId0OyvE/Ddj42MBT9mFXcNJuqV4Ua67mRnkNcGYvayynVst+kLBlRHFdaX7SuVEpH2yrYmo8RWRL99jz0nDLCa0YvCpqoyVk0jVKPa7ZLqgRVeJ+OaLRdcXfnEjrLGKyFkk+J9Cb10RSaOhgHkR6LHJ7RlxJm6s6xazoGqVUuuQTY40uqVleUREPaIKyvMCsr1/ZZwydwvl4qO8OADanOsKSYiI5OFyKNoaQEd4FGLNPYPdKeLj7f65H1iTAESuHVtDKTiyfJoiWNL5t5sozVySkIy5tPMez+4y8e2P1fKYamlUjeJngZIPlgDqIIJ0EzPwQAHDvjTPNoJAa1VK1RcAr6aok7dDFVAlrUtnjwLsCVhOzUnMpHLfu5CEotJaQj5fO+u5KRE1MukuxnwaYWq1eIzZo+cFM4bAPu88jl/VU6cUsFpQtoQ++Y7qJPQAdJ8FB7JHu+1kqyOx7IKBCvFHxUUKKVhEqNk6Spb2yY4rGhx9HrwAi+VvkSkjqnrufR5XyDdJdobqtYTriOgKwcJSdyvylKU4LcHyU0SvVYmUycdhmU29xDxZdYkYcpgdZQikYS7sfCcmbWB+MuReEnCGLf9Rl4R8lrvZjpaVbbaZsx9Xq0Ky927y/ERolilKto1SCj7GhxPFjn7d4whQYjNlPs28SjoAHnjgXD0qQCS9DmLNKLOYOZsQL1BGiQyPXyI71jN0eJRN8LYrPJmfOogs9d9ch7VOm/QkKcDGaGsTvtIIXA5Djc0zMZyTZXQxK+66GLEabiuMaAkX012CROy5dbIXAkpZlyOE2TcgBas5ZoaAoN5beUwJzaxyLopqUgzBYMXiVCKIZf1F2Jfr3bCkQ1h7G1CwO059aCQeoSqx6A9TneARlxKWWQJ81liYLvRmSWJDCsBNF0TpHH8YCmULJ6xznSQBBZ9nxRbGGthKyWkOFoDoqBdkC8FUuqIju4FsT91mQWoq0BBYnlVBB2dhLFJbSUWlhfghoh5Fz1R1ZNnQ5OHQfq/Ob9KbVgE6kkg787yLEdfVdOxwxRXV9vOV2MDYDJfZF5+9zCWZ62rs2OCI9b0Lo9HgsOmD1M3gUK0ParYvK+QhtWaBFleugKOZkCE6LcxG19mUaqkyqWfbGhhCK2O5CphlMRxW1VjU2gceD00eCI+lY+OpyYFURtTjK9sijiLRnrN4rocG5WaW3+/IjPzJxo1+hjzxvzbLOvhIB/tMgIXCRp2XIZ9LQgMqs9DAXX62FMCKsXod3nRiBMLfkyxfg1uHDOE6SWOyiMYWpyoVKhofzObIIwBH9+NFhNsR06/SQW1I5hjIcNikwZEv9pjBKDlQ49WC9hTphFswU0muAlmgmpCpoVhPWYALlgsU8UexGS5QNVoSt0qt1G2qarcSaES8D+GcH2KoRMSW72Ysn5LQBxhMqJCxImEmovPZsZmHTagqKahFEIDRa6IYFFtCGTKGMAjWsvaaGyqLnQQop/NtxIQT0N0kpBy4i8h5eVeYrQWY1mB0LREoJs4ZgbrJsMiZkyKIArc2d8aRK92YN3omC+tlOmIG5PUPRM4bMZkpHZrANTSXSmLWPmWDAI3wK5e5MdG5VWRykAKllGZf+oTMjVmzk8KbMu28aFVImb5Yp9gAHspVF2Vf9K7EfUnIx6WqKmed9yYruvwVGgYHjeWj/xR4qMdeAID5J/pZmblT44JPZj7LdRKDM4KIqp6aawgouJ8y+j0JjMJUdXdfce3aDCahFlsh5p1E5XoZqb1+rSOmaroyvWJmAcapvp6/Ci3Emdey+zvplQpS/UoUUVBxW+ZDXYM+UfcuaMSkT1aRqma07BKMXAVFoTGqeNohDMCEiDEkg6XahSL0J9eYZQWg5y05QqrNoWXLDKGk7eroiJR+OCOft0rQLcA4p+0mBFJ0xHq5bOmq6qj8vR5zav5iJZEFV+oGit9Jy9JMGVmneJT6mJBZmK5+mMXCeLYQAJW3K8A1PTsmiygq/pliOVeVUaHMt1KgTe0g9yw5CpqkY3gj/lgheBIDNY24YFUFJCtlAh57KwpWGakARf6nRoarY+8ojnQQJWLRjCarDmwAnEvxo52U+mGTTkNeZbNEdFKxUZEfqaowLxs3A8hIkDs6hTokojNsy8wsVh9CFV4F474hTW5XOwG0KG55lE8IilMtVCAQgM/lZPNkESKyIjoSaBWfUstfp7BDhm+g9754mRJrC+J8AsJyHxUF3EfkYsjxm+akWcMxT2UBrWobPb75zTm/5JsdJKZpnZOreyaW6s4A02Xtx0oxicBcC+a6WI13YzDERiE8e6oj9kQP2Q8wF4KIqCg1tBQ8ZpW6gWn8lZHz4RNU09NyrXyAeWrTyrhAOzJH/O8cr45UDJuQPULU6DR3ahZgfKsCow5KpR8tCrJSu/0/XymewiJ3WIsDz33pltigqhZJIyIKJjp3WEEfJiJWvu73KpxjUMzGRITWcY+odbOfI8aCSxx0nVPjx6VBY/b086us+yZ59YMzJuyHIYkqVs+4tzzoLrEj9gfQJoFuNrGJp8oXq/gzwq7pmjkpNFbMJrmi6XLAVX3AYSvBmIfDzaLndbABM5blrkJBtq4r6tlcCHaSH0U2jKrbJ1E+IK5MEc8i61KdYe5ScGvhTNSgnvgz2IpHJPUc1ucSG4O8Vd1r4paBZS/av0RXaEeHIZ3jqpCyODYwAhd9HhdISAg0HS02AifXM7mGHRYSuISLLYSxqEYcUU7lkYIQXwOPKa5x2X5NFhWa1TtRTYHgK7zuw/E0ScQAV+K3vaAwTDicgx5JptTi0IUBNmI7drQ/5mIi+yECoq4GESlp+DEza8YNTgmfjVyk/1VNVGm5PElEJ6IWJzlTqAYQ5al9Zo1qBK/Ez+N44AiJdvbygeswR2ycVjlEDYk0HXg2BdSoKjG4YM22w+sZ6x2p60hFOzzgkojIijZYdL15OLzuhzvSjQBWyiuHGB2JYH/fWtbxDSPMakqmGMejwI90oZIdnJxvU5iFtrJo5uFsIZwf666Wkwi9kL2bdAag0nPJm6Mz5uRU8Es6skfOVv3UUWi3924767YvfyoLcX8RAJEeGRwq0klFJiRrKOAUGZjpNTk8iqENj0s0MDiqtePp2w4R9BVGLvBqIwAanXZrA8B8all+1t7dExChW/5uHzEHGig0tHSTX+ET7gCFE8K1l6ht6DaAVSjjE7OeMTP3LuOodko6ZIqgOc/+CacLM8ceAQVFzfiJYMPg3GNvUI53uWgKKh8Tfe59k9T2xCro7YFebZ0aFq2TOtl6ty50TkaId4tdIsnsuixWEfD05ZXaTvnaiwDMO5oRfKs8EY1EpB5EYucAewNp0WLigkG95gxvRd8TSdYJnMoQAHGg7tiCJCL0aZetYi+NDC1WfqogskUj17fSkZlpwGlK+pJsn6bsNslJVcXrMNXntTw/T1IoflGptbMKt07vaiwJUgXkk4YwmrcOC/z2pOcczTS87jaiLHhWmFVDZ3Ygy/yPui+qYQR4vSVKRamqkd4M0OLEdWdBkW+TzZFbuhVIVdUt3ToMZ1VVksFBGnSFoytduckX1cpZLs0TWVRhxZRkeMC8FSkHxBsj5bxKYeuopb/TcdNpp9BDU1OqGp2M5D0ItOysK9zKKyVaq5etm7oPswZuc6gb4IV7AYCktbZodJvOcBnaICxfF0CpvR+klyLaER6sHhjX9F6oMR9RVGVRG35ZAWjF7YS3Lc8sfjEJUhbrGIyds54r6a73sn0USyUrygFYpHMAshyU5agVMdcIiXvz1i0kzNI5egyh4PtS0dF40Ve6fipAHA6sqhGQy6pnZg9GyXNTl/3F3lf3SWCpJ5vZdPksykQMiSJBz9ILtSk9UzGAitlkRycUOg+s1jtuOOZ81U6jl45aNZ88cBlouT9o4WBmt0nX6EskIh2Bfion39q+QCW2nGUaC6A0oLMikANcyTIn9JIAYkbtZaCI/NQcjXaizXVD2t7iyqQ0AD4o1zMj0C6JIBjy8jST1UigUQciX7Stk5Op0x5eO+evtui7AWoGck4MuATDFcIY0mvQpvI4zhuUqTc6KrT6EdapJqq4MHpmDyfPCjp1IoaF4ehlsjj2eQuDgSKKi9p24eVrAxetFA5XDT/3EYHtcuyIPGasLog6vOxhsTxumHuY45CpkR0tZeWsqmKHJuYJVlCBWEiXj3SNgqweUEFkU5rWr3zhzhih2l0q4BDXJv80DimLyh9iawMLpAVUqehMJ0jzCZm8ouJRE172ZSiqzaqqnL0g22wqQaHLzJwjfQG2ETkquU3RfsssnDVij9yRhvB+eY9LlsmpujTVDY5O5Gl+cdZ0DJ0kwkv96rG3ssjfQ+KoD9j2YQGlqcd1jz17r6ijlBtvvLVZrx0AowONiheHsC36e2mn5RFwBBSG9yxBInIXhfNziywYLxrYB7pThFlfuZzNNKc6ojy/OweSk0qRR5M6XlWJbeKt9XpC+lS6Ptsk2Y1QorLumX/1rlXVky+8XJOe+1kjziBf9/Ga4Bu1khixptbqUorVBjYtXpkkeS9RRxlRG0MCMNPI4HzmZsI8evEFWV0urDwZGKsILJUrNz8NqU5lW+310VTKfcD2xqtOcj+5EAO2wnA4pcx/BSzxAMDrlxt9OlAFEqEc+FKorQyt7nMPVbFHketBZZMDhI/5tY62qvP+a3Xp1x+rY0nHQmYEUC66KmoqEFH3kKYMVJ0AC3gGmvIJhMKuoPqDF4ZMcfQMggbseTnXFioJaahv1PiA0cgRPg3Suvp3H67WGTyXvpbqeei+oBrFJiJvrqIxBzJkvA67nwJh6is0MgUsibcFclXNWS0mlyl+dwQ2kJ3yY7cjuJsXNlwRUhwwVewgtRhGeIqWhzHQddz4KhWViTVc8qLjNMfp70DXuacIc/wSiDLYFkLgkWzZSWx/y3INWmxl4Jwue1XVngaHRZkRqSWEeummIvADz2JLqZRXq3AjqXgfh7BG5WJVZc+gmWKuEz+bAFmkyvRKpu+eKh0AMrYDqoAgCbk55m/0ZCVLT/X42qLYxvoVQAvjbkQs5jNmS3JjKbtxHAYHhWdgCBpLRfS0h6HII3OZ7WS/wioCWI7lADJ4idVjKdZQwVhW+siSUho8XHgJ1dEgXPFj00GkWUgg+1WlyK6UTG2qtJ6GYf6ULnEiUl3C/QC8EHTjPsMA4/mVhfzKvYRhwlvL1luSb1whFt24NpDOZ4iZDM23Juvxcblc9rUmefEy5KA0pYuELBjYAPywyaELFx0/6CdL+xX5WJmhm7U31ivBDJOi9XAsYFRKJbi7xf7W9M56Ld2V9dkoDjGsQSO52LxIaN1CU1WxQARKe6XxMC/asO3ijN3w5LlvjeSsngaceTpuABVRO1sY55rrGLOvL5xfICLbvqnPZ9zuIR5qIz66Pq0IK/WupoMZdsS1mGN4aKQh6wEsJHEcbmLt12Vu/rLSUuk9P4xnLhgcPimjmsTxY9mObAsJS7zrseVkh4Om52CSCcPg8MiR2tTmcxoOaGOhIqDMVBlUHU1lPupWsinyN5s3SBEERu5dO49I/NAgpBH5US/n+1TA8OUwAGYWgcYJ0uUdnsPhA3VEpsmyILpdvXeckGtjNRZxVga2WV7Aq6OwLGbL2HKOc4lVFbCvaVMIHLBGLkVocioRxA0wc2KpK2aFmBlhek68or9qt2T7sUSJJJopiFvVahtIPQOl6vpuOXpFm3r0TJTcM0TGUpxq8P6OtP0qMm2S3ic5D38GCGzxqop7w+IekVNELnKr4PCixJaGB0lsB8l2gImabyZQY27MLP3EDGY2L73I2WoKSNcMiBURtRgrsMrJZgu+qoBSR9ka0Ml/FbX9wzcypP+MryEIYs9bFWW8ROKWoI2aod0U/4lFRM9dCoECuI4kumitSxcROZ3yuOcBZztR79rlXI8sEhEVIpxNyhv/mP+cmQ2LAqpAMvP5no3umjy5PUX/MFm0mFN9ZHp0q7nQiEGkxMREyhYnY+/23lsbBx6qdq9LRsriheTNHI5oGALOJXL2rKrcWuNGdJXRmkbTBGpEZ82g44hx89ExdKxCJWItaXYaE5EBLONg7pwXJqJrubY5DHZw5mFFrpZcILigqWWUwp7IIOQiXGIWTuw78dZvmiDGvkGZTq7mih+e87GBdZ7IyYOSwe6qRNeoEAeALMg0aoiRm22qYiVgCACJWrwIEQFC3GqsTOICOIU+EsSCWxXN6uTavRBOufayr3UpaVdGEhTJa6ae00/in6iJ6FwomolIru8l+UWnduZ4Ovxz3omZz/6YEPygR3usq2+NDeKEQtHs3EAKjwS8FlNs1XGaetZRSwt19uf5UibcUEkbxJMFUBYbXNYSZOW0iZnMQPSjXN1nYC2nHGBlcwMz5579Kvos7li8FJAE5onQaZAuVCF+4FmtQOq60EunMLOdXSsKRaMrOzlStQNiJcUyaWWxR6XE+AMMPcWhV0KszH0U//CjqTgWhexTMeonMSii+maDQ8S2yBUhT7IymJ2mSgDGyTHX5Iei6ch3c8KgULGbKiUJbgUNv2yuWjWcJg5PZsOtBfpc/qQEGPQJjNBXyFnVVzai2mDyS4ktSxTMJCK9i8g1M5/ytDX27EIaW+0CqxyFCCr1WSYiOuFkXF7sShNMhpVxrG68N2BO6QRAJYPJpkDM5O5Rok2ELGjUBKIXvfeyFnZyqQMOaI2RzF7niVlcamL6jijCZAigBuqqEJEu1wq2TSvzgMGLMPUUvmSHK6JbOUgfn6ZbsGPJg4/+UxoeENAc6VMHogXF+ast3CdeMuI9TyEvQ0OUvDUXBugAzmdUkJIbvSNS1R6tMeC5QsUBDt9skh7F06IpNERactys1neNHi/7uNXfuHik4lh2LfGty1aFP09onpbpoaDRhdDsQs+uVUXm6jS2azYR8WyMx8V1+pZLVS38dtOjsRIyxTmdzFcdxWO8FV3YSCgl+wZCulg8C8m/RgJarCzh6YKYSLTy6jwX6X44WDwt23DjrdIOhWswKrdWa29lgbL/mMAM40OnXaTRS52v/bCofYwT1qJCWqSBmVE11fPeB763754zJagfAzmQoAkvmHhpZCG2qK2ZffnezhIFgllKJKoX+rlh4IkAq1gYM2LOKrOrLFpuDDbndDEZMdPP1t3k6rj82NRLlnB03Ym2nIuxDUNRFrXWhyHfQJ63eNKVYvKn5VZZxu5YLWeTMo4ZLBSogPaStu1Pz2SycNnquZkfK6n+LqqyPnW+QoWbME+uWRqIRVqaHcx8Pt8LV8H0ihlMeaBK/qjKltPmnfhrxZ4wCIcn7JjLdiFD7kyKdgYOKLuqr6dIr8PcpRbma+HWbOfUQAqcNUvIUVY4GoimSIlSsB5wF4CuNWp9QOOHNpHtKdwjNLPlRER0mu/A9FlVNZJsVSxZgBSnoWxGrrBcX58XKgmoJtFQZFMtJzdsBY8VN5hrLY0ShGhkH+N64VBkK05EIykgOdYUjxHGmFaNd91lbJaW1uEUVPuW0AgQM4c687wRC/VoME3Hfoo/ijh2bqyae4nWgREcF2ddOEtK2eCxzDU3JeWK6mwFuxKYCnwSaJTwIzvGltC8wtBGoCh+hVU0HMmU/FY+aEgoOxZcc0Va1ZjGlU3YDLrN5H4IwsjTSp+v1l69zbkmWEK4CGvvkVb7aWEui0WtCEGlxhhR4Ce13Ti9k1gxGTfDEJE1UO7YmNswDJo09Cprkt0OJeAS5BuHNCTC7MeOUsTssPH1JvabBBBJuvqN0dy2jSBNV2OXhjDUfLDqAk/IN8ops/EwdMdShbyMTtwHnBRr4LqfaYpFTb1Stz8wRMrIUsGEkMmNn3O9YzKv1lrs+aI1O1libPQso6i0tBC5/Z/GwzRxjcVZT8yyy4GekTaqlQBW8jgkjMM76b4qz3C06ZubYWGjYi+7WCa3sm29nwpl6w7xfDPHz7hvijj71J42rxN6UI6I1MIq+2BxNB0hi7Jk+wCnvkjzWzKiyuYVGt+EcyLNdZ3dPzH1DlE9y/BpE+wEH49S6UCHitGoZBjgHDTnaXJ1V6iy2bruYeLuqcWxnnZPe3pKSJhONiUAtATBUeRlqRmS5SgQ3YIw5n4RoanDErdsQ6ZTIsoDspyVvaQxjO7imWpZU4miNdFkVbqDEKvkArCSRdxULkXGwqXFY96IACULxrbEP8MkUbiRjFus1Sn3GBu5Vy3rytKeF9RSQKqjJszxRWrFOVKruWFGGdMzJkR1jZIxYgDGaVITVhUhVlJOEaDY3C1uGaQIW7maiLQUjzfpCVXsK55obaCoiPs9xCd/yvTmhHOxdKu0gmqU3pnVfHm++8ApCQnVfxAEdhAKXWc5smZT5OW+LDCU/OHCaASX1PvVDqjSp+DBx2gwxt9LDip78UDl7CBl19XwsitmNu8f0/9ixOhmvnCs1IeZ65SwghRNTUio5Q0ORwEIEYiWeexEV/FiGw0QdCvYf8Nl7Ka+ZJyGlvNoM1sMhZwvjiwMj5Ec8kHVy+z4146o/7tgo6BlNTqzRhmUdaRuVhWo0YAVN6iKqs/4Tx7UjKVASOmFW+tcY6aZQL5ieBqmnLtawyafn2l1GnvwFyymH4Ct6aScxFnlCUoFZ8WYl9Gytal+GF+uKykdXYkOmRed8WCNoTk0yLKFjd2mt3IzOqWHW0HqQFrs6zBThiEiNYD9dJZnu8hZzjIqd9XwkB7HVvVA/crq3mpZLeWUmEhcnvcdgahomUEG9pfDhcvMgmsTR1AuJRRlKQsNUO/FZGG2jcwZX7njQIcWSZ4uGGhdJ2WLfhpbFfUukfbebaMn9z72HMLKn6qqKiDfpvc9G48PRZ0tKhd8Uz+01hy8tvMVCtsws4gLJgbgPhJS9ePRiWhYPyOqcZhW0dSUXLMz1QKJz/cwQDiBr4LjEq5qO7NxICm5MKyUfB8gKxg5gsMBivQ2qYitQ6tjOWLIMUZ19Tw9HzM7YnLzPhHtabG1tR2BzFcxv6p6THv2zgJVxBhNqlcnS6iyUl4H03o4F3U6DqcvG1zfihp5CxICbxfb3K0NFASSm7DTwzNOVuDrk4cXzavwSi3jMDwbTw/7evNdzZfU89ZN3xTYhgcud8eDeA50w65WD38KVKx1lpfHYji1HEgXWLAFe/1ZXzuJx0tcmCOk/UQ23vCCWA2tYYsMY4h5qDTbyXX6JK8yYI3GkKZOFym3Y2PHzKHIygdMzC4MtfS68NGhclmuOnAfjcXXmsK1Ep9RzybZwTpbu9YBQ4XzEgw711TDlLajHlAYfxFuVWAu5Lf1PjbUTi9cPysiZ50MjoLBLETtLTpA8zyqWminPwpQOpbFV5yVygU4iBv3zguVWxigFgu3jqpidiGXZP+AB2kU12DDBWVHk+FPyiQOrIt8d4LEltERFyaZEF/br7QeLlAB5Z1B/cx2BvSksweY5AfOWZiXuiOqzjcXOpmGbOYGHSzFZNtBZ2AK0NHosiTtU0HXSKA/0goUDoZMr+zFgVExfLwiGbbF/OQiSXPIJUZV4Hs0JuvzANijxdB2vHvpCJhJbhde5eFMZw80EZXnp3DLCbdjLMYppZ7YhKcJPJlA8hPP98gMeyCLU8la4npSlrvU3qdGPy+bo1yhwX0hEQ4ua8zdWDNLVtRlj9lpEfQTSvnI5Xsojv1+uP8NnPIkOWwwCrcdjVxhS4+9S1OHywJxR0sJObXv58EC44AubbO7ERF+XNuvI6o0acQTqt1jEaoC2/GwaY7hQjPJE2mTPaDVoMxJiZZhRsvoUSM4M4EXjEjg1to1ds7yaBoWNWZiPhj4cme/STRApfA0GMZqer8NuYxoiOJdg9j9cex2WckU1/WKbSJJfo5gagJATXy3Ila6Esqxgo0iNOrMHvLjIdkf0sAlBgmcUBZozk4rbwJY3OLqhVZxutfvqdmPJpVAdkZ4LUlrCSbWZS9cMsCK49ovj2f4pqpcoHKUKEiZWaV5Zg6I4EG2ABOLbmuGImVW8YdBiPaTW81JS3lTNdXkKh0oNxpKy5YI0IhQFsH2OEI/hWxci3Bjm+BBImKRuwdbgESwzQiLgo77Rp1nL7bv81XNmhbkm7IyKZayKLs9n6hlVvj52mVTM5Ky7AaNwql5VAUBLGKrk0kfGBVmZD5TIzBFdaNA+BTviQsL1uAliqWVwWMDnyIDqiBQV+Hngn4BkeX5pSyQqRKdZ/9mO7sU26W2lmuZ9CoFZgHUy7t1pVjNZTdMc1pBEhuRpLgebF+EeJ59o2Pqtca+zUa/FraeNuOXsegspiu/XJJTu+DLoiCAFdgSgHw31p03xHMXlZZ2qMp00w0wzNdQk+UBIlqNrYUA6k+DgHkVgAsZHEKFshGZ9WCIRikizQr44/VsVgvL1L6iRPpBXxN4fkxYGeYs6BDtDGeMrWqCkHJaq3m9csQsDZzwqCxBAUQNsbJUmP1JqmoxLqUo2bz035CcYmcZ9TLSQl1mW5iFpGkSleZLEZ0yzAUAiRMod0iKZB4ACKnzLoknRBCg3FU9LZ6tuKzCQkbnM54OmGszOiuh5gMF1RfbuXSzzu9e7CSeK+uJQCAAPztbiUgZpKRooHQIaqQemPYKJTtEQBnlvoWxEJ/ndAXxZYZVs0DCzF5TCW0EywNt5CuP3Yal4NgBTsj846goYgvQtPRGL/MsKo0PjIOtuyo082TFNL2JyM/qmteLpvvXsyeiNc8902kHsTFPRANQ712iWtrcjm3fcHmc6izkRCw0QTQq7qUlwkSqYlMw43myZurQKn5ycoFp9vOyDa/8ycts8DAQF14qwwSm+gQICCezT8MAX/WEdo99sdI9bq94ylPQzDAmii29GhyLaK7395uVIevru4ywc4Zt27jOoD3QPf+eU2qLWEzRwcqJiEZdh9GFu6mWIGv7tQjEaY2rW3Sh+sxyIj9fqRGBuybYkRa/sqpY8jNFfAOVF1HIujY+iSCnD1doCPqTzWK4BEZce0yMvT7GVYltBWN7BrOCqQipV+/XMUSOkxsEUCnZ7zHKDb6pNXNJHjjG66SbTlf1hG0coGXAbxEJEsHT+XP8NdsEcCOo4CqiPb0plki2Lz5vF3ThiVGG9gSdzBABGZFUTM7qZb0sfXSi2yD+yub5q8VwaLFRbDIKH01v7ei1D7GZPkjCzXovGOFN5dtidaSs3igBgEUuapdp183zgAqrXTIgZtlyCUFaPHkIA85GcOnFXSgdNXvjrAAnsRPwbHdMCVAxrpU8aC2XYrbdjzAzTbCHPO1u0bhIFRNJqBkFGUjYu5a6eLHIE9tjV9gO1phgP62gSurwBkuVJCgytKr8nez8SVtZETfmyOpEQKU77rxlBUC2x6YSLObHYgh5MtvExkSjDkdtTd0dCc+AYFIlcRz6oZdW54SARtwag48td/KsCtcczAx0EVGxkxrMgGtE7B6R87U0hjKzVTBUImqtsTaFKPfwnVolMW6N/dABr0zv+p5LsSgiz7YyOR/DZ1UQrpiYQL338/mMsDzI6tYXqVTEnJUfSJUD3w9RVYVvfIa7MV4U5UZaQwg9UEBxpVNopAd4p2JbFBLzOEtF48AFAK2lwLLoPzOOwVHEIIu8qVo10az051rLCyHS5FELOtHMotLVsuG01STKAVNE/Ax9bICKMEYEewBvysxt1qxY4ACgRypZ9TwpR6mnGHJLntpUFFS1tdMSeedjMTOvqjqAiE4eEr4KsixdsnRh7TRXG1rqtpmRYY4dZGsUhcIsOnKQRKwWEnPqEmGJj5l2o4im0/6GoAjpBAiJwmqlENGwfb2aMDQPNyGaSjvYHg31rkT13JkBbfXSL8xSIr2k8OMwABclNEbEx2GVIUMQ9aOYGHKWMOSSDFa21WJ5E1HjEYzZe2dWJmFm3z2wU2zdQc4AlL1Ukq+gInpG4uweWlzOXSi2naw0mXWk52kVlCO67i5aRwSA49NISOfqOBqeD1IdGUAuUb02khXPFAd2WzK5Ghczs1APBnIaDgjjDYsfYImiQ45JEABuXG0apwoCzRXErU0RSd5IYIzsKMIiOKdetUMzDVhiL8kG3XSSbLkb2+Vcw4+Y2XIISC0GRSuoapVGKyEulJfEZxgHgPmkotR8XNh+QfoimBLWSVKU1QA2qt0hvARzXovIKz+Y/l49ELHXq0s7l66kEi1LKHJLKyHX3Kk5gMQbgqJD/Tg+azKTuUEUqegDkwtKdzBWhJAQtlk4NQxsG7+piHBuA2nqUBCVY+sHYqlCUpEAIOuGAbA8+8r52Chkpz37XA5pA0WYSw0KLr9OG9srmkNDl47cQjgkFQsirm36Sm6UhNdJ9+Bg+UkmLgkj59zm1BdtBxRe360IYTZykkAXgHXGUWhjOdsompqM6Ypn8kROayuzTMPy2PxVuXNYgQRwPp+XWXYBrWZWUMigCeAdFYdDI6LYtsPIgy1Yv8hlOFjsHn49bEGLBZbyKkkRsb6HL2Nq6VjXT2lYxIO+fI254KTt+rdq8fp5H0Iutxbs0ebA2+j8IEurPjARzFEkbNL/YfsV8gqJ6V9SMsPdDUlliey/oNVYmJWztKap5GlaC/1vJi+RRqXmCnDFau7Mlp9WbN/ArSleqhaTeeJ2E/BQwRVBuhqXS/wE+aOjtYWh6lcTIvsc+V9a71Bc2mVHVwiiWVi5mSBTlFZcU2nzaXqQNleOfApcr1OraZAWbJqtFObhpJUxTeHx/B2S7z7ZW2vTnaSzFe9ALDKyVrURdMdMrEvLRfTYvxGY4uGoZLnEMU9RKrLuWQYYJoM54zY0n0b4JYnM1HCNtdkNh3hbuC5/opKqwNxSFLD70ViVtGzzq3qt/SEo0EfFwEEYE0rTJAc8SRUHVmbFw4GRVLirRd9TapyV0lyGmSOs8iLmK8NEknRVNTZNUXQgFNA0ODbmPM4QQSHaG+YoJ6hWw0xuqrmdG0IsUXCRIA5gWdXYquIgZAxHrLFAvkNr0VfZ3XheXHbXUSeP175CPtAuCnc0TiJoszYWGVLHsvReJqJuLS11R1bC26XTDVNZ57pmw1LxrQZUxZvlZhdFGB2L+3Rpg3w0soBxCFUOYUaFLrOTc/GiAwSQAeCl8TquMn1HrG1saz/DHLlIOieQCNyGbingsDZyOEwUkqAwiRhTOZBDAjOPLAArOm0t2eCqM6lSSOK/koeG6bngcBMXN6N3ssuXF8M2oupU2Il8l1IV+OW3wUGlo9q7B5SUPVa3oi6a8kbz657AGA7V0k04EXOa5KCs/pvlvXXZ1ByFv5Coh257yXlKNcfpsknodpUamgdkUbHj/fLkKlgkwkKFKBVIty5Sibo8pVJi6HDicTSFsbfXVksiaLgOYaHaWewqQMpk+3q5acclpkQD8zs8Cx4qxpwJy9l6BUsrSCNlbWeSiOcxaRnRbXvIQq6lnDxC+Y3azDMMF6zs+aad0bMkncbrur91JJyVUHeaZlWh6WkfomSpYrRzbCBktnVs8LPaYHCGPSGMf8CPI16k/yEX3Iwik+OpBvLKQ7oQppQ3rlO/NJsLR1LPnBM0kXQEVC2YISIrSVcANusHe1rsDaPeIckr24+3Ukzl8+M+jSpJ6870WBlu1sYO5Ey0q60DQHUdTnlxES+OFpqQwkdr6xUVqyifhlN0ySYEFmG7D7BehebXWJ9L9ElETYuERJbVOe5IVQUySj0B3U/37S0cQ/OggINzyA+aJR17pTtnEXmuCzDsmuAFxbr0XdPTcMEyqD8t8ACw9KU8Q2rppHhQp8mVOFIjDNSAX5Qp0es1YxJHOzw6Z2lpIGE5/ThQ5OU0NIpqEKn33QKTXh/F8FbfHb3PdJLbcATzcFQOSYSWUlpSbY7l+UNEV4u+MttyJQceEv1CLpWdkuyW2Myl08/jmtYitYVK2Qtm/M0RfDTZHNHcOP0uAE5RlX+VyI/3pEEwGNsYGCyr0cfNA7skpnMgKi7sZMsot1NFsuBYFJz2HBBrPsT6uowITGYIKqN4FysCVwFxwcDPsZzP99apL5kd+5Cts721Oq2zGLoocBcuileOX6zSsFJO3TpZ4LlBkewgbWHIAzYtVk5e5kHJXgoOuQ4wn6/jre2Pz5lJaHUC5qMi7DFmroOozN77tW42zeG813cP76Ow50I/E+b9J3uS6uYmEc2ej/HKvlVXe1lu5rx4yKRqaIHBF1SiHNSkeAgH5VzX1bCS1TLYP99A3va1tnCzTDi8iGjJ4pkj09cuDuGsZHlBIKdUAdzBMHJKK1Etr9eW0VhV646zLYmzIucCTFlLHIBdnh/5DZVuxwQxVRMhHphGKtUk3q54cuk9n56SMCqH1rku9HxMFXvnORydn4QT65AMKAfULTGRddQm5cqvdXTItZAN6oSNnbJvHUu93DGZxpmzOO+pr9bGBWq7SQNVSJJ17R5GKLxBsqxuHZNpENwoxy1H5pgfcmh14CmdjQ1i1C1FRgaNJszD7t/GpeoHkWtJoCVLPJvpG1tm8zaWY8O/O6UKEamQQAmd6WRhd+oOn4G3AqevuqzmW2SjxOGEM4nHeoIJx8k+qpZ6rduphkBJV15kBGZOs0aGdU/55DRwWtsHtuj0ZNSdOmJ2DscxeRpRp/KotDOOiD/GQhn4pOomqYejbdciYmpHC5GP3mNTNCrWOza4HevOvGQ+ppiI0qReaHiRGNHA4LvFtsjPN7BkPpZBu0uPyYDVtkARJoshAh98NUQaETFPsH0+WnkXVuPvgMT+o0hnXdrgCKNnW3pm0WSKQ1vsHKJDMkChAZumXWAuaMfRXNd2djTG8xMmF0toF62VYOqM1A9Vf/PMelxOg8I2I3RhYZDjVZrE4yGx+Ydh/100ajMIfROJ01WxPfPLPAoLyx169+Ls1CHbKbhEo+RVdpTBm4fvLvLhkLYvMWZlE0RV8uWtQ3Ka7y8amWKxXNJiE1+jUTd2at2ZaVukdlm+rtbG0agGrexYWEZYHptINqs5hdmxWqCXgwZMX9agbntriq7ah7njdxZwjcgMkZPOJJiRDYUCkljh6lYIYCGDhwmeZWwwZoo/ER14U+Yre3EBbUiYH1BVP0uQLLcbiQrEWtCftD9QoFecVLkT3TUiM3VHNIw/hg54mKTKAa3TLH2qwKr8o3P9sfL6dBRZBe+QzOabVO+Xri8ed46Nnus1DYp9vAtbLlAl1R22tvDFJGc3KXPE/yvkOdJsoe5X1vnNefEPF7TgnIs/2fqli0kD7eha7hwiCjPJvej9+WaIJmXV4+Pr9Mik2D5PCkzDSEyAuVDsPKIGi/6H1MLPaRTtNFwF8iScDzA2kfGOzEPqOryZDS74ScF4+G7umR72UmnYgbHlnKZFbL+SZdSTp6SlHD4IEvdmQ5ILEWPQ9qUB1ole5jq+HlS9S34Z2JgDm8bnGIa7Nzhq5B9hem82/x5mWVaY68zusV8D/k1W782OkaYXk5Q2ZB7CP7rJ4djmoNL4wS8m0uHhuCTvEpoXJTj7/46OFQVFxqGsQVF4GDNlAKCSDVUpuC64D4npAlONkjtV/lYYMntwYeBlAqoYrT8SkZbaISqhU10HA3bccLPjq1gt6MkDSvIEpnDsjAHeZLEuPzmhezECQ44dvTvyxQHjbd8y1NiZK02JnX2w4OFAxCtnqvgglTj5z2JlemHnhZwWeWp36oLbirESETP3s2JOibQPWhqf/3KgLg0+qFqa9+g3KUFkneX4gAiWnOiQNj1qgPYImgs5Qt5KH2jMC0cX+aS02jLcOayLYVTgXEuh1KS+OoOOz65xwq275eLFGapxUgHnGjH5TlVFegaTLgUWDfm1QYoFwOEQcMS8acgWOrFSS6sQyL9uChNBeWTkbhi2q0b5VBgWz1Y+bzFGcSKjWio0gLqAoUieDPCaKspxJFoRXiEvQ6Dla2IgPoyvlZyW1nbELtIsYW7tao+x1c2Cv0S0y4vZbN43d6ehSxVEas5RUSmI8hf3stSjtcCwjT9kJumc7lvlcjQxQVgoakLIYcEuWgzxIjfy4FeUt2q3Q6mXTifMLGbQmO3k+mlQWioFJxj5TBv7Pps+LcO8RCHZ9S6fsRFGwDMaIXBWtSci5kZv/Zn/S3awnB45c7Um42Wv+UxuqRTEtTQpEuJFNuWHOtpUMMt9Oy55v58CIuCXfF7LRdte4MZyq6nk8HjRGfuiGUgVu41TcjwRqbS98WXUdapk5feYKqGspYNgAlaI3h3PEPnJdqrn890la4BMK9CVw9PFPA3s7xU3RpiAzGwxoTP8TEQq9/xhZF4PEZHAPTrp0vT7k9ekiMitkqN9uI7Swi34SlVVHPWFcjyNqBTCGoQBQLhBOgOQDkBJhKAENvqUND78XTM4duKsgqAKrNz9ZGY/s7dsOc9TMwAWGjftAG5Gm2RxBqbMjSQ8kkFb6pRgHcgmKRbyqJBoqXhIbhCvr2zNjPCCiqhdaAIgoEdlzFl0rEc05+eZXKt+5Wwk+XpQUWkBvjw4zTIxHRjT4i8/9O4yITEcpRH3GA43aNzWYTA1oqZKKtROXXXVwaoaHhSbVlMGDcp8dUtVRc52TJXVCKesRzLLw0N5VVFXSyM4dfFSB0Xy0NdqSy1u+cTYmIjmtK157LBZzIXNVVW8FsUoPkS+8d+ztQU5dWh5CkQKZ0az4s4dmgYZA0pZx2iqk4GJ18adFsRSUboAUyGplFDhtKw9neu90qxoKwyN2c62UM2ATQVc7BFRCYzw87ZwxHdMQ49M3AShrSh2MLLUmwBACj0YMgCKIRu0gx7CsVIIA6h639eu/lzKz2WKewl7qL+OalS7xLz0dR3VBTvaJiOLY84CaFnljMsMC7ufa7IdX8uVErAYniswyWmV+I4k7IJrJQlz1TJHhiHsDuTSy6HIvql9vsAA4ZKYl2IYaWOb4G5ALJ5GS6RuIak2sIS+LwETN0xN9GIPN1WtWWsCpuJOpNIrkJ4Dc58KKA6YuDCZxPbbHAIS58ik8kiYC9o91sxHIVM+gptrilia+7DiGdXZlU3l2uU+la0WUxsBG22b7mNJ4V+KtnRCTSkZU4LCShUAjQXKMjVV1K74LNNaHyj30/d/TLTBJqPEE6JCYraxvKjjjszAc8H5kW+sgI3Ez9Glge7lrTysIQEgD68/ze/65/2Mlbi42igBvBFeJSHrWHrfaZovUnkUbZsxQBgOkouC8RBXu0Kqg7X/J7PMKupiR37Hfx87oPHi0oXa+WoRg04YDp5RYmBu4cA0H7DRATGjrDTKXwHQ7Hxf8fp+dBTOXEnxcOBU1rGLQtSy4jvUlUuD02FG+zAOxjXiWuoEHaondXG1OoGW4Rz2Uke6PDzjYS0gVr9SbO9TlJiqR01VtGeeM2ZmiNLml+Oil5vL3ieOtNThVXF0KHEuIWJBbkXE3n6Vy4amtFpuRnrtqPbIUbteCB7FYg+Ls9Z0PJpqa7Z6XnyJNkMHo9ixlANp4V+Bs7WZGy2aHcoYAOEqs9F8dQiCghGFPOik1FV9Mc1Rl6JSyQ3TmFqq+ybfgYzLdojsaAz7nJNyU1glu6UoOh89P78yxOvu+vamhkohAKTNSgdqMbD8YbbD5w4SnYraW5EyoyvbvBSHf/HahMs62J3CAXdocBgrsmWvzO0zTWTGQF+2PpdBVRgOhVreKaWsJxaOeKORuhUPHNPWJQWQxBkS2b+rHx65IkdUrdguSiY/EUGHJwlFo9Cp8LK/pqoqI3DNyzyqKkBtjaEz7tMqScw6IedZN9dqMBOxds8qd5eDKtV0sV36XeLJul21y7EURxFYdhAQsF/rTzSK1Qb+NFd0mGfW2JEIJeyvhSECFKquX1EMjvFA2LIaKcSGyiIEJppJJrWRzuH863LicOA7kscr4O3XQh7bWzqyEdFAMgRSDj+BWX0YN0zNgpw6fAczulh+1bJVt03lGiBh7dcZmQhyDdBU+PlZFZLlswe7JA5Pkdeu5e94Z58q5igOP4N7KW2vujfyQ27BVMmeTdV3lwbpRgPtWJON/F4zHeJQmPmahd30NWiB7XxVs3nbkadhb2f5dZ3CYIy90xBYuaLK2vej2WhNAPXjy+PdLGgmnQhWh9w8Fc4Ah2gM4T5NujUlIZFNk8HCYAmUh5vUUaOS0sSZFS27TlVVK6KfudtjGb4d1ViuUXIbiKrRydhCSjUGwkRmBlVMAqVy/qE5CIxfVXWcQ1YEcQWy0UmgHggHioAW1VOs5zA+IAKED/S95p+DXnYMG6jWZMp9CitkGgKwe2hKF5UHx09ctoom7I3g6FrbBdWOHGNSzUrSh9J2V0tAy4mtb2U5cFW1Iyb963FFWm+iq3KRS4j3gWC4LHSNMtGUmoNomiYuXSDt4woqe8U8k92q0JygRXQEOMdKyM4WCdQdFMyomYMLU98slOAjEV0FghSu9q266M4qhVKIo8RDqyvgw04XmaNhWi7qk1S8gJIOjV1dnohN4aoOqrXh49oObl3Ib1dJM3JGNYRtTGM4Rvz2PzsYpixBqQZfU9mhdmAUAPKo0mU4zMMWH40Us2MGez1plShOiJgRUu6Qhq8qUyu8vC9NTQHYZfsi2FXtxTHFpxpSvtPi0pz930i5TszR+MedCseoLDsfypB6yhxxq7R1mWg3MS8sLubN13YSwkO5Vq9h642LE91Ly/Xh6GJRBkmFx90t8CxopDLH5ORozLxiiaiTd9QQ8peISM2OBiBF6yDOXulVGrpILMNnZuZGRBIxFocSkDa0Bk5Whic/ACVVXb49GpAV/7ZyHSK16uPo2Zm5uQUAMboyO0AqgESlvO84MvBIDC1jNJQAJcwos5y23TSHEDN8wS83xF5gntmEGMXMvUTGBSEc3dXfJ+lmdwKfx56eKoxm4mzw6tyx014U8z6WQ8GygVcfu7D3fGChIvstYz9Gb1FsHjUsRE2DvOK4+bIuz62XKRop7uhskO28b8K7h6tjwX8VuceeqiUGpfZVyaMiOSeOiOrRPPVd+7pr32xTVUkAO+hIdY6FMOkxwoOISLTTvJo34LN3ms2XRX5OcnVolmnIFdRF6VSs6nztQ1saXHhtvxZmsa+XEkOUSYEGIjrZ3LU0M8ZcV8l+DNsFAOpC4kWuVDqVf3fBUl8xeqgxQCkB6q7cJdhyNlfOVcoF3kGy+2LxbbBOlUMvdZ/2RD68KPLUwKmX7G878v7tfS0oW2QiEcEO9yIASuz71eFtuWhX7fct04TCggYQonyY5PMs1ha0jvVwmpeb+TeNMltEZv5YEJFn4RKR5YzFlg0wjsRQQFvzw+tJlbiJxwwDwxxObj0QTPnhFPMiBk74SdILldO20U+vzB+xJkpjs5ZUfWXvRTZoBEbRWp/MjKQEeykK5BZeBmkqgz2du2VgwfJW4nwXyvtjqho+FLIz6kLhHswpABUjID+EmeycKkI9aBujuHLovU3Hn3xG1/tp/w3KKSLeYnDNoqjLwXj9omJOkliYPfttufqBtjhvSoOeoplRQPPylTAYBYV4vnBVKp000AggIEe0Wd5bbdm9NaFRQPlUckws4Km8W4sdC9CWQwp3Dqq9APDkzaDSsPagpU7oGFHYBFsjiPty9MzI6qqxzIeCvQrDQhUGqa+1SVTDPNZSely122GcAe5w6uSJoyPE/vK1im7kamBmxlhXKqo6ZEs7T3W4WzAL9s61MDRPHLdiYH196mKZr1Wpe47uYDqTErz5RRYragc4oYquD4c2TWJR+Texnj8270lVkshObfgHQSmk9YgG3IR59+uc6sB2RCy/0myl1knaqHYtFFZ5QyOKe8cylelfWqiSNG9acGKxNwNnZcGwV6GnI+2yIwHAWdCqpy48w7nOX1BUBND0QI3qqL3cUCw1jGEg5BMRWWiHiEBOIIsulmXvKaWtqhL1UEpERCeNU5hLnZLKaTtmlsf88FDFWSRMB0oIjy7Lz/SYr5UzEw9myOaQSWEFmtZVTq/OzL1nUkQwa7SsFqwN1dNGpagJFBWwQ0VLRCI5uUrUwubw01+XdgBElO5s1gG0gE1DLy6Q1NZ2UKvDaXmYmevZXdgmF4Na1kMosutEQr2pXpCWhNBAZnOAqMfGSZEJB0XD5ss3zTYaHqslLQ4YstN6dcVhBF9Xm8ARW6dyyBwaxaZVVZlIwWwGbm21w40Smorauc1BUSKCac55YTrZ1JM/mbBpUV2BFmWmybBQdYuclyjqgkZLxKuvFP8x6ciU0SpO63TX4hlHtjsEWhY2RNBawrzunhzHEpFmHvWh3ZnQVjkDP317UeFDwIY3C8wsR4ZCsjCKKtnxULsmGbyATcvUHdtLmsK7yzWts35zSrZOx7os+X09vWuP8K1QJUrrENL1UkfqD88wTyww+yRyRItqDsLeIldobXMG+zjSZTI46st5FknFbDLJgg5mznoVSb72Sk1zRaW8o9UAEcUyaeq68lIiKGAezVIYHDz498CCxpEhdknxK4Gy8IKV/38RR9yqqxY4l6fTo3NojiC1a5gdjZsqA2cAcTZ3ruCjLzTfSlcFXbtAJ7IwFFKViHmoPJZomfNurBk9MZE5O+O86UakUDmyDlXVNdGgSLOjp52gmbQUMgqBmIgBlCdNLLa/g4lVZEpPKMcm2qhZLdfOctXMrGkRDcdKLyxSBkFOx+IJTcQSjIkIzFfqJ223yqU5Z4bLtPgSSyNWI5yq9rdutdTZsTd1xjYR7Vsh9d2qAuvoEJYxzeniR/yYO/dai1qhs1qWPaER2QCby8QlXm8KHlyu4SErYDCzxYrpyNWfdjR2OIPAQiygLTJ3Ydg4JXFdm1YjxtjKiJbJRGVyqxkiFIt4TUyqqnQoa+rI6JT9xdiIobA2iFdPRs7XEra5CpBiMxl1MA+vDDmE/mJNjq08WLVR9s4W/K7ayZq1OHQ3OIp6y5XkqU5TutClTzNV1f8+5OMxukxPxu+pU5gY1CudIxE+7wbm58yCXFCazm8UJVUwM9wby09L+3GSi7Vj7YOA7nnsieFjg3iBYVVeZP7U8Uw8b41oTqinSuyJssUYdQdYkXWttd57IjMPjWutxXokArOGGl9NPZ9c5Cl5M7bf9s6/PL8WXrg+jOX6QohXrQhSJWothgpAWjOfq1qKwNYvYK4tZcTS33FEV0TaiHwdD4YyUSPugdyRK0tEKk3H6rmnCyu3P6L3PJW4LAuKZExWKcsCM6FKxR4dZ9jbcicLdAAQdMBrQAR2p1XjQqPmLLki1ojotBnzcbVOfoA1scKD16RT1NVQ7RKqRABWLt4ASc/qHBPEXmxALXq0TqIL6OanJ1Xb0cAex81XlltntVwT4UpwCI8E/UnAJQMAVsQlGsFChJEgl7SnlR7qXh426gWszFr5tcGMp8xET9jm7tbBZgueSdTP9X6NmzvE2FXjqI+QtGr0P8oqRAtERCYImnNZXVL0Sdf6opkzemaIY8qVxxRL6GSgRjdF6omtcSsl2A+NiETPE3qDzZOiBH3kf5JCEw9cx1UNEeaTl88RWqReNls8OlO0tcEDnQrYIzh0zKY46lpLPhqNZ3RakGXPXysfVUa4lmtTxs0CJmKGu2IGe1uIqw0w7pzORMTmIfJRsI7DCwfx9Ahat9ZEzk4ttJgak6ze7TYTiYXS3EljYqfDq7ZEed/YjzuDiJR8KQ+PK3J6ozlda8xFLRauBjaYUQ1igM3UDEI6qGinpT6HlcS6kuB3TIIlUxMRtqzX/LB0fR2r9iIARwXuuH9w8IXzo07DzGv4zQphk/mZDbyIt03eKwl3EnMqtXwDIIiBDEE6OhoWpCCJvxv/6tjemuSPrut2Ct986lk3uAN7SIqq0mCZIATP8hzTnT+dmi2hXU6NpEQv9b9RT9HHKZpIVck2qAjK6n4kK6I+uy5L5wyAmBRsY7fTcGyVyxSSURnERJSuRbUyMISUOISTws/aya2msuJPH8Fk2xLR2IPkWPv6ZarAVGxFLtEw0iWb8WewTQNN/L9gH5MoH2DFzeYCyJtnIq+yo26+UIZHcIwubA7K4m6lX6bQIo75aRYzeBB50m9AxERaisGjKoNEJubFdy5YXXxQCtz1WPb8kO9WU30ma5vxUzZbXhn9VkgmkoMv1aYbpJyZVGUUpeVpVyLpP+gN9iuP59va6UYA5GvixqwRSGg81OuyeBlU9QGUBuN4MGOoaS5mqw5QKCLsINqJGbRiaPWMTVK7M3pUzhwNLrOgOo7KCgDN7ZR8Wo+3ziHbnWHIElrInUEhs+QdGjpsYh3vAhGaV3iKzg65fdsKyy6yrLVTgqbFfFmCNxPJV+02kYcqi3icsqouFWzzrUL8s3edbKLJDj7Mndnao1Og3ZGJoYjizJyJ9iy6xgymU0yKDcSEYXguCtkTqQqdjM5JRXgKBG7mSrGctVyUmqmBYZSuq+pS/ciNbErrJIbmBodhW3US1zKW2JTeKSIKApWsXGR/efPzJ5eXeRnetdZOYbgPs1iVWlszgByMqhkNBcV6qJrUuwhpxpl3PfuWVM2DuHvvtOogjgKYOYQJzwaPGQ1MqspZ+BFDHwFQkjIirlJ2ib/0ft0vUAUjHf51JMgYGgoxnFINk0XXJm3x9JyGt6pxM+k2yWXnlikEVeSsmEoF119j25dsSZcQN6Sy6aZb2aVoWEKwrQLfy1eXR2bllXnK+daUbm7nFszmXPupvIkH3o8GUE6iGZNKgIWaExgnjToccbHShaNPomCB2i5VzlaZJCY2i8wRhR7LCIJzJIuejW5a1ESvvZMvNLWElMdSexyPPjLcxjRpmTWedkySBKei40U41r8o1nq+WFm3tDDSApk5hFFLVYER7mrPDLW6SBbM25D+axi45THfU1cMSuZI7zuXwDcASt0ExMmqiPGghKHKljXEKjiqPG7wEpO1zmC3WMyK53z3dBrMlf4nIupnF6/wojyBdvUCjv5KnEisep6IWhXUQ9+ZbR+dclrweadKIo6PSpSeFcQ6m1g1kmYnjWsoHaPT1DHV1V/JqWIRiVRVRVGE66CWfudQiIQ/pWHOzox5jX9I2bjIVmJTIap2Qi9UoUzu7wSWRbxtsYWw0oSBU6lkMBAVL6NE1AJyb5yyQOeVeDHQE0hUJldHEWUIa4OnWUDZo6TgQdbFsHYe8nYgHr7sUSxE05ZQNjjUR/XtU24By4xtVs13h4EVXObiEaxcU7t9W3muSlICHWa7xyuxYpBivDKWZ6dEDpQr4Sw2x0I8w6IKxZwiCOaRcm8tTMkQEQjzqbbj+bKW47p0ZEojrx30HqDZf3sW0rginLygwlc1FWlEpEJQxFmfExKqPF/Efs2+qag+FQeAtRLwXcjLZzrVepPRIkOUQAQqvqlGEYKePY7xh/oRKLN7rpYgJg1Pbw7A2vBIPRu/w2A/l1X+OSaGw4XlnDyoxCUk+RpRVUs6XJwbb0vAWMEW4hjuOAUj57s8pqrmfQHmqdWs1zaJ01z6AeCIM3DZSWaixfKCxKwfxslk3CwHMzwNiEpEiQ2T1BRiaPxEZA5ngjuUAuZczatrLp9Sp/6Y04kK3cXtl5d9pDjZazmKyWaQeRgxsZpnqK2ke1lO2UAGA+T9KqSq1CsK0n6aFCdVnldVZAxoAVKbqlLiJAzDMggu1k91YxauUw4eIXEaWCP1wrtTTTH77IIVszjIwcYJ3ajEliyG8coJ6d0lApRgm5JKvpiiAgxmt7ObJTsMpVwKxbjPjCYaRtXYSpuXaHqVoQ+VRyoG8idV9ZLPjuGqM4adMRsfdmtablZenvEP9+KEuyCDahYbJYHsvfuawQNctNpdNpPWblh95zJr1eCoAQ25rHX8l4Vgzs01c4t15ylotYHUT8AGiEvNQ7VTLVJ7uUJNp0IUL4lpNSkfJpQt/kHkZ1eF64uITQhcyKaxme3kgAFxMDIzi1A5ErJhVKNHgTMaqjF2VDJx5qreCUCeyYJJeRPhiilNq7R4JtllRehDSgzrRKGTSnf7Kfx8HsmcBtCakBz9TK5iKVknaZ5Vre9bP6K28KPiEQSQ/lR3SMUaEpBgSbduVynNiefpYi8hP7pWVlVltv3uUdSnwHCUZ5B74a7ywsOxBEvmHPXZ/hhM4s6kxTwEt2GfGha47FEWgKLBJsacNkE6yr2EolVlGltQSUCOBT+PIMEbxFHOl0JEHlDGYDP5/gsKb2SxWNNqSStEpOGpHs8rA3bMN9t4gvgSPCy6CoDotbcZxRRcTRTnPBeo/CwAsMK2LclRx9EI4IrN4n3c2jGQ7D4RkblYjIuM4p2rh/4wc8qjNSvSXEp6KKfWtVqegJAAp7Bw/RGhEkRU93eSZjbTe6yTiFoWLov9bD9iJRsxUbvs6WS/xZZTorEMSrQnTU6UII4WVW2tpUOlhnFQOf21hoKqF8BUUKfBtDIMHTRQ4na1XAE1tUIRJ5tw+sMpZN3lbloEzAIzZJjg6c8Kc8d5kG+Ieqc0J+fkJlUhOqmca49lpnKKp1/TNPThlMl0RKEBaJRYGqsOG0W01ghMIKv4QBQamsaqjqpXTBOZJb/RLKewtyYwpvOuS6jm1r69YsGPNMbjsU1dr5dJqR0RZTS903YNhkXReQq3t0JzJB6KcWl2n1Np3J9tjtZaBPRoPLYd6INGBKsvbLZF2BwohERD5KDT8L5ouEOQqViKbsNkoiQMN5zHzlf6BEx65FcLNrTVnYmOc8QwNV+vC6VLuGxJCBGR+1z9bJrBxWWbdfQyhBiCMObNWWWQ5sFNzK2aYmU6iKbTiIZNHDvSWgU4AB5nVA34Aci55hQD4BNxuGJCHKkqOrOFTSwF8caB2zOSoznfeVCbbqITFS9RgDQ8KMOzoosBYLXaDF2mFyAi43Hq2zJp3cFQVapezECnqp6KvKtXYy/Bm+ROwZkTy6XsICIViZM7xH+jWPoP700Ybk4MvEQFqs+3aR6xgnoAWAkR6Osv2Bp92uYc+8oYrksa5pHHfyzWhiMrtGNVBrTuBSqTK4QTWfBUcTTpAKbtZmAGZNU7uVk7bubKlwhqJSmc+kv7Pk2kqsSKjsAjEJoQJm6LIPPhWDvGPOnli5VBNS4ppZz7nwzU9Elu+Sxa7l+5+e/BXK3ws3sC8vmC8AGq55LMVeayLwLHyZym3szeIiqpMflKWP2j8Zi08nCemANongXgU2PnyIj6KZrj0rEQMZ9QHOVFfWUWTe1CMdJiO3odNqGSTTDPtansRrGXZNGUpzbxoxqRqKV4+g43Vf+Bj2WcuRqRcU7PSY1RuiYXW9P5kmlrUhgc/la4dxaRhPnmcDJRK87CoukVYX8gfrCltpvUtC3O4rVq6RaZW9yKKCoqfE4IQy22LAoxqKouAjSuE7daCc/KbAiBNY+pGnRII77E1cYknexpd8lkX0VHEU0zQByJYBwxQEaPmta59WguO08pN0tLmZgAFknXslRyFU96B9lmLmCOVPY7nEGjHh6oCW5GcVr+qlWdmUO41EiTmLvDj8iaS76b1+L+gKZZYyaSVR6v2s63k1o5nHIKlY3ZYkq+OzGzdhC1cN42kCkLirMuCcVqBOCxieoLOKRna1BCSHXDUqP6K5SN7rgk1YmIxTAxtfTg5tzHGKftyNolkauIQDiKAA+khowdGKPJ5qhh45YSmIo7ADlNXh9NequX0hYDatdUaTSfICLSNTTP9GxN+wnEpeSi4JSTyBkl4CubSkHgp2XGmm/IRAv5zD1n25Ym8TSbNA7QvdvNSvCOgOIvShxLID0BVlVIhP6aJh5mVsq7GCyxg6t85e26r0k7zPWYuG3VtX5qtxJvuRRgZstPIYylM8fODBHZVioQJXeEMvxKVRikvuXPS6RFmcrZwT6iG1EfVl8D+Yq5bMRwForO9lPZcLEGqiECIE9SdRETERjp6SxBMwPby1+U8gaxEEkSp/3F3SCIB4biycTaqNAvhvN0V6jlYEdl66AKUpcFp+zUGhTKlbTpejuwZvBUQgG3YMsEDFZvIGE+qcoeImoPzJhRCzDkUDmOGbZwJLXTPisGOqmqNme0kaJlbZLFomMYzV6mbI6GSfhb7IPUsRklm2lZsWQGTZ3rInutEFz6L9NcWGMCvCk3idIMSnk90guzfV2Om9e1zYWQgLR4yk0SqLay0q0zS3FiQLbcIQyi7YyJ8vrmNFI2czZlj4kmY8A6TYgBR1NNcWb2TWEj6chyOlEpGaBKUfsyg5ncm8tsIYFTRgZ5gTIbrPWrYAadAAis/rXRiVkY59SFbk2qe/klc0pMsbgfeSy3YiN+WOEoGq5GuarxcmBAfRN9zGNyH4X8UWim783il5ypqZFRIIio0IPRWNF3VZ3VzzOfonSBkARobZxmzPB4DiKCkqg7F1s7hU1jgyviUdqIsAE81WWKf3cXtUU6a2oi2jb0o4MpfCduz0k6Sx5TDrYV2phiIqO1LaQjEHMi3/gJd4/6uZ20nTERCBpYNkXiaXIUtgizQiwOUrcOUyKQXjnQRK01wLIiheiMIOVicNCpnSyvSdF1kMugDx9teLYj+G4XcIlNSvpOYl1wR6ykleE9HgQAxla0mBvQK0726tiY5qnuVSfkqQszeyLYWMwqJuKImyAiFYQJogQp6zDMBaw0jnLlIhzR9kMyHRg0V//lCIZMJ0uaK2APtBchtUeAW7KPAOwbPVV5zLRUmh04Z+bIxeLhnSahzHMuDVLNyJ+vCmR1zNgKb0QuERFRFpXJFWFRZmPUlEQamCRKm4NK5lTa5eycbhvqsTkSDZ5AQtSWA7sXhi/ZKEYrxS5RW6MpESTynMc0+QreElh7skbaYQDiaBff2oiFr+ZkhRlKfGparoE9iPGGzlQRQI7Jypmpc51xc54fW8ZuXy1KX1XVD/HJiRvrhJC8Ez3UuQPqFsAkGet9IgLJkOCbk886C4ljKwQw2Nh5l/LMrMPo4ZzNmE5QAH8osisNJwcl19RTS6JrBhbPfKv620ZkF0C+wjZzPOp5KMQOFTcHyalZmJPWk5WIyE9wtyK8psmIVLVrJycHAzUD0eyR0zS4KbcfodV8oatR3QHw/H4iO1TTJlYIBDopVFxMTvTv3dj0+jAzMo9PV3GmWGbU2vKpTYE7SbdCAJFGcNSgn+Kxjhlp5V2f2pLURhBWRTudmJno3HsXkdZGkHLYmZn0MEngYqKZxz1Ea1TRwNFVDoUdQcEIt0KMd92OBIZFjrIwqPAErxUmqgb6P3vf/0xFT5woqqnHOfc+Z+t6q5ogxbnqyybFfBSCqnpAYrxlMSIkVc0AttfFSkSRt3PgTlffUVSYxX6kyJdjc4MCNNN1bKssG4ytnBE1Ev0m9QBwBxuA1q6cM1VLIZChmOFr3G5oITnN8PhYslxg/lRHmtzH7D7Mc8/2M0UegJZzpCdcLVHW+asFBwVxIJMjFmDyRavP4ZVRCpweje/kyEPoC4VJ7ngAABILMlD3JA3Lg/k0xHrz7e0OPcXKNSExKXk+nxdoox3OAHuUHYElbLBMxGFBqil3FBhbBiai6x6qoaKfFSSCnhra8+DXXbBgclnS2+AIpAi2rQEHR5D7C/PZS5qF5GdaQs4+63Kn0i1mGiCyvXNRleERMUJsLYF0yA1xJHHwL1G1/JLBvWyaRStyv742ONPACkgCeyUlB+HytXZEBLFctkqR5b5r07FgnEuyar9GiI4qHxrxCJvwTsUkItG0RTXCoUqz5iIywGIsRESc8x48KNDqcVHPNFljm+oMElH6g60wo4GH8GpoOhQz+J2WmZ1WPiIy0mKZao96zrOTpsM1sn6STNv8KpLw+EjdY+q/nlMsO36GKyuen9cJubWE9UqqZgCCaes/xaBFoC9HY9ISzD4CiSYKrILxdDolkInnOlNW+jZXZWYr2K9mOlD19I8tIRcgdtKKb2SHW4x4SI8Yc8xLempBzKM8DEPE4g5CswAeGAVgnOmapy4v+bRR7ILDE0nFAobDOCYgu1hiNMtspgtkoudTjMJ/6BAmjJ0lb4IxT/wRHaRtfnzlGKbnjxajN3fkd+ZQneSNJJRESlJbvX/gqNSti/JVc3//IhvcPOo2AzA1cGmM9oqJb6HZRTPXbtp7pLGslOWnQyBTPlaU1mdCLW1FJoxpCRls5fzQ8s6YhaihQjlAAAsqCC2lGCtqadec3E2LrwPc0TIPtn41i2Rhp4NTLivMCwA30PDc3WDU2JmerAotofV14YIplmK6dp1XP9cZj0X59PDMFEd0mAQ/1mSFdzi1psLzKUaQVW1OitvAce6Ge00MPpgd3uiwDk0zdmSkC7oUNv1Rq5EP2oZH1R72m7yz3KwfiFy0rwgH4JM1FoKJxgnb4VPc21/E2v7MTgaF7ImK/bSBjRGOPfMLqZ9AtGDYhjNy4M0bGm7zuvMVb3H9EKUEcpU/KarDUdgHxqXBHmoiWn48JGkKUVWiH+jwSWzIP4Rzv6pHgUpYfZg+EtGUMI9FU2S6/6AH32BY9jIAgNJzM3OYD22Gi8JiGCHM8ZYEnfgwM5VaJ2wkEhaKGl1vmIj5OibRsbGakksiTxRl2nS2a0rz08Jx1wTjefMhp+pC+g9jbI6SZHULRKcddBShULd45ge2Qho+K7oJwyERMOMaPs0DBt6ok0yP0mQBlAe8lj5KemTuuNtIj3U8E2QaoGOtbLPVa9cc3lpxvU4mfJSGLKJqtTnqcOzHCUiNgPZA+Hw/gbQnbIfYv+wCHQjbgikCBbQsExGzZrg9lhH1Opjimx7mhcxyODrrlaUqDoDIi1HPnSZE0PRul8QwYuxBG5XkViVUWxh1NdK1K7OpFK/kGRM54zul7RQ4j9QRHiv+Vn8KUoQfqGIYAJapyZhrKgKL4pwRVaWjwxqD6mzzaFI8diBj1gsRkQZLcluRlkNL+kG5Dl3NJnp1O/h3wFZUPh09MEuPSUrE/YjFKWy8PIwyvzskC0EOyH1ObWs4Im+AZKIxKezd1TghsrPUj5eqY8M3SryDdQQYqmrEXw+zj0jDhSBFrzeRzsxKByKrdp21/zGpiTpqNQU6qFcmA+tQAlApuV26nuNxb7Q2luuS4KXi2KC6jUsmBj2JGtTc3U2CLYFgAd60iIM3a0Un3ZKSk6jL12v1z4ygBkAUDmDKNOOlX6CkLExTtiHJ1A0f8TWAk1pCnUzAFT+k3iTclQ/7o1rRbDJQehYDWkChC5QXP+KC63syg/bV3sHS01aKANI9mz7Z46XDZLgQaE8KYiJFU0zFnodTxBE4GsyRXpIdKO4fr1brE1RlmOTqM6FOUiuNMNR2Gsnjrq2hVbFdXLJbgzL5ipzUjMrHkx5qfoBDazV+HVJhPGPiMalUGW5fyQLMjrH603LtRuely9dds84bzRZ7cYIHLX0wBYzBiqWwT7GbiCADYPMT1O52sC2sZNl3qJJlh7z+HbAd8NeBlTnuc6r84Z8DoNJDbyLXEjQpeH+nNk45NGXb/VniylPQH22BjVhaW2gvSVIL/C+qMxZmX7Bxw7sLevcpO9B2AOYTtmw8Ovql2vihTEDYrIejiGemihQ6TUWFjSg2hlD8DW2mhB1FubD2oPXx0xTrEAgZqS6YnoxzvAlYB3ugOIjocEs08TEGMjBMmeFIJUzBUtaLNM7p2L1Bx/Lw0nUw6URJ/MtSwQ5jgi1WUaRcGLI6F9KtHHTYtapYmZBUgqpayWXzGOVgZzOi2HkVGzon2Q6CxAG51jvLT1G+kIl0V8+Fb3f207FMx+CTHNLU3zAFhtmLfJ3LVM1S3lPgsHLaACZN78XSXKRY3qzQqsaqNPbCicbxbMeWZkYAeWGwrAwNQiv1PJJ8QyqBKtgJzM7SuTTRMmx1AwRktUnm2dgnKIewC/TFLFv6xRGtmIQvltbB63VDGsWFPj3jqEooi8LIsH5lzEci7tCWERzxwMxRqsgF337RkYTdqagowjG/c5JzAwTFF+gGB7SumCkuRBR6bLr3YQoGJDsb79qoCjUjg/yscdV+D7FARyp2632Swqm0YExB4yGa6cPG6TFD6DSIk4CDycWM+UiDmiKHAIL0Wu9uP2xylkvrLkPlgpnOjxCUY6mSoSxyRptFk9UPY+/MjP4iN1SVWDG7VXaeXWiyMvIlHAJxAruy6HXc5jFx5EvNULmr0DuiQJqcfxaiDMoc3QVdF9DJRJP028TmNhBaCw1EH2Y6Dc23z++la5dOFc83v5VP7oJuGciidyopIrQbtEximCBwbM/SKTl61rBlz+6Ai6tjwF5v/pNk/jnCIrsZaTfgpH4+JGYApxAR5h3zQh/24jphtghzS3JaW1RZv6CeeV1/eyJ9FkefQc/J0DG1Jr7neU3KmCsHp2CdAp12/rdZ19Xts4inFafFVPKwDuXMfbVEUstvq+4DwBcy2zAt1XoCTAbFrPV3/TblAT2zRqwl1XMsR3O/mzhEQ0f4Bm3o7EVT1vfsn8d2BcDzA6haaleWWo4tqCuwfBkAJAKEKfF20QqpUvgGkbG8NcOcBmJzEAOsBRtTudjiZMp2iIiIez9T2VtxqnODw4dSC8nz0dCwxTrgCJ8TBJ4dm4tI/4dtXZEcUbk4f1KVoGGOoQEkbTmrKFiji9eGStUbrGyNNMzHOR5RxSRhKXi96hLYzZANqo7TeQ4IO1Em+x/JBBO7i2lSr8kO8HsDLfZqVS3Rpq9qVLNAMmFUdtILJ+nCHnRVmt2sFtUB3gJX4dEkUB76pbAaGImmMSJ1aSvq1eeQ3J07IEqW4ACFWj6nYWGcYI7l3LVy+SYsxcyUmfa/Y4ttld6EURlBSosEIE8AtYdZ0Rd5kmzlh/Vs0nUm+wvwoz6wqAk3LLJQZNV6KFp1TkooAia4bNgPOfCLEXsDGFDYrEViDxwOxgFAotoURdAWYHVp+VLX9mscN7g+PG31FlviRGhuXkVFjRDZMxOUo0mwXpanKYfzdMMsEo0AhXz4EKdApTwAedDD9OvSTv28S9WRCDqrUjryPSzWht80ca68ZE6mzlsC/WqzGX05qaIJ/m1oR1xwCV3LT8sAFxRN/R62VVoIaySwulFhKM7IyonEpRDmIwgDhRmKQSZcPAdh00/ISftjGSNtBked/Xx9H1e5Gc/OVvLyiq3pZ2VJmD3M5LJv9ueNo4sKBkjVNr+mnwbBL0PYR5Ev6vwV89QnwBuxre1PbSq8TiXMXTQ5KecDQYAs4xtOqkLzrgWtGGKI1AnaBU4iWvKfZ5Ju0F7rve5NHd6sFLj8aubRIXcsz1e2TPYfv+bbWvwBAJQZJGQJqLJPxKUe48lqCx5wd2mECz1wVFA1JdOSvDnkvBQJttbqqT0qN2Kx5VAtb6jVw8HljIjkkZlmHP6FjMcicE3gj/aJSJWrDoaTpT8faVhp3IyZIBpB0HE/sn83fjJJcilYe/R+ZPdXWo3P9rfTKDg2GRw+xgBdJmr3mSSi4dUzyZGsEYezhKXhRmoKk5zcBtJjR56OdqLXHNXOfdH1ip+bue9U1pfmbyBVUZF5y+wmpA94I3qj9jiL8qGPmbg99blbT30O06yMLQCdkAXiMAyLYaYZ4hAdhBZHYxaV9BJRzIZGCRpTDxpeFgn1jzg9wUfOYT9i5gBxpEt6fbw1S5EC+R4zBenWqRqBh8WSnTCWsqKu29T8XyU6L5+f27f7gOfFLxRABBLt148+dH7JQzewCtbXLv40X2ZsnWIR4+CFFbsarIbGsxZQVYp4GmRPR9bVrj4XS+5wFPlw2osvNqjxCjOX6JmxhqhrzWRI80xgszao1I3AZHaksTWZC4d20n4n73fJUyqoomVpMH/9ZWHA+gOqNiXMu7nGcD4XTNp1xCxDFwdkRWa9T0RZGOBQqBFx1yn6qj6pqn5KVkGe4aTPdLSQ0AJGfXdT83RhLtIin3ppzABOzO4IIrKlWpSh22b5yDpcxrsPpChUZOwLsFk/GDTIOtkcC7YXwBqaBrlSHjk2V5Ozq5QJDtjmU7sPn8/ZH3SLxaaZxpvDMOGtqtROlT2TJVX9NEr/psdb25euxay8JCf3nwKGMNE0AmAi/inH4uHraZtte2oUBsfCcUt3pY1xtQgslZn9McfwDWFyJHYmHl9DQ6YnD959+y/82KBRtFTkl96vGDd5bSiQekAJCcIEZRcuQJkJVb166plf9R1/ZsfUF67/X17v/bPfdf6ihwEAWdZaAKsuYnaDx5MXjp1Km2ewmEZSnbXMdKq1PUJsWG03qxTkpTtCgcWhVjMLE1GmsxMR4gyD6liyJ/1DFkObKzvtV26aVLL0En5EdgxvBSP0x2R8G7UnA8PHOEaMjUvtpz3fxB4QcFbKMCE7s/c2HMol2mSmd7m+OPC4n8UDlnLD9RmrZwAxxm820arKc2Ge8TmPvd51WxGXiu6988k88LVULuy81XKc6aIFmZlYRSQPVFrP7Bh4GMi06bPWzvrCEVq87MehBTajKI2ndSLsb9uCKO2DrBrTr9Z8F1jmxWfXcZyuFeYyzPOR9V++VgeDU6wlmMzHcCR2pnrBVkyiEkP+6vsp03j9WK/pMV1DaupKwybCxQirDw3GzslprWbaZ9bb0MqqAOQo2J9m4xWh3ay7+eF1sbHKk3UUcX+roDgKn418LoaEXOHJUhwhrlEAY+nCzSjWHuO16WvDCWKPltID7MtdiZJfY9UX2AhHi6r2LMeSEsDKLA1ZByCr3s14S8K+KGPtRWR1FietUw22YkaRpxNnlL6WIMTMIs6lT7CMCVCvvjIYz/6envrcCuK/gNfLXoZXvxrX1/jAB/DMM7/sd7/8y/H+9+OTn/x8X7l1C+czisy7eurpMDiAuqqrZ8RszSxqvhLfxDYum8qGbvhCnXL0YiznAlL2i2TaA0EzgWSWzQIk0qsBZ3patGxGbynP1r37MFzYXljcqCqOnN7Ldaiq7UOzAP7cCc4Kx7gQw4ESWVXv7yJyWtCsBtAO2AQhjdXMJI8uv3V4DYSEN7gULhvLHpuVukJbIRyHuNJcvGTva2qEhgVMFEsjnReR4+ENh3VCXeENZE6Kys13P4M3lA2mQdURjcpddNM0adqIp5PO1DVDWIMfc7U69WgFfPPtBc97EO7h13LzwAACsHs0oWx8FBAaqs1UtpihPHhdAN4rqMLssOh6MRFyKvWy1bgM55BVF2Nxub941lFW+qiz4A+MLL/6ij2z4scemH8wjmPHDxaHBGD23+5+W4s1ZNKl1CrVRQJgQdHm6FrklR/SueHnkkjI4u0gssIPxxZ4AsE8DKXB/AGZkqiMCSCiHhOwDI/kAkT/glyPPopv/3b8S/8Seocqbt/Gj/4o/sf/8fN698EH8V3fha/+ajzzDB54AD/zM/ihH3pxe+U7vgO//tfj278dzz03bsa0CqTW4jH6djdv3Nmb1I2LBhtJ+maplkFNYaqqNNhqXcdX6Xko+jdIQnPYcIyd3IWh2YLnFpV2duF+SQGnFJv6Rfe9kAsLo8P7y7WLNo2QOhoLgEmGrjJCAoposD62C+INexe3VMKqGTUcD6Cdhry2vLSfn9NwUYu8NifziCTLugUmXkZOnKJjCjdfa6jUfjGfq7mO3XvpNyunS0ibGzxOcFhwviYXxDXk8GyTTJuybpDMzx9MxCLDY4PSLZ+kjWG4z/s+vXDSfsX6YSPnipDh8CrRmvWx1B27Babah4GURB3R6fEV3Ysirjtu0b6ZsDWU/nJo7tEUbwbxRLrmOlMabGU7wgoAuZTqe3aFD1wT1AOxMBHMyiyjNQB1OaeqkQaMsN6OG99vHpP3VKdxMn8PxXXtwoLW5/puQjSONASNQi7W3zGIQfdeJb6MSlQtS6rKF13QVA35f3Gv0wl/4k/gJS/BX/kreMc7cHWFb/gG/ME/iM98Bv/L//Ii795/P/7iX8Qzz+Av/2W8/e34tb8W/8a/gb/4F/Hv//s32Ry/5bfgD/wBfOxj+y9hPQ6dzTyC2DUX9fn16NJYO9rXxWhYZFdRBp3INilEZ52EubVF0Vbz3N6ozw8VK4Kyc6EyLRuIyFKLpgaLZDnUQBMGSEYAdoI3h8dna3U4i5U243Ze2ZOQpUNFSf4dUf5ZaI4lOsD5oXSwQdUKH3WYiQrLXgBgs2b1DPL1fL7xAWzYaCMR4trN5IlSeG5Hnm04513NyMGJIXRYpMGndTuTwa4pLlLZD8fYWliQdmhM1HEdjndCRTH+Lr0VJaAmyiEvHuWKp7LABRViD+R0dMAWi30c9TeSOfKS7QPFPwNvRzUF7FrMoAMTv0DrZ/RgGBXDbou+euDLnilehGjHjwHbGDMVZJ5RsDBOfayi8RKVxtiLTHNLfNTaymZVpwIY+6WqBK+8znlK7nYxkRaDJbBMgaUD4tFYmbyoz3EV0bqZywfZIcftVMxc7tgJw+twkKa+WaVSUm20RQU+CZagIfTdrNHwcfyLbFlcuL7lW/C61+FbvgVPPul33v1uvP3t+KN/FB/6EN71rosvPvww/vyfx0//NH7oh3A+A8Av/iL+1t/Cd34n/sJfwLd/O55++uCtxx/H930f3vEOPPDA/uNSDD+1RxJQsM7Oq0YtQyzOXAcAdtLekjS1yIe6O7uQ78IGCdguO8ZbNaPdiHWMCdO5P74M8nY8TCQEeu19wY+3zFq/jl9pHcilpQYKf+bDHsJdtWHBWTVW4gOvu5+2b1rqyu/AL3hDne5iQEyQK9cFS0Z9VuABJLoXT9Iij/Km9GugToJ/yLiFwMGhqkOiosA8Da3KsVkBDw9KoNF+vWkdnNem3rBYvYdGoX1HIa1K4TkEp5lNcMa2w7C8VyUx9LQzZvwqESTRNPOiSWbHhtYkp50T92eWGZkRvtLPYmSrVpdDftANZz6cURp/LViyaytrP7dcNUuu6ZGBeElT7npwV88AavWzcT9DQbMO78YsC5vsvZs02hA7Lg9+KnJAt4yNGw6zrJD4WDKsWwaW/M7atY80g52XLqg8mYEyRMSMqWq9oit6xrrUtuKvAOuoamQKMMoYa4Qg1XH64YSHEpgZRyWH///0+pVB+5KX4Gu+Bv/dfzesDbv+3t/Du96Fb/zGm9p8zWvw+OP4iZ9wa8Ou8xk/+ZN46Uvx+OPHb/1n/xk+8hH83M/tv0hVxnFVfbNwHTbaPVSlqgoSc4YrOsjO+O2Zgx6CwP/lNq3EdQmqcVM0/onV6rC/pB3FglFViJL6wwSJf6WK2aE14PD35Z//yAM/1Qg4gNb6VSvCjPpvuWNPmsIee1DK9m9Bo32Nk9hGfGIGJew49M9CpFz/xZ0JjPxHaA6DdRH0cO73RM/2z3BFrNzGwA81Tf11mCyeHWoAd9UuIipUHhSRHqpU9i4Wx3WdmoRhmaMyc8u582QheqqU/2pE5N7IpaFduPryT+Qscs7qJOOvTCcyZjFou4hM9wtgkbPe2obpjZsM2+UohtHBTDCYZbjFbldDs+SUHrCDfUhanelBwJrbHmACk2HaB0ZY/g2Q4vOhdMoRzaaYLA9cYtgNJ1CwgkEt/9lX5pP9I2qMRmjGKYeoCBjKPxJizZMUFypaYLhwXUrYyc+KkKh1HqtGTmKbWGku4QhgKa5d3yLWZP/8BxJRtX9KogSBTS7yCNPB+ayiRPXoBBxNKhFVODds6EgoAPJMwjKSwNfjj+Oxx/DhD+N3/2686lUgwj/4B/iZn8FhPPdjj+EbvxFXVzif8aM/iqeeGj8x43Wvw1NP4ckn8et+HX7Lb8GTT+Kf/BO8970AcDrhjW/Eb/pNuLrC9TV++qfxrnfh3r1fRvsAbt3CG96Af/7PIYLf83teHNrD69FH8dKXHuxunM/4xCfwhjfg1i3cvXv87m/9rXjPe/Ce96z33/9+PPccvvZr8Qu/sP70zd+M178ef+AP4Pf+3qMWx6RIKYazzKuI2PHl9f4llvAWSEQk3KFCcY502wrKBZGEzaqjHXLX6EJnypbEANT1f7yupFAWYAqzz8VTjNpSl6n3WTmty9F1da6ejVXHbrpiNRO998zKcevK7lM99UrrgslXJFHv6YJvoKK6fq2LLZ1XzzmzOd5FweRg6xmbNmtclm6Zj1PBro3o9kB2N7JhI2g/asBK2SMgQEUEJETqJwZMRV3HulBVvaAOZY9ITGa4ekH1AGyQuplTfOQbP6LzmMFp5ZdI9sYv2ejzGT15iSpUM0VgYNLNxKTkSRkkttO+CGhXFgvfnct58R06H0gt1XVZplf0JglN7pZFekycQhLWqi39Me5/HtekjGic3oxy8ijcj0A4OCtHa/F1DASuQ9556hCSRTkae1MgFPDzCghQrImvKBZJZaLKOFPTWCN7ZticAFLKJR3iQiXf2stkPRCpTHRLnjd0/FYdyAKV2TiLoUm5EetdQjkGRqxDmg9pi8zLOhxDjHlzD+5CM1v4V/4V/Mv/Ml7xCnzxF+PjH0fv+Nf+Nfz1v46/9JfW1t/4Rvzn/zk+9Sk3Gr7+6/HH/hh+/uf911u38E3fhH/6T/H44/jGb8SHPoTXvx5PPIH3vhd37uAHfgC/5tfgfe/DQw/hmWfwTd+Ed74T/9F/NKn2vf3v/d5pg+OLvgjf8i34r/9rfPd341Wvwsc/jutrvOUt+N/+N/zwD3++NsdrX4vzGb/4iwc/vfvd+E2/CQ8+eNHgeOopPPQQTqf1vggeeACvf/16//Wvx7d+K/7Un8LHP37c4JGrze5r7OvrtKaZH9tu0iCV9F4kwZpiXg92tyA1sw/S4KikMunFFGrFwC+/igWrstkcUc12g9zNjmw4M8TMwZDqOPs3DVL1SFFONwroS78VNM7satkoOXAyt+wJk3Sokp2IgIZpOawB7cGi7fCrGYULtrMFO5zdUGdX44kIFzFkeFzEUG3cIj0KYUT6YAiQsM8kCKKT10MyGR3C1E4UxrSTMovyYfHMQ25rMV8/UPKYixcFf4DA+SZXq6si6rD1OCuHBGhccaVm/MWp4jmQoM+JQXZqrxBeMghu0EmfR2tJITIf757m46gG5uC5E25VeP5XvS7W5wMGglNmm+M4AKu2U3+9hDqfaJ50GQolXIBoGKNEhBAdtX2Ks9x0inqpsQogUdkOFGmg8xYidgxEsFKVMESU3tDz+d7hKBbytmZ026kpb+z8Yvg5xtJJREbeEcF8q0REkZvk6CZP283c/WiuUvIMdFSkVlWLVGJmq44gqiP46/Wvx9d9Hd72NvzxP47nn4cIvvzL8f3fj5e/HP/FfzH2Dr7ma/DH/hj+0l/C3/ybfucbvgHf//34/u/3zQJmvOlNeMMbcP/9+I//Y1/r37uHO3fwh/8wHn54WCciePOb8R/8B/iGb8Bf+2sX2//6r8d/9V/hT/0pvPWtfufhh/GmN+HP/lm85z341m91aP/1fx3/7r+LH/uxw5DMg+tLvxQf+tDqO7Hr3e/Gs8/iFa9Yd1vyet/78E3fhK/8SvzUT033f82vwYMPTvssAO6/H3/6T+MnfxI//uM3AuS0eCI7R9GFRUwxAGK60nk9N+goKmTYJpmGKFEau2l+RrMSFGcvSJV82yc2ozg+Omz1K6IIHpuWeqWoodOeiKiO+gQqfrJvrnhmZYqwrIF8RSO/1JduxrH2e3TIaudeYOSp2ofu4kPn1RWRQPMQqcCeNmrWEwZMROljjaeJ0KNipz3nBw8pq6iItNM5X4aClEXPYntZIIrz3jQcqqfTqffer69ba0RkSWdAl87Ruc0jA9TFT9EsWpnJy59k9L5M3K9xMhJN8tTAuLq6ckj0XEYZI7ZFjjKgXV4gO5zeLLBIaBIjURHSTkTceMtSGbnWRMThxK1LNyLqFjtSYEgbJV4Xm0YiGfXdc5Tag0dcc3QQIDnx5yNFUkWoHT7nXCDUbk1mid+WzhGYr74A8Ldbu1JFGmoIQWx1U9R83crq9RjYD1JQEGkBg7w8OZFSiei3efQomnSJQUSZW3AuBZkhCKmrMhGdTieiq5wMe757QaZu8KT8z/h0MXpuXi/R8nKv2slApcZ1NydTw6ix1MpAoewT8wWrNom18u9agt1GRsQRSM/aXZOhVKgowUb5otpaq8/pVG6vsEJFNM9VdvvSushGOM8jUBXu2ZmqKgMknUpN+mEc250+STcSZ3+6GkrcpBFA1LLwRqXMjO/RXG3m8s+9Nd1YUFWtKo8ozAOBEKHdnGc87dAll7NtUPo/arGs0GSSvArRVztxNf2S9JMCgggUQCOyfy6UTye84Q341KfwAz+AT30Kzz2Hu3fxznfiO74DX/3V+Df/TQfz1a/Gd30X/sJfwF/9q3juOf/3oz+Kt78d/96/hzt3/LFHHsErXoHv/E684x3+jOng170OTz6Jn/s5v3n3Ln7mZ/An/yQAf/ew/f/pf8Kf/bP4ju/Al3yJt3/nDh58EP/wH+K7v3tA+3f+Dp56Cl/7tfg8r1u38PDDx4EaRHj00dWsrdfP/Ax+9mfxR/8ovuRL3M9xOuE1r8G3fzuef351Y3z3d+P2bfzAD9wMjtN37NE60fRe/eqqFiohY1tbvdh14d7JHzizenX5YlnmBXX5rp9IF+n2GXCxNAyg2NMtRD5qVnpNJGZbJi7X0qMJvhzg8PZnX+Vavu5XpMVx/UDEzI255f38d4ilm6cJBds53jqDqt3UPzO31uzX3vv5fO7dtpD4+voM5dPVbW63mW7ZJrTIRTBitsslVuQtN6SxALZcKT0qDg+fyZGqbwFMHqDlRSIiapeiKyrecnJnCTh5Pg7/xq9D+u2Ncwo6dg0nItrnmLa4mK2qxDaVfIAQm8QdP4GNXuJDKdCV74v9Lb2MAIIaQYLCsNMYD3wM9o/jHzAT8DILATMDnDUQbMpqtOlhCzuqF3FUvybj12uZ6IpDVVNxBwe+JCqWt3aZsL+oxbyuTU29W2RYQbjdmaLcRmzW2r7WmkalttsNYiRiLqkqbpFzCNgVzSMUIxA52Pxo80vRRc8TRVlIRxGwQTxQ1dNG/e5p9EIl5KvORGgrGWhF5PnIF4E47lSfh/1qTtXzGT//83j00XUcn/oUPvhB/Npfi7/+1yGC3/gb8cADeOMb8W3fNj12+zYeeAB37vgexNUVPv1pPPHE9Mzdu/iBH8AP/RB+4AfwEz+Bj34Un/gEPv1pfPjD+PCH/Zk3vxlE+Cf/ZAXj7W8HEd70JnzoQ2DGa1+LZ57Bj/3YPEeCe/cuBmzu1wsvHOeSAFDFU0/t2xxTX//Jf4Jv/Vb8uT+H974X/+gf4Tf+RrzhDfjxH8ev/tXTRsxv+234nb8T3/M9OJ9x//0AcHUFIv98756ZYpXsYr54oWAiAibXH5bJdV/oQvoK9ZOIsqweVNXXx4ggIU/LEDljEjTkjxHDyuzM9f+JBtV5Nj+Zi4CFwJFXSTO5jqYpKor2jkyem6ZikiwZ9J7HzSv6VKRZeRQbBmVQAa0r4xToF3y/vjYa1yJ86iiYWfSewWV3xpHCOmMr5YcQURNB72dVZUYjbu2qqy6G4Hz5NJUmTXGOTZCEa4G2SPmDa1IMZSuhnchGEYLSdLliVIY+UE5BnCVzx2MkJ5gA0BwHtyvLundWx74oRe99icGcg1eOuhi+YY0tiWy2eshW8hjgDUajsIqcK1lLnRJKu61ehbDjw6oI4iuZlUDekZ12Cyh6YMByJVq+5fftuDj3DjHsQDiapE2F4XCkSQ8yM0vyjkUUpeVNM1armIr7vqGT0O7234JqHMy4VsGSbloA1HjpOn7SwRq1LjGNnYTskVbfzMBGgH5TxOiMPQm0ebNRh9SpuiKHiLJivXrIfwg0y6lGt/IaCiV0Ugc+/VWqHiyxxKXmhxMVcOIHw9SkWnIM7gvVYVHm0Oo0ZwfeVg7eqfAmrQoA5zN+7ufwlrfg/vvxzDN485vRO77qq9Y4ieefx8//vNefOJ1w7x7+2T9bdxYAfOIT+K7vwvd8D/6dfwcPP4ynn8ZHPoIf/MFhcHzFV+BjHzvY5njqKXz0o/iKr8D/+r9CBO9613GgxoMPoh/Yy8fXhz6Ef+vfwiOPTAW47Hrzm/HQQxfjLfL6b/9b/NRP4ff/fnzd1+GTn8T3fi8++1l8wzfgb/wNf+Dhh/Gd34knn8R3fdd46yUvwQMP4M/8GYjgrW/Fj/wINhuidpJ8EryN5Veal306HQI6zl6qb6oZJuuKFtaPfykXEXWdCFdClTZ/vAdTOKEqM5Xc9TQRiMj2aVT18DwXLTaHzqazPZL/Lyw6EkVn6+TiVvqCwNo7Clap2ByJ50l5H8loLfv6kltd6QMX6l2UCRDmU2uxz6Kdt1CTHf7QasWgrM6AWMHQLJ0PL4oVz44TVdfErBZq18m2yRSqLCIdduzZ4kDbT9k41tk5TbyUuE5Zt51pshs0c2sdoUxs/4lBRp1V8SxNGelcGL7HQ1zqNOGtwpZ89ewZHYO02A8FrDIZ2+yoatRbq8HFpXfzqKvAHXUSB2Uvy5UwGd0HBqJGIUMAAC1ODusLJKlod+QbeEXfT2bfJL6KBNI8rKagbUvBXa9D5q2j2x4bByzsMkTjmntc5W0VBfGhYRBPCemlVZH77aM5nRSxm3+rgDWOy8ds2QjqYVZqVDfvVDwPaXRWYKr4kvNI2aWw8wCcfH+9yrKNRac3Jb0rraIpZeKGiwWnEcn1IhYHPFXEuvv4x/FLv4Q//scPlHQs1nE+4+mn8dnPHrf2iU/ge78XL3sZHnsMX/Zl+NqvxQ/+IP7IH3Gb44UXLiajtnYxhPNXdn3gA2DGl33ZQczHG9+IT33qxWuGns94xzvwJ/4E7r8fzz0HEfzm3wxmfOAD/sBLX4q//Jfx8pejcs5XfRVe/Wr81E/h+hrvfCdm798glLJR2nu3YIY4usEfrh8OdUyVXItokE1e2N7tdjTB2t1h7ymkxijm6l624lehdhqic29k/A25fzqdUlJQrLAB9DkaIxPuF2l4SbJfMkTqK2MsR285VKGZugRjx4o9FOpcI0H8SJpbt0/n87mfrxtfATj3e6Tg02nR0Fq6K73XUIZ50QZYMa2LHp0ykFWkaIyrGKMdHRgi20BSjzWVclK5XZ02IZ4wzzdTAfCCc8wEfOlOisr06teph5dd4oUedgwsc8pF3WYXYeQdGn+XUoTmOVFeVDU2Wq0/lSN+yBfxSnFm+mGuAFeNOzqdcFXY80Y7/BBR+VWLGT2WuZ+Hcb83PiCd27/wwGRxzjbHRB6fDyQ+p2OAdQEzwVCkaMORnTHBpvUmUhRURCVl1L4oYlr93awJl5/0TBbe4VyW7ZubJ7lX881iUY3YVfvlNKecUDGcxzoJ0QQALtuK1Ub0Iq8bfsVjysLKZrKm/edLpSwefBC//bfjJ3/SLYx/9I/wjd+IV70Kb3/7+iQzTqcDr0a97AERfPzj+PjH8a534W//bfyn/ym+53vwvd+Lu3fxj/8x/u1/G1/xFWv7r30tXvc6/PAP39T4L/d6+mk8+SS++IsPgHz5y/GBDxwk6+5jASAyTJMv/mI8+eTYqfnAB4bxkde3fRvuvx8//MO70VY1q86Eqyp2XlCe74WZ6O0iItB4JqXM+ow7CIYMVVXf1llPe49eDIzwK7RijBMR0YkUdtz5hqmQbrVknnKKvwmq6swzXR448Ycp3PKrREcUh/7lVWRJeaoXhJ1Grt2FF33WjEOVwFFnL6MEwqtppWMb88mENgBCs2NLVU4ahb0PVwBWZxqj8ZFokPBQTaEvAnQpwFN1dookNY0GDzcm8khR7exYpRSsSoQ4PDYP570g6KNwiJDE5lrkHTlWl6PhJ/SWKxVwDZggRNqt0XycWDsZN4fGylCQB4bEsWflUPXOlh9Uo96iukvDTGFiivUr7VwLILNdlrETWh4fnk/WJXJOYjX+jBgGk7sJVa2N2JrENJwLRtWYmENlrLPXoaIuFXm9Od85YK8dEiOZI0uiBmwO00rVA1pNP7rK13Q8jf9VxbqIRDj+DURzLRyaMkVAzUMp01S/DrKZkZayVteFymAMyR6LheSCaHEfiFjEvnoppmKO8B5uwx7WTFabyP9FFFw+Q0S1bsnezhCpqkricanrrAle9zq8/OV46KHp/q/6VXjgAfzkT/rXD3wATz6J3/E71ozQb/xGfN/3HaSJ1uvWLXzbt+Hrvm69/773efzHDe1//dfjySfxvvfd1P4v93rySbztbfjmb8ZLXzrd/9qvxZvfjL/214bv4TWvwdd8DX7rb/XAi0tjeelL8c3fjLe97WJuy4tdi9Kt9y32sJ6xvrwb6i2jQT3cT6BW7MU+2GcwnU63WrvKncsSyHbA/CPHASP6OIitZNUrU9beyddp6EIislDHmTgtnE2ExGK1vHxNAzWP2K9lc1LAJaVXUBNjVbsccsT+5JG1FI8d3Yy8A6gq8QnUoJyVsryukJxt+lprFCVJmLnfwxXfuf/OQ7eu7r/d7rv/1oO3T/eRjPldzL5xM6LbQvSEvlHOKcBIXQGtUWPTqBMhxXacZQifiE/UGGxloKzeEoXsTTnWF/ohosX4S8usApYScLteJCFzUXs+IzkgnZ7ZZ3bjsgmMfKX8HTwVxpLOQE2LBNdWyGKRZJki2FibMnK/YKk0yx6TO50aOEcKoyXrARO7oUwxAJAIRozq0teh/Fm+qgoRapB3oIXyFo7mq17qC/daLpzghzJO7Ry9OFHLNAEx0Dr2OgoARXnakcUePDsqhlksdhT6q/3efN38zAat1vvl1yC/LimSs6AihKKsIggC7dCuXbQfF7gD4FUBxf9ZgTvVfkIrpU+Hw4tJz9Pk5TzLKFOqqsioriNrnYjOXUzqqHageXJNDWp73/vwxjfiR34Ef/7P473vhQh+1+/C7/k9+J7vGTU2nnkGf+gP4Ud+BP/Nf4Mf/EGczyDCd383HnoI3/ItL7Llce8e/o//A//hf4iv/mr87b/twRa/+3fjLW/Bn/7T+MxnXrz9fR/n/83rR34Eb3wj/sv/En/jb/hZKl//9b7Lk2U/Tid8/dfjN/wGnM+4d8/zYJex3L2Lr/xK/N7fi1/4BfzIj/yKwamiQT0oyAObW2vUGMrSu5vqS10BVS27J7vQxCwFWjupqsgIj3cF0PPJtFMBgFs51KE01KEuanW0s1NsVeqbrCcgYqF8yBxa0MqT1mTdVYLUtQIdMgBWKbYI2bx5s5Q8bjO0tW39mGUmHQAEoqon5qurW601gK7v9evrbmG5t6/ua63dffaFp59+WkQeeuihBx+8/9bVfc/eXTfyyIN2R9BZ9G6jrs+afGQiiFwnlpZxVSmsMRARIVazNCp+rNBc1ccxNfvWuPU+Ka3aVJW5Q8uWmwuhLucM749VYNDFs5Yp/gCNPCuxvmhNcQNhKg8TJvukpLe6VesVXDiYIwZeV96zxyLhi8ESUc9ElVgKB/Y4TvMoRMuqYpEiy6YJky3Ei71lmoIboKIZJUliAiZfv0FfErkvnGicuGstmyONmWUx9y+UFdlu1sL5L37tU7kXFsvhHA4q2GbXldOGLLnvw+iw5BAdYGzq4lCMqCqojzLBBVTRM821PYPXnISijoAJ5MoFEeTkzKdmBlTxq7bSHGM35ADAiS311gkljQnxtOIs4SVkpZaYToDH4TORsoficRwIZJzofpaA18lfgbMvM6fCQU89hR/7MfzhP4wXXoAIzmd8x3esfoXnnsO3fAu+93vxfd+HO3fw/PN4//vxR/7IsAbu3cNb34p3vhP79Y//Mf6H/wG/7/fhq74KjzyCz34WV1f4q391qmbxou0DePJJvPWt63HwN/R76Tqf8Sf/JL792/EH/+A4Lfa//++nk9tu3cL7349f9+vwnvfgfAazez7qWIjQGn72Z/Hn/tyLbCoB+NmfddulXLd+6cnOxMxU1zq2OT2FrUF7KE5FZEkZC43NByIUSS0mOJWgHhfNIOL0N1oxZ9GFRRdeDQncKjWnfISussC2FYsMsugT98VV9R8d3JTYWdSNXxYM6/fNbdCYqUlm2SljOhvMcvCXECqlElsQCtUEq5WdGCAYcNLFDtXzqC5ncLPfcZbOjPP1WURu3751Pp+vbp269OeevadnkDYSveLTidqpPfD883c/8YlPqp7v3r37wv13nmrtvvtuf/Erv+jWFT/3wjPcpMt1F4jq7du3z/3aJi7m1/eWtHcQJRgAPE9BhgfYT5Nz1HvN9optVb3lOQ4D4fY/EFOEMSZB+lF7q/fYFEBoPiLzbhkWBaPAUZ1ii0owBxaF16qU9Mg+XD/I1Oua/YiJ+FVELYJTDjJEKrMMWuJysIlahi2B4DFz0Ugqlct62ipGBZIjeQTsx+LFTxE+KZZ3sK0Nsg4TQaIR24M75pf0A4bBFL9ScnlkWgIAutf/QFYNJbf/Uy9Mh/UsplL+JJaTk0uXsQzwrqp6V+iyFZIWbUSojHkHkCefl2MRnc1P1ASI4vMKgA0/WK60JBYDZciH+X6Q1qgwOhX90K0etM1I46vAv4aVLKMTE6EFOCa1atCAe8wGr5VdNhU6P/bgvcce0mJSBDeZR6QXeMbWtoh5I6uU6wDoHR/88TSvJjyV7ABVhagfCjWnouSSh8ox0EQjaHaqkKIeDUBEr/irf//x//s/AIBv+za85S34Q38IX/RFHtnw7ne74+Hw+sqvhHn4f/7nVy2bWvnwevBBfOmXesjIBz5wMTbzhvYvdXFzvzdcL3sZXv1qXF8fw3M6wc47FVnbt7Hcvo1f+qU1DfiG61cM5xeuL1xfuL5wfeH6F/L66B/8bZ/4nb9eVd1DU81NkunrqA4y3UlvzSmfptUPOfdZT+L2B6ayYMXolurebM1LVqtqli545Kfe6dZGvT74QXzwgy8++ne84+JPN2vTZ54ZezS/svYvdfEr1uJPPHGTuZDBofv1eY5lub5gbXzh+sL1hesL1xeuX871yr/yd68fuv3kb34T0FXBfMoQi8yHB1DPCijByFYvwUuVnPQofXFza2vaE9W9Yb7W4YXzQI3pmdkJQ+aHuff4I//fxM8Xri9cX7i+cH3h+sL1hev/M9fdL3oAdFZV8tKgsX3pyn0ceBKXAF6oIzPqAJwwBQodXtOm3ciE9i243Zcytrso0izjwEx/Ukv1xKff9IqrR28/8X/+/XL2kmIVkty4wWjWIgBiP0lkCoVCOGdoqeXu0GZwoqKrqG29ewCKb/hFzAnJWmhg7iY2p0eEl4j0Lrk3acnr440It7M9Kp5rFljkoucNx06tbUpWW3AdKEU8GqmIkCoTsxfnAYOE97cUtplru6sjbpkwNisT2NicJoHHVmaAkuXfJ+VQ1EKYNqfBYGIqWbWIDV3/CLF93AokzduPAMWRJdCjUK8EWwnIsCbktvoUMZfhF6CS4bnQ/1HY43I5JlFooLZ8ACWmgcfr5MH3qqpNa+iMPykCgVxdXRHa+XwN4HS6YiYRPev105/77At37z7w0IPns3z0wx/51JNP9a7ve+9Hbt269fxzL3zyk0/du3vvzp37FPS5pz/Xn79+8MEHb926df8Dd172si+6deuqneg1r3nVww8/9syzn338ix69fd/p9h1+4MHb1LjLuXld9lFCbYx9AFkWGBpnl5RqRcm+GYsQcW8KLtgo7WziSMYcGaPmUqfUQdmnrLbsc+C9cBFoTF4pP45cISKaarxKsEM2XCWS91s2ue003PFWUoWuctLBCBkSMVCFXCPOKWtzqUXul5GWecFyuTSCOBSLTKNE0dyOkNebUmQQD5RV5romo1/Z7pWOao8aET4osYfpoU9NNAVaEXRghCSXr1OtbyrYXvXfWBWX6dguIxU7kmUCJn7OkTbmzNXx1bioLsGkRW1NAkHHHNRQhJDMqhoREkWUwXPd5xylLAQSCsldDvnZf7CvUSgAOmKDLBs1OEUsp5AU0DsfferL/q9/F/EKYKNTVfdzUKS+h81hGAv1mkxeHBCnZWJ05qK9kFxenpgXDy/+jK1Sfc+4v0WUfE6fVn3i2S9/TbWSdptj8a/kdY5wvCQOQxyXE2t3GUREIInTxcZZZcBISZpPIsDSTjC+2EE4cMWwRlRpHCVVj70ABEuhyYJzniqqcRbhrhhwzFPNJh3nCxDlEXxmNE34VL8M1GqZst1YnrS55uYDLL1YobCK2ZH6NXrkcX4YAFWI9KSlAtiaGZtQmcFBZAWIpNLDNCMKGGanzEZ/Ubegp/j9IAAwW94Njk0RxiiB3ThtoOvMuJujU5fZpDA4xiFxzMwnACrO1feY64v37t27d+989+5zp8cffPiRR5ToXe945ycfuP/q4Ze8772/8PN3+xMf+uBTn/7s1dWd3vvzn/j06XQ6nU6PP/wSIiKRZz/xsdfcpkcfffANX/66X/NbfoPK6T4548Grz10/+8xJ+mMP3b7dzip5JouTLh+z5/g6nwZcERdf54nmSthVw5f5pSF2K8YyzP5QZZaeJzlQZUh+zXqs4xiwuZBDngaywBncNGSj3WxGt20ckQUv3bEeBO+91BjtYpzN7Y8eq/SoH0JZT9iwd1VtdBbhGyJnLu45BFfczOPQiBqU9yMO7K8dtoftitGVAh4+unbISuWQxV5bSAy3EOwma2xZKROhqZQw0h2iivw6BA1TxUWoHU42SnSb8z4T9UWsdlwYTxCNYrMXl4jlp6zTF0VTZgpXPdd5yfXzDPZU5+YCkY82Tb5vw2+S1kZU9TRUSLGdokEApLCDuHueIUCUpo9X+rp0xvhp16nqDo8RfRo/Tcp+AUWrzUEC2Wfa6wNinoZ7T3/yuWfuo8sulkPu2n+qs0VEWgRWZd2RxRAiwk7iyx4UHuZtgeul9NlBd3awYTauxcKt/D9jWC16P+BRImY7Ns+dDOGz0czdanMbFrQftqQNWT3w3t61+s/EhKNzuagU+JqnmKYqWaJxyIiyNqjOdRu5GEsAzPdQ6sL5zd04oBTZBZ+H0gGRQQnAzrjyd51PC349zF/cdzPaV6X5HJZL16GuukF2TPDLSG5EaCzNMxdoqsZI5PMydkDVq1qd9Qxgi2lHa+36+hrArVu3VPXZZ5+9e/eeiFy19tBDjzz0wENv/Qf/8Jc+/DE9n/7+W//uEx/95Pm6Acx69fSnn7l169ZjjzxyOp2Y+SzXt26dHnvssYcevf+RR1/y5l/9hje/+Y0vffwVUGXGdb97uqZ7/fnnn7t3fa/due8W2syAUcw9bwSmAmDuA35fULFq1LOevVNUZzeQrKEzI99etGY+bwZNMScGXY1nOA5/ADCKJCIrMYXcSE0MAGyp+6h0u4qgSg+7FDV3hx69EmJn+JWJiDeRWaklWtjvHDxfnyy/LmvIA1wtQ4g2NXALRcdQqG441M5mSTsMhQokFUzqvAzQOpclM9n+TxR+KHUFjTBQSLWnp5aAI2FSNTHK2QsB5OQnq2+pLRFXfCpYtJzpE8XIb0DqwRVHhaBWYEMYvqMo3zg4Ii2GGjBBy2onK6MDZx8FunQ3DipBqp7jGCijWM8aUwVN1YfZxG3kc5lNIVp5KjFzdBmGD0pmHer+HBLbEdKZJpaGmgzVHoJ06t5o90CpjJTuUTXoMtCrbLLDcpbniUhiPmbkKrmXyyrB8WIkIkNfSfbix/WrSK9FjZLHcstpssAAIfcEAhNbNif3uG92jEIIccaPJwMGWhbS9/WWVRgGALXz0LVfwGGBQdJasjGpTtYSlStWaXaAwmpHIyXLbMcsViDZ6cjMLt7LbPK8lTaGZ2c4BG4sAROu4Ic9NzoKSVTwA2DItc/z2gVl3pzshhzp6M6MxnAc28WDC+x1O5+6dmFfT7euVL0RPzy3q4jcfzqdz2eEwSGC++677+GHH759unruued+/Mf/H//wH77tiU985omPf/Z8lx568NE7V7c+97nP3T7dTw9ePfDAfY899ti537tz59brX/faL/3SLz2fzx/8xQ/ffeG5++48/OlPPfPB08dv3RJmfPozn7p1uz322COPPPwIN5xOp3vnz1UHFRHZarW4jkfpawDAOZJLh7Wh47Co1d+AaZFTZEUwVNVDAFrdmyvJjdUsSH65YXKBTnlyfRHlVxHkXu6DFKVo4TT7ld/tFRcLSlMLpTJmXhXI3FSD15iJynVz4vciVTCzGApNphzzhg9WgC9+pUSa7qyYPL70grFe7ycqll+NZ3LIlQD8YfsT87LL/8PRLv0uPWJd9uwrvbmpsq6/4bGF2gPalAPX84SmAB0hAUU+Ky0dlvkNxDIVS85HREIdEmoLk3kX3nAGAb1fMmoZypj9N+arzsdn52XVnqOdU5qRBReA6uk0uFH9sD5Las25Ua/QSMTM3QSL1DxSTlUalwAEBreiaRqxpWvaLJwMgLE0d4FdDjVNwMhWirGCyaktcQlxp1x2hrlinMBOaEC3mid+04qGdG2nU+9ddewWqPbee5yguDqyMivH9Qd7kZwzZbZzg4jItVGPMgOwupAxCpwBphOhEZ+sxi0A0Xu1JFGWbLahnuu5f4ZCkXPvWbo+IQyANa2N/Al+SHCZnThqJ05Ys4OzVEQaiJmvpWdBSRFx9wxFNUpuUZGCTImweWK4lZPGOgAlsYOClllmHXNNXthBVJWLQK8Kg1rzcbjaVjDF0aZGSFqN0aKcbJOMyEtkUkZWJzaIKA2FerS9YUpV010MDgx0Od2+1UVAYo0y9O7du601Jj6f5fb9973wwvPn8/nRRx5/4YUzRE7t9MJdPV/LU5/9zFOffpr51gt35amn/vnjL330Va9+2fPPPf3c88/cuXPnoQcfefe73v/RX/rs3/qbP/7TP/1P71zd/8Ld8wP3PUw46b1bV/df3f/AA621z33ucw8+dP8Tn/yoyPmVr3zlE5/4zEc/8vEP/uL779x3+vLXv/ad7/mZp57+7H0P3P+mr3jTl7/uSx979KFzf/6Tn/7otTx7586d1tr99z9wdfuWyJlP2hoLOqC9JxURERTONa01L0nuAQai2gmxLC3k53OrVg8gsujVdp0JBOUOqGL1syq6RHX2lATMzonqNgqGuhKoQpdSpIg6E+jm8fRFMZG697CUtDTXWS/h8JztiHk4mYiy9qsvMKbxOvUeLeXjb7K/MiBWq15RredKeBqnRfaZX8qhfeF8ldEXc7VyrB4MDO1KUNUe8DcFRoEOza5UmsnjFKoBW1M/zteHE/pGUhgyc4aMkN4TMECKZgRApI1U+TTQPk2Zd9dBDQxG+F69/aaOc1afVusnSGVgnm2HeJ4dtokdk2hoEXFK8APMADKfhLi4DseK+hG9+xatYfGEk2ZRNiIlJyfig7RS9YWx7XX0IBL/BXQGlMj8PE21ERpxJ3VGMwE8TnZVQEkz6ogERFZiJDewZmS7AwP1orvgF4ArE5KA+bOJSGzqVUHUjMBEBMoRxeU2gLV/SqW7oCk/z1Q1mw++LrdQlulFCo9IvpGsuDSi4XBgEDP3UZVs9LsUBVltjmrRl2aHAh62gtb+8xOBRFC33wh+IjPi0ATXTjknVdnMN7MRFfMYK4JdHLAje3+BX8SKBkmsc1L5rV6i5fVtFlZUJ64uvVJwtTci1VzVcXr4eDJbcNQuvY89VEyX16CtdzkxNANp87LP+OAT2ki6yiy/KQQisMc6+fOsROaHpzgPE0s7dfYrrnLM01Gfp9Z773b+J6sdtnbn9n3n81mVbt/30HPPPidCwK13v+sDzz5z7/Wvf/0Ld8/vee/7P/zhj4jI889df+7Zu0984jPPfvbTr3zVy/5Pv+0tL338UdB973rHh//uT/zf3v3ud//SRz59Op0efvglL330pb33j33k43fv3n3k4ftuXd1/fe/e05/97KOPPvqpTz55ddX+1be85bOf/Wxr+OjHPvbaL3/Na77klb/jd/z2V776Ve9633vf9ra3vfD8Mwx5/PGXXt1qH//4Rz/+sU++5jWvOV/L008/8cgjD93/wO3bt24D+sIL1621W7dui3TJem7zMmCMnajExKmuU16n5vO9HOFiNc+GxVllyzL1qlojr+fuuUS3ASZGdSFa3aozJdPRkSE19bWLpgvjaklsYnUVpw2dMRanOvOnzuxfhUnQZCwYdMC5SDNmltBGFAfBV86dsEEConqwQAnX0zBN3FtQ4V9lI2zRmTXiAAtWHEFhEiYaA+g9oxxG2VIxvazqjk03jrqqiuxDMLSNVUQgc+C21rxCtFaLgQJER0epEYmnO8yyvfztfQg3inX9WCoHflyk9N4rqPGeGdu29BOrVWGYYGYiUeU4H9PDPDd+ZCt3p+6DJIXmEdz2QLUPytVG3XrTaDAvAOXaNYnKjw5QUhWy45LiLIuTnQ2jE0EAQJftDMCYhUH0QdxntUqjtowwJ08DbDk+NauwM7VqDf9ghgi4MdBtUkXEVzmYo3k3Tlt+NRs21Z5NnGrEZnkwZahP/xooU6ZR8Z3cnBx9UaIv+x2eACGKJ2V4ZVgcOUS23RO0XkTDYkYYFYYd5BsmQ8/538uyOp5BysSCuoUZDkRbthD3pLYDoKMzcTkV5fCSRVhrlmQeFupeZniQTTyfYtQF1A5/MjbAJdItjZjZzIpTP+rxPjFeVRXfvyznnlc5hTIL03AVS9i5yw5ARBishH59pis6K65Ot5muPvf03Weeee6zn3nm5372Pc987vn//W3veOD+h1Wu7l6riH7i4089++wLn/7UZx976OH3v++JZ5/5+48//ugzzz79jrf/7Cc+8clTu/WSx1754IMP/ta3/Ktdrn/+53721a95xcte9rJPfvKJj370ow8++CAzP/vss694xSt/3+/7xl/1q970zne9423/+99745te9w2/63e+/BUve/jhB5Xw5V/ypf3e9f/z7/7E1a320pc+9vKXv+zVr/qyW1f3X9+TRx997M59t5544uOAvvI1r3zk0Yfu3LqjhOeff/7WraaR7lacPVMZRPUQpWO/tCmqSfnNmWXHl3LN4ChKJbXdQL6q2nq0xg1EwstgZ1Tu9nZo3oMQ1xYUf6rGmjUbhb27CKXPw65KA1f9yC5g9+o7zgHZhAZg1cers6eniWwyqoerJm1lzeSXPAtwmP45zNFDdCr1gcXi3L8eiRTKgA4NHM6xorrgzfSLwnN9VDU8GQpA5tDLFOZbXfCaW2E/SLflSpo75tF331uvM2zazb25gQdVWGKEZSnOAAPAuSAq0ak65LeW7ZJqGCn60Ik2v6a5xmA1GY7mA1WLvFIAjdlsljiBKFa+kfBERB5rsO3dlHiOoRGIvMJs9ldiftVd157M6O+cxN1Z2zYq+rDCstOFDwtVBYLS2jXDsGtdLkRHU/nRWLubO1N7s1gO296I9YfQwV5dhcSs7wGwumPAxwCTMNBRo1Z7gLGEeWrKJxpRylztzWUZgSo3y7k7xcE4YFNXaY6Xnp6rcswmAEIPWDzuFwBIUEKHl+NEd0m9sP0C/OFbLm2m0VHR9wZlNT4GWkLx2O5JroG0/I20Q1+m1K7z8+ya9qDdCf4k1PwboIqIGCGRrUWC6paRjhcNn+4iFvXlkzRuzu06XjlEWpUvtg0qAor4eeORxnx9PqvtuEGuz2LH9XzsYx9733ve/8IL1/fdeeglj37x+YWnPvX000995lPS+fq6371794knnpBOT37yM3LvWrV//GOfes+7//lHf+lDqvrFr3jVc88995lPf+rhBx783Oee/chHPvzhD3/k9u2rB+5//rnnnr9qp/O966t2aq298hVfLOf+Y//z3/zwL33wwx/50Esefezv/J23vva1r3344Ydf/vKXf9mXfdmv+8rf8NLHXv7TP/2P3/fuX7z/zkN37tx6+OHHPv3pJ8/nc7tqDz300Gc+89SnPvlJkNy5c4uZWmNzeUMVIO0uCiic9qoVRR3F6zPPgviJG8zEVgE7dy6OnQoUDkLyNZaTxLkUclYMft86FfZNzKFsKlV0sgNpVr+dTiKrWlQHDgYANSsYsdYCsCTxptQVFVuwdUggwRZaVAksrxSs+au4fFOFqAe9ciDK64fvuvAsZ47tdqN/2xxSnR4bb5HJpUgWQ1QW0KFppucLz9bec/2p8F34OPcu7Xu7Kx7+j5HVYngJgR+DNcuxrDpQGtIICajBoTZkYiUhX/cWYnDVQUZFRmmUkHc9Q414yhaBdpHJ4TfGi/P/i7I//bYkSe7DQDNzj4i7vS1f7llZa3Y1egcaAEGKlEiKlEacoUYzZ+Yv0Jn/bD4MP2hE6WBAgCBIkQAaItFoVC/sruqqrKyqrMrMl/m2++4ai7vZfDB3D4/7skAqDlD98t64Eb6Y224/iy8dsCOOIWzlP2niqignL0US0ACSfBi6PpB1v4qrt2PC6d0hxpFkdBhAki2BqXYA2qZtwJ/DmUq6VzLDsrIXDC1RQEQDTywiMVaJSrCWxcEgU+Y1ciunVB6kVqiIlfxXMvxnVliefTusvWRRRJFgPgSvEYvEBoM7Aua1184N3ncQRWAaKWr1CrJwrj2wSF+9xiIAmvoQuwno3BkTE5FMOQvbFotZtNcMwI5ZAJg2LbIqAUDc0b0GcRkAj5GaE1HGYwlACLthztdeu7qRDDXLNIVckKef5NPUoCBEh5qkUEfPeYUQo3s0/dYPqpPiSKTXoAcrIOLylb8u5l9j8Qy3njk2ykSVLmbnMEM8J6JyBJmEmDVHk+OB7LLX9WrNdQocrnyI5ouEqhnmWJELkMpMwBDX8NGHj58+fdbU3Wg0YS+j0ej4+HixuiIyz09eXpzPy7IU13nH7DfLpTjfHtHBZrMajaqDgwNAbtrt4dFssbz4k3/1h4vFqiiKoihOX10R0WRctW1LRLdu3bm4mP/+7//B5eX5arXabpvFZf3zn/16Ov1L7/2bD974jW+9//DBG7/xvW/9g//yv2uazeqqXa/qybQqbbFaLo5uTN9++93PP3/y8tXz8Ww8mVQCnjLPd19YDiG6D2Ex8+XCmBOW7ZS6MMVTLOhJAezrjrH0q877tJ6ILIFu+xvy+yVmh8SvQjd5xP4sR08nRAU3bLpI0jn07PaWdzjFqtDIrucVsue+7qvr9Q4AACigjolYlBhvw2D4JQGfTQ1DwkvIWbpOnCpgCADEhwpnlbLpvSxOS7D1cz0CRLsNS/snh/jywOiSaESl7c70lf7O3KCKTCANNVnUvSIoEpB/RMTaPgMxPke/yjqcST7gxHZ8NJIZEbXxtfIhZg/IkpmdwvkuK/9xAHS9yFMFaoSsgCRDOWSN9NpqYCOQ5QD17luJ7rDYDjgmEea4EsnJkfT4rCgnrhaYNECMcShQRT/sjI8JoQwo7EMkJVN3Al2ngzBQmkH/GXWdazoCoBcATcQWEBGf/RwlJDuB1XTFfDHji3c84cFD1YcJAEnSMgkARheKFwGt09VoDgwIK61guNTDo7SaCzz1ZUWp42X3LMG1DwZnIwY6dWC580ANKU7ZTBCg00SFRJgg23gCohWlyW3XonfppUF1eI0lh30UUAZp1bLj2cvWOS5UcAgnex3SQeV8sq8PpafPc2a0I8XzmxMjTjfEpdMqfmFJDvDEs3YFQ5x0X/OiK673U1LRMq4aGkv198dSLgGRuPsYUgU5q3dPnw+mAyLhHnVC9vADQyJRBdeDALOC1KnSCYjofTS8+sn2LHWo9KTbgEWISPuBJe+a9977zlrrXSsitiq3Tf2//cl/+PLLZ/fvPXz06FFVVaen5z/96V+/ejnvuq4spi+efdW27vj4yPvterEcF2aznY8no+cvvmi39Y0bN7zv2rbdbNbO+dVyMxpNjo+PNptaGIlMWZZd141GI+9lPp83TWOtvXPn9ltvvfPk0y8uLy+rclLYCXfrL7949uLp8/39/fJf/NHR0dF7771zeGPv9p3jG7cO9w+m683KOTeb3vjGo+88ePBwtbparzdlZZidZgoD6AYp0QoCitOjvVs7pjmOWbVOX8aYKCajOkTcZfH95oogIIHtiYpI+v3Z+VX6OAciw0STaYuTuMKY2x+/p+Gz0t+BfnqZCpHbAAr7IZGkUe1awOErChYwhMMRH3+tHYFOJpfikh1YDk3RMHVfU0SHsE8h7S48h5k9AiZbK6qJoMHcKHcHS9pj3WHizCKCaLPt240fxSdkCpyIIIOEREBSh2j02e5o+fkuBkrDUIsH4NT9n61JEiJRTofk2V7dCQ8EL+xFPCCnJOJAEoAqwgUh6jT6cL2BYxpy7uGgniqSDd+vXNhf3FE4tBqBJPVJjVMehGZ27FLJVPbIefr4jva7V77NwbQGEUEWQAHQZad8s0QixA636kySGI7Mxu+GHqAesEpbzwOAUAdA2rs6rg8AmBDxELJ5u/nhfHalYJy6T0uZcm4JwHO/BLrZzCDiBQsYLjGnm8Mn3otLhjunCsYEiBpsDrh+vZay42b0aRb5gTFEUX0ZeJy0e2GcOAl4ddGmCSVcE1W9r4v2tPrpjdmZ90n7CYidr1vktAvD4QEAAhhAzZHWSFv/nQflcEPqGSoZ+Qjjtz2CVvpVz7aiJtQvb4hw6UmglGdkEvAL6GaltBUD4KMDOYutQkiA5aRDIMYk6QE1p1eHPB4dMIIIMncUDUvhwQ8lB+JRnKIwCz+0yaLHqI8F5DISmTOFA68pHENHt0T/HAoJY2zrCmFpAZxzxhAikoHlevHBBx/84R/98fe+9/0333xzuj/dm44evHH78GD6+JPPwVVffP78048/N4DtZgvsgRlQjAUAbjbbb3/728fHxz/60Y+890VREJqqkrZt5/O5MUVV2a7rBJz3vq7roqjqui7LkplPT89v3rz57e9884svvjw9PW3azWQyPjzY2x+Pq9J64cmkujg9+/DDX965c+edR2+9994777//CEtazNv5xdZDXTdrO8KqqgDY+2QMSCqBY2aAxKQGGl4ofwgR7kgPwcmBwAoIlLagr0rbpd54HnpXfNQMJIPYShdmvaMCLYWDNuQMSW0liOHYgaZutfqM803viw8zbpCG9Hqhmx3wweV9M1g0IHUDUzbOKOOHknj4/GQSIApkUyAU9YengSmInxA6YBMEM2vQmWMqUn5kwqYaDW2wDP3ivbIyMJcTdk62OICI6Nlr41OOwh6EcAjQN7AlPDNoiknKXQvxUwgHEFK4WScZ9yK6V0FDVzkn9GqIC3OekhInzojIwa4LPpIo9Jgltd0WAAQJ3F4VvvC+AQHExckoJKAyCPRF1JlBi1nVTDLLB0imQS3OxqlqCjtEo2qH4ltGXq1S1YsIGEiqJAICRZkiCCHrNp8jMHeet9nikALBKWdm6ZgdAAtYERQGMkFVRUT1dgMIgFgt84OM+Wbr2C9V/3GEpRLVmAAAUSLipJZLQTQFREQZ94A0YaA6SR+zDLq9cn+IYQ6VYakcd7CBOxuQSQXBPhktP67MyeBO0QpBNLEeWp/mk6aRYpMUM3d2MuOyPRgMAwAAPSKmiQBAhIGK48QInnWNAQ24IQCRBKjWa9DXYVWv4QEone0oRrsjHJoOOS/LP8kGFMVofI7vLRLozR8A4h3FKHHS6EEJP+Vk8eS3JesEwQh4pSIiAvACyDyMtgIknUPUxS3JMxFhFbTeB4xkYimVDgJgVEGCAdq3m4cwC2Yn2r05u9KKhUMkAe4d0egx6bp2PBo5B8xsDBVVdfby5E///M/KsvrOd773zjvvVCPbNcvTs2cXly+en3x25+AbV5cLdjKqxpvV5u69W/fu3r08uzi9unCNK8vRYrGq67auWwAA9uydiIynE2MMsxPpEH3XubKcICISGWs329q5brVef/XsxXvvvfFf/N3f+dUvPzo7OxtXxVsP7o9HxenLk7ZuHt64Px5PfvCDH3Rdd7lYfv7p88Vl/eajt2/fuXny8suT02c3b+2N98q2vdjbH9uiVy6JIJbGSWah9loaBMeWqt3av54j4LIAIINDMeoTlRBbGaRWpL8xbK/uS5BP+QDysrvrJyvdYC1J3pk9w8VCRACTu/pEhFB/m45DkASKBrsz1MQcdrRSCVm0u8aTiAC6+FjKc7M4c+4iUioi8LEsVqK74vpaqcaff5V4AmICWkYASGyUYpOBnJ8Mn8lJdkKvjkd+HxXCnj3q4RtWvSGi84wkABr+ZIjF/4NURemr84xBFg5mQMw5YWYyAhBySBEYgqdEQvcMUVh2E9ZS2HuJTiYJ2kYQB5KEQhykEQm2cVSARNMtRSRpHiKaFo0CDsHEJLDcQwbpToCUUAykThItVBZIyQNx2TWpMzHzVLSCcYQm0CoOklciIwr52uxd3HRj1IcB3rPP/SlASJHxGqjiizhX+j07r9gNwAgmRGMAYxYLax5ryJ4JClBKYzMpqmUTQFTPfHVaNKBUyE4RpPTAKMt6ysqCPuFXodqll46kBfhpJrGon5mFNcjKLFm+OiIIeW5y5IOkx3OW5xGITliQSUqOnvl4bFh3N2+REKIVojlYvR8v/ZCl1tJudRglRiDSBdbQcyUvIsYUYYnQUnivk5i+Cyga4WfU6Ipx3ATmhYQCIGwANIYdg5QCAY9FnaWd5pcgInM6xiToYBA6FeWnnjEEF2Qo8nNVjBAAnDjwQOwlNoVIuooL1lzYZOccBpyYbCWHfjIGhwNuG/42RnTHM4rqqSWzMIxyRh8AS1BEEpMFBN+FQtOcISIiI5MAxPQlEIdoKPobQh0UhT3TxgGIiGDYOyJSGBXnnEayiSjFxwE4QDqF09hvPQCoQWyMYfCioHBQeUe2mjRti9KBZ0TDrts0ixfnX1Tuu7/6+Rc///HHXz79/OLi7NWrV4+ffPb3/6t/+HxSX1xcvPX2XefcV19d3Lh58Pa775ydnRVPvvjkk0/atv3ss0+JiNmpvCgIidC5VjUt78UYUxTWe2+MYXFI4traGDObjlfLqx/96ae3bt25c+/BaDJdrdcbJ//g7/0DAvzlLz98/PjjcVmdnp7fvn1z72D/8Hh/Mik/e/LJs6++OD8/Pzjc2yzd8dHNtl1DW7ZuPZlaAO98y1hw57z3SIJkIVh8klgDROkbPEMSsrjChwhIXms8ASR6xxN7DRlwYakj8I8xBlHREMT5aOdAqmxMemRu2yT3noh7ncs0WL2QxEOKgHRukGqXJBOLI6SAGMuBCBEwhvbTWyI7FU5pdFm9JYHXP/yOKy42dFGcG5/K0qJaFt8aj1hk8RGuAzwLM7M1QZRr0xaMQZv4qbbooCASAQBaAfDpfESB5DqXKXNBFQcAICMBmjjlCUbrGXLrNQFnRJkhAsAeQyQIqJB+nXsPx9a1kBRZDtAulNhvUmeTKceKvaHltLoRJCLIHSIS2ehB95JnVySWx5oSAGTVL6IGUjRTSbzr+Rtzmz0hTDOBCEeSAyJSRuR9onyMCMUQtXB9PYio1yTJIwJEQON5hVCo/1i1HxQDYD05I0zgvXgqq7btRmbqmw6sZ+nE+bIcARrnOkYn1IWcYkZgZxABqPMsWAgsIeX7Y392ED2AY5bgukbWNA/2LSKSJiCxsHiNEUEAGgERZKcEaYmox+HoMbx1kXoM+YGelrTjoTgZZGtnFCnXQzYi4jPVib1XQaLeb81ISndKjzE58CtkCodk2RiJ/li406y95JXS4asNlsapYhUlp4yBzQoAGRhDH38NQQcE6Nu2BMsgvIscCOXxMNE8asZ0W5Dh8VEECKF8o1/8fP2VjzBDyIyBiDwOPoVIdFElXsYYCGmUnBd5QqZu77DeXoj22kPwZg1XCRGzutxoKaah5iNPf+faRnp+dnPScRl764oDa8hkgHLSzA0RTrVCLohAStgWcaBWAA4UMoCcDPonQ7BcSbMv0pJCfzJek15ABkTQi/p9vXNOpEMofHNpzRTBrpv1gzduXyxWf/kX//H5Z7Q6/dWf/ut/V2/XFsEYU1XVuJyuV7X1V2+99fDRo0dN07z//iNjzJdfftF13Xw+77qOmVUZCpl9SdnNSyIQvfdEIcXBGHN484CInHN7e3tds/zok48ZaO9gfzabPX369Pd//w8ePrjfeT4+vvXkk4+rqlqtVr/3d/7WD3/4wxcvXmBhmqa9e/feO++8vd5cnZ1dGCNENJ5Vbc3GkjGl55DyYog47Fdvq+5oZjsXaggjhiaEfZDNqEyCMldHOuaqfXLiMCJCZujMSJHHqATo69O5SI3odsifB+2yXnNd/2qH+SBoVD59jZF++vBifG9aE58LV0xZXyAQ+LMEK2bosOwzLSUY7pzBGeTr431qcskAlLgPUP7AdGQEQ4lBgjmOEViMgE75Yme9q1LiXZQUKrQGeTCRegdpNHFq/cjzNYF+3UTnEHaQe60lPV9EADqMwVAAUNcRAGAIlET2Mlz5HbYAAJrKFc5YrEkBD8McL8hetEMdmfOJUTLHgspgzzFsMXDZMogFZAxqJQljHL/EXGAGZBAOkEHSIFHXODDkto2IOPDWkgcU6Dy52rWEpZaDee9d64GhoAJRXNe4xqMtRlXRdmE8CJiHVDx3nhsAQvAIiBKx1LANbg2Vfgom0FsUGPfNaKDCOmFEJO4jZ2HRr2VTh5XwPXHk96fF3XnOYFfih9zzcXDed12XNN748wG3wkim4cmMSeOIRAOS2IoylogPo/5tPZAikuqs0sBU3Hxdk7Nh8g4loaVvwRQ1QGEgAY++g6jAAdgUKsYIPdvrTOEFoXWLBBQftT180v3yxU8sID9dYV944FFIOoehoJ9pZS+m2GTv+g5aR9h31fsGLINTgh9mqIUeBjBd1/SWxGJ63yNk2U85Ylj2E85+lTyfIuJ7sMhYxQRZphgCei2/BCuRrYuajBJUkDTOa6ua/uizXAMmKbvBrgFrKWbKYOilvmGiwrnOt521ZAvj2q5pt8YyWLx3/+H5efsv/vhP/uUf/ulf/funzWZikSbj/RuHt1xTN+12b28PhD7+5Sdv3L/9nW9/ezqdAsD+/v56vW7r5he/+MVyvVlvlkTUuU7VoIIKQBBUu63Xub0wsZ+MCh0nMxdVSYCbzaYsy//xf/x//f6/+IOPf/34aHNjNpvt7++/PD1dLBYqA45u3urqLRlzfn7+8ccfe+/f+cajoihEZLvdzi9XzjeHN/a3G/fq9GIyLQ5vjMcTy8E5wXVd26IC4NT9NxJV0gh3rRdxPcQ7qiWtxqjWw2dFgxAsamR+TajCxXO381+CQrdYor8w6IsxdrbzqMgH+ly05MFP9+T3I2r/VEw0j4o2HRWd8N9BDU7+nFSTH/lB+FVy5uV+gpwnh9ORfeJTEgxGSNy0Pl5z76LOocyWdV0G/DmuRlhknQYnRifDk57xn5QTphkAMlzbgTYgyZ7NkCeyJc2FS3A/mJgU6cNK44DA+k2R+DcnhQMRU2gJA2R0skJVwIStyYrUOHK//smpgKjfqYTx0d/1muR9ABDoENFDb9wiGoFOMEYu0hNCdrzm+qUdD/hRoAVdwQL36mhHNMCNeGyadjyeehZEbNpNJ2BoxOQRveOafW1NiYzetcagE3beEYGgQxIC6Rph7NJ0ve8VDoCOpQvLoP1EAQHA8VbnY6L9GQ6RT+gGBtEIOAD2DDbKQ6SdLl9fE2uUa/XccXivUVcl5ljwIEtUBi0Tmfs8EiVo6AkRVNlHxTLVY0exIE0lSS/3hodZYq1dYh/6KVPm4QjiRIB7OBDMjopIKgQCAPAIGJ+pvw7lEhxOo8QkNV1uL31sGMMIgs810LqwhOZ7vZLlOYSWXmNmccwSiP3A+mw4GDIg/bn3DoJbheMAADA0dxMQVLzhqG9JSFAK0jR9kh6bZ6emt6SVzN6eqw6Q5VuFO3NOESTN0DqItSpKdMHJca1kIIgrjg9kcOmQpoczgySTc4fMh3kqic9zvFSzSbcRCQuz+AiRFMxKII/oxRshZPH1pgaAqiq6LZST6oMPfvIv/ujf/vgvP/r016+4KUalYaCyLA0glaPJeNw0jYgnRO+758+/urq6XG83xpj1er3ZbDx3y6u5AqKrboiImr6NNCjeVsA6AHCu1UpUY4jZdd4DcNNsO/bvvvvuh7/69atXr66urm7fvl1V1ezw4OjgkJ0ry3I6nvz2b//W0dHR4eEhi7taLJS/LNaryWTqXFmY8cHB3quT9cXZ2cuX/tad/b3D6WRa2bIQH6PsQb2I7gqAzPO/q0OntIaItkkQwbii7qdHl6F3kQ+0ClWt0ic5HUZoakjyKQhgDfn1mDu7qkDGzUSk7yILw4sHplrQTvIx7P5kFzY3PNblQeQ0C2QT7r9WCxYw2AePjWOIdlp2QtkHhaPXQphFGHLku/4hgmgSimWyqSCntN4RHeYe8kAwMhAI78vnlW+B8m4MDuOgJaQz28tsNSSiUNZUrFBKGKMQO9gSAMriEj/sOTAAYcidTLucVCU1p6LCoYdea1uof0scvK5hss9TecvXtF9RVFDNOkpbqHS+Y1vG9u4APXH2KlEsSwLxIh2gDw4OaBHRm85jCx7ZmaI8KMez7WLjYUsjEeqcb7zvDBgQjyhUkA+FAJ2xBaDdbDbFqB8/9wngwOAZul7TSkEMYBV+HpPzRdmtGvkowJQaUghmIRWAQXID7bKG9M1gdeI2J9LfOWw7x/i11w45QjRoIupZ7yTUyGX+TByogekhKgx0Y6hXe4k42DCDk0MBf60/UelY5m07o8zTVbCRgk3Mb87r7gSylJ/8meEG2j2H/fSDJ8Dtfh7eGzhRfFrOx3n3eZhB/OaF9cgU01FYeBBuFEqZdHJNsxQRwb6/yc7whtPJkenUJ9HbamlNrq9M/yLRH6IMQio+s+3CSxkBo0tDAhJl75KFYdToGulmBocIx1zjADdECIIpcxlisp5+kh7rvUfrXessjqqq6pp6uV6VtpjN9ucX6//pn//Pf/G/f3B+Wru2tLJnKiBoNjWsNwtxfjQavfHgwbgqi6IQ323b7bNnz27duvXs2bPRZOy9f/z4MQCUZem977quLMu8I3HOoMka1UgAoHWdKSwBjsdj/Xa2v7ept//bv/l3x8fHd+7c+fDDD2/duX16eopkT88uvvX+N7/5zW8eHx+VZbne1gCXZ2dnRLSpt5PJ5N69e/swm0wmHvxyuTg7nU8nh/Ors7rd3jjeK4oCEZ1rw44E51MsIBRJZcz5yYL+QCUdVCFY9Nhy8O2j7q3ubwLri77JgWmOgegHO+yHtw2INmMsPSdNEjH9EzMnPAx1nesUtfPhzh+Y8jayBRHoS1JFJOINJHxz2InqpguTf6LXFV7vmR4MQ/3CIiLCPo/TYx41zk4QRBcwZLmNu5KVY0lCtq0QnS6ZhZmnY8f/JoD5ni3ADufpdQflQgDacUYV3KTHRM3DG01KBRgkvwefRIIpAw8wxNTGvvJF0zYQMQuYRAAnSSx3Z/dfn+wcHLrBLg0++3zjhoJVok2YrUDSacQAMKAXcYCqoLMTQuPNiLxvjCu5md658a1bdx593vz8dPGVkwWOEBENgnhnxdT12pSVLoj3XDebqjRYlLFjjr6yf71nxznUegxZCoN20gIIvdykV2shwowGnikiqZZdrUPA6K401yzs/JhdFzZfd13/9nXyZXB/TnCSdEl1I4VQbHqs1rj63aegGIhoQigRl08Tknuvg6Rqe9Su9Ylq0zkH0yPcDTyiZFj9evz66N0uGkf+BxFJKOGJZhMKAIFATE2CnLEO1lCBgGIVxnA7EHZ0LwGPWmhsUoxGz0oiJoTknASR0Ji7N4Nepy8yDnTT/Ib0X2Ouf4uAkrLuMaYSIyHSwFu800QgbcvuK+NgINuw7MY+OU0AmOL2DZv+KOQXAAD4hI6q3XP6oI9gCsPxIFcm+u2JvHeIKODqxpHA3t7edtN+8viLf/6//PGf/dufGX+McrRen4E0XmA+X6IpxuMxluV2vVkur771G++//fDNzXrZsqzX6/l88eWXz7bb7XQ226zruq4fPHigndjUbyG9ohZFOPYUJQEOhJuus9bqXPb29pbL5Xq9tmXxm7/5mwDw+MmngmCoYISr+fyvf/rBw4cPHzy4d/f2nRuHh5ZwcTk/unn8wU/++vDG0Ztvvnnv3p3j42MCmM/nxs7u33tjui+zQ7LWAImwtL4trU2MOFtnn8b5dXK6P/iBUBEG+z6oZRuugH7Y4woMyCNuE+06G1Tw52cH4ycgQ/Mj0lVM9Mt05eFcMgmRmPWQZQWFIIac4uesxR8gQojaIyRYi1+HcwOQjn+Q/QNv7mBVITqPQTQcLag8U1KYQM8jpa6LgxBtNgVt1gVBb0juK9QcmnhbzMmLOyAiqTopHcCe/Q7D2bmTBgJ75C4BrElAWNYQqiYnpg3KU2TCkwNyWkzy5S6Mv7c1PEAfA1KaCiMErx4LjNGZIVX3SwdBroUg7M7iAwCzBYjhNgAR9doB2eTvGAIFse5vFvpBFhEiXQCTjUU7/VnnPQAW3k7xwMDxrfLNw/G7b95uVsvFslkRARZEYrgDATMt7zPDantlSjDWtLJ27Atr2eWSPU+1BO8Yd4mRRUxSDkWAtUs2KkHHfQGfXEE2P4QiojXRqnklKJK4oBQ3ctclvrMT+SndUS527JL81XHnCF7Tn8yogz3nJsqSFIUifZ5+SMFTkIbE8Sd/07XDXCAT/JlCkWIT0TmQ3RBfkZZIFw1yVwRrWSez954IEHUXUNS/JaJSMs1luNo+LWzsWAuZKjZwe+g4Yo19kE9ADBlOcMZu+rXFoZ13fdk8hGKfHQU0Iw9//Vtt5wM7LtPBGR4OPtS54Y42199AybSBzDMffKdaUB6ntmvL7kw2bMGQkESCm42IJAAK9aFxzvqAEBiNbjTN1lpb2slXz5//m3/9oz/+V//7wfT+mA7mp5cFQt22Tef2Do7retO2DtE7151fzM/OL9964+E777zz6RdPLy8vX758WZblfD5frVaj8bjrXNN0RVGVZWet7boOQuZNtEfjOiQEJ8XeEJFNvbVta4xh5rqu29Z98MEH773z7oM37r14eeLYM9BkNBmbgsV9/MknX3zxxfHx0Ww0/m/+0T+eTCYfffTxjRuHhbEvX7744umT7373uzdu3DDGNO363s3D/Rum5XndNCUaU5rKVhJbdST9oAdCeJ1CsMN/MCDYpjoiAOgDBzskOnzswOroKSEo0z3wZFIarj8weyYBJFNeEAfjzAecVZoAxqOv/wL1w4XqwaiwsmQtRPphC2M6vq99F+xqHrklrWYuAAxoMh1hRNSqQ0aQ1J0qANhwlBZ6XoKoFgkhlX4NNbUAQcQPOigNAIclzDp+Qj3ukcpvPcuRsWRWTC68Rfq695DWj132RgBg/bEPPxkc7ch/1E/AWm0R38jJXxEZB4t4RJsJi35zJXHyAMSWU2/KqE3KCiHlHnRIssxxBwAm9BExAj6ILY4xOEpKs4gIhjbjEnYg6Ey6m+G2uP0oYAw4FoLWVrKPixFtwU82MF4cTGYV2Y3q/04QSnJU4eTB0Q8F3dPm8bo+M1NXkSdh1253zmP/N4OIYA/2lUaixmEakoSAFUcyloEWYXPq1K3CDIw2J1npNY/dtLswhq/5PK4+5re+9oYk4PJN1WlcY0xBxdvJdehv2xlIlp0U6TPcFxTaIU5LmmmucAzGAD6Sud6sXIyzmC7lj4oA28pEUY1m9inKGOaVPA9D2ZmPLfioE3dOv4WeRILakUSvSNC/+nnFMw/pxKLeOph7zFTIFnIYJoso4pmar/e4jEEAJL6M0SWAMYUeNOMMBjmkIiLBRaHcB2JKaSqNVg04L2kjAMRB5inAkPYSS0rUnloBK6DCLr9miMKG+v0RFBbvmJnVowgAZWW998WoKIrJdrt98eLk5z/75Z//+V8ac3N//3AzvyjKpoJyvTSj0chDXZYjZmbBYoQi+KtfffTxrz68cXiwbtq08t5JVY7ruh2NxvP5/PDwMKFTp40QkZDYoVwrpExxXdeTyWQymeiJ9t4vFgtEvLi4tNb+5OInRzcO9vamm7ppHS8WC19U071ZVVUnJyejUfl7v/u3lsvl4nL+3nvv/eZvfh+Qx+PR1XJx586tqqpGo/LDXz++uPSecO+o3JuMO982TVOWxc7Kv3b9e1JBjNkJWX1EoGqEvklbUAfzjUvbFAhyB5k0fo+M+WD6zeXB8IK0iJqBUkW8X+nka2Lz+dFTRWKQ/RapMX6m84gElvlsAhxmsAlCbQJ4pKQ9X1fOMOVWRw/N1xpUWocvsQUOimap98i/oX5Y0vlKfEzhfwK3C7g70J+4oCTpcQlxRkw6h/cx8B+ClWE40seAdjVFEbWJe34FAD4LnQAAaQsVAGHCzCMbtowkVpE4ABbmlO+pMwpBycAVBUCQegG5M57hQpqk3ACkCItyCcAIV9lva9qvAGpgESFyXwEQFh+hGZQlhkNNZAClh1FBJ+LVES7JqA1hRMWsqifVPjQjqieXT69otZ7JV8c3jtykEW4LA4zQeQA0BU7G5cHdve+MDkbclZ+f/IzrSyzQkHjXQo4rM5TYiCZ6XHzMc1WnhggzqX+dosIENiqvA0FjTURc0f1IrxHCoBeokBTRYD8hxTfpQkS69APtT6KxZUwyAiBWiww6ITGCEJIEC12rxDPqYRHVqYvsfPa8ADj4xgL/ilqLNnNSfTFwE1SPJ3JCUYjaBgCYHlk5x2RFMCaxnjg9QkTvQQElOdNwARAMCrAHD/EgkTowUI0LJgBN4yWQwrIX8N4jGN1REGD0IswoKGAkZG6GEC9hDMfofnvqcc9QE4AyTqEr7QGQiCjywUDPeVFl1lLSAWDmDyckADJixPhUDhp0BQTUGl1AQFZNRT1pDIDGDogqhqOZUYS7rkMSIiITUoAJWQABSIFItAgGkAU4o/t+zJqwggBAoT9CmB0oaqCo6YYRYAc9pwPaHyYBx4EsnQuoLUYTNYg8c2EMInRdCwBFUSBB17LzHkmObuw/efJ523RvvPFm03RITWEnzdojtfVm+bMPfvqjP/t5uzrcw5GbO2htu92KNG89fLOu66Z123o9rkab7dZaQ0R10zqBl5eXGgAjIgJjCssgZWFEuKjGXtgUVkRMYZ1zWkSOxrCwdD78yokxZjSaAAsBsvNE1HbdeDxW1eTw8BAAEGVbt85LWzcHBweP3nzz+NaNqiwLMo/efe93fud3NvX2r3/20/e++82/+3t/21r7ox/9aLtd7+/v19vm3v27AFS39dRblrFjga4lI+PKeu8QrAiDGM2siec01559v32IpFbfINVOuZeJ6QAeBEKHsIi0i9H7OGhvBCF/hRTaGRAkuHYRkaJIEfHAQiYWdATBCQLsPRuyyc0QJQcCGJQAPSxIQKh2pYAHNAGHAhGBOJTistGcQxXMHE9lzx4zOK8YXSUioMDvdDcRTBThvVM5MvGkYUi+qkigyXh91qdi0IRqIEBhZi+Q6uAS5xOiwN0j9oaetR7NCACQDYZCC6/AhjoYJx4RFYYL+oiapJ7mPUJG4JRuJxEqUAiChHamEtmaAICx6L0HYFL9mRmAjTHRrE7qpojyDHWLZeZrUp6ynVWDySj7ByFE0mxHES/CAh7FxhQFiGqTMtZWmUiy+iQGabLZYBwDkOKCkL4O090QkA+RQyBPl8c65xH9cHEKBCNYGwAS9GzEWC+dcFtgZ3iG7WT5omnOl/XThSyaczH3bs7g9p7xTWNWLXSEo4lMq824uMT68NXo+O37R+9cPv3qEpwrPPnaInnJuqwPDH+TYdxhWhBryqh7gca3tdJHYpfESEWCaIjQZgv0tXZh/pIUJE4bHCSV7nRa6Whspcf2nlWGncQmSc7EwSf9Hxhd9JkA0+2X1B5XstwIESEaeAjyp6WR/w1vVNMkm+busqS2cMFj0T88aifC0e2RnHLpeWkYqsbwDsONxjRI1k56Z5zp5KTzk+Y7INOA0wwynO/OlU1zMGMRQWR43Ssiv87sUPFxlMkWCSh+/XjUACIJXGj3rbuU8HVXmuPrx/03TXD3OZhQkqJUiGwRu64jorIsAcB13nuvmqs4f3F+1dRuuahfFfM7d+52bmGN2AIXi/Xz5+d//qc/Wc27u7furOeb6XQMwGRNs22dc6vNWhjH4zERjUS22y0ilsUIkNu68d4bKpAMEgGAITCmNAYBC2tKIlJAF6131RJmHTwRWSL2oLmlt27dWq1WbdtOJhPvFRdEmqYR4dFolNbk7t27D964d/fu3e99//vsvUX6/ne/9+rVq5NXLw8PD7//ve/N53NjTF3XH3zwsx/84Hs3btw4Oz0HgPn86vjmbDodT6e43JxNZ6Ou67rOl0UU5LHsVIeX8FfiRX1S1LVDGtTpeBJF/NDYyv4RoWUQ8bUEjjjI7ZDw6hyQNLtBcb1ZdvJFADx7LwFHWTu5RGUiP1cYqBclgOn1RJUOZlgH6VlZ5uOR/FlRQO/MKI7Wv45npjNFcTz6z4AJDX1AMwOPj/GjwNykD2pfZzuR3Wlpsf5NET4L4fpoe41QHZaBo+/EwfMXpUS9UIKCAELMLiTWxN4RiLJDVHnOwTX2EK4dF2bUM5Le1ntclFOlDLIwnmEjhf/8K7MMOa85ymmjl7kaCbrGCQW8Z2uIGNmLZ09krcWCvZ/KwcnTi/MnC35RH8tkeXFupvRb0996tT2peVVW1aiacW3d3C9P5m1t7h2ewvGhcXVhnCHPBl3nc1yu62t3nYUmKZB+AgCIkkK9quFS1mvXvjbjEgA0zJ89JfNepgENR5DfnNaRs1hOtnCvmUY++t2FFsnytMMgVSSnQ6VzA9hhX7sviq/YVaeuT+da0LS/rZd2A92lD1YNxSeLRMMl4t5CPB7BMQgOE02nFc5WI7Gt6P/vbfU0r+EeDaoH86nl25Tfmesc/Uujq3Zgk4Uf6jjVpOLI54IPO7LsJFTCWwgthDBFWJyIceRjzFLFjQeUr6ulvK6X7N6ghu411nBt44KeirEGOLF57jprCiZkZu9YRLxzur2j0ajx3fGNW589efHJx58f7t0+e3l1eDzpus5YXi22v/jgyfKCvvft391u3IcXHzLIZDIZj6eLxWIync4XV2VlDw4OlsvlZDIpy9KDrBfLrnUsaKhQJFkig9YYg8agMaarAyQvs4biScH4nXOpMkUTYHV32rbVStF0pmazmbXWOffgwYPxeDydTkV8vd2+evVqPp9vt9vj4+P/0z/+bxDRGNNsa0IAz4vF4ssvv3zx4sXdu3eragxAVTX9wz/8w69ePG275Y07358cTsigVkUWRQz39AwHrx+0eFHS1Hf2JZzQ3LCR4IRAtJlZD+krxGjPo/pUewqJmm1g8yICCIqNlvC54vnqxXBKXQyg6ckzdo3zqeIfpyTqCAmtHhAoa4sMgKwohpHKAACAEQ1QarIUnulBONTw64nbMZ96CO2MU1FihvHmHDoCUq0QRE1LRHowichpRVIIKWdB+l9N+0jI9AggEm2keG/mwE7ObLXhQ841xg6a+tidJCoFl5GYB2aQRMArQDAndxHu1r9Apt+k2Ie+emfdEC0kboAaxYP4NOwnjjoF32+dZJrZ/5Fr5yBkYjStmkS9ZzdZJ88LJCo65woL1kLjOnZINC3Rnj6+ev74ZNZNbF3Uq+XV4uLuwa3nyy8viqsOt4UdQ1N0FwyvnHu5hS37Gy/hwTHD1mIr0CAxM1Ix8qw9fTD7b1qP1wvNIaXlt0sOb6Gf5B6O8Hl0AYVwA+YvjtQPSTJgUmSygyjZ8QhpMimRNWTw7YybowsHMzfJ7sSGFappVrkg7B84RDiV3qrYvUQkZSP3yzDUkDP6SKvpCPsmzukrEoxqkApsxnjMdwYPQIwAoM7DBGrLmf7U0/5gHcK8JLGM9Hm29+F+g8hZvmQcbfp7160V6B5THESLfSJ3uUZwwaJKDCu6yvs3Bt4U+XjwM3NkLpD2JU5XC9B33FE7L/3PPO0DneO1v5LozRaRJDbSqhpjnHN1XZe2QqS2acgiEU2n07Z1wDQqx59//uXbb73bbASoadrFy5OzX/zsya3Dt37wrd/67LPPPiGzvFrYojLGjMfj+/fv7+/v+84tVksAqKoKrZG21dB4URQKjS9IaIwtLBEJ+NZ5Yek6Zwxp71lmFkbFXQ5wqB6EBBGttUSkoB1VVTVNIyL6yWg0Yub5fF7X9Xq9LMvy3t277777blVVi8XiwYMHh4eHf/Znf3Z1OV+tVo8ePVotlvt7U2CZTabT6bStu4uzy8cff1ra6tatO5vVeruqV0sYzcq2ba0tEUBCHj4OV5Iz0f6f2MTE6LOtDz6AlCUdP0k9EQdWMoBWp7GIUN/FdODEkyyXLbMyU7R3IKKUEiDVjLCKbk8CQpw3GoRcyQ6H5zVTYwTgvFxrACOh2oawMHOEsoBMqwGAgAyB2DsVogs5l1hxLhEDPrDlvOU1SlSZ1ANhACDvmrazsAAci1YkYKSkF0VjKe64igmOJkQaOgNqv0bOnx/lAgYATZEEiQFiYvhYNIdX9SFF08+XN8vG7RWd+OrcBuNcUUuah4gElh5CJ0Huxs7sYe4CHmGQrvSfvIYqtc9z0dKHWc+XNKlEjTEHzhCDZ2FkMYClqag1q/Ptq1+fztzYroTqzvltZzajm+Ucz9e0pgrJlVev2uakLVdEC+/W3YsvnozevXkly4bXgJ2wK6ggscZkDPPrMEWG88onklqnJYUjO18oInb3ARFyZ0fE9t9nAj5JcewDKBCCm70IDLnh6QF/8+gTFe68XWDXxSQiIJhjiHHoCJDGtmvNv8bAjQ2cMsLtg1iIyMMQZnoaCKX07PhV4Fn6pwTDArQRlMTW3ENtIz/P/cR1mfJXBsVqt0mxf13dzTWzngWHXdYkOjaGrCQX8GmLPUYvrXKEaFiEfc/vF9FKZBQRE2qbWTjCJIfBcXx1VlYXHuFSGD4qJV97ZTsIsHues0/kNX4OyI6E7j5raknmJSqKous6QuO9b+uunFVFUSwWi4rKerMty5HrgJlv3ry92Wy32y0AjSb+Yj7/6svTF08v7t++xQ5v7O8dHux99eyFtW3ddJPRGB/i3dt3lleXbdseHByQMfOzxXq9NqYoyxFEEYKIaEj7CnUsLN4CdV1n7YiIui5qY4yISFq0hj2kNDNXZamq0mq1unnz5ng8fvnypfe+aZrT09P9/f2yLPf2prdu3tzf318sFt77g4ODP/7Xf/LFk88ODw+rqkLE0timadq2ffz48Xg8Pjy8QURVVf3Tf/pPzy5enJw9IyqbxpXjij169IJE2YmIR0Ag5Gbpyvemp5o0+mfaWLX6ACH200kgqgZiqCJeoQRMtGUQYkoRhVDGIEGO6nLFbxLpZsXPmvom6YbeVpYQ+Fdo3SQdNUuDg0sAdgxTG3SmQbJaJLzwT5QgffOOjCIp+wUgKBaiv8yfn9gIgGJvZiGq0PhQt8CHLomY8q8xE3LhYWHBIBiY0sOoDN4c+aQAaBaISmLtEMJp+KJmRtjYvJomJf8iYNKZ+sEgkYiLdmdyqSKSsPcQDgaE5p4iO0d7IK12395rG5mM7N0h6eDHD/vkWRBN5cfeJoJezYX/vGvIadVOE0QzhMT0O8n1w6VjAELwxiCyeO8LGs/MdHG++fJXT0dby822XjaF86tuPrk9mdydbqkriqJdu3rdbV+27qLFDbjLJdQd7uFN3541yxo8WSPOWypdx1Sk3DtNXn798u6y2Ws8loiS8UlEMekYbY7fEtZaEsfvn5hru69d5YT0F39HuaFzfa2vf55P7Por+k9CUy7NCOy7xUZB9frIDijZZs6AXMkI3CRwwOjuT47YnCeGMCeGqEDUygP/Z45pV5LAJLRcM4OuCNWVgCgIHJsL5bNADDHO5C2II78uWXmYwT7UWkSARd9Imp+rv8Le3osbmv4JgekHiyFq3/HApanqP7U+ViD4aARJuWzewiY/bBHQTC0Mn5zAEBY8uDSTh4NfQ0G6iIN/9voHY2704ICb73q8AESBATK84b6MWUTQgDWGxdV1TURFUZ2fno9Gk+Pjcm/vRlWO0VuLxenLl/fvvr0RJ360XjnvodnWe+MRtJM7N289/uSJLRmEVqvVF589ffetN9984+GtO3cu5pevTs+LogAgHzKsDTNbUxhjBLXvDFsismXXtV3XzWZTzajQDCwRwWgDJ1XDO9fW3dV8TkRHR0e3bt1566236rp+8eLldtuIiLVWU0Amk9nzZyeXF1ej0ej73//+Bz/9+XK5vHfv3unLVzcOD6fTvabpDo8Pq6oyxsxmszfeuH/z5s3bt+8SwdHhYVmZ6aza2ysatywL2/i1tYOubK8J117fx9732bvoUnoUACTfOMazEYmqd28AUMRtE+rr3UQ0x6hXr3tSSRZ/dIUGYFnt3helnSCSAjn42O5SgIADoDwAKFIeIKKwCGonFQ4GUs9Fwz+0+iCKK0aORSKphlw41boEEn1NYDd+lY6tAAx8JFmWAEdwdE3Y9/G3OQNRVUjxzqOfH7p+g/rNys9ycqNGBU6NN/CZtcBDfLBQziEQGijGfY41dBRsqpg0mphSn1sak+d0MTGT13prCurt+qiyMevy5nJNiFJ2QdKcQAHrct99LHLeoaX/tNohsVgJMjG6Gw8SyTIHzPU0HQBgceJ8QdXYjtwGzp/PF1/O/WlddOP5+Xll6KpZXcnqO7/xg/3bd6947a/axZdLd9XAlsYtuvV6vV5VVNx99P6Nt99dnNH2fAnYigdTkou4eq+Z0TVtIxOmPUkMxXE/2SCLWGzuxhlUV78OMS0xhX7JooTbgf69rqDlz8y/y3WCCFI2UDgiASFI7nwLgsGQGdzZmxGD8excuQjceRdmmnhShbM7lcIo6gDpzIeFjjsmSeeI2TDpjSShuQQBKt3vqofJtQlDmsaYLz1c7eQghYwtx4FJr1u89kprlb1OA0HBYMp0/6T3SL+AqVw+pvqHrZFsMaHP7HOZzy1JkD6cHCWInnZVuL5u2GnI+UKB4ribv2nK+UXCUT/RUyHa49c5T0SarFmW5Xq9dM5Np9Om8d41xzeK+dniaP+mn8gnn3wiAk3TWIamJt8Vo7Jkvz3YG3fb6jvf+vavfvXRYrUZjcd1XV+ende3b337m78BVfHJp49Pzy6qqirKsmmauu2qqiJCx85rhyNAa01RGGutEXa+LgojIprKiojMqQ9WpBAA9sCGR6ORnsqu687Ozuq61hyO1Wp1dHSkCsfV1XK9XIzH4+9///tnF+cXFxd7B/tXy8Xp+Vnbtrdvvjzc21+v16PR6Ld+67cA4NE33rXWLpYXSAeafIpsCabgOzEdAO2Ys/k6p+3uiUcQcGDgJvYSe4H2UY+w6RAYX+QAiLgbOdYuOMrNB4QaASXjJ4nvBU8IhNgjyUAqM4ROrU4h3uNSi4iAaEu0ZGjFscWmZTr4pDQLSOjwHD/xmWoQ1Mbh0qXjf2094yuzEEkkY+hTqrQpJESlQr2tUQNTNgaIAByCuSiiTSR7h+juYAC4XyI1ytSFIjHXAfNU8UEaVs6jos6ESbcQSUXRoR4kDkAMFQpkqfNV5QhjylikqNe2gxg4ObIbJMkRCXFJHt5MAEAJMBBI+uiVlQz2+2+QJtnn+j894mL6NjOBdgz7nVkYAED2BIXlGbrJ9mxz+tm5O98cyEQWy4OquFicn23PH/3O99799nc8VBM7Pvni8/rLBrY0Egtd066vDPmbd+/ee+u9yc0HxySXZ8+Qt4SFF8clhcZ8190Kg6ME0NNkn0vUTwT7bhhRtQpauY03KYaJTw/aIfTr7GPnn4FTUAo06DoGSOPdsb4uHVM3IueecZoCAAQmi4cmNcrkQEzpeFxfLwlKVvZ5bJYW9nMXbyNXayEfUk4fMfGtF/PRwtOWPDp4H601inxQtY9QAglgcGCwK6GjIvWnlxIRGJKs50K+xzu7Nty4IduAYBz8zXuafx6bXASWkb2IMtwO0VpqACHBbH2UhCn2I+g1GBhudK6FpPHsHMt+jRIcRSSS9E993a4P5HUPgfjb/KW6vrYomFlTEyaT8XK5XCwW4/H43t03T168+vLpSWXGIihM7737zY8//vhyfn5849arl/PNpimK4uLi1enLl4W1P/jed371q49+/ekTa8txNQb2i8uLs9OX3/nt3z6/vGjbdr1ed103Go2KQlUH6brOucagGY2rsixHhUXEyeG+991oXDZ113UNorG2cM5puxsAYGZDBEJ6bev1aDRyzhHRfD5vmmY2m61Wq8JWm3WtpS7z+fzmjePRaPL48ZPHnz958803nz17Np/PD/b2Dw8P0ZAHuXnzprX21atXk+loNpvN5/Pj4xu3bt06Pz+/mF8uTlbji+rg5qic+GJcIHZ9utew0CMjSFBhEUQa7eQ5qATFfit7cfKfsCNzgu+JWYeRy2wtc8h7oICHALaBEbAo3hs5RDCDDKEQcKhlQQXdDbIcRbwAYYSnYOhJPdG2oj8nmoWg00TJGiS9SAwfBKvhejhYsQQGTClbRopNQNBEDtzzRh0AmV5m6IOTspQlP71efMaEBobYayJq+xydrBAO4DXlKf0r36wE4EFkMrRQFboB4V4BHyRk33gJjboiG5EE0tU/Px/wdYLBQSouBk6u5bQM0RHS2zORVxjELODyf/Ta5bvXndbJCNz9HAAAaFLNeF1dvNxuTjvrpiUINA06WayuFquLB9948Lt/9/f279+fL9oXL151J45WRemMtHW9uWzbzXTv4M6929uN8+vO4si3BktTlFXjVr6wBX9N3saQT6Zxpgh7fyNwwlBRwgfoFQM7LmfSV6srAKZjduhKgEBASoaBr4ElJG1+7ZlBRAEVgjUfaYVCIII5tg0DAHWGAQyCQwQC7AGAoutPpxcZgwBQTBdK5xaiziEioVAb1d2R4KpMWiXlHGlvtSYzgFt4z4iGrEkBl9gljnWQJI7QCBKiYVXAA+pNwvcFQPbCBIgoHaptSiIMXlmqECEwCqpZQEJAaEAQgbz4gvTtqBXMRGCIfOd7mz2UlDNo/EVEjTvC6BkGQUEA9NDvvQQ/ZSIgjtigAuDFeyISVTuifoAKti9eOCJzUPA9ashsh+A4a1KKOHDVOI76UJ+h1hum8f+CnkcEBoI3NXpKwnYVIVKDEG0DDX55DJoP9l399IEtokFG6iEgmYi8R5GMAiNnzxXiTENHQO5cw84DurIa3b17az5fPH/x5Te/+cPnL148fvL44Vtv11s3Kss333j4dvfGT37804vT+edPvrRo33vzva/g2V998ON33nnn1p2bv/mDb37wk3//9nvvtZ1tmu5isfyLH//142dPLy+uFpcXi4tLWxTetd57KCyashyPbde5rkP2BQKIb+v28OAOgdlutkVRHOzvzy8XZEttX+EcG2MAsHNcGGuM8d4j2c4xxVNgrb26utput8ZgWY5AyHtflVXTdMxLi/DGG2+s5qvL8/nDt96oqury6sJ3zcMH97/5rd/47LPPPn3ySdttmf3+4cGDNx7WXfvFl58/++rk5cvTew9vfmv8xmRaAjv0pi87TKbqUBwmH3UgCqRe9qsoYSBCIfSaVqlg2IyAgkgpZwuJOLaJBkTyFDlCcOlHbufj6RfJmgmweEQKdNDzx1jBl5kQ4WIEYfSiUQkOvdMoAtaxgABx4muOAzKKiKJYCQAQkUEb+FHEHpIQQ7QcQKQ4vnewbtJr9krsub0+EJzhmIbYJsSfJymehCoIMBHw0IQRtZFMr3yHL0gVJgPAiGAsikDoIKr4sArJGvucxXqD9F4mRFWFJGEGIAZIJxPKkQ17AMCgtqW4DHiujdXj6RMVqZEVtUaOJqXB6HpPjKpfOtTWFqpQ5GhE+t6oIKFyGu3dqEJH4cIYgAVcwoCQQckrsHgcNvALT/eerBVEYCmNQZaWxYGMDIGQIDB3xrIQdp0XwILGAp65tQbIUNs6ZplMZtRN1xe8ftXWZ61dwwzHzshlsx2Tm0t36zvf+a//h/9+snf48tPT9byGNeCSS9csFieWZLFa7k/3Hj64sz9GfPaFeVLyeG2mCyebQpBp5FoX4bV0j7p+CQPEVZ54C9g3JSaIPYwiDBuH1QntLQMrsNbMIFoAgQ7Fi3i0HE8vJ+ekiCgSWWLKYY9BnRkgsVVSTHAlY0xfUZm89NSn+CJawiJtj8HkFiOIHQ0QMXNtQR5+yyevWSpESEQBC21Q2EMAQKCF9CJIvQRlAQm4rVESQSyy1f6coDhLLKIszFIByWxiVcWEBCwFv6sR4wVEPHs1pwgkAoojRmgdwtgLIJJoKAoP1QoiolB0Ay1Ywr5q58MgOPMgRW/3UNivhOzMMQXNiICE1m6ZFh+Wl6KCD9Hjkpxh+jqIBNfFTRlsBxHGdYzDRhYQYxIIrg5SAr/uMXP8TvZ47ltU7QoiPAkA7DST21GJMjKTuA6vtRtg50PnnLVWkBTWwlgzHldtO7m4OL195/jjjz+ezy9Pnr187533v/riq65pz87Ozk/PrRmBh8OD49u3b19cXHjvLZnZbPb2O28q3FnTNLfu3vGAP/qLf980TdN0gNi2LXJhjHFtV5RWt3tvb29/Oqnr+uriEgC+ffM7zPzkyZOyLEejkgwgQlVVtW8h227B0FTFWitaHNs5pITCF+pWQGg6nRbWbrfbzWY1mUxOTk4YYba/d/PmzadPnxqEw9necrn86U9/+vTpUxHZ29ufTCbGmJOTk5dnp9vtFtHs7+/fuXPnwYMHo71u1Vw55zIiQQRMqAlxo3dXe0A2mNDycq9VUj5Vfr8+lTgJmCR3A1lGv+bO2/MDlZ8aBJPTrR41ialUeQu3nefEfoq8kwGariTLd0aunwu4GNuR7MGY5XBIplVAxtlEhpQsQ3dI9hO9LVSU6LepSWTUb4Ye7tghQt+eJhIM0WwuEbBRf5iHVPS8p10LikgqiU4/U74Te7jkKlSfzdovRI8UEjhbdBTFrIveyTpQ1K5n2eerN1yutDuv4SqvJWYASNpGWkntY0VsCLXQib0T8IyE49GEpRFBZCQqCZhdVzAYwpprIqACWu/9phuVe+NyXzqz/HSxuurqK7G+tGhdu2m7VVnxeu3e+9a3Hv32b944uv3JJ48X58uxHV2dvjK+3XZbQTo/P6+K8uDGsZD8+Kd/NblxUD/oujumk6WQwph6QyhO8mXPpre7UPrfYTgXYkpQD0GZ16shoiWaQjQrg2ZCqoxrUzQN1/U6Rw98iWSCdqKfB6EC6pEI/UEotjiP8VRUxleloVsal8VeUgkJgoLCICScLBIy2hSnL5GIDxiEjRlDVhG3fS+PSCMAQCbELb3VFCdin4qpdklIcxFYhSMFVZYBLACYhHoJAGBSWWvCARUkYyCEbPvUTn2uwvyaXAuGLJQDg2NPgXMOaf0axRNi70nVd+2oAkMCQlWkfB7NBRB+zXlL44FMSMRhmF2xEdSjPstEYQ3DuR3E0XsWZob5QyojJJXqU1gln/HwRDMcVzXSZ1Dmoqarx34gBrKx7QiwMDDNH0SD4MX7AP+1vz/b1qu9vYO333n4Vz/+2aiYbZfbZbOYn88vzi6u5ssbN6q92T77kHy12Wwuzk7ffvPhP/z7/+DHf/XXL1+dFtX03oP788vFar1dLpdFUVRV1XVdWVZlWW42m3q7KctSREw10k+0T/2HH344mYy876ydTKfT7373NjM8+fRz1ERRDJ0lE1Ek0UiFGVVF13V1XSPier2uqqoqxwCwrWthLsvCGLNYr0Tk3UfvzefzGzduPHxw/8nHn3zy6eP3f+ObRLRer99++20AYS8Xi4vDvf2jg/35jeXZ2VlZ2s41sm1YfMi4TGIpsRQOZZk50b6WODHmEGfHPMikwB9iKO3rpGwkVFKIzNAqPZbRZbp4/5J4DHsa3tEqALQ/X46j318xMTMdZK+FsrnUz8aZKRzYyzMRFxUdQUSkAKo/LLzPBWe+CJKtQG+h5yuT5htVDR2GMHNE4dPTGVM4sVdEIBkMIpo5E1WK/uyk06RSY2eXhwGa6zpTvx1plRLn2X3S8CPsBwOp1fA1FeFrHvT10Q0AiNUJPcnkX/V65pCkd8hMQwEAYKkU750wEBhjPBCIUOcb4ZIqcoV4MMQleiZvjDFWNs0GhKwpy9JOzQ2/NC++OG0+mYOU42pamLKtV+Q2ItumuYK9ve//3n9RHux//tmzi5eXsmkMbStu2XDbNZvlYlyNHj16RGXx5dmzl5uz4/t8Li+JK29rMqGnpngktJkkyulWg2V9LEmC005vw5gV0GfCDvW8sGShbRgIARCz+BTuZANKviqV0ATsTu2XaSEVx6s+gZkXi4gITbStJTjNlF5RAMDgKM3EFpOq2O87cwIlbNTYjVqL/zLSkNyF5dJ505EogaEpsjlnRMAq8BxQiB+h6jSv65UgIsEXgSZAlIfKFSHfC1oREQzNzLSM1mubIrSGIHRXZ8j7uRiJbRmRYrQ1r+tJblXcOb3XWWFkmiF0apITQxci/Dc+BNOR1o1GA+LECae0VpOUhrh6uwc956Sxvit9lXhHP2AMPg8CAB/q+FNuvP5MQ+C5JRpfEQxH0egPBgmUOkn18U2fTQABAABJREFUpKyFkXGyJkkdRBRBypAfr2/0zqXP9N4DCFkDLG1bI5rRuPTiFsvLybSsRub89HRM04uX8/u37r339nuf8Rfb1fbW4a2m6Y6OjgpjFAPj4uLi1q3jNx7ef3V+ttjUP//5z68WayFkBA8ihNbaojBFURRF0bYteAaR9XqJKMw8qiaqPSwWC/VPPHhw73vf+8HLl6fOuS+enyiKKCICCwhqqYCGzIhoPB4fHR21zfby8pKZi6LY3zs0xlxeXm42m/F4TNa0riltdefe3f392abe7k1njx8/adpmMpl8/PjJJ7/+UMRrBY0x5nd+93fv3LnXufr4xu3JZFK7K+ecq2shLkdFlJrXW6nlQjG/ei6WSJTFqwdXhVigQxHMYIVF+gzxHZqMLzI5vkUSBulvkRxvNFjVcM1NGAmGorsNh1PIkyIlCjGfuF9OdRhDPNcWB0TS84O3X6HZ83dldmQ+sPw5iVfkJxRFIGZtQ3QRqRHjI1ooh+ljzCPZnWPSBkQgoa2nKrJgVwAwomQ4YtHwiCAsaWSUaXhxnKAz1u93crBe59hSvL6kmvbhURGJHTHDiF976ZZhqvLLeGOmmMbxhMsEYde32gn0wEPMAkRM9YMi4rUtjppMKGTIOrTeHLr9o8O7BNO28W1Xd7x2bVM3GxxbdCNT2dJW0NnugufPV5dPrg4arEaVdNzWV+zWdb3gtq4MvfW977333e9+8vizZ58/HxEhS724HJG8ujyVdlMamEyKFxfPV74+by7vP7p/67s36Vhq2jporbHAiELoBY1ukfoadhVKDBWmdO10vEZG7Cyj/tMieRACBO3rE6xzifBqIEic7G1E9EyENkbjRMQziACaFGMHACFAK2wQDYiPnkJJ4b0cUcRgae0oeUQAgJFFvDbxUyMVQwqHSXucaM65OukxEIrp2fuutNHICNZGeCOzMHsRHxQO9Bza/u4msgYNLmWW5BJL2MReIVEKpouZmfR8Un8AHLYA2uRAND/fgOYllGQCoEK0MhhYtN2zMSYlV4cL+g61kUPBDmMyGeqGIeWkKH1ulz6QtTG8CKN4zfomohgczbqT9BorQMhm7a0rbVaXE2XaGkhMMCiIGEhTMAaD4q1I0MOFhVh83OgQooLI4wKJZ+amUmZIX80sj/g0hOTfyzTu8Jyh+EsHI7ItREQhAA7u9Omk6roVgDs6Ovz4w89GMNsuts3sxnvvfuPzz55uVuvLy6vCVkc3jzarVdu2qkMsFot7d24/evTuR48//+WHn0z29pu2LYqiLEtrCQ167rYbx07Go1JFqXdONYzJZNJ13XK5FBFr7f7+/g9/+EMi++LFM+/9bDZrmsY5x8zasDumxWjolL333nsBsqbEQspitN1u27ZtXQeEDN4zkwFT0Hq9/OKLLwBgtVg+f/785o3jTz797OPHT1brxcFszzv3/vvv37x58+L8fD5fTGcja6rtdrupF74zRUkx+UoXzeZFIknh2Fnq+IeKikGCXq9nhDpzEA1PomTkl9NedkTiw4ksZF7S1250fumeQ3DRpZ8onSdAkUHCoAyAXuLR4GB/5ENKP9mZfnxs8vCZeAPgsPovm3Jaq8D3ogaAMajdS4Lo8UjqiJJ9CLEbk2JPXkQwT2fpj4l+qL/gZGOICAQGCywuLVoPQBDrDofaw0Cf212NXuqnxQnpMvp1/hNEJAPaY7s/+dLzwx2dTJ8QrZvezwHQu3KHY6PcvZGTVqgZAVRDMbIXUXUk3tYTpQNXGWMEO+88SynGih1xeQ8f3B6/VU1vQTlufHO1vWy7dV1vwDMWst2uLs7O5i8vV6/W3WVX1sjUeIb1em2NzKaj7WJdL7e33nhrNBufv3rVrFezsnSrld9sxDWbdlsIo2HcN6eLk88+++rONx6++3vfuPfuAxn7tuRttw0FcWSJrFVTMAuD9utGwfuYiBCDDuAjbSjDDwScV/Hkl0UUAQYBRgn9EgEgwKnmJWdBZmDSQAFExIWWM4CG1I2hzhIAQlR84dCdK8FNxjy/cDEQgwUwMRFENA5twAKyptMjilChM9w9qAj6XuUYIN6DRzHGUCRKUrUj5CIYYHYiHkmnKU6t5Yj5MyDTcCyJyMakofDqMIzUdgGyVAxmylCkwvJJrc9Pya5axCVkSBBtOqvBmFMPSPLrqCKl/p7XbmSi8rAsCh+EaFKIihlCdIwARXMygu8HwIBn0CwqE2I9AXFcK+kTvC5k7ExFcn7AII3W9M3b1NkQqqdIVQ0Mt0VdgUIJHybLINB0ijGDj310dR0TJ+DAmSDMPXFMFTlKBproTpGNcurfRwOcAFCBIyLCbE0JyMwsAqaw4qHrulFpbhwdTacHz16cl6X94umn9w4fvHjxfO/mvmv9er159erVjYMbz5pGMT07z3fv3/v444+vri73Z5P3H71z8vL07Oyims6KoigMWoKqGgHLdtswCQDWdW2t1Tb0LcBoPDbGeCez2Xg8noxGo8vLy5OTV977o6Ojy9VGW6UEauxTtsIutm07n89V7SiKYrlcrtdrBrE2bBAZMEXRtu1sNlMJ9+LFC3UA1HWtVHf79u133n5zs9mUZfnp48+I6OatGwjm+ckzL+t7b85GpmAU57TQBpXvhAakGTffETMAwAhEihrd5+5IKNzSUEhIrQxaSIQ8RxWiX2+8BsAGMaTyT38hos4EBCLU+s++dzFi0NSvnyweWrRDSaat4VP6SepavivwVAMeOGujIEewOgARiekg+motr90NCOZLGNDDQDHEBGL63vDObOUD+CYDSJKXAgABqSm9Z2i8Rh0l1bCoTAUUDCsQmEM63foPVBHfL1o8nK+94m93P47LBANGhMICGbhzvzvymof0l+Q6Wf+KRIQIBMHlvAMlAgAGgMlkTpvXvmHoyxNkJwieLRXWTmxjeN6t5yszkRZbPPLlnf1qao5wVFgCEKhKPz//9bNfnn94ubycS9Nhw4XgupuvN1zZAr2fn55aMW+++ebR4a2TL75o12tBsszr9ZXfbtk326YuxuX52UlntnRs/s7f/nv33n84ur2/qFdehFwHQJrs5TouCrWFg7bBr0OVTPCbEpNz1aoFgIDZGBxp4j2mWGhYJgEAtISlgDgIIKQAQdyR8SIEGDvNBPheQkohQNJSR9HqZ/TJICHtToqkzZDiaFOdzy69xVOcZQMIMgEJIZiQMWIpPzNZxagC7RgAVjCRQDqB0A2gYjJQOO0giNpvTzRF2oburyn5kVOmLoBBMIaQsCCyhFmQiFDEk4GQY4sBN4aBwACIWBgU4wgXKa2MYr2GiAgJDXwwjIiE4jnX9kBAkDxlQRkYHksCREQZCvJwD4IIB75NwTFA6EEPLxaUuSKNMURWqSdsR3A1DZOw/ma+EFTdZOFlaLDiU6mIokFg7P09MCDiPmKywNLbRWk8cDgwINL3q4j1hLFRu5fEiZJcSSQH1y7E6N01xCikeGkY1haJtpt6PCtms9k3vvHeh7/4+KdPfiEN/vB7v726Wo2rSpxslptxORbGvf1p0zQffvL4B7/1m9/61rdOTp6/eHmCKLdvHa82a2JAz549oSEsRtNxURTbbbPZbBL/V17gnSvL0lIxGk1Go8lyuf7xj3/SNM3x8a22beu6bra1916xt3uCEREiQ8TMm81Gk8m9967t0NCoKAGk6zohBCJmnk0ns/29Z19+tbe3R9qcnRANIUK38c+fP19cXd67d+/x48fLxfrWrVtN02w3zcX5eTWB8Xg8ruy6XbHzplI2lLYyy0C8ppgCQAICD6cqAQfFtI3XsvT4kOyAxCu/IZ2C/KUaacqjbPEeVVN2kk/7X+WPzfQP9UGalB4d4wf82rcDBF066x6gUi2mZw7FfDbT3tqJD0rpn5yOiLwuQzas6OuWMd2Pfbb+IG4bppwMql28V5UqKUVmd+S5ohlHhYgJYfbapXwmPh4RU7Z7hF0fhFcSaamilTpaXFf4rq1MX0CX1BREFGHlLvHD9ICAHKFr1SMSYj9B6D1VuEONhgp0jGwIK9OW27O6+XyJ523xHWvFOOesq8lZZoFGoOlWq7MvPn3yyYcfz19eGOFRacW2db0dFaZrOyvSrBbL5dWb77731nvvdlyUJ1/59bJzre8c+Mb5erVZl5PJ08366J03Dx5Uxw8Pjt+89XJxPl+ejvbG0loQKAgNmYYdgxdwqqdpJc4uEQUxZ4LSF5sMGFP0zYwAss0qMkeIUoUgorVm7L0nYAhVG7pOPuQW6YOEkKI6o5mcTgA8EhGZYOZzZuLHK+naGc2JCOX4xISa86H6BHFsMZAsGYWeA/EiUafWHgUqG9SdiCwCzOoR4bjl6pZkBBPNfnHSiVZwxeij1uBpwpFkfiSN+xCpymIEC83oUJvPVhbRCrAACQKyD0jMVIBa6CLqhw+iGgsQjamoXRacUEqDSTVBtEiKvIN5vzSI5a8D52Qm9a3moFDvxBsqJeloJZdJw8yeIclm7z2zWGOIDKFNITMJCBwDyZET487R0stzDf2xz/1SfXktofZfRWNMaDAdtd6eD1JUQ7l/OwCwlulmvlP9lnOFQxCIRQQJsPeN9clgiBjq+rK56BkwxnRdx+yttRibnZblCNHU25ZMZa195923Vpeb7UX71tsPX5ycTSezN9544+zsYrFY3Lp5x3V8586d88vFv/yjf/Vf/Zd/59GjR9PpdPOrX+/vz+7curm82lhLZUWC0rYtIiJYZi7LUlHVRcRaCywoUBhLpmAP2+12u10j4t7ewWq1cs5BBrWI6sBhBgDFEXEK2R6LnBWWo207Ij8ej2xVjkblZDJBkrIo67qeTCZnZ2dHR0dvv/325eXlixcvVqvVbDKtN6uHb9xfr9fW2ps3b1VVhQjb7XY+n0+8cb7zHoloMhl5BgGvZzaeVmBmGkCSD6605gG8OXD6oKwMBdhuyCzJlYG22l9BX8wFj9KG95ioNQ0j+mbg+qPykOtQGGOM65uUG56Ows4045AgegggK7rxSdkNdyLLINQieU5AKsiPX4VsUOb+DKZZDOe4s/gIiteMGBOrBbIy+PjbGGRM6kJq0gsAAoRWLROArNFpBP+4fqVPE6dKF4ZE2v6fceT58qbp9OvJXiSaB6+d7LUHpovVpyZ9IE8vk7CpoO8wl789iMj8V7ojQ5eYAYCCjEHLzl6dr84+vShO3LGfdM4VleWxdeQIQcTVy+biy5NffPKzl89OYOP2yqlv6m6zYWq9NKal/XK6mZ/77fadh28c37692K4dVAflqKm3db0S77wXz64Vvzeb/Hf/9/9hfAivVl/U5urZ+hRKMmXh2BemkM6B94AE7InAGPTsYryLRJCGeFlxLik+jgAhNWDgCxAGQUIrmcIR8OERbeca0EB37MKlbwwu61jJmZRfYBTWUmwiCMiXAp6jRh/0h3Aq8uipHsggazLKQ0ACMiLixaMHQgowGSIAbKwgkpfQ0hOjh9M7ZubCoIBnr65vLXo0iGryapW8BQBGD8CAgEDqNNJsUCD14mg9HoqASLQU9RFcIiJAQPP3IEgCBGI69gFmhNASGfYAzNqgvQd3CGQnlsYiEmDBossUEEhUVTQhWiTM3jMAe91uB+gj7RpCBT1kdWcxs/eCiMYYF5wTBCLsvaomRCQeUvwLxYuw8nLCApGJPCd81yI8E5D6Kjf2ylxs9O6EYHbvQVXNLyAmpc6laIrwB4vE5tcSTVhmZvaETDY4tIk7iL0ChxkkHSKCtkf1Ae2HiIwqdeA96IdR2noLACAoXoiwMGU8Bvo0lTOkiggAEBaqy6AARMgaIhHfFihCAOIBkFAEUNgh0HQ0Wq5WhM2bb9+cX966mtVfvPrqzs07l1eL6eTIt/jll0+PDh0Ys1g29Xp9dv7qj/74X/7Df/yPnHMPHjy8uFy8+Opl2y09Gw+Feia2221h7Hhklc+7wjRt671DQwyw3KxRjNaAVFU5m828k2273W63ZFBLXZh5MpnUdS0iVVVZgLZttU61MFZxG42x27qeTEYHB0eaBDoaleLZbdtubKtiVLeNYw8Ar05eblYr55z2Vtjb27PW1uvNe2+/U1jy3C1Wm/OL0/nF6Y2jB6v5ejyzVNqtqy2M+lYXwnq8DRrPHUDyWgNACBcasOJZFXBESKFN5UOEqO1Bk2kMAVoEIeyKALCWjifYniQVOEWURUQ8ZmBfRGqNgIhLOvoO7WVqetD+e+bjFWbD9iE/AIUMyTivpPT2qLUDSOyOJknFURbqvPfadDe+nYhIFZLILjRHxwmIUCHqvASO2gYDgMJ55RqG6lDabAzD/QwxaVRDAwoVkoVrX6916XMTiEX/ItQUEIAAx8kBwQIESX+R6T0hq3SgEunnoC5JAMCUww5RsNlsRvqHcpVcHekzbBIgFRFFGtA3ZnMU0th6TNg3UUvWyTIAIwGAF0kNgEi5FxiLwcGkRT3BI+d9B2gQDSj0A4IhJoKl6wir/WL/9JOz9dM5Xfp27fbeuF3cf8vevA9VBfP1ZrM5efbsy88/a7f16uKydN26W60swKjjpqnYF8K2LFq3Lm5NDvfuzSazDizOa3Ttptws11e+rZvNdjY9KCZ7+4d3v/d3//6j3/3vF1efv1xfETYkrTATVihWwGNhAawDIKwEfNu2Il69qkmUZ9RshS2gQaI8tSAia0dBL8FxoP9KGlhI/2CxuSU6JLLgWEgpx1H7M1GcMjMyh5dpdYYIgBCGPEqSAJmSeb0y4ojUhNqgABENWjYIsRRBS1E1Nmmj2zPaPYAEhNrNAxC1Lpd67z0yApJFQ4RoDKMLKHWIxCJiIFRFB4g66m2FMELBgPSCSCHSiRGfVISN6laK4c2MkdwlpG6jBGVPQTiQE1hnxhAC05GwdpgYByCLsICHUI8E6jEhUveHT17ewEwJBXzwM2E+EZPMKVS/VpaUKUKIsQwHEQCJBsW6EX7HJArJDqRO2SCicKhUSRh8CCUm3RXC2WNmjewRCpJg77tDNBEEpc8po5zRgDAlNzUiWSsiIN6IB2Lpf5KEhCGiFBvShPkQKYdkGoJWgsRX+FTsw+xY2LlORIrCVlWFaJiZgNfbZjKZoDFEl3fu3Lp3PPoPf/GT1eVif3roGjg4nC2We9ZgWVUv221RlC9Pzm7cOvrFz3958+bNz754+vSLLzebFSJ13ruayRhrbWEtA3jPVVVpjmcJ4Bw751xEJiA0SNR5P19c6RKRodKUk8mksOUPfvCDTz/99PT0dLvdWmulCyFC1c5SOLYsChBp21abyrqu0wqUruu6riuMHY/H3vvVZu29H43HgqDlM6PR6MGbD0fTifL0l69etW1rTfn8+fOvvro9PjT7x7PCVuCT8GNIkVtUaykkDQCAgu8pHTILc/KNB3pwHIs8NWwbUs5DzmgKxKiOotpLyl5Lh4shYOQECotuRBGMHtBYnZE5xYMaDZDlb2KSc/ESEfBerC3iv/tmhGEu4f8JgEGMnugskgKRVjFLkE/NPiCoSZkKg5ANVDwCxOiCCjtVHQZBhLhKSahnFWzIIKm2Ip2a+GXOpPJ/Zj7IJJkgDRlSEAQR8FrN+fUribS0oVGD6bGxg36z88s4PN3xeKwBYzREItZzP1oYeqriQ7Ite43jlgEIw0RCISGiTQsdViOOxZoSgLwwMhORJQMeu017ODuUtT/96uLppy+buRxUN27cOSj2bnDnFq9eLVerly9fXl1dXc3n6+WiICPoEaUqjG9rMDwajXzTsngCPxrb6d7e3sF+aat627VSO+HVxYVzHSBP9maHR0dX29aU/uGdmatfLVbPtvXcF1uxQmSFQhghrrZuKwXAtJA0vbM7ABTKTqNWEdZI/wfBADKCarv9qUl/JIPBOrdIm5H2GzHUG6Wd6H+JJmxhIPVwcnqC4NBCMO00hqC9VsJodltmFohj6cALoSE0TApvF/EBkaOGHt8XjWxEIELxPfCcRjDDdEL+i5eY0GQAWYsw0FBCRBXq2IMwGnVm9phogZBQiNAYDED9qE5a8qIAqMjM4FkwpHpR2CfGmDUiKAxA4KDHy+oPNkWECTVf0gEwhlIWR2ycAQrSp/kxiACCxoAIee+HELN9IDPyYdztlA0ggDsYPMmdG/cuHXvxvYESm8cG4kNEImOizEgUbKJm1ePlE/Y7i8gJ/AMEYhFQsi8H5ewqZGIKCwOAxREzM7uUYacWls16uwRVJtOW+j+yJF+h1D7UB3saRaDDwpQFN03jmesGALxzbm9WVSMqx5PxFBaL9Scff/7onYf/7f/lH/3Zv/wP7da9/95vnJycvP/+u6vV6vOnT+7efXB2erU+u5i1/pNPPm0699VXX11czavJWFrQRqxabhMauAAYU7CACviu85vNxtetZ3YgnXAq7AQQa21Zlkbg/fcevfvuuycnJ1eXF75rZ5OJiDRt2zQNAKjfKy+y6Lqu2dZQVWVZtm3LrhuPxyB+tbjywkVZ2LJwzqEBNGDIeu6Y3WQyee+996qq2m63p6enFxcXZ6en9XYrdS0exqOpMUXbtSYiEiIBc6gHiBSUkZ82IYFYfQDc75eKi5APqoZ48KIhYi/oBCR0yxVULJZI35xlIcSqATRg9A15NlKk8yxvgyU6W7IPJQRwIYreBAeSEVVAtMsZZiLXrHV7b1Hot2oeq3REkpgBCiDXUc6CIoKxDYWk0EbsRpbOcjyM0dJDH5dzcCVAjjDT/ic7ikus2LrmBZF4f0QRDLat8jkWH6Wx8hn1qEpiO9FIIGHfy6ZoWAZ7LE6z35H4Bw4dRfGBkLWAULfQIBCWKxY71446BaBP0I818mIAUhPKiEEQ+joIQeG4AwBbILBI60mK/WoKa3v5YnHy+ZVbV4ez49vHD2ajcbttP/jxXxZl2XreNrVzzvuuKMy4qpabK/FNRexF2q5bNQ2ZCsgeTj0iWmRsG/aOm6Zt27bzrm1NZcxoZEt72S3Ors5xW/78l386g3ntrshuqcBWiFliW0Gf5V7oyUIAwYGC26eFEYYUxpgOEDcpqtUIZgA/8TULa7uocCSVJ255gbFqfEf7SzpO+AlpoYFasYyI7FOYJ6aaIiqohj6KZZvG4aX2biVowBREVosx+oMUgxPRU2gAINVAE1LLbdj3MJ6YFEnEDJ6d9x1iqLwwWDhw2gpWb2NhddpmGIKS67wsDrFQwhXRpsuKEkqYUmy0PWTgHaqXSHwFBq6x2zIieQgosYb0eZS4FjKtnKK/J6iiDIik00z0DsG5moUk9OWRVcVP1LBLhz86PgI6SK/1BwdpMEx3KUmdLqG5AKDaZwIAyIBFUD7COQ8FAthDMmspSmLEJtOdE6Fj2JSgcGBKXyVjEFgjYkERZmRmIJc51Q1E9xpEigSIHt6epD1xUDhSZLAsgAGcc84a8IzGGGOKEowhY2i9qsfj8f17b39y8EXTtW+8+dbLkz/Ybrpm499+++2PP/745OTVetu4FyebtfNMV4uVc+5qve66rus8EltTOk0cZXaOATwFMOCthqWMMdbaqqoAgJmFqrZtDRktYLGFUbFX2YKZ/+2//bd1XQOAMcZ7d3p6uj/b0wkaixo9Cfl0HIonFfEJPDjnxPuiKOq2BUIt1iWCDsULH+5NmfnGjRvj8fjk5GQ0Gk1ns/nVcrvZnJ1eNNvVjZvTsiyJiD14L7ZACPJeBU/QOQisqr+ZWhxKBXSYRJS6owEAZVBRgaIAAMQgAgKzAJJSBAQ9GQEwqBeKRx2sHf0VUN+hRSRT3SL5SQj49tD78aU9A5Uk24wJ93g/yAHaiarEn0WYrMAo9EqhkDBB1TYyNhuCLykeIbENmzAqMFeyEDjmMO4Ao+FO2GLocthRLAZTHjoGevXimicgKCJR40PFMEjtEyX3DUD096S/of8wJtzoHDNu87XKgYgk4y2ZkOGrACORFnPA1dOwITaKfv1qxDsBJKbpxCvW7XFGHQDQBoh07wSMkMWRlQq74tmnV1cvF4Xbf+fendlonxDr5XJxecrNGomorIw1aAgFUXxdb8iSb9i1jRFXWUJbfOcHv71pu4snH7Sbup0vGmtGRekFvevY+en+dNHVUNC2gIv5havaew8PL+BkdWlMIVB0YBA9alYhxgBQnKDKi7RQaZXyXe7/jLEOXbFce7suIOJ6xp9Yz7VSVXIsR002HqSYhohB648e+ESOWvcPRbwBACgVoxKRFsGyuMT1nF+nMXm/brsrImvZBvxsVUeDoRnewmiIbM4mEJEF2W9FFA1U4p0MAFZsTH1Qv7ohsiJdaNwSCU0hWBHAuT6ZUdlxXKjArDWzndMSkXdei+2VZUQ9SWOrkqiSe1Um8MWBT0/HGBNQIMKPQoxMk4R7IHo7rGqjahIBpIYqanhJTPYUJQuDkimqIkIefECQj3SkoPR6pWz87OwlTTYZjvmxHLCe7DwrL4hujOC5kUjQPQpc5BcIgBF+La8ISJYK9/qH9jkIyoFuE2hmCoTwDYUPoxafnRBRL134BFiYRLUWoJS8xMDeexZblYWItN455wHg5fOXo8mMWbwz1ah4681HP/rzf//P/tkfvPjqVWUnJ/b89q37roO2k7KYPvns6a2bd2azGSPb0l5czGd7e6Px2Htf13XrOmb2IJqOZIyxZBTFi5nruiUia+14PAaArgU0XJYlIgizFYuABmi73T579iwJhrK0APC3/tbvfP7kCw3nF0VIplH6LIw1ZIiIxXlvDYbmA8ymKgpbloUt2rb23hfGlmW5Xizff/9RWRTeu1u3bhZF+fz5881mU29b7/1ms72J+6vVZnm12iv2xmUVxaoScC+lTAbQlJNNT2QRhl/vL4l7bwFC0kGDIhLvBICIKKj/0Dhp+FBANFQnKdsRBAX7LioxrKbnAFRFRYkprv1R9cRqmKhDoq+kHdS45n+znkRmJ6KaRB+UyWIr6Y8woszZkG4QSVg/0dIjkyrVg8EQyXsHDjVNNFMUcr0n7zSraiKYJFHiM9OuQQoDJV1H9bPkX5GYAqxpUZmQTtmdr7GDJestFz7olYCvNZpfewV9S58gg7OPiH34NHPn5ypamjUGP5beDIDBpEzmXHAIYHiaEoIXX5TGC7u2s2Y6srN67l6enNaLSYlHbz9882h2uF5eXV2cLS9foW+JqHUNsKeyAAAkKciAyFW9HJfWgBHHDDwp7A9/+7d83f7/fvkfsOm4bmrvGgG0xo6rqipP6nOYjO+9e+/Oo4fLerneLmaHY0FHtG19y17YIZUja0oR77klY1QvDCdLLb2sbGdH9+KQs49pvtd0WciXsa82678mALAcW/fk3AERJaaBCEsol4iYjwiIWkIj0heVcB3pGxEpRdBBKEhjTqAa6H2ThtH5uu1WhsijJaKCCki6Q2/+ClApojkHKNwvB4ecL88gAOxjbK3hRnPE1HICJs/kgchq4kN/WkLRgneQnU4ICyIeSYiACwEbEx0AEIE75SWpZyOL996XMPaZIxSDjQWp5ESCimBiaSnLACdYAFAYBVw4Kn0IKTXJIwBiYRQE6NR60GZUGIHbU4RRvci630Ebk8BxMCgBAYAleT4wOdl0gQXgGoPoJ4iImuFFgW2A/i/5RJsa8QiWpSFmjlkmsJtygUmlSHoPR00Fw3aR2i/JXhSAkN4ZdaNo5fR+dopPoF6MKTeMFpgEGBlEBIPYCQMZY6yIbNbr9XotImVZHuzfZIbFduGcG7XVZLx3+mr5ycdfjfyEXTea7P34rz44vnm0f3T05LMvy9Fs2za6/rYsnJdN3YzH422zbTun8hBF2HMLXAiCJS++0J4SzERUVZW1FgX2J3u+qiaTyXa7Xa0WgmCLojLFwdHt6XR6enq6WMyJ6MGDtx6++WC73X7+GaunJOpYapSrpw0BoG1bEamqgojAkHOuqipE9K5lkdLa8Xg8Go1u7O/du3v3YDYzxrz46tloNL44nz//6tl8Phfny7KsqorIjkaT8XjqJYVKAz1zFOQWfH+Wo72rpCnB2lE3Xth34i7erJ6SxAq8KuV9jbpI8g8DQAjCilcU/FRWHc9jTAMJQPi79nrwAwUp1etMBtkY0Bo1gAAnI+E092wq46KYKE2iYx80Moypa4oP+S4oIQeT0kOCWR1zbzgeCkX9Ee+H0ZbYgym8LnrwEk8LX2U+jx2JEs8LpEKP4ZHv9Y/859lRChGlVMUQoIhMOoAQ/3htYkdyUUvYp0wX/doBS4Y2GT5JmTSIQBDzFlOsVoahvb/hiuzXAkZrFgZgDIIx+AZAGohjIQFp2VJZ2il2xfLKLV9t1xe+FCvsmvXq2cX55elJUy/RNSNL1d5NNupZdYKAnoEBWPbGI7fZOobJZIooF5enH/7oT7fr5dVXz6aTyXQyASo2bbPq6q7dEhT+9uzW2/dGbxzUI0/jkZ26NTgyOGYRZlvY1qVWdax59/HICPS4rtEfPyTm9E9MHSoynSPeQUPUfF3wyMnj8bSaR75jtGqsIBM5wuJinzCI9ipFVzf0ij+GSgMtEyEK3R3Vgk806rjfdWHvWVPEnGFy2KZppDmLCGLbH4OU+51ZGEoQrNwn2nMGAsqFCKIoElLoI6qpaKzhHgTn3VBZi/IShD15NgGHIxpMBCG5XZNCACBgK6HnrOccx6iYE1A9SalfhToAENoYt2JEDKFSMCxNlBYB/AoBYyiAALQds2cfyopJM+RCQFYwVpEyWQSnbhUmEVaXr3gJNKKuDhHShA0MpmBQ7KWHGutNA+jtJ1X7Q4Y49HxBYr0JZiQIukqRdvUGE/P/Jaamh+ONqEVDGBYymTuAAELgYqm4xrCV9yGFaH9qGaWZpylXTlPt1LcBCMzxfRixjHQTiqL03nvv2rpzzlVFMR6Pp9NpVc7Ozl45V77x8N7Bwd4nn37Vtby3d6u9XC/X248ff1JYenH6fDyZts555s7XKk0L4Wo8EpHWOY4ro9kVGAqOgm3qyFkKiRdNs+1aBIB6Xc9mszt33ppMJm3bsrjz8/PFYuG9Pzk5WS6X+/v7e3t773/z0QcffPD5559XxUi17YAJBpyAOrzvBAoWqZuGCKqqIiLddRZn0e5Np5NqVBhrrQXP68WiIrO/v394dFhU1YvnL5fLpXpi9md7BKaqqsODo7KqluuFtWXSnoXQIEYB4KJNrLUbvUwTzV0Y9tjUqq4B4Sk9IqtuOlA4gjCORIIs4ClyjySJQ6v6QI299yJndN4HzX7IgiIWS/QEU4LUjsA2IpKzOEX8BFB3qRcx6uSAkKaqJpzocUrD6H2V0ekYm3GkjNhwL3PG60H6YEQWd0+CATLxsCsnwgPy1Uh5QgM/R1qQ6z9HRAYPGKL+iBi4Wb7OvQ2d5BynArq0L3HTMxsj/BzzPmDhvaEgAiAWP8dXQ2Zb97FgiZD213WXNMf8vyISAZaSQyjSNoAE1GdUIEtiMQIkI+kQsBIuN5fd8mUta5ryDWB2dfti/sQ166apraVJWTDL1WaJ1hhbaM9RLaIE9O1mM67Gx3fvA/v55ct6Mf/j/+//587B3mFRNM36tL7qCuK9kb09ndw4KGeT6ube4b3bOLbL5ooIrSH0BoWcZ2FTFiNBj0Rd14mw7XunQkZdmcOs97f192U6aDDtJJayZ6sYy1uH9JPeZfOKs6FGo+1zdHMyGGkmRITo+ScgFo2aq1MURBTkUkUO6fnUv9NQ8tRrx0l7QkHxrqNYeJO4CSJKLKtDxNS5FADEx4OEChvqVNVQZ4AHJq8CVNFbyTVeGRupxa8USQnRktMblV8LOJXuISjjwpqUhKAVLMqJOHhxWmhS5EgS7WoxPesO6dJFF7HyTfCRXRoM0LDJCdS3W9Qf6kMMFSHTHgxhicmLBB5z7sBOgn5DHLib7og6n72WBWhuBAsTUp4rpFaciFcGt8O8AEDEaWJszCpDCNpeoQgaGGoew3i8i8St4IMgwV3MTsQKBacaqF4LJio3FFhw9LQJWgo2dOQgEjBMVcDo2keFPZRkB3aMHLv1JrXJC4RiIc2McezarvWdM4YODw8tUde0i/nVjePxdrt2viHj15vly5cvrq6Wq+UWXFeNy8vF5bisAP3yfANogdBzB0LONY79eDwmW6prART2lXvd1IuA94jonPPoC6OxM6/JHMWoulotH3/2uCzL/f39Bw8evDGdNk3z5fOX6/W6ruum2d6/f/+LL744OzsjggQF5r2HHJwAgUGMllI7F4GNqbBFWZbGYFVVs9mstAWJZoR0XdMqgMfdu3fLsjo/u+y67qsXz6/kcm822Ww2OgA7NsYUwhrMiuwhig/McnFivkVSTxUocIDkC6aIXsaMbYkn03tPE4OCGHaMGTssACwORMgLEZFBABbP6aClrloZJXsRsUYPLvbcTwRANOYVBwyJzp1s83MBUXCyhPb0AOB9x9JGEduC6vdCov0FgQHYuxQBSQIvl382AtiElbAJnwNz8alQAr3MyFloPIbR2R0ltP4rfhi+9d4ljyNklzreevbQQxX0Lx3Ke1X1MrUjD+LE1I38gXE417SinXvCruknJugcENoEEhYJCSNujbrQ0g9fr3PkzDMuiJpYUUPKvGRqq5AAsqAXEZiayo5n67U/eTHfXELlpxVNfM315plv6tX8oiiNtQQAZEZN23IBBREDO+fVJ1MgWDIHe/vGWBacLxa3bt38/rtv/Kv/6Z8V7arEyWq72pCMb966+71vHH3jDTiYtMDCvO1q8QYtGM/Wk/WEbKicrDZXdcdt50ajwhjDDF+TqKFL2S/aAIYj8wWKJJtQZZNHNANcFmT2SeNMITYBAJsTK8YLokDSfSK0gh5Fm48kayAGR7EAEJAGAYH7JHBEQfRaVk1ZUiczi+9NXtTugmRFE3EqZAYGJjIQkhsEQEyyJAA9tymQWFAVEjmzAhaIx540fYQFQJy0yMgoBGgEPXDKPGfJUO/j0hhjBChaEpoYC7EdjNQdxg7ygIhkLZN37LwPNREkEEFyIPX8RTAiJJw2TxHZBgcg1qS4oGeELPSQ9wqsKD3GcRPPpek6dF5JRLNlQw8aIqqdM6bQlFsCg0AUauF80EJEAJFD6jUDlF6CfUYJZgWEPcftDhxKNJdR2DvUmiFjikRAaFm9KD6TqYgo0iIiQ8i6weiiYBABy0LAmjxohIE5uLuEBSmsmCZ1sNEsDJMCdjpg56PiE5wdSYZpvRwHjDwCBhFmQ+rftyJeokNYRKxwWZZSFF3n2bVsLYM0XXv66nlRTRsP6xp8s/qLf/ejjz/86OrKHY5HRGgKa6oJANSbSyLvwEGLxhBRyeKbpilLQRTvPVlEF1L+mdkgIgGzJwpr2HiHImVZItm28443o9Go7tx8sXzx8mS73b7//vv3799frhfbDbWNFEXx2ZPHi9Wy67qqqsSz94CIxlpmbNq29S1GWFugjsiCIURNhzWzsjo43CPC0WiEiG1dA5m2aQ5v7I+nE1NYh3KxvHr5/MUHH3xQGLs6f3F2ctoeHe4dTG7dumVKU3cbsiRsvB4KTVXWIqwQMVGzlTPjSRTYKspmAgW7QgRGUsj7TBgAWK8ZGIICqY+Pnl2XUnPQI4gYKAEIqe6RGFDpQHUKEQge/8AQQVjYBHtARNQdyKjV79apnZPHcxHFyJiZAYSAtXZev3JdrUVsAEDkRCahQA7RuZbFA3HO99lCSPnCEHdWdB8fvCYpmzIcQ8MgqaQAU5a9eN8JeoW0QEAwuh0oYERYuAV0QQYE5UCDsCllLegTFMH6RLkBKMQiECFS1DkEg1XpkQIf48hvISBQi9obQUFEEuXMXQjBI6JTPBVUB7CeQTEJNBlRkEINGgAimujUZgRAQ5ry50MUOGTnMBuyBIDivEuZ84geW0DtoxWkZsyZMQC+sABNxx2DLdAykq+2V1fjY7bTYnNZWdx6sqYcu7rGUYHUuHYMPNo6rErw5UN3eHzjrfOvXn32/HK8rQAKANttt7DY1tIIy2h2iLFZyaZtuBDLFVJhR0YASEF/u7Uhf+XlqPDd5vLi1Yu/8/f+H8vN+stCNjOiIxofPNi/eXD7vbf279/eiNvyGkiobapq7B0TQedaMZ7FGFt23RJLwyLWWucbAEBCZjAIGJwCISylfBVtrt9nLjUhdXgndUG1TAx+QRePsD4qPkAEMQgC7UjeuwogdR4aKP40aPyY4jQAEOOmIdvREMRkaX03h1pqAmQtlQu9VWiAYBbkUHpD1Ncz2RZuTDdkPxyU/OKgXG2Qm3JdVd+5MDNo0s3qDE8P1Cbb6V0AnAqBmFkyH6BIqlJ5jR4dLz2cbbpNgksQMTZtAuRo4gsGNiQspP6ehDcPAF6VGA5h4BCFQWQE8p7JgmiBAjoRYRw6Qohi80yFFg2LwPmqDHwbGKOhipqq+pC6GIOa5VtEBKFo1Irq1YKiPYnDyqQ0JaEkDAA9kkUgDLlKSm482EQlfQzIhuEkaKmOgAgBIiSE06T8QSy3DAEgSMSWET+KcGkLjRrEtA8siuLw4Oj5s2dXy6vJ/h7AjZ/81X/8w3/xb+bnKyzGrhM7ov39fRCaz+ehMMSDwQBI5dkpcpm11hiDJAiGiL1XxqyednHOCTMZg8bYzKQmovV6jZHwnp+8ePXqVdd1N28ft20LAAo8qrAZxhjnQUS6ruu0r5v31pIpilFZaqGvYktqHxZmu9ysy0l59+7ddrtdr9fG2K5rR9Wkqird9Nu3b08mE0Ssqurxx5+0m+1oNPFe6rouiqIqR2Kl884YVUV1q7VcNWUySXLGJvphZBAyiTepTqne8rwjV7SHRFgg5SpF1y4EPAxVE0IGgPbcA2JR5xiJMAh5TZgISB6pDXo8yMkbFBHtEFFIQCiCGiVrXpUJoxtngh8xKARkSsQAnq0tv/X5JGCNZXRIydcYKFckxJ0FPIKJyWddYlBJQRERG9NaVR2JwKMiWCeovaijkCAgFCIepErl95qc5bnJwZYAQo8LspqpThFQLcANWw1JuOgDDmBLCKQe2YRmFN9PPuqaPq6PBwAjBhWNBUL6WACjpGh2i6abCTOjKkiakichtxdAs2eIVKnJAaMAED2IFw8gUiCiCVxROYQGQRD7HBfrUAQ9orcFohSMrfdblIPpnueCl348Hc/NSrzYq3ZGxR2zbZw55P1JVxbFuFjx5mw1feNo/h+/ejm/Wm27Du2267bbLXbeAhBZIEYBQiGBjjsQIbXSiqIobdc6SwSALFSW1d5ov1udXV1dTg/Hn7z4ZNFu/tb/+e+W2Ni37o5nUye8de2qXlpr9wGAZbtXbduOCuucK8ajTdNQYRA7G9qM6MIEZkgUdTa1WFE963qP67MpMol5XYAGuo04biLKfpVEAz5TuJUgRfhtnzkNRiDUYYiIQSuiu2NCCIQ41RMqX87zwzE4SzStEwURgZgFjIS0TNVG1Pk2wDlWxM9QVC/MINoBjiEwg/5YxrlqNpBmvnCU76gRtRjP21UgJI5c4lLmz0wLGvXu3tEKUQ1SAzH5NqMXF5k5dIBDSYqRotPlKkgUHj7ugB77brB/KhphkOoV/ogF+sydyuGkcokIU9S9lOlKSPswgAwo3KWGtMEFFZNUVAuRVNsSclN6hqX/1FBOXKvMMhOHYEIrODH96sXFyaYmesIlu+L6kEGN7nUAQGRJOoBY+fM6FTOLMSnNhOdgSOmX4NMJGreCX0LqktATX4gfJS4ZTDqRwnsv0teUlmVZlaOH9+9vPpufnn0FLP/rP/+jzz6+OLxx4MVvNvXe3t7hwf7V1VVRGul806nzLyi+XoS9J2ZmttYmfyIR+j6hEolCilppTHTIe3aeBfVrAHbOdV2HiMDy2WdfjMfjoiiIqCgKIAShpu5MH5RUaFq01lZlqf6z4NA3WNqisAQAjv3LV6/qpjFERVEcVKMQImxbZn7w4MGdm7fOz8/Pzs7YeWYuy6pu23feevPhO3dm+1NjCiZNdPaoXIgRgtmJhOiBAEEw4fKh+lARINjXGA62DC0NDEpLPJgGkECAwy8jP4qYLgEtJ2gMAAo0HJgGkfrUc80gHsxYuxaOVa8YBfIQq4W4yvr6kx4jQSbZLMChHwfELtDRngEBFhAkIBOSDEWCIAUj6AWGuoJQRM+LJ0u5dKz2ivQqEJtRWCqEBn16CQAgokOGc61fk4gg1APW2rObNuId9i53RDRDTBdMCgduRVLfpUDMAAlVuY8LKysjZ9OegqoL6EXEkxdR5SFAPguCgDdIgGQgZbmF8WgOIkR3CIQ8ZRBoQIhDdjwElQVBu2fGKfeE5SyKgENoDVQCIw8jKBiKTVtPOydUAMONU34TDivcW7F/Z7tZy3h0+JD2bnDNdPpqvJbteTv/dL7htjbYkPdtA21DFqnErkWD1poQZbM+Ofas564Suz+bEdrtZkPj2fHtmzf3D//Vn/xly5dvfuttc8fcmN0qx3e2m8vO2w4Fy8JYcuAbEe+7siylFmkBCjBiUExhSlsW3nsIsFJZ1mPQsHO3Qm9JSuwfEkR8dgyxd4n0q01ktPE4xOOrXzIQCEfHAqdgqg1Vub2UpXwjOOTsGVVbEUMmMw1jOaD7iBj/P1hmHFwiassqOIUe111ng0jsEiKDDwVidCB9MSx0hMg1hBBhkITcHzkNUkivHkkoncgXOhyh6/xOJJbLS/9DRGRW/7AVEYU6tpZ62x1CYRz2HpF0JQfm61Omo2oCSawm01APUKiSizHa/JmQ5VsRkWaXCYAAiwAhAZAQgPOivjQhgOBQYWbEaGPFgrSMwUXuHF6jP/GIDMIoCdJUEDH1dJBggYUhMbJIamRDEX1BGBS4TeM5QEQ7rZhiOXFyjoXcvcTOVG1i9hxyZfpcHxFhXySyiTtCoIs5ZLi6pF3HznVEapwxM3edZ26phLv3jv/8f/nTX3zwP//yJ1/NJkeTatLykux4f3+/LG3b1kVhL+eLzuNkvOe51YRqzahgZu2TEtNFjQIegZDmwJN6qSgA+RskRmbnNcZgDFpblGUpIsFvAUXXdU3TqEpBUBBhWZbOaVKAofA0MYYQsa5rRCyKQhgsmclkNB6NvO/K8cg5t1gs9vb2mPlku711dKuaVNbaBw8efP/735/NZpeXl3dv36nXm1s3by6uluW4atr13uF0MhmREfZMgB1rfSApVnzvPg0tW2NJZFQVOHN7ABCHKho0KVoAqWYbw/9JLEmFwC6ilaJnr4c2h3iiQYgp1RRQPx7oU0uHZJAcYPoC1Vz7ek79DwCI2CzdWABU09IjoAwgUanqnZoxbJRmOcNPjNpMX6UuIorSSxh7O2srWkCBNrJpEPECRtgDMhKAWIUnVh1VYraZQsmnRQNBL0woidtDZhsIaNJbj46jcAOGCsLAH+JXOuz9eNJ9Okf5sQKEhO+OiFB4CI4Kzu830gRjqD+qarsYTFw6uvpRwIsPDCfy89A9TMqgrwuzC4k7hfo5EEQbRivqgD7HtbaoEMECkmHnnPE4dnh7fAuuVmZqisXojeVta2/B3TtH61XNUsHYwUFVF+bnj9dfnEy/cXfx9OLyYrEc07o0S2DqeFaO0MCat5opKMaAMQhAFhDRGFNUVVtv6q4djcbGFLO9g/GkcEY+OfmwHdUPv/HW3sMDfyi+8qebxWRSeS5d46gFA1XpCR1g58duwkRooOtaAVitVtWkAm4JGkdWizoyugWA1Idcgoreux4h7hEMRNZgJ9WtHe7Xfs7ajCzulwgwoB4AAFBYSwEQmysy+QviodUMmRD5VpLIuTZzskL9TgN3GAjOdFGWUB0u9XSldqnBd6KBRlZIDE6D0xK4KPvDhxx8r70vhGMLhn60OcJLPP8Q3SNRRKXIQvwneJCd4isC6C3mpKPo/ex3DOhe54CdQ6jaeR9ekvQcAIytvZW36g1eBIQtak0gQjI1ABJEcdBP47wJgmsYYvCAhDDxZQToMUMwwKMCQOgJGQWD3hcsB0nEGpKwwnj6hHMSYU9Rz4luMEUuYN+F2HMwSnVDyBMDCDMzqG9GzUGOGS76yj7DHDP3TBA/aDgWlOowTCzPERHNHYGeHhKC+26RnhJAh0ZQBMlpzB7BMWybjgCrSTGbzX7+849mo3tWqCztelXfu3XT+e3L07WxiIJVVRVQRgwRERGiUJPCzFo5gozGgPYujgFKdi6YC5qnWY0qImgttZ1P2dCI2DSNOl2MMXVdd11HRMYULNJ1XTbNQJbqkdZCGCIqjAUDlowJpq8xBoksW1sUFTvvOgfI1aiwZO7du1fX9ePHj9fLFQKs1+vV1cJz99477/360w+fPX9ad98FcJ1r0RTsowmKAAAemSQ/PLs8LN0JPW50cEqFf0rCVlJKRG2RMngUowcXH8jJq6F8SURtH00kxhgjNpLZBsou488DnaRvo5rNiezTUJlBU5LjcQslMMGhELii6i4gEhAqIw4IJJLM35hsobhCIToejzYhAkfVTUSIDHNoI8UoKD6IC03fBwA0zF1CJVc3iUaBUyA4m6yIiLVjVPtTyIegqFa6GSIKHEAXUAiAEIpgmPX4IgSQ8L/SKYsmxC6oGmsXHYIKYqVNmDghAPgIREZp78MKhAcaiB4jifoUotfkPMMkDOKRhalhBU5TLGQBdIwiU2sRC7f1BaGpjC/9IU2PeFyuJiAv6cmJvajsu++t7t6Xy8Xer+deju3tPVq1/tnTzY9/+vL8+R61p8v5WdGtpNhSJYgFFAUZx87XUI5Ra5RUKYNoLAnyeDapV8u2rs3Yvv3ovQfvPPzV4189bxc/+G9/Z3Y8rqmpjdRNWxZ7vkOzxYomlRkVZjyp9g4mR6NybNAWZJy0m3Zd++blxcnGzVvfFWPjQ8zRJyRfAGEvoelpyIHN0wGULrn/r27PsHt58nMEhIWY+Zv0VfVSKSwUouLIMYDYIbXpOxNDD48V1JCnwmlTDHzpIYnGNBgEJEDVHwM1SISy1GS9YKIPWVByCkatOc0reucUqQKHyxFL1MhGtAXuuRXuKhzpRTtqWz7x/M5+ZaM829WcJAamAoug4LmKXqWkzWjadEGUwUKks8GabJWZWUG3jOpXPqTwwHyQvcKRieHBDUCYbSsAoQJOZw2mEUW1EHjNleWOBd2UQ865HhtMjofgbRZtFhmZZlbY7UFRTxBDj9PgQfPMgQGlIoJIhEEJA/SgxYS94qP2H2qwn5nV8CXTlx9nGU4Qk0Zjq4VkB6PPNZik01AodQYWD7FTfOfqrmv2xzfJjJixkbre1lRV9+4ft+3SwHhvf3Ln9v2PPnrsHAv6znkbgsfhuBo9LIiuYw5nKogojInYiLFVnfdEMKoqQmzbRde1zGY0GmkXN0QcTcYoQETb7bauW+dqWxSK9OWcy9KPAhGIZ2ut914Iq6LvgjsaVYLITmazcWHsZG9/VJTeewKsqqqu648++mi73bZ18+njx5dn56OyOj466Hz7T/7JP3nwzp31et00DUtrwVvSttSaThMMABbOkG841xUQkJUnACNYQi/BN0aSeyQAYkpHoudwPESEQBDyYE08esyGlOT0XZACappkrTSjXDiQg3iFyVFCU3VcQGItJyXEySjsKfaMhOSPJMpNwOAdVAUgMvGojsfSUNbywkjbIY0VOBWRBbYpAKFRe59q1vfI1H5jiIHzRstDAv4eYgICVtHNfodjZGeBAEzqEaL2GpKAWAAgNKrZZ4Bj2nzRZxg/HhHBQ8xITYiRAoIeigHWRuAGYmOIU7HIhZEUgxgtgPqOoEedFspwCjQ+FVAJLBkvDAyIXFhrEcA5xw2SUSuKAAix8IBGiKUrfeGKQvxNGk9rX5+cHrTdxE5W7f54M+9+uYLbN7ezo9Fnl83v/5vV/OXsje+Cu9Vcnb784Kfz85Pzrml+seS7d/zxpAYRkspWBrh1TkRGZQncAIAX5+IiW2OgKBpXH+3NpkVRIkHXFYUp7x3frm/PR3fs/uSiW/sOrC3HXO6ZG97jG7OjqpzaclpNDgRKz2jLSeddVU4rv5keoCc5uP3OR09/UW/F2Q2GqvgYuIOAuMh+0Aw15LihEe8Ct4QePAOCLyrbq0gx19D3IwlxYP0EqbEJgojN/ArpWUl3DpQn4jOdQ49tEPkACUEvaqBKMRRAjFUCq81BwNoGLEfnCxJ9MFzJvxEdKUPkCyGlPPqCFIon9GIQERkEGsIzMYYYeEDjKaYllBQ8dVREZ37QnCD4V6PQDenZoiUSmrAFxF5Ch9pM53jtpZJYRDSqPczbQlBEE2V86Tl6kmOCNYDq50lepugyRWlNiOqcBI2iUWL6Ikg2iXZGQAVahgyYWZRF9eVIKTLSKz0YlI+4Bb29EhrYheqh1McBtRmb5vUIxO4oEsHSRCDkxoaYd1yrfkNVx40b0dOMFjAzEwAgKRhrj7gQIdWVSgMH1RGqfpyxbxERsb3cEvHRf8RMnSnsrz56srwUOmy+98Nv3r139P633tuuV5989Okvfvbxi+dny0UNVBpCLxIyjUCrsXpy1ykkEI4IkNN7tlnYd65t27IorLVHR0er1Wqz3XrfzWYza+18cXV2dlbaoqqq0WhSFJX3nkWcc845tMbEI4mIwIjEIbAigAKFMQCM7JV8iWi6N5nNZhbtqKxIuGvb0WgEAC9fvhSRo4NDdn51tag321sPb96+d/zksy//r/+3/+c3v/v+X/zlv95saltx5xqLYwmaIApJsLNDgD71K8gUYkTWPWMLZEXZDqAJXgrM915lalI4MIpWFjbJKmCACAPKwsB2sLPJrkhN3YL5FHOhxId81SB0lXJ1KkbEq/lF2nZAQtIb96l2HA0DjCYEMye83Txy0bsJw1CBU6aUOlQwFu/ozNRPg4giTkDhUHt7SZ9JsZETAjOCEVVkTOIwuQGDJIQZZmvYEBARYBQStUwISJCtlqZ7gxhy6LTfVizjV18mqNERdQ5BAgnadvQ8afr78K2aUiwCrL2+MWAqeRQiMGiBkSTUXoIAoEG0BIBQBSwAMQgCUBhgFmeYSEvyAEjAigAaQ6Un40SbjoIFrIRKBuNlVbeHbjrC8c3Jvnny1eJPvmxW4t54Y+/+bP2zLwEns2/9oLvcbP/f/yv/+5+Pf/Do6oFQfXry058tfvahtVSO7OW4nty/ua28dN56JPaOO+dbRDFIvqvDigMIoUUyhoywJbKdmxalRdsJbJbz5Vefd66uRoddR/t7x+y89TiFycRMH7z5sLGTwpSuceVoDxrPTU3WlnW3evYlFFLtT4r9g/294xt7i63bdGwMJTwnr+ZcdPMZQsX+0ChHTJqmWB0JQNh3IDFEBVre2TYA3VMkE8VxyNNSagcABKNxfGXoqUoleQV73SWydYBIxDFz20cekNXsComIMEPy0gJ4ZiQEjciipM6lWSQ++RV6V9O1KamAT619TOQCDBFIKiaKiiBIZtfGc5ieE1T+/KvEhfI3JnyYZAFkS4HRI0IAAeGG0AZnT3SxDBUb5ZVZHVBQX3ycr0R+CLEyE7X2T38NAMIAKNYGFhZvBtGmspoJr6Ui0VgDBQBFdSyw2ndqCSCkgnhNNI7nPXluAwMPXuLguELoHVEgAFCQJs+ymrQpNBi83sFii/afSBe6v0aXUtgJIp98HsqtEdXrG7L39fKIqCUekFJTAEkRP2I+VKCoaOSpERnLlyLhJhwOoOhforxfjDBwzLMVUTQLAIBqbD/68ONXJ5ejPTuelP/oH/+9v/13fvjz//iz5fJlWdFoXH719PT4+Oa26ZqmKUeVeDbGFGRYkJmBRVhYhMikvOYYBQyvjgVKosEXZi6K4saNG4eHh2dnZ4vlcrVajSbj2WzWNI14jdJ0oqqGD5EX7oANFBQSRyRsMqPRvHiT1oqZt/UaxFgqLs8ubxweFaPJermtRkVVlLP9GYOw80+fPjVEjx49ujy/AObNup6MZ10Lo9Het7/1g48e/8SUwl2LIYXGCyFZAxRC5hG5IJ3EPgLIzF7QGENiqG/QajHUt/Y/BACkvroq7o56OguJqFwIFHI2QbhjIhJDAH33BqLYXCiYBn2OOYLXXDc9BT1bQCOi5fOaJhlzyWNyGLPvCQ+ExQTLXpUMdfsBpzK6aNdxPN0uaBsS+JjmD1GGvKxhE31L6AsdbNDIVCU6z4EBiULPh8RREaLOnbGnPIkyeTmRiELJpIgoCCYCIpZgQUD+/5z9Z7Bt2XEeCGbmWtscc+3zpuqVr0IBhSoUvLcUCNCAFJ0gkqAoklJPaFpuOqYj1JJao5lWx8x0TEsatSg1SdEIFEVRIimJEiERYAEgCMIDhSqUd8+/680x26y1MudHrrXPvq8K4MycqADuu/ecs/deLjO//PJL77QVJqTzgXAgzJFyx9pPRECIrAEJgR2iRbAEuWY5rHFHpjWNlYBqYAoyCDMBGmOsseJY1KuRAEIEgsiAqJCKsKa3EZVGCoaYTZ6RMUG8dw7YGcTc5rURDAEwIItFyoVKwAzh9KwYzYciFqzl65U8uVccO5nfdS8+87S9sVG+482wtLLxiUcufuWzx04du3XlBEJRXp0dPLcvZmW1KJswt3meBddIlgHlQgjQGITMBN/U1SRT20RIJiNDmTF5bosst4Al4oCMETx+bP3EiRNNXVfzaWFXMMvF5zbwubX1k8O1dq/GOWGWmZVl8LMwq5nZFAiFu3zt8nBjPlwZzmbzYWtzHpwdn6umO5VAizNj4y7xoWX2iEgGDBVEZEx0FNIBiGyioCWgWLtwOMhYYzRGgbRU9PwvAADB9PLdLCJgoxUjIgOEELt7WuQOmjMx5x6LWjsWd6BYt632R1FtXLhFRxFOPd9ZF62ltCe6RIABCNT7iIiEKCy2UCaFGOvqT8hAtGj6FTBxrkQkkEdCoyXyAMwQglZSCSY0k6IfIABg1OGieCssHlEQmVNb2m7gokHiThVUzVv3IDpqRkiY2SgrAbouSjoAgKkyM4gY0riDFR5BAhEC1iIlZpE4+EAIGNTKY88SIahRZA4pfup8IxMQyCSMJxaeYGBJ1EjS1iPEjEhoJMUKpM+m1AIRQDQIuEiaxHbhCy9OG15EG4YYxCrzU91QFlDH0SREHRH1JFWqDxnUYFEfJ3bzYjZWLYcHSB10ISjMntYV6OEL0GkhYDoiBUALFIHBIGmtg1p2UcE3EUo+qwb98XEY9ChlAfbsomy2oRCCtRZRvI8l5jHH4TPm+vLVZ5zzRT5u2mpr92o2sPOquXj58t7h3m13nLCUy07FPliQEFoyhWdhpCCBkAkNMzhhXRxxvWlZNZiEyjAChhCqqlpfX7/9jju2NjcBeGlphCjOc1tXIgiMzMAc1OHQgdKUSmAHOoDK1lEdQ7S5LbQU1maUWwsSsPU2yzijpqlE5Mbm/IUXnz535tTq+pmmnTb788FgkOflaGk8n84lhNF40FZ1lhWvf/NdF+4+EwBMma8MM5wcHi/W4NipUyfu2tzc3Nx7sm73GuGiKLw7DEXc1yQgLCjJ8qWyI23xahK86lgXoVFFXQAGDABMsWZbOjRYV3sbYh2CCErUYkmVCQxR6gVADRgKgsuQUh69V0LPXZ22KoLEl3WtJ8wQM4RcAoWgiCOHVgE5CwCiQBVZQgRu04VZeBHLeU4ugjLoNfkLbMFGrqRyPCNvDT27rlhJJCCJAAsLYY4ImlyDSDNSwTHDqZopkqcYMUI+HEB02Dg2rAiCSh6iHjeFAaAVh7GfosaTyRVPTeMS+OTVbgWnAbTXYVHPiQhZGuUPBqDALaJHjMEOEgUCYKGARtUXAcj6NngOYigDa1hnnpitZIKGM8fExmCWmTy3ZIZOLEiOmVWYEAgpBySoA7q62d5eHpQZWDDDinjetisCEth4poFtAMZTHFXltG1HuzW7CTUG/uTy9HNfJBwM3/qGneXh+OLmbk1nz93C9aF/4YWyBiyXL082hl/eu7F7EJrd0mBDLNyYMAKbGSY04omBA4eam5a5yVCcYzBU5NYHL07KvLA2J8pPLo98Xbu2dt4Nm6KZTw5bEjtcWR6Ah7EdnFo72W7tX3vy8vXLV06uHzt3ywVwrQxyHyBnCvtzWh3kc3N5v70FRzlw017L1+2s3a55Zmic5Vm3ti0GXd4kZIwlIgQrRBIgqLouYkaedWFI6CMcZMeUrTL7CNxpPgvAZEV0M4Ro0eAeFJ7oqh2JLAkyg/WRQNO5C0BILIvMQzSBGKFLwXiOdwYvKhwo1x5B26UaNGomQ3xnch+QRSQclSuWGH9HBSSRyORO5lMwhpiadsJOLAgAmT1BR7WOUT1299Z/geGEDZCCghKTtQCoQhYp6sWYLUbsSJ3xO5IDQRS5AiKoOneaFE2ZkQU0oj+YlNbGCPYwiAFhMVYVKISAmVG7NCTSWXzMhMRCQlS6fy6GMXDETDUwQYyNv8nrbyJqrNQhkqQ0DN3dqvSN8nziYQIpfSOiNPrFcGh9HyCRRokdVhTBZO50PjBNf6SuBljEjorfAiAHNIDaKAVCLLsFMJTU2iGBR/GHmB/sj4BwRFiCF0iuImp7Uew6RKQ338Slx56YPQBQamO7+Ii6HdZasnj6zIl2dpAX+PzzT1+7/vxguIRgNzZ3l5fW3/jwm7756ONAZjxenk5qg6jW0QcfQgAUspYAIXDf7Y4306NP6eJ3LmxvbxPR6soKMwM0Lvj5XCtNCiKr3FJMgX5IEulkojWNi1jvPHGi1QIECCE4sdYSsfNZUSJinue333bh1Ilj7N2J4+tLq2tVVfk2bOxtFXl+fWMjz8wbXvfwN578VkbZzuaOD+b06eM7WG5tXTl1+viZk3cGsufuvKO8PH/uxZ1sCE5qNMTsQJkaQGlN6MJo48MHQBDuRtvUIKikRQAQcAqCZjgMHLrJwjjF6CUKz8QWQ6nXtCSmZHTIBNAjEWFIOgHYP4uC4CKJqZIP6nGka1kN5tI0aWmoymoJq8ZWvB+Oywyjh6S3yn0xJcTEA5OOBIqaRU7uIxBq4ltQaZip4EXJCiEgGNFclYBIQAldCgNEEAiBCAgUMZWFICEBAQKLi6wa6edWWHPmgIY7MJJRQDjpf2AMQTEEECEyBgRjrZt4PTwEANGC6qoqOCwKQ6AzGCCmKgUBwAQRQeCWjWQFguFIEglWBGnggQAygrViVNqyDGingSqXtUI+QFWH6bRpGs6ybHWlWBrXWYY18pPTyVPfGq0vla+9ncajYzACa5sxeZnRxkFetcO5QDUfCoIzU1vvPfXs4PMvIlj7/odgfbD69edfunKl3arp01/K7zq5e/UaZMbPZiMz3L5xXeY+cxy49ZwzBYNAICgelCoBgUPw3mva2RgjhESUGwNAzBBCGJaZocHMNwfTClls4wctHFs/Pj5xzKN3tWuqZuvKxvNPPr1x6bqbTbMsOy7BHR7k2Zoxtp3O6/lkdZAzhOnO5aevv5AZWDq3vrruDrLWoze0WPmpRkGLISLCHhenFiMhAcT0JgICUn9JIGQIGYJJXSaM5i58pEoCIhFaJKsgJUUgv4s5EZAQ0Ebp6cjMAERUMyKp2qJji8TNcCTVcvS4PHp+GkAh5ICqZilagqU1M105PgARWaRwNL9ICVLoDgtr894uXeREDCiuFw09ChNwLLPsvW665/jBJEEIABBZ7vGI7m1+6TY/9qkzolB/NzgGIAAYTsSIlGGJRkvSSYNoBITAalqbDUX58KQlwVo4nvY5pESU3gbLEV8NFoej6qulcptktRgCoBJWdYl0U7VgZnTcej1jFw354qpkADZgELsCv74zJ10iOXlJyoA52rZbnww0q0FIDGBQPZPIYA4Y8+kq4tVNYFjod/VWSOdtdOY5zrI29YQAAjH5IqhAYnp73B5pWilxU5SzQogGgVR+GACMiZg2IloreTbc2tryYX7q9Ood526rm6kPdnnpxHPPPXX8+KlX3/fQtUvX67oeDIrRcNmY2eRwN4hHzPq8JV1+vVV8hHjVATDKJZrNqhs3Nuu61sJaa/KyBC2FZW4WnmmPSY6IJh7sSL3LAIBzTZZlBFhVVWtMWZYBYX86y1DGo9FwOHz3u9912y23vvTi8001P33ipC2LnKzLAx7nyeHh8nBw/vz5/f3d6cG0rtvJ3uHujcMzJ94aduaHl7bGJ++HGRpTw+H+MVo6HKxfqS+3RbCm5FjwigswH5MvCpBa/3SNDMGQeqmLXoP6nwvzjjCEccUYQpJQC5nk7YNwiHW4SRAqORyIgMxoFN9MoBzEqB1YTDdcSgBQ+TJJUuVpIcV1EgMCAW1ukA5fTD2pVUmvl62W3kGUGPcAUZwxvgcWGj8oTGgQDYhFsIgZitEDkDkFETFzKSKewTMwB9/9PpZBSaZHR5RBQ05l7fN0GlD/25BAwRajTxozxSiUqHsRStQwFkG7fOoYInDkegNbA6A9r4UlkG5uARRiDgigWn9BAjMwSAG5ojittCwBgAvIMghLeZm1XE58frAt1w/8pR3ePLRTv3MwzdpAs8rPZrV3MB5mJ9fzY6vH3/IwXDjHa+evfvPz5ebm+Yrzt76OVk8AGgCm/SZ/oc6CB2Ng3hIZ4KJ00+zStXayd+Kh1xd33L53+dr2pz+7t7cjlw/3PvGZtQfv8PvT8XBohGVrF/3UeB6Wg8q1GDwiWEuOa1sWhEFENMAQH1gCimS2CCDBCxAYo6G1XVlZOXPP/fefPO7A13U9Ho/N0hK4cHCwD9v72zs7N7a266bZ3try8zkFmUwOrj33fGPo1nvuLo+tN/PD7Z0b+/X+1sHeSxcfnU9n68fX7rxwv6+2KpRAPgjYpBhOAAKMJERIpLquzJpyi5o9AQBQrOaQYZHu182agWSo+OJCnI0gSr/rdsgQLJHVOoSOmdmZbESypu/+I2L0Q2Ojs1jd0tVqk6oUqzWNJ2PCNbvjMiBa0RXJYjSoEja6KZEBwfScAUQkAyiU2NuSbDwSEiOQQUC0ZPr2tdu03YF79H7AxttiEECiRWtoE72otP+j4YlOHmIUu0ybP7BbOCvIC2oMKOIiibIuqqFgfCJGBFAh7STYCUipkkKbFIgqSrWgMCYLsEQaJgbAvggsICttO87iTQ6fpCLedG5id5VobxAR9AupK/rtR/kdaQvVK+gqEZXqI7horaUObAq2MNEdEbt2GDrjjUiE1JJQuk3Tqp3nIvKRFnTCwISxP9EdI2VRyKr3xknoVmcq3p8WRwQF2BmjEJ6AiWx2SEu/88q4V82hjF+jpYzc68UQQkDwhvLhYCXPyjNnTu1ttsdPLI9Gx8aj1eXxqUf+6LPI5tKll55//sUH7n/VtWs3dnd29g6nuSXXuszmRJSj1cRTCKxKd7057PkcMcYFNICGRKRx7dbWjrV2OCxHo9FwOPSeq6pqGscchUTjMjZdFiBFzBK3iS5jg4QCLOw5KGHBO6nrZqWw8/kMEfa2dwY2l8CZMd967PHDajYqR6dOnNy8fsMa89oHXr2xsbG9ve2cL/PCgP38H/+x7O5eeuIryyBDZ6ZPPXHw0lNXX3z+1W9/29q5pU0vbMAB2LgSj3Lao8WOEypCEKURGCU7CsLpZ9nHpobUdTYRAWZWvzC+LzrKAaB/6gHEE1QQKQrcQWRTdRMNXWm9VolDhNQkICAzSFqRhJIhUvC+E6NjjoQMTdEBqvO7KINCxEVfqpfpCfX/qQ4HEUlwURQcLQghZhgL7dXJoL5V0JxL4KgUDBCZ1yyIUMTb0Axi8FpR4kPTKdxEBb/FBgeILbKN1rgSIkijALeGsxHDTOhOOlJUCh0RiKL+jQgIQpCYooHgA4FyJzMhFEYgMIgwq0NufAZoYIBmWYrVYIqa6qs3pi/e2P7WRby4azYmYXvq9iZc++WlVXaOnAMfjIizOC0yzkzz6LP5973/xBvffOqWWy596Wv+Dz53fu346DUnYQDwwmb2zCV7bRPGBS+VbeM4o4Fv/fOX+dqhWx3Jeg6Xrx0+8eRkNjMA4/GICeHGThF4Mj1Ys8eCDzZ4YgiuCRKQoAkOMql8o8LOwXvnGgjBEHQS7wTA4sWLwVLhOiIqyyHlBWWD4epqWzXbz79wsLG9t7tbzprdw4Ptgz0yRtOjk8O9J/Y3NlZO1MFNDrYv3HLBEFbbG9sv7N7Y3Z7IAa2Y8pbx4NxyPWAmFfxlZC0Lku6kFdFgr7PoGKcwIXbfpqEuEVlmAAiQqPciTJkV1ZdOEnAcBJE6Lb/FOgRCRJvTAkKMfxZAADKJts0csT0iAHBuAWZ2n0rrG6L17TV+zNAyExNKwh4AwC5wBSCyhoruHhA8d7RGougPUSR8ScrcG8riidPTztIln2RbRW+eI4ITjaWNioQAUUuMCEAEjTVx16U9r/9rj7a3huRbiQTl0UT7GqXExYo6RrH6CGMzehSjxV0abSAq+MFsfUAtSwHQhEJU7ezyB91ARUdnEbt0jyy9agg4igMT2XRFg6lhSrrD2DhK71YdAiW0Hw2cFCnWnELkmSfymkkHOiEaQqvtVERAoGX2IYTYFCb6SQHIRtSIQUCrghmRcwhpsXWVUCIiYiwupF96fe8MxC+RmLmNg4aqr5MtljQgIFhju7nrfxv0WpBr5zwiG62cBABRXAEhCAkR1dOwNFw7d+YMut3hqHjb2940Oay++MVvDYZFXfkXLj5z+szJOkw8zpaPFSfOrG9t7u7tzsAAeDDG6GqMi7gr2WCEBZcw8kVAYvZMfwBjWhfCZOZcKMsyy7KiKAbFsG4r55xzLoRARJh4PN0KQURjTBea53kxn88BYDgcAkBVVcpIXcoIEc+dPrOxsXGwv3vLufODsjx27NitSxdcVZ8/fXZs7LWrV9fGy2srq5/Z2Hjqqafe+o63bG1uXnruuWf/6DPrZvqh97zz4Pq1iy8+cfkTnwgHk7vOnRzc+ppROfJSe1tYNWBH8xcAIGyQxCBFXyTKg6JIh5B1fwIAKuLMxnYezLEPUmaKbh4DiIAq9Afs9jt0X69rK0ByZhB7B3KclO4DqBNGaEEYUburaHpUbbNoAhvUfYrPBsp1eNmLKLJNITKcUkVMWGClnd9DoO43aDGtQ/V74jGbxExlocFDhCSxR2OiJkWtcQSrbooxBgRYvCbWaNESywAQsFfjEeIWsBHISULGFjyHoKxu6cuCdd2zoxcYQFOJbdzQQp3MFgJyJT4HAkbvUNsyWMoQaTwsvK+x5gHb1caY69vTpy5tvHSjfepau3Mg27OBg1FWDrJsvLSMK2SFpcwBch22LATfOu/aw699I2wfDB67Ot6bDEvaeurJwSOnRrPS5Y27umE3DzCzAQM2rgRqR0V9+aWNF67MDxvI4PIz3woGJxv7Y1/Mq5ZLQxk0s33yoa0bD96hE24NUNW0kKGx5t3fah55Y5GX5qCehhBC65g5szbLLbJ474NrKbMUM9aMHKrpbHdj46X5l1fPnlk6fXK4sjrb3tl46tnJ1lYzm+6QCCEROF/X1cwEh9xy2zxz7ZkyL4or2Ex2Bzbb39vb3d9hkNOvu2u8urJ8fF1Wy9Y3QmgC2dTyBqNTAaqopQQb1PojNVhCpD0UySTeuRxlZ3aLE0VBjs5jJsUoMDE7BSCk+B8xdXUGCIhkB9n4JoMat0xcYRyIAcAkoWWEvO+Vdwavgwi6xoCIBgWMscyMogp0enBwni3YKFk2KouVDjlg7nVf7FlWjqUxcU1T7DllOkdErVrPBwox8tPSn2gIF+2Jo88l6VYNpI3XuVPq8XVh7sIkgNJNjNG4SumECvMaNYRJbmiRoImNzQwnTFUgIHBm1exJiLneyFDp5JwXkIWG2twJHMVXdCBkYVTSXzVSsUo11XYnoMexBAkO9AdwAJBkEij1yzrCIANgB9xNblJ4611LoyKy6pGI8ryYA7kQQlIYZAAQQmRkZkltnJAEhQkCM0uyN/pczIzWQsJd1WfSv5KJlSmcfI5uXhDjobdYh4gmvT/FoAup/25RYRQnjU5zwFgvSiYqsRLR0nBlc+v66RO33HnhgS9+7gvPP7/+we/+nhcvbR187tBSduddFx549f3rx1ZvueX81Ss3rl7d+MIXvjmZ1RhRNAKwiIi5weToSAeHc4JSEI0x6kBoMlQTPUTAIlVVaXplUJR5Xkr0miNyBhTHrYf8pR2UqolMZg1SZqz33iANB8Xa6vKp1ZUbN25sbGwsLy/jytKVK5cGRbY8XnJVndusmc1OHTvWzmZf/pPPv+M97/3A+97/xa88FkJ44onHz588+fQz3zpxfunMymh/60qzfamU9tqNqxuXnntV9lCWr9pQZwZzyrpTJkX5zAjEBVEvVSfd7Me7XpxIOss2MIc0y2gtxi0TFtpQJrX/0L4qApKuGFKOVEyM2BdHamzmbCXCjX34ARkkx6T9JaI8CINorO5HXNxhXHjk4rmlfnG3X7tRiD+lJHfKoagATNfSRXsPiQSkACDaQgsh9uKJziUwi9eYMOVCTWTmCSQJQQEQjLgpJeoVkCmifwAA0SMwWvABAICEYFUvP941eAStCgGIeow6Jm2/Eik6HABzJZcAIHdEO82fmkywdAiekUyZFyXlGUOY1EXN2dbUP7ex/8TV2bPXw+YEKl+0NM6ycnScrGk5tN5nCKUxVVVBZsRoWYtkAPnAjCUrBzS5fP365d8vlgfjjCbTsPf4t04vnQglFShmTHBixRRZe2MfW2m4vP78c3zoh5BPZ9ONi5uQA83NfGa9rWZETXNYFANs26IoPLu5nxeASMgc3vhSAGgA4L2//jjA4//yb72FmVkCAlgSG6tBWTiwF2JqvZcQjLHIODmA2fWNW8SvnVy3xkDbivPONbO6agoiQRdc8K0ELyjZwNQgZwZLhrL97c3Ll1+yo5JG+fK59TO3nl2689bhypIYmnsHaLKoBQdJQ0FDGiNKpRNkFiKjLasAIqm8x1XqgOT44sAcG+ghYteXG4woqV87Dmh1mH48nqmGeuCCAZvl692/MaVXRIR5QUYTXBDuqEeH7N4sItp50i46F6RUp8k44YoU70Ns1vVeh8Ish+x491XBD/tfzhy5D2QWDke8ezJEZFNJpEgStQRARO+bzngaY6216tMYixBh+4jh60BzFDCVmx5N/4pd9V2CQHrKqkTAlmKTglgeDEkgtQN7wCT7oXLOWkrnUfmnEvMrGFMhi8YlkJZAR1bvFCfVC4yGGfsOxwJljQlgINQG6ACpvkURDp9Srqpr0uVl1JONzDsAUA6CWnciq2VBzMwcBzD6Z5hkNtAweAI25NXX1JyxZ6ao1pMOn3gD3MWicaWpYYhvxehwpGGMaK5+BbNIdLwUh+id6xF1W3AdZFFgBQAIWWpWJ8mnUWqwMSTd7226nDTmrtvvf/SxJ8aD1de//o0bW5eeeu7JAPXu7v6dt99x7733njx94p3veOuFCxdevHjp8qVr33jsmc6oWMo8t2SMtYiRvxwbDakHpji6LgiilIQSIWMEwJgiI2Tx2s1EUypAC29JRI8SVle7v3S7st629XleGATnHLAflra0pp3PbtSVtbau6zzP20ERXHvuzB2ryysEENr24gsvnlhf++mf+NhjTz3xG7/1W/PWPfjgg963zzxz6VWnLqyNy1tOrG7feHE+cydX18998EO7w89e3t99laNhebrieSazEJK1jeVmgQkIGGmgK9kkfXqdrOAsQGeVAZIhJ9OEEJhi6RAREVpjjGtbSk5bbFGruYzU3UOXOkiE3KjrbJwSItHhpsjixLTy43W19SgvAg8NMCQhGX1vI34+Mqm7lIq2BI6sT72x7ntCwp+7HaTjwBBYPLNHYogZRuqlF3XxeJUUQxQJUWY3Hlmw4LsovV0PhBRNEUiWSnw7fh91AsoCHU01PqMRT8hMjJ0cjo5SyJJnHA9PIiACLkCYkQUFMrCEiCwSeAT5ONCgFnRSZuWQB1A5dzCbvrS199LVg2+9GC7vDmd+JLawY1MaN8pCCFVogw/GYJZnxos0ztqMkBAphOC9Cyxo0FjjxA7XczCmZQ8MQygOtncODq6fuOcNsLzUXL0mk1kzk+2rV2HS4iDf25+MGjSem3YqEJZwmCPVtimMpcIUkuVotg4qRMxcm6MAcmB549WbY/Wf/Adf+NX/8xsyY5Q16Zo6hNC2LQKENgBiEGbf5nlp0HhHw6Xy8ubl7NLKydZfvnrt4tZm4+v82Bjmtfc+uEBkjTHzuvbS7k0PBo7yQWkGg6U7bzlz352rt5wZrI5sWUDVYqY0R1dkJbAPVnUVqeuixckhJCJmQLAIFmnB3VFIw1oykjF7MnnvFKVYwNjDm/X87JmeRSwXD1UwKddJAGyMsUTD9I3YN7SG9MBSStsiddL1Y+kAa0hUMEIb++sAQbLcAUlNcBK5EwAQGiymSErCEUQKgSBQp+QRQsCo6wUgLaHpKB4pXCATPXRJ58tiA2OqFDVkrbGRzKh57diTWW2JNcb40EavpaMoKihk4qnNDCAhJZi00ha1FZDRX5Agold6J3uk1HNV/86xFZKOvbZp9gulhwDMEB0OCwCxWWM6/HQ1IKJgAGQWJjSGtCRVAgQQSxD78HYGVUSMsVpZEgQRQhDl34FRQwtewOk5CkgCqDgVAKRyxDiean2DsAgSWEsW0TCwFzEUAY9oMIQAwQsIWqCAYjV9AzpBR/okaHjEIOxSXjr5lAqngTU+RVekJkbH0wcXqTBoyKjSaGDhzGTxhI2SurE/RSLoESKKQiyCImJtqQ6iCC+2DSoUA6wlWRD1RUTEBS4Hoze/4a0vvnTtNa89f/lqOZ1Prly7NByOH374DUQ0m1Xb29tbW1uD0dg5B8De+4wWnqsuueC0OoOTZyVexYhsFADtbIbWF+iOUFkONTvC4pwT5O5ru6UCAM45bRvbWQtEbUQHzrkAYixmWUYIbVXVs9l4ZbkNvizLEMJsNhuWxd7e3t7O7uHu3j133PGmN77++aef+bVf/eWP/NAPf/SjH/2f/u//jwcevq31Li+sd9XJ42u333Zu++rzzvHFafPq97/3PQ+9Zu/yC/6gDsurc1cfWx5OZgjChKh+p2B3kFiCDIUUpRUhEys5mzQ+cSOkkHtM6KOmCCILskBgYxCZ1U4TLg5PTakGwQAQkATECamrnenIdPVocdIV7NOWqpr4iOchApAACZtEUPeIAljGbZIc4OQ1L1KrokpcekazQRQi0CWn5QyIghJ7/UQGX9dqkZz3HtGrKgcYUl7egjQHbIgBRcSJCFgXnSUwzEwUUMtUKFNvCcRAciMQEYJNKRtOxcaGyPoQQHU9U8AaIkYihBIr0KOvI4BMJrYM6uyIsUiE615AmERysQO0JRgCBGRuQlkF3K3avVloq8P5jf1LG1sXr2TPbEjjrHNjLAmxBa4QjEEbxDCVWESuPgHbUBN4DxZNJmTIojUOfG1khjziclbPikEmAdqKh4Pl+ewwO5i0t5zJs2L7c1+fPvECrA42JrvDVk4W41EoJ+Fg303GYE7gkp/DXCrGeYGjajYfAAY933IqrXHzSmwWvAO4STYNdJPmeQ4AwbXMHHzrvTdgGldnWUaGgCW4VsCggAk8b/3Btc0wk/3t3cLkZLFlZ0zGjiWAc25aVY2E9TMnj91+gU6urC2vrK2tr5w4WYwGYA0CNPMZC4XaU2FyNJawcZ4yE5DJE1LMhkdqk7YRsYhoYmlJ6n2mxsYQEkFgZ2jBi7K2zPOyM75JL46Ak9u/UNCJ2Je24zFkRbQNLBMZS31smWM6nAwFaDFWIAh0NPqk3dZ/qS+TYdHtXgDQplG6f5xzAKIlEkqev4k0ipHSjCwSMkXsEADIZEAtsAT2KKZrXRgjBiBEYy2FoAEcEUXpJwHO81yZdETGGmtMBkCE6MWn3hLRIfASWu+MNsXtNUgUQbU52k0dES2ZLpdJqXhh8RRqS5AFREzs1CDJTGPskZwDGEsZMwtzRuJZs0UWMBgSpBRqAzNHJwWEmFlvSIkZXVZeL0BEwGKoI6ZBCCIixhjCLM2vV3KOrj9kFgFmCKr/i0hEhkg4HtWAALLgzwIKBwEQmxkiy6z0fsrz6G14hU4RwaCIkIImAlEoSeX+kI1ZIMnpmCZEVGi6P57Jz8sXqxyUBGMEwNoFUqdtkQ1ZBEZKgmaxYFxRJeLU3V4AIGqjCSKwONLKxkUqUINTBgAykIK2NJcmOOfPnrnl2Prxg+lh095y/6sf+PrXnz57/tR4ebC1eeOO2+979oWnBqORD+aTn/rsc889NxyW4KBtHQDmua2a1jMQR/IgB6eOgjYcV1wysyYIIwplqrAeQKI2EnXSk6QyjpqF0FCYJcnq5DazZIDFsbPWlvlA/RgMrTEmQCBToEHvXWGosDbULgh7H8KgNBatBUQYj8rXve59F5977tqN629625ufeea5v/V3/s6JY6dvP3Xh1pNroZ0NGpnfuPKm+27xs/2hOKlds3XlxS+Yd/7Vv1Hefsfm7g7BYVZK7YY298ytgNcmDgatxkZepweYonCOqAKFtbFdbTpkJC0JILACC+cqzgtaMIB45P0gFikIay965UplGpmgNDGUR7vgNkXOPiZDsljELFZvxtiMIrZnABFMxDB6K1bZESkkMwZjqsiQAFrlKi2SdFE5DBrN+gUWRDTWMHvnnbW5NRmjT6eZArsLKWQRExuJgObXvEBgCSyCaAwVICiMLIPIetGsCSiJX9i2IISYIxgtgkUEBgjAVtASIYLXErrAJILsVHLUA3oUJiFG9Ay5J0ATZERZBoKeC7AocMzhfFpZpozJtAgNy7SGlnFeg8hk/2Dv+o3J9a3q8qbf3rOO0deD4cCMyhBC6z0B5ISZgCCjVQwHiAwgMpMPHm3Rsm9YiMRkBhAxeCN8YMEV+bx2xiIObAjO5uULLzx3l5vS9va1G1cODjZWeDQA9m07tUTsYHpYWstEMz+1ZIxwbkYcfAZEhT2cTpnbcT5uXCs2e/ilHxX4TXil18/8v77xq3/zdTbPPWAQ9r4d5plDHBaDjs8iCAzccuOqejBe2p3sHjYVMnLbMPhhmVfNvuO6ymsYZSfPnj9165mVteUsy4bDM8YYQXA+1K5FrwFtBjlF1pcxXhitEZYMmWPOkUgAdIUrCEgWEYkMxpJQ0g4ExjKAhKDSt72EoyBCTrRgNEYkQ9WE0SBZiZg9ExGKARAiAFQtY8VrwWIihwIAJtiZEzYOSocSoUWiYVHdkAyeEQhhQczUcEFvQvF57SGspouICKnnGCr0FuMzNJR11GtEJKGAjfokhAkqT1aKyAJlIEHVz5WdqUJ77F3sYhfbfGhBGlrMNQISMUBR+I/Ra7zbnRqdkcNEqpVetgURlZYoR3BU/U8zEQqB9EidxiBaZgIxQgaQAL0AW0QBFFRNqlRMCyxEqPMQS1oSCSDE7ogLln6EJwCJEm8DtdObMSazSYERLUgwvVGXBBR1GXEEVLJw/5VCFhYKqeSWiBKlEZjIANksJTUANX2sJDI9WCU2VgCi2IpdNUGkm+hgFhXIvYtq6lkWxd+QuL39O6TkIFLyZjpyYizcQms14tQ3KIS4eMC0qaTbY7LwtFLhk4gwZ8Y4JyBQlpjnOZHJ82JQDvf3d7MsO3369G233Xbs+AoQff6LX3n+pefvvPPO+WFz/dJmXtjMkCDkwXgOotyj3pOm24imKAlAKTHIJGZ4h2DFO1qkitJXxQWMoEwOXSRtW1MkEZMua92pRVEsD0Zlke3uHWSZFYTBoADg48eOIcDBwYH14aN/9s/+3r//3Wefeeanf+Zny6WV//Uf/29ve+s7BkIHW3vT/b0PfehDZ0bw6L//+L3HVg8OZq6ZbXz9m7tPPLX+ptfbDD07X5iD4ImFiKTb16TCQUjImr3TOiVdhIpOIUYJON1cMXMXmyl2jVb0OEAM2sSIkjcJoDoTDKoAIBIQkjgYCFKuibOupTDG6uiuJwuLUEcGIjBK+CKgFOrbyE3ArCtwFRYDllBYnyv6tbEinSTe9IKdhlF5xFKuZ1EIIakimbRJSanf6YDqQgiMKzXuXRBBFkZt7KRbBgjJiGCkigGxdiOOhNPYQ4AZIUTddEOEKLMsYwbh0JUNZ2QtYJ0DIFJAFDEIBVImxhoopc2EjA8jZ7JGYNbYwOADHFZl22LrcX8eNg/4YN40Tcu+aloAmFez2eEkVBXN2wIxz+xgMBaRrqOyLtrGO8xyPQsAtX4IGcWjEAQGYWFkFfphCCwQ4Ei6OYbB3vvLn//KajBweDggKgw5ZrQmsBfXCHsIEdrUIrUQYkGf7rX37P1F2OsdO/Bjr+hz/PrfekuGFBiYgqECBZjAdGqwKaCNG2FQztvGzfeLduacM8YEkq2NycF81xTZna951T0P3k9l2XIwWS4AjlnvMQAKSACMXX/AQKwnJVH3QIs7SedX0QQ8yszQI5cTQ1nllzBGg71GKhCtW8IaUiMIRROidVDhRw6aLdZ0sEReZlfwAdZQJiI9xaHEXTARNYv00/RiZuUbIEYRqMhRi9WhHbkvbQNQAn6koCIYuplIYpVQCSJEIhDL5+PzIwDk0cBgx7zWx7UYAUAEpdr2DLbW3+rNpFqvI5gPRgkUEgkKP+r71ZBHQoCIdu16uS0UtBF6F8G+DWCfblZhmJjgSMgOKT4hogQ0oohz6Td3o8KIEcbvTpMIfHELWr9jsnifKN3m7DgQ+oMxikawEKKEjjC8iA5RExyL+k80Hak4UWjVBES/La0EMDqcAbTEJxNGkMBdlUGi4FCUDo/rGOWmx8T0fowOW3KD4vKgSJdJWK1SUpAXgmCLlSaKRkV+RuT5L07k/jwmC4G8OFAWtbU97jAtnGMkEg5d30VjTLayApktbrv19vtfdd+F227Z29llBM+8t7d78eLF7//+733iy88+ceUZa60RatuGmQVxWA6rueY400CkGzMGk0h2rMJAJGsz4V6FEfLCvYXEYUrP2WVYgjCzGKQQgmNHgNbaMs8pI0ADyG0bKM+HS+PV5fGdd991MJlMp9N5NR3mg8n+/qvuvvPCubOf/k+f2rt67SMf/t5HH/vm//qP/lGxsnLfgw9MfTs9nCyRXTm2+tCbH3jhK58dSFhD2zJhYWZXDq5+9ZsrD792sLY+uXoNQutGJlfpKlBXGzkejHHmoiOAKIQoNxOlu0iAiFgWa7V/ZGHMhclCWUfipCMQLE6wmC4BsVrqCam3W7pct3i0f2x0CHSvA5CWohBGmY60lbrqDNbDCrG1qlueRCxUeYVZ/aMF20ydl2476wblQERgiFwssjNAAQEQDRAJECEmFwTSOaYHDiJq+lhFeyNgjuJ1qaA2Mkol+sEkUjYAglEBGwEoAxqkzGSCsSsWimCQFrhAkyFZpAIoE2O9GM+DStB5njS2Yph6mDlgAwGBmWYuHEz4YOIPD3xVtbPZfD43mDEHns1kOrEcrEESIARBDCAar6n7FQAMLbrPq7HS0WYE9T5YRRVEk94MgBmyhqTee0AkAoPkBXa//E1vCtqf5N77pmq9MwSzZl6IZKgJCr1GQNIiR3jjtR+F/19eSFlRDKbVHCi3hgIieBeFVoBRECQ2cQThthXnHEhDGTnnJsHV7Cdts3r7udc++OCtd93VAFRtEEtCBaJpQ4PCIohkVRMlaAwfdKGmxFYqz9a8cAiBOsuVwmMAiXBCNEaQyD0xfusra2GU4EuuPGB0DRY5h45kyerqdSt8gVOKRPHB7m8LL6a70uLkjdxAkSijhCnRTgRm4Xcnpmt6bEqGDUA7NRNgPyyjju0oKlEA0a6pCdbay/Tluk8gFXkiCEZ2djIkEFVnTHf4Emaar0Iwyp7TUxtRZ2GRd1RDQsmRklgtFkVH+gPSKZVhrzZERMQF0EdENbsqXA2oujooKiEgIiofq2j9oqAurnfqHB39XfcntX/pimqWRLEDQeTEsemsZkyyvkyuDbFT0cbenzBNnz5v5xTrkbq4k264fPAR+tZyXEiwROdJyGIoEFFC/x5s53MYMamEDzqyi4gEFERrMCYOk0noQVDJlqSN0d1eMic9nz7eNnVvhLTf4s/dc8VWatBNotobrSIhQM2JsTV58P7cuXN5blFkfX1tOp2eOnP83/3Kb7/5rW9fXz/5xUe+0rpGApusHBSDqpoNxuMb17fKrOQjl44LjEm0d3l0WKM6P2tVjqqVpEaG0WeEZHH7Fjr63cz6VYbQWmOtCcGB1nehAWRgns0mTVM1vrrlllvuuPNW8eHUiZPNbPb0E0+eOXH8B3/wI5/79CO//4n/9L3f932bn/7sv/mt3zp+6pYgtLGzfcs4zyBsXHpxf+Pa2spoY+tG1RqT4ZIdbL54+czm9urps2BzsqHIjdQu8oo48iN1iRjMIHmkKoRIkVt9pE28iNpdQrGd6wgKEgMAxOIOAIAulIzabhKVA7qmhmAAVSg9xFYg8UIMAOz1HDMYe8p3lE97ZHmkhaUyRTrYCmao70eYQwyRupmK+w5AE9Na3x4wFsQt/kvNg4jIEGgrWkkftNHjMTHVyFH8Q+edte5Rz7HuVO9a08XuSqhuNgFA8BjhLkRIcZYXHhsCCZ59APEgAJChsRndlq1mYkoH1jE0DucNTmuu22K/ggChqsGxb4O0DDYngQpkFISQ4NhScecJKKy/utk89kw1qyV4xw4kZAiFtWggBFe7KLBmjBFmFxzEAy4+bN9UiYiVTtw5Uux0K6SoOvLBFcAmoqWqIW5KkJZ8aANzWxal843znGWZJWRm593Dl34EvuPrK7f+ayf8mMkfeOmIasXv/r33g2vQGjRkDKEIkfHExrcRnlcsD3R3csYuJ6mrw9aRzXPna2ezW++581XvfOexkycaz5NqnuUDRKqbkOcZADFr7t8QpcQcUOiWvWYhMKKzhITIRAY5oQo6Vhz7aHQnDwAABICs9zS94oNUgdi9Er+np6AQ54XgiNrToocRs7cCPuYqonuuYEzHkwCA1PgTUYBRPCmEhUjpCXRS04ZMNjJh0V2jad3/yqHv3bnaXX026TlAkf+sen/pHEGJxwTHrtAIihtCLJ3tKuK0obkgWknuAWAgIhYPkUDO3VAn9FIPekQSbY0cguudMjrQCoZrySulpwQ1qEmWuzsFQuTLMpBB9b4MiGAQxZGTK3DU7HX2vvMFk0MVf8J+bouIYtEZSoLOBECAOUBAZZ8AeJbkfICCQMKsHom6d5BA++5OeodgvJ+4QGOjCkACAR9CxBUi5S1yOARVcy5qJTEiBkpTHxv0Jl8BmVTmHPTelAAf1UfiSkQGMCggyjTpfNAFVCjdyo9TlvyKdP9MPSaQiCCF3s0AdjLt0ftkQO28FVFwygijW8zGojHUumZ5abS2vjQaD5raXXzp0pNPPfWmN7z5Ta9/07/8l78+OTiwxB59U03G6+urKyen0/mJY6v7e5OQDsroFhMCgA8hyzJNuYqIckiZ2RjdmzqY0tUOxIQa9kN4kdTnXg+1PMsGg8Egz4wxZZEH4aZpACAvstxmiotOp5PHHvvmaDBAgeXx0vd+6MP33nPXH/yX33/t/a/5kR//sS/9yRc+/hv/6nVvePP9973q0tWt6aRaXhq5pawI8ugnPn3KemJbB8BgHBWwZLw15JlDaIcFDUGqQ/X4O3A1Ni1DMZBDErNXzibFsMnEZZm4UAgIIR0TvVSmvkxMBXbNjbHnSSOSrhlF7BbJaYwUn/SvVKqkAQPE7kNRt0a7s95U9JSsYDSTOvZaNRZXoT5ZsorRMcJFSICa1MW4eoli4EgExiBHqZuUaOtmOp3mAN3M6681lSOYBHK0Y5gYUi4/RVFRJQvhMC+ZOYgPIbAWLRgaEE2hKoTy3A5NlgHlYAsPJkh5fW7agPMWprXMG6xanLXQON6cEhGyJ2sNigseDHjmssyBchDPhN5ITghO3P68bmbgArcNAQsZQAxGmePGe08+ElzImBCCD0HdzK5VVayp6TA/jTRF6wAYASGwFuRr6xwOXpgNQoHifOMRgzgJkAMUIBy88+HhjZ+E7/j63PF/keWmbduiKEQsoDDwV087yO3rL+F/vlDza24pmT2AgDMGCYUbJ6EV8CC+Q3aJNI4JCGzmVTEuKcOZa6dNU1N24rYLr33z247fcs/uwb73oRwsAwCEMChyRBGxWmVMgB2jEgGEFoWNiMKpR5QwIBhDpksO6oIJIUSHJO6STo8OMTK7j6RUcGF6jnDdOrMIvSi3/4bOfukNWJaWkKADtFPgLiG2XRFUoVGU4JEIJIByTgEk9dxEBOYaEUF6iZXYmlyAg/LytImzQBBues/iEdpO0w+AWJhVaFxAWeKUVByi0gYGBIKocNbrkSHM4oW9fo1aRBaHEhAzYNaESbIfIKnfOqIQGBYG/Q8QkQmZhQO3GKnjCysFAIgZAiY8NhILRMTEfvGRttJVoIn2FwAAQI7pLp+Om4Uth+6xWe8/SMR1afG3GCz5DkxSaqQoOw4BtaJVgoBRsh0CCwIpoTUCZQG0r6ME1UJN9IgO6U1WvoPq9NILDwBFklyLxPNLm9WJsMSAMoAwEkcJhGjR9QtCZzV1/nRcUzKrW6npblX/FliAAMmk/SOpn7imw2OZqX4zU1LhBRYfwQ9QN4QFUjwIkBpeYKpGQYLYYyim9iHieUys1Y3sgzoelsKp0+tLy8PLV19697u+6zOf+ez58+e+78M/8Mu//MuHuwdLy8WF86998rFndjf2Bnl2x4Xbnnnmuf29Q6EovRkNla7fBFRodSYkw9YVlkOyLoudnywNLH4fuR2IKCG6KRlhkedZli2PB2WZN03Tti0AWGuHw2FRFNPZ3ng4tpS5pt3a2vrVX/3VH/6hH/w//tW//n/7+3/3iccf/Ss/85fOnz//a7/+r59+8eLqsdPlcKk6nL4023vVqVNQ+3JlMBwf3ztsDidVeXZ9cHylXRn+tdf9mV+98fUpzA/qOmMPNgcQRN+pYijygmSEMepaaoIvre8Ykqe9HWOyiK32dkNE3lx3uoGGkbo7SIGkgBj1PyK4LRmiEW0ysqj8RDKtRh1p2QeKK40jxa3Lfy5QxiDCqdOySnIBAQlqD27WPQ8QSSbRWYkWUznOmNhpwcSGQkzGIIntlD+0W32spQIdjLRCpHOjITL1eEGKQ4Nd7wggE1ExjRmgggYIUNgSGqQMyZJBxHOmMJ5tG8yBg5mjSY2HDc7bpnLomGonVYt1C7WTxkntZiIEHLzLtA4sOEQIwgOTHYS2QhmvrsH+/vblG7I9DbuToW+YGVGEMiH0KAzYCpREWZZBYBHxzkWw2hiK4U1foQAAQEJSKCahLu4FEBNZwArNBggMTER1M2t9jCFJ5I3X/gJ8x9dXz/+rEIIxWDV1hOeBmT1xCIQtAxoEwm/dkZVtMzuY2mY+zGnWzhE5Y2zcnEODCOznWvDIqBkjEuYQPBBv7u9PvZ96gWJ426vuffDt77pwz70bk+lguATATVv7tkFEm6ExxiUZJ+2Vq6NBLGhoYbu7hluIPlUF0gKzjwdFinPUQU9xfpJG1KV902hEa3/EyaBucYqI8sQwgnacXPBUok9iOTSLEqx0WgkAcEAFGdP+UiCu52OKQEiBIAYBXNiPXqkui7BX7nzgqB4o0i4eQlqQtifzjCIsnMz2IhKNeFSsJARAMCIgqnwuKqcdREJaZJH5IgIQ0yJWIk83Hnmi8v5EhgyAxEI1DkTqjHjoYFNeCAJItARBG79hwgZibzZc9INQ2qgKeYUQQNtYS5KcEMQ42QtzEgdA4zlQM6ynZPJ1Eo2O0HZXURk/AIgC6ITaUwQ09cnouzArTbEBBGEEH9GOCCOpc9jl6uIN6Tenk13iOgMQEIoYLklk9OtOBgYbSf4QosBz0jaCGIB2+Bt0QATGAFQWPNYOjVABDSQdk1T/K0lXRJtXpagO1PcNyTx0megIzXcLGJPKbVQnElQpC/WXUEkzvf3mA4Mm0TBwcME3eWmXRvmFC+eee/bS7//+7x87duLKlet/93/4O5ub2+urx/7m/+mvffWL3/jal76+tDTKi+ylF14UkUE+aMIMEYG6TKWEEJiDtVGhrjsLQI2KprRiZifG+QC0IPniouUpYmq7agwiZkQgYhHLLIPQrq8ct9a6uqldW1UVckDhkyeOuTZI4DOnbr3v7nsQ8Utf/urhZPazP/MXn37sW4888sgH3ve+uq4vXb1mR6vZeJVH5Nvw1MUrcsttK8PhtYsvzXcP83JFxiu/8uu/p3f0U6dfBwD/7bMfXxoO5u0UI43ap3QvAICBFgAEjJpZTWtgD/NL+VbReKJPku18X0Rs/aJ3TxTNjCiP1fWrTpvWfwIAQINglBIkTCAJPKAolCQpwadOvzB2xSwQUxtxmgRYwKf6IA9ASCDs48rrA9nIHGtHDaZ21wDMwhjfJgnHEm0K3cGqKRBSj8ckDC/6IpIYSMp1kl72BxEB2CRvNaMsdl2TgIBlRhawYMpFchds46lh9II3Jlw1fl63tSfPhSdqBbyUhNC2MG/8vK7nlasqP69D3R5Cw85Xs7kRUBctN5aZC8QJtzDIh+cNzdvpC5dD7dGQzGee2Q6KPCs8iggoZYSFrTFEJnjvVHDIWjDEHX9Tn0jiEQFkhD1G8hdL5KQLCna+pg4pEaj6gCV8w9Wfgm//evT2j7Pz0XIDed8Q5ZkhIdY6xcCtBSsANYc8L0ECMJWA08Opn+yWx1cOqkqQBIHcnNh5ZAk1ghGgAEJCEiCEUDt/2PgGzfj0ubsv3HX29rtuvfOu4erKtf09j4EYvXe5tUsry67xTdMQ2S6uCCAWomMbQjCJKtS3470FAP2fEZHQqHpbtOBgFa0jo2djOo27PRVLFyTl1jucg7RAoXu/Fn8l/YheKQYJIlqMqMMiVFKcXZHqrvNTV2iYog8QWGCJiIhkonWHGEnobxExpNZZSf8bBXq6v+wlNJ0ZQFOIeBHWntQayQmItiNKX8uLq7ABRIkOh+/uJ52+Xq26WghInW71wsIs4gENgohYEa9OsSwyOAtSQucQRBxffIzpQWX4SK/Z6wWT3hszD0FTUTq6omVyZPUffQdLDyZkS0RJtigaS2YWqxddyJ2pO0mUI6JwAGAUChKEvaBBQ4H1tI0Dp+lM0O2ncZZGbhxEhFUwrufGapTJLAm11gMu2uzAutYNS4h6BIgMLJhDRD71FFC6e3S/0lHecTUoiO9MbwpfUBHvDjXtIkgAiFIqSdxpMXRAMTcfUXpMi5dFOHB65GTSks+3KNXRGzCxvUz0SyBBESzctgwA1pgsx9CEuqn9rL3zrtufeOKZ3/zN3yzz4fRg+upX3X/62KnXv/6N66vLO9ubH/yu93/ukT++fPHS2TPnDvcP2oY9eyI0YIwxROkBRKy1nITdEBfFk9oADDA+OMQkV7+t8AJ+0wUqEowxhc2sQYuYGTsejs6dXjt+/Hg1nx96T5iL9845Dn5yMB+Plofjpdnh5Mtf/soHPvhdf+1v/o2Pf/zj//X3/vNf/yt/Zb5/+Lv/4T/M6lk5Gm7s7ew17eC+C3/rv//bz37rSRwN3/Wm1/3u//N/OrY0Hh4787//k1+Go6//990/8d89/4vCqR4bWNhLKnnlzAsCC/UwvOiapvxL5DxF6KvH7+nCXEQMvDCxurnirpSRGiFhr+ePziblM0CDaEV5rEBKbgApFyhbaq4N6uxoZYcquHA0SERWRHXovVaiEhGRDeIWYAsuZoWBgU0iw+mu1oZY3ZtRQDgSJ4Bi60bdMobFK80PFuXuqQwXDQIyR42fFM5qRpcGmdXgNDMqZxS0nnF51qJzNKvhsKKDOe5XMGmhCUBjg2jBYG7BZIFCE1rfNHw4D/OmnhzODybz+bx1Tajb4PxxZvEeqhaMQZMhUDDBc6AsGxNVW4c3rnzLsauDywo7m86KYR4CFANLhfWtAycGpBByVnPuLMyqkBSYm7btJjp650lt1iQGNTIDMrPKyzLE9cAhMCIaiw9f+hh8x9fX7/i4MBMRB27b1lprrWUGHV5jMUiMNULgPDe1eBechYyZWEKBCLVrp/vlsXFbTYJBAiOuBlQaTFA3j6PqPrZtW7dNef6ee+65747XPnDy3AVbDpqmOWhqyNAg1vMqyzIwsL9/SGjKcug8Q3IohUMgsRSFyju0LR0G8X87/mYy7wsmX2dBdMUmaKFDDbnnb0TZ894JszABItxBKnIzWh8vBMga7lqt8ObYkg0hioqmJFDqndjdbgDdtCAgIVa0A6ZkiqIoiAbBsqAwArYAwCF0zQsQTN5rD+PFO24RkyfTCyiTlVVlwEQ8kdjgUQfXGNXPUB+XA3gQICGETEfZKnvhSPtEBIUc9CgX37YuIigEAhC4N3Ok/MAjlQsiYsCoZ8exf7vEExMdotGsGrNgJwsIoXWBE8GVhS2QgHXeR5UTTIEda87eRM2hBMYAsB4UpHoiOoSi9dUMUHeFsj4ojRQ8e+HOA9MsT/RU2h5z+EjjMDEL7nGSKgEAFuRUDdUtO0SUwAG7XqxxxapPGd92cyugxZcwe+6mUkCYU41SIpvwkR3CkDg7ANxvVSHQLXHS4UIFj5ElmoMQWtU40euSlkQiej9PSztOmV7Ocz9GVDdIQhA0wsACwTG2QQIHALC2PHPsxLgsTp5Ye/B1b3rtax/6zB8+8p53vf39733P/+Xv/89333tmOBg8/tST04Yq77Mib5umoLxu2uFqnpfZdDYLQYAsmjwYDACGBC0ABCskgiEESyhJEgIgkqUBfJbnWZZ57+vad9oMiIiGXN1k1oKEDLLl0TgnxOCJaGk8JsS6rmODytwcTvYNmxCCtfbkHacmk8nv/M6/e/rpp//8j/25r3zxj//BP/yHP/XjP/HTP/OzZTY8uP47L13fOHXX8qms/INPffLec/e+5s7X0UP3n3zPO994531LD7zmf4ebHQ4AcG5Skq2aQEWWm4ycx8CZNQHF1jzLmU0YoJm3DRYltpiDycDvFwGrdilbPphXSyvLdlZzSeLFt02R554dI8zaeWEz68SCYSQwhKQCOUHEEYBymNBoM2XH7FA7OrUIgAE9gsrdRHiZJIBA6j/ABBx7ALJh8YKBiYUAxApbFIPiEFFQBJxoNySiIMGKbYNnEoRgwIuIY8PZgMKMiCgoEUQ9dfbBF4gBIUAQjvyngMQgJbdRlwcpoAloQdAIeKkNW2sGZHPPzoXKSEvIHpaH3ixT6b23uYEsDEpB8WWdZY7NPMCsCY13B/Nqa6/Znx28uGGDtVia4bJZO54tLVtbEmFboBFA57hq28O92c7ufH+3mVXzG/t6egozuEDB2SCI2IIPIZARMgLoRCQ4RsS2AskyMqENrUXKRdrD2QAtMRQ2NwzStJrMdsEDgNTBGKP+niFCA4RAnpP14da1zGyRLCCIeBRQETlUxpgyEo0HF9i/6epfePlq7L++fvqX6rY9rGbLx9cZ88PZdDQasXA+GhRFMZ1OmcIgN+5gNh4vO2N29vaQwLfNrPW1q4uiaLem66OlylC7XDSzw/aZl9i162fXD7mtqqk1CEQti+VBVXlP0Bqas5OiOHP37XfdefvpVz+0vLwMANN6j+c70YX1HoALEnaVd5BZRGTn9iXRQY0BrfT2PmoztqzVRpkWnDP4BOWjnrkSYbLouBsS6A5yITVwIuLZQAQagXu2mHkeZKotn6Nel1aNuXQQa/0hcmCv/keyXQAELgAAo0HrXMusancKVEkKAVX5LnUq6uJdCJjwA/VU1ICQiahAihR9FLYD6VIGourmGFj65kJ7bdzEkOguF3ON3WHaf2GqX1WPrPu4iKjBQzEqcMFJ+qcTRLvp1fPdFpB793vpJS/iBHSPsGBZBgCg1MFeRIEmViK6RQqQKK3aVQ5ZRFqfnHdasEdFpEs/QQRa05iQJoUSpS6iCvE3EBN1cazUNz/q2Cbj3auN7v+g3X3jtXo8I5EjU9D9HpLS1M3z0jm5Rye0DyQcHXn95SIv0L/QK1y3N1PQUVmhS9mIdB4Vs9psjCleEMEAYtL7Fw5N4jL3FwCkrFaaOL9AHUT0T8xsDN1xx23b+wfved9br1y+dvtd59729je8dPHZE6fGLP5rX/uaLeDuey5ceuEiMDRNDXlmLYbgnOOizDyDc4FiaRUaQ8YggFGZXkQrwaeMGPYc3xiKZVkhgtrCTUc4hGBMRkRZZgflsCzLQZ5lWba5ubm7u7e2tmaQyFhmrut2vLSWAe0dHuztHewfTj784Q//7F/8ud/4jd/4x//4H3/fn/nA9373hx772jeanYOP/fkfP3Py3L/9D7935sKFv/bnfnxzb/PX/+XHeTr50PvvWV9eHZ675SdP3A2v9PpH9/2Nv/rkPwG0HHAGIRhAohLEMswHnktLHvJKbJMFJraEgQPAWg0OzaydjMpBmB26lksqBRHRtMG34ossX6UBg5lZn2GMmGLX9VQ9W3gPiMCMzCiBQpQAD6JdWEmFDLTZWRAMQKBQFhJycMzEQSAQDtQFgQDIYiRAEAPcZkhE2usZIjEgiEgDDg0SoPeBFb0DAdfklEWZA2FgQWKjB3NjgFhpSsqbIwkM2BiLzMRgDCIAeY8sVtDYokHnYJI1ULa4hgWaVU/mnCFvTUArE7+yxbg99Zt7mxs3yqraPDw42N7D7arcaYtZsJBnuR2cPzm65Zg5f5rHI7bG2kwMVz7QjcPDw8n+1s50d7+dTPxs7udT17YZIxEZRAqCwASoLCcA0kp1pa7xooMxMocQAotnzETEGGOtCcK6VhlExci0tsZYq2RP1Vyp69YLiwgxq1EJISALp7RviimCRv0g4Q1X/xTu5+dP/rOMjO6RFokLIslme/suzzMyJohFaqvaAFqkLWnHxhTDfH9+eK06sLceX7/r1hv72xe3Nh58+PWDrHj2a9+8MW8k8HBoBxfO70K1sb8bwnywvlIUpfOhdd4R4Wpp8my4vHTq2LHxsbXx+urayePLa6vTecNSOReciyQkbRAWbUEqbsCEaOrxySKCUcQ2gbsOABAcyUL7ABL3szvQFiYytfcFAEr5ERGJfTtZACD0qJbO162bdf8UJFHh3S6eDIAEEY+PhR3p1WvZaFnaI1nGxG/oNxZRjbDoMZBCOOoKsKqMAGBKf+hX+FSzKouMgK4JTbn3rEZn1/Wf3Vj3x6j74eU+Ryr7XGAwWsCieIOkbHFP8kDg27xuukTf7HXf3zV3WITm/QaYjHikrGhx56y4hqjREy1jEVh8PGajEnBx1LJqXkBNcqTX6Vu6UiWMxTKysL7IRz0GQTALHmjKut1kwhf/TD5D56lIomf1QQ4QSTTM9M3qSvduPV79qBW/6aLq7SYfJyRMEPsLN03NKxRv938Tejsqvpml05JafARR8y6LlRaLrmMmEgC6RD5gFOnr8jsd7UaHIivt2VvOrF987o//5JMA8H0f/n4P1dbutQded8+x9VOzafPM0y82VVuUw/3dA1ugkCGDCuQXw9wGCcFlGSICI1rb1U5rIyPmuMv6j6z+PTgX1PlRiCuEAEJo4zpbWV5bX15ybVO1DowVaKVpZrPKtWE0GhXDQdVUeRvGZYFIZTk4ODz8p//bz3/g/e/74Ac/+PQTT37yv/7Xd7zt7W9/y1s//8hnrrx4+W1vfdeP/YWf/caXvvz1r33tu7/3/X/nb/93j3/l6/VzT/PmzvWXrv3CvfJzcPMOBYC/+vy/cIMqEyQWQiiLvEQzbKAUyBw0lROTWckZcNa2jeGZn01ze0xQCMG5HDJvqR3YtvWYl7lHBB8EBbwPjjnD3CIEQEEREyLMCwBIVEPHKQYPATJRxySDISoMKMoKEkE91gMhKTVgMeJCjTRKkFbxLg9iMpYYolE6AKGrug8WrBAFJMFABgxYkUzYdSlF3a0URCRIwDxnIaQ0zTFR4As7FOcleKXrCXsEBsQDX69AdgzKgo0gllwO5znNgqv3YHcSLm3uPf7i5uUdv3k4cMY43nYH1smqJwHLy+Pswm3r992V3XKuPjOk8RDI0MGMtvfDteuzg4PD6UG9tT+fzeYHs3Y+I88WpAApmCFTzWYQYETRJsDCzBD1XCUwIAqzInKCRne0iATtACwkWhagudp0rKC2BGMfOIqxAkAI2v8hUoZF4x61QEQoqUsthDdd/U4Zky+f+6U4k8F57xv2YpAjCRQwp9a5tp4bY3anB2RN3TpTZAHEZhlm+QH6K7y3cxze8oNvfd0PfnhldyOrdm599auJZfLYg0MHvqrK8ejULeceYPrWC8++tHl9uLJ05vjpQVF6A2KoXFrNsiwrclPmWWEpzxyH3fmBBWlc29ROUW0RiaL4N5nIxBFOBlQz8V1COZ7JCKZzOOA7H+8dAg3QVSaKCAYDqUSAue59tBGuRCQi1IAgyAGP3CjrWvACIdnBqI/SvWx3BmPXITolRwAk8bc5RZ+qvhc/ovljzcwKJnO06LMMgMJh4W2kCsaeWwSASa0r2fvOZN7si7zc2+iGqTtto7ho/FrqnjYVR4giS5hMZGJXLcLonuMSjyEA6BLH3e8xzqi+P5W5H+kZpu/kNL0hycqiOoiIICQJEFHzprUYAUB6GovSv66WhkYfClE5KwCCaBfXPSIrlNL8KSESV2GPSdR5A4iYqo+PyCtBct3S9+s1oy/XOTuIi/W3QJLiqoj8nqRKdTMiIhASkrNAYXS19Gckfndv3rumU0d+idAj6wCIdghIrdIA9Gs7qkjvNlhd7LTtI7SuOnIiok5lvEbEOQIAWFPceedduwc7jz76dRGpmkPnhlU1Wz2+dObMuR/6kR8VCb/2i7+D7UiYiiILaAE4GxpbKPmYs5ysxYVMWa/kjwG0mQ0CdZ2NdKgNQnCtYyCiPM/R2FbaEAJLcK2bz9yJtdWVtVXXtHu7Ozdu3Dh2YhWAJtMpAM3qBnagHAyyLBzuH2RZluXlXXfd9e53v/uzn/3sF77wxZ/7uZ/96E9+7I//8DOH27vvf9d7kPGRz3x6/+Dw+PqJV9135yd/97dXV5dvO33m0mPfwsn+EjfFzgYcg5e/TlX1gakKk5UtDh2NQuBJVe/PfBvqRy/W+5Nb3vlWev19U4L2cKvFqQy8NUyuLH12TpZCHbKhnVgMrjrwzvk2C76gIJlpKCDikimdCwiAogMksW2SYG2CSXlhiwSofbC5CDqOEVFT5AsRAw0gKMkSRZQTnSEi+akIIlkBZAQh8eSZArU6LYSEkIysCBKJtIE9mizjDNvQIoBBFEUuERFNLPYDQYSATAjAAiBB+7pxQBHAmkCiii9aYywJosD5wWi8z8vb1lRGmGzbwrUb/tK1+Zevz25shMODLLhRaaqqMg6yFiY+Xzp1auW2c3zbKbntFJxa99bO5lW+cTh9+kq7e1gdHMzr2Ww2rSb7oa7yaYMsRnAQGEGsoDVoDDIgsMeYvw9BPDOjMJkC1e/oHSYIyMrTRBBCkcAMIr7VRkImZVchkIA2oK2r1liLiM45QLbWWkLvvVblCIK6lQAILA9f/egrrLbe64tn/rmIAFAIyUxYCcRB2z0GVjNfGtsUxEGEoGm8CWIshcYh4s5kPiWYncSz3/PQe7//vacefmB3bQXOjV5Ld3gUB3L6Ta8ZZJlvW5vnUuYgdOttq6e9z21WUM7MLYtHsY6Vz8vMHBquGmEW1/rMMlNgZ4whg7pzYeExdD2uAQGJKOruQDgSmEXnAwUYFnoQGEH5VzKjvR7CCyMlIlo8mOK9XjYcA5IT1l1j1EKIdl9n7H9zxCCEe5/tIRyIJgpLCEZLFj/Z3VAUyOo+0zvIj7wQY+Ou3m/iDxRDeT1Jj9qbowa+x/4DjAof+nMUGOkPXPfBns0wkCh+8Z5vxuTjIxy9aO8RbjK03FWu6qs3jovXomq5I7J1ZjPNtweIRQb6GxJklv5nI+ExplfS1V9mm+Nv8Mg/u3UJyRQdGaKORNndcUpt3PTNGlC/7OmOrNqXewzf4XXTquiEOo5ctIvrFt5Ph+gc+So5MpuJSNgRoRGDeIlgTO+TBAKxtRcK9TESTBVicGSRSGeKtLQBoyMInaRjt4TUr62qxhb2ztvuGhT51tbGpZcuLg2XV1ZWqmrWtn515dhH/uxHMjP47Y9/8uqLW+O1sQfj2A2GZT7KZ9WUwWe5yZAYyHvWddRLFwrFrshRiE5LktXf61xSjHgNGmPyLBusrh3sbF+9ehVZzp4+ffrMmWPHj+/sbxuEldV1Atrd3T08PNze2ZlOpw+89t7v+8j3Pv3sM0889eTB5PAnPvaTO1vbv/Gvf/OeO2/74Hvf3+xPfuc//ae3vOUt3/2R7wMfHvnEJ2/L8SMPv+UX/8UvTW6744EPv2lKbSYHdPyfAfy9n5C/118Av/zVX3OuOpWt+SDtwTy7MRnseKixXFqC0+vQzi/+0bN2dQ8eXF5aHiw1uME1Gzhdh3ISkJePj05VUuMXnx4UFdy+PhjntckccRaAAltjW5Ywn6AttWgukolRq0agAEAQVFU6AQCjG3QKZrHvNLliNEUbgAEk7UoTxz9DrQTTWjDhELPeqWYPiQhwwQGSwNYY79V1EBIwkIWWC1IOHIFBEKsSnyAUqLUMBohBlPdogDKACTR5nuWSQ4AM8gFmORPUYfDSPPM2bxB2W7i+W1+8tvni89tXLo0PB2RkaVBknnBat7UfnT69dO7k8n2vGRxfg5URBAcHc/jm5dnO9nRvrw1zV9X1vJq3TetqaZpB5ccBueS4c2L7TGQBYBKP3nsksdYCsGqQm8yKr0VQBEGigiwQi0gIAWOrMB2tCDpKRCkibqFGEgFCaFUwWdgDABMiJXRcAAjfdOVPyZh87fwvcmrMxAiqgiTJE6x9a4yxhkIIzB4DIzOyrJqsBeOEbWFr5wHxsHWlAf+qc+WZ8cM/8J67P/zW3SxcrapyTq7hsg0+eDssAaVp50BIzPPd/UNwZTkcFZlvQ10dEhpjDSJ5ciLAgdk7ZkZgi5QRKcMu9caCTm0lHU2hr4fRMwd66JsUW6KeC8kKLA6/BHt3//udXunLUyKm9xEURq39FowiBazRXlKykcVuAjii3QfQoXra2mWBLixC/F5wKP18fxQG6GfN43d16Hcn8McKDSRQwSQkA494JT1c+uWeTM+2fTsjRxiduM6SUfr9wjD3/npkcDsDdpMF6v8paiT37O5RyxTvIf3T979f3wWQKj/xyKAxM5B0oJCACoNhd9NIkqr70hUX2ht6lVg5csQYS+xUgoip4O7Is0unUP4KDsdRxwSPUD1uctH6Y3XTmAh4REzdI6l/oYXP3oMWFo8cfQ4TcbXep/o/EMWPdDcgUatjcfuMC91V5qCLUCJGZxKfQ8HDzk1kEWGWVLUovTZc3YCLCKsHSUTqpmdZVs1m48Ho9Imzp0+cZgYIcscdd9RNdTjZt9bedtttH/upj159/tof11/NsRCTTWY1WcgHxjF5j4BEoigxhFT+mhrphOAS/6rnx+sEIaIwB+a68QimKIrhcDivpiur49Wl4f7u3mw23d7dQcThcDgoR65pRWBezYejQZbbup6/+S1vvHztxceffPzNb33ryvrq448//s9+4Z//8A/+0P/wd/72Zz776V/45V/57ne/7/7XPnhjd7d96okPvuu9P/qjP/L05z75if/4H++9/c6H3vqWq1ubZjIZfc8VvaOP49+Tz33gJ9/+jl/51KcC13ZI0E7lAPNhkRWSlXPAGeTWnDoDd52FKZk/+Nrsyj5tTgwVuSsGFa9yWPdZuWvbpZU2WwlmOP3UU+UwLB0/dTrYelBU5dhkwNM5otQmzMi1aD2Ljx3GIPpgAnqoA4NhYgASZStLaTUXgOm8UpF7IBMEJUqskwiylyAikwwJ2IojRBJCQglGRMhaRARMbWZTDo4bj6MCsiAcBq1kkg2zcR28y6rAEMvURBDFGGPQepkxI3lDSGysoSzzbBkKaAaSD31mKykqKOeBDuZyWOe7uZ/vNdODdnN7dvGG29q3cz7jV4rl1jsPtZuzDM+fXr79XHHXre3aCknZTOfhmYvh2ka1sdFMph4dWLN9cF0y4xGl9cMAIzIyzNvQWq3fZ4+Euc1UbkdECISBUZAEEDEQiQSD4NqWyBi0gHHzCgcOwRgSYfX2OUR5NGYmrSQJzCKAHNUWAfPMqLtgjYhI8DUAvOX6X4Tv+PryuV/oartcEJYgPiAiGwVfQwTWRRwzgpEQ2IfCZLawTdNM6vkKDea+2sp8OLMGp1fL0ydyS2unTy4/eM+F19xjTyxv+zkHHGPB83Z1MNrHubWlN+SDA0MAEIIja5jEhbZtWwNo8kwQffCt85JrlxwxubFo1R8GY7hN/bxS7BTJmIvSPDUfRtOCsYagM1uLUzVG2v1jtv9D/4juTpKEcPQ/px7PTfEpMHDq8ZNwekKICa4AUc6/D0LLTS6OupgWIutE/7YwKL2Dm6IF6cWjvUgUOnuGEQJSm9FpURiIncmi4TEAXQnc/x+vm8LcpPmheHzKd6TbQzCx7Wcq6Vn86Sgw0P8lHDGKKcEU27XHWU5fuLCU6d46fEXSZ4GD1kxgVzWrExenBtR9SPVuCgUdeWLs7iRE2SLq3tEt026OIp9GiMh48X13Kl1yUSXVfUl3scX7KIYjR6Y7XfHlLkv36n2k/xi6LV/ukB31FxPE0mFaN91kYlcs7kE/xdxzHBFVcCmImJhBkp5OmiHss2c6T7dPWe1SYN2tHmGT9BXxRaRt59qtd21lra4rY4y1tnFNmZfDU0M0cGPj2rlTJ+97zelvfKm57ezdO4dVgIqlRcxHyyMiOztstC0GIhIDI0U5LBIOXayz8CxFFH3Ulh+d6rPPC5vl5vTKCQAAgbLM2fvW1Tv721U7bBs/m8yWRuMst6Ny4LM2y+XUyfUHXn/33t7eb/ybj7/2gYd+6qc/dv36xm//9u/80ef/+CM/+JFX33Xvp//zf3HOfd8PfOT+e+/75qNf37549cz60vrZU5cvv7i/ca2eXn/4H1zoBqf9L+90k/ZXP/EImcw7AV9aGEmGOCwZuT7Y9DTPDRkrrp5PvvoNmkxhOi0bL5xBVmZufLaVdh6gHsDJZWb024ew7eies2BOua2J3T5cXRrb+26ZF21Zzci39UAOg6sYZhBaEbaEgkYIhcgDBiZPmZCV2LFMJByr5wAkUTEvtqcGYDdYDiGAFrWRCEEQ79jNcyMQIIIohpE8mQBYSh4jTAIR7QHJAEBgA5IzbonsytwXc1keFh5W9v0kiPeg0h4MKIadNbxMAxPEekumoGwAhsh741oLSDVT7c0cYOpgewZbUzio+bBtDvelmmeuHTWhDYTCFmm7npTFeHj6RHFifemO22g8htrPHrtUbe/O9g7qyYQzCUNTLXs/ncvhfFzkIiKNM40fBrEU5uiq0IDBpJFudXM59sycoxCCiPfOxYcWCU2DwCik51Mq4RYEzijzvkVAEA7BA2rWi60WE4Go3GKsQQchdVYkIOAbrn0nP+MLJ/65QXLgrLV6THU2m1mAWQhBKLYlYAEJwAKKbbSOAG1hHcqcuCnoOXe4dM+J9dfff+KtDx576B48vjpnZ/NCnG/KYqeumlm1XA5LNFOualdTbgnINw0JFEXBzMG5zFhvSwkswC2I801M2ZR54CbG3oweY5IMHFtAEpUlRAKLCL0+H9HhwJSz7oAfUJQTo2et56dEG9/ZlZch37I4PSAVjfbOVQQABtWXUr3/vtWQrlBWUvUraio8IkgMYHq2ZtE3AwBUHws60qjEg4z6t4WIfWAAe3ll6RuSJHvVnc7pszf5U6JLWG6mlVHSJlPPYAF49H+gVD3Rt53YS9DoSS2dlycUw2tFy8GkOXqZ29X7tps6y8BiyKkbsmiwtZ9v35ALgQhgo3yF1KxEfVXUQTuqcKWURUCkVDOhl44OQfzOOCNJuVY76HTehvbaTC3c1PMQeYWMSbpuIkUmjKNnYqEb5/TmxYR2SYf+mxej1HNHXv7Dy4caes5r5zp0wygLLK6nM3H0s0c8pFTkvXBBkDH6IFEiNSEiSSoboPPPevfQv0PuOdm9e9DEO8ZYDRMSghCKchBaH0IYFgMRRoMjW7ZtMDbUbUVUet+cPru8frxYWx+zzaft/qw9EOClpRUSmk/azuFIjgWAItrMmbVp1y2SdyKgJB5j0NqcmZ1zVTUHkMHgVJ7nSyvD3Gbz6bQsy7IsR6NRBU01q6p6Pjlo3dLo/R947/Ly6NN/9OnnrvHP/sxfevB1D/3rf/Nvv/boNz78wQ//3b/3Pz7yyKd//dd//d7zt7/vve9/4fnnf+d3fmf45z76tje/5Utbn/jaJ7/wlgvn/PH1Jx/7ynd//MHF8PzhB5qtG4CeLLHN2BOToWIo8wqzQDbYtgl+mjHQ1aq+9nz5teeWD6p2YzPsHdg7bq+Hw/ksG14+rNsi88F5GG3O2q8+dSwfZ3fe19bLnBE8drWACk7fw2dX/CHnW1OTu5NnxzPmTOzcOhbVHrI20Kh1wGQZi2ByzJAIGEGkzc8RWTKWyAoaAIrZ6dkeONe2tXBAA2gggAuSj4bGS1NLW1GYE1QGKjAM6BABGC3YTBtJRvjNUlFJcMKDrBgHj9tVseSL5eFozoBBLIsNAm3gRtiRNL4CmrNprc0ARhmQgcrBrAEWdzh100a8mJrd7lR2p1i1+eF2MRrY42tQUbnht69fnZtGjpVlfn7l3JnRbecBKWxNt7/xTLu/P58diEgw6Am49mbCIwZh74Tq2kvTIItkeFgwS52FUBK2bWtNTlmOgBICg1giymyoGm3z5H0rAHmeA3HbtsYYBGYvWqhpjCECAgit4+AJDJKABAYwYsRzMNqmT3tKoEhQtOP1mz/98v3ef33p7C+KiPgAWpTCYkzv8MBYcmRNBgaEkI2ASIDAwigB2Upgg1RmeRPc9vSwLWj11IkzH3ndna97zfEH7p0NjR+WrnaZmNJD5bwTyW0OJbWBgwEZ5HPDWd0WRTnKysa5tq4pz0yRBwl5gxBQhMRCnlkAABZykoEBtIDADD6o+pcBAIE2wcoqFSYsPvhgYhs5PcMVvVB71MEY2AMSRFUrEWM/EG06jwgs7mjUFF+mB3tHe6dyA8gJP5ej/AF1OJBTbINoEJBM1IyIDRiTJEg6iqGDTPSXFhGSOimk4LBn1NGLCAsDGmusMVnwNdIRR0Q9EGMyBKOAdLImBgBUqVwRCJHgBIkIez3QtWJeBKLECgCSyryzQABGogzBJLJql1kEBEtIwg5jzYZi5mIRAbSIUKUzQU0GkggHBFIBqw6C0wquLDMiHKKgu4kypiImi74zABBaTLaQ0Kqt0UddkAlMHucDIo8VYzuG6D3FZxQitEgGFt1KPcRvswCWpUZEpOhqSIfocN/kE0EKrzggAAIHVVfT0UoJkYUxFtYq5+gO61pVQXRNIqLmPQlZgIFVeBMAuKu/iqsNALvk3MJLi1xRRMRU7waxe9DRdb94CuTUTgITVVZtKgOAD0lZbuGBRdxFJVi898KExIgq2aKurURknSPQpQkxgABJqCM5ygUCAqrKXABkJETVeUoAnsiiyis6vpEWErQUkIDQ5sysPqeXQKlJrqHMNVVhLYJpqursmVvWTh6ftIfHy7O7sul5lgmKa714seLYF8BIPqiDihkiIgN6D5AbIjQkCAFUtQmBjQcUz1bU7JEp8qat2knjWhiPBnRyfVCYZurn+ztQDnleNQiIkBubDaxz4dHHHnvn+97xAz/2w89dvvg//y//8O1ve8uP//iPX3rppc98+pN/8Pu/96Y3vvFjP/rnn3jiiV/5zX/1nre948e+9/uf+tznXvjDR37sIx/JaPJHv/cH73rogXf8k1u7vdx+84fYzYtm3N643nhvy1Fuc85mcsxWy9n4RgvLRbtSQp7THh5SZf/LI4dPPDlePjZzzfLmhtvbyo6dO85n+XBzjANeHtJzlza//nT7lae8mP1PfuaO9Q/n3/X6+rmdnf/4R8dec9ycen1enZx9/onR/PLsox8ZHCvz7SvBTuq8Xq3MbL8JMMgwG8AI2kLAwLCA0njAAGLmQ0sGBgVYE5yzgiYzU3G0fC5jzp+/Jhs7TYmQ28KMXWH2VgZrKyfHnofNdLWpuAp+sOpWj8GwOJge7E+22/ogKxosQmOZc2NdkCaco/GwNLPrF899fRbecqeB03yiDfsz672fzHFW5XUObTtHn/lJ9tTu3oX1sFYf+/xTs689TZwfDAre32sEMCvHU2BLjqvxzuFoZQC3vaq6sLq0vNR+9cmLmy9kQxyOT2VnTq3cdpYQ/MaNye7OzrUNYAxBjMmtDcQB6saHliU4jJ3pTdsCCBowhATAYj1DCJxnY0SUIKqDQCTC3nk2RhzPEdHkiIieGxCwWWYNNk0jInmubcYTOSMEMgSC7IUEQcASFkVeu1p1YwXg4at/ipPx1bO/FFwI2kGJDYN48USUl3nJWFUzIsqyTDiwZyIiBE/BUsYhuCoASV5YNCQsEw5FWUAIgfjQzw/Pl8e++w1nPvBmc/+rEMwBkncSdiuG4AkqcoQIITCLIQKiwGyD2IBibcuhEREUshYF2AeB0EJHqYRYnQngewi0oEjqJ4WIEqxro/xgl9hVPocekwDazbGLi7h3HIosqG8hxlR6zIOoiQNIVbK98UREJoiY8FGkH0BEfFB4GFzvMxKLZbWxCUKU3/QYg7COOhFx/UUKGBIcCwC2S5dAz9VA7HoFpUO2l63o33f3ICmVoCd0Sp3T0Qd9pVfvHdyPMmPcCCDCSGhNoURcTLhLlJkA4IT96OjxorCYRUiSXpRmm7z3lAT500NAN5vdsyBGJ7FPS+zdmJBlEdXq1y7yIpIKGZLD1Reu6I9t56b0B6H/QREhsr039HAmUtpj/D122uqs0iqA0J8U6eZAkYAAEDs541FMAiPAk4Y4stlQlJ2zgHyOAldH5vEmJ1oiWvPyib75g70v738bQDLwvFA6V5UFAQBVzRDhtKGk//H+qw8s3fTiIL0/qf7jkcrkpOcWzwJV+uoX68a9pE4GQCqziiW+ACASQhBCBjDj5aW148cmO1BV1WBpcCi2dZ6blp03gEVRUhD2AgKeUUQsohCaLAsegrD230NDTAQITJ5ZjEFAwyJeWEDyrMxKhNDMp/VVPxsWJQoYU/pgfOUhg6XxsJ7Nm3o+HJYvPv/s5s6Nh9/w+je+422n108+8sinHv3KN77ne77nox/98Ue/9vU/+OQfPv/cxQ9/94fOnDz5+c98+sUnH/+J7/+BvatXf+XXfu0t99//pntee/f/ddyNw+S3780cBCzCcETjlXLvgGqGAUEg2Gno/DKsjWE+HYppswxWbXvx4otf/OoaDJwLsHXYfuUZylfMXRaqWXU4y8dFJsXWl75+9fNflcvXq4ODaQE3rr/w4JXvyx+63z95rvmtzw1GK3DPnbB/OHvqyuj+zfCBe3hpPXtqr9jaB5MNz51pnSlyahsffGPYwqwyg8IuL2GeQWgdYDYP4NiJ2x/QGMsxZ3Awba7daK5sFl7Kk2OxJszmtuE1RNjabge5XV+ClaWsGGSD5dHSunizcuz8aWgmGy/Wmy9iHZoSZk0YMM7IFmZQvLDdfPHi7FqDrz0obCXbja1amVWmqvzk0DfeilBVZc9dgnJ5Lb8FQlZnDQ/2qydemh0cgJXWM2YZOIHcMoU8sD1/HO45v3TbiXpjw5Wycvf55XJYrqxLUVSTw/nhwf7mpjROmIs8hzaE4JxvAUT9Y120HMVeRftcheDbNgr9ZcZoJAZRyBGUIWWtJQ5JZwtAtDZRkyT981NEMxqvkDmNlcMP/2m0jC+e/OeSCA0p8Yyxxi2Rm0IIwbvucTo0VERMVrim5RAyawDANW0gEQvLwYrnnWq2nfnxW+976Ic/sPSGe9uVsp0HBABgICRrKIb7AgKc0GC9B9EGTfGfi1MFAITJWFXFhb5qog7mTUdcd+zc9EM6NI6MZ/f+/jNCwgi633TeQ+/7oxtx9IqiDgR0z9DlYuJpBjoY/1++RDSW05reI0TXo++BIw1nARlf9tY00MnmRR2Im9+jSuQgWhWVagujPUgPuRhWvun7088dDnNz4oMImI+wN0REICQ6IktH4kjmSkS0ZZoSnUU4iXb0OYyLNFY30+mRAYF86DgZoPzBZMW6zrSKfiezJ9hfOn0z3Pc5MHE3ulwACCF1Stui7a0hYmj9+TeArEACgvS4P5qzXIxYl+sHhP4dBRASwKOpisVNiqS9FH/DmmkjStXRiD3q601L/BUX/csvtHh/QggTNNKviIkbufMbugqX9HFOEyjMHoA7ju1N4y9H/cUjExRrmnSRIECInW56DKzOC+yujP1aHtED1qv4HqZGbPqfRQlBACQE5wIVZbm0unLp4uWs9rawxuZkbVmMEJrZpEVm59h5DkGACQQ9MGqZAFlRnSSOLGI2yGDAQOs8cG2MIWuRUZx3lc9MYykTbzyGIh+CQOO8QSwNHO5tLo2KnHA6285strdx/fd/53f/+DN/9I53vfP1Dz78+S984Zd/6VeOnTj+6lfd/yM/9tHrV176lX/5S9/1/g/8xMd+/FP/4ff+6T//+b/+l/7yiZWVL/7u7/3M77+1G6Irf+GF4upJGG7ALbdyZhECtR7mTWODJ6bG07QBk9fAphWqHRTQPPMS1+1W7S0Xq+sr+eEMru84uNpKU3vJ6nb+6JOXP/3lybPPLWGQan9QSfOlrz1+5dob/u5/f+rdb2g3Pu0+//VmzbiT5dqfhOa/fqW6MMQTS1xla+ZMW2Rg1jMg2NzypTVFmc8bnlTSBo/Wm8KO0Nbi5octSbY0Ok65zKtqukMAxWEFTuZbm83G9aXbztP6ioyxubiDywFOHHOW3Eo5PnVaBsMgaAgcQJCsxNUlOVnwigTedvUmTzPK8gNTf2uWz5bgja8eHjvdPHc9ywpsHWzvwmTiJ4fONWPKs+2DaRXye0/lbQ0QwutvH7/6lvKJy+W17Wt/8uXBznzAWORmim62P/VlOTx9anb7mez0urtyabgyWhpmdV3X3G7d2J1dv26EMXBGVEuYzabMkmWZa1vUIDV20o6pOhvbEi96OSEaZX0qeVOxfaVeEVoJrCep1pqov47IWWG73a3fjIKCcGTPojy88bOveCzo60tnf5GSeiSH6EcELVlgJSbGPav70TkHwp3yvdZ6qOCYTOsBGUE7Yz8lJzkOkUaC+9DsmoBvvvXMex4++743Lt12blbNTSsQzawQGFV7UOTbRNkHlN7Jg6keLB2Wi4Nice4JIR6x2L0jkToL2HWX7L1HR+Dbcuak/zpiy17pWrgADro/6h96v+GFwwGdvYZX+uKbI8MjVQUKuBzlF+IRVEKOOByISrU+ok0Wn7JL4feuGkc/ZrEZkQA5FVn0IQTseRgMYI6ohah6GABK162qN56pACQEp//sDxMiABmSwBwLjvWiHI0Tw4I4EwS8QEBCbbSXniI5gN0bQUAiEQ97vEKtjewGStUyusmLRV8I8DI+rPQ4KIu5TC2aoL+OoZ93UAKOwjf+pm8DDCi6VBPan+KJzhgrXhYbZ8efERGZvSBQbzV3/3tEfjSNJESHj1RHoHeJV3hS7A1HmvuFB4aIyjVJBcs9o56euqNhxy/BKLMKAIIsAJFylHgqRLqxWSDc5C53kQfAohFaN+Avjy2OuPRJywQEiOJ6EOHoVXR+cX9jK9J4pIAriuMhCQfxoTW5HS2Ptw+2xrOV0eqy1Nw6l1NgxrYJAWqTDUT7JWdGOHYNDCIZIKrSEXLXHFAACDnLDHgGCNy6DGltaWm5GI8GQpjP5s181vp6ziEQcTkerpbZ6onjS8uDPCNr7cnTZzau7z717HPXdvY/8R9+NxsMX/PQa9/17ne8+NJLjz/x2Je/+qXv/dAHfuJjf/4P/+CTzz7+2Pd+1wdHb37TP/35n//h7/+Bvrdx8APf2vnsczUsZedPc90Kic0KGJfAbYZsraVihHP2SwHPrIXrbelktndt95tPnL71VhOK7KB17CZ+ulRgZigrRsXSSb608YX//InZs5eXPWQWTTHA4MlDu7m3+VufOvFT39/84OsG2+1wsFI9dNfe735m7WtP1b80W7njQnN8ORxfN8Nh2K79vGkzHHMpB/WMq+GIYP/Q1aG8/16/vxlY2GI5HhoxcH3PAduTKy7Hdu8wXz+Bty9n1/es883GniDA8YEpwDI2EzdaPQ7ZCBC88yb3IbBBS5QfTlH2Q7m8PFw6t3QKZdZICKNbVpZX7j+4Zw32Q7F5CKsephXu7Mv2NkwODXio2WxPBrfdalYH137/P1fPXRycXAurp8yD92d/5k133n5m+pmvTZ55QVBwWMAcgQytrWYnjsHepL54dTyr5/Pppeub7MHVbpQb7x03rlWOJACieN8YozsmMHuJ+UXRIgMODgCMMVmWKdssBLFWUnNcEVVXFQksBo3uJiVaJZEcI0EpmUc2hVqLh/40MONLJ38eCKPCZqyqjGWwohg1c+raCMwsJMmzcSiQZZnnEEJQNqPnAADBGJdafS2BdS5UUu+zm9x74lU/8P4LH3nv4frgYF77wxm1gkCSa4IcQLTrbAyzZXGGLE6P0NmNeHQtTvJwJAUcO3x16EvPBJiFz3Hk+xdJ8O5PPV/wFQDj/lF25ESK/75ZhiDdtaQbOIJwUOpiCMimf19/WqpCFORI4Wr6Wk7E0OjR2uhe9P2snnJZ/xsjtNXDH6InEVH9FJCSdNpfolUCLwsub/rm+Ht1VhZeYUp6iQBwYNfZY3UgAGKWUJKhQ0RAZUVAisLVd0PdSGr9bh76hUOn6wiTp4IL2m3iHuLCdN2MN3WRdLdcjk5G9+oJbyAfkYAF6MpBu0+JokoppGYOmkkR6JCr2Oy79yXCaR/EG0CAnp5Mf7HeNBqkPQl4ccfYU+TsYxv9h3rFaU3b7ubtmv73iDpZ708oaddh170sVuUtpl5HUiQt11j8r9ImcfP05ppS3/nFHUanKTmd8cshIHUHSJwjffZ+42ZESUMhAl5ANBDsrYro03jxOuN6A4NxfubcyWKQ7Ty/vTIarxdLO3vbs9qVS8PlwUgQGifM7L1Xl9EzAGBgsOC1LsZq2osFWAyhAcwQiGRUZpYIfBhhsM1EHArWXNXG8/J4kOdFZmE4ys6Ol86ePTkY5qNxkWdlORytFfnQ8v6XHx2Nlu1o+OKLzz/70nPHT56899V3e+8feeSRBx988O3vfNuNi1d++7f/7Yff+d6//H/4bx74iSv9OX3h6986dnni1l6Et+xkp2oAAscueLe7xzsHkpWydmx8ar3OIVsZQJbD0tKNb35p96WXTt33qpPj9UM5nLeHcGO7ODiwt1laG9mDyYuPfvPZR79x0oztYFRVMw5iwAYQCvbG3uaZw8Px2+8L1ZDCwORTWEJ37QZ/5ip85dnih99XF7bFsMwIzQEOV+fNdJgXowYn21v5sbXy5Em4sWm9C8dGmBkz91BXToKURc5Zs73rJ/Pc2MI1IgAnV4IBmbajUeaaeQv7fj0rTqwDgjAXOQQIORGJheXV6anjs8GgWF4frZwYrREQ7LYh253Bs1dlMquubA1GJtSTsLubz6d8uJvPptZLvb2fO3FnluiJZ/0fP8qTvWZrt8JrdvPg5FNb9g135idWw8GSr+cZc+ZFhqY9MS6Lsr30jN2ZIEu7N2sP5xlly2Bc07L3wbfsQ5ZlNqMQQl3P87yE2Emxk8oVEfHcSogHvvIMNDkZmzUiK7ZhkAAhhBAUCwBISVit1TJt6yB5GADw8NbPwXd8fePML2jAwKmZjd6S8z5KOGr1rMQ+pYwp6oAggsYYgUBAzAyEGJXRhJU1QlTnULX1ajE8l4/m27svTGfNA+vH3/vwgz/0vsHpY/NBLrUfedOEwMN8H6FoWn0mjWoYCA1laDQB1AX7PV3UmwK87oVd9JQiFgKRiOD2pbReoclGX4Ogs0FdlkB5HgsgAJIb0EVQ/eM9nX6L8tejtq/rk3IEC4nR+Cuc3N/5pXaWVG0LUDUy1OvqD5EkosARS9/dE9yEriOiwLczt6lKUEgWjkJ889GJ4f4cieg60cg3isbf7KWJADASqp5mSn8waHtUgM7hQIxqo6mEhCCJsiV9szg3xhyZ7y4UTpdMv6doiGTh9mJaeDc7fUcG6ibvSqirk0aU1MWUug91ayWSBrhbQILq1cWvBVA1zCgIgQDaDr67PeH+/S/ST9Kr+ozgTf8RkuaD0mIWd04xbI/eQDeEvanpXevb+MELNyUa84W3IcmV62ZHequxP4ydm4yIsVVKavIKoKXq3W2/IqHk5lda5F0XnoUz1EvQpY+jIGkjXf2w7rEQefFHkEO+6XISAzWf2/zc+ZNnzh67/pWd0aB89V23X3rh+Rub1z/7tQtvffD5g3o2pBzEWwgC4gIQGEGyxkjdIDERBe09zkwBVfcxFx4A37a8dGx17Kr5fH+6u7XrGMphsZqZwfLwxInV8VJpDZV5NrbWhHpksnGebe9uTff30BTzg51ikG/s7J5eXVpaXnIhXLtxfXt3673vefdHP/rnP/nJTz73zLPf9e53/+RPfezf/cqv//j/OOo/2vV/cWr739xdT54/ZUt4bqO5a69YWoVi6Hk5mx5mezOoGIZcTaeDatju7BNaWCo3X3qewe1d2S5Grl0aWGuLnRa3ZnUGxtfTrz72jUc+nXEolwZgMibjHeGwbAMHBBgZ2N3HjQO7ugahqCZTvrLZLhFbeurpb9xm31je/VpDApduuPmOXxoOV8YymbmdvcGolPGgme3RhLMTa8YLzudN42yeZcMhe19tbOQ+gGN48QY8e8WPrbzj1fbMegbor+1kVMDx0h8rZdXMgh8CAASBUWhcLggFrt15fhlYedQgEDxf37m8sjU7fzhdxsqHuR+Av7EHe7swr9nNsuBwUlWTfTi1Xo7znS88v3r+tvz0m+bT+vDq9sazL00uXikvPr1scrtUBmjN3ryogz1Z4LlVP59Pr14rRWrfVi4Q5Q07Xx264MuyHA6Hbd2ISNM0WgThXIWornwnlcsijEJE8UzzvlUAz1rb+CYjNCDMjAJojybfExqaBJk8Ijy09Z3SJQDw6OlfgugxCKHRJHTno2iBRc+QAwAwRlWG7qIsDMovQcFUVwjKk9B3GmKAompX8mE1m39xY6c+bc/+yNvv/si7Vx+4czq24uFwe58EaDAAS0Rkm0aUKw4QImMMYhdSXAQ/CbdYHPL6ioGH6P10Pa30N/FcjV8CRvNBi1OlN6LfefT6w36ToQGADraPR326QXVrXinM7uw4KhCrHwqd0oMIv9Jp/m1uPiHmiKkUdAFyJMwDRKTPTDT9vHV3sqcw9cjxjV21NC5cMAAtgKDuuNdlffSAfrlbJ2nCkncNi3vvxlnllVg8UY7YZShuHhEdbRFFNUDdLuVbpLs68iDd/PWkn+Am1OHIl6ckRTJRRxAtiWIkNwNc8f1H7laxpoBgbgLV4hcq9zCxRvQvN11Ov0f7e0F0cdQluDnTJtFnioOCR2GYtJGOvDSk0OaAABC9moU1VQeBWHxvKwK8zCvur0sREVy0IIlX72EPnT8Eke0aDbkK5KfsivQhCOagbT4Vx4qL+6YNdtQ77DmOkFIn+h8ntWBlySxuST1pSjEWgEr3Hqn40lc/aa0kfEQTa+SDlwBrq+MTx9fMcs7Y3n3b2f/l13YB1gDgTx69EwDeed/jI8sB0ANNQzutKi/IgEQmueIowAas9YwCPrSD3B63dJroOAkMTL503J1cFjK2yBmCEAwGeZlZS7bIMichz3MCbObt8tL6vKknk8OssE4gEF2/sZWNx+VofObs+dGw/OQfPPL82ed/9Ed/+PBg77/+3n96/vGnf+FTH+pP7s7T3//lT3zy9LveMDHl4y9tX7i0VW5cK9ZW/cqo5nq0tgYnKrc9kfl0MCKY1kVRSrlUNY174aoxdDg9HFgsCsqABqeO2dMn7Wg0vX75mU99dmfrxvHi+Igy8EEAPAb0LTLX1Ay390MtXAX0O5IP2ulksNf4LFu7/SSfbmR9GUKYXdstn7pUruR0fASbMz6Yz5eGWYaj64dcDuqza7aew25NeVGsjth7t7UthLgyyO3yDHwl7cr4QuHYv3gDn72OeeGOLdkWoPHD4yszIEKiVC5k8kxxAxYnKJVzbevKbOn6M8/duPrisTCCfCDzFsfW1nW7Ny0O5jKf+raxzsvexBuEu8/Vs9nBo8+dOAhy6TCMBvlSueaL4Kftsy/Uw+G0wOD8CmQ4tEBi5jUtNyPn86zYnkydpzwbWEMITQFlCKGu27puMkOAQiSW0AW9R919DKljgDEWEqsj7ntELbEKISnpCYQQ1CGw1urhEViPO3rgxk/Dt399/eQvdHuta0sdSZQQ85SRsIAIACazAMCyYKEql4Nw0WadRQI7DcGJyHuvuxq0yxmg9946vxnmszNLKz/80F3f/ebVB+/lYbFZt+HQG0AuC8gLQQx1m1fNOuYTG8vgRaVERPu5gDG97LA+RY8e2wszEKMutgEIPdku/VQXikjMF317b6MfrB45xG6GLha/6X6+6RhHxCMS4wBys2mgl9vQ+LXIfZsoL3tbfPbEKIuXo1Qms8itLOwXItojUfjietxz6fpPm8zVy+8RFgrWnVjWy81Y76u+7UtiQgCi85UcF4h0FF5osQEgiiBBz4axCLyMccMMSNDzVG42ukeEKyI0oqb7phuO1QexNBIAQEsbItImsvC7QzSTSERRrysVX3T3lrI8GIP+btFoiK94Rm/wezcTVLUkqui/zMnoX6V70k7v9YhMVs/eG1ZXwyzGR6TPxUxf9QqL+6bVD0eNcTp0pLtWWrJHoKDFpHQlx+J1JImUwha/U835TSPTT/wdvb2b5rG7ge4XDKis5whgdjtf95XOVGCX3BfdjTEbqIzmzuvqniWwGAMiQoDMEkIYFPl4qaSRvbpz7S///cdvus8/euo1P/f+LRaqnWzvH27sTg7rxgX0AILgRRiZ0KD+v+ecqGDMW1807cAZa8KoKDkr2CJZChjImMEgyyjnBqX2PFCU2DLYQTneOZhe29hExLwcsByOl9eyweBwMtvZ2X3Dww//9b/+N7/y2S/+s3/6Cx/8M+/7y3/5v/mDf/8fj6yr6r995htPbNZucMvJ9fe8cemZnd3NyflvXYaTF2iwbFuTFyM4fkyaALMwe+EyTA7syoOQ0d7WNl3ZFgKm/NL+xu1sV8+etm+4j+8717Ru/vTlK996YohD00pGQSCweDAc2tkAraOGLu3AnGQ8nuehdNVoVtPqapYv7720udrkMPPu4vZKMNLQnH1xabtaGmVn1lcPGphVsDKm1bFtpHnuCpxdy1YtzSayN83KApaXPEr14hU6NS5fdauw989fky9dN2U5f/PpcuVc+60XDi9vHBcDwllLYMGRKbEN/x/S/jzctuy6C0PHGHOuZnenvef291ZfqlKVqkq9JeEOy7GFDQrCDaY1SeDBI5g4CS988AJy3vuAhEDA75EECCQ2OI5tMI0xz7iTLFuy+iqpVH3V7ZvTn7O71c05x3h/zDnXXvvcK9t8rK++W+fss/Zasx+/0f0GaQNEDKmkYEVDmvSo2JtnenDx/EOrOyUwlBbStTW4e52KRtXspmUDlhrDs4JOr6UPXTTb9aknL5vZ0e72dlUqUqM1Ssphv2kqYpfXiEmKo+FxMctm49O3dsdTcbd3uJwfH0+oScSyyjFRVNTWGEdESimd6qYuCdg5p7RiZmaxtgEApRSiIiJgcFZYWClMkrDrja1bA7CiBDzlqAAR1XWtFD6z89uEZTx/+n9r6TLvKy/bMyFoDzGJA2OlWeeEcBF65Y9mJGmZrCXKNGMMIiIRM3uWiKqpjwZ8+jve/8j3fcvqM48CYT2rqmkNuVopqEmQ+7mpm1woT7KpqWaZzSwCeDemZ8JWrbrNUdpiLCMMLsjiE+cnALrlitMQddq2NtaJb7W3nTg/T1zd20688d5HLY0zmBN/9V9BSZZsKq0BnrxWF6J8vl577ts89AYVXGrniUsjJhyCa4Jy5pxjh8FFAiHzQXwKLtiQSevJNoBCbi6gosyzTXhndhxliumdPv/Fn8LLrWESbi0KLkpubyXDVrp7IwuSADaBAjAMEwHHunFhXaKvdBWhBosnVgdf4C4ETjvr+SpibT1vGY8rAZG9gU9YAcrCLNbidEkiR5kvCN6GsITwZuyY+0TEhZBvRaiZ2TqHCErp4CgjRFARs/gNSeDjYBkBhEhi3HhoCbMgSstwQpiEUV0eDScNdJY4g2vDgwCinQIEOPTRooAQgvggSEAUUA4QAUFIxCEkGMqYhUcG2wkqRIQQAC+IPn7MCYAsPB2LuuF+YfjnMAv4RCL/e6yqJiIitgt+2/AXpDomnhH6gUAgAuYFk6m/urDyhDVHRIAgVJ8HXxSKImr01M7sF7eAFQDH4qEDYkAPfk6V0hpcbQ0qJRoBAZVWgNZazJUtmj6ywqJ2heHhcH106nR/lLnJZHzfPfnIhb5Wytb2cMVW5/vX7x4ejKc7c+WSpAIR51AgM5g2LrUyVI0SUH1dJQSDkTgznlSDLK2AwXKWZYgKnK6NS7Oe7muNIkrVppqNj4/eenMyKypjGnazosl7g+l0mjE/9PADk+PxKy9+be/O7Q9/+Fseffqjn/nkb0zuHvzd/+t9bSP/5V/pT49nwsYCvnbt+On1Mxe+5WG1c9vd3Ibb23arL6va4JCV0vmKAiXlPu5aPKiSUdHjaQZUidIKdSKz5jAZXjr9yEO0stq7ffuF3/iVIyn6goOVTcfOcj03R4KsMCFJrDVHg/JGcfWsecegv6lFjhRs/tnvqV578+gn3zIPn98Sqs8NCJW9Oqe7Y37ggj6/pffLorylt0bpaFRPSi7mvVGPT41sUZrr+ypN1LAPx5PpdDLIcpWmhZHswCTH9eH5wcr6GiHXzXFvZ3u8e6RvHMFwbZASiBJKjEDCIFWl88yglK5ayXNlebqKldD5SS9146KcDOdzq9W8nLGd5DBXZOHwOEt7d6vi1PqDrqz56hv6oTMrD71/bfd48tatg+s360SV0OQ4mFsr1mlhM53YNIEsvfuFV0m/OZ9O78wLEiC0lhuemgZIuCYSAaMInLVE3Fjrs1H8cvUEcf5Ycs4QACWU6oyZX7l95fGzD2okZswSzezT+oKgfebub2XJAIDnT/3DNlWEAZkdEfk6ej5qUqkEQ/Uy7yqRkJWrfCwee/KCsK1SJSLWhrBQdA4T1VjRTqgsB6srY7K79eS06jklDdueKHFmv6rqs731Z9526o9+8IFHH1s7e35s6uNZyQmR1s45TAFBYW1T1IxQi9OklIluDk/wFOLxEQSdoI/k80cYAhAoRlTqZKKlJ3gEbgBAFtEtgcaJJdAjdU42f7n2tnBCB8GnYzFYacNCWumDUURiazQKRzQAtgmI3EkC8PAMvd0YUflqvIgtD6cgKBAi1TCzc9z6aOLFIkKoQbrYyBHpwCIRzT8ARKRdPLQlyCj0AizkMgV3BvvITcLoHvOwMgRmigCAUgE0hJ7EsqkL3uhusZlWXV+OZzkB5doRR9DeRB+/Hv6ulFrY6oU85YR/fhuZ0X1aF+J1seGy+CHERVZT+4T2W+GHSO/dUdM9nm7pGVRbEV1ECDT49N1APRufHBAbCDG2Li8R9qKyMx4nWqKUAmgNXEvs2t0x7Ha5e1E0inYQMQP4QmZfF4feO6TRvLZkXfTT0d4vC48stSkk/gEtxA4ZSQieDqfztmh2ozZ4O7yv87L7rx8AiKzz2LVgdRfAMlpvn9fa0nyoSjfypg3sAGSBqKAoXBQ+wLCDQawTlCRJEFEsR2sZkWNoKkKuE2RFTuWN4fXe2uXV82uPPvapfz6E+11/8ccHf/MHndJpP8eM5fyaW+v1yjuTcVki6UQlTcOFqbVKkyzPIBUwlbWTsjkqayW2KWaHBQo0SqnV1dXRaJQkmbXWNqZ29VEjs3o+K+az2SxN0wuXHtD93p3dPT05nuwfYJ5nAK+88sr5s2e/67s+cnS4/y9+5p899ewzP/ADP/D9f+ywbeFL/+q9+zu7o43R/ud2EBF76fWjA+2q586fE03OGS6qPOklliHRNZUNcn5py1xIKOtDVUxv7JZ5lo4G9d6MbDXN84uPXoazGzLqH92+U1y50zcwVAO2zrA0bABVzfVI9fI01bVtZm72xg3c3tfZAHqD1WceT2o3/o3PDualTErZGPU3N2ZXb7nD8aqt3Ubf3ty1b2znp7Qb6mJ/107sSj8rzo361w7UdO62hsnautw9nM/nwwunkiSFeYVHE2dRPXR6oxrB1V3d6wM0+9ffskf18NrtSmzdFMkwl1On3NktzDPo50YgEUxUb1Y1FbjiTjFSOd6+7ZxDWzfVtAQeHM+ktFKYsqlWBivz69tTMOfOb46vb9/6t7+OpzfPFvXKIw+sffAdbpTXr15fPYaDnLUQKkJAsS5h5tpM9w4bZ40xwpzqBAlAHDMLiw9gY+FAuheINNA5xwzBG+JCGUJ/BorIKzff9DP7+vY1AHjizIPWORF5bvu3sWR85ew/9ttBk2LGhT/R22a7NnkR7/vw9ysfchG4qjxH8yLUz4kgMyJqrX0MdalEWYcClKsSVG2KhPGhZLTXzHOdZJiMXX20qvLf/ezD3/nB8+95Sp0blo3ZnYwbx0onqU6QxTFG6/uSug9CgaS9Y8sEUd1zhhcMjf5YuK/2H3kllu3r8PWN+t0TWILC48+WpdtEpL23VfZkyW4BXYvF4rztiLzuJyei7aKc9qZsjryOnRtAdY5T8vpYpyT4UnHQVlb6ZrdjhYi6bUrAHMGWgN33SYd5qbUke7QXnwggFBBWsD34myAuIxQ5CQkXv3QGAmQRYtNmKCCGGrheH+4SaXQAxIlHLsGO9vNu5ucCl90DgDr3hNcxs3BM1qDocAnsNhAlccAlXRaa+KiF0SU0j1EYI3Nch4tsYWXpriefRnXSS9W2vIOHlsbE18Bcvrld0wsj3omfuw+J87O0mgHg3mymtk6xN3GFOHOiLr/LMuaLnmMMgcSdBQbR9Bcq7MZX+7bLiRjntmFEGIHqAk0iAkRGr4iPIXZBgdcYlrvTnSwRiasAEZQEtwsqRSFnT8QBp0qjgFjWpBCQHaMgkDPgTGUTna1kKyCK8rXRA4/mm9cuPfS5m1efvrcXgN+e/ZnPVfMKiVf6GVk4Ojp45Pzmzd2Dg9oZnTJbp8EATF2TkHIArnFuXsBxkmhwjQF2tjT9fn9ii+rWQZ7nSZJYw4eHR67Xc86cPrN5+cEHV4bD3nB11jSNg/F0ptN8tLpOqd4a9vcPdj/5a7/6zd/4u/7oH/xDn/jMr3fRhshf/vwv/HK20QctuzeumbKoBslxORNlV+fZhY21albnhhPXuN1jYYuzWS9PzXxiL53lHBmpYTftJ+cw6VNvn/dofTR45nF7cYuUPr52u9nZHQL2te7lqWOeHs8dGADSRFVZEpAuefrG9fqtK0nes6e35NSwvH4nvXK3B3q6McQsge0J3z5I0xSQmzeuOTVE5bSIvbGdzlT/zDnokzmYwLhSK33opdXtbXVUpGtDx+yuXtcqG2bDWjk3ylNri7uHqdJsZm/s3hhmKxqa4eS4efUNckjrI711UT9+AR6/cDCdmOPizNpW1tOFAI6G6WTOt/fq6jjf2UEyaQ76zn4zGQNzLY4qV+wcjR4+g2uj2edfak4NZDK5+nOfWrt44dEPvWfzzJmd/fFRWYIFQlRI7CwYqwVYXHV0LKnyGQvMbBCRfT2FKFR8oHeHXaOz911nXyMCv3H32okF+OrOtR+AH7nPygQAgBfO/KNWl/CIoktsJSLcieFrWRbbK2xz7+mHRV1eYe8JRULyPOdKESEJOONMKqKUMmIqy04TIJZV4wozSJPbs8nsVDZ43xMPf/gDF7/53XRufW8+kdncWWEElWYIIFWjSOWJrhzE6gELBqOgGQZbuL8hME23o4eCrS4EyyKjewYG8zksQIkPC5OYBHDv6dp9oISkgRA2h8jSOo+6GjtGDXbRDImKrUQl3E/xvUGTAF0ZJwtKBQBgJhCFi0yTzlcC5vATSlEoIIAScbF54CVjrPEURw+9gdzqzpC13iYi0q1gFokJAcs+gnaEfVPaNQzQ4hp/WysjsZWXy3hjkSgcBTPEpoeFyLJ0W1fP7k7hiXVwYnzbqW3VUxFaCJZ7fGD+30jzQB6IRayzYBFFhEDtiicK2cfKuh2IE14ECgFaTN1dr90+LiMAiZtkqYPtqu3WifErPTw8VqJdhlb3f04EQ/c+H04OcoxmbQdWWsLXzmpePCtYzhZj3j7nHsznv3Iy0SOMUky0OfGuToO7Fq+uiYsX1BqdXCQEn1S/YCMFABJwjqWtN+P7GLc+CJHPmAqVdxyzg5YGhlAlmkWMOCQEdlkvVwzUQM59Rflbr9z+zKe/2i/hyQcfuQn3v37of3n///3bf7qcFa6um7JICBlpmNDcQFnWAprSpHG2YadQIWkH3DRsp8Ug01qAgFivTua1qoxz4qaT6aTu99OV4eqjD14crvQ2NtcVQlHVu8eTazv7L73xFuhBgng8GaOiBx64/NTbv0GDfOKTv/rep971b3/p97UNq+SvzpvCEJ+9eMpV8+LwQFmFiqosbYa9V/f3sny0nuRpP4dEVzumubWjr29TY/SZDa1y3BSbcIYJ6cQcTmYMrPMzjzwMl87Vo37v9vH02k0HJkNNRtg0lTM1NAjU1/1EZ2xtRTLIclsWk+tX041TNFrXcz76/Etw+y6sqHzUV0cVNONhr0+nVotXb/deT/n9z0Ge1G+8SUWlLz8EudjDg+TaXnN5K1nL01uHZudIP3AGz2zA9uHs2m29dQbe/TAfHcKtAzctVD9nwslXX5nf3s4f6UNaQKrqyX6aDNFi9a9/CR7cOlrPr+7t1ZPiTd2fobiV/NI732d2D05bYyZ76totenRLHxVmPLHTqdOKCXa3d7WClZW1u6++Vd7cXdlY76Xu6K3tvZffsMxnHn+oLitHCp2z1jpEcdZaqzR524ACBaQAxTnHnloOAACss4E8gmKmKLNAd1PQYknD11HU73e9cOYfAYtKtHPQBkX6Y1ApZUwTSkaAgITUjK6Fo3sCAwABMUhgQI8GRYi6swJ0COI3kQgiZgiYKOcYG9sTdChHJIcZlDBf/Y5nH/zYN6+972kcDeYs1fF03tRalIdfzKAIkiRBXwYhBIP7dHgCESItIohCdCKmzUvrRbqc9wDEXnh5FA7nzjhRRyeHqBfdv7KViMS8yyXOAi/sMEaYtZIc2mPw/pgDYtH41ogg3rMTRapE0UkLoAcALBD6ziAqekBOrAyKcY0UUQXHD51HkL4FACAMRIhA3q2D6E0FAoz6HkFLIdMyljELtHFR1nbjbwGoNUjAPbaE7uS1k9TBH0vjfmLCorAPARbMTus03hsPdsKYnrD0nPtiDlk2McFCKHrTDvt3deFnAIwcQtIRFKiORaerc7dWI28bFEFABIp8oBhwNIQ4EsDF8EJMqsQFLfp9OoIIhBrUwvATmxoiHLVOuoPAkZHdORPVkcXOERFUJ61E7RBJpFRpm+EXTRclLLcNIwQJI+y/7dNsFwsDvZ1Q+9EIfZcIfQIKju1ZPHwxWd6+5D/n+2x1jtPRNhUW36XFDuoSjsGiHC4AAHUwqI+Sa+NH/DN9lr+/MHafiJAURD3PEhhjLUiaparmpnT9lbW837v7yq23vvTqVz/zwv7dvce3zt9w8MipL7y1/96llYrf7v//P//S9wHAt17+GwjQy1JFzcrKRpOY8cGUrbVOmG0vz5usRwDWUmMNGBBFGaISzlPd7+VraytZouqymo7HGxsb589dXBtIkqUN2/GsmJb1zri4unN8bAjEVI0ZDoc6SW7fvD0bH3/oA+/92Mc+9lc+vtU27ef+xTNNWZnpdLyz876nvsFWc+WMK5th1tuux7VaM2m2Pyu2NofgGFZ0evYUViY7mOHh/vHeEe3s5tbIdNq8fntV9/s5bs+P9frK2cefaIZ9Tcq9dfPw6o0SMCc6vbI2c9Vxcay0Bgaw0HDdT7PSNODAmWb39rWVhx5b1RkU0n/5RjHs11WV3zmAm7vle1czNeDb1s5KPItuPOa9afP6tXx92Kwlx/Vk/fpOX6gWU1y9Mbg1U6fXioTt9eujvXKYJm42g4zn5Wz48m1cHWSPX6x29m68+Ko9LNPHk7I6xv1icndv9MiK20iGp5LDl1+68ZWXdGXPrZ2+evvOa9u3+qc3XzX/+J0PPvDwX/gjk8ZRH5rU1K/cEdM4a+bFWAHO5/PRymC8s3/7+e1cZSOTCqr++Q10rphNdq9chdL1SNcEtWsgLFEHDAqRFJiy1FqDIhSOOXA+VsD4cLJ2HQNK63d///Yfg+XrJ+Gvwv2un4S/+gPwIy9c+PEQpCcOYk2F9qxoT8nFUd8ehMuWV+mEYcVWhb1z4rBmtr4gti/f4oPhdKrH9VzVNkOlhZqm2ZWqvrTWf+Lyg9/zTRtvexjOrc+ctZOZYoQk6fVH2gqztdZaZxFJNDFzXVutKGpkLdGA38g+FRZFHMeMxlbBXuxOUHifHJMFqajnaQhxfhgAFfoJidf9JFSI2WwHFjsHXRQ6QQFun+AxR1ecnbgwltdoxY0Idwq1wKImKIOENFKK5o0T/hr/XlwoZoseeXjUPbaXTAPC4V6MLpUW/7bNCiQwzKZdUiLisW18wZK9JSiwiBwXk5cqJxgtYYmPyg+ocDR+IBEwCYQdEuQfM3iml9CGkNnlg3S6yLG7Ezpul9YfhgtpiAFyShz3LnBZuoSEUcDXFWs3TIzm7XQNg0INPtA2sGdA4NAQIPQcDojieUZboLE0PmFiIo8viAgCKFIAgqKhExR578JtP2kfa5zzifYAKMAcSDp8ibuTDwlzfY/W41dqbNyJPCsXVQEAEgw2ycjqgXJinVDI96VQ2S06MriFUOBadae797qQGxEjgSm2sONelNbdimoRJb4MvPyzfTKRAIcK4wv4pQBlGT37nylCMfCnAAuRIq1ZhJ0oppySAfWS9bXqYDp9ZfuNr7y1++bdBzcvvfP9HxmqfPvaGz9z51OPnj+rL75w8czWr3zpwo/+8Aao5oeWR/4TN/7iH/mWn5nP56NMSdbLaN6vrTNclLWtxYFYTc45G5aUTikjpRrTZK7K+6M8AU1uZWNw8ez6IO8BmKqWo/n8eF4WliclX721fftojGlPkegkMZarenbm9Knnf9cb537q7vbOX25b8t//t+Mrr77+5FPPbg2zc6sjdDbNslOnNm48/9qFxxAsz4pqc2W0V44fcC6dznmY0Nogfei8SjUcr6zP0+riWnZ2nT93dHBrp6maTOlcXP/8I9nDD9S9PCvswcuvj/fuOgSifLS6YkqxUyOOtCQJJSBo2aXcYFkjUXF4IM5B3ufZOLmzt7Z6utETLsoCi2Yg8sotunK7f2rTot376qunbIrG3dm+uzqerGxe1kqBNe7KHagN9AcADbx6HWblbGOoq3m5v7uy97hqHB7NXI6kV/ZfeX3vYF8xrg1X3I079u6xubIHjzyMKIdHNw/37pzKME17O3vXdvZubfWzi2v9alY92k+gOCqu31jRqTscb7/2OgGwqcC6DBQqqhXYvcOssDRIHUJtDRAkpKRs9LQywGUSqr17C5woYbDWWh+l7tj4tQrIQSVSqCkVkWevfgx+Z9cPwI/cF3M8efahF8DXKPXQwFdUQOekpeyBSD9jLZNWrZRqQQaDqKist/9KdNAzCARam4U26Jz1OQuktKAwOwJEUv1eBsY52+xzPbswgqceffwj3/j4h95z+0zKTOVkZirTGwwAVVFXUNqqqRFRa1JJ6sRWVSWEOkvBtkqabmGQiAi3Wlmr8fpgDtWRj8HO4c+fcCYEQRvOB26pInx4PkD4Uwuw4t0SRSRiPBLRW6r8GCIAB3eyRxcLN9DiahFePPD9w8Kh1OpR3Rt8L5SPJQSIjGQcMgm8I9oLpyWXircveBYg5RFKfF+bmKMkSDXVxmC0gsODnpijEXT9EInp7/aD3pqD4lHrF1C33KuXUksm9AU4kja4coE5uoIyPjZ8A7tEpSIeeLZF1eOT72NvPzET97bkBF4LBsVgSlkEjrQ3h/tFe+nDDLQM8DuNhwXJ77Lrob2hfWY0nIQBoTi2C9l/vwTX9oGhqBqAZycPmRqgOpanpS7H6kcAsIixwGUQ3X3dfXHMohmLXRSuGK0SCp4BgI+KaNPq2lo+cWRYwAlIy3gB3hSBHiT78OQ2mw598gvBUgsBQGESf2/p11FEsBN0HLBtUO+WfJnLU+P/DXkyzE4EfXC4eP4e7rydAJDFsQml48Iwhrg9QGRJGPqSpLXI8eTg+l51bTe5Wzxc4bvPP3PhkUcxG7z+/FdWx9P16XwL1Z4kd24ffO+3rt65nK+vJn/zz3wGWP7C3/9Q+8Z/+snv/cPf+tOzykyOjsdVBVp6iU7zrK5cXRvbNBzpkCqGuQNWhKSJ7d7efnZ0tNLvbW6sK6xSVQBAba0BtT+dbx9OyspYxKQ3RK2sWGZnLe9+3xjgCADufr8B+Dj+6McB4P/5F9/6hV/4/O/96B955KEHdq+/Phpmrqz1YH3j4pm9X/3MJZZTozVhrAEmyt4+PBiU6z3ctEwW0LItwGxQyiAV2enO9v580p+WbHl10D//4NvMxVPJYABXb1156SvO1QNQPRrsHO9XUjMwC6+nq5ujTcUwLceaKRflBMppgU4kSQuxMjnMmsEgHRYyy3qJ2j2El66ZyXya6/WjucwNrGzM2Nx86fXszOX1x942H2Z0/WY1mw8313mtP7+9ne3N+5trpVa3r17FvXrtaLY26Bfoqr09KI6Orl7fPKqNUauj0fHLr8+/9FZ2/mF7elRVxZ3XbswPjweDwV45f73a463eam8wc0Xl5m41mV29s3pQQwbbX33l+GBnU+cF2DXRQsIKpTYAkK+NkMVVFjSxptLWDhsUEAcJO0MOEX2AgTf+W3YokGaZdY2z5l23vufr7db/kIutAAAqEIkmAEFBQIks3QAC4Ck7fHJKywLgzxDuqAHdgzHKixhsoGJ+mkc35PG+V2yRCJhdWReSqO1qPF/PBs89/thHv23rg++QU6PX5hPcqQQBtKJhvwQ2daME+mmKvayuS2MaCmIVUICEBC3GGtcADqStd906gHARNwqtg+NkakJ7xQ62XWOJEqyVdwsT+P2udoiEF3aOSL+1sExzZPluMzX8t0KVzciVjgCt16zNTIYYhOD/zswCRKAEVcxpIfEmNOxIq+UcBQSKTYKoz3PnsS2mbCVhR4qFMn/iUd6JzocJj6b7RQWNFnAsLuRwHN/PpNMZ9FYwh4G49x5mb0VYqLY+xbENO4q3t1kMgm2A4PJ1QpR2JXEnNXwRO9nes5DriycEVbb7HBHXrcwewT4QkVAUdK3k7Ng5QoMlQKoTFqAwRDGvBJf/5J+nqRstvNTHE8gm3KZV9JIKI0g0HXVv7vY3DHH02nRwcfihi6X8UMQ92aarOESKvsl7rQ5N3JbeNdMaTvwm8km9LCE9hQJVjLRfD8sjutscgBKw8Yjy4OXkvPv9G39d8i61DSOIdLcizKL0YlQxWkURUQEKi+OFDcbjIYVkmJkFWbSoESo4nh3cuFP83IuwO1OO1Nr66NIjqBLo9Y729nF357GN03t372xg7xYXX3zxld2D1fOn+o9eeiRR8Fe+/xf+u5/6zrZtP/GJ7wOAdz/6d12qkkyzlbzX7/foYO9YoxKtWEFpbGUsV3UjQAoM9CnvW4LjaXm3OFIoeZqhiAY6mBUzZlGZU+SMBXTO1pgl1vLRH5zB8iU/9PF3/PI6u+/4nu/5mE4HoFRt60sPnk9YSVNbgr3JUV2Uw7w35bpsaujlu7t7F4uix6IcakmhRlXKpEcrvRWYNttv3R6q9MFkdW62JxuDZ85cGq8Ph6k+fuv6Wzeu9nrJZpkA6KPZ8YynTqCv01Obmznn1jZObJNwDqpqqsn+YT2ZG8sMwtXM9jdgVjcHR8nNu818ns2L/pnNuztX+tAbrW0eHB/dvXMHJrUcz6EodS+bl/Ossc3xeFpMzaScCKtxM5oez+/s0YSrySQdZAfVxO0fNk1hysLZus5zurgxffV6deP2qcefBpbpl1/Z3z5aHw0Hun97504+YyF3tHN7cPbc+WSIjHe+8NqF01vlqp4dHuabw3xv6lZG2dhMqXYaEwMNwqGbn5P+LFNgDdVWA/TyzKIUplSYqMZlWSbAz17/nRotvt712TM/1kaVYTSzkzDAj72xfaV75xNnHibxnHVRHY+Z8Cqexm1OeFdb88gDfUiZICLaxvhP2hugc3aFLYbMUcfQSomnZmAmUkopa21Zlsenst43P/34H/jW9fe/HTdWj2ZTnowBZNWoeQp1qg24pORRkkqiDqpZbrUmSLJU2Ip1JIBAYB0q8eZ4b8yI6MeJ+DDEpXOvc6guzKgRVKko1E54l1oi0UX6HizLlKX9dVLxw879S7e1xgmJ4mNZokPoDmIodhHFBDNHTwoihixl8TVxACEEeTg/Y52wm+WycLLoVKfBqnVPxxGLX14EC8dhRJFYvK37lNBbdiCCAk4pRaQ828Q9owMAIdHRGgOJbjvpZbDChfoZLSU+9mLJxBEyuNAbu8LQCEiwegl6intERBZE1Ub3OMdaU0fqh/kjaiNPlwzsIgJCKqRV+5hkBABhROXzm72wF4hOAfE+NA5wgYhYWISYEelkDDazA6f8CvS+LgWBGh114pwTYaWU1/6d47g+YvIqcLuciZKIWAIm8GlsAM6nyIZC0+j3PLqohcelHzqehFH13Oetuyu4GhHBE2a33yUCAettie2mA/BJ9UCovXGCCESAmZVK40t9YV5USnlqHPCgECD0S0AEQr2GRX1C74R0arGdPM7wrB4oYiWgWe8WBQASAF6KwxAABrQi4jzZoHTREgAAdu4Pzm4RQG7rDbsOHzkRigJhmzpoLDilE0x1qqrUJQ1rQWfEOMEsMQosG00K2DZ93EyylRvlapWKytNaz998o/naza/cvb41xSTrv3z75jMf/uZ0fVQfHxXXDu40h0OCTbG7uZ4kqy/tFNeO7e7+W0mqsiT92Id+6mc//f2dPsKX3vzzz73jH5BAP9WgcO6MGiWJ1c4ZEB4oZQWttWU1R8QmydHvMyZg0KTRGmZWgCwogtxUxlnrHCpSSiNrdf94dvi93/bdb3z5TXrf2Y98z3vAHJ/LNJQzImXTTaUwNyIqV9jAbN/KI0TV9OJGfecA3s7omkIqPUzSPaizBjS4mZGdA0PjeV6XhRmtnK+fONXbOqP2isPf+OzGdG5U3wCvpO5A3HRmUz3YPHvOmmbezOaTeZr3jCsTtiyEFnqpTkZNLdIbbB3C9NxaVpQ4/erLDzz1lH3i3MH4GF/ZfXmAo/EYnQXGbLBW3D6AqRnvzY/euqUBR2mPdCIoRtxk7/iQUBzApJy9dm3j0YtHwnhjZ2WUszAORvrsanP1lnv9cLq+Oksb92u/Wbx8dd04mhecqbKZKs2mqXrItpia073Z4e7q2kavl85ubRfz+WkeVJTCvBmDTVCtMFWuso1Z1UmTssxnrfB+8spH7z8Tv+Pr8+d/Avw5LKF2K2liRmYm8ckG4WR2xCjw+LlHCNSrd19/8sJjzJZFQHkzBhKRCg5sH50AzvmE1UQInXPCgEgsVkB0mqBI0zSIqBJidsM8M8aIYyISQkEEQtSKBUxTM3OmtUZd1mUtLun1MtcYYNSqD7qa19tczi5vpG9/+6k/+u2XHn5w9dTWvKlmx6WgEmA2ZjzQAKAMKwBMdAMMDYwoB+WVEGHmoOyR9QcdAvjy4QDs9TARIOVEgi0zZli0ifHtSUJeWRQAjQigMOCwICQABCgTAPAnTIAv/gkKoi8JYKEUQoy3a53LGEPiOCQ2U4ftkMFbXxeaPwd1V4FECy1GSosOwqPoWEDClDQ5VxMiIHkffWwJeEURvAW6QwsuQAALmlCMtnNjOHwlJp0AcGvV9u30JW58BVFtnWtRArTIDuLZ31YE7gRd3neJK6WUp6MPZTwBOORG+jmL3PIoIs4ucEA77v4HZuFYzLULF0IVPj9k3cCZSIpAMYgUIoQ/AccAljIpFh+KiDApf3MLOX2SOsH9DAAQ003vGRO/mFrRteDgilGcjn1tICDnnA+p6Mr79l+2nnyNQvqDR6WILsrKxdAJtRWBJRqoWrS+oLaN67zFm/53EWjz8jFkR4fmtI0JN/qAEvJUXW2Yum1XSNt+JFCULrQEcBINVyGIJLSKA+G9gLUmuqViyrG39TBEn+siI6bbMIhWFgiWD4BFbMzinrh7Y4viNKGKqT0S7kFEQEghmR2Ns40Vm0HpeEvBCDEr6n4y7CWpQTOeTauyUDmlyhlnV/XZLE33X3z94HNXnrnwTHa6XzV0+vI7jp64srq/LUNx06r+0qufefMmDfLNtfWvXr1yuKLsMPf0ycM0nSdNbZtX9nYVgVJKa3rs4b8rCG++9efbXrzw4p8CgKef+ftgEQnSVCtRpFWKCMCNs4hojBGRsiwVEiISCAEiBSoXx9IGFLMwiIhjB3C081/KD30c7nf9Nfwn//03/dDrL726//LX5MELjZnkih2jBhwMBqUxs6peWc2z/sgyjHTaqHpvMjuzc6g2T2mtQSujYGjROlPtHeTj+hTn5Xys09HlSw+KYUVU3d3buXazqqq1wXo2womZjKu5BrW+spqiquczqWsiyvI+FLUe9sxsjgq279x4YD5vNobuqQfU5782XpU5sbm5vTdY2Xzo3DDtHzH0KeGiqIqyErbz+e7+zuXDg34v2wE2xoFjYBFkVuisVUr1NM5tOdneWd/eGzV21phqbvNUcS/tr6/eunb1ztXro7XV3SvXrOH+3Lq6IgUJ0OnTp9+49mZRl1aMlGTv2PV+n+fFla+9ZOpymOa2rsE0kKatUGHmZ7f/0H3H/Hd+ffni/wUAbUk2Xj7eBAEVEaHEHHtaHLZx20ZW5SfPvw2EPDl31P65s7W7Es6b5f0GdyKUKHSIwN4aEiyihDhxNRAkSmudimPnHFlJULmqSdPEojVNbbVK8sywmdeFAqhNM6nreY/4ga3Be9/99m9//6X3P2dSsuwO5pPGWaFgQUn6uYvGSgCUUDrbAYC44JsIpnpkEoqhAouckbaWdbTkYlB1ltmn2uFsjxS7iGSLB5qPyosmE8Cg1UGkPoJo2sZ73dadwLh4rvoJ7eYHCAAoRQFJdrJCYDkXEpaM4h0r7+I5ATFgnKjOi6IB+GRV0YXBo7VpdbOQ7unXotyYh1z+RNft11pn/4mGxosA5L78rOFl1H4YmuIrmnozyZI0OpkuRd43CcEg0/UbhcIziOjJ8xGRYrRE651qr669wWMTIgpBi0IeP/nihxi9WdC1+QeCuYXYhk62TntGhJnDMKYQvE4I3vkXY1CW5j4yg4E3HrJPSkZPId+SVbSj5E8kQvKJtizMbgF+T6wqXHJRBbNe+7RF9IN4njsORZtisb22R4joDZjLsrwFHDFZKeIMiXVD4myFQWPx4RkxuBUWnYqLzUeh+zEP7fFxcESKAsMdRX9Uu4iX8oy6iWS+NDyGjb0AJd2N2m0DYihNjLjIi2nFsL9nLpj3B2JdSsl6r0970/LKreRoeiF5hE8N3bnRSrZpiqk5qswgsYNer+Tyi1+rfvZXZy/euvshe+Y719P1syrbvPj4Y7d/7YUqgd5Q8oPq4Oi4qpPbCb9eTYu0l2VZ1QiBS9m5hComi1njHBsnjRF0jLBy9m9Ntv+r7l772lf/b+941z/WPidNq8XONcZZscBOnDjrkDWRIPrJQ3HCTNG+TUS7u/9197H4ox+/L+Z46N8O/uAfOPjgOx7bf+Urk3c+kaRCWs2KKrdFMZvvT2ZHx8e9wWnDyGyUThqd7NTHj13b62+sK4Xc0zDKYc52Pi/fuFHtHSSzytRVevGh3tZGlg4cQnXlJh/NsiwbIEmOpWVHkKf9lXyoGnEsSCpJMweSQcZ5Yo9rZWHvpdcuvXwl/dBTxRMPb3zmpXlP91f6Zuf44M42HxyePnU62VgvjrYZgW2T9nJP9T092F3Z2CStxFnnDIhDRI1I7BIEAzYf6NnenTuf/oK9cTtlK4zc8OT46Oit6vj4ODM8VJrLZqiTHulCJ1mSZIQJwrwsGCDL8nldrKgkJ7KTcVUUzPbZq/+hkRZfufRT927MNpw5EhegRIUVcaFcBcc6LWo9s4RijqQz4JA8H7M5UURR2LbYoUdYJFCIiBWL3J4hTgSBhZEDwwaKj/JGAdJKEOZNoZDyXqqI2DpWYqGuiAVBC2NVptb1QF+zx3a9z88+uPL+py5+6/vXn36k7Cc3TNWvuDZNw6KTRKXK2MY6pk6R94iQTpi0o3MBO4I5cqeGUcJQAAsRY4nMjuMYXMehvKgSymyW4hgC6zT7Y8WH53NITkRCgqAUeWwXyQruAR/dY60NGGj9zh3Yt3BhnOj1cvcXn7cowb+Flvg5OtRHQWLwyWdGt3YYzIWcvQ+EkqjQLpeRAxDSSqng1OmcyHGgAWEBQWD5BO8MQfw5kBmEyH/w2EJsO/GLxn8dM0nnmS0ry9JXRMQJqw4wQlxIkUXjRTzz97Jt4j7hkO0WYueBGHBsrK9YqrQneQ1en/AA9MYL6TyGYrRHO1ZxuUDkPg86e4DhCOS3NfpA3yj5/L9ak4jzvszAroOESAjUJmv5P7AnA6bWs9OiDT/mKg6UIIeDBVEwJKm26TLQhjd3myEi0Rfma+CFakYBpsT2A3pTirQrwthA2UsxmEg8Swy7iKDDVicfQ4rtBAICt4oVxvDeluMEY8UmCXZIbuO0EVE6npETkDj2N5iT/dQ7CcAo1sMJieylWEmoT7RegVzdOa0GcBdf/6efumPews3Ryrse6X/gbdkj52QV8WjK1w9vf/E3dp5/Ub984+JuYX/1c/N8qL7pA7x5avXRR1YvXpq98abr500/JeFZAtdnu/sqPWTJihqNoBKoagKX53ldAlgW6+F9yK1Z2/rbGt3+7l9oO/Pil/+Td77vx11RI6X+9HQiIVtXK+WAYtYaAXqHnTAww/ben4d/z+sj3/Ztz3/q106/7/3/6R/94yvrfVcVpimzPNO2vHPlSl0ZUqwIAKifKjHOrOixombnuG8cKKA8pY2Niqbu6t3qpSuFdqqRTbW5/q6nswfPi9amnlfXrw9QuazftzARU4mrWQYqRQvlZErOKiJQVBTFKqU1WuY6rxXdvFv/2hdXn3yEz1+sTOOmmALVCM10enhn58yDD8DGSrN9Nc0zpbRFUQhNXW6//ma9usdNCcYKkBJGBAZh11im0pS9QV5Mjg+/8rVsXKVpahWxNSmp7d09AVlf2xC2aOtems2m+5BqDZmZz/fv3CGwg8HoB+c/DABQAjz/7zvS4frq5Z9u1Rtoo/07JQtaDgb0xaU6HDLdTM7ueUiowve7tceCF3+pOoQgAQlw1wWJ0cqI3qwR97mP1gJEcaHSt4uJf+FES42QiGgkICeutJU/r4w4dJKQSpLEWnvoijkJDnP9TR+48P6nNz/0Djx/iglntanGpRMuAXWaZAhOxO997CiuvjGt4OgKQmjHYiG8XGQR9dW4sM2BwADNgizHqJf687NFCRIU7Hu9ugzg/NGPIbktKEsci2l5YXEiwiNevPzAFibFXKQFdcICFbXP6eKk9ob252AzDmm2nnItJE93B8pzjEowS3zdKx7Pgp0P23HzfYnigxA9kCARXFSLPQFYuGuB8Sx2GKnHwkG/gMsAIEKCDhlRUXgdsq9qFW9wUatWS4Aj9iu2T9pPu2Phl4SHEgCgOhRkGK+umAxBBy07p0grxCD40sIv3UEEv7twUTS5m/0hHcbVVhgDEKIQeBoP1Y2KQkRBJ8G15CWc3xWOSPtlKcCA0OaOniDMuBcIgndPYECR4snRRQgSn9ETVguKeKOOhzggzMEbIj7/QlzH5KV8T9ucZ1jUqPPLgAViOQAf1x0Xruf5aJF+axnyZhtSYWsGuCsgC0MOB3smMoQA6HZIvd4RTCad8WYEBI6nKnpnYXfDLAHZ5ZNXAsgI0RoStwR210874Jt5flxNnajhxPK148HD56EcX9juj3tT2NmrX7qa/vKXh+952+h3PW0vbO6nvWGyddQ7c2y2y8necHJ3+LWr6rHH1ZnT7vEHnv5Dv8/8vZ/YO96f9NSKzYyCdF7tg+wYq7leVxpRaWsZxDhUbJ2zaPwsB/IxAoCEHn38f33z9T/d9u75z/8xAHj8yf+DiJ7/6uvvfO4JRFSJ1hLUV1/6hQV2dv9L+O2us2d+NEnVvUaO577w0H/0FL3jzMUnH3985eELMi3QcZLmFiwf7b/wm58dz6bsanTWNgZ16SRjpetMzY+LtXmJqz1JEhyN8n52/NXXyuvXsadU4wYPXug/9yis9OcovL9X3b0zSJLS6AShaerjal4BDwaDPMum5sg5q/JUKZUlilgLOwVChJnw3S9/efXut61cvnT89geKa9eUlnEqfVS946K6uzcdH2OWgFZgnLU2BU6sK+7cyo+mZAw61t6jKI4ZjK01krWmUSSmySwPSDVirWm0TqbjY2tKnSRVU7GCHmbzev6O7W6QzbcAAMx/25Feur689Y/SLAOl67r2wJFQRwgNuMhic94cH6nLLTL6EhQCQKA8taUAKArliiC6yIUZPLeARPmHgN3cVh/FEMWYN2ULd1ztnXC3E1e4h8CCgELkVtYGJ45OVGOtAkzzjBnLukKNo9GAjBPrJpPxneJovor03IOr3/jc+jsfX33mcemnJaEp5tQ4LaQ1YaIJlFJorWVniChVmq1z1pE+oUZyPMYXB2lbnmJhARUvj3Q8JDx08HogQFCbvR00yJS2hFv7Iv+/8LqQXeILibfCUTr3+KybgCEQpQ1Z7Qym6rR/KZuh9bl0AISfLzrh1+g+s1XMEH1Chj/VvW1LCXpP94LkAgOi4SBeulKaF8fsckZkZxCWAVALDxA1gvJZtfq+AhWgs7xOFMvwo8AYaw0H+UoLGR1FvrBa2Fo4yqSTkWm8aFkYo/YZXQqHDpgFkUU12wgAsH2MiPceLrwG6KMlERAphGoCcKjIsoSFJfhiFlmuzK7teDuIHTWijXMORgIJlPuLIW0FsP98ETfUwYlx8hBRfLMtOwEJqeBhzL09ULoQpIO0OIQdhfuDJ4jYyVIUUpTf6GW2T68NRikRwXi0eX7eiFcDcJQFbvPGFWH2oViI0R/lO0coiNxafbpcYR54CEsn+QN9tpOI9RZIBOU1Cic2bJLQcZ//pYNtAyLHOSKAEuHuzgRsl7Es0s2X1p0Iu/ZoRgAERmAR1uN5T8vw1KocTXTNUMGLb15xR7MnOLUpMXB149b4yvX5518cffNzW889qr/zOze/4UPTd31t+tmv0N5hsrJupnV9a793ZkUEYdpQbSWTBJPVJFMH+4WSmSYWcNbmhlPCBFRTcZIph9oSiwMXvF1CRFYYkJ958u999ZU/290+L758zf/w/AuvAsCTb38IAER47/Zvb8k4c+pv+SXkQNii9WVufvTjACA/9PEPfO6x06c2E3Pr13/u3/y1/+a//taPffTwYHegexmoal7k68P5we0rr7zWGIsIWZIkSYJgRefMYLTaa+anDydqtQcOjE4SW9ndfZiMhQ06Tp97BC+dbnbHwwsP7F97jSeHp0+fMsdUHu0f1tMZOABYWVnJXDJDRK2SLE0SrbXGgnPTNFlSkzJ9dbh7/dzrr65+x3f2PvKBm//g+jopfWatV5LeO7rz2ReS8cylibMOnRNCIsoU1eNp6jRpJSIa0TlxIkz+HIMkSYhUCqScM+jqxjiHj70ZgYUBGAOMAbZ/29Fdul55+KcAiI3VWisCYCnLeVmWKAkCi7NKofKYm22bHqi8WbE9RkiQEcABOy9AgEkQRBxKdDFrHcMIgoE8LHcXnAtezyUija2tlAUF2SEje/WACReEe93jmT3/kFfxEUFaXnAEhciAyODrNoIIKCiUUEJoxTZGE/Sz1AHXVTk7mswSLrby/tPveOx3vXPlPW/jB07b1cH+bJrMrNSGQbCf2USB48S52loiEBGlSGvyxzIRLbsbABZGa1moH+EQ4NY50upIIrSQ6SGsDTwi810PDw8nuj9qFtEVAIFPMGqS0upp7ZCFczj4KVSchTgxcYY8P2xMWwwHdZwCEAkHLAanzMKcEPu7ZN7ofELdYxY69qkAiLztIFjoQZyvLssxqngx9dG7BG1KkX/gvWgDAMSrkKHqbBxRpXTnm4vR6fRHWmMDIrUruXu148IiLOwn0DkXqq3GuYkNklYJXvQkpBK1kLAN9lz0xPp6g7iohSdxJXUb3zZbKY2oFsBBeXM5KKXaDSwSRCsFaB7SIhGBKDJ0LRJHOr4ZRATVSjsREXQSXYFtm1sPIiIyLyBLu4aiGWbJVnTiEm9ZXYSFum7MTTtuHF0DAGERt2hBIYIC5yBEC8cBQfRDHTZJdE45idY/EWG26PO5Y2BmRKjRqwWOhQkJpDVRQASXEeN0HWqEHnB4bykg+MpyGhTyInffZ7p60MAiPuzZD7uIWwwTtvYzv5UoRuYsAN9i4trJiuFgy2aeFroBIjZZssJJf2KuffEl9RvXH8IzT73t8cmHrZkdHV+/4+7sj1gNiY5evTK7s73yiTPmm66cettjen01f/AClJUdTxN2RSrw4rU3/+WvTA73hms9IR43RcEyJRAElyQlI9bWNs2QMVW5UjiXwgESkSZhRwLOL/sGmdApa3/Pe/7R6mj4k5/4fgCo5eMnVssrL1/N8OSH3Wtj438g8pzYzFbCoIr0+sPrt/6Mv+eBB//Oc5+8ODu+o5x7iOGjf/KPf/O3fVN9eLCxtTk7nGRJlicpYHL9rWu3rm3Xsl7WdVnXRgibSnq5q4VJ7UDz4O7h4PIpLQR5f3rjrWZ7fzirSteMLp1eefphUj0YGMhy8+qVVJrV0xcnpnnj7rV9U82IeuzSNK2Py9KWiaIUuW7KjFJLkhlbMVsrTYLOVHc/+en8qWfpwYvN2sp8e3d1NKrN9KE/+7mv/g9P9POBYQQWhVSxa4xlZybHx6PG5etDx8ayOOfYczMbBwrece0P/xaj9zu5fhz/+sNnL5zdPGXKQgtba5FIANnYLMkt16H2BDNBMFI6McrzP4awNBZG8kboSIkk4FAkIGu/cUQEbMwDQxXws2mz/NgtYr+8ZibeBQJAPnBKfBEuhyFN3TcBAQh0a2P3wpvDzgiM6YvQ0eBytUJaEyCDaEErLGwVahGXkNYEYprSSaV4CmbSVNMLvVPPPnbh296z/v63q7MbhXPNvMb9Y1cU/V4/7ecVSYHS2Lon1MdU9RIAds6yWGOcc45QJ1naNNW9U7B0XCP7SLhWNAa9DhYEUSDUZRhqzTmIMUpGgm6DiA4AUCAcQgst2wtfjDQiGMNEQog9H+4AAQAASURBVHBYtNxHNgv/2yIgAz3pVji7XCdIc3E6wT2Wj4Uc64gnickp/qCOd0J8Wvi6P7q96QUYYsE2C+DP5KUwjmA6jzIz1k2T1pXfdiT8KwqAccm+QIioGYPokhjQ67+c4EmDTztbrSToTrA3ADNacd7k7pQgEgq7LvI6uRruQUatJo2IJzg/OhgN2rE+gTY6HK5B/rUWBf8ipRKJOS9LksZHU8bgK9+WVhp1PlxqT1hEnvJJOQFAVG0YgUSZ3/kuRS8Mdvsd718gR1GhIL1z4pxDZK21UgoluAYj9JIWB7STKsKRxspbGlABCgW1QMARkrDvOIsgiwVBIulE73oDRoiTkI5hJqpfYUF3A7+XZplcBFEtYvNu15PD2AFb3gkU3SfMzJwkyVJIKUE0h0ZdIWgeJ32isjzyLLaNkpEQp+FERLWuUJ86h4iEIlBtrZ49crc+98LNX/nNrc/vvfj60fDZJ9YvrY+2nsr2j9zOgTocl3f3+PVrcnecHkFy7eea06evzcY1m8cuncv6CYz33VX31U991Vy/M7i0ub+3owzz6qBJpE7BVsY4Vas0y5RlKusGSLHWikQrhVoLkENnrQXnEEUPtEZEZxOBvkp//4f+z3/x6d9pgsOpM3+bbcBp4RwU8MoABYsYFkXR3m+trYpyNBjeuX3rBz/8u7/nP/5u6ZMrSnMwztIUNEJhoDfc3d6rStBrA1G6diykSCWVNciOiKbkyvE0szaBXPX64NgdHG2MK7WSrDxy0SIlb942F1bUwX5z/fZQEZCw4WNbl0omzDlAmqa1qgWgEadtnYoaDLMGRJXOGeMA0fJ6ks5/86v2m68O3v3ohUcemd3eeehPfM734pn/x6sA8MLffEIxJJSIbaxw1st0YinRjZi3v/4fGsh55fF/fTg5ctMiS9IJN2/ODsdsSqHb+7tDlayPhuPjQyJCERJKlEbLDCzhjApqA4AwuxirQQCikMRT6kc7tiYQUQzO81IjKssGINRIAfBHgQIWw44QUAW6BeccECmlvBRtaXO9rRRZ2BkU9imLnjBDkccXLh628YAFBkDCRfktiJsIEYWF2DtaHaBCx8iMSjZVbopKHCPJ2Mz2wKSXNy4+9kT/+75l/bHLfG5125WT+YGmJNUarOjVQQkwM2XCMEpSrdMGeQYNVi7RJMKOHSmltLYCtqk7VvDlohmdrDSIJ5WIdCkrvTjxRxwICDhfmnHhUll20Xo85o83i25RlgGg1eaVLN3vkYQIC3QN2wjY0jBS+31sSdM9AFpcSzIoHnGLYxIg1JGQjiU+wg7xI8PcZbTyJ3krwdgTMwAQxtp+nReFd8Pi8F+gn4WkOyEifc5DACmLAdEaNQiDYwCHIiGCTwQwi311AICEIiwAjv2ZpYM5IJolhFAAha2A8Y8WRCvO5z2Kpy9HCjGMHU2eUCMk7EJqK2Djs5iQSMR6FRkRFSpgy6gINbXFWkGcNYiAJJ773FdARkRSql1r3elvrCEiUgkgChonFhCAGoQEABgZuXUKekML+/IZrXD1L0IdE64kkFCBEDtgsH7GPe+eJ88QAKKFky9Utkck1N6EgK0jRwl4pOOMB00E4KuQeF2kNY0CkHewBJABDBD5ZsGRt80hOE+PK+DYE/UkMWzM+bnwEBgRBKwAOzHMDOIgpE4hA1h21FriMOwARBIEZgfICrBj2yRERJeEnQytpQoBkFS3/t8CMjrwOdg+2iam2BA5J4iktRIRZudc7YdLiRJPIS+IqCO1iUNQslwPEwBI2AIqIdsYVs4qJ8SpaDLSiOuDQsRJIqXYEeVb+So6Vi/sX/n0C8lLt99/uJqMcPe1a+WbN9ypU+XqWjXMe5unzn7jc+npFXnlzaN/++n9V29oBacPe+cFX+2X48z2ivQrv/jJmidVgasq4XnNSHO0qqzJQR9UCpiUpR5BwcIWIR045tzZQWEKMjIaMJiUJElkVhs1GGRNbay7sLrSNwCHs5T5XvOGv2r5eIYfP/fIP3SNaZpGCB0lwpZYeqTnFDK/SWsdrcHMvHcYMla2LvytvJ/x8cGKgj/9Hd/+g3/uP+Oc6uk8s6Q0Op0YZrLa9jO7PztAKIRXOE+SEVa7TmdYVKSSvWFmKZ1Ye85yk1aWtLlzS+bVUS9fUwN7+cxwe76XqzVzpprsbV0x6fnT87Q+3Lk+caZIcMhACJP5bJgkSAqJ69qkvcRYFuBJls4rsq6hyiT5YEbl+Gd/ZnDmPz134RL+8AsnRuO5v/Aq/PCP3HegfufXVy7+2Jvbdww7y7I2Wl9JcltUwzwDt6mqUhKaIF+fjWvhPtBj5y7gvLSuqkrs6bSua5UpIjKmBqWVQgbHwoJUNSbvD4ABBX1afnD/gwUEAecQ2O9jb3G14gxHxUn7mE/xgc/eiUCgUs1WlAMlBKwSpRHFspUkEOWhAw2IANaYpmkcN3mSJoAKIUtSVFQ7Ns66tMfOKV+hga3yRVyta8BoJzkqjdoqKFkYBRFTESZxzokx7AywiCan4Xg+M87NbTnJQB7bXP/g02e/9d2nnnrkuNc/to2ZlYrtBqYxoVA7AQDQWgGAQTS+SD0oSHwiKoWD3UeoiUTvjRDpViPiyKwA4K0I6MPmxGeqos+zWFJ0Y+mMBaOBd8kurKEI0fLLEBg5zJKgFQIhliAjoD3iQADFQYOiKIRx+HKs3iztMDjjQ6BkuEi34rx9FHZcGG3Iqle6OuFn4X4POLUOXxFgF+MaRYQwBcDoEfOeO9fNj0VE6FTHdWycGC+6WHjhq3MQswq8VVtE/Ihbn4jdBj+AsHOB+GshSE5cshyiAgDMFlFHdmo/It5pon2EpvjwAACQJSwZB4OxE6kKAIC+FoCn2wokVIGvpfP1QHslLR6MzSZkH+fpt2pEeR1Th3SXBQERoD9kmdmzlRJ6i6bysYoBKrYss/dYerCtVh8q4YVMExEwlrsM6O3kCSsRv+hdABJCANzS8HU9ZlFxBx8fHtYECHTSdNvwVSIgQuczvAFOsI8wMylYOOxa12bHMhT/7eSsxwYw+7hFYueAlpZIZzeQJ/LC7jMxqAIAED2Xsvy6EyutdUj5pi7lH51oKiJaYepkinM8LaIjFrGjEFhh46NltUr8TmdAAtJKGWYEw3Y9X3lYkv7t2fbzn33rldeKL1wZ1HAOelIJMq2uDYqi2r51w12/6gRJ4OiFVzff9fbVrVNrv/ub9t5zePUXf22yd/vi6bMPwNqNN27dGO+Oy2m+srGxtjkrarKcqaRpGhRRCGhZASgRFGIEC1IKi9gGaU1UhmBmsyxJ+oPRvDb9JJ2XJusN0Nq6sDTI2ThG+fCzF375K7fhnivDjz/13n8+n7JWijFpyqq2xgiwIpNC1tQJKRAwxhhnfGRDO7PnH/zRIahk7+ChrfXv/dhHPvqx726ahsERalAEiMCOjdOZAgfzecEAKqHGNfP5zLFDJQrB1Q1oSVcGc+eKw3H/8tl0ZtI3Dw9MRcrkj57XZ87CaGOkJHnwVPWZW72Vvs70/mxyaEsDTAYQKUEQYxOdpUrXrgKShl0KQoC1tZ5xxPoMOOeOtrftL3xyVBs4e+94/PtdX9r4+1mWkVambsSYXq+HqS4bZ621wALk2Fir00wnSTKbz+dFlfT6DOLYEECv18uzDBqbJZ6HRhSS5/4j8PZEAQCFJCJaawAAwpaT2p/Q7fmGiOTrPUobzRP9pAqttZYdEaU6AULnnLVGBZmBgD4sAICEnCgOrlilFCJYa50YIB6ASgDJM4QCE+mElEpwaFxjjRVngK1YUARKgeLEqkF/wM5MZ1MGGQ6HKFCOZ2UOeZKSE3CSkIKEZqaeV/MZAZ9d0U8/uvWBp7a+4en+A2dr5NvzuTLaWuPYQfAWsz+7uU1kDQMQzQwnaSHak+FklGX4fNnvANjK7JgNu3y1J1L80/20/JM5twsta8He0b2p/Q4iivJWZ2bv5QlsEfcl3far4X6HpCzJvkVLfJActiZ5f55jLN623DUQ8TEAHlEJhjpVCEtNOin1oqxfujhkswIJUKfMPXIM7okAzr9bL+IGAmUKeczF3MYEtJKgfbcLr4iVLxCRyMnCnuHbaztfAYiBAl3Cdv+nrmCOhWEosHcE6KsQlfAiMynavrglugeAkIGDC7+Pl8ztuxBRqRh7LB7e+eRDhaAQLUYZBREBtPPXRR7MLKDanGnsLG5NilS4h5mFOXrjlGdRY/YEpn5TBPwQ28ctyPUhkJ0F3b4CORxJIUE8NEwUeICKEMrfhVXj2gEIZhTEaHgIu1pE/Jx6nOvxSMit9UclePyH7V6VOESBTSPGiiJiYGvFRbPjTPtcGHPvBoDl3dW9YXn8PYj2KTA6vu/E4pT2sAomGRFmJk3W+XQYlzpmcU7IpQkb2FxdU7O6emV39wuv1p99bffFt3Z3904VgKAOld51NtGpBuonvRywR7rupTXzfP/u+F/cQpW99z//41s//Efh4QeOfuTvHW/f7j3w8GAuI2EDYAtsskIM9HXWY5g1zgFiBsI2BUgY0bKmBBRU4JiUI4C5W81hK8O6KItxOXeQjnpDTXZW13UxR3KUgFJJLz2Rat69XvrCHwCAZ9/5f9ZSWMNaa/IakOMcg5cNE3JphoocwvadYN7A6eFKoj70zJO//yMffueH3rM33l2DfiG23x8k2VABo7PG1lk2yJK8mFcMkA56eS/1x0BTgyCv571+mjbO3d2bPDCv+lZmn35h9sUXYW+SX9hsvuEJszHUudYWzMvX59du5hlVpr65c+dONW3AMxrqRJyrGr2ykqbpbD5jEWgqpZKV3rCxxts8ETHRsDbIn779/fDPAP6nv3r/4fif/uq9Ro7rT//8bDYjAWMMERAiMxtjNJMG0IDiuKobVlqEJ+OxjZqfiCBJluZEMJ2N0/4gzbPGGABAADa2mM4y47QmsVacUyjCFix630kgIFaKrU2UEhHyCQIRr/tyxRTOAbDC7TmPIdcAAcA6AwiJVgLA7N2XrDWhsPhwb8RQPlIExKEzyExaZVoxCDtHipWmwpqUHAHmGrQiZgsMmugY56yYBAhQMyOIsszMpNW8mDIhDnIQHpsKBdJRnloDjZXG2MaM2UxTtmdXeucu9z74tnNPPLL13JN8dvWI67vFHFjyJG3qZpFaH60UiE7A146B1v0vnYjI7k7vKLH+4m6S5j1/XXx+Qo1p39J9VPdDEekKLIw6LQCEcBwIVE8AEEIvOxgoyG/2HoPAqxRD7L9uj5ZR1AIDdVJg2tsEQFr/TiunEIGIAmEmtk6ieHSzxWgXRwnVSyCYjSCyLy6Nj29R/MCdqKcmFKmNfPri0l8BgbxIWC54EV5B0EnfgBCD3A5Km9Hg2rkR8BFoIVI3drhL4eVDb4iFiYj5656VEoz8zjMiYIzkEEbvQSBf4p68bFNtWpAf1XYmYlFZ6LQcAUCBOAlLk4gQlCatlbbWoviAxpj4AIzsXUH3aWTIZhZYlA1AER+sShHULmCKRKIOCEHOcc3HeIKQRdxt6rIoDVas1osWnHbePMu4IISJqae4tHQXqMv7yNpwDX9Oxn8BQADQh6AyWwBqg5NPbGD/a7S4QKCGAxU7wW3+M3rfje+TACyMbJ3HLe//Exiig/aCicsb99otxN4bQyEdCQBU54uCoEAcMKEORzCLccYRnD29Blf3Zp99Y//XXxp/8Q2+caRAjSQRkBqgdk4AMkJsOE1xkOVmpUcatTFJmqYr4I6aozevDL72+sq3vLP3xd/95i9+4vh4T5P0VFIBzO1Uzd1af0VnGVeVgBhnGltnAAPAVASNoUQjkAMUYoc0Rb3Vz77x3Y/3wL1+9fbutNg5nGgD/bVRmqRbSXYqVc5JbQ1qfPpd57725bvdcetGjH7l+T/0jvf9K8wmdjrl2TSrTB/UZqJFWBCMQGVNw44jcfK3Pvm3njn/xAefferSudPZUI/37qSKKnTTYgbW5Bs6wT44axvDfSHjJpOZBRz0e/1hj0nAkVa9RlV51s+IbjSVm46fmc4H125e+/lfaa6/dkZGG+96jzx2ufja64OC8/c86+7M3d29Guz4aHz71t0j12TUQ7YsOkN2daWIer0ez6UW6xpOdJZR7UCcwH9s/xIcABx0Ov/DP3JfzPGrf+VsdiojoqIoUkVFOVtdXTVmE8BXP/cZBILCmlCMKUydpikAIwqzFRbn+fWJfOh3kiTOmaKyTVP1ByPjxDRNAkSKnG3qqtgcrisEyxaN1UoBi2PRWgOzDxNVSLZpkiQB9hRMQvH0DbpZyF4H5IV/MFJDgoOQu+QPGctGWIgIFbFtEELSoGPrzxUR6whRoUpIiIVZwGpgRaqnEgIkgRS1BnBWmFkl2K/ZOCvos/aB0kSnOQDMemRqAet6Sg0xZXZFWRTllJkn1Mz6Ch7dHDxxeeWphzaee/zMEw+XW72qqnbnldnbRcbcx7k3DCpGm0a0ARBofhaWzqUqnguXU/fiyBGAABiYRgE6GYUQDR7hrOD7oA3oHG5dQ2w8jO4BLsgKExHxxaUBIIar+2ADt/xAxBCE4B063Gbn4jKOgc6Bdu8yjiqidP/adkRCUucSOCNqyVWDAXuRo+CTUMTbWgTDmawCJPLlfJf5OU80THyZTBUzIURa7VdEVEwRpU6xN4m1VNpnEEgIXD4xE+0n6qR6GqrTxiyJ++DQIG9igfHuUoBlQSPRZISIApHp2jvn2rxq6XCRdfjnMTg3pNtgjFHZ970QVKQiDXMZnoNtX7uhyyJLFrCAb/xajwHJ1lobE5wWC65ltZOgf0v7a3yyQ1qCxt0BjD95QKNanxmScNg/fntG8BusD0Jx/ywb4rxRon1Fa3NDAadIxRAKF3GxAgAk7JZ/BABEQgAfhuK1NIrenBYmQtRU7l2vbe/amTrxp3YoWuB1Aod155pxaRnAIpsmjqF1KEAJsQMBIVQasad7+vbe9v/vs/Jrb+qrk4151gxOb54/XyVqXB8Ms54UppjO8iRNgEb9ATbWDXvMtpmOS4WUgObm4CsvrT5x0Y16/T/z+93tG/MXPqdPbVaYJ3qkVTOvyiTvgasVQW80LOp5URcZ0oaGXWsPGsOiFWlmThQhy0zR3nzaiPvGdz71+CMXjLP7+zuKuCwxQ1xVaTOZHRzPbd30ELAxDzy4CgDXr40vXl4jokuP/C833/oz7Ri++PmPAsA3vfvH8iGNGrdKejRtAhkiYW2NRfnHdwJLxw9+07subm320+Ro7zodJ9TUaZrnqwNblJylbA24hg0CW8mT4ujoeP+gMZLkQyBqmsax6yU5JdQ0jSKaG1OUxd7u0fyNN+cvv9GrZv13vbv3vnfBrUP7yS+Ud3bo6cvu4rn8E3WB5nj/YD6ZaKWHSd9UtSAqrrkxyC7t5ai1WGsAvrP4c1DAv++FiEop727zMfK2qctqpgCdWAJkYWDxNWaYRIAdWGQGQlFkUApnPFeUBSaBRFE5ndVV0e/3iAhsI6bRvsAZgFiXJImII2Gf1I2E6JxCxYuSn45tQ4kCdgo8r6cTgUjT4NnuBNGXNImbF7k12vXy3DnXuFpEFJHnxWNrPJ02kaf5sgKiUSkkl6LSWmvN1lnbEDtAIHYDyhyIdVw7W4mr2ToQLQkjO41KJzrRDgm0sqRFZGVumNFaqKrp3boqCOx6Hy9s4GPnho9fOvX0g/rRc/0Lm9mgX1XVrdm82Rk7nxGZKaUSB8AM4lihRA7irrcdo+YTuZvDUYAqxLj4je+6k7t8Zrp44HwdBebriIO2DSeUKz8PJzFHzIYLuYrQSi2ETl4rBFpF/wctIEDMHaM1kWpfJCfdKx49LLl4Igg4IYI9mHCIQKQRPXQLoCfGpnQJLxYnf+ypADoELSJEfokt4ppPDNsyNmDA+PyOpV9EEL2TTnXyqwG8hePkoIuv2bqo6bI0oyqomOJ1SQkJMFFstCvAD73XxBXKIqICALrRALjsb0MfJKUYg8cxWZSD8HwPnYTM2Pl2MhavaJlcu+VYAYCREECEEZS3YzpfUwK9EdL7UFVIoSSFS2R2J6Y5fAMXhfXIz+19lrvPX5eQTA3k51kQWqSP0DpixHmXASIuW85FKc0c4kV8fKtPMmIXrTIB77PnFu5K9DA6HHZGaFtooXhumxDU6X1AKIgh7BopMmp0OoXRcCfi44Xj7kIVOeKWLHMefbZjGP+F3+JqRybsRukQ9IKvBSIAvqrfySI7YSUgoq9BZVgJ1I5FZKSzkaV119/51Bd3fvlF+cqdPg5psGqHNDp36eEzpw8me33Uh7fu8tiSIcyzdLQOAFuYjquZ5VI1mClyWOzduoKf+exjF87AmTM9nQv20cHqFHUyulPdLQAPZ5MpFaeGq/2V0fG0xqIcIl3UyTHwvjWFD9FV4AMrsmHv8Hj+ic+9cGFz5eJm2pfy0QsrqU7mB/OmqrGeVfP9XGQ90xPkO0eThIa1NafP9pkbAmRlLl/+0Rs3fqg7hp/60h//0T/wr6f7e66utjb6xtYKaTAY9Pv59/389/p7fv1P/VKt0VWHx3OXMak6OaiuDbY257MDZsnTxKyvmSpnp3QvVSsDujsbH+w7gNW1TdKJssaiVE2pNVlm6GWW4XA+O5pMzYtvuPFkK9/IvuGp2fHx+Md+9satzw1BHtrfG56/OB5PxnY23T/SwGswGFE6T4ScMIgz1jTNO29+72+1PgAA4Mrp/+OImyRLe/+fn37sz73U/dMn/9uzWZaJSFmWjp3WlKa6ruu6Lgd5D4ABUZxFT8nPAiSpThGxqhu2nCDU1sybxq8oBNAKUaSpSwbb6/XINRlJLyFdceMsANR1fTydnNoc6IRczYhCiA4YhREYgXyFAWCHwpqAAhcH+wNegddPwhpnZ8MG9/I5uIzJuYaZScSB+HIN0BpJvNQkRnIopBNCUIxOE6GAOCYAVMpXkT5ytVJKJUqjTkgpp9kZxVQnqRYBRcLIztiqZkBrrXVSJ1gkMF5VxWgtfeLS5Q9/4OL7n5luJMmgZ1CKqiwqU+0fE7sEQKvMCVvnjDMNGyDUaaJTzbVpd2h7GhC1MQetcdrrMK29POTxdQ6ikxAB0AfmJxKzQ8NQRoPuCbUnnicnz/nuwwOHNgDEY7NTm8k/hGLePoaibiAMFhYh8+ILrIRp7JQm8X9ta9x8neZ5uYyI9oSGFn4Q7cNj0bM8xLFqQUxHf4P4og6+kZaa2HfStYU+ulecsgVIwuBGCP5rRETP7hSeCT4nucVz+p5nxn6C8mu7fVFX0W5f6WM+2siPWGzFrwDwbKYI5MVnVDoZu/muqKK/J0CjEwMkSOAz2b2Aa9OBIwRrrQUirk026/J/d8Vba3Prcsk754iixT6UoqU2Nb0rwFo1OiaCImBwzTCzsz4veRmuUigdK5E1C4JpjJktAntLVwsImK10nJGwjOgFLGCgF1uWrJ6LTSJu5fuslzBfJ5Z0GFP/eOeTJ0Ehda2XPl10aTMsNjgiAnA0wbWJsd3b2jfca8nogtoT93RBXgAruPy5ACFFto8w3QsTTjdrWmlpDDkREVIajSvf2sG964/pB3jjbS/L5HBeN+V+Tlq/+Xo5HydJgkLVeG4bq7Su50XW66Vpum+KxMpw4uZlPTkzSM5s6CM6fO3a5378Z3uNuN3jdPMMF0Xi5pvZ0OBgB5rjpp5D3dcpIiRKD9MMSqe02tfJTWBLWCE7EKWQEbCqkqy3M61fu7V3YesSN8ZaWzErZ8SW8/nYuXkvyR7e2lrPs9W1/pXDuXUJO/KKY66TrdXR733mFy6dG/3Ff/ihdkh/6J//PgD4/37XjzsWMY6duMxirzPFRZUOsvHhtGma3mjVOXtcH3BiTW0znek0GZ7a7GdDEknTFdC6Gu8d7u0M08GDDz6qKFGKszQpbJm6gVJKMm2K5truzvzM5a3DstSy/r5vzJ95vPnkl2Z3r+z3oHBU/qtfWOfPy9HxcTPjqhlhnyRJLdZaf6/50wAADcC1+6xgf/0s/I3VXn9jNNQOaoE0zRWQLevX/86TDPLEf/Hqr/6lTRAirYlUUVbW2jTNRBwKiHPWMqJiNoDMThQgMDBLY+okAQBgY1GIGZiBIq1dprTWuipKFtdLe2mi7GyepmlP6QywAkh0wk7mdbPSJKRTL/PanAUAEAwsyW1gFzkhgUQrX8cAEbyXJwaBuZgyKU5YWEgppVRZzEgrpRSwNM4KOIWKlEIkZhBkQEYFCn2dHelZENMwAIp4b6M3WPaSVCklDMbYqimbpjFNJSKYa0sgg0xW+rA2SrfWsq21Xi/b4bp3drO/udYbZINTmxsPXeTN4QFY5bg8mriyzFAlSVIIj8HZXPctILNCXMGUNFnn6sbaugnVTaEN4Tx52iC0cuGkObOV4tHCHc6D5dOpe//itJLOD92z6H6S3r+IOp56juIPoyxY/DV0ZKEROQLt/dEiImJbn3X3CMSliJDF1YobAPCeh9j4NlZjoUMCoOeoam0Y8dVL8YtLvYulbmNHVGx5LDiH3RlZNKnLgADYpi5AG7rnTQwQkUYk9hREAeROlkpnvv143dvKzvy1iGGRnOMnINzFGOaGSWKgU+SdPOFzofZbEccENxIA+AhvLwixY4NqQQ8jECEj+5+DaV0r8bzOkfahdWqEmiihBAC6uDKj78RRDJzxL1JxFu8dBwyBBH6ekFmcY+wkiHZWQOvcCl9sEZNzEbEGV9GCX8vvw/i9MLFxWIK9R0RASDgeZ346UBA4xo22M+VXaoC9JzYbhPjTwFCiMJTnYWYBQgyREcs0ZR3Q0V0bi9fB8jnSvug+vhUfr9S9xyOGUNN1WRsQCYXvFh86hph7j61tJX6LBCpx4ByqLE97KgHePr71+Zcmn39t+uAHts4+/Ph7k52dnRtvXrF1cby7vbqSr62fEa0LsYfFVGvdy/JcJX2d1eXkmC33tSgwFqez2SDvuxT0zqTgWb42wONknsMhzkbFISe9zDFxg4LzsrRNQ4NkNe9XxVgbGSbU84GGwjUJoBJyuRWdjuaV+8KLbzz14Pq5vqobFsiK4kgRkdZJppt5sUputDY6dXr9Q7388OD4eDwjUP08H6bpSt4b9DLL8BP/2Wf/8P/2Dd0x/s9//o/96Hf/dJb0NcN/8m8YIRBo/rPv/Ke3p2rYuEGa5ULHxxNLrPKkPjqwQKCbYjqty0LWnIKMEeumuXPtyvF+ub5+6fKlB5ihruv+Rs82apDlpijHxWwyHt/Z3Svm1YpovT7Q3/aNTeJufOnTd91OI9Bv9OTl11W2lumRGNtPsw81fx4EoDm5LrrXT+LfRHBnT5++dPb89u3TrmoQFCueV/UQkkQjA9e2hkH2ub/5YEXJStKbucY511jT7w9Go+F0cmwbw8zWOBFwjh2LOCFNwuKc5EmOiOI4pZSZq6IsbQ0iRMqyS3WikapiIsD9LGXmXKtUqwRh1MvrpmIEFqjrumwoVeScsSgqIRHHXrllRk3sHKIExi22wi7p9dCCtV4b8YqH8wn5RESAVtgYw8zk0/IRxbEVIYIkVYghi1JrbV3jNz8G4zGL4ICpqqraWdJKFDXWGHYM0limPDOJrnKNZ4Z6fZCu9NQg14+dyfp5b2s9PbuBp0a0PoRh7jSdLqhIseolTAgN789KM59YEOUYU82j/kwsCouDBHQO2oJFrQXFAThnHBhNlCaJbQwGo0ZgKfQud6USCOLQ63UAAMLI0AZGBNmPiABCQT/kFgT4pdKm1scjJSo2XwdznFB7MLJzinSBSFcyxkDLcLxjbCf4KhYA5E/P+LzWQx29L0GDWgoCXRxxnfADbM3/HtAstPH2v5Dx5CULkWdbIBFfZA7aPmJrPQpgLnK6xxiU+KKOJy80CWDxXkHESFUdQJlPVAhCE1Civu2zc72sRAQNyJ4PSlHSZZsQIURfDAO6hXrDBEWJGYcehZFZQHw5AGFkICAiy4AaFVEb7djK8tAg50IwCxEIOucAWYBAkYhYYbAWRCmyIAoRlUqY2RiHAkopBEttVx2jT4SxAUhEfwGKJz8FUJRAC3+IFKK1jXUWUfnu+2hTjA4O7IBNIvLmB0TU3jfGzK7tjhAhkhIhEctihcWzhjA71IoYPJEGAWlFzMBOAJgIAa2zFgAoGg8FbLQdCMSkExEBbLOxIUBdvxUXXi1Enx4cFoolohgBI4gS83CjlQ9YOnQuWarYeQ51RCSttLS04hHxx50AKAJIMR0LF1VyhOJubF1p3uwUivm1sGNxFnR2fnfAHTtCjaC8L4bZirCAQ9JiGRFZoVgmFoVKGARdPx2VZc22STQmCY7LeW9lJXGE/TRDvVrrM7L22vN37Jcm+iV38zd+rbx09qEPv+vt3/2+nS+/+OWf/8XyeI+2s8G5s/MpHx00ucrE1STQ7/esnRo9yBpzWOzqVDnb6AQs2MTp0Wpura6r2mSSU7oia5NyRhZWJSWhQ6gP3BxFr7rVnkLMh0cwzitzBuAuOZsmfUipFKYsUVyyMb30+nj2ua/e+Mh7n9Q4ZxjrYVodHZIpNbt0OJxNi6Q3V6OhcsWG1nm/55wM8t6w10cAU9vdo52D/aO/9l23s17vv/pnv6fdbj/0b75P4KfCIQI/BQAI339sbc8Wpak4STXRSppZoPG4qNJkPekVA8wHWZpniQMLDVqTGfPGr3/6+TmceuTy2kpmbKFXR9OG+7malJOe9AncpC5XptoebL9eXXvm2fe5Zy7Wv/TL01deRQWDJtPZWiXmPfWfhhp+6+u1h/75rf2DW1Uxt2WBmIqelPXdw6PSGttUSmOuMelpaypRSZpnYBqq7Ured5U9roskSebzGRL28qwsZpPJsSYCRcbxfD7vZZk1dc1NI5QoImdJoKybLOvN5/NhPkCWVFE/y6q61gCJcylITZCqlK2DsoEUp8U06+UbK6P5QT02JiFlyXKBNTut01QTiSQeqZNy3CTJwBnrjb5pmqJCBVpqw86hEiE0zooVdACWMVdOuLJWmDU40oDKClqXJJowQRK2lmsmAc2iEctGO0CLzkplbGEKp0ml6TZyPdJ2fSXZWOmtryQbK9n5TXVq1Q56Okv7g8GpwYAGaTLMk0Gms7SgEFlcsnPOgWMqDLAcqUwK4Vkpscg7IWZIrAWDVZVExAOGwFYpvqKTaCSlUhGxloU8ZQ478fZUf3QwiA5PBRVYnkmQBDhBFCCOVFckAgiaHUffujcOUfiuoEioX0FEXhMVkRBXzlGzBd8DFBcYW8MbETHwI9h4OFE4lnwHvX4IABRcYB7haOXDDACANBIAMjcsDklFgdkKfhbw8f4ePFlAz4Ld8YoIgSgBCEl5AArJ15ts+bEQwIkP+GjrqIs/Ub0+zMxIoqA9nBWIRNe2itwWvlUgkiwEfGcbBrSGwQxBAMwh69VfhEopb9sgKwLMvl6YUp76TkScOLiPS8VrsV3msla3PgHEluDhvVELi9Dg0KzoUbuPrd93T4S1HyNA9PwPpECUxEJezjnv7FiwLSxlHneA6rJ5rW1qB6lJ7CzFEOgTcNhPwFItlYU1bzknu3UWtib9iGHjsDjG4OhxEIuihGei5+uKGVDIrbrfQdzxAum2ttPghasshlZ5Y4aSyILTfiVCjWVnjQAAsPOTTu1KiFaKiOWjfagdFk+uCpB4z1/ssqc6dYuGAzjnm4In1kALQdqlEhYxEYLy/tFoVCNvlmYWIqUAmYFJqcRvJ7JKDmZFlmXpsFeU05oxy1ftHHs56Wm9YmA9G9z+2uuv/urneOdw89RqkbvJ9u7z/+RfP/S+dzz53neufHTltd/8krp51H/rVjNcVVBmTZ0SNUmvxjSXwXF1NOz1VtdXxrNxbY1KEwABZ2dlkaZpkiTWMiKmaZpmuq5MQioRTiVRwnOuZIo0XBnkeVZgn5JNkA1uZk1jNDnAhLJZM69FdKqcopev3rm0OnznI2dVVVjAQW9lPJ7MxrPV1QxTmY+PtKtMrw8AAqKUEuR5NS9ms6IojiZHg+FKbYxD+NE//Ms/9BMfDsMb0cZi8OGn/qESAW1E0DnLLEisSZTOB/3BqY2zFx8bnj/X72mLpaWNYa+/e+P1zz//8tTAI+trAmxMDToTEdM4rXVTm6asyqYubTU7OHpiY2PjbQ9KU9lxdfm7P3Lq554FgN8aZ/za1j9xVTO0kmtVu8G5hx+YvvJ6ImLFGoDpvHTG2qrOELXWROiaBgXFWjQEMZvbn75VVSmlVJpUVVWWcxFx4NhYRDUHIQCt0GcPEoomsmwQcT6fEwAYp7VaTXtKdNE0uU5TUvPxhMQ5FqcRAESpVOkUlbNOMwyAiJSxjanrBphBKNO+GCsCArAi7ZwzzjpnEKWxjRLV2LoQ7icZV7VystobNtwUpu6NRmZ6DIlSaeISBaTQsxSBpIYVKmCxhpsGjHMOnABcV4yKKO+rlaFaW0m31gbnt4ZbG4fnB6PNlf65U4PNNZWllqBIoEnwAqci4lgacQ27gq0BK2L0pBFUguCZuBQGZV95ynNCiOEkXrfhTr0Bf6ZhRyKcOM3CgRZ8RSG3Ipx+S0pTcOgjRpUbfRpae9DdxwYP4cCnrj4TT++lQ97/5X5CrXNOLrzb0gYEIiik+MVIPkF08lGtGMKF3hVuaBNGvA4XvSQSc2sRENu4ik6+Z9D5xPNVtkMatcu2O9gmC3jqBZB2NAQYBFv9v/tvK/EBALphDwCRn528c1FkMUrt8R577aQlwwwdhPZm3R2C7jfbsvVEQfB4zEFRonf71gKO+FpCZI+3NCIBcrz8UuquEYxkFBgDZyKy8SeGJ3hHYIqYxUAEdCTAnZV0YomfWIvYaTkAAAODeIlLRGFhRL/PYiaYhNkDvvgEPOFragFHwAPgiVn9Hx0AiANQ/tWAiCwWwv2CISr4xIa83/5c6t1iCtup6fYOEWNG0clgqDhrvgEQuxwWWYdvox3AFml1Ztj7yXyAKklgT/GhsGEBeITqpze00GPt7nScmB2IFo7OfvBGlVg/OoRxMDLoJEEWthYQDSlkUQIJ6sbWRK5qarZmJRueTtftpFmfkT7QMDXpVn9Yrz504YkSN29cubrSsKzlaaEOPvniiy/decef+Nj7/8q3vPrzv7L3/FdO91YfHmwclvOpNg5qW5XAvL62ipatTrxvnkGcNVprrqokSVSiwVYilKZpv98XmUNjFWCSJJnI3NhamnlVq1wN0z6kzrIcF65kcwetgZQsGlKKGNFJmrx1XH/2tVsXN9fOZco5zpI0SwdNrzZO0FjjakpsqRSRJ6oXMVVd10f7B9PJJEkS5xwpSLLUAP/17/3XpNV/85PfBfe7RBErZZmtsGZkcoCkBvnK+sblZ5+CwUVUZOqxICQb5yDLXvrFz37ha28JwPmLF4mY2RIkCSXAYowr62pazCaTaWlm1d2d0+9+OvvbAH/7RYAzAGfu2wAA2H7bL2yeO7d9Z+fW7q4hDeQIiS1LZRWAS7E0ImnKNbNrXOkQTKZynWQauakNEoJjto4IQcBXygVxiIEvq7G1cRYVOWecsK0Lgp5NEiQF3pzP7GMytVJ1UedJFqIiVJo7zFGvZBmyFHU57PebqlYgeZqRQmsMMKZK9ygxXGrLfcy8v5PBihNWnmTX68TKOqeUSrLUWsvMaZ6kpEfjCtiYNLMEx1KblG2qZlgMT2ViJLEyMJBB0og7rIvDqpABGqWqPKs2e7h1evjAxfVL54br63RhkOW93miYjUaSJyZTMMh0P31szrWGEtykLE1ZMAikGlJ9WM6ZmZ0A+Jw9SL1Xl7QgsXhLOGpPIuRsZ7fiiUPp5KI6oQHec6DBgnOoexq0JtJWwxEAn4XjtUQObE8c4QKeeGmsLhMSG6JFFpyIoKhOswUA/dQvmoFLUaitJAqHj+824ZKRP3YIESN5UvRcBOeF8wClQ2pAsWELiCPRUOxPb/DHstAiUxIcBOmjRODeMAtYSIrwHy0CBDp4i9qR6ZgMvME6og1v1Fl+cKC58oLMC0mJiaKE7ZSpzqLoTisBgG5xzQllOt7HItjm8iJiyHEN97dCqH1/K/sJgRAWCUVheQp014f/NnUcLsF6wQIiGGoWAjvGWCRGRCh6zFigVbXjqLVzsyR928ub7LxrSRx7psW2Ae2jFjgxrK1Fe333VfRRoXfVcTBnEXnzIcfMHU8b4rPqY8FSAQYXCFKU90e4zhQEIqDlNRSygjmWW+v01AeOLG/maJ/gDh1vO4l+xbR0/VEbDK4x8KpEKNoUtkQw0wF12hXdH4wQSUQCGJeF1tJtPIBP/F6KSIotX0C67lQu3DShCpG/R5EICIkwMTkUAw4dZqKmaNQgrZ0Rdluba/1SrZY6V4NGVHq6B0MGSoeXN955+SmYF6NP/trr/+4X1wru5ak639++tVP92L944gd/76Xf80H55m8Y3Cpn/+5TvH9DNdNNXh0R11Al3KvqEtiCcZQRAFlhcezQl7xBBwLOJEmS56mIlDwVRkBHSIlKrJOSrSlnpwf9PunTKA/U5aGDI+QanLOOEp1n0FQzTnsmU6/tzb/8xs0PPLQ1HIixTd7PMr11fDxxzmoCaJpkiKi1aey8LJpxY60FhJWNdde4sql7g77OUkBMenme5/eaN/z1p/5t/uN/QFljhK0RMU4QXV/pfLgKvTUmhroSAMhUbyU72r71yX/5767vm2y4tnFq09ja2AZEI0EiQGkiBP/j30gA3gPwnh8+hB++et93AgDsPPPr89s3teGyqcvpar1SbG1s6jw9cqYum93JETcymtVy62A97+3NDm1tFCRECSilHInShl2mtFKJsLNiwZHnkmURjVCJ5L10Oi99BWSdJmyhbkpEZGGdap2QtY2IKKXQsWlMoomZE1KoSDQWztrazk0tbJu6Vs5pwERpg5VxDYOrjAOWQZoM+r3GWXtgGThDHPRzTWhNtCAiixgAQKWQIM3TpNTT6cSJWadVpVSZOtZIKaFDXZmB0ipNK1tPjudKpxXgHWtmyGZzlFx+ODu7sfrUxXxjY3jhbHr2LGysuX5uFRlgrAuNOiUNALZuqrqwsxnOca+pINWiiK0jkARJjLPW9rLMOUfkRLxCHauPeVOGIAEF6cgSUuAW4X0+jGrJlhB17iX9AZdUZ4hHhL+4G2cmIghK4KS6yBxTPdvCBeT5IxYKW/vaVlIsjhdsQzo6SjKAJ3tatG1JhNMJUi8ILpslmCWCsghkbD8M+mT8XEWWyVhMdNnijrH0HogESjvxFFnYWrsBwAcVIHgXO3nKJIwfLR+eCKI8/SgEPe0E9xUuMFYY4Q6pOXiVskPexQjiKaY4DJuXbhF3SMcCFLvmwZ9CAMBAFKaxTSZcrqol4ro2i6DIxpZ2xZufyO6CaxvdmXIv0IjvYW6hFopEwRO/rharBxzCYqpiAjcxc9ey1JnFpSa14+ijGbBrFPEJsRBAT2eZRq6LIHfDLywh+ZOXc18jO1YQriLOBysgIoJC1CjCNsSN+Z3DoZHsC7R2YBO3odGxFwELi3hbgi+TQhFkOxFQi/QnX3O5a+NZxF22ikIgcvWvAEBsXWld4hqMrLIRbSwvWIjc+yI+BVchoi/bIxHFRFcP+sjdEMTk6fY7peR9ah92OOlDg4EgMLjE8yJYWNmyQ4GUSAANcgYwYkWNQURnZUWna3vN9hdf2z7EB1cuppvnZH0Vs549mrqUpj0a5XRpbeP5srw82jDz+dhVuJLN9u7c/qmfO3PmzPp3fTc8dP7MH/zdasNc/aVP7B/vKT0cZMkxFimpVCcoUpVN2stTVNYwaqzrut0X3mSaZQnAwJhKm1qaBphRKaewZntYlUk/7et0K8m2XH3b2ZkgQqKcUOPQOIMO8/7R3H7+yk0lzQefPpMrxAwUotZkBJ1xxpl8xY76w9Xhyrysx+PpbDYTlDTNdaZJ66yXs8Jev5/2cmPM//5fPPYn/s4bcM/1T/7EhjQ1E1iLYoxiFivonAVpbNpLqvHxHsvg1FpfSfX85z79lS9eaRBWtrbyPHdNnShtEf/yX5rf++QT1+QvpfaFN1//pX+TmvnombcNYJMHg/pwjCzz2dTdurG2stZfGaW90cZHvnG+lk/ENW/eKr70knnpRQWSZsOirgjEsAPAypp5Uepe3xdnZwZHLoXUVx/RWiOiiHPOMDjSiSIUBAushNIkybJMae1cpL51DCLScFOXed6vrLWpOqjLmalrkHVNvmRJL8+Na3SaOGsKU+XDIQmUtpocTKu6Xlnt99OMQAn6utkIvq63L4IAAOzEIelUpwkDGGOEWafpJBVFYo8nquJ+mo252ilLt5r1zpyFU6v08Ln04YvnHzg3uHg2W19RvYxXMytcOHdYm8ZVMi8Tn3nPXEk1Y0EWAefA+WiHPFWsgMUhOEUYyA2Ya7YCEtMgXCsUpfFFmEKtOCICYrDgK+u2CgwE4bo4eNsfugfvvepQ98SOO92LtxgSG2mFJfBMLAIXFjgAXCRVXtAjhUO1ewbiIrEipo0ghFBHaMt0dBvT6n60VOwteHVFIOIkAR/jC3yimx6NtcdmFOeB8ynq7F83PyV0KijXC+EY+BVRS8iP9bGrMRMVFl3wbWOJpI4S4kCDVI1zsQyegmBFXLQ8XgqAgrbtj2EJuMp3CIDi40PRtq5WTBh8KbrV7DlWJsSoH7fJpRJ9cojo/RC4PDESMcXS6ompquBb4Tk5O7QjYVrYsbUtDBHmWEXG1xwRZufV67ZtHErjOhKIFUbvHbWl0YyLWJSwtItPRMQXiUaIBCnxL04EiAiQfW4NRlbQKGKD6t9uKGaJUaUiYGMdRY0kSJ4tntmFWnTeCsLC3krpF703W2IHbcSFjp1+eYwS4s+9sBYRbLNwJaQoB4tFazsJMyje6Bd6D04EET2duSPQvq6DhwJtPEqE4UKkBLptYyIKhr7FmBOi8ud4wLKR5J6IJDgplzbY8opYQrSdvy7x92mCCmyCQaggSGolOa4eH2424sT1ssPy+Isv17/58gCG5do8S2+MN/vpxloPdO/0+rjHTdHw1bdWINmXisn2SqNQqlPZYXVIv3ll/Pwb6bNPrj798Oblsysf/U62PdIDY+r85jVTFs7aXq9XzCZ1bdI0BUbnpKoqAEjTlMPQMQBTpnKVjwgsg2ukZKiJG3b7AqtGZ6kaZdlZk180dQmm0qoRbKpGq4SdWGdUL71bNJ9+a/vMqextD5zvp2lZ7oMibtgYmw2G9azQoqAPvTTPT/VX+quzWWGMSfNcparfH1i2IJInGTLs7R7A/a6kP2gIAQWVEgRnrYg0zMa51f7q8c7Lb3z1hfMXn3v4udPju7uf+uVP7c8BMr11+uz/6//N0Xb1dYMy5B8+dGzq3s/8THmrGGy//+7BzswUA4JqcrwqCFoZEUTUIFLX1XRcFPMiweb2rbNPfogeOKM/8Gzy9OP7f/1Wvn90p65XSDNDBZZBIVJp7CDjRBOhahns/MImIudMVdokVYCKga2gFQZAB5L1UtQo4JRSKOCMcdamqJEtg0u1rsUZjQW6OYggsEJCrQhIK2Pqfr/PTjtjp/MZCuQ6SRI9WhlqrcWxqxtK/BEKgL6UUFBuQVjACJMmzFMNAMLoDJ8q1D6avRTtufX+Q+f1A1urbzs3evR8fvqCXhnJ6qDRqrauqpuGBcWV20daa1JKIeRIwM5xLdYlSRZkqSIgAlBWHIOrg04AkCpRyiECs3O4IlqEnVjrs2L8SYdKa03o5QeGgH5B9Bm9wcLaLdIBzCecpNgVB90f4q96+VavRxEHkwlAm7SI8fQGBwJdHk9POX3i+SffSwsFuLVkA3KkozzZsPYhEtTFJbNBR7h4+a38yIg4CGmongpsWa8WCpZdaP/zLjxPqeDjaoEAxctuBlgwJXabR7Ft/v8KABCCM6NjXfYHrIQAE1+eB6PJAQkRnQuQo50pAEEMlOc+Jxk7r1akiBQEEjRpg1IwqOuBnDOe/8iewkQo8neib4DuuBJAlsnOpLVV4CID8cQktbJBOg33SU0RcIiIUCdP5sQcM4u1logk5JI0XZQgoQoecyjA6+190UGAURguS+X7QhDfOxRGQQnzIdARn/5tGEyFAsgcktUhuoLCSkJECcyqGLhM2cNwFmQIPiEHCAwG0S9DD4clGMQEvJeRQx6sb3AbHQ3sXOTRCt4xYfbeCwCUUPgmtBOAXaeKLCKCKMRQxkXAeWMdBJjDC7IKDJbJ4DsDG6Gp37QxVmiB3tjbO9qV4BdhXCpL+s1iCiTEwXR2jh+GtgpzKOnXfqtdXydCi9qZIhQHFgkNi7OWMp3Uxt7eyx5/SPdzFqTxfr0rG+mpS+cfgGEfE+qPUgZLjuVoD6ec1qq6s19Usz5mJOKyNFPkZsd3uJxv9R5GW73++v6XvjqR48H5rdOPPzN4ZGvt4cfoF8f7O6Y2dW91TTV1aawmBRoQrHMLHy2jo0CTDwnCapLnlGYq2W1KY40VaxKCukpIaaUv9de5qet6cp3rkkAhodLknLJ1liirktuF/fzX9nS68fjZoWCGWBljSCdprw+Kyulsf/dQQPf6oywdJJimaQ+UZFkGAMPhyDnHjUkxKSfF91288dO3LncmAn7iT19CECbFSQIEAC4wIityIvt3r1//6tf2bt859+hz87r48m+88CM/+1GAjwLAtc/B17t+z+975fXnXz61+/I/eP93wNrTve3m4M3bZcW9vb3Z0V5P97CvVUO6pwu2KtFK+QIqhHU1qasyVfSV188++qROh0Jucv3O7vU7ADBKRoobB46BkRJArKyzgInWgIBs2bETRiegFWrFIE1TD4cjRvDWRRYhray1VlhELIs4F9V9AQInmGIPEfN+b67QgSgChbpurE5UgsTWKSS2TgTYiUoIrBPnMCEUdrZSDJmCBozP8UKiNpEVAFLtU/GdVwCq2hzuH2miibOb733Hcz/wHYPf9Q5zamD6iUnluCmngM6JrebYiAZExEpM6QyRsszoQEkg29BKQaKKFEREnBPHaIF8bprAMM+stc4551gMM0KClAKVYAFEgFmLKCTQRESkxRoIsQLOOWEOR4fSGI+gpRlf2u+tPL4f2gjnBqZdSyrE7BKlujxR0P1WDESIAlUIQp0N8NIOANqyEiGQo2ND7bYTxf+pEykSTLkAbbhYG9HfSrRgafZqpwpMIQi+rFWseRNb7s0q0Sfi0327oxWZDLueDk8w68/Ptg1LAyji2qGJFhRvVIBOWD2AhJKAgfMFFEsDC0Z8FfVh7E7c4hM/Th2XCilNGGhFiEKm7kI0hGgBxMhoHvjKPRdZxxau285gSIteMFBB6ziIBKsShVa3od1wxQg44pwuDFn3WUP+irp2LOgXJ6Sl+4zsHQtw4OGPwrZ8+dJa7y6s9ivthlcUauQtZjFo82391WCFExFYsHK1JBn+ntY3FBEr8sK+5MlDQ1kzZLaIolR6otNhVTgIJqHFFcfrfiMWexogoECoIw8LYe98uTURLSJInZRaD3PEsrC4OETYpv6yiGs58DvvDMET7Rj6Ai5+fSsdD9OOTUKEidTJwgex/vKik51+nziS2ikLPsjFjEQ+N2FLDOgSZhab6V4uDsaFmyIkPUFU+tR67ywNExyu21Eqs0rNxcwKWF2pSyMJsU62G16nZF1nLHg4n9aVSVlXJVbzYvbQUG+dN/NCrs6Ob9588+ZN/Ez/2bc/3tSKG6OTNEvI7qEoSvOebRoAYNfGxAgiAqEIa4XSWC2UU8YJltZNnUWgGsCaORq7MVo71V/VyWDHmbtuahkw0bVxKC5TII0xjlQyenNvMnr57kZyeSNJEJWA01nPiDk92irKppwdbe/vTWc3QXS/P1gZrfXW8jPnz9y5c6s/7OV5fuvmnbo2+/uHPZ3/hfe6teHgL3+iCjwc/yuAfP/f/5N/0gl7x5hPUfNHwWuvvjC+efdP/vM/Aj8DAK8DnL53Tfrrf/xbG6483JtLvX/rKzfKxllTOyYpXQPTcro/TddG8+KonE3X+it37Xw0bWwPSaeQaDIs4MRJNZ1prZ546FH33qfg0obr59nh7PqVW5OMZqJmzq2xBQAEokSzk8YaY22WpOCcsAPH1iIqlVKSKp0kSVGLoFjrUCdIxE0pIg6grmsZDkDImFqU0qRRKWdd42yeJNbavD+c2xqMUwIITitSSHmaasE8z+fzqTCnSjvrVgejPNV1Xdu6SpJEgVhjIBOvZbSHJDMIsLhaqYRIKaWSJDG1JQBC1Xvs8hO/9z/qfdMHt4eyVxS2nDOxQ9aNE0LxEbEspAA0ZakCxyhIQuKYAS2wE3Agam6Vz0Qk7f0FzOyQZ1WNAolSqdb/f9b+PGjXLbsLw9aw9zO8wzed8Z479b23J7XU3VKjVmswkkASyCgQC4iwAcdgYkwgSSV/5K9QcaiKk1CpcgonIVAUdpkYUi5jgzCEQYAQIIHUjVqtHm9Pdz7z+aZ3eIa911r5Y+/9vO93zpWMq/JU9e3vvNPz7GmNv/VbEQ1EQIGQmElVEBAkMadHNAJQqdTBRO0wneDcnDMHS2B3hEvLrqfl8PQiPp1xQCjtPwtqjYqvvsto7GPezXCiIyo4DwaM2dooSqrA0q8AE596mH2ZU7Bu0412bcmeMZh2v6aqhFPqYb+R59PnIhtYtDOkbE/7WI5u7NyqkrS48pB79zWDSdHkVUl0ClYKGMsXGUBTuzEzRUswjuyRPsWotC9yi8FBT93aDC03DsvgyqwMd9mcUjCMSD4VeST9SOXr4DLhNjI5nJbEORdj3A17r4mOQczWwK4VTbIvzFQNmYiRCIlQLWEpAdEsaAIjGSLwviZCNGKA0thwf8NlQlJDQt7v+T7NCSCJ9YTE4CZq0fzYxbYi3lkqZhYtNf6YXP/E+KUAQjgln1IIMXn30YDMeH8fpOKL9Gfi7SBQl3DclrmqYOf0I5iE2BXuvGT2RgMh05jtqUzAYqkq3YiLcakAUZXK5lPti6rG6SQjoiIQAZiqCKGrqhrBx6gIkGAoZnmnJnmUe+FmDg+hUrxkmVRDMyON5nObKNeyTWZAkHbersFPMWMBKdHdJ7lEaUIAk5w3tSIg0v1yLxi3x/yKmOnS0x7I/lTKxylGQwTC0xjaANIPPaGoHTYN4RCfbPr33pkt26Ga28XW9/HsvXcvLh4MRw2dx6ap+2H9Vrdebdbf+V2fwIOjy+Fi5g86U5A4d1XPQx+Cm1V9HO6v9cNHcL1Z3Ds8eS9Ex7Dttl/76rfu3LwV48je6QCj9KowxtEQgBiQImAErCpvJjFGc0SmSBbDQKyzub/RLvvLMXbbTdA1YMc2bjfDVpTxBulHIjDAQxkH9h4aCzbAoF6oGu579y/uPtjK9nd+3weuv3AD3wHtQ2vdE/dg1i5v3DppZ8vz0/7h44uLJ/3l6ePqkXv7m/cBUiEbqoLD+lr70nMHLXr1jv7yH7z112/+6u//v/3ZNOn/4V/6SwDw//qD/24cQZGI4I/85xN7x2fgN7j+3P+56UI0QyYv3dAF78f+re16e7FZ0OzEzcBj1V0+eucd9boe++033x2C9SCw7YK3izDeaJuV5+04LtF32248WB58/KOzH/6hzUfvrGS1fLuB0+3db37djyo4v15J6AMQiIaLYX2tOfK+vVhvFvMmGOg4HtS1jJFq17TL882Folbs+r5XImcOzRB4kFGJogC7xqHFnpyhjUPfj47ZefCgrZ/13bjdbtiAARFsXrkKoUKuvd+s1l0cmqOFzupbsZJxjOuuJmgrJ8466Toel7KMIgaoHpfHB5uuizGS45nOzsZ11Vbr81Pf2sc/9gl37U4/W+Anv7P95CsBxu7yCfrg2yYiqaFUOVOOBGYoZqhG0VQNCcXQMAkNIzNGVEqrPeH61cwIlV2tqhGMVBCRAQ1tBLXQT96jprYXZIjq1KfX0jFOBIoGCJp1iJkVREWSyUkDJVXKNAXSLdH8ZA8NEXEP7oDIxZlUhUCopnsYyUKKZZZSNkQ7CHl+J3Nb508SwKS7EREplWEWj8sMij+ZXknPn7Se7aFHhUu8XkvHTdgjhDRDpjpj9TJxVBoFqYbCzUiYxCwm1x2fUvPFmc9hlWIl5fjNlPGZmAvMDHO5RNKFkGbDkBGQCylGqgQs7Pi59WYKPKiymZiCmGSGzESor1kv5we05KTqVZxpBIxJ4ZiBJFQFI5QUFUAq9kmoUEeggCCZ5SsS5T7HrqxE5mqYdPZkcO27pNnazQ+UKnp3diICT6xQqoo7tYgAfNVW3Y1jKhG+Yi7s3bEEoK5YrNOaETrcq2KC/SyPmYHgZBOX0JkZIioigKiq5p7sSZEal9unbIUh0B6R/nTpxPCa/impdmYvNJIHlwA7AAAEqPvN77LGT4VU2cgtuUMAgoyW2AdOYyEQfGqurHgJ03plH5townBYsb6vfOs3sMcNBHeey8743i3aro5rMm/TtJRIhxEiKsoUk9g9doo1XsmF4TMtlxJoxtBbqtCO/agK5JxzFQgckN/Iqmc5Xi5OYvW1n//cg19+ffalRz/yycotj/rDg5OKB4OL07PN/a3NqhigaaoHD+/1/VZVLu4/audLEa0oJbjUTFQ1qphYP4ztLA4aK/KjQUTbjEMAhaZe9x0R1QhDHIYwGsJoAYBsDIiI5EWCoMtAXbOIZkzJonKMLfKNdt4Ahm7twTqMK7AhDk6pInie/SgWLN43DRZzN5wIJlFM1uC/ePey/vW3f+ijH2j9yRjOetggzCKB89wALg0R8foht+2sHyTBiYjBewcAjriua5K+mjXN0jfzarI2put//tf+34DvX8kyXd+9/L8+Wnff/8M/8qM//mOQufISCzf2w3Cxuhy33Wazulyf3tE4q2qO4IPQZmwWzdgH7QYQmfmWDNbnF03Lytaw70TOD5rrP/Lp5Y//4MUHbh/epXBkWw8MatsLN2wXJ0fj6cUAETVH1CNYMDXQVd8d1q2oxKTeRESEmSmTMHpjThkvMyOiUUWI+nEkAlUNIihZIbDH3vHWhTBEF8cjQGOnFS4Maufj0I3dtq3qG9duI/P5+XnnJRJsSS5lCGqOm2q2BKIewUS1G2DoeNW0yk7ZBzt3p7NZU6miOvXz6rkPNN/3GTw+aV88gAMnOmDlZE4dmg5ji1Xcw+3tOxiJQAjJTKaE7yS3n1mz/UqHpy8qsmj6GuZUJqVOsym8mUrcSwPOPUDVvmyBnfwpeqSUXexJoUSTVXgBsmAxAC41pZPTmJ++GDQ29eK0p/IXTw33NxgspoxF+cz+o14hwwBQyjUSNt3iStTBsh2Qpb09xS69X38Ae6JvTw1NevbZJ7+izsotdZc8AoDcb9YgQ+9ZEwTQCpIDyfZ7nWazAxFdDoHjvqOY0wi7PJTtYkv/OhfCLmm4N5Cdn58INczMpba5aW7KFyjHsMu1//2kGPbtkum50xpNkQAsefqSQcg3meZuerIyufu20u5nk01K5BKYA/YUIOQtW8o3p/HjVBxhtuuwmiyhCKCFlkQT2EJVEhUH4q4z4GROTTNgoIBgOzNibxioYkaa+CkyxcW0v80AUUvkDcsOmPrUp2squEIzAWW7UqNlZuXOZa/tLy1Rgo4nqmBUVcDULcLAEgFcIh8qgG3dHez9RczbtKRssq2HCKBpSJYO4WQxWPI5dqe3rINKrqHdMYyZFYa+3f4hgF3f7f0VzLsLoet7U2XmpnIAFMagUT3ZfN7WLR67tnr98Vt/6xcffP7tj7cvfP1LX/r48nD5wVe3s5pfPH48dHi+3l5a7f2BO54BggKi09V27OPh4XFwBqrmUIzZOxf9GKMCjFH7EComcchtGy6HHqAzO/JVajgzhkAOjbCXrh9DDVw5J6JjENBEL6uqURk1tTNCRbEa4Zr3R7Tw5O8Pq/dkOAfdIrTkZuhuqCPmEcNGx5WNqf8jG7tI5oBmR5dj+Nw7q3771vd+4KXnbtzs4j1SdFHZx2bunK88g2zBIR+2SxEJITCYr8ggAAbmDlpcHPhq2brqSs3Rb379H3/v373/6PK9d08fPF493oyz2eLFl15ylR9UzSTR8Rk7kbiN49j1Q7/t4qYC8+xg1YezsyAjD+OAKGBIULX1OI6osnr06MbRyX25XC3q1/7N33bzt34/UA33DWjmtn0X1jPUl06uvwdfXYeVI4gKAEpACNDH4BwiwmrojhcHbLUOWyBU1XEckVBVRcSiJH6wqABgzJzojfu+d1VFiCIRJQOe+m3XzFqJoe87bHjWzpyC9ONy0ZDjLUYR29K43Vwws7K9/qH28M7t+SvP1TevtdePZtdPmsND5yqWLlxcnn7rnfOvfuvuaV89WcOjS7nYHBPWUcPFGiNdWlhdPHnt+cPFZ74bxiedbM/i2HvUuophMDBkyg3Ei7OHe1epR90XeYKYKLl2VBCwJ/f3j96zqzwpQoAkh9EKASciFMTcvteb3aqUUN0Xy3u/k4IdDgFExEwBk6tuk75ETJHU5LWlr+9XwWSD5llLChF3jp9dSQHonnzbH930m1cG+/RFZqgINEW1jcpkXpH5ZlagrFmF7c/APv5suvX+fYvZlLVeYU2crA5IQMArT5biJbl+J6UxGECs4EL2EA4pWDJhKYByOCAFcwRAAbk8M4HalD/L8e+rOfF9L7GszlMoENxZS3sGx14sp0jG9P1Cu5lC9wpXEjnJwExrGfd3cL53IWPf94OJKISQAnyQedBSrOnKJE5qePfoZPvNNfZ7fyAiF3ZuK4TluAcmBQDM8I5g+bgCTHhJi2BU+LkMSVE1ZfHSV9NqW1HoOxQtWoHzJNNDEIq9XexgxbJ1wKD0H0mDMQDIt84Gh2bYDpeOd9PRUgQyNTA0TBU5iQJX0wHdNwH3zmSuBkKmXCVokTmBOMQMUsYF4Kql8owzlG2LXWAm29HT4XnaAMVc/VV+trggiJiNrRL0AjNTLmu/k0jJqNRnHiVlYaMyOvPRTHvpTYyI3KyqNfIg5/dX/eby9J+97r960d7dwsHleGvxlZ/7J7e++sZLP/ED1cc/KK/dXH3h/KRpV0/OLkxYdcFORIidI7c9PfOLNoUJnSOoazHDEMZxJAARiQZ1XZ/4k9U4dt12NXTXZ3NU8wyEOG/qbRyHsevHwflZUIHIalHVVezMLMZI4NLyjBoIgAArUAR4/uiwWUG1hQcazkxHi4OBKC68u2m4VrxveoGmzgQqZ4687/oRnF9z82sPzh5cbL/rlZsvvrh4ztUpfEoueITFEkbUOGwxjKyIqgDESoAjYvyT/+gP7J26P/DMhJfX8b8CgL/w0z+7Wq1i1Y5I52tYd9oHGIVGldvXri2PDocQQo7jmJkCiZh2Q78+W8WxNxhbjWqo55vNvbuCrkPZ6qiVi303jCAxHh8cHB8v7919aE39HT/4A0ef/h65cRzR19AMbePGGi9Ius0rn/r+17/25lv33ub5vOpqtaCoaBZiiORq56PI+WbVAkCMFeUeBW3bzuez1XY9DkPjq9QyfhiGJIkDQD+OM+c8e8EIAMRgZrOmYUMdxgbRt01VeTeKr+on3WUU6wCaO8f+oy/0r97E73hp9oE73/3CnfZw6RaLnnAQESMFGAWlhda7537kU3c2/SyonW/O7967ePQE73ZnD55s3rxXXayfPLi/2b5N737xxQ/M4qLeVnZZ4+CQg8wiBnajNwpXiAamI59SkFckMIDZFb5LRDTLJNkTSDDLt0l67LsuWYLsdLvt3k8lFJCBajspUWRvll3ZZdrbTjS1YcNce5/aJiQlVNirMeX7ZRIX0++X4TwrH5IDTE/ZOgC7dM9TX0IEKA7zvvwBAEvNp3KoOL8nk490tcc6QJLzBXqfZ86mCdn/5StPZVMvt+mLV0iJSnQB9kiSZP/XigGku8hyWW3IQvUpoH0ajgBk6KuhpBq6FOcotB8F2V9C7O97TdbSbmhEeYtMMhzBQFCKQWaTRYWw354+mzm7f9LEUpIGfjUsEVJKHgBL5fSVmYU9u+Pq7OvTwyklmhOfaX65NJUtJpJA6eQOoCWCsWtFZiApOcXMRKw6pnBIiQmYmRooohb3HlIyBTAVmqbEWK6uRgNLh2FXbpr+b3cMsGyxyXQFAAV5auj7llnCeOz/HICWkCMU/HPqOLt/fp6yNK/IlKsHHlLPnpSbQ0Tbbzqcw1jpUAnuEYw8tVqT1DDb+QppyLQj/EirLABgWtoE7/GTlv8qQKl5B2R2ZUKsPD/DlcFeeRQG5zwLDmPsAcV5BI1jGK6184tfewff3MoFD7/6+FZYLOZHdnG6PL/u6uruV7+8ffDgue/9+Ed/4Hu+LuPwr77RNH69XnnnZnXFRDFGQvNkOoyIKCKp+4v3HoCcG5yqJ2Kwqqo81vOquei6EOL9x09mlZ9du9awN+fX281gkSonpAYooi5GqxLGx9SkjqRg0RRQc0I3+3ByrZ6fcPPc2L/Rrd7TYQvSAzjZHiC/ar6B8KbpmZlBCEbj0DPNbAyD7+OCv7YaHn71ne9c3/70C7Pjozl5hzCaRldzVTUW0Dbbf//v/KaN3fG/el+b47/8Y3+q/4P9/XsP3304VFUz9H1veNbF0/PtZtsrmK+ra3euOV+PUSSDqTGEIBrX3Xaz2XTdYIgVxmOg9viEmhmNfXCcMsAVE5OzOKDhrKrPn5zL9eULP/Cpo+/9bhPr37w/OziCOlSuj/MDOLy52m6X7fJ77p0//Gt/5S3ramwIOOk9TZEKxyHaIDpvW5AIqiIyjmNldVVVVVWFobdUtyFiZs57kCECjDGKiCGqaooeGEAIYYsGNR34xgc7PTu9nGH1/PUnH7517YMvn3zHy4cfe2X+0h2pKwA0w4sxdiJwepYKQ8yMHJPzcUWXiGqRmTfeNbcP3c3lNYDGz5fbwY2hHvp4cTb2W62qM74QOojOWUWEgCpo5MCiXKmk2D+e04v7XZ0nyVC0wv5B3h2rp47YlU2xE7/TJ9OfQk8nPa9oVhF539fBsCRVkYg1J5+VEw3BledJI8rCYfcjmTpor7v3M9ekBfdnYJqiZ8f7lCkAAKkjq+3gilSCDE/N205ul3marI2d7bXvJE+vAEzWeSYpIEKVPdVZrI1iz+3uPI2olCZosTRwx/2FCpZ5GaCAQ8vw099pRbgQclraI5QhwES5xgee0d5pvFre3f9ALg+G6Ztp/jUpdElmZbo5lE45iIhIDvb2IqNDwNLKb0e8IbkcdHqIfUDv/iomHtCkTbNeLgwWMiEN9xZS8zThxIeRzKKCVUytOVJXQDDN1Z0pxwFZvJsoKIEaqKhMY7GEw0hRFjIAU5vgTinKpw58QUOV1beUFdpPPcDV8eaJR4BpoyAWOObTtvl+0sFKkxEwSzo7g1KLFreMtd5NHewnHdI3p6XbO1HJzCTDHOizq5Yi5JDDU2ZBXr5kwaXgKZaiIQOzQmkPz5zkYnFf2aCY6NszMjQVIaeA3j7mC64IU5wO1ZWndezHcTAYvSMksyAe3WE1s3cvzv/5N47PvJ5TePtiPNt4sKjD9ejdrCW8fPCFLz759lsvfua7+XSlc+ckVQtbCMF7L+PY9X1VVRJHRMy96swIgEAJVEIkopA6dgI6QAYIqhdhq1YFiWTWVC3zKvYjMQQkVCEFQ2AR5khoRiYazAxAEJIhqQJgCDGGGfLcV0t2FfIs9u9J/ySMUaUlaLlpzAn0W5VBNaoIWsNIpKtRI0F1dLhax199++HmVF976fZ3ujt/+m/9Pvj/x3V2fvn4ydnpxcWoVtcCVXW5GTZ9tNGYIMbgZ+3N519Q4hAVPKYyMVHox3G1Wq0vNyoIhC70L9Tzw5eeh8PDmXP3w0jk5lWN0STqOMoI8eLiomqrj/30T7gf+s4zteNLnf/qG2df/EcY4uyVo+7kzuxTH/Of+Oj6xq3b9hMf/vyvPPnqvwpQEwMYEBIZRZUozqIAu3Y+E41x26vE2PVV67z3TdMOMRLROI6qWrVNu5gPFyJDb0hBlCRajK74pnXVeIao4XTYbCuE3/LC9R/79J0f+p7NR2/N53Mz7UL3oN9sNxdaV0J8GHwMgc1qX2HjB9ANhkjDkS5UNZ3yvh8lKIJ64nF90ZlB24y1uGtH8/rm0MvYxcoQQ/AB2dPIOMJICjOxkfZP6O70meLEMKGqAILIiIzZf6UJzr/vIE2rbEV67CvjfcumNCvIcpuyJNxv6Uz7shHgihbfExHvY9/sRnElzPD0c+Y/8Gnpt38ljs70q+/37vt8C/dE2bPvGgBaxry+7x33BrEzNSZBum/67EvIafkAJoSclmE9e6PsldvO8Sw5FJrCP4mfy0pMCgDMIEIGu7iM8wAlzFoAjSE1kAcUy242Woa14l5oJ/1BV4i/6Cnix91M7nq+TJFvSe1jEgMkFnMDkVz+NzDuVQchIiY7KFtkWRMQkQqkhn1wdWah9JfbX0XVHKXY315mSeruPrW/ca20iCtGIqR2rCJTm91ScZGAOcgGYjI1DDRDEJPEk5GMmJJDUiQwi3smvwFkHgsDRculMjsAI6pB2J9uRNwPN5QNlGhx0uQyoBSj9opvMdlVWsBrRKQgqQYllaEnf8XybkiQzbQcAIUZ/akDkw2YpN/M1BQRmTmbRgkIkatjd1nM/b+xRDiKBUS5LCStmxFSzpSUtd7dvdi2+zEKMgMDBRAwsgI7nb5VJoSmIAcU8wWvBm8AQCAaCyqiAG2hkura7OT6/PqDb/6rxdvjPNL55WWMK0ZdDYF90xMutt3to6MwdJeP1vf+0S+LRz30pL6pazLouo7Iee9HiUGF1JDQEo2KmZliCkOgAlk3bCUMnl1TeUdu0KgOB4ZIAGpt7Z2vY9/FMbRcoZIDI8SgQgGY0TF22hNg7kqpaJD7S1caBWKHAwGftK6h5cFQ37+8eKxDByCoB8jPg1ub3FcIGOuatn3PxJWncVAJOsb/bQfwK2v4la8AfAX+da6/+kd+XhUUQc2AkP7YL/x7f/nP73/gP/6x3/PNJ2cXmy3WtRKvt6MPtN6MKuiJZxU9tm52dHR4+zb7SgAh2hjEERNRCHG92Xbnmy7E1XZz0McP3LpWXb8W4ghggB7JIeJ6vZKwHSBUi6P6zvWP/NRva19+Tk87enw2Plnf+8oX7r7+tbDZ3PoCWn3z+Ktfu3X6o/QDn4off+HVn/rRr37rrftj55HE1DGj4ajSayS0bd9HOHTsg3VEhMwAsFwuV9vtxXqlqgLGROxcVVWICEipEkxVHeQsrZFFgsfD+nxm9SdfeO53/MDtH/20feD2E9Qm0sOz9aa79BWjd86YohezUKsQRCUlYzU0aIVVVXkARGTEmnuWwDiKIcpCoihiiKAWhrBZCwhWVMcqYNQkCzX13UYUnKTK0/pPtQQVIYfHEa/ouXSGykETfD9H/9lrugsRmSXAWoptFGsjB/xTqnrntOxz8Ezn2izF8wTBZQ2dUsaTJjZKvC8lIw8FmLKP4Uhtm54q18/Se5Kx71eTu7v2pMpupPtzsieUCl3W+5kmk27K1XbP/P5vdPfd8+UuEFok8BWwP04wiPzVXaVF+Zjhno2CGW6RFTqYpfczQafB5NQBlDRN9o0ZgBEU8Eq38OmRn91y72uemmIxcfb73ZfPQ0FY5pfUpQYQhIR7n0NMhYtolqifwAogwcoFCaCUrWDO/VZ2vwBAClKyZZbt8Tzv77c18mD2NkTOlagBQHrOPfumDBjVShtipByTMMsZ2cSfagm0l9+yMpsAKf9gAEAmkhA5RskC5aTaEzUs5l1Cz+4rM0xaKm3WRBZqhRllmtTUUQUmGgwzNL+3igZgnChZQEykxM4m3BdATvZcmbF0C1UldgApkwJE2ZoBSOVkOWpy1dvY39a7q2yy3TuZ8nzXPm06hApmxEVOZPlSiMlzP75d1DQJxMJf8gxicarw39uIANDpWDsHEXi0546fu7G4A6f9gy/df/vnvsZ3ezjgPlyerh94pG033Lh2Ew+XfdxutpfzeXt5vvG+pdDL5ZaWR916470HtRhjylaqKhuhEWg0hNxexxRM2XtiHvpopo13i8WiWl2sx7jVMPMN1j4OYzAIBgKE3mna3YhAqGBjHDwQcTWQOkNP5NTQILd9QtK+Fw8jo5p6c0tsGl8dN8uvbeW+ymPrCOul4U3jLcg5Ut//aQCImik95enpe5/r//kzf4dQHZj33ghD1MveSF2qUUYix/gXfuaP/on/+icTbuPP/va/9o033hpiNN8w+UHVCMdNcFwj0ep8EyJWVXV8cqNql3XVCqR2HNHXHpGCxL7vLaooDGGcM71663l3fPjk8Wk9q7TxkcwkXIQOyebXr3/kM59+/ge//4JGeOuUvnZ39eWvfDucbXhoW6jF3rUBxydvfvmf31nffbWu4Hd+6tZPfL/+7M/LN15nwghYsp/qzVLrE++9azRsGJHFbBiGqqnquk6hUCIiwHEcqev6vkci5xwzs3KFxEQGIGD3VpfwiTuv/MwP3/rJ7+ebhxchrPpNRzAbfUC0gyVULsQRg1WKbogMao4GxtFUwSpwFXlnpi4gAojREP0Y28qjMgBssXbsKZLXqBjBYaigg6HqAzgfHEFQGGLNoM7WpDO9kkC5qvn2XJocC0g2zr7k2UmJZ9UnXIkQlPMNAAmFmBxLtEL7mEDuid2SwQAnBMb7PFu5uybMPgBkFzEVbWr22CcjKTd/L5JnVyVRtMZTTUyKu1juuFMuVz2op5+qTNRTj538q8mCKfdKRsnTtOVWLKn0E8XtTCi6XUnOdNPp6/tWzqQX959n79r5tWb7tYppxXdtsNIDJDGMkFDGjKnmwQx43+FPM5DwBAm6gVMQAPfYtvLw8Rkp/d9/kaWeHtP0TqBaMjNwnNrPgeb+wsnSRCiFN8iMmoiiQNVAJSJmrH8BnBInw0DNkuPOhACiCABiIWu+tATJatnXdERAU2wg2QS7zKVqtNweUFIzR0KnJok1DxETiV85fHkxpgNHu3DEvioDtRF2HUYIM7m3GhhBNqQs9a8FznOf9bcoqqq6jDBKPOupaiOamU6EWjtTQcxMTQkckSM0w8EsVcegab6dmqkMiTSQGCWWOyZLiwgARJWMJdpkYJkqkLFDTOQZpQ5WRNNSIDqzqBb3lFQSGekYlBxHIVO3EvEqGzQ556jF5p0MCEtdOYOmJy4pIdyPIAIlQrB0wBKVrwcASJ0REAExGCBwbWOabeEQKKgh25JhPlRv1FY5wmM/OzrtH3/2l9/9Z1/EX3/vxOqVSAwaHq3ksgPmmXMhxO708cnRUYBZ16+OFnMA3YSOHGO4pMoFM2CUEEGMkNhzlDgMIwAgJiGnMQwigRSGbgUyeMfd2DWz2eGs3vSr0ZGOYbvulnUtsT88mp+uL0MEIa3YOUWNIgCKjEY18AHPVNUA1KmIwqgEWDGPZBzBCQEwEAbrDXE5x++Z3brfd//e+n91xRj816hQm8GfeeGw+fQrt77rxvKI5dLCZiNYGRDyyJU1lTgONtilc84755xDQR0DACSUaGhPbn5ofrntLtcXwzgQAYGBJw1xHKxdtA/vP4R2fu36CQ/RajEwUa3JQ5B+M5xdrDamytvto3G2OJ7Lo4Pnjy9ruTZvzl66efyN5++d3zu9vEsVvvb9v+XVH/7Bgxde29w7P/zVz771xrcvLlbb7daxP8bKgR/MDrE2HehhPH/0lV8e/sKHxt//0g/8G3d+6FOrb3y15mbNcbRoFhwAkzkDP4Tz88vjwyNaHMSLNROgaDeOFpipRfSqYTsMvq4eX5wZkzN58fq1y0enEdhrbFQvbAt3lvDT3/uD/85P08c/eI/ksu+t15mr6iGMlXEqFB2CI0aPIyp4RlEycMAOkNClGLJgTpkSkSK42geIyRRnJIUYURO/B5ihCJspOVCFUQEAGzZQBJgZF+GVj91kM6AzyY4gsOcisobUnBtQzCQlZBOyfad3dWempOLhcjwtS8l0D7USxqBduRxeZQiwHNkFSHo3isREMcDkET0CGyZe2FxEiimcbGiFCj3ZLsU3sckbNdslr/d14ZSoxZQwsFTBIGaAZKaF4yeBMIyywgErHiARcaIlTJwIBf45ZYtcwjJYyRFY8ZfSDJiZpdhtsSoSs5EZiYjtoU9sD/S2Q8Il+OaUXMbd5KcpSgaBlKQ6ZBz+BGGJAFRAuFh2BVqBIhgYgqAxIiCh2sDkidhSJUFqNwvJ+01AfjOb4g2WymuzecdPGRxa6hvyEqTgd9EaBUoCoIqCMQEtARRJzUwLaJRSlKcsUtaXRDBhNsv9qEACc71J0VARERn9tHFVcw1qNiN2JQ+Qa0/sykgKy9O+nlbVmDZB6U6SkiYYo5ZfBsRpIadjUGprU1wEgAETKoZSiuR9qiHAzIhLFiFZ09nsmjYVJsTZ7kpGWX7eHNUCgBDjbgKz1jXIPCXZdi5oXCCkCWtSrJ/plleo/iercwKWFtxvDs2phVIYlrDfpBZNkVJReAJU7wqsrxCDPjsh6cq/Bjur/NlroqYtP5VtdlUtfYqnkAlbsokghQOAU5kiAoAE8Vir0oAR6nHmyY/QrfXRteAbobFyqxB/9a/+je4XXm8Hfum5l+Jq8Ag106xt27oK6Vqt7t6NJnJQt977OPYhROecq3wIYyJ6Q8UcdzMxdOnBs41oyYRl7z0ihhASSogMJEYm79GhShilH8OiqpgZEOq67oeRqMrNh5SRBFVAbBgCeZfdtdRowCGllpDEBTCEv+3sf/kbLcFvdlX/JyA3E5Nk+2Pz3kW3+rU3373RfuTF5z9yuKQYfD+wBggBrUPmqnLLwIONAw7jvPGHBzRbTr/nrx83Y9R2a87327XEQeI4RjZzRni5HbtIN288f3LjToT6XLaDSTD16LxCHHtYbfDR+aWtHXT+9OwVhA+/+GrbtfD22XzFJ3O+d3ezPL7+b/y+37342IfhfAWf/bK9e/feG28/vv/Ie3/YHMQYV6eXzNzWjRep26atyW+3D95671s/+/ea9y6O3rn//MFJLwHIrYNAms4QXdOu++7YXW/nMxbr+yBDFwapKwfsFstZBFtfrEcLtTkPMIgs2mbTdUPfNyq0aL+uq/jJO7d/4vu+76d/Uq4dfHtzudbYuIbZR7SQVWrazOUsXI2o752CQv67O8u7s/ZM2zMASCRNOJ2UFFQFAIDMXgDFzd37OymYXKOXHCfIktAKuL6c2ax3s+KchJrtNUzfV5PTYK1A49PDJLNm301P6jzdvSSRscgNmEZarh0ismDPS8C/9DR/tpx1f24RcWID2z8Kk+p9/5Ny5WM4WQ22k4G74Zc/yiqX1lT7P/5UP9udkviNkzq/yVv716QFGBDwfYXz0wSgT9UrPfU7O0MtaR+y6S0A2KOiSANMkwPPBnXSrbOLXb6NzwaQ9seLBnZlsTB10FFM/wPYTWIm5AbIXJOQqUIog4mM0nZNR8iMYGJ6gJzguFqxnRqSxfebwWmprCRuEtABSlhEDUxtREQ1U8kAiGRXJnR0mqJ008lswTJxqGhUeN0BS3M42I9Mm1mOGaZtBoLIufF6sgYL9gJzJIX16iync8ipGS/u1iAZZt77ibUzfQARp1bL+1ukmFNTb2MoBk4OKRkkM9YgQYZMAEAk9WNN+28KZAFgTISq6ZUUCUli58rmeGrHTHXhu1julYfcfbGUsRRBAyVzlAzT1Jxo6pliBpRsjlKpBagCQNBWYVg5NecrqFwYQyvjDaR5uHlwcmyev/4P/+XmF74+fP3+q5/4xLFvTy8e+XZmITowNgwSvSNBvf/wPiPWz90mM1UdhoE8qSoaEjk1lRjBYkIyiw6pG1HiGtGY/ZW6rkHHcRyd94iAQCJSe4+IaBAsbPvelkvnKgY4PDjYPDrVEEcFcr5iZnQOmUDVRAypEO8iADEA4A+f//FnTsF/z/Vh/j+sFC7A9cREhAZmqGpCOgYxw7puecZnff+5R/2Xz9765EH7wvHytePFS8vDuZNucznIBhdVo4fskGsnswUujrFpp1vMj67VY2zqecPN4GfjdjV2fWzp4nKriiBQ1/XBwUHlvIURt1A7apsGEPvtsI79WoYNhGqD0atbX36sat21g1XcYrhcrNejbm5++OWP/eiP8Z07p+8+qNab08//q9tDvLjYVH5Wz+u+7xV0cXzoCEMINspm7AcFMLtJM733hL70+itd6Ng/Wq8rjTMwdjUiDuOaR3DkmnbetnPr4sh+xFElEnhf8xKXg8Ttds2jzuuqEnKMi6Pjoe9vXDt8cPHo3Xn3/O/78Rd/5if4I8+/PQSxYYs6q2e14nboQ002826IRQWXg5BqCMvsqepUojUdk3I09vMO+wobrRTZQW6GDln0J8cM0XBiYrD9vmWQZVJCqkEJxLLlRmJQSgM44/+uRslwB5natxKyz2DFoU8yao+7+n2SEVguM7Lc3XTfTbriWyJgtqf2UgkInEIx01w9o+2w8PcU0QQ7m6l8ZKoFffoJJ4k6zWN5Mf0ymkHq4TJVdhTiLkNApCtf3P/lp+mtrxoW01tPy8wr129mJO0+fPX3y+u7iMAV86I0q5g24aSPbPfwRUfvfOanhwl7S5DbcqWYd8lwQVqOvOWuROPo6sgQkQAR2BlyqdPLhqSYIqQoRSRiAIL04VJJAwgGpBARwTDVuYrYmGCtNrFWZ42y6+Y67fI9xAiYaupQB0Ap0WC5sa9a1tZiJmaZBFwkmCUUbvIFNMecaLLWy3qYIqKYAUiizAMywtLTBMEgRa0SlCYfNoBM0Jt/GWzvJOQ6W8zd8GAK6iBi8VaeKkPN7gURaQbEJKMmpUWumIeTJDIzKsOhzFiuJdKQ+TYAUuXNfgOkUty7C71q6tyWbopouesbwtTCHkoQ40oy0qbQhE6k47bnakyXlIgLIiaTaA8skkw/mlBYiADKVhrECUoiNyETkwvPFZALEEjOW9DDWB8Mczq4ySuEN++t/7svHN0dq+deuvP8y+ffendzcXHiPYyjV/QIvUTvKgNwzo3jiHuBirZq+zCiau0rD7YdN2riyBFZTOGlIsum/eOckxBUta4qiwEBRbRyngwcYAD9k+t7f+PGJytkArt2cLTZ9k82GzQIRARIQKlVqCpEgZ86/Q/gf+D1d47/022MW7BLpHtDeDh0p0LfBj2lqKgKvpLEIiexJldXZGBRBMm1hyL2eIz//GJ9sF7duYcfPj744NFxo+IRDyp/cUS8aGl5gMsFzQ7MNX/hf/fgT/zHtwDgf/HnPvif/G/eMiAW8EDKKETd+rKDoTO8xJGvtf6k6V1f+arhAzOgiCGE7fnq7PR8s9kO/RiH+iw8bhVeOTh2/Vi98R6tzka+xNu3X/nuj/GLd+LDFUdbfPBOU43DZ79c26H1PToCCKQQLQ5RwtDN2laVDUyGkSzq2ekFvVE17QsnxySjXgZLUWmmCF4s+qr13hMRO+dnjWgYRwMBIYlxVNP5rFHv2IyYF4v57MY1Pr188+7bw3eefPCP/dR3/ts/tWJ8dHY5xNG5aqbYikGI3qF4Hi2kMhZC1D0mJQAyKGIKcilAUnlFP9gVLQVWqu0ofyYlKyEnGfcvRARgsZClWUrLQ4IBZTKkhE8vtFSUbRUQKADSZG0kt3DfVpj+e7VecHfrFAgB1DKSHXpxX5FP/01AjdRloyin9/nlpLEKli4Ni/crNaY+5gBXSJbLk+1bG5pNgqtwhyJqng4/lHGV13WyoghAilHy1KPCxAB1ZciFuHP/k9OPP2uX/GY2x/s44FeBlle/MwnPpxgUaTe0nAKz1EJDk+9uAAKY25MVSMP+IkKhevsNcBuIiFSYJnavaUZJolnEPeJ5LDH0bAYYpEY5uxYkebDZNjLVmIDKRFMMrthEZhNoJWWDEC3GERERuZB4plMoxSAqRj0qINJeTXWix4CSHSj2BJaKUDGIBlY41yyjC0E0dWHbwSjLwURMtKGpB2oefZnd3SbODVfTM+yBcm0qE0rGviTE2VWDg3IUJ09d6ReUykGn9Sh9qSFPavK6FTBJCjTTq10Ed8OYnuepf15dqf1eBlfMglIznczXTGm6ZxfBM2Cx3QbaWccoYAxgT9362W9NR27/gCGi6URUlg9uKhwVAknRX0rhEFgGWOEQqnCMeG1tzSUwzXF5k7B9/E8+++SXv9i9e3ax2rx8cDw8vnj48KFtN2jXas9S17O6WW9XMY6bcVxWTarc3p9AM5MQK++RqO82EiIwAWBBIqcalRQWyrSqKT3CjOOoppHQNVVd++pPj6dp1D/9xhcA4Ode/fi8qY+PDtZ9l2b8D6//xG8yV+97/cLJXzQTsWhm81m77cb1ZhQRIGPCudhNrA/A2ARV3wO8wDAiIRBzpRpRDRkdoarFoQd2i1mzHuXcwyb07949/5fvnS8BXru+/M6jOweeW9+yqzx5T5XDWnVHxtMIs7AZqxFGs1FpoIP6YIhd32+Prx001cx6BRKrjJxDcOYtViyoOo5VH4Zu9T2X8bvMf/rOa7KYyaNL7Lr1jYMXP/NpuHEAmxVYf3hUd2dPzh9fXFx2FaraKBEsjIiAGiuiZtb2fRRRV7F5H4OwYhwH8PT87efqxsW3gq0v+zEEiBWxmIZhHDbb0PaO+eDw0Hu+ODuNMZpDVSXC2WwWhj4Mo/O8XM6Hi9VmfRHuzD/xJ3/m5s/86DcuzvrTzbI5OKi8EYjpMK5FhL3zSGHsDapkShQild3mn/5OvjtkcPp0YKeiDACA1JOo0HClYDhYgT49e+3dbeJr3smZlHcGEDAuseGp3GO60lNdcYWvMlsnD2ESNem+WkL6k3GQvr7ze/fZDSaNQDSxMoJa5EkLFt+mxGniXmdRBMTSVmnv6ffdm53xUeRwUgR6Jc/ylFH1lIhLg90PupTPc5HnkWhyZaf7liCASRbvNjWB2qMGeL9r3yjZl+fPXvsPP5k++79bfNPsHWWLMFuT0+3eX1ybqSFSnqVkqD2DO8+mW3rIZypgpyLN3WaYKMtSXR/tddy9OvNqhinFYW5amATwyOrLzEBUAWBHKpps6mwXWzQTSoARUANUE7BUpfNUaiCaGaUOZWB7yns3GaC5ZSrkIwQTC7haTF1ME8YZAIhSnEBUS+4QEuXDFTjudLiSGQSYTI+nKE5pPy36tEY3Q0w0ZViqgAtZp6Fq2BXKTkECoCtBtj0iF5UM0oZ0pBGRrnRPvbK6iLl1Z9n6hqCmKgWpmoCqu8AsZFJAsrIRk5k8lQlNV3YvkJLxlA2yXahtr6Hz3rM9faKm30zjLdO+M4CYfREKmOzv/BVMNqvmPreAZECAERcz2DZddxz98XDs/DH4Fri6+CdffOOffR5WK2RCM42hAlgIrBN+RlSjEKL3ftTARt3YEVgIwXmnqhpNNTml5pBc5WpfDUGoeGB7IiOF3xKDuzIjg5lEiQHEyAHX/o8Xa2O6fuLbX7yEP7P799Nu6vtfv3jrvxjHASD1v8NMxUisGofRHDdHy5aGbrs+uwRRoJmfVawfG6qXDd9W+TIP36Q4MJsn7EwtakTnfUMc2URHHcabfjnIsFEOjgZ2a9HVenz39bd/8nte47aaY40BYzegY+bdDqyZlAglxnEYur7bbB3Mg9owRKKD5cEtsNqCX1YHoUVfY9RufXkxnD50d+/evvtkPsi83/zod334k7ee+9B3fVQ//AG52ber7qT+6Fpgcb4FiUZD9+Txw1/7xsWbDxy6XjemCp5RtWka5jaKhBAO5u242sY+cMXAjEHGy9Wm3yxds5jXz9++3a7nZ+vNxXYNZGOMDsbu7HSN3DRNO2/a5SJqJJURLXg1MiLQGCKTbxuqfR23XwoX3/OHf9+dH/vM467rV9vFyUlH2G3OmNlVHjzFURSkCtYqpZ4maYdPbdGnUzDt7ixzi9yYErK7fHyCYWVXfO+8XO3euTtlZXFSY4fSsgBtV6ew625a2At3nTIKam1PmeWA7i4wOT0D7FGnm1050ZME2Ivx7/xjAFCVYuJPxIBippYfaSeF9sY4AQhywX+Ohu4Vv0wzsff3ldIYwIzSv/p5elZk7anzRIBx1XIsTKypiIKApjBAsrpUNeem88BxjzbacsYAYI+5a++39xXS1dfxqX9ejZpMI3/q9fLPKzwZk/7eMwuKMYdAexmrnGHfv+/E1ppjK2mP7UeYrsxG4unMumgyPp6OjhRmh90GI5dMNtsZLJbOQ2I/FSGAkPRQmusJc5uiF4Wf2wASxAFRhMiVbrxCpGYmknIKoqoGpDruP5ZaLAUmVpYz5vCgqWoEVETKvBuYlbpqinepWS6FuGpvFss5efnZ8Ndc8nr1Slsw6+n9RTWaIJBPnc/k7kD+AhQXRdnZtJFUFffoLsyu5iNKMBX21J4VAKPuTvIuFhpjRLzyI4iY2t1ydpgmO5TMdBewSj+cOfueEWp717O//6xhvv+BPS9nTxCQJTmYlgD22HwNING6oyojMmilTADjGF6bXV8E2T7phvrIXbsFDy9O/8Xn3/ibv9Ct1sfXjs+fnLViTVsRwwExLBaeOAxxtVqNQ3TOOYDKO1lt01OllEpd185VZqhDMFEAmDU1qYmIKqSWj1CwRyWbrgBKCAYaQgBQUBOJEPY37f+A62/O/nzNVHn2JT6r+pT4IEQkg9Spk4BUwCHVbbsI/UXUPmxqc950CX7JXAPWAm+JrGxrqN7XZBSGOMBQ+aqqHaKF1aWxNZ6NSYEGUNFhs7787N0HLxK+0NQzxNrUq9bVTvRElCBjP3bD2MVxCGEYejnvw8V6zQcHzaI1i3UNy7Yeb1I7it67OH7wZLEJi3p5/fn5nXb5ykuHzcdfa567A1TTKLPKI6tspT1UePP0m7/4Tx+NZ7rZ+rvnzx1cfxI3jlVMK9/UTRsI3j49fXR+MZq8uJjf8jMn1o/BSGEIVXQO3OPHjw6Pj68fHR4tD7f9uOpW26EPYayCNeyw7yNoz4beudp5dGHTSYjgsWpqihWqcFMZU3fiX/ix3/rSH/qdj23cPh4ODo82qMMwzJaLMI4SIiJ6XzOgjqlX8667EGSteMWZTkcAkkY3mAh1njIhVEt1wxTTQEWcHK2nL1NX4qdQqA41x1qm6EDu8+kQ0ZT3rASdTuOex5/d3GkH7snMHOdAxD0KcCtaak+HXb0QMaWWwLj0pbLUia2Ma8fXPAFdzUAVzBLJL+T6msnC2vVFS2dkUg1l2jLeIkE3bHcXmyK77zef2QvPZQrlYyk1bzZh6nfFMqnmcdcQKj2SXo3H7Jb5at55euZnTKinnmr3+SIi9pqDXp3w7ELDFOS4cqP9D2b0BiHtqVcBMQSTeOXhpxBXNjcBAPbZYy0ZBukH8puZRbREr3G3dtkOvrIMKoCoblKlyaSzqSokW7gF5pnQEmgpj5jUjKpqIRcvSE8rh6zsV9BERWUAqlFEzOhKLA6SKVOEL2H5cQSwZG2AKaKb+LKeUor7U1ymVREcICpZOq2W/IqM2ktXTt2VCZpCFVd+mdkn36LAyzPl7dQARQ139TpmaolZMh9yKs1o0v7GUt0zPeaOOT3r42xwUF54s5KeSGUye715MJlE5Sxmy4ZoqnN7OmyT2AkneNq+rJmm9KpF9T7XUzO/tylzcItKXRAUA7s4f2nECqCgwgYkUhk1Bt7gRaPmCUC8MTs40MZO37v78Jd+7clnv7I6ffxqfQCPzm2z9ky32+Xm4ak7mB+ir6pKDIYhjDEI2RhjAKucA4BhGGLlMVOVg5kRYozRRXbOee9jUBFFdohTL6EEHbV8fsxUVSQ451RDDPEn3vvG+07IAfxH+0GOvzL/Txthb0iNC2R1BBNUVVRCRlATUwCoqkpVTcrtANKqxSiEYJomVl3lKpY4mIthCwGauKjnn9D5UTcsNHxb4ZQBdDSo/awhZAMd4yAWaQbZcFUzEc/oHWkcv/mVd2A1LDayuHZwvJgvK+S9TPm1h317uamebA4uu7AJ/Vq229VSzW8HAbr9+MlssTwxN1uF9dcuDgc4Oh9eXi6+82Mfm986UCe0aGCMp+8+bt6x/uZBL527OVt4gG1c3X1n/ZVvhkdn8zBstuvZcr7y3baRauDjW9ewql9/+62H6/UGrfOwjeJwc/PgWHXYdn3lfVUxqGi0EIf15eXBAaO5ZVUdz251Y++9H7cbGCMDCtIw9lFAxxHYMToRcb5eLg7JOWOsZm29mOlr1z/wR3/PwxuVnQ2z2eKRjKOMd2J1uQkNkANW1RgtEkaA2lcg/TRLkwluOSJIV30EmN5NW356JZ1izEdbyolLEU3Z/+X8X0NN/Rh2OVucHHosJZcIlNwwQhdVEdlsPwehUPrLwx7yLH0gy5M9oZcMDCbe8+bLu5jIAt4/YQHJl5hS1iX2XkyWZA0UQwcS2DAimqEhucljLN+xPatIEvGzZd14pbVWmQ8oCm+nMt/nQk04Niuo9v31Smoq9TZPSj0xBZtZqc5Ivrea8WQTXOn2cNW2mGTsfiR4f35+k2T1swJZMfWvfzY187SXuPdKdsWnmVRLXnfSLE+DXgHFDFL3V9sDx5SRyH6hAxrT0877U8+/Fy8HMDPHCllPq0WLokHNkCDRcqCqWVSNRkjMhARKgIpkajFtrgTziTIiomhInoHAKFGdcwicSD4kICI6Srwou5GkqVALqtEgBkEwIiJP2WRRMUATQ+eacezJiIjTjRB8GHpmTuNGQEQ2MFExHCEhkCnrjxSQJKoBEUDVRtW4M96VGBkL4jHvYkKNAQg9+zGOQYP3XkFUI4IvBz6BOkXVVDWlaFUDpI3IKZaVZEcgAufYrIpxNNVkPIUQElxARKKKI+eci6NY2Qeld58RoNiAOaBLmdgC2aETCgYUYmDyRA4AVVEFOaPdKYU3JMS0+4OGiZBnEo7MrLnI0gDAFKMpEew1QAHK59kSFUrlMISBHQpCFwfCas4zGwAXzTiMlYEjl2wSohilU1d5sT4EqPCGbw4ejLSW5vhmRcfoedVvm008/8rdL/3cz7en63j3YR1FFmQKNsYoIaJVtR/Rap6N0iMT1SqDgmGt7EzXsWPX3H34uPWLebPotsOjRw+8Z2YSDWHMYNLgQ4gDq4gmdJViAdqpqiGIIBgS4NBtvPc/+PCPAPyZA/iPnj1Xf+fOq4hm7N989521jjHOLgGdcRvZE4OjaMMYQ7S4cG3raxKNowAaI6EnVZVMHIOcirNBlaHvx+3QV217MmvYtmfRmcb5EGdh4wA+6ug6w8eG+Hms7mF8XMcR0Q3SAjtu1haq4NABMAIpgjmLLopDuAZw+2H/EVt/dFPfOKqpGmTcTmN59cvfckjDMIyjsV/w9cMYLrqz8dGCz88uwtvvbBZu/lVW4Xh598OvfOyTP/SZmXN4+XCll8sbNwOKw/nieq1t1TTUgIPN5vzbb7zz+tfhyfnq8lT69YGvli0SWj07vOk4znht+uVvfPV0u+K6EYCbN689fPRk2ML9Ni58MwfGfjCzyzHUvvajGcXN+qKqKoh4cTGI2Gw2G8dRU2/AyiOTjgER0bu2qm4sK2kIuJ2trDYnN66fvzxb/o8+jseHcr6JDW/6VRVxXjVPJBj0iEgJy4jMhg4ZNZoW0ACaamrM6Jm9icv1KqBMqhnhblF2+gCLs6yqzFUi0kJ0iKoak94SGxERITE6JJ8dARNvk6ioqiIAkwOAlJhWURVg9kQOlExZjBJ5tCkqAlFqj6GaSRAAVQxSMtqAczwvyzpN4eeSqYkuWTeKQOjSuVBJbIXZt6Y9xzoRkJgZ0pQLBhExrFSVSuDEINGGYoiRGNgpYsiYTakRHUJMFhKiJjc62XNBks4GEUVUx84AQCRLfeJMLCmqGkVH52eTuiXCpEFVVCmZXwCWmogIoKopgQJB6piBKEREOR2WaKhSZB3MTMQysWuSyUQIjJAaklCkkNWNIiqiISEzIrCVOQy2R1lhUEGOH0yRm+KmZSAdJgvSBAlYYYNEiJQrAYo+T8UQmX0bgIgTUj81C8qbUA0M2cgM1aFqzOUaqIpp2qHSWcoZMjq3lwoQi9EiIhJXoiHF2p0Di+mBoap83w/OVbZLgxRvFgxQUr7ZDVN2g3J7EjNDw6iRCAxFNSgaIQmAmjoWABVTkajJqQUiI8baLCIJAERJzjqKqkiKoBSeOCQAENtFp0MchtAZiFkETHXnCIqKDhMKAc1AGIxAKi+qgxgaigEE6RUVgNT6ZPY655GQGSQm3uJdO1kics6JpJzTLjKpqiIKtNLMkbPH1pFyJQoEpAjoEFgQADFKHBBSWgDT7IEBkiWe8qnvXVLMZsY51JFCQWpmaqIiQWKq700zz0wA1nXbQr1Xtl0525IDjyllR0QMyEoYQ0xjVEOwnE4jTgadqBkYqGqUaGZkxLxjUpnW3UyiZYMi11sAQa5fyZGwaDmkk+Clg5gaqBiQEiGzKo3IoH3PCOyrrr9Ec21VS+xnDlcX2wO/eLW9vn50+iJ7d6Fvffntk0+cwNyefOObct7df/f+3W9+y223cd2hSs0udFvte1Dx3qtGIgeIMcZUbup9CnVoiDoGYV/34zh043bczFvnKz45Oh6GYRi7HfeOWYpziAhRhsOUk5uvyruk/X/o/v/sWSNj/5KogtEFXVSN9ipjZHZMhiZMLMnQRhPREELDFREhm/c+xjiOIwAw++T7hhAqx1GFmWaz2eWwXXebBmcnB4fVZliPfdBwYbFSnLN/oVncqvRja/iWdV+N8U0eV8SBfSRkjbCkIQ4CWiE3UedjuEl4Yzb7ycXyxWr2CvPxxTmfPzEEFQD4TBrL0XoFaoecd6tnqhfP9Quaf+mNk3AAfnGXAh/WwyDXv+O3v/SDn1zcP5fPf+1ys2qevw3fd324eTBst65htBAv+u3jJ4+//e3zb70ppyuDAUI4quezyo/90B4c1sfH7zx5fPfhkyeri4A2my2qqjKk9ZPLZTvTcSOmzayVi4yLZOY4jCoBVBs1VGNmjXJ5sbp/98H1w0MgbJZzB6QidV2hwXa7CSTRQ32wJLLQmFu2j2h942Mfuf7BD12aBNEwWuMbiDKOo6oheTOAUvWnQGSkapojYUZJvQEhOMh9giiR2pXzhGYAGKYzu0fOa6AlEokEoICCCEjmOGnHcrwkH3mmOmmhzFqDBqBIoBaTOtDklCMiMgIX3g7NTWLTud4BLAxBESIYpN6gYFVJDafUNJoZGigNk9jJkAc0RSXNBY9pfqYWS6qJ+i81OYcSBma0kUusXYs0Y2LDwcyZNIAulc2bjWYdc2U5P25qoqYpRcKIiUoSAVVNxpBkrPMk0UIICT/H7H3lEHgI59NxxqyzTU1RPCJyghYoZDBlAfBOOBdQtsQnCePE8Z4baKiCKlAmDjBTQ7XSDQOhPDDlqgVEVgCLFREBoAEm/usUFkFO1UbTRKbZs6ARcoctQoypQxZiBHUGpFMTuMzwBFH6pG5UFQgNCJURcUrtASQCUjNVEyVVNCMwMAFQNDUTAwUOAIRkiGZ7sU+QQCqIqDGYKqftrBHZi0YEDEKGpiCAEDV1BrU9tpKEoxNnuIQpMQmqGtOihnDJjsg0xkELXEJM0eqSMMtFm0TE6FHG5NYDWogRAIjcU6XfaQRmFoad+T9GF2KFJogeEXOPVmAtSMPC1EnRkIglgmVMIiDkbjApW4hAltqIABF6ALDS5g0QkRyTU0mhlLxSRGQqKqg0ggGaccpFGUTT6UYhGAA6x2MEkYianP4ERs95lrRRHLc7LZ43BBOiaEQENQsS83SQL/ksSkJKJMXQVETJk6XYxkQEn0VJLhsrkSlH6BQQOAAiEBma5Ba4yaUwVVNTBDYgZJ+SdTGIlX44yalSVTAyME0I4gJoUlWV6LOIREXTFM8BAMRI5Ig9mUgAlVHGGMUR19Xcuk233R5cP9lGubi4eLk+PO6wgUU8HWR7/opbwun2a//gX5w/unzZ3/nVL/zjR2++e90vqAuz7fb2jZN75w9j3zXXTzSMYRwsBoeYWuqMoW/IqaqGzDkruUUIVnU7RInQjXFjvCCC5XKpIa5DGMcx99EAqKqKiLquE1VNE0GlMDgtH8IPvfvvXjUt4B++8h0//sZX91/567c/SOxiCKxw4+DQe7fabhOTE0oEJgVJZ0Q0hjGGShpfOQRDQCaHrkg4RCJfVYwQYyTDRdMezQ7i9iJuRwkaQhAQAQRygqijUOxalQ8181dp8XHTdyTel/gkyAYAvFuvxtFGIJg5OjD3HDWvtfMXF8sPNPEY3DL2tOljHJmo4moaTntxISLOORGJqlZVQ7U4legOffXhD3Bbvfzew87s5BMfvfmTP37661+9+/nXX/r+76yXjX7hHX3S0WtNW/Vo2N+7++CNNy/eu7e6ew9X2xvzAzEPtQ8h+tns8M5zdy+efOPLv/54uzKq0NHBclGzd4AHB4ePLs7A+bPTy1W/vX1wCI6VEZQd0hBGBpRh7KLEGJfLg6ODA0Tu+4f95RqZmqqOKo+ePBaTk6Pjuq5dRc4TmXZh5AUPDcMLy+Pv/qgeufOzJzz3Q+gUvKkGiW42k8ESMwyk0lUABQIEBVGIBkIGDN6QAUYwYsoufspdZaczSdO8srCX6s0heky9IDKmSgkghFCUB6fsSCqXCJLC6UDkDERUAZSZLWa31UzEDIFTtWDScgk5lcrwAZIjJKlrF4AWX0ZS6GNnDyXCT0UDEAiTATVJN1VlYzOTkvnFnZ5MMAAz3SUpkjqYdldMVM6pA0XOTwihS8+jFkzFACw3sk6JmFTYyKlrA5aocpo9ZpY4AIBjQgQDUNW+78XQO0Lg/Asld4GAYIHIIxZATOlwNqV9AQAyxSUjIphLqt5KBzEyYZrKhQkMVKCwqyAUKvqSNc+ummjnnCOiFNMCgAiGiBx3BgEATChSrlJ0Ac2Ukq2Q6FABk0GbGCNTiB0REXzCbRooKNiucDKXsZSZAzAyUDIyS3F6MxMEMUtNlhCRoOAEprVDAnZgpqCKmNWiSIoPRUIKYSAiM03OM2ibv57b1ysCmYlzeAMRHVKy0x0JAyNiNRsqxwAQZVRVYkbEoObAFwigaI4tMiKiDyGMRIRkQ+gR0TlnKeR/FXVohm1TTyNZVM9Z/XyxQzHGxDPNiFj6zygRMTqRwIiMwUi995ZTAEOyKgwNUhcRJSIKNiAiIFDS5magqJGa6kAkiAbVxIJLgAokYgvLwZi8MKkZCwom79OT9+BBDRDIwxjDFL9KFnSWKZySEbmdbQoWIJFKoASgLXSWyaMVsRGxaVxd14YxDAERiRrpA5aIyw5nA2A5JyVqhoqKCMREpFbjVPOaOQEByZw5UwR1ycQthjRGi5nkE1LJkyEoGLoUVVKgQqCbGkxLCb1mrLyQiAhYIK2B1cyAHM0Bk+xj2czUXOWtO4dW6zt27fCx1ZuheXTejzoGs8PZva+8941f/5YP+sv/7d/tHl+ctIujAyXnBu8evf3W5tHjG4dHAMDMzjtHwEyemWsnXUT0YlGCMaJDGmJaEB3HUZGA8Xx7ftDNUAWjJgypiCRtmnZjaqVhaE4xavEszH7Ho/cJafzKi/9FjGri/84LH3zz4cM/NV7+GZrPXBXxuvPVOA6E5rw7pAUiduOoqgYagnBVT8sRVPphSJE2s2ysX/FUECECM6fGPQfzhXPuYrO9CBvyropIRqyuImZQAzWHb4Wzw6p5zqprxlt0GxBUaK3uTcEtkJEQ5+RuzpqbVb0E3LB3ogIYGTRF4/fSsLX33DSImBhKmNkxXr776MbHPnTtd/1AePPB9vPvuldv3PxdPzwOp8t/+c26c9uPvCS3lsuTGzA/9JeXuD7d3rv/9te+vnr4yIHVEiPbAOO88n4+F+dPt9svvP7VJ+tLbJ2r/GJ5RIAwjs+dHB02s1GitvNHF2dc+a7vOwmz+VwRIarG4ExljMM4IiKNg5idVP76zRvLo+P3vvr1EEIcx8ODI7t+/ezs9Pzywjnn6KI9XDbVka9dvVw+0OH6x75rOLpx2Y29zua8cGMdutE5x2isVYJY5rhncseRmXlUARTIGQQCo4z4nsBPluHjaReJ7srdbQ8jxaiWeSfQxExjQhWkJgwWciOsIjAJyAHkQgzTKCEgAYFD2yP5zVQ3jIBW6uHT500kGQchDIjoSoWgmQkIAAiMkBk8CHL2NqmlJitCNS0wBTJL5XJg5UXMvL20l63PoKisCKvpeXLqQNGMZRTASBzNjcwMwGAVGqluJ12QsBRmZgqcGm8mz4wQkIKohjgjn40hBDVJ2QVGUEl1mAULmctHqajMlLGY8CsIGLSU9CEikWNCJIKYzA4ooEkAcJbITq4wcSejENkIASkFFlA0mXVmmYARKMfsSzdaohzRyQSbBV0bA6YwvJkFi5zjzkhkKd2S0myombeaoLJd4BmSFSJgDqZIOZhh5utwaFrqJDBZXKmKhdQGNDZEII42NUyFEKUfhoILZEOx1MeDEgwARaJDB6aefTTlDBMUVESSfCYsuL/7sz+X5tdh6mKVYgRsbJXzRLmMynEFhALW1iU6Yppg/4iISEZtjIEdTpvb+zoZhOmJk3hFRDC6dv/xx8pI7r9z8VgahBytNASidMxARFQVHTCzNy8aBQQxmXUipsxM1k+/j8CJhhYRsZbJxMEdiEaqigFR1WXmHAAzVCVVEDETI0KXCpaTXGAgxKEXRCUbYoyVZ0Q0n9npywxk3HUIIzMzM5G3kq0AMGLOHSlLn9i+77fboe/7qqoODmY2b2KM41ge2HJzKTNLmjK9nrJuiJyiDGTATMw8YjPBv9nRBONlalKIJ22ULInMgBMtYI71qGqCs7lsTgoyI7nSOJei7QNsLfXlIzMPEdQkCgJx3Xh2OqqIoavYteePH9wM/AFr5ltAo1ErGOZxiCe3Xxjeu/vG57/ena5CiDeb5c07d1pXVc6fnT85O3/0zjtvecTlyZKG3hODqGcHoCEMXDsiEIspIbKYtVG1G0M6qeM4Ogby7mx1eXx4cDxbyKB14wUbERGJZmldzMyIkDMfiQLAb7/3R5+yM/7li3+VVEIIBHVyJmtXzar6/zK2g+IY4qbvGoepGW839ORcW/tt30WJ5Fw0aSyKGIgCoqhu+i6azpu2qesoYlEI0LMDQhGJEtHAOYeIKloD+XbeVu3RsHgyXnZIGwvRxtGcIaiKBzXmddR13EQibusZ2Gywg2ig6M0omjP0XLVmEDeXMszCNU/sHRE1CoZGvIc2APNIfhxH5oor13Xd4+H+AnR4870v/Zd/29/rnl/cev6nf9d60bb/zd+nr7zlP/O9Ygfjii+fWzb9Ft94+92vfv307t3No8ezyjfzNlbO6qpuGyJ3b3359uXFed9tur6p/Ml8iWixH1599VWnKl03ri4U7Pa1gxh7IOrXm4vN9vD6DSMPwzBsN23rLuJKHTvC0WT95OFq6O688NL1mzde+dBrp+fnZxfn/ZN4+85zh9dOnpw+vry8vLh4qGDVYlktD4zq+cn15z/4qSd8ux+doziuzROIDJWrQ4z9EDzXLrW1MpWE8GFGcM4Q1QAVFadmTQgZTJZxAln9kJkpbKyA/or6TPo74lQ4qqlRpypiOulmNvm46bBxarlAgEqokeKIiAw+jMkSz7WJVCrUBHZk5yISYzRTIEwtmWKp1AXIoFE3lUfm5FCWCWMoEM6U0i1+o0hJuyNqagFhZqpUqMaSis9GA2AIeRKY2WEGC6KiAwQQtEiqhEhYIVWGrLYBBETOpYip+BHUeQ8AJBJUGJmYZRj6zSYGrCrXNA17dmSGCgxEJNBPwgp3nbk0iDdD3WtXngQs+Qg5BpJCL6xGKoCUU2NqquDUNNklbgf2n8wpBCOJQpSwgzvyFTNFazUH+F3SVjlr79psFplhIWlFZC2FqWqRLXFJpLKOWKI1ktI3KSJVwkIAAEiGZIjgAByxFSswxdyTeopRRYKBpQIhIExEehqDgSEQ6h7jCgBgJVon5YXkJAW4GTVGUEbzYNGUzczYmRq5XFCpGs00BULMxP13P/vf2mT5pB8BJKKgRgTMTJCoaAmZwGiIG0QEUMJk/lPuj0c+O/SJIjN3DiPFOB28BD4CgI9E/V1lIH/rb/7sl3cd7Yi9I+Q0v0FFNSITM2HEqqr6fkuMrqpCCMmQq1BgZ83YFAwwrvLxzQDuvOfq2jOnovdcMZBWgpzEGC0KUQIgJUWcIjs8DAMAjP0gEhaLhZrYHuISAAp4HBGqdLp2qj3tq4oROd+LyDmnCuM4Xpyd1nXdti0AiAgxMHOCWTFzihIlgyMttnNpLAAFYe7IEdHIMAkCdiUbZTbHCqCkZksbFwDA2icZBwDpj7R8pDsGd0pto4EQiStXtqwwYLIsERF99OQdeVPoRWJQEnRAXX2+vOh+4NZL3/X8BysB6Uc0aFWkPagahPPNr/3tf/LWr3zuYOZdW1+/dtybnT28e3N+uHr04PTBPQGNHt/ZnL3cPBfDIGGs63oYuq7r0DEiigTVKGLkK5SIKozQOB/S5lbcDv3lZnu8ODIK5Jkjiug49sw4oWW9T6Fp/e0P/n24ev294794tDxgYgliiirA4EQVRA+a2XqIMQQFu9x2i6patg3HMGxHSIz7gCZqnNN5MfXqYlazMYxBopgGUAL0SGQQY7RSVIzIoGJQAutAjXcHVXsS2rWMD7r1o3ETMBoAGzTAUT0rJLSVdb2ajqprgJmfDTE2oI2f1YQqIUpUtur8sWtm1DRMnlQJciFPuhZ+GWKEIXDlIMJw1mvozxkWLc6edDc+8pGD3/874CPPy899lj7/Zvcdzze/63v44KDth3p1fvGrv/r4i19+PMZKddHUFSBKrCuvxHGMrz+5exn6h9s119Xh9WMn5oiPlgdt24ZRxJSB2lnVdd3mckVolXOd2eOz05ODw3lVAQDH6BgPnB+GwTRiDEMYL9bn4S05uzh94ead2y+/QI/qhw8fPjm7uHbj+tHx9WZ+sG04RA6CDt1oeO3m848ed2+ODy5nCwAdus18Ph/HHmAFkGg3V845rnYOT845gsv4yn0nvijWfZMiu5N0pThlcn7AQikX59IUExB3zaf2zRQAEBnyK5TvS0TOmSk5B0TFx5iKAim5NEiEZjyWrWSYOlpDEu+5wRmCBz8ZOrvOoWYKYXpmxSxgAQAIpjETEZVqiCFBlXZNH/MQ2CW+aXSabQgAAAPRaEqAbMCCaAxECigAx2kKLBWJSEiJj6AVEYmIxkjOkfcsI4bV5nxjs5mHGYFX0CCjSADUurq2q8XFnJZGM5Q0ctlxzKuBCFqkcmX1HFRVZY+hNc1SclZCIinGnX4hIlXDMSqiMhFRjleogmrqg5aQv0DIyCncnRUWFhU5gf+CpEbcqBHRyAiRE6Q1fya7stMQs5VsloIvlnankUdEUzWREAMACLNzLmq+0o4um9RMMxwCETXsJAPhEcIJIjh2AJAbniOxRjJjdWACEZiIxLFGtmXKnUVLKSRFjaDBOVdp0SQJNquApMm0zHQuqrnDGJFTbA0EVCxnKgwtAhBQn44EACBQNDBFZk4hOzPDPa71CyAoDJunF6uHoADApW4qkaggsoCpRkMgwpb9ycnJ2fnpMAyuqkKI5FgFwOKkHZNuTpOYQnnTYkx7IoTALn14R+FiZq4iCVFVPSe0qWZcslja6N77PgzO0/Xrfhi6R4/OJuW930Jp6HWSR9NNp8dLgQQA8t4no2TaYSIhBfydc6qaSldox3qSDZcS6sjjAgBGNIVQ2Hmn1xP2hSxZbzDZFkQEqP0QpvOfzJo8jUAiUjyAHOUjdOSyREQVBCDC1NhW49hU9eLgUAnX200cQ8vem80ef/NTz7383f/T76usGTTW145X33hz2YdxfPL23XvvfOn1+M13biGdPnliTb0+vzBPGgYEMYuXq3NhJKxJ0XsvBqqj934YumRIoUHQwAgaY4xxHDoUbX01SnSK/RjHGAz44en5op0feC9jn0qrQhysk7ZtU2KFmT/zzT8EV6+/f/0vgWacm3MeWF1C/iehoNZWtWPGGI1xOw7dOJwsFirROcdETP5wviCAQSKBJRh8YaZBwBgkarfZjsO8bhZ1y0AyjmnpvffRBNXMBIEdOTCTUQDiYTOfQW0hjN3lFqAhPK7mJ/UisG8QF97XzGYChOQdolVcgYUaqULnlDQomhLD0F8gO0WHlrnwlHZiS0RIbOZrFQ0htK46qW53C9ceLfut+e/9IHz3S/0vfbH6p18YPvZh+eGPx1eO8fFqeOuN4de/0r3+LYv9bD6fN16HrUps27ZTffve3UfnZ+v5TFVOlofLumaDW7efaxbLN95861e+/vrR4cH1o8Pa8KBpjpaHHsB8M1xczJt2dbE6vbxsr91AxmrekopRQ+TGoQO148XBEIdNt36vuzx9/OSDH/zgjdu3FocHwxASNctsduA89p1hu8SqrQ+aVb/+h3//773O/j6J8xRjJEdRNYRYO9/4attvnXPkMo5bSslaiheSlRpIs6SxJuMV9qwNMwM/3wnrnaCwmrP7Tpgt+CnkkP6ZJNh03pNeSrSBRaQ4IqrrOrWHVItElISJRPNVLtdkV03igijTA6TIfHoexSSWvWpu8lQ0q6ajkeVS8nM5y6LcSxTQlT9SBSr6LG8nCs6swXCbJQ/mpuHpAVzlEQigxFDJEAUJDCqRJD8pN7UAAVBATlMtMRJRxc7MxnEkT1NqKcVxi9FQTYZC9p0gc84iJvYILVORCgvHyWsFAJGYFmJUl0ICaWhTSFstTgqbeefIOVJELP42FiVpDEOa8+mRwEhVjZKCTwuTRHdaaJcdYzVEzFFPheSNT6K7DA08tel2qlHACoZEuAB0RokiKqZESiQJRZRNO0TAnBkI4IjIkWNmPdsZHOcP7bxJW10AYEKiIKWEw5i81rp2ABAjkIr3jplVufQ9dSLeiVaTkiYiLltlB8xBAlMZxRCQK0VDICv8FpnlwtBhldLkZuZchVGiKVPFhXwx2bvp1FUmMBWq8CzFKBUYkWoqVS1ETJhcakO4cePa888/bwanZ2foWBWbahZEyaUcWM5Ea+Hq0GGnsNOSpx1Q1/MkOxL8MG04AKCqURfNzFHOYqTkjsUUAVNXMcmanPPNtT6sFm07Gf2qmjwVImqqcW+8OAkagJwiUS2eUwqgEYQQmLhtDhMsJk27a5eT0CnGpwGAESXzj9HSMVABEandlPjMUi59cZRIRABaYiQ5nXwyy/LIClNNSqn4plXVfboeQkfEGkLZ6aoioEIAiKZbtKixd9Q678QB8ziO6/Uf2d75n/yeP2rXro8HB9VId3/99cMYoXLxX33ej93x2M+uH4yV3r+4P0rcrrpaQ4N4uToPDqvDhUWplG9iu9luSa3rOjTZbrdHeqyqfd8zWV3XBBhjdEiVY2OKEZwjDEjomnYxbjeb7fb4+rUwqmMGgFQY4pz79Bt/GJ65/vFz/7mqiQAiioCIMXmq0BH3/VZM0ZCYKnIgqiaAPljcdNsQDmyIDj0ZeuKj+dKixM2KiQFycTgjI4KZH8cxSAgyWhSMquwTIN4SzQRa7RiMNMQQhZEQCJAeby6vzeYvL46OkQaM0DZNvVg28/kInUVpmJvKGbbsK3QxBO1iM6tc42KMFqAFVwGRiB0u+zGMo5JgW7EnRLdLqRirb7xrms35eRjHw2uHp4vZkkkenl67cSvePlq//Xb1rXerTzwvr7zWfPJl/dbd9a996Z0vfUHuP4Kq8vWsDuZMxjFWbQV1ff/BvXuri+bw0M/mXuMC4FY1O14eYFW/++Dht+/d5aNjWyzub7de9OHp6c3l0XKxIKLlctlWdRhCNw7oHKrVVRO6rYi07bx2HJm9d0C22m423fqyG7/+9a+fnJzeunWraVpTrKq6nc/W4g9OZj1XYw3Nsv3Wu2/++le+9s58+cA3ntjItmPvmjpGrdDXyF3sdyoBGZHASBEYY+pJkGrwUyWJmTH7zA2VvNVi95vbCesrckBjshiSwZFgd7gj7biSgCYih6ACMcYktJl9MXEiUop9BiwhVRFpqzq5NEknjZLL4JFSPaolQyEF/MXUMNs3aFl5JI0b+uSZoIIJGBKljrMqPsVIUg0bGiTGr9FtLMftr0gtYEzo94Q7ADVm9szCiCjElgobwRxCg+AMokSNMeszg5hQrpqKUABFREUShMUh0YKzZjE2ZbIERqHBVrALP2MhLDfZMrvUyjsr8lRXHIaEHSzFz2bJjRwxltQ2xhhjjMmYcLXLmW7USREU97sYqYYAufwQAhIRpbBNYT0xM+IWcfc8u9ZXgs5R0uIp1M3Aqgo4ZKexWBvZNCQtyk7SOhqZmTnzmEmwNJVBpLhChX6KZCPiRFzb+4qZa1c74lfW3Y+UPfwvfuELbx28iWiiIWkHTd6eSbpvXddmtlgsUkw3hNO6aquqSjMAOS4YHZo4giDiqBpjBOfCGAHAEzOzKQxJJzmfysYhVfOmgpqkyFM1JhJIyl/qMAxG6DwhiVomngsxEpH3HswyVAEAABwgKKooojCDYhVkTGXwGo3ZOcYo3c0bB0cniy99fTs7OFxdrL1rI6KyqeSfEgXU3FRJQAnZDGJMyy+Wk5s7Ku7UX1EVMgmMZO85QV/JO1Udxn7WVIvF4uzsLCoulvVqtXrv7XfqujYwBVIkS+0GUxe7JHJE0GAy3VK2ajZriCjG2A2dmZEnAAghOG7BsQAM42hmMQX6mPBKV8lUcBYnf4WIVC3t/mynm5mqKCgk1yvFebBilxlik32T/A+AIGZm6FyUiIjMTgxU1EJARMtFgOqIFSSG0RmOJiLGgC1yRU0EGEzcrBu81yGGrVIvywZdd/bvyPx3/+//pF/cHh5JfXBw+tmff/JLn73zg7/1jbfOh80ah7gMPAR8eNEZekK93Jy+cO3mZn0JoDPnTur2bHsBFY0eZ+RC6Jez5dBvHbqh62fLWd14DLHbbGOMzG4+myHyarupABzwzLer2G2GARw/vFwfNO1JO486wijM8Nsf/yk4vWJn/LM7fxkAYlRT9py5WOIQal+R0RhRQNk1CKKqnl0YxharOURVN4JG4x7p5vI4DKOIqKCZzZoFGK+2GzCPzIgYLSoqVszkLSKpdBbiqH3dtOxrxUqETJlYgjIiJQygAZAi2gF7GUdEOliesHdAaKK0GUaymVHduW7bhVm1dhq35wdce4VxFXTNlfOILDquwYhcMz8w3dY41oigIiE43KnG2vi8xoPDefNwg/VRdXjttnTru49D29gPfBx86795WX3yu/vbld/K6l/82vbzX7z81jd0fdEs566dDcNYoTdC7xfAxFYdzo5AH9TzxeX9B6996JWTw8W4vuyl7zfj3c3K37i+qmbdGKQLzy8Obx7PTpqaUIm1onlXN83QnT05e/fe3Q/dfsGTG0lmcyFTANfWhykKePPW8fnFqp2tJcT+/Mmb5w8Pjk6u3bnDlTuN65N2gQfHYZSDtpHI7z1anbpq/fztZiMpoHc4Xya1RLm+pJmKSmDnNnAJX0+nMseFgVhFzDRBtKZvxRgLe1+2NnIInCEHjFPgs+CFwaFZ5ifSxG4MoEYhjFgZVY0vrnm+hTpE9AYeAJkQLZqi6YgOFEFUEYm4Sr6EZXo3I1QiAIiaJUkcNWV4kh8/kRhyxWACagxal2y1qrraWe5LoPuRm5negFTZA6QaDQRRiSH12JqCEMkoETNgAmRRSgXAxGAQRUJbzQWCa9wYgyoQYBxDxV4ECZEYXYXgMrHBKOrH3JBMIGdJyCEROTkJIRiAcw4MslLzHmcSJ9poQIgAMZiNUFIVIKiaenGnjEwTd4EEBqsAQAW2XSR2zjVGqGKC+TNmnPxJRkr5VABgJAeWgsdimstVAJhINahpMAXILdsTQLJhW6/74+PjD3zgA5/73Oecc2QgIo7qydSYEvTMPIZETanJiqI9WB5miAIImEiIKmbCuKNWmswyRGTGpDS99yi72OfXX//iF0DTJslpYkTvfdDsryYMQA6bIU4053sxHgYAR6XDu1omhEjxdZWp2y/k05jKT0veJF3TiRKR6V9ElAC/KqLF/E9bLZFSJKRN/gUiKsNm5hgjMzvvVTXp/sVi0c6Ojo+vnZ1doOGsmXebkciNYwDniPasxdQJPVWNlgKnXFUFJVqY0w2JznrCbMNEw5WHYJBKi5qmOTo6MrPz8/MQQl3XiLjZbNp6loYEWdcrFkQ0I1nqEpJLrRERQwhpqcrBQ0R0rsr7y3IVf6axAVSbyqXKtVfLUL5Ce2/uHAvYxTkKk+Ae3nN/4WAiKyxZp0TwMVnCqplBNBC2xgwmFtfWR1NC84amNAO4xAC+YsaT8/77nlS/+/f+jvlrr52ttkfz2enf+gdv/OI/X12ef+ni5/naDRpHG4KKiIRBgpgOEs/PL1+78+I41BpDW9eHy+V6vVYTiSM7YKxCP6jGoGHTbQ/1aM9xoWnViAg1egD0vKDZCDYM/TiOm647mc0U8Pve/CNw9frF5/8zX7swUjb/Vcx8Okv1rE2+na+rxAdEBuScgXrv27blMAwSFFRE1pvu5mGFnHhPEICIfYK/DBiJWMFUKVFeVK6qnD9drwBgkOgkzusmdOM4hKPF0id3JQORwQByoHWUpm3Hro/9cHB8hAb9piekesYjjNo6HeRQQC+3pLJYNLEiTUBokVFNVMk7dgZnVqk5qhxziNGsMmymCSFqjlYjXTwBz85Tf+9hd76Fa8uTH/oUvvriGOLmzoJutNXbDy6//Prbv/7l/r27J/P28PqtPsYwWIMzV6EihBAYwDl3uFwuF4eby1U9aw0hhLBddzev3ey3XbdZB6aRPKCcXL/GQM1iebicbc5PW9c07TyOHRBaxY9W5x7pxVvPUeW8UQJaUcFfI3BVVQfLW/12s0bcrleXZ+djkMXRqp0vTheD60J949bR7VvvPLr37uWZzJrubF1VbYLkJWmAxavNgLw9+QYpkreDh09sLimYmssXVVMbI50253TcrAQRi7TbSfnpVMZR9u6oGXmKwgaolIvWUxjVwECm3wE1MAVOLFwmalg6fk4aBQBTQiGV1VFijjJTNXI8QTeSpsmPTZAJG0CDSCYoAAi5yRkAAmoC5hMAeFDVVI+TnOYkWq2EFiCreCj7GoukKhi4NDmJX4eZUZTIKucJEMRKbhmQkNARERg4Be99ym4k1sdUkJ6a5KZQEPMOVgIABC5xqu2vLwAkqClA5qSf1iZRPEx6YVpQ7ypkSipWM8E2qCZWASMiJmZmTbsUkNAoOX2ayAvyjVMVceJzSy9x4rAW9b4ScU8er7ybJxvCFXh78TlLtp3IMTjHgJqdUmY001HYoSmWaldABjA2k5mf6w4FstMRWDlIwTREYIGyJar5QVskrapySYlA0BT1TqNOu4CICjduVh/TbGczJ4VuiFLsTkIIxN6lnEKiBS9c5lbMmSlQOKWUEHZLsjuxwKnMK5GBJsoDRAc7dPQOdmUJwAj5aKS90vd9iHq52swW83Eczk8fzus5sR/2wiTpkVKbounOmYw805gk+gpMnLXTvsn/neo1yq+l8TLz+nKj0bbbrURN57iqfFvPsECC0wRO1eYEqIhTeAMA0IAQQwiZfN7I1DRaQQtHK12gLZf+I+Yuz7vJZMB05qgUUqaVneRaehdzq+cJhJtI9Z62EadX2CDuTQViKXorCV3RHK0xQxUlNUKoGVxFnsgjXfTYGtU1VE/O6oa///rNH3334VwRDq9X9cX4T3/t4p/+SvfttzmKjq4Z4yCjZ26aWuI4SIwADj0AxlE8V103CMWm8oum7oZ+u7loD5pFO5NoQtqPw2bcLo6XTdPQVXmRoo6qOmPeDmNQQTUiUsGfevgfwEN46vrHN/+8mUWoWMlABHTKSgIaEpHjTb9R1VkzR0CNikgEpBjrujo8XHYq4/rCjIDocrtZ1XXlvK+8hhhjdM41TQMAOPQAZAjMaOyBMIUi0we2m81q2HijGllNuzAeV3Mo8s5MwFLzB/Rcrc8umrqufHX+8HFb1YezhfZjDOScb2gWIRzMjqIPwXTLGEjQwBmiKIbIMbpAFVL0aw0xGFTKyOwdA/fjd/zD6qs/DgD45u+05/5u7yMftnK+Xtkw+75P0cfu6IfuWFs1h9ca9tvPfvmdX/xcfPONOdLJbCmeN2LsZ0uuXbSBAxGiCiCral3Xx8uDJ3ffXlw7PF9dttVJ08zQ4OL0DKKcHB2rqzablSJsxuGi29w8WNRVy0z37z2kZQtVTbPZ2ZOzutu+XHnZ9gAgIq4UCSRPznsfhti2y8Plsu+709PT7XrTjeoPooDUncLRYY/hrQd33z49lQ+/4oJLB5YAE35hIvMtM79LUFoKHeoVB6xwNmNCaVvuG5KMklTSgdke2PkYluChKdid8/nlXE7FDkmuZISZGlHi5qf0bTJIFakKxJmNUnKNA9LUegt3dXmQi15zqUU55uUVYtq9pXtBHUBL3SXzk1PSknt+aGLDyqlhgWS8KYFLkj5lSuCqsM1PRwiwa2yZJiBRiZiaKcWoyfqRFAMyM5AQg2rkyM4q7+vkuCMyCKiOYIRknPiXc9IioygAIBN/aYZE7Nax0LSPMaZ8SkI2ceEqmXrPTaIjvU6l5BDUcssvMDNj8ulFhb2Oq5Q675CCiRkXPipMvA1EyWtNahvEACBGYea+D+9tHhiwKEKie0u0oWqYO5sYABAYVz6aimiC3+V3MXX0hGQNEyAAJ5MolUEU93UPm6IAyGYaY6KFypcASlrKRIThnJoFkZRwNzST3FEUwBSIpxlLNTRlW2aDI5uWiJKwb1yNIZnOBpoobBNHGmLuMpXXM8+nAXmPuuOsTDXYVAg0J788bSPiqWw7PwcRpYVz3kUJk50LAJvNZgyb7fO3fO2WC6/RZi0Q08UmjhoZEwMYlDrmSXfSzubIxzWJkbST8i6fniFlwvJ+SgQvRIQIouuLSxGp61pVh2EgA+9c4n7bgbuS51FCFJM9r3sICVXFbMlSrm7f83LSPNi0e/fsITJIPLXTE4ok9PSOhFQnYVE472gv0oPP3GiXnUnNW0s+DyCz4Ez4FDJAIhctIgS2CrgR1CEMMKwh0OGNy/PzRTf8lhX+W7/zp37oAx94/XN/ji5XuI4O7N5//Q/s7HG9nFXvnFd3iIcNiriq9TUR4SgREKuqArXVxerw6GBA7DfbuvaHy7mv+Pziot+uPBoSIANWZEG6rmuaBpn2W7MyY8UUCVrvEl/5GMKfGv/X8Mz1yy//FTMLwSU6PJkKwTm1EBJVNaQ4buMYRCI7IKDkpqgAeETHh1XVq27CsJWAzIPI6XZ77fCobVqxIQYldMxsNWq0IDHIaGDsCQBj0KEb2JAFa6pqwbZuDucLD1SzY9HMr5+rnkXAzCBGIedMwRTqqpEQu/V2WTWzSFVnfHoRRHmsoPXIjIbesSGAI/EQGx1VhLBncp0zjGgWFR0x+wqZba9LE8x9X1N72dfvrfS3fbT+H//4eL3pQ98OEfrx9HOff/yPfmm5GbmqohpXjZ+36ZR5dp51gHJyDfu+J63T0ARss+3tOs4Xy8vzy3473D65jsvldrVh50O3ZfabsYeqYsB33nrz3oOHL3z4Q8AukjPvqfJN02xXnZEFFbeXGI4anXOMPsQwREHC5eFR7eu47benF9Z31c3noCVtWSK6dhGqmrRQZEHGzBU0H9Kuqdru1NieU1QOZg6tTZK6MH0nEo1kCdl0hHcWfAbQPd2riICTAgdBxfQZhQyQKE9pND1DCr8RQOYUVlLa6yd2xelLcokwpegMTXMBJpTatHKPHU1XdqIQS/9LYHZEIKHADJMpotloKAhEMhQzEtBUDIlAMBktOykHpMnZzy4iqgFYMsXUFCD7wDGKhAiiEQYZQ0rQuN75pq2rOXtnpDtCTKNEK5HNlpRHKIQCAFCctF0nrGm9sg2lmCw/BYRsQeJTGyA7eyUIglhIwNQQgJEyEb0q5bh7GlSyJRJ2b8dKS+hEEyQI1DIduJkRsSGLYRCrXQUApqBq6DKR16TmiIiZ2Pt+6ILEhNITVQBixyJaEnWgaJCo30USCpeYiDnFphDROTdoqtZhgAw4KBO1C5hRrrLUVD2Z5j191gwFgIHirvAYMbchAzFzJagCmqp3mA8ODuq6fvf+o2yBY2qlqkjEQAaQTDkqoQ5MROSUqximZSjLM8XTQERFUr4Nd0Grst+xKMIEVrJyGLz3TXvwU7/733z55Re/+pVf//KXvvjBD7zyqU9//2e/8MW/8bf/v+vTESBVb9pkYaSOSrvTl25v+bhNeyjt0f3PpHBqgtiAFJ4X56qqSoGfZJf0fe+c0yKnEoVtJodBTlYHAIqmRwLEZOQapCBHcowyQDHZW8XW2TG3FJdLTfOZyO+qpNW9EgJJ6bYk0wqSd+ev7Fvo00mbBJ8rQKl08rM5lnrdFUcQSQwtJnbelPV1Te1hXF3cBnhxY3/yR3/ilZc/+K1f/qXXz9/zv/bFV995JLeAn1t2cjGuB1fRaXd+MjtorLIw9p11XWcxEmKMcXO56g/7G3zive/HDoHnbVtVXiSuLi/67WY2W4wxuMpVlQ8hqKojMpwi24ilXmDoe0/uD1z+8afG+7mP/DcICkFAHYIiOzNDUfTMDl0irkWMKiGMIGAIosJi3QgOnSOPiDIqsEPpPaY+rAgCSmDATzbrYKCGS9+0c8pJKcTFbNYNg3QhxigArMYKFfKsboZhOKrao5u3Zr5GA8/s2fWrrtjzCGBguRWfsgFAJOOKHHuMPm6HJxdnDeKinSlStWjOw8YiYNRZ2+qmj6ZqRo6dd7Vz6JiItu7AEVUVxTiOQx+k977Q8wMAQNBgpz2tRNt5/Vu+y732ghu3Fga8d/bks1/61re+Ubv4wrLdHjTDagNEc+8bALVgEJSAQgI0sZqGcUSDtm6O5svzbpwvZ/0gzslmiNev35zfuv5gfU4X24N5ezkOVHPdzKht33733W+/896t5267pu2321ENXTOIbjbdzFeG4r1H51GiAWDqd80kBtzWRBjjKNpTVdfAOsYmZTmXtSCcnl1EcBf9MELjTVNWVdI0F9t9/7CkP1LgeXJI9iQWYArlICLtvo6I+6dt+kEzI0okprkL2b6AQkh9DSErJrMEOowWEHM0FUu6AgCixhRMTaq6eEnGPnfSzpYCFnoPRQSmXFu7a1MtMe48/pKHRkRLWNRS7ZBnI1V+pudJkiIbOTApFQAIkruf703Fbk5y1CXTVBQ6waKGBICIk50CCKmn3SgRNJoJoJraMIYYVVprdGZ+F/ed5pyIVCD1N7FcTEEIgIBAuXtIHhHm53GpF4npVK8B7BA18TTui9OyN3YKLEeQcJcs20fzQDaLgREV0kZhxCTXUW2cPumIlCFxRjJxolyqKicqnM1IIaVEip91f3Ks1eIwOmDnE9JDErcGGYoBAlJqVC4pDY/EDsmLyDAMVOp0ih2LEpWImNy+S0diVFQSIzhDUSCxmBqvAhRb1RAg55HypQpEkE00JzHnQb2rBQzAxnHEBDbcMyDyRp8qfc3UjEo7OURUzXoOU7giud2pBVaiFQGj/AfQTr7llUxbXcA0BOe5sO4n1j8gojff/PZs7siF7/3Uhw/mi+ND/kN/8N/yC/7P/h9/fc/Dz8cVDJgyX9+kWfPddN/CyV/B0sUxeRAMqKohxgQ6qeu6qqoEnPY+92xLv4gGNsUe0hA0qxrSIq0wkaij5eozSwyiCeKCLnEPJtxG1vFmOQxFpY2jWREr8vTWTwPZ95cEEkF8tkanD0+nerLTJzcRJ5y8apINmec8x2lAnNkYXUCrsPdkhjwMvpeXxuGVs/73f/xTLz13bfPmt9zZ2s+aN7/+zeEf/L3n/+0fefGP/94v/8X/z+qX3tn62Ch3qg7MVDEKqTjAAIAAzBwljGNPBN7l9lSIeLQ8WG9XQ+xnswUW6FmMAc3ScpRxCTOzI0b4idP/EK5e/3f6s4u63QzXm8o7Ysg0iIBqo4yMwMyOwTmnYBZgD42FCrrtt5X3jRc1EhUTpxpDCP22G8ZNECOHSO58HC/PH40xvHLzzuGs1RCHYTDUqqpdVbXzJoRgmHFCplpVbrvdNlU9m80kBI1CAH3fucqnw4sezCqzTFJMjjRKWzdAOAzDfLloj/n84ePmI99x/dOfhDsnUlfD6WqGtYWghDCOTkRDpAAUFUbFMUqU+eYSxECEt1t3brrd4GatYUcpuH7rkbWN+64PjXeOuZ2Fx/fHN94Nb76zfvvu+Vt3bxAfX7/1aHseCdobJ62vpBtCv2m8Q8+bbk2Rx4kbStGiVK4+Xh48eXSXlsvNMBL6enEwq5uqqk9my/ql+fl2PXSd9WFxo9lcbr7xrTdu3b796oc/crHZhiE49jTn89XqjQd3Xzu5Pqsah6kTBhEhABEwILvGpeg3O1cfHHjifr25PDvfPDgLl+evMGOElYjMZ+xbbxWE3nDX+DI7H5YrR2Ffy+bjU7Qx7CLlCSOOpYN00dxZej2lcvKXcxeKchgzOCLdC7IuzIKUkDDTX07nPNNjggEq4gTdn4I0IgJqqBM10e5RSxWDmdkkghOeYTKgrOQIcMcSmBCaOQhKRjglgK38vOKUQJDMLQEAMKHW9s9jGQ2b7eIEABOWH5A4jMNUfeMqr6qSsPzsQS3GqBJC36FaSj38/xj701jbkiw9DFtDxB7OcMc3v5cvX2a+zKrKoYau6qpmkeyJboq2QFuUTEi2ANoEbcCwYUC/DAjwHxsw/MMC/EOGBdogCdoUKNIEJRuwTIlsmqLpZk+kRHbXnJXzG+98z7CHiLWWf8Te++xz78u2NhKJ+87ZZ++IFRFrXt/q1EEjHfAXUDremUJU/d/XFzddIYaOB4IMrCbRu0sP2yB4Xs2/Gf5CAAkdfslAbegLnoc8mC5zBVMvmy3L0CEmO1ZBRKOZsStCU5nrIKxSgLUHjAVTiWKqGqLs7u4WRV5VlUggYESITZvq/xO4upkhQSq6me8fLJerqqqg7+WkqgaEIioa+zLXYZpRQgc9AqCaFlljDOgcUgrGJSGivXsh5TYpdAeG0vZ2loCrxYicaDDDxWK1XK6dS/2CB98PRFBCQjDszPnuSpqjiI1PXYezBuAABw0dDFJRFiPCZplMu/yr5POz5PRBRO+dmTVN07Thr/+N/5Cgee/dR//r/+X/Yr1a/I3/8K9M9m/+sx/80CCdSE4Q8mZqkBDy+21hfWHStmkyvB17+J7EJpNDCbFzrpZlaWYikjJqzWxI/0xPBABKDDCdt5TyAp2/w8DAQFT7qshEla5bYHIfolqnzEHvrsRRc+mBzinCtXEeJWr3/YVT3kY/zWRAXH3E6KQxkfYApt2qqaXkuFQwb8krl0ycKAHFEXsiJwb1yq/rvVYOgB7vTX/9a1/9+q27Lz79+Hy5mJ6sd13xfHV6+g/+U3pt5j54D7CEJixtPaG5LmTtGwfonMvZ5Y5jiEQ8mUza2Cyrdc5ALiEkBiDM83x/trdqawDI8xwANAqo1et1VEWzPM8TT/3mz/6N65P963v/QR0DaL5q6qenJwe7Ozt5QWDdAQQT09g0A6Ir9rn6AKCB2JOq1LFJXzlkQBMNQIpt29RrjcEAo0YztczFVpdtfbq8dIzTPMsoq2tVNO994YsUle/w9dREZFaUiBhCi2bFpCAiqNGzBwCGhFJtPXw2msnu4UET2qpt5oe7YFbV7eH9W8WbD+H1+7BbtDHiHsFkjmVGFsUTu8wVHpw3ZiM2I0NQCG3dYCvYCjSBmmBNo00L/+5RIlr2b/8ZuLOL7z3OPVTPTp7/vd9cfPxp9vLceT89mB027C+byd3DrIamqUMbCc2BtU0jlVYhUhvUjL1TEWafMhN2Zjs7lxf1qprs7rvZrKTc2rZdt7NyenBzh1++RKa6bvfyqSyb/cne+1993xXu6fMXqOjLojap6/WnyxP19r6/T45D05IhEasqeacAEpqiKIhZRNogkLGfz/en09nDN+q53/HFj3/0048W5093igbAqymyggF1/YTIxk7XgeaDJCDsykOw5y28ZcZ0fyhinxKR8Jz6czrcqenJQw4IdNuxL0lN6Rqm1iVVGoaBXxkgGiR9BDn5gUFBcYQuah2QehoVboKzqL1oM0TAPtW9M0iGjvMAyXHoqIeC7L1tiChmxJ08sc4mJrAu8czMUtN3RIQO9ht5e/qJ0Y3Z0cbU6YVx27YxxqwsmTHUDSB670F9jGaig2ALoRERH6PjLMsy8j7FaswiQHLlbHj+yNai0cJtpAAAACoibJw/iIgW45aiNua941mMd8JgkY6/HS4aebLRwJitwxbCYa0SFR1noAoCzmXpgX2qJSXkrV5YbCJQiZ+nPJKB1Sf9z8CMO4VOQZumCaFVFUQaoF8Q2TmHCCmsdSVsbX3EJ+0FRGR2BpziUH2EIAWQcFA1xsQBI8cdgkrjvVeALHNjGnW3YUcGVev7yxv3JzTtMGbCHqQSOsUQAVF0KCQbPXCs2kIfJEzrhJsFG1RFdt4g+5Vf/hNvvXl7vV4/fvONe3du/o2/+59ctlLiw17n6RJL0qEOKl2Q1UJqXobJZOi8GP0+604ZZOwsQVeaMSAjwZAWBJDiVUnnSFHY5LoA7FT7RB9TNULruwZ1lIQuB35Mh84Hax3U/vgcIiIjBd0YndYFAlVVoTc8sA+jphtSbQUNQde+/ERH9B8fkgSaAqOBpZ+oBEI0BOiSkjp/D7QEpQdCvlgenK2+kc9/4+tf/+577503J9mT4/XJibM4U4yraoZ5LP20Xf307/799e984utmtrfrFrGqqsN8vvIa2pgARzLiFilojLEVcSLBFxOTEKIgIiA554uivFgul+vj+f5unucRQlPVz549mcx2M8dZln3zw1eoGv/x7l8OaJch1E3tnDOEZ5cn7H2WZTkSSFA0QzBCiYbYwa5oH0EFACLPyG1sYozOmaghoWcXoGXnwRRQiYEBg1nQGBwU3jUhPn35NFbrB3duZ1kWJHrPUSU2kkoMmAC7tr0hORET06/rOqgQQapxx87RJdAXy5WuODo6MgRX5Ku2rteVrOtzheIfPcn+yd8PyzpHP3Pl0sAyJ56yWlxR4KRU70PmKC+y6cRlBe7vmgFkBUymlmUwLbPpxJczgE7hmPy5X7u8OIWfPT376SeffPjh7MXRQUbzm3umMCnneqN8eXG2XwOdrdbVoiFBhtiKiAG6KABNxUXm2YGaZ6dgCDSdTm/sHn56/Hy2s+uKqRoygLXt+mLxfHlOPrt//351uZ76nMi+9uZjanUdqupy5YjXCmtpYV6cXVbt2ct3dm55dkGiI0ZCA2SXJZB7EAUDBiTnmF1EC2rNrJjfPrBl+7M/+NEpynKWCRNVQTiFMUZ4oAbQSaYtZnVNxqS/DTogqUEabXopDOyzS4QafagjETt+OKINJzeKAXTgVxEUEdl6LwumvDxIzcq6blOWVKJ0+IGYyLZ5OA4MCRJHReqSYIYmXYkPdDGUXkIPoZwUBQKg9HWH09MzLbNkr3aRFCKH2ImATfRodCGmcsIN/+mGaqQIbduyd3fv3mXGZ188aeraESOwiIUmIAl2jnaMGhOKklOHpkRd/97kIB5kP4wAh8AIBvG4WVNTiEnV6MkmKSiQjNckPxOrTYSm676rXhzipgvYaH2HrJ3EVQ0swYMTd7l8XdEDJCs2tiHPcwFpm5jnuYhIFDQyBrWYujQAQAKxBELvysV6ZSv13hNRiKnzA6caZABAR0SkoEFF2hBaAQDnnHNeRGJM9bTUJk8PAhKyd9B0BBKlVjvvsBikvDdiryIAZKpgQMyp1Y4BjlSVzuxP0tKpChEVRaEIDkDERCFGKT0OYpKHdIGEDwO4pUMBmAEBRBHqWsCLiIBjJgLqrOf0YVfyRBsPB4iSd445qLRt65DULPkYYgxqbTl1e/s7+/t3cq/r0+Pzly8/Jytn01/4hW/+3h/+gVyYipjF1KXPiBE9pAY7kLJ5EQ2TpwHVUnfH3prp9QmEEELTNNQ3NRBI6LQktvGOJPGQ3HcBYgjBOecQTSQlG4sZGyQPQaofI8cJLFzALEQzS/Y0dDC3XSTPzGIHWrepck6lUAOuuaWwWWcJ4XCEtEcndM6x9wiookETHE1fTJaOBCL06V3BFInAzCGoioSYavRZTEiVyRQyYQdUGQaiXY15u5wfvfh28H/ug19664233c78+OLCffF81dRNva6WS0LLZu5lVpcr0gDu+CVkfL5YCsjh7fvVcnVJlasdG6KBA9ord2JTA6rzWmR5U1U2KXOftXWTBlnXdTGd7IYdXi7jcjXP83xSLJeXlPmqWf3pk38HXmwxst9+62+u17WCRWULLWkghhpCy2IRjldnZYa+zE1bRKTMSdVCDFHjIrbT+SzJDwKUEIEhSDCIxBDb0AK6gtm5LEJsaufczm5ZzspPXrxs27rMylixlNxMoF2vaPFyyna4v1/kjJr6oCVZYwEkJceYNLHn/qkmHlSDSMQuv9ht6p/VzJZ6lhK1YAXed53/WsRq2SZnqQM8xq4Bl6p6IDVlJAYEswQNaaZEnacUgQkYABE8EQH8jxMNF/+z/9VivXrWrCJq6X12dz+bTGqTYjapoF0/PcJ1/XzVgNRmKP3eJsfOOXbE0zLtOuccEAJgrOsiy+/vHjYCoaHINPF5taqPvnhyfnGCO/ObO/uH+f7+nXsvLs9mO1M8jTlYrXDn4MbRxVnbNmXGVdOWVu5n+Zqyg7ycRnRk67ZB7xDAGzVmjjjVNqiK81AWeZRqvXiJ737dV+sLXVYuW2fZTgitYWt9ClCPTQkAqjIks4+UDAToks+GcFsyBFXjGNCvZ4kGYInO1uPppXOtGgl8KsrvwvzaGYKMvgN8GuEUI4KBG8nFkXjTLnHD+qB1yhvjvkutDe1VEQmtMzASbBIAiIIIqvYNHLvfxL43bPfb5AjpYj7AaI1I5hxzJiJqltqGiKnFSESJr4oEhc7ijKLUG1FdXSiAmFFf2bvlfkYFQp9niPji6TM0iFEYXPpZ5gsmLyLc10WKSHJrGZGYmSk6BkCLAgacIM5SKh726Ju68RjBYIZhV0Q5pnAiHUsHBch9+ZB1KBKDC7qblA7OyH5fJf9QeteEXIxDf1dUNOS0Dp1g1n6/pZpQQouhISLnKUoLAOwJ0BxA0wbwPJnMNfWqFPPEoOrJmxkqqiSA6dQAlTBB2RqYCIIxoOPcKCKiSGzrgEguywAoiGTU1xMYSLMxeglS2hwqADIig5KKSTHJTJVS5b2KIahDQOz6qpgRbNRuM3UDldEg9RVkInTbuxzIQLFLItD+F1vuxOGhOPgnRlnc0Pur02NVdINzn4DSABwS+SzNVvqQimNmsrZu7ty8f+vm4c9+/C8R/HK9+snHn777je+88YB/evoMILn+ESAJcEsqDvYmQzfBYabbDrGOoKkLBlECkUXtGNJmd/Y/79KeuWtCEUIwRe82ETsYwPYGQyGp2Gmn9uI/Dalth2ZvnXKQ8OyGIvKBIQ6FJGOTa/iD+kM4PjMw8mgN4dx0PwN2wCkdKKEImIhgnhXOt1UtYpRha0Jm8yw7eHL63Wznz3/tNx7t7tI8d0Trn3ziX569bC6YANE8AiGgWEa4DI2KD2LL5VpiVJG6rqPFjDJCiEFCkElezGaTi5Vf1tUUJykfLsZIoN57ZmrbICGSd3lenJ+f57l3zlVtU5blb7y8mhP6jx/+NVVtWnQMURJIWjSNIKIIIjFnv6ybl6dnvL87yzIEBI0OmAqumsZUqqpK2cEJaqUVlRgNuiTzpmlSaJ5REVFizHzODm8c7NvFZSOREC2GViJLi5iRZ0MIEiT0wAygCb2+a7/cr0sybq1PqfFZZ3omRjTco9FMOrhYiR23ZeYEwoeGEVRSURoaoqwdgCinZucGnHyQhhD7RtpoREDYQ3OvO0p+/PyzRltDIOcchpOfX1CetxLJO08utiEDAoFpkRkCIRN32M/kERE563oJSW/fp9MwmU1fn88+PD8Dx1wUOilgd/bg3s0b9+7IsooqTVVP8yJ32f6du8efPXGFv71/UGRZePmsDc2tvQMoaqri2cXpjdnDiGpIzKwAMUZPzpFLNYeAqCrahEDYtu3ubNff2y8/DuVZO7sxcwLBLBU+D778gc7W1xR0AqMrLwcASHbUoAr0NyDz0HXFEhZWOmQ6KqPdNnZ7b+go7X98WnVUpIaIwF8aG+0ea11O3Ejd6dnLSHYOcn24cKgNHLGF4bfjYY8/GSY+8J8uyjvy5SDiJnmEMPngu27Ug/foWnQ7PTM5jrtWHaPxMnPKn0uEw66XiBIzJAt2RG3Fruv8UIoEyb2PWw3J7Mv/3oyqr8nsP+y596Z8aJxfsInEAYBh59sGgABmnKoWIBmZkDqIjcC1hvdSb6inT7EPVyXL3gh93wFDRRKKxNiXNlA16XzD+AdnVvociZK/FbpeLkCAA5DMFZqw8w661ekSXIaQb1rfYRaihoAwosPoD4ddCLGPHaWkVWLZJFQBA4KR9sUliDiEQWB7dw5UGypNrI/tjI+fmsGYPqISBRGTDkUJP0TUWI2gbWNdV3Wlzs+eHa1/8vPfnU7nX3xxdHr+B7P5vpkZAgL3q9PrHD1of1KhhqNydT91CwOGiI4ZiZgT106ZJYOKmi7tw0bMpH1RD5NfrVYhhCzLpGklJaamDjvJ3ckY2xavnd5hhBtCIWJfcDH+ELY5AozoiaNOMdcfNWg84w8Buk6VCfmEiBQhWb5M2fJ8ube/U4XmdH1WaJxW1cNy9y++/+3v7N48CAAAVmv94sXy+QuxmAOAamybILVIyJyfFOU6y09XaxS3Xq+LoiAndVuZxqbF3dv363W1OL1U1bLMXUJUEAVCI1vXlWnMkIZEsJSNkLFThe/8/N+Ca9ffKf+9nZ2dGFGjZJkDVVMBU9CoIRgoE3kkZGoETpqaFmx7O3OXE3Lps1YlxkiOq6rK85yZDSHLstjWFgUAyDtUa9s2qiiYQ2bG0LbshNkf7u7UbWgvLgqfr8LaQHbz/HC+X04LwdDUNQdI1ouBgEhyh6rGOCQVbnm/KSRkPFQeOfaJyGEJfZZijBuEusiYQHYEOmMurakQS++rNVUHxtLpNOzQdRk/kckDwKh3JjS+tU7/RnCYRXZddQN65KJwnh0DExgQOpe5rPDeIxOACpik3tmmIl3Tx85j17QrieeXF1mR1+vlfDp99M1vlnluocZ8guu28Nl8Wp5cnj8/O1peXL5zeB+C3b97NxJcfvrh3mTG5eTZ5adH6+b1u3c59yKCjjHFJAmYspQ7QkRkSoypUsjnE3h04+JHH58v6vWDrEGwGD0wgIPReRyEaO/DSJ903kdE7P2JNGYdzIjAtmGVycSKSRccnj82FQZ7AwbGPeKiw+s2DOealtDdpptjDuNZMG9KW7ErgfsyQbulGQzfpq+2+fkwizEjHV+DRZQ6QgzWnWEHsKgAPAzy+u9HE0REtA0aEDGZGREPWXSqCmpMRGia+pgwqZkiDXWlqa8dpjKUQfmBTZ7r1VlfEwpj3tuj14/G2WfdEtKV52w9pP9EIXm+MXW1ICQEEDB3ZfojZa4nIFrSz8zMTAjNIIpo24CoqSYE2vGijJUeHEXeRy8xEsJU7wCcVgRRNx6fbvCbX2GnVfa5vX1+cQjBREF0SAOCTsRvEPDGY+szNjoIus1ixDhKvSQigw4vCzcDGk/sOrmH7dkN+Mu8C2YqfW905xCMCYlJwCxKHSVVQz354vjDn31eB63Fnx+v8snhxUX7/OlnxbSbAhEhcNerVkQG5NBh5Xq2cn0kw0R0FHJMiZdjZjHeSYOtk2el976u67qurQPuVUAkcobd8U2YdF2HnrFGnzzP472AOHySDpj2/E977DW45k+Cbea19Zbt1enKXBFNjVLxt3blPABGiLaqZ7s7Lxbn2cQfFHn55OzXbtz91Te+8iYU1bNnn1fNzYevLdfrsxdHEBtEyaIhApgwgpi0QdhBiDWCEUErsUQEplBFgyh1UI3FpDTDZl3VbUNEBfpYN21ZExV1qFGUvO8ULyREAobfWPxPr24bgL9d/u+rprqsBDzvTibsEFRibBGIwDLEjMkMxXNmuAzCxK3KUb3SJekMd9gXebZeXbQac+So4kSqqvLeF0WBoUHEaJqw9lQ1gjVN4Mx18b4Q2Cwvp7tlLk1+3tQZyDTLHt68eVhOXNBQ12BqEs1MJKbuzF3HCsSQUIcHWwghPRYgIdTBJtsuIcIYYRfv68ohk0/ONv5htYQRrGpmGThJiy8qBqaqBKAayBQpoqoqGLB1DsWBqn5amplJ2sM0meQ+KyaEQMg+IyJHBNa5A9F5xxm5FCKM2AVYukxj5tSyzhySAe7N5rdVT6IA0tPzi6PFgoju70wm6ArAOsSjo6Mvjo9//NGHd+7de2s+XZ9fOoQ2xnpZlZTAnWlVLc+W53f3DpvFatj2xJyAfxwxE7kYgCmiCgIf3IKD4sMXn39Y4KeHWeXARTKXzvumlrU/Sl1aHVxV0DvrAvpsgOGohlgPT+hPHzvHSct8BYdRGSr2x9dYEbEtp8uWZ6I39XqEoW58XWXLwHCTFjKWAQPTuKIxJIXjWob61kjGU8A+stxPRy0FEQitj5MPv+rCPdBDKVyb3fUrwSQaoaUyBOzKFgjZDKVXms2Mu4Q8AOQOb2oEX6SbgpQt23ZYiLE+Mf72yth6NKIhct3l5+Z5Mf7JFYpd0SMTAdyWqsqICCLDJoSRkgcpZaRfps0rCNVADU1MJJgZGzITaGqvYeP3dpJiLF6MAHpcBuEElgUQh5W9ItDHadSWfm5GhINgMkINagapx/3gNoRrQnO4XNciFgBSmA1pGCtswoEGgNsbZSv1yUZx0PGIN4cWOg8Y9M5/GAVLaVxFreMQJqoCInrvn3x+amStBWRyPgNAJpzvTMR6gEijATVvs+PNrmj31y8cu4P6s9TNBWD8Vbq7+4nGopiY2fn5eRdcZ1o3NXUmF7JpQjHsZCdzgh/d2u5988NxlT/0O3LQKsak23K3ju4fU374p/Y1aWZdb9C0McyMCQhYNnB1RoiERhkByk7p5eXJI+V//Z1f/JM378yX9emnT5beyr29i5enzVk1K7Pa2kmWny2OiMgsIAMQqEaXMTn0QsAcY9vEwGbomAGapnr64unefG8+3y2KYrFYFFJEqS9WF3JxASZZlvlO1wwp+faDn/xrV9brH979awa4XC2icj6ZNG1bNWEy0cLnbVMnb5ZngiJDx61arbpuWzBBMjFYCdhyYWYw3eVpTlmOjqHPORCJ3jsinJYT733btq1EVUX2YNC0rUmcWJ7nPrRt6tazN5mQ2urli5nzN/YObhQTDlqvlmbKzIaiKmqiMaQFGkLaiF2MPJ21VMAF7Dp+CrRxkxqBbboEd+zeUKJ573psNx6Egap68szdVvGivbJibEpEBt140iuYhx6L0EYAMVDwTIgMnlM5O/ZNPpnZ+xxSgwZy2EM1JFyzbHDdExERI4kkF4FC1d6a7kpoz+u2mBRi1sb4/NnR7f2D2c7+yxfPfvjhTy8k+Bt7N7/2djUt5/v77aJ6dnLu0HmletUUeQ5u9fLs5MHde1ZV0KjPmJ2TJH0dG1GIAgYgVqtZVvi3H0HdPP3409P9+XpWlmuYINWZQg9TPD6SPU/bZBX0TNNUUwqeAqj3Lt1JtDEYBspjx9C2HCfDi0Zxz1cIXUTcRKzTwaQN0xgrKAMjShfZBmNwIzZGiZM4YhpjRjEoOgPAQfonbRum3YeppKX/ZzcRAMA+dtw5/7u/CQng1bzXXmV8bmY9NvHVRCRBW2Lv8Bvm3pHRNk8g2zDAK5VHV1Z8PIzxMl0fJ/W5dKl9OjNLD1uwNcEUx9/YuSPCag/kauCIM/aIGA3b2KYZ0cgd0nHkEf27yYINgI2pV0vyj4rKOKSStmLs2rhsDQaBwWCDOw6QXHTX6ZO40+g2QDIEMASiTg9jg1TvNPwQYIPydmWJ0z/dliZCqTwBrIcV78i9SZB5hUo4LMlQWzg+HjByAA7yD8cKBwAQEnLSx5lZRcWUmdExp4w3IHIkpp6dy7iua5UwyQu11jDvKndpM20mislt1Rl/27L52kZHTJjgmhSjtNJJuo+1qPHxI3IqotYlww491FIn3fGeMzONMlYpxtudR+2t0zU0yBkvG/U97scpIDDalK9cY1XNuuS1zW5OdFaN1sHGJClIxEBg3pmtLunZ83/tnW/86299MHt2ZJ+8/Pz4+a3du9P7B2uU6uXljD2zr1TPTy/JoUgrEjSmfk5QlsXh4f5nXzyXKBIxiuR5xkxts04YX8vlcr+u9uZ7eZl5j4BxtVrW9YoJnOMsyzwzAf7yi794hTK//dr/dVXVjJkZzKezKrQgsYmhbpu6jfPprCCS2GhQAJj4rMw5qFys103TzDO3aloCQIJG4GyxYiNwbm9SzmQ3tDUbAICYRpV1XZV5UVBGRFDXLUTGzroNokF06jIAcMwqIXP5NM9uTaeTopi5zNZNHZoEbRuqtfRnhzqQ2W5jEFPPMQ0geRAREQ0doKoBU4fcnFbNOTCzlNnWNSQCEBFmIt2cQQBQVAGFjCGlESSvGCakapsYp1Y5qc0yIqZAwJDDQcbIDgkSsqo40Ricc0ktAwAFA8dmqOkkpSNO6JiJKDVUQySiFgAQmMQQMS+zdrHam8x8OTv5/JO9g73KLIRAbZjs7LkyP7h187/x5utPzk4/uzj5wx/94RfTqdWtXK6rk+N3Xn/9we2bR0cvjuvKeXe5vKxiy85pK2TonGvamsQAIZiqRA8UzULmZzf36atv2c9+vn76gu7fLAK7ShzxJUpGnPzkg3AyszQZVe39BzBao+QRAefYuZS02wJAluVpLZiJmZMJLqPmI9DbTv0/rS9lt01swbreE90gxvwqmTldqv8mIN/ZgqPTgR0G9MixMfJGX+Fgwz60bWkB0GU9bGT/9v1pJuOX2kgKdEXGtmFEfb1M56C/rmRcuRKXNNskykCvGHUHYTtZDcklTwsQOiS1VDtoKayNvebUTW07bjKmyaDEXCFIUiCh72UPPc5m90DqqG22yeXY1BKnFEsAAPCceoUqpchOQgAdUAl6HQt7PS85Lw1gHMtBAM9OVTmV4mgHPXulX8zWcieT/YrzO5VSdCa0Dj1JcHTnlSuVI1N/QsxSBclocCPyMqJsa07DDa6VuDGmB5AWSjntBuOYopmZjZODxgszHutYbRw+GZMDzMZ6cgLhAAQzdYbIhGIiAkwIJCYSIjto6nY6nbKxM0ZHErRtW1d461DiNxmaRMTYMYykPqRBExFsr8qGvtd8Bt2B7BKyulEPs/BIbdsiUZZlihCjJKPVOsjxxE7SSl41ZQYuZn1pNYxWJW3opmmuR3MGNeiKtpHuGT7fdjUNmCBqSeUnAkSxiMiGHewcgpKKxoAvz752cOvP/yt/7nuzm/j5sxefP2na9saDR/NHbz79+OfNycnOzs4ZVWenL25OJxiioYCad6xRAMBUUOIk8z7DpgnQ1lFaokme5RJbRPberVfVixcv1qt6d3d3UmSTyeTm4c1FvW5DuFyv/nvw78K167ce/LUyy1sxR+iIRAQtokkIoYmh0XixXBWZ25tNybypoBlBqhJ2U++1LBsypyLshN2qqoPKsqoNLvzetCxLNGC09XqdHObLam1RvPedB1tQOw85IVEQbUIs88I0oprGSGK3Dw8hCoQQExPxrCE2oQXQ1PSByDvmzvzpc967FQcY+kqQz9I2dl2Hqv5wkaoqMxIRU+eOCCGwg0FSplOQah6BUTeQz5LKKdUM2akEQiLnEEhVO+9bfxX5hIjUokZR1aZpKm1y5xkp+NYQo0o5mRXFhIiIHDMzOXZkatKhBbiuwCqlhGWO0F2cH08mUwQ0sTs7u22ML54/mx/sZVkJ7FozICxctjw+OX7yeQh1XbcouluWe7du7E+L+vy4wHC4m12cNm2Q47OTO/MDq1oJER3VdT1xmZgaEOdZ4YtVCFSWt954jLdvPv9//d+Xbb2cTaAFMwuIKBHRX/cxmJmSKmkHPEqUAIINzHlihzGKiMSmVdXpdHrr1i0wWiwWi8UixsDsnCMzHOzLkb6y9Z7+q5EHq8e+xG3+MHgOxoOEXoxdDc4jwgj8g0bMWV9lkHR7pjdkFWDwCWjXaHTL/YNdMj3AmOEnucBkI08DERmhgFEXurVx0rp0gDRXZf+WBBnMa+xy59M9Q9UyDNajmQL2KjsBCAKKGqWmNgZDyEl7OKpBvl7hvdfVsh6CGQ0ZGdhp2hgdTor1MO+IYwmSHt4VpBKaGRL34SeIqrE3a30/tc14dGsPDNI9BadydkFDV7qhKgDprF0XMelQD4rUeP8g9nAkAAN0PQwBgV5gyKb4AVKLl/SShDYLnWp+1QGBvWY2UHIsj1wUgf6OoEK2qXfY0D2dhy2NeLTkw7+3pWBv+3R5xeP7VRV6Fqdg0TS1MjKzoJa7nIiaGESEONEdRaq9/fl6WbVKydftnCvyeeixCrgrNO1iSbptAgik9E9g6FsEbF9pkN2hGhFunLR15QQyMxLFGIOqc46YmqYhR9w7MBOt0QBkFKHtR5hUgFQBm7waib8M4P9jDy30gRXv/bBBYcRBruw52uTJjrxT44lwYklExARoUUJTx7b+V99+/0++9sb3924t/vAnT37+ETme3jg8vH/v5OkxrJtyOr2sl5nincaq+rSZcV4H04DIsW0A1UQdUsZub2+nPj2vQrOuqkkxLRwzczmdWojz+XzdtIvVUlV1Pp1Oirv37/mz01/6/L8P167/bO/fR0SzyenFKQgUk1lTrds2KoRg0LaNmjlyi7aGo0iA87JwKSVSTUIkonlZlHl2enmelRMoJlXUULUtSFC7XK5cWN+/d8/nmQNbLpcA4JxrpQVRzNB7j0hgbVeoTBzV2hCX6yovMjBzzLEVBCMGCcaA7HwtoaoqM0Vm6jxuREiAROgohSFsA7lGXQ5Z2jOKmJTu/uwhE1GrUVSMnEMCdohGRAKGbuMfTSE8AmDyHkR7WSLW7erUmcqAlMx5j8AakytwE+nNJyWAqrJmAgA55KEOaYdYG4NKq+J9flmdIjKh8967zCeuBwCCmJexLMsgQuSAEIHJ8c7BXrNqSuRoliOt62q+M53NJquj1afPn7/31uuHs8PnH39y8vkXhcj3vvvHC4dEdHl6/PyTj/YmecFmoclQJERkOj8/v7d7gxFj20bUul7PdjJFQ4flZDLJZ+vFyrz3N26GLHvx048uMns5c+uoocAMOOtluV2PBQ/RCiJkgNRzxTpDObkzmfng4OBb3/rW97///bOzs48++uhHP/zJ8+fP43Zn0Ssh0V72Q8+YRtrCxoOeMm03TpcOv2Fk9Q1nGHoFZSxqOrbT33OdPwyfpOfTuJpgPL5tL/Xww0EB6kPenZ40DsEg9vmIyZ+atKhkY/amP36JtwMNoooCUMKpS2ABSM651FgURnlsqWVP6PEr0s8NoAswwcb9AH1WxDDBVymCr/ITE6eG5wkNorMOADscv5SOP/x4qHIa1rh/TgQ1NOy8+6CqSMRE2ANSXxnGAJU5LFYKjmgUk64lvaLG1LcFIHNuMDihd6pdobCZdQ3GDQBjv3Gw72yaAgWYzHKJUbdze9LjxtoYERFwVxXc59YAAAGy68QZbXtuHBtkxAmMiAFDDABQFMX4uYCYclnVFPsOyzYkOlgq8k4l/t3RYu4Oa2pWK1HMzPXVtoQ4dItN+QuqmhrqOXap/I8BnOOEyciIBkVbCzmOMTYxsmcDU9EWJM9zaUPq8CvREgw5QPTEqb+MRxJRVeXMj7cYDYXg0tXQ2mjPdZl0/bINBO0WEsnMxLrU1Da2oOgyR0GTpuCZ80lZVVXdNLfv3oltCHUTY+ShzBKAM0+ECcWF4iZ5JyGAEqEhJM+t88SOse8xSV1GLxgCMIEDq40dMyEBsGnT1ooCuZcodZSdcgpVDKgx47ZpbtBkRXOuQmYIrJyZnJ9+bTL/zlvv/Ldfe92fVx/9/j+GVVOW02xv9+DWrZfHJ5dPPwaAtL5ri+AUALJWWguGGmID3JF21axV9WA2kyYenS+r5eqUXJCJ04iqkQkAAkqjDbaKlTax+cZP/9yVk/83+d+rpfbgW9ohtYvLNSsQYH25BABP2JBzAIVoUvgAYAn2pFo/9M4RewQwFYlRgdCx8zdmu1FjJVE1ls7FFoNikbm12cvz5a39XdCwM5uFEOq6cT4PUaVuCuiKn9frGGNAVsfs8rytm7Pj05uHN0ClbteOMDZkUZoQzEQgigEaOHCccj29I3Rmxo6cIxNgzmEQKmoAmwgLu+RXJukYpalJSUUtrSigAhuRIQEUvjCNzrm2bdk55/x6vVazMs/rWGPK60QE6qB72ZFGSfXqIEREGWdj0QiQsJ2YsizBObdWU545MW1F2+Bb84y2WkUEAGDy0bitJYSm9NnOZBoDxCprvAdiQWSfl9MJeydtO5mVgJYZTZbh8rS+eWPfzDWMy5OTD6Pu7E9/8MmHrbdf/IVvTQn3c4sSf/75x7OcY7tYNbq/t7eEwk3qZlWfvjiKdx62agGBzfJ8kk1uxrLezXI326/qZca1e/S63nwdPv/46KPT0zfv50CrEHesXZaBw5QpATKbS24MFSJih00QNPKeOuCKKExARIXDxeICKLtz586jN99+/4NvvfveBzfv3EFUP/8XKymenS1Vzh3GEIypID+ymwFFFDQhUXTlsiIpU5hUVTQ4zhBBCRg26HPQo04R0ZYq0PUb32JZnegYWbRX7NqemW35ToAosfR0m3QtWcxvI5ACQGcddRieHWBdUobMDMUYugJvRERFMU29vZJEyJxLGUuIG/jRbv+PRGOSFz1CZfd2QaMYqZfWgwIhKtQjcmGqF0i9eZkFtetTB5iUNgeIRKPs1a1riGKPCYWICEbUwSZtpLJZws5RVbSYKisT9FoPS48b8WwAZlGFoKsnHB41VKgNi9VpNv04xyRKt4UYiQgIE7xPl4MFEPruBLh9XVFloK/loL4+CUcmtJkFUDRjQGTCrd9Sl7BiiqCElPoAB9NUpxNVASBzjpFAtEnr1Ss13TTVXFEUYwcI9YAqg5d1rA6Pd8lwpQ97Ff6qP4ASsAxvhq4p03eUPdsdAwIyCBJTaaKZRZUO/KBHyrIefCXGSAiMzAwhrAiRGDw7dRrCynnXKqR2G0ykAE0MiDjJ87ppoNdhxwd7s96j8wkA0vdjHt+cBpMOhiTvfULvSM7vkc2UZRkiglpqVq5rTfBoWZYFlRACA0JyzPSOpc56MAMDEWVAIspdnlwg7WIhjDHz6hgRnUIWLWvhnEPCPBURR+TLwhBbk0lWTGIbVoGIJuh4rWvEZaYutmXOYLK+PDtc4J/cf/CvvvXu1+7ef/6jH549fVECw3Rinmf7u7GuL58/B4AYQwhBNBCRc5RqiJsoJtFAEI278nd0xGbCjHmeadSqWqnGeeEL71i0qmuHBM6Htv0z1b9z5eT/f+7+X1rRqp5xzSKyuricT2fTcoJqXdTGTEyzhLHPHryuJUCMrcj6cvlhtZrl5d50MveFy/NUXx2kJcdiUFXri+U6ovd5poaNBENwTbuumoknn+dEJHUtIjk7S0kGRN77sizrug4hAJiqsnei8uLoZZ5nuc804achIYEmEFNET+TIM6MhECavRh9iA0V00Ku8fby/s0QRMeEnjt3OBshFlnRKCIKWuip2uDjee4nWhATT7tdV5RwlcdSle/b4tJB1Ibzh1Kc3/vDR33n3k/8uAHzlk3/ro8f/MUDKPIcDLkIIAqIMTR4b3wIiZ5ytWxOAKCGGwnFRzoioClGbIBKCdwYkpgpULbKsyD27Zl2Bc7O9w9v7B1g2L9q62JkdPnrw4nN89uknP/7BubK9++5XX79zp1ouP798+tnPP12cn7158/bElw70cl3lezvYrkJVU5Gpo1qCEcx35oqgGc5ms6m5ZtVUq/Xk9o3i/cf0zoPVb/2/V7FZQiFI3jOoIYInjCYJrXMIIpiZCsYYi6JAMmkDEeVlrlGqqlqFMJvN3njr8Te+9Z2vvfv+3fsPyuk8pa49fPjo2cuj119//YuPa7aoKilLZnAGpBPd9zl7BZ8Z3A+EGw8HpsisbAuM7ls2sCtMDIdt9Crb/fo1vGWwhgd3BQBI7ynBBM/Qs3azvldGb5d3YiAhxPSCgHp9ZTzlKwnv1wf5ymEnAI++i+Ro5NfyM8bP6SsCN1AqhgC4wc/AkfsHR/HoQfvZCLjBtzQEswyidN6slJx3fVnT8gwPzEZAcEn0AoJC11F2vCIwWsHhk+FKwuXK51928xUBt9lX27Qa/h6+0msLgQn9uPPLEsAW5lMqfk4FH4YJX2NTqzF+oyOi2DcMTKJ94EQbZjfa01fosnmlDRXOqXoTiWAoW6cUdx9Kqghgq1ipuxRBEJCQkEzVEiZ5v9FVbeNvEEA2JMy5aKXxjCbqPABRvV4yFuzyVCUyrBN0TXu3prb5dnudNn9/SZZ1t90BUFR7oDqVTjFFxBgj1ICOzWy5XO7s7GRZRgar1SrhenWHPAxcqavySq0RHIOZoSKnkLhziCgiblLkBk6BKjSAwNAirDIoa3OI7DJh0yDYEgH7CKztfDJdSnMG9drTJIPCHMXWmgCX1W4t7xezbxze+rWHXzkU/fj3f3dy3vCq4elMiszPyqhy+ey5Xl5EbyIimjoqdZk8IiKhVVU0YQdGlIQgIqrG3Lt5ae2qXjYrA8mzHUaLIXjv/1vXWqwBwN+b/B+896Y5mXrvC7DFepUBM5BzPmOnsUsU9wAQJaoy+SznwqQFWzX1ol2ftLBql8s27GbNxLsM2RN64sqJz51rM1fVmBxfgOCoCtGaplitsJzslXk2zQJYrOuUmKmqzrmkcKT1SqCvMcamaQCUvc89S4xZEtBdzjwxIjNnROhzTYD3kHBvk7/UUitIREdEhkY9rIJ23o7UlHOjvAoiOSLvQCS2IblVzaDMJ03TJNU2xkjkEhDyKMTWNdbpGHDqqoAbLmCGRJyN4AQIOgQ859w6tsCODRxQJjIVUY1mVs39hD0HaOq6VVHEGKWu64lziaUSkaqoahtqaZ34SUI/zlw+me3cyvzp00teV5HgzsH+a7s7TbVeVcsYwh/+s9+v1+sfn3+xvKi+8fCNW7fusEZ2/mx1+fT0nPMJUrVcrZdVfXDrJpgxMztXZGWEWK+rdbAW+fCN1/2br1cUF//yR6cazg0qY0KnpGoRVQS6HIWUAzCwpt3ZPI0ZDTLnNUpoGkf02ltffe/rH3zn2999+Oj1cjpTIFUjshj15s2bjx49Onnx7Oz46erslAjUtC9TSSEaJOxar3fJOKpJp0xLwJzKk9UMKBWq9OVLfC3JLP1/1Pz7VdHhbaFlo+oY2GbjvWTspi8qXYVt2ioGnHLpYcPzcfvVmJL+k7qc2kj1zxzHqgYRA9eE3FiObO5J70fQ5DUgTOiewzblbTpcoYbbBiIbgMlh5FAZdA4chYquUIb6SPQwh3RQh7D7cI1F5JBDMHxLjkUkxtg7sLpICo6UkvGARYb9ueWmGo9t+FC3gb+GBcVthWzQVK4vxIgmW7toTNru85Q9ksIoSSfuPSWKFlX7Hfvq5XZJ5xryNmjU6v46FdLCjNcJNtsr3WPQ5fRISo23qIioHTj3K7RRAOggttKCOUbHKfKnfZGaiAAhdk6d1CMyKWIS1+RcyWCE4l2ZeS8RVUE7mM4OtDQvClWt2ibjjWvlyizGW3CjkSUVGdCsg8kDM0TAMZiYds1qo6knTvpEEkseEUSbtqqzzLmuJqhzc/EIJqS3BqxrrmKYespg8m2hxKhiMcalVwfoDVzq+RIpQ3QRZvuHi8VivV6jY0JmVDbzaOt5tuAIVdiPEc2oDXcX+rjJHvPuG9//1dc+eCsLYfWjn/vlcrFa03qtotPpFPJ8srMrpC+fPKuOXxSqaxFm9lnC+zNVrZsmhIbBQKOakWDXhk8UEcVC5pwWmDUNtGKICrZomj9//gpEjd964z+K67pZc9M0bdsaIThWjaqR8uKyWkXTG3v7RVnU60qjOKI89zFGQxSCFiwSeHYxhIpARS6bpmqaDLhgnpXlrJxIEEY3LXLe27to5GhdryTmPqsdRcV1VF7XGbt5Vnjv29hS7IwJVU1+jn7txDm3XC7btt072C1mE2Au8jws1wCmxGaa0BKIyIiZnIIyJfAMYyRGjJugfu8/64vLsO/gABvfoSGigGbsszyHIJRpQrlXsKhGzgMA+8wMRSSq+Dwj2OQAjVkMdEHSEVshNIR8dC4Cg6ISBWbLOUfEqNrEaI7BZwAWJCJAHUSlldwx5zm7LEiGGbgNFG+OKa4shBCaFgijNucvXsyaiNPJBG15enJ5Fu8e3rx1eIhFtsp4ubo8urxYnJ+4oPtleeP2nenh4cvPPlksLs1RUGjPF9DK3dt3b+4daBskxOm8aEMIq9MzaGIbeWfXdnf8a6/xwV77+cnRD39yVrhVXjamhZoSARCoqBNCZwC0CdijiFxeXJRlnvsMAKQNIYQbNw8eP378je/+8uPH79y8dcvMogIRikqI0QG7Au/fv//k3t3nT+/9/OxcQXzmmjpBaG/z7G1WA73IQUwtuHAQVJriJmOFAwA2WVhbAnXLQPoS38b1e8ZiEoaQQULlIewaxAMoQAKQIEDtMy9GRiZiMpX6jD0dZSRcl8QDBV6Z5/iKTwYzOTHL1ItUu7wWAOhadAxT61Wirg8opNqZbtYKdrUm8BqVBpHXKRzb7oRh/FmWqW75sTrfw6j7q40UoC5hqE9fHZ6Dr7J1r8ZBrg1yTN4vSysepjPWb65M5MpPELtikVea2WYGQF0pcGpabAAEff4sAiCkXQubzKCtuZg56iG9h9jSeDNdmQD0+tRwT7p0hPcwvjNpalf21rYaM/oJdiGZxGSHlmZd0StSUjiS6ZkeEWN03iE0i4tLg9A0mXPOZwUShAC+9yN3oyXUsElWHV9X2fH2Rhmv2fA5jbDGB7I6IuZO4ch7jGcEcMwhhFA3qZ2Bdw4QVTWqeEsGAgJsMp6Cqkhk9sm+tSgJ8FhFdluHDtET5ARJcxcTkecXZ84gK7zLuLVQt3VUzYjopJ4C3TE/WTU39ncePXj8wE0e+91bv/79nT/5vng5+4e/s/y9RXt0qW3IFNuJ1wgH08nU+xcvny1PjkDbtbSYZcQpTUdEtG3rEIKIOL/ZOaqQgriiQQGItHBup8yqmLXS/hvHV70af3v336+qyszOmpvzLJuV++26Wi+WqTlRE1tRWWvbhjqYTmbTLMu89w6Q0YXQREk9AjC1mNcs380nbQwtgAArYmXWSKyrag0wz9mJ5AgT5102YeePl8u6aZAdEQWxy9A451yeAbJjL20NYKnsHsCyLPPeMVNdn4cgiDaZFJPJJLVKyrJsbQsCI0IERwlsERmRwMildgLkkBJakTmAqFubv49rA2d+OGWQHB6kpua9d0DO0JAEUu6RRRUgmu/tWYixadn5HoNLnfO2bRN3R4/QRiUDAACEzCx1O3wwYVYzkNSFRQUMgbOsgC7fSJziLJ8bC03IHASJTVUj6tQX4iiGRkSI0HPSGtXMKJiCoelqtRJAqtaz3C8Wl3uHu+16dQaQE6Lazd39g73dun2tCbKOsZjNP3r+7Oj0qGSWVTw7W9yazN7/1vu39g5kWeVIwFlYVSGGVbOWaV7Mpm6SN8itKwr0+PL46dOnZ3vTmE/V0DQqoSOv2NJQmd/XB5kpgk3yjJFSitXBwY0HDx68++6777333q0Hb00mk2ha13VadOotyxjbvYPdh48enR4fnbw4OnrxlAvEkX2vusUVoZdPNjJYIfn8hxuxK7i7xpFe4X6+Ijyu3HDluiLUx+X6BJDg7lNSS7dhek0iyRO1TQVA90AAA0jNmwaLPk3HoIP/AehgQgZeujXxawoQdrIgJaq8Qofakhrbalw3gHF0Y5ssuP2TKwS5rrFduW1I3k9/D/3/xpYq9r6f4bcxSsrzYNxAHlwfySBTxs6hKzcPF/XXdUl9/SdmVyhx9dtuCgm+zeCKypGgyPufkAJASoLtO2+PynYAry9Y/0Y3KHEDvZJL4JWBIrvmEtheFQUApORZT9rCyJi6JsuHDw2BNq4yww4hF4gIHQqm8XSaLBGbdV5QIgjx+Otff393/nZdrfI8Pzy4uVyv/9nv/5fUOlXNvGeiuq7rEIA70fhlU7gyqleu02a/YtdWkXpXR0L770JUw9TMAMAhNU2rqphAlgBUxLoWtZ0nKXVWY0DDlH5FaECAXRq5ARM4dqxMhEqm1oB1oSJGjSj7nOXL2r64mMR4M5vcctk+Zdlrr93a2/vq47cy73Zddnv/FhQ5HM6bx3fii+PV3/8d+Hu/O395Gm5Mq1lhPsOcsqjo8OWzL1anpwXYSgLlNC28mYmEpolD37gs96lJo2qMISBispM7bHlRJtudTn/j5H9+hbx/tfzfMdHpomo0euQvTl4eTua3Dg7L3TkzSxuCRgzkzS/aNSNHjeeX5yGEic8L78ll6pS1A+anlEBOYPPZ+uSMgRpgdS6itW2jYtrEHCDz5B1Fa5Ftp8xV4ullHVUUuHXWqnHT5G0z8VgWRR1icoFiD8KWHFS7O/PT01PveDafp3p6RLw8PxcRAkJi6pMzKDUU0PSEVDJNgIREyOx5y0w0gCRLxgou4gbQxQHEttEYzbrqG/SOyRm7ddNenJ4QwMF8l8nFGMEwqqipdbBMAACYwjpIyXmSGFVaDgKq9hg+7VanUqXUXdLIB6zrBpDLckZG61VDUcosvzRhs8xJjj7zee4LR+x9HmKM0kqIZkagkOJuIs6wia2PMbatY1pWq7LYK4iWF0vK3LQoptOddrVcLNf5JC+KydShrdanZ+fH52d5Wa7Pz5en59/55ne/+uBhrBtd1aGqvc/rUCE5AIOdcvfgcOrzdr2yVgG9AF58+sknzepkfiuCR4hoEZQzy4Q4tU8ggw6HIJGHAMnW6zUzv/H47e9+75fe+eq7t+7c3ts7EOywnlJCfVVVAJBlGUSLFrzh3fv3Tl48OnlxfHT8omqbVJoEnSkywDFc1Q82fAbT/9HMAJX7CNemOLR3w4yZ0nVt47qeMfC6gf1e5XvJzOwt7/QdWVdXQn1vh6QPdZrHtYf0Kaip7nskO4b3jpinjoS0jRSR4Wm9ToxqlrrcWRfqSZGbkYbxJZO1BFoyWNtJwAGMysFg/DocWZXDh+MHwkh+IeIAzjvgGnS3pXVJ/xw9Z0htMTAgBOuK2MdLeUWzeaV+oF+SFXDlzuvb45Vq1vgh3efSWUJ4lbbdPFJGb9I2OjmYAhT9Eo9VxisURgAXY9ykLPVA2kMmx/VhDfO5onARgSoYCCEjIpCBoZl0m280bYAtzFRFAEuQWwYAZNa13+uAtIYdCVEC9JgBMarzNCmmd+7didKI+IMb+6GVL54+PT25bCNm3vc2Ylf85p0XMNOtNbi+zOMJXrlna8PBpkgnaRsp5p2OiqomP4dDEhFgBrPURivV3ah2PXJTUioAmCkN/azNkDwRMqemlGogAIpIYUKkAUJjq+WkCvOA8wZ8Czt5diufTRVv7L3+7i988PZX3p5lBcQI+3OpK96ZgIEcXcjlGmczun0r1JX9zo+yf/LD+OIUdnKd5tN8miu3BOXULc9OXjz/jCW6jInA55mZxRhDbBNlmDuekrpBxqBN2zJSQY7ZmYoo/NKz/8n1w/B/8v9bBCjyKQAsVysFEIK6qSNoQLs938u9ywAyzic4rUJLlxowBonLulo1NRGn/mq78708986QVJJlwMA7s3lV1baqW4uqBMQIDsEQWYVaxhJRAULbUG67ZY4x9wLLtmmlNSCUmK3WWPi9abG7u1vXdVVVSV42TZNYTFnmRZERUZ45VbUQQ4j1cjWdTjN0bKwKYkqAjMYK1tcEmmI0JSOXcpS6cCECwjhvcdQjgxIiftqBGiWokHPsvStyZCeMrclqtVxeXNaL1Y2dvaBibdtv1M1eHfYtERmS9aWGPMrs270Y2klDtky9CR2R4/mEfBGdD4f7fndnNp1MDnbd3sFhYe2z56sPP40vjkpw+7s74mgdgifLaWpmKbmH+ubgAOBFVDU0jWdHdRVNd6eT46PTnRsHa4nU1EWWl8WEmc8X52fni+Pzi72D/Z2sfPnkk3v7B3/8l7914/DW6Yuj/fns+enxT3/04688fnvv8EDABKwociTXqq3benL7Vrm/L4inP/3ZUw9HZS4t+jw5aIw4bxHYOBlo3UJIyg7marW+fefWex984xe/+8fefOcrk+muEQUAAK3rGg1Sbz/vXWJWamogITbT6fS1h48uTy6efP7Ji6PPgCkJOUWADgG5s7bTikTZSA4DMELonNEKHYQlAICOIidpi3Truw0MiNu29ZiVjf8ei6LuoQPYgnXYSGamoqQAkBqRIKgNOSVJm7CRNd+9hXo8D+otzc5i3pj7OPLrXAm7DJxWzIYoEgEQoKgNsm9jlfbdTYaqnMSHB+N5ePpQEIFjdWRIadr2uMDo+QNtx7JguH8wXDcnNw3gVckuAECOidl6FxEO5UWjJNZ0DWLlioS9riQNEYkksq8synDblY1xXXyPs5thCCzYlpdjAKnfogYTpk6r2j/QgACvR2S6qSG6Ma5lCgcMutuwEsMqQt9KYKyUpSvJ2oHNDZ/3h23bSQAwnkwiGYgCANsIikRSlXFiWygixB3KW4zBe7+zs3N+tnz27KkjQMQQJM9mgDnixHljQIuSLO/5bOa8X1ZraTftia+szSuXloZ2Qf3g0x8JbRcAQoggmnwb1hfTpu7hufPmffpVnuUaYhvalO7nnEPAEEJK0zCzTe+ZtHENOicHoYGaxBijgdx9en6fJ4+z8nF267X7+4e3b/obe1J6d2tyK5/xqkVFvHUIntqzc7MYfvxzV3r4XPVo0RpNfuFdfPu1I5T5/+N33R9+Isv12Q7qnG6W0/ne4csY+HIhsVmcX7Dntl20le7dPLys122/Mbz3qfSmbdumaRyhAMUYmzqwwzz36PB7T652cwWAv+b/N02IEHlndzfP8xjj4cFBiHHV1lFlGdr16XG7XB8UU4oyKydcZPW6ujXfWbV1LSoOl017slo07covwZ083/Gz3WIyy7KyKJIMmM5n6/W6irKsU8MLYnTeLDMPTHVT5c6VmTNQZip85mCnRNazs7aNEa2JYbGKmRQ7PlMG6N1RaUt0oZPVxXxaIjAZIGDbVKo6KfN5MXVIrE5iV11FoIimKJiguFIKHAACISOqAlhih7bZjeb8oMUC8sZS9HkGIpRlWZHHGE+Xy5fnp8eLi0k+mRXl/dceHMx2pGqi1l32qGPcZivdQU6MycATMxFaVyi3mG1ijbf/lT9OswmXOTgP93YP8gLKieW5FRPMc/McAda03rl4Lbu9v/qn/6L64qmISMaXsSlVUw880aiqiD7pTGKQ5wWYIOKkKMr57Pjy0k/L/GTZ1GGpYbqzW85mZy+OVovlqlq7vdnt+f1PfvrhTuZ/5Zu/uDebOOfOj49eHh998eSzy+MTQZkezM2zmE53dueAK8PK4trD7o25TYv1cnXy4w8XU1/l3mrISswcxsZYQQjTbDv/kaioMoJn//0/9Wtfffe99z74xnz/0MgDezFYV02ZWZY5R6yqbSsZuyF46ii5ruj+/ddOX5y8+ebj5fqsWjdXuG3X9xEhdSNL6eXJzd6JCkomMqCm8BMAADD0uWwAvdhOOxKumbDXGdqWTvAl/g/rrc1UG9i1dYTeMlRLCZsw9Lntn2y9NW/aZQKN36gIBsbXoifDD8fbcjzipHMMbvlxZcowqcSTFYxtowRsvYW6tBKDrkcJASZn/1gGb4mqL3nLFTIO5BrfNojwznbALZojInoyMxDtRG0qMrAOrH04p4NClhwBw+fDvMbvfSU9x8sNr5Jx1iso4/FvxtnL36Fco1uFrhxaAVAxQcpt1LvhCYSYfCRmW/j0w7BclmXQV5GIKCI5l2IEW4WswxxohK49ZKUxc9NW3ntCTuY7M5NDESVAU0tqTTdb3K66icJEjp2wqWob48Q7iVFDzJwnQDMgoio2s9msKIrQtG0IRZmh46Pz0/XlOs/30+H3ZOScmcVYo3pVYUBm9kSTvCCiZdxUyozXctgxV3J9zQyYzACJe4zebrexkUUFsBSZV9WmaRHReUvZu957AwoCzF7RU7UGJCIWZmRyGaOpN6kQpRGPxOxCCGhS+mySZWcTcDFadTlZ1QdNuC/+K7PDr9y4+9q338b9/M6jB3t7B7CzD4aQOQjSnh/58zouQiwpPHsxffoyOz6Gktw58esHq4tzgXLng2/I/Zt2eXL4m7+jP/iC1D5enNt0svvag/nDO2FdV58831d3fnQSlpcqDeUcgpycHKc+I8655MhJu8VMEK1pWmZGsiL3zPjdJ//DK/v7t+78B8pI7C9W8xcnp2R5jFpbvb8znxNBDMi7nzz9QqKqoy/C+lTau5O5tJUuz9HhZS3EMMk5iLjMT4sb66Y9XV4+IXgRlmWoZuhn7CaFm0+L0taWu3Jvmp2rhODQKtAViOQ5rJeld6sKQXlnNkO0ug2U+SnRwzs349Pn6ygIULexLbLzpi69y7MCRSzGBDTXNM3e3p4nH2NMgAWIOC2mSdW2KOawtYacQ7UYo5ETESiKvA5Y1ZIRlQWsg8P8qK1cu96f7hbkDHANEtDQk4bYSn1Q7nCEVd20YJAxM+dMzY2C1xpW+oNPnr1EWVoTF8u3bz94e3ePAD0QBGPyvvRAlBXcQJMTO0OLUcHMszhrQG9AngrlQxOYqNZQSbhz7wF97V34w27Jsj//Z4FVl5cEEKOhKEqUxVKPTnzdwrLWi9XOjQmonP/k5+effcrreuXQzObgLmPbEGVZRgAxxgYV0cQ0RJjNZok5KBEzH2QZEM1L/2xxtvfwtRfnl8dny/Vq6XM3fXD7xU8+DOv6/XfeeeP+fW0bCe3qcvHbv/3b9/YOvPftenXn9r08KxVxOpmB8oq1MWzi+s7+LfvK+9Wjg/b3fndxdq6zG4WEo4lMahdcsaJ6d7fM2uxscZ5nBBjRLKI4lz1+5/0//id+9bU337xx8+b+/r6A1XUtsQKiPMMkTlNDMeecJphHwmDiOVuv1llGyHT39ZuPLt/++NkXy/MPnWNgU2kT+lkbo2dPRjFoh7PjCAgVxMDAHAAiGCAjY4pGEWDQDUAcpAYKAKAo0Dm04ZqkHJjzliC5ZmLhJtMCAMDAEqAVG2xyMYZgSv+TLieja4WdPh2a3Zli/5UqipGBHwTbSJTAKBIN27Iz9x5SGE51cL0zc+wREZ1z1lftenbD9LtjOLBoNRyQ6UdiVXrTGvsCCAIcQOGvUzIlGMBI/0jybvAu2EAZRACQlExgkN6FvbleAocYQojUvTS58yG93sx6l03yUmz16LmyrFdWELYt/PFaq6rsJvfbAAEAAElEQVQSAiKN4C4ZwDmnMVXnamqZMVpQYyKDlAq6kYYRQgRD5KQFCQgRAysgWhBKvZ6iGiIIZD4TDTAKL3TjZHLjmHGq2koTGMOzj+d8xdYfq2bXJ29malvhOu27yg0FTZhqHqBzPufOHx4essHp6WnKbCfHwJRRweQJHZEScAwapA0hJNfCeCTd2BL1iQCgaZqzszPyLoTgs+z6Qlrvi7ui8I5vGCn3Y61wQ4p0w6IJDqhA7wxAo5mYEViIBK1EiUrkMmQffWZoMcS2mrJzzokZOUJWtapp6jc+b/fZP8hn79x6/e03Ht17eH/v9o3JzpxdBgiwutSXL+nJKVTN4vKibAWXNXx04qaMX7tDyxXt79huGX/+zM8Ynp5Nsxy++3j17TvTi7b5u//k/ONPbrz9RnuxnLQ3b9y5nb/+IJwfX3zxfJ/yxfJkubxc12vT1iCIRCJS63oBmFkIwTrIxZD4poiJ2K9dq3T9rVv/x44sUaNZ5t3Bzmy9trqp1RHhPMbYVI2hOucOiqLWeLFemQgQZlkuBGYSQkAxIkoOAWbMM7dTTFpt6lYakGi2NuUqlNU6Z9rLs2wyzRws6lpFCl+gar28qCDu5jsTR8BWMM18gVbVVTV1UOT5vZ29p+fnqxiJ6CKElcQ7k9IV+WRnvlzYel0xMxIenRxPnHPOZVmW4hHe+6TsqohIskvEuuYmxszrel1gBoTRlKMURbFYLV9eHBdl6djarn4LHMI0kGupmR+erC6dp8nUT6N6zq0sLqP85A+eLib0VOuXi5e3Kf/q3q3Duzdv3rqRxcAJ11lt1B0ZXGOUoXoUcmjmDcu1TKMdw0XuM08cJRAIME1ms3J3VkxlwMZp/+bfRZVQraUN7rIeDoNajK3QqgmL1ZOZX4TagU1bCE3TevTsLqtVY4KITYeTG51zyCAiUVoI66gQgizPL8k5MPLev3F4c1mtNbScz71zh36/Xi0//q9+8MEbb771xhtlmR+/PPrJT3/05Mnnzrndg/2Ty8u9vb1H7zx++PCR935Z15MiN+Ssrs8Wl/j2jcm3PrBvvxPUwh98dP7yuD14YxmkNZtxwd55klaiIyqLLISmrivv/etvvPmt7/zS17/57XsPXivKKRHVoU3J6exYVUPbcpbDq67ECqjvsrGzs3fv3oNHj95sz88uLs6T6dXGQIiekw9YGdGoa6nRGblmRDju7ZI4rYgqbwJkA/s1tZT8ntZ7LCOHJ4wZMm6nTcA1MWbbUYMrf7xy1umrTXu0DnfBEitMjSqHpm7jX/3R11BkMGbClnweKTldBFLLlb6ycosyQxY/dHWwPEwZAQmxRyXdPL+vdLUvCUlcJwtut7UaU2mc0tF14k1X3/8opXkOTx7qLcb0wVEc58o1fDUkWabHw7YE7AYwwMuOmq0mvcYzJ8iHFJXopDMAWh/xJyKmoaejdcioieYJnIy89yliAKMQkoGYORHJsixVvGKfGxpCcGmBR/TVBKwmo47V452nI61tvABMHizFARnAVNIipgTIVLmwcYcQ4aZZLCADhL4LX1VV68uFmdV1jYguKbyqTQxpVNjrQ53XRDYuL9suUkpUGyDDQTXLMttWiQan0JZbb7TPhq1pI5Rc60JIeuU2VZtgYSYRLJCyT4UmoAgq6AJ5MGcMRnWI5ybB5GB/YoiNxlhXsFxNV/V9yh/O5r/42luvv/Hw9XceH9y9AUUOTSsXFX1xurw4n0U9XRxp25aXIS8LkcrEFuu2XC94fz+bQJjP1oW3NRXlrp09wxrXf/KNybffcMcvT//BP6c/+PnhG6/F2/Ps9v79m3vrk8uLTz46e3kcLhYTdBeLo9V62bSr1IkNCIndlda1Ke4mEs3sV1/8j66fit+685eJOARARCY0i6qRgWZFbiptvZJWQ1OFJgJAiNFlOTRx4kh93obmYrXUEGbeF+UkrtfpRJmZgoAZMxfe3V/L2vGF6RKgRSuJCR2qrcKqbkILlmXMTKYBLHi2zLwLMbaxAquVplOeQjZxsIor5/lgd7qKVXMRjblRqwzz1coc3bt9a7/Ij148D03rvVfEhKnvnMO0L1VBrW0aRwwQ00ZDxF7N1ozJOw6QMSGzM+efVy+Oq8tHtw5dmUMdTSI5FoQ1ST71dV2XWT6bTQjgeFkft/Hj5vIn58erqNmS5gxv337wzsGNh5PpRMGpxgTBY2am1Hd7DiqkJiGKooAQABmxACtOskxFYwflhQAQLhYv1h/OfvxzgN9Ig179p79JjgWplQixizyrqiCQYyJCg4PzReksInnvweeEamKTskQJIF3iOqFzLkNEie3Eg8YoIaqgKqXO9bGVnaiuatrlarozOzk+ai4v37n/+i/++m9QXX/284+OL06i6adPvyjKsizypy9fPLpx44233tzdnaMRerc/ORDAum5Xy0ub7Bx88134yuPV/qw4PcMffHqOYVUWOC1zIa20rdZZwc16tRZJCK2P3nj7na+9++5777/z7nt7B4d120ZTizLIBkZiJkcbKfJlAkBVIWpZTO7cvv/Wm+9cvHh+vriMbchyhyaI4JwLIaFFdR2UNpmMiAA6dBNNyTW9iwI33m7tLaIEfNFLVh4NZix1BmZ1RckY/nldvsJWV4RX3EDYgWBqL1C7VzCZdfmnKdo4Rv26fo055/jDKyGMYfyDmP+ymY6l9cDhoW9+dkURwdHUElDfeFRfNsKxyOt8dSOUM9hIiu6HqYdZlxbZj3+sbcC2ljD+Y0z160oPDBHS7ayUKz+5Mv601dRM1QiTGpLUXhsScpPE7JSkEehc0jYY0MSiCjkuJ8VsNnv54khVk1MEAHpohNjPwsZ596rqRAKA395YqZx1S327QpdhnqMPeTRtE1DriX79IWNqdh0mzBDRs+NyUlVVGqUvcjVLoK3eZ2YQQkTr0D8VjZESFukwvUHJUFUNse2zKxC7Rm4DiOp4FYejNWyXcUJoPy8auwGZWbVP50TsMOoBCgBl15ApakBUA2qihRhTC3tVgIARmHGS50UxfXnyRVmFG0t708++fvjwq6/dfufOvXu37zbv3MyRoW2bxWV4trbFCpZ1Fmy2jmDtzGsWVc9XtDfbPbiJJ5f5xWV7Z7b78B4U02xSxMtV9mwBRycra8o/8e3Jn/3l9sNP89/8l+0PPryc0N7bDwXaoyef4UW9OD6tzhfatnPvm9CuV+dtaBNOKDoiIs/eOScSB40zEeFXnv8l2L5+752/E6p1rCuT1Ey9qz0iTO2CxcDKwkVzq6pZXV60Qfb2D5uE2SeS5xlMeVnDumniOsJ8XuT5xPkQG1ADjW2MYsCqHsEQdssSQdv1ooqAmfqMPJAH14ZAhLs7M0dcr2qHLi+LEGIbQySgolhlEsKlN8yZwAy1zTA/2Jk1oV7VEcgDZnV9fok2LfJJXpiZiHjihPQ57A0VUW3RIMaUXUvQpX0ggBiIiLnctW0blIAdgjuqV5+2izqnrMiJUKVlUGSoowRAzNzO1EWjT04ufrxcfpa557k7Ctqw38njt8q97012H8/nhvWqWjatxCoOEF4mGpKzF9ImJ2hNRCxKJBTvasdAwMvovS+KAjyoRlTNALEJ7ciC5xs7FCBXt2N0WWKJrhA0kUbiyrQhU8bL9Xk2nbYhVE3MmRmdRhFVX5Yi4tJhISRyBsASpxnFGKMCEBJxUZZErg7tlLO3Hz745PI8HJ28c//+7Q++Lsvq45/89OknP6tDW2nE3KuqRpmXswfv3ru3tzObzmLdxKhTmFZNWCzX7LMzrfdefzz7ymPDol5U+dFR/eTZxY2dpuBgCqpgyhSLMltcLBd189rde/cfPPzGt777wdd/4ebdu5hxqxLRYmiZ2bNDxBhj27aJn8CXXMk/myRECCHLivl8/vrrbxw9/ez5yxdHxy8AIJVQdrzRrIPXSTqK9TEIuSIhiMiBIzPBJCr6WubhGA68V8x4pPrYyF0xnNZxzH77RZu/x1LgyrcbWwvBuqoW0FQCiWBjz7dupJeZ4Yh0g9S4wn7H7x0LbBwZeDbqejPcecVaHl8KNtTdAKJ1yJ49Nx8c2teE/R9Bpe7Jqmlv6Ca/cJPsNXTC6n7eq0pDiOSKXwTRXVeb+tyYq9dYvdARFMWYaFdomKgj1kEOW9fOHFuVXvHBcQv79Nhu24zzLBVTV3tVSQCG/X9EwF151agnX1KpBwxA7L1uDgDMBPq+x8OLh5DYFUKPtaorSzLcnwpPEqE3bcv6ME23Kv0+sa6CtztFKWnDOUfeGUDbtmaWlQWk9lFm0IPzo6ABXEnPSbPKskyaFpyDPghnhKZdRwnbTtcYFiwprdjrocO62siFhRsAYFVVEbEEWdhNESqLjOyBvYAJEKDDCXsyaMVr9FGlobouVs1OgInx/+Dm668/fO3BjdsHBweHD27D4R5gXLVrXS7joubjy3xZ50GgrqCuQCx4gIygVTmtMMvsxi5mHs5PprXC7UM4uBmyCVWa4Qzqp8uLp9l/51fpV75X/5c/l3/2Y3n68mx5eeeXvm3z8uj3fnDy9IijStUgaO4RM1i3dd0su+a9TMhEyNY1AEuQOyoif+LJX7hyEn77rb/NTCLSxCASPULVtnnhk+teNRIaEnpEY5yJJ7MmxiZGtZhUQHMUY5AkPplWUaFe6yXe2TtUEFZAYB7aPgI1c8TM5SrTSFpriLJwK+95h6fkMyAKZgLs55kzM4T9g+nJ2dmqWsa6Xq/XFMI8K/ZmOxNiFNOqnWXZjsuiVoXjVmM+LTN2y4vLtZ6TQemyVKk4mUwx9fdJ+8HAEbuMB+hY7JzcPccBkKBYZuaY0b9sF08K74v5Sb30jqeMHmlSTgoxi0CR/+np0UvCnzn+fH965gDW1UPw7+7ffFvae/s7+2rt5Yvm4szaiMVksazQkLpuIF1Hq45NYyBAjy5L6BzEYBhN575Ex2gYTTEYExTsYwy43Hg0g6Tu7FqUhavPg2LVtI1EcwQAbFQ6v5vvaa3Ieci0lljMp36aryXkXIhIijoBgBlC4sgGRJTnXkGqegWMzjkWDqvm1o2D3YP9i7Y5eXn8X/3sw+VyvVwu333zwWK9+vz501jJm6+9NsvLezfuvP7aw/bybLFYOEYHvDq9ACImhqg0mbh7N8N84hd+j4pwcfH06MX5bBocxlAXlJcZnDdNtQilzx68+ZXvfPuX3v3aBw9ff8sVE+Su8VWZ5Qk8LUG9IeLgH70ueK4zxgTvnWXZ3bt3X3/r8cvjo6peVatV5tjM6hCdcyCKCAzWmStmBF0K61DgkNpxQp9aB0CooLCVk9FbQR0rlt7PMUaoxL4qZGB042GP9ZLrsxv45BWdIG0zGV6NnVsiiRruG7Txl8Smrw8DXqWCjG+zL7HdB10KrgWVYFs8pVxtHZV6IqIN+OvX4hfDM8fjH982VhquXCn9Zahm7hSKIX9xO/ZxhT5XXvdKco0XYrwu16+rcjm16GVCRAfYQj+SQeszAABLpVxmeZ7Pcw9n1UBtRWZG5zKRYKLr5bppmgTcQEjJk5q23FCJkmSxcy4V+pmZS+oDAiSFtV9qQ74KlTrendc3xzBtSclHmCASLJoCQGoIAn1J1djFYbBBwxURjYJM5J31+mPy5NShNTOHxEQ+Ze8zJpm/ie8kQgOAGSLmeW5mSRU129J4hvUYNoH211gXubJyMNr9qckRmGDnibKEVSyMGhVj8MjAFB0vyCLJRAOtqvJ8dVCHt8udr995472Hj+4eHOQPbu7sH8J8oqFd1zUcPedVVVSRP3kJABBFQiOh1mqVt4Ls6tf35ru78NlRuw78tXvhxl710Rf5k+Py3g68eTd4duhX1MzWq7OXz+2tQ/jOV/xPv1j9P/+/h/dvviwdcMboPvvhD8/+xY/nuzuqumjW0+k0z9xicfny+LnFkFqOIxNiKlCGaJq6Nf6xz/7tK9v6d978W9jXbZqqmTUS1yIny8tbtLc7nZqZiVnqb4xooI5xJ89bn0Vb1utVrNtsMqlBTCIAsRkaCMAyhPbivI2Cop7IExIoGqRG2IYQFrUh7OU7WRYvY1s7lEnxdLpn7CJBjEIGnpiIROKbk73GZSyHTgGriurGFFctmHNZ5lSjN0JXloXNpkVVVZnLmABNHYJzHNtgijs7O0VRxKYrPUWi1JFrXJOmqSGrUUqqUoHMOZhkohQbfdo2n+cZuOLhwf6d+c3JMtDZYnkpzyB+VK+erpcfHdz8oq0Wpfe537tYfiD8/Z3pmzndjtPqcnG2PGskekWPzgQiggMw7HqyDqfSEcfQMGfoHTuPRNZGawI0AlMXQCoNggDIGXGwUK/W6Deb3K9APLWMLeIku4NlRtOs3JuVO3NY1vL0hC6rYx+9ghDBLN+dlGCRHB7sllngEAIBOupK3pCBiNpVUEjNLWMTgjTRTNq2JiNZXjD54+Ojj188b5mms50sc8fHx3Vo79+6c+vwxo3DQyc0yfKjjz7JcmYxBIsiCOCzzBUl+7ytF5O9nWjgiR3x8uL0LLbibwCZjwgxLKu2Rbl3ePvrX/v6e9/73sPX37537wFxtlit1cxMYwgmSORUJPGEoYfzdb4/ugixq9snooRYP5kUd+7ee/Tm4+OXLz5ffTx0dWBmNQHr90nXKM0AmKgrAzGjwWGAiDQ08u15bEqb2O4K3ukcAOC2B3xFJl2RZ2PGPn7U8H8dYWZ3LHoQ8LTh/IrAyYTuKPKlkZQvu8aj3Sjr2xEEuxZwuXLDePAdfBFtySwbFcciYspYvKLffNnAYCQIEDFlJ1wxwtMPAAANhi5x6e1DikJiF8N0xh6RMdGuqzvXFaNBD75C7StrurUBelQIZqbeS9G5zhIwq6XkNGBmGj0VCbiHESdgRQOBoCH1pMQuE8kAEuqMTqc7CTY60TBJYUxO8/HIhpmMAnlddCZNZLwu2OfrjjW+TvMiwtF+tUEpQcTtpNG0pMOq53kOhEadayQ5Wpq6dnlmZgwIA3R8FImRiKgv7aM0KDVpw9AjJ0rsdlrfaCd9tcnt6AMoY+fNMKPBRNj4DNMOUyNLKGTdDksE8kLRDBnRIUrg1aIMrUf66nH9xs07733lg3fu3Ll368b8cB/mZXDoOWvPLunpiWt0slzIxSWsa4oxVhWoNlXbSCTvyFObgQNxxqCm6ybbm9vt3SyG9uQsu1nK7pyaGp4cIWdU0vlPPz//5OUb3/tToP7kH/z2ntMnp589/dlHX5vePvnpR2ftRRalOb+4qNd7Nw52d6br1WJ5cdIuL3NPv378N/7xvb9kvU2gYN//6N+Ea9dv3f/riOiyCQLEJsY2iMUQQtU2VdsogIK2FkAFCc3QVFOszRsyOnI2y4tFbBGURcBjiZkDF6IgsvcGABri0XIJYBlADshonqkz+xRbAMlznWbrYueccMUMWfHJ7nQd24BIjlEMRR0COv7I5dErR8liQMom02ziHKntNqFw3qOfgNFkknlSxyzYNjWaZY58lhtokNZ7z96ZGTAxICGCWPJZWpRUzWSpVQpw7xGlINEbhLYmzi+W1bOq+nDK0pqeX3zR8N1Kabk+A/k0s49n/Kwsy91SV3ZH7PG6/Zorv7E7vYm6PH56ks+gDZPIRTFtGVdtQMfzvRuMkobUZbGJMpH33mwn7eRGJYrFDLHw6Pgsm872d3FacFkCcVQsfLFrINrA3+pWducv/pu2U+rUq2df3IbcrT3oNJdpYas6Pj/LquiL5V42a6saGXzA+Pv/8uQHP9ljDMBqUUTrNoS2TudFROr1SiSkI5lciRJj0zRZ4c2smE2PL45PZYHifMhY5Pxs8dYbb7527/6sKDVKDE1U9Y6aGEQkVE1RTsvdeSMSQPZmpSwvS/ayaiNOYLm4fPJk5anK5ioBxBjdzuGND97/yre+8QvvvfPB9O59T24dJVSXquocMyCx80ytaMYOsq7EvY0hHXA/gn4fX9anf4lIUoXbUGVZtn/j5msPX3/x7Mn52cnq8pIceu5FSCeHruHAqg32N6asWwGmLuZCABExYXV3TGwEZzTImIGtjcXVf51rbEaOGPOWp6FLUOrUq9TRzZI/mwDZELsmFQCMsJ1fAttidWCnVwZp29f4h0k2Jy59xTIci+exFmVqwB3ACXZOo42HIMkt9yVBGbgmyMcvwu1ExuFbtQ389JCqOfadD3S+oj0M+sQw/mFGYwVinFv5SuqNnzn83I0yBJI1DtQpjJ1WoV2dtkhkhwDQNM2y3TycqROdiZjMHokYIMbY1zldDcylP1JQctDg3ZZ+h4rQKRCeM+sTXoblR9wk2OB26AGGvAcdAh0gYCl+2fWRiwLpV0yw7ZQatlEbghFS0gzAQISSY7NDWgYVAVXmVN/PADQmMfVgGElTGSqpBEyTJj6KCG6oyTz2UG2t9AjxfaDaiL5XFZQdnEbiyNI2y+x08WAdfnF++4Mb99763ju37t6Z37kBZLGqYxX5yYVrNVaNLtbcBAttXV+EtjKpY2gUpOAcPDJRludZWZiZSfD5bLWu17G5eXP/4uJs8uHCf/Q5v3NnkXP2z38i68sjq/emu8dPTlb7O1YeXvzn//zZZx+dQI3rWBp9cXxUVs2qXM24WErLudu/cRDr6uLkGOrmv7nuZM4vP/0rAPCP7v+lX7sWPflHt/+q996zA3CqWjW1J9YQYts0ITSxrWJbqdy+tZ/nPrQxNk3Ozjmfzk0TGgAEjWqQeV+QMSBoNGRE9AIxSMFclrmYLtsF+tw0qmprygamxqatWJ2hTier2fS0yM/KyWVRrlzeGABPKpRIAEzIRgqOAACeszUUs9yXZcGTCaFmjsxk0q4p6IHL9oLuoj8kwboqzLLMi0jQKNUy8366t5PneaOtBGJmYiZEIGN0DBhjNDVmwJQ93fl7MeHTo8U2hp1yqgo18iorxM1+FNZf6Hmm0Uq7ML1AxPyQy1v5Zx9/tZx905df8e5+nmWmTd3mk/1I4LISDVaA4DmfUkZcsgeOsU+4NjMJ0QF674PPIIiF6FSgzP3d/ckbd8s7N8vXH2U709YRTSeU5RaNzUEbIC/gb/29tMTVn/3TLJIxcQwto3fOx1bBoPChJDgoKCv2mgAKmYTWQvvs6JKgCq08XxgIM5NqU9US24wdgFZVFWSJiGRshhYVzBHwBLPV4rKcTqLKeb1wPpvNd+7v37q/f8ux3Tw4jHVbXS6r1WoymYhq1dRuUrg8y+cl+6wx8fOJn06PLy+hLLQNcLxwtw+1bZfPX55pOAZrW5lOZ4/fePz2++8+/sVv3T64vZsfLMmbmGggQpc5k4hIGZEGS92tLUo0TYZsh/6prxbeKSCYTNXMO0RTjQC6t79/586d11577clnHzfrNaASUdNW3Pn4GRGZCXrEJNGhiqGXZEYCogoImLKBiSgl2MEghBBRt6TO4Kkd7hlYK4wk0BWt4opkxT4Wc+VbxL66squiHOkEBp2HRtQAiFBf5Ya58pYrn+Mo6WT8ISJKiJDwG9kBQLRoZmgjKNbtRzFi3JbrncKBm+7wffLNl2ZLXKHMFekwVsWuU3WsXowFcOzLVcb3w7amBdCVxdq2C8q2ccCvKGTX/2lmQcSPMSlU0xICUqqCNuhb+ICZGbNLiBtXCGJ9CAYQzFA7TPdUF+e4j4d0AL5EVVVhf8HImHeAXX8EAFAks4CInLmh/njQ35OQNqKUCUGIrUROxUdJbVRFxNJlhhBU1Mw5lwGFRGIEIzQiRBofXkUwQgEDM2JCn7dV7QS8c5w6W7rkRVBUA0RyDETg2VKbTTHoMq/ITEWCgRiYSOdSS5FRh2Rg0kZyRGjAiGQCJipkoIatR4jCIhkQIwGSIhixNiF3zgCDRVVARiQBFCidLRXXVM72V6wVNPMJh3r1XI/KVXVwvv5gevBr73/73Udv3Lp1Z3p4CJcraGP89Fm8XFCMWYLFbuq4vmyretVEUkNEAmLniqJERFCr6zqFAVsTJMqnc/CcndYX58sjfXb50+WLT58/fvw47O/Hz1/yxHNxOF1XR4tFnYNp9ZPf/M/oxeL89AjJ9nd3vFmUeuFtEvUkVEVR3N7fbRaL45fPLy7Ofv3kr1/ZZL/65K8A/BfDP//x3b/ab0QFEmBCI08WQr1u6ybEGOOyWqrJ/rzcnU5EJDKRz6IaGzij0AQkaFENRdBMsQDLEKMoVtZSiNASAQNYXamqA5umpHckJDYAATTM8sy3B9PnOX02L56XWUO5dyUit6FlEgfqO4cK5JOCiFZ1lbWSu9zMoqqhZ+Ya0MAup36vKS+JVrNmMtO7Dby9OH1n8TK2DSFNXIkiQGYeFMQFY5+XZQmisQ3OZ2bWhOhzn7qAOueIBqSmmGXOmbfMU7Nat+F0wm1lk4ifz8m1Wd2Sa31d+mqXSda3z4/fOD75Hrm38vLxdK9UqdarSmLhsmleWB8xydNeJ3KOmbERZHSI6Mg5R5onbsUHhi8t6MPbN771Xvb2W/7uXdjZbcyc5SEECIEMqTUAMQmGgKG1f/qn8Y/95wAw+d5/Ev/B92No0SCjHCS6ZYVtC3Xjq7WprNran160l8v66MRXVTi7OPn8cwxhsjO7iFWMUaMCABrVBokrmTkkksSwPBIYkBLS4Y277Jwgfevt97K83L9xSMSxaUvk9nJZVVUqfY8xIlLuc+fzoshd5qu2yfNCAUIITdMcvvm19tEdOry53OfZ4qz64UeLZZW9Q7M7j979+jc++Oa3777+xmRnl5nr2DppEXomKQbAatCAJXMkeSBc6kSllnCjupaYthEw6UqudQDw3idZ68ibQITm8PD2ozfeOzk6bdr18yefzSbztooJHQK4RxTsre+uegLRyIKGGBQR08QJAYZUzS0ncXKnAWJX7UlEKoDITIxdky3TKABg2HmL0y6FZJsioksZPwBAmlpuJrNN5IrIt87Tw1FVoiRfixEydFmZnU7TueSBMdnAV4M7g703SKPhwySr0udDwCJJH3Jdz5cgERHJsZmFEDLOxr7nYcypnpEQU+nxEDrRUWdg3PaRDIpaKqmwUcrFlYeP5fowwTSFcSrCeO7UV01SD+2FiF36Wm8Yj180Bt3qSCeqIkgbPz301m/3akRDtAFrBDFhJkGvhiayExMAEJqaJnQlMohRocvA7ciJ29EM6qqKAbiDhwMAMyH0ajGE7repnsNM27oBgK7z8Egzc4O6Z4ZRoqoyMwIhbrS/Lc1uE6vaUtwS4QgQiaAHTre+1xoR9RHKzRM6ahLBoICriqj3vvAZp6YkRIhYh9Z1WRqIabxBkIGtA1fpEpg6l0O3bAkjQUTatk3AbcwsEr1zwBRVQDXF+NEgr4W8g8y3KrEH29EY0dkKzAyQMc+ykrwXtSaG1Yp95g6nF7YShjkBvHi5t1z9meX8G2+//7UPHt18cOPg4R03zcP5onrxAtctRYVVg4sVrNsYWmlqbZtmghKiqaKl5htAgISOPEkIzueeHXu3rNbruuIln774DC8rqgNcLiAIHuzg2/fJ8c69W8yuOjk7P3oZ1vXM+bAOi6PPm6Yx06Is0vmUGAVMLBLls/k0y9zJycnJ2ZmEBr78+vs3/s9+A1zZa9yiplpLowohxrZt69Cqal7m8/ncOqwOUZGENZGxA0955uu6VgXvvBK0UYQNs9xVkanjUAAgBqSKqnP1kSmyqCpG9T6H+USm5efMxxmfs1+bE3OMzrP31tleiBhNU6YSEbVtmxFvji6iIqTmWwXmgC6CmmgwuCA6KcsL3Zm0R04lGmREgCCiYsLIqjHGFiC1pRKELmGTGQG6Nl1mZpDajcM6RFbMmEhhAkhVk5U+l6BqzcStpyDWztbxUavftvKrLnt4/3Au4OomhAZBfEYq4XLVpLyzBLwG0NcfEjmfdwy0bWLfEZ6ZF22QnWKnzPO2CT/7efujn3shbs1eHkkTpambKKRqIB2bKg+YGeAg0b/6y38bgjCi5JmEWF9exroOVV1VK9FQt+1qvciZwrpCiaV37NB7d9wurY2qKpJgCskhOYfOeelgHzv3JyF1wP8hEtGkLLMsA3bWhOV6UVVV1QtFACDHzjvnvHOuMQkSVVBMSRXMxaC+LCZfec3v7sHhvhZ5/cPjCzX3za998P0/9o1f+mM3b93Zu3GL84kShhBMotkgFq9eX5Z6gH2cG0aS5o+6VLzPDg4P7zx48Oz5p+fnp1EsL7IugQMMwIgQoO8mkbCnANHA1DosdFU3gKtg17ypF5wb85cAFFPzKu35LgxsMHUPQaaEi5qsT2Yuy9LMgoZOrPYh8rTHJATobeIxq1dVTIDlAICQBv3Ka5CCY3KN/7YRMV8pzsef2DVcijTaOMK3GD7Hvr37+I22ybLq0Bmwd6jASCQP9wwK0JUBDwrTK4dnX7JDxnrG9ZleT2wQ6/SDIcGxk6qjio8xhRFxaNgziMNhOsNbhl+JCAM65r7ku1PauoLtNMJrrp+BAuOZDpE96zLYlIgQ+Arx0x8u7VEi6iDLFTSVwGAKd6UJEHQYIeSQErAE9skQg0KaRrjlu1PTvrNLwjhPacymOmxTJOy7BKTgEKtqG+oEwp9xBgQEyt3ONuSE4WGExkT1gGk/zC3NXCSEdGoAwJgTwDQyuSgCIshEgBJFQTJ2M85qkSaqoEHXdhNRjRAiWDQzVQhSozaZg7mvXa5ny+nxYreSaRP2a/nabPc3vvWnXvvONw/v3vQFN2endnSiP1ni2QrrNtyez4sJ7O1A5kRP1/UKGLLZNIOAmSMisi74So6dcxFsWTf1uso9I+Ll5eWqqrz356tVJpDnOTatM9x/90164w58+EKcLS8Wp0dHq2rtFCCKVQ2tW85hZ2e3KMu2qap1bVHQMZMvZ1NEOz8//+AHfxoADH7l6ubqiPkr//DWXzBDI0yqIRIhdF6xGOM6tqq6btqUhOzzbDKZlMUkrqsYYisRABRQEziEQQlOgQDERBMrVGZjnOaZgkXrjj0YMdKEvTOKJGbCoiXnOpmd70xOJv5jniwzWuRZIE/mgDyRI2dNUxMROlbRKGIJacc2nDplF5lZNFPTXIoGqIVIBoZ04l1O+b5M38pXGprQBM44K3I0UoFoQBqsVYLElhwREVBUoSH01gHDKACqqiEIWEneYtwhOgC9qyJNdVLkQVZ5kBu1fE3pF4v5u7PZDcerk3NWkxgMJHpA4FQMIwKqGkIYTCICdM5BXTskVVWJnRlkEQC8kB5p/OzF2W/+9ur8UqrGATKo5AhqoEAGYIomRCkhqgREgK79zSf/t78jIBm4xjsykNgmFcEQKPcZyNR751w0I+fIU6ui0qiYg4yJPPveBEdENDIEB5A6MiS2SQgoABBkUS8XlytVBWJmNgUiwikTEfQQt8gOHKN3qCCIYMrkiBmY1xp3Dw/DrbknhswROTtrd9/7+uNf+mDv23/i9t4h+0zQxc6Na0TknIvhSwsNvuwys/8aikZ3aQz5pNg92H/w+ltfPP3i2fPnZy+fe3ZqoB3aKhEDE6qCqVnUsUCy7UBAusYiLfFv2qgVffpd//lG8lHnJBgYbJ7nyQxDxFQTmY76FanZP3jTAD1tsIR93WcaAgIMXdehr0/5o4lzRQ79ETrHcNvYuB2nDA6Cfxj5oH8MxKQejQNGchp6Qul2tQ6OvEfD26+M7ZUDHsTwWMYPn48TS69rXdfpM1QbgVlMSl5qS7ad5KEDDAQApqxP7JqqgSbQyS3qbXaXWaowEpFUMDXcMJ7LaJwwptt4dte2KCJu9YtNv0rpxs7MALs8dyICs5QXPRbhYxKnPxi6siLsq1GS7t9Pt7tvs2JmKJpqVZIlOGQTGYKmStrkbAShxBSIiQDRVIRxa22QENRijEBDb2UdHT0CgOQgGSJB0CH3SZHnqhpFCICJOFXEqQbSGJUAplmGgLEOEIUAa0dZlDk5mObV1NqmKs4X85U8qJp39u+8mc8f3bqxe3OXbu7e+uCt/Tdeqz59Ek9exmcneL6y5bo+Xbh1KDgvvINwqa3EGFNjdyALpCltWBXMYvoqDRgdX15crFaLFBIKTQ0AjHDIGWQU0fzOtCHbeXDbzlarj56s43q5Xi3qNTKj98vQBAg8z3MKWUZR6svL83q5ytjlrvz2R3/u6haH/+KVOsc/vPUXEJG4Z3BERJTgTEIMMcZWtG6buq7NrCzL6bR0eVa1AUJs2yBg6J0xtSIxtDHGKWjOziFiEAnChB6wlejJi5maiokaEqojQnAVRWTIwRGjZbPFfPakLD73cFROArP6zLPDmIAvoogEFUYg2ToJRGSpV6pumHXSoEOIwUiclggIsCA4Aj5i/+ZsLwsLWJ5GUD8pGDyBtRJzhhAiIZoiY/ScEZFFcYSqYtY38O1Oo6aqgVYiGZa+/MrewSxzd1v71Gpq4i3Mv5rNvkLl/SJzXhbxLFuZ8847Fw1UgwX1QA4ceIaQDnziM5JcqKCADpOFRmiAkICZLiaiVctNcEGR1O979i6YAnByoWFqCBcjmBARiAgYrLp1b3I1A/DoUtJBZERUIjXTDKJhrFc+OgJg760RDcE5x94FRgAkTtgVJF0amDifAQD1NjQkEShSTEqKERFFjIi894iYZZkhJDZqCEAMhAoWQDVtEgXPDhRFrIpxdz7xOyUUea3ITZuVO6//yq9nf/z9bPYAQhSAEEUxCRsFA9Cr5vIV5njlO7rKfK+y3esXmqhEl/nDW7fvvfbo2bMnF6enCIZooJrCvmZshIhG1LfGgi22/kpplG64YhMPbDBFuAWAt1WHRNvVaoWI+/v7bduuVqvJZBJCQ50jpEeXiVFjHL9urPoksceEgwiHrhZk0yz0ij7xZddYrYGROHwlScc0sXHvtP9/3qZB59Bh/H2eH42UDLg2eBxBIVx/4B89L9wm/h9BileK8EHj1P6erqaXELc3wLjooUupSR6x9IPtt1rvuQEARjIzCVGoN3SJEDEmN0+n1I7G348LRkRDRNUEZYC9GpPMrU1ibPfefoIuDiEJhgwdcKc5UCfLhxdAj3zavziB+iflRcQxI/ZdYQf9F0DNUtJK0qlNlZkZafDhmMHgywIAiJAVGSLGGOP/j7Y//ZUsyfIDsbOY2b3X3d8Se2RkZEZmVmbt1d1VXb1w7ZY4DXJGoIghRpRIChhhBEiQZqA/QJ/mmz6PPlCQBlo4XAQSlABiOICG5Iy4NXtls1nF7mZVZVXusb14L957vtzF7JyjD3bv9ev+XmQVFxmQkf7c72LLsXOOneV3uuSZmdF5zl6ipIo59YsMRGxQanoFjWzE/8g12zL/ysdxRHTOxdh679lTjNHACh8QXepiDUJMDIhiWXJYwejcYeLGpUvous1l8Wz1TuQ/cvjwm+88fPv1e8dv3S8e3gn3j5332AKcbFZ/93fSBx+UUcqIIBLb+mJ9qYSLGcpHHwGA41DMKg4c27Rp6ja1LntgzcwsAw2JCJgVVeiaNh+RwYyZmYDQyLF5LjolxmWw1WfP7dnF+WdP1CJ5FxC7GCMasKlqjJ23tN5I08Y/9OH/5HM2yauagWBOtM7mKzMwU9UoqUtRROoYuxgFxAcfquCKICKbuq4QFQGdA6YuxSa2UUVEY4QjruY+gAGrkSKAoVGSznKxtT7a15IqGThpQzm3anHB/qnzT2ezZ1V57rhBNiBngMlQVE0UrJOu979mc9ykVGku4auQI0JwPHZ0IgkUQHqHFkBEXBM15exojnixjNJ2bfTAzgd11pvXzMxAzYwkl5dK0gEADEhnZD1NcgJx1GlCRG/x3ePD+4pfTBJBwelxOb89m3sR6JqYohebHx6oShRJBog+p7lj3sBMTBTYZe7QK9PeO+9UqS/NkePATOZdtFBZOUtglotqqnEXXZjlTpqCOXEijMjM0UdVHRWO6s5tICiKItadI/LZtmykqujYzPDAgnM5j92SVEUVQikiyHm7mZgQGQ4ggzCYl8gxu/5IkwCiATrPzlHeod6bmZimmLz3yKz5kEK9jc0hao4OYGbmiKDOucMDDx5ClZKigr9/5/jundOj+91ldB4AwAgzLLNGTcmMU47thSuSYCpdev5qk+BH27/mVY0ARUQJF4vFo7fevTg9O3/+/PLlcxxkCQAIWPbvwAT3aBClO/JvZPSvkluZ4WeO3UdvANEgYwCg67r5fD6bzebz+e3bt1erVdd1McbsaybaoorZrglhFC35e8b+kMmIAn1dNLsuvfbqRL1KmXhVm+o6o+yfmjSymJj2c/yQLTE5WSZ/kzWwLqXemZKS7ea8jC/dE6t7Y9kbxVSyfv5Ypos4dnX8aSLCdW/d+wK8GUrjFc8f4F8N81ZFMM1qys7yjW+h/kV9Z/o5AUgqBL0cx4lFb8RJu3aktm29OY3Z2+irmkymGxYy54VOCW48B8LwwQBs7EQfYjMsychTxukDABBF7qE/coFvMWNAcgxjcThR0K2BwwAQWCS2bRscO+dAJbbtLCzIuzbFqILIAH1lGkYGVM0x3joeLVEtgQEgO3aczTAqScSzSykhk/deRLI7s/AhgQFASpYkoiMXnLHV0jxnXbxcvfEyfosOfuHBT331vS/cefNeuHFQfPz88umJ7zr46MnZs7P68Yvm4xewasKh1bPSPMcYNYkrvFXlC5eaywsi8lbwcp26qDERQwhhuaoBQAYEXlDNZXVSbLZ0YMaMTASil2yFwm0OTdcWTC//4IeuSWsvDsB7NDON0YkyMKT47Q/2LRlX239z/JcQkRz/Pfq//Mqzvzb96f975y8SETGPQdEKllJsU2zbuo2dqraiBhKKIhQOyLrUZjsNFx48E3OradXWbSfIQIydwbJr0eOMmTymLqJZQS6rkplVRjM1E3ZCOE9lzcWLsvxwXn1SlmdFaNCpECObGkVBVBFRtJxBZYNmbwO64pBIhlkjnTILRIycsm88mjrhwMwI0buzmF4rZ9Vstmk0pdSmWMy9mwU2QURNAqCMxMwMlqv34WDzBIARAFRVGZiIogjGduHKBeBdxMXiIG4aS9E2l3WSGGPF/kZxcBk7hbwBiQw9ssPMPhSRECipESCzY3YAYIiGBAwEgNz7KxlYAyEiCJAAM5PzWbGVZoW9N9eBEZkjAyJAClNRMJ8dEZEvQiyMmXM8eDYrMrKqqkURMeLyaGaISUURY9cVTDLgWIzsyQBySoOmpGomRo4hZ5WjISEQ5jDJ7F8VUByNlpkvD4cZIiLHSETkmbyahMXMHS2gEwViRUaDW0dpfqgRS7M6xrwiqho454b0qER7HLP/QEgTjkoGOkhiuGL5+BwNgLhQM5XO+/LunTuPHr395JOPLpfn0mx6RtxDZuXpgZQ9YhODxJ7Am74UERHYYKy9MviYB9VoEA19CocphhA2m02W0BcXF+OoM4eB3RrlU9Ey+gKGg2beYJBjC/qgFusZb74AJuL/ahvF6pY8rviPRvH8qnkeL9hzqcCwlNviZ7gVhzi4S7K0w0kyztiBz3/vT9KuDtwm+a7XPnA6Xf3KjWVQhoNQX6138gqcljzroUENuI85VVVQg6EqxRiLk98lomZgaISUoflENYvnbOIjQNtllVfDVqZKDACMtDS+aJzZrcKRNyD0MHaZcJQJZGtU2/enZI9d9ihDzhyjHrNBhlOBA8q2C2TKvoypemViU6TR8RWqysgiaoZlWRY+mMTUdWZ28snjcjGLpp1JUZYhBEIM3qsAICDyUJUmP9Dm83n2XOSD4DYTuuAYI4jk2qfZBikiaCBgwuxCIBVar4umPZT4FYRfPHzwy288+sLDhwfvvAZHC3h82vz2Dz757neN3eL4Rt02Fy/PpWvVuvnhojGrzzagYFWAGwcxeL1YNs/O5scL1ZhSa8ye0URT7DbpssvlyDFrG0ZobABmIhkb3iOixiTMjM7UmJHFWmcNptBRt9pAEcBBNOtSoyl9+4q75Gr7B6/9lbbdpJSAkJkN1Tkywr9z6885Dn/q+V/9e7f+ossANY4BMcc0i0iU1EnqUqy7JqY0ugzZE3tOmpImBCKHRphMJaYmxU4EGZxjAFCgNsm5biKHwMyVI8kBlgyiuQwHAAoSBAfBf1qUJ959XBXPqtmmqCJ7VVWMTM6S5s1ovcswh8rLuKvHD8yctQob2UEPz2zgMERWpA5MDEkdoTUEl0CJyXtfQtmopVVMHM2zJ+e8F45m4j0zoFpiotTXq5qcS5AMLLGRqUNSSY4hxQYAiGDVgUlrMfnkZj60TKq6jq2CIpH3joDQzEQ7ECAi7Pm+iNgQSJ9XkxDNKOPQgxpQIubGBU7GKgEhsBeijaYI4meVAWg2lxlJzBY1CVbtAhKQGFjSmK0jiM45RKTgfQgE4Nk1TYNMi8NDM1uuVyKSLYqsmhPtVFUHt2Yu7I5ovXFWevYnpszgyPKIiKiTJCJlKNg5wx7vQcFQAAkQBBgNAVIix8kkHCxgVkkVGENBpXENTKukTYxHACH4fCIZjckD2tO/hizJOZ/7X37uYV2BERVTBOoOZ9X9ew/eefdLT54/e/HpB2A5en/k1L1avF1QohxbAbvn6VEnICJTBBggJYYouOHl1v9kZsPxOBelyovYti0OKTBj7KTqjiwZ9YypIMy2QzCTXRUBp7Ohg4vluiiHvUmb7pdr9YZR6GxjGsYZnlSxmN7SKyI8xGrotoAoABwuFk3TjIj1qqpJcPd1VwljqpRcO7S9EU1/nT55HMJ0TUc1aLx4BBLMkzvNkBqNMVN9qyeMzN9sAJUf2J1dZ1ARzammNJjFQAEVFAjzq3TQHaczcO205M9582YFqNcNAGzi68jNDVOZXaoRh9DADIs+ncF+HgdObUm6rgNERdgWhcMtVTGgAJhZhidXVZeLmxuk2MEYVAw5ah0BwADKsuy6ro2tmV12F/V6eePg6J233vziT/0RVxZny4vPTp6t6k1d103dpDoW89nUGJh3pZl13XY98mY+PDw8ODh49uxJVZWdpPVmvahmr712L8Z48vx58LOYOnNMBHC5CWcXX5kd/9Tr7/17GB68+WB242iTuvWLZ/NVDed1vWkLH6gsn508b1PrCc3HYsYQ2thyKqisZvPZrNm062dnAfnWnTupqQ0psXYWazEBVS/mrDDEvqBONDBScJjnxASM0Zhc4h7vQRDnQih6IpfJ4bxuXelaDz/zL//UVdLfa7/21t+EKOwwpnR6eRGcSyn5IjhHUTSlhK5PBvv/3P4LbAigiI4MkqmqSRdjSkmls2zwV2VEYkIUiZBlowoAOUfeeyFouti0bVJjRl8WiBibNoMJd6Ixbeaz6nB2YAZd3UhMJEaAnh0gCmLnCBx9987s1Pszv+igdNFVjZjTGLBVBbRcrkwJxdRENYkRMCEOuNFZ0hDRxDmIGcm0Z09iTl1iaE0BPBkLyBpSItYEZua9V4NWN13TJocuzLwLZKQgRIQGltR4q8QPG6rH/hLGrm3nrnRRZ0VYxY06UDaK3hwJcmtSkpBhsuzxURGRhJ7YAxtRQlVUUvbe0Qihgz1hI6jCAIjEWR0RIqo2QOySc9GrMJJZCbCgYOpy8pAREgGyJzYCW8cW3S4/BRMRp8CgkouRIAAACQJoDeIq75Da2ElMlQ9l6Zu6hjJoDkJTlZhgwAhJ60bAFHojLwwxVd4XqmpJVRMQCaKhOeeSKgw1SphGGy8479B7Y2Il7703Lo6P6HBx4fAwqrE2FmeJsEQJjCmBqBEZCPTlxtDMooqbSK+pLDEAzckXV3hr//OumHxVU0BPhGQoqSoWt2/efvudL370yYeXzz8TEbSxtGmvkBU+TOUBAPZRnIM414ygkJOiAXXIWpTeLD50ps+TkmwyhoHo27bNNl1VHSGYcdebMCVgm8JnmdlQymQMPu2/GdT3vbka773WkjR947XaxrVtFLHTL8f+7I1idLWYGQwlyono6OgopZRRIvrbVZk5Dq6l8UXjKKaqw566cLVdHdr45zSOddr/rAXCYIQY53mrcORjPCISWZRxjUbDs4gAXe9s2esDDK6JXssZgj/ACBmZULFfMLS+IlbfT1PV/bGPg7LB1KHSV/c0yGlTO+qXqjoGtmQG4Mgpj+EU5LyqJgADZMxIXaqiSVGZEQ0B1BMLGAmwI2ZSVRRFgD4wFBGYUJSJkEiIkkhMCRHNuzGGwzsmpov1yikc+nJz9hhEj2bzt99+9Pr9146Ojr7xjW/80i/90vzOvfV6ud5cnp0+++j9H334gw8++eDjp4+f/uDsopGYAMyw4AJjLEMQEcAqNmtAc9UMTWV18fO/8IXbj47/4d/5kUN8rh1B/ENffa9cHPzdX/8tFxaRkjeLZyc3Ynov8Z/56re+cHRcMt1IuPnhZy+e/k6XusPX78+/+HaM8uLFp/MKzZqYVibCPnhfOHTaqkpdeO8s1pdnbdsSm5K8rM+C41ygQU1NFA0tJeecaC0iAMrMhCammdKYvUM00SQtIhrETjtAUDU19VG/9Qd/5lVEP7Z/8uivoIz7x1OgLsVNswHVBiOXQZFaMVQyFJLkOUc1Y1akkyWwnGBi5mIT203XiUICSyjGRh4r8WFWiUiX1AEjopitu9rMIlrnwQwZGdXQkNFhQCrmyYeW+IzoRARM/EF5Cw/MGkg1S1tQ2VSLJ8X8sXMfzO53klDRoSaoo0f2Dti5JFwEMW2lBQRCArN8aLOkOGGOvUVRRoZihr33IaXkkTvXEtIMGFhNa1W7tIOLIBexflBU2pzjrJIb1fLl8l53UMdmPj+oDhaqsl6tSGVeHtXrjSsKHvzB+bSIiEZIKXEIAgZVuIwNAJGSAwKMKoBqhEGFgMhMOunIaEjn1iiChghEZuSUQLumASLnXBO7XpBHIaI+4R6RAc1Ykim3iIzmCDypAwZjjKB+4byB1HXbNGUokyp7pwgcnZ84iFtJ3nvUVCSumzV4NMHOove+02azaQ6LQwGNYMzonFMA4VCWZUuWkoRQauoODubaxtYgudIXDTsSAmm6ChhFl/UGC2QEkqQSPXMfpIXI6BQ1Y2yKiA/MzrVt6wu/RrrF1VpbO/Dny3MsFwf3X9N7rx34CihGT4VW6D2SzFJcl+yjWuaUtC0OtVeKbcpDaWDQMtRj5Hyy7I81P3bPjapJZ+YQAhCtmstQ0t17xw8fPqyfvvGjj37AEBOwik+JC88pLROZKpj2EfOIaCZqSgz9UbPHQWA1UxVG13sMzdRSxtInGopZqiFQxqZGAzPJZ0IxQ6IupTyUrIsPppCt1Pfepy7mUGvYGs+zCCfMWYs2FrVCGx3kCOx26oaMAmkUkKqaDQzTE/9UiRnl7ngjAJBzMJipRrXARHNxEBi0gfHEjwNYAxNnU3een88++wwRi6KA0VrAJKbjjXk3waAQw65TadTPcIDaG40lPa7JJMnlqullhO2CQfDnkkM97Q03iogCqKkNaV1kiGJoirs+oFEJy9Id+4DFxMzO+2xpGBUpHIMfBiVAUgJCIFTUrNKg9MYSgOyn3VK1846IUkopJQQeepuNZBkEIQLnN5CoAABOwkVzMpYbFb2+jKzLcXZ5Wgf9dZKKbZbLy/VmH0LifnuMmvm2izkYMs+70RRlZWv/i23U4ObB63K9fHn2R37lF3/lV37l29/61ryaHc4X1fEhAEhdw2Y19zS/e/vu/Vtf/upXIMrZ2fnTz559+s9//zf+2T/7/scfffTZY19UwOHycl3MZ21atzM5Apx3Tetgcyc87y7wWfPtn/lCcevWP/yv/8HPP3inWtbf+bXfLLVd3S70RfcFXvxUOvz5W/e/8a2vv/61t1ff+b789g+eBrX1xlJU1fOz0+776lzgGNf1JpvjcsKCYV8Zz7lgBjn2czxkA0BseywQM+t9iKAEKr0eTZhd9ORz/Z9crXcg7p4RfON7f/rH8rtff/TX+9RtBADqUteTuErS1HVdlCSmpB5oSBnNjnMRTUYERI4dE5GadZKipChWa5tSSqIA4IgcMgOwsmKLqITAiKCQRDqgWm0hjsg8gpICk3jqvCUisKJzfI58wb4p5w37RETO3wnnh1QdyCK0sTE7LYons+q0CAkt12awTG2uz3FQALIeHh8REZCRwCwfF6Znte1mRpSJIzN/2Udz75zDEAk7oMZR9M4lb6KOOCJuupZCsVmuNpvNYjGbl9V6udpsVsH7lKIN/IKIHLNhxv0FGzLDr3BYpL5WJOX3E5FDl0+fAACEYL2tso0N9D5HHI9BOoA4jbySRn4HiuAAHeSEssxnCI9v3jk/PSuLeeUqVIux06gHs1k3i5tugsVyNLOUsAEIrvRc15vUdkVwqWljTLOiWq0uCyangAZCriNrYC1MxxENMRVBGWhRYbYX1GtER8rkmMwQlRl96UPprVMRAiFQ08wZkAVJUtfns5iJqaQoJsCYK1P6yHGlEmbVu2/oW3fTzVk4F1JyAlmhFCRTdfLKKq/Tk9/Vln11+OMuu7ZNj7CjE8Q5d3R09M4771w+e/z05fOLi1M08wyakio5X4hYLsoCOaBeiQiZOVm6+vzc/0y02fRtEwmX2ckU5hOxRwilqbl6V8mY6hxbed9f3MOS5YftzWG/y3adAmObukLGYy68OsijDw28cpK2ydhHQU6TwMGpaQEHiI6pE2oqaKd6Q74rB+2OQ7AhoWMbJDHpc7/HnWuaBgdQL+fcmLWOu2aMsc97rpO9GZjeoikZohJQ9onlmq5D+vGelja9d2p1MLORP9guC8r9BBvKzYBBjpoaukAwEdIAjpiHEvOZJGwInxhSR8YhiNlkfXfnwcGQTcqc47kNEZlYpU9UMZDBbKWIiMPxgHJR1p7bo4AaQg+bCkC2Q8oChorMnCUHTHA4inIGbTPzxIz/0Z//c//p//4/dd6DqKREGOP58x6vpnbIAA1HNHWumM9vvnb/6M7dr/7UF//wn/2Vf/SP/sk/+O9/9f0PPnx8+rK8c6OWVMQmxtopOKD2ol68XPHz5ezrb//F/+w/KW67X3rv4Yf/8Dfe/9Xf+qUzPsYbgQ+rw/Cw9V/82ptH33wHbs/b9z+6/O735OI8LYJT9VVJGmtNm4uL0ocgeLZap5S8974H7QZVBURHnKEPM8Zz9mMTUReHsqg9fEvGnQJNGSYFTFRQiWxAl++x5775w/8Qflz79Tf/nyNJJQUzHelSVclxDvaMkmKMooLc5yCh9qzKciw+Ql+zDaCV1GqKKUVQBdyIKCEUrGCC5LknxwaBUYGUDRGss5TANNgKickTkRkmoNa7tqDG80fFrDW8SLBCr8WRulKRgNxnx+kQ+NgQJK1NL5kvg+9cUQlaHxjfa7eELDLE2Jrl4kM42LongE67FtFd3/C4OadfDockJMILkTO0uigOpaQUS8+8WHRtzSnFlqN0DFjcOAzOxbZBRBrdHDDo3gYmShlIB/vAugnHyfyfzEYWnKPYIA/OOQcZycMke/THMxwMdcXatuUrVZ2h5wGI2AMs2iCEiGi5rDebbjGbM0Jsu2J+2NWNGidIc9pWqJ99XKNjAL441tmsCoEtRg8E2rQpxbgJmmJwFyCNCXoOFIIx17AiVVVbA6qsL1wkybDFC1gYEwVnZo6YHAuCY3AcCBBydrqIAiFu7dvDeC2rm0mFTZdFFEdgvrxxfPvLX4HXH8SiaNPlTI0Foxk4Ek8A4JLJlRIo1/L6a5siEPwE111pE2Fmo5QNITx8+PDFu1/65NmTi9WFdq1zTKhJknMBURF7sGmzDOHVh/1ue2uEQxoeDGEojCiANIhkGgIMaYjw6PP4MoVPj8VXhfpEgegLONhWeEhmKbrvUcLBG379HA75lrAr9qbXTKl3KvX3pnQ83OfW20uuQ9yaavbjn6Ow3HvC2M+9jk09IDZxpuQX3b9/HxGfPXvWdV12IlRVNW7Sq0xGJ8GVez9dbf2VObPGepmd//ucuIo9lSJ/MwZVTEeRW+ahOfU2w3IQDAGquRuTLunEYDOd5Bw6iYMJwUxypPX2sum6G/TbkdkRkUjKsR7e+63WaJTzgYcYfB4zuxARMpNV6SsMDdX5YFB9MDgwo7FSyZXJ3bSdxFgvV//+H/uF//BP/Yn45PnT5yfL5cWN4+N79+555zgl8g7UWTQUJscWu7pLvixdUbaBFrdu/gd/5s/+9Jd+5tf/wa/+o7/33336/gfSdndiowyPwuyn33w73PXlQ3j7G19568/9DyG4l7/1T3/W/C988xfr136uxnnx8MHBwQL+/q+t//n7IdUaZPmjDzf/7W8XrZ7fO8RVDWSdSjRBpsCkTbNe17nSXzGf+xASJESMKRGiiaSu65oG0Sg4FVET9h4hI4laf9xFNpW+GAAaIopGFSWiqyAZ17Zfe/OvjUQTtaeZTJeqKpIAAJmQyRBEY5e1DdOM8ahqYCYmZkZgiFuTrIAm1STSSOxUDAGQy84oOCWLoADCxARokhBLU9PUAQj1ePaAHpKhOFr5coXhEv15qC6LsHF8gWVU6ygJUuGCJwSNJKnhRVK4QBSPjUdBpCi+AWEdqRb3CkMMoIegRoCmBq9mZNK737cWxX4T0oRb5QMTkSEuUU4JL4uw0AqX0TnyB7OUOukiFIXn0GzatduU3lOBqhkqRokQAEUkJUFEz2Sj0oMwxVYCQLAekAz6rHlAxGSKfawVIlImly61Y5ToGCW3NSzvMvFsWiPXg0Ip9sbzHNHdnF9q6kGfzCGVTrkQ7w8Wt6v5DL7bT9f9/82fR3Kbzeb2449Wp6fWRm8GSWYAB6rrelO0HQDM2qbtalQz0Yz52FQBFEPChZuL42W7gi4VIhusU50QEURzMLIB8DrMwnxkJohI3pmptq0LpClGSUbIWLJjzDpxF1ufsDhwRzfoa+/Al94CtfTZaYdu1u8uSAzRoTH5RIpbHEK4IiZf1XCSEWDwkzhSXvWcLDgoxshms9nswaN3X//045PnT85PHptEZkzRkphTy3VBsA/+IxwkTc9pbUBI7B89yVwFBtAhLNoQkUbYhF63wB7SezIJ18rpKTkNBWih3yYGfV3YyS3jbkqTWJBpGxVHmNAqX6nBO6WBqezfbuFdgyUMxyQbwLP7GIJJTCUNLdsL99649/lqUGq+d0/vGZf19PQ0x8RM03xU9VoLx/TP6Suuffj4dkQcFUS0bam+6WRenbe9NmWb0y/jcGbjrXoCkC3HY7cnhK+SYqRx4YZ3WgbTmyxNJpvJNMLWDg25/lYmmswvRvdV9r9Yjy7ESKMhBcxMBRC36lK/qyZbc+iCBWYbgM/NekMV2BTgXFS61+/d/vlv/cwPvv97n7zvQDTG+II+fXn32b1798rZzMwSJAEjcr6aldXcecMoUHd+vljGTXl4eO+r7/2PX7/37339py5/9Tuf/dPf6T786L0//cu33notkFNt6PAQNmnzd3+XTz+84RC+8Mb6xg19cO+AkJ9/8snf+X9d/PaP6ucXs5P52wELxDMyvjnfnC9LtijS9XpYoRLbetNslsX8UBWZEcly5YiUEjuUNnVtrSk6TyqiOdtHe2omoqwSAhiAqapDYqRvvP9nXkV5Y/vNt/+6mQn0gZAZKXHQX2B0TKuagYopAJDml4OaiKkgqAEyZg4EANnFlnGRCQHI2tiCkRCoWUQTtCiiIEity84Rk17tJFLkRSdGWAMahZqtQ9RZoZ6fcmidW/rikv2KioaqhlxrNFfHaN5Fh+o8IiXUhGhsFZhGhYgkzGgQVENKG5c5GgD2ZXH2VHWynKbRU7zpvvc3T7sOtShGpBZEZCKlLYNjzgDTZqYduXNvZ8C3U+GQEYw8c2CLmroue143yw2URShc1hrjgMNNRBkJlB0n3Rpa1BR12P8wmmqzn3isKtir5tkBh7iNeh4ZmYigqttVOKZzgog5aZaQoEcmTUmMiObzquugaVaIGNit10smWhwddTPl2ZbY7O6cDw8qNV5euLOXXZfK+czNnKAJUrCjVLcmEdu21Mh5cGbM3Bp3jpNZY8WH5+ffP1m61eqLZfWFLz/YXCytjT3/EZWUtIsb3/ULyr4oitJKBGBJBAWoiSoyJYygosSdxrpp8M6tW2+9Ubzz5uabj9b3DuyHT6vzRl6/A4UHxza4CAH2i4f9hE2vu+tqGOnnXAwTB8fo/DKzEMKt27ffeue9Z599vDp/2bTLoqhYWRVG0CTE3vOhKn3xJkTMFSyGJ0/fAtAjMCsAoPJ1JhlDyFlOu47DHSk16hywlc0DjhONqaU7WRL4iuzWaeOh1OWegNybq+mfV3sCWSQNABU7qjbu3DW2rArkfTriMI0duHruH9u4cNOuTmV8/vLy8nJUNfJhIKWU/TJ7E4KTPJHpM/f42N4QdJK9ktXQYb22gZx7Os3VmaShgMu1w1FVGlXGCU1NPtn0WdNFNBuR48HMADU/YqDHLcIHDLa0rCQ4MyXKqFxtURRHR0cAsF6vM1L1ICYBgbPmogaoo/3EsumvRxEZ9A0DUOiTkUaC1iE51nJF48G2XHjmdfyZr3xJYnu2WnsO0Mc34Pqzxy/OL45v3jg8PHRenXMmsD6/DKGs5jMXSu89RT0IJZxdwuECnOFr1Rt//o/f+0Nv61/978iguVzxwzvdZiPPPvWrjl/W7MuVpvCDs6QXdHNd1PHZ3/5vLr77OxzC4tbR+eX5D3/3O9Xx8YW2nmc31a+oTWDo2DnniWO9SdL5WQBC9hSlE0tRcv0IEQXTlKRznr33OoToI1JKre0i8P/ch/8z+HHt19/568MySxxCwc10DEpX00wWavvUlt27XTJDA1QBATIgEtFOlUCw1zIAQAXM1EBBTFSkS6KQfeqYTTCpYGRiBFZGRFRWIxE6K1op/AXPNr5ac1iRl3LWkXvG1DHWbAmQwAdlNpipWFACoJQEDADFANARUafCBIxYmLk6RpAORIqd7QoDvzMzwAzbMtnA1Oc/9BqGbnPfM7GbmSWJqkyEQ5RlDy5jRogESpDNttABnCM+S/qQ+ab3mmpirqpKgc4vLkWq+exARC5X69C5xWzus1vMFJGYGYizljcmCuTVUbCM7p95AeAgY/pjjGSxrZpEzCl5HzLNmCgS6aDlZ6XTTVzCg3jjzAd7TxkK97GPpqYgulxfenYE2i43RC7VjWd/+eJi/bgthQD+Qn7gZ/+H/1O4cVjMZ6dPX1SzgpHOLy7LWZUAOhUXigI8eBeOZm4ewFFd1+26BoBLN/vdk49/99lnZ+A280V3d/FGhe/eer28eSMa4KYj7TUkFxMZMKkY1G00SR5CUsnTMgI0oWMjNiJfzYBwczir/vhPz7790+7oJqPYj57pR6d869ZsUQEjeSoEY1KKQsTR9Kows0kkwdW2Z0e4NmPlJ2kj7WX2TNTv2PksvPHGGydvf+nFs6dPH9f5SrYcpSTbe8EMQUEQPFjvYt/uBaORckYCoNx72unD+Ln35f0EISkjgeX7FLJvv5/J8aw8jYjs92MvEfZ1jnEJ9pTj8fNU7u79OeoBOZ1k/Kb/dRCKe9fDoHDsdSO3UVHASRHdncdel5ky/YyIs9ksPy27VPJ2DiHsZMdcmdVrlYzxy2m06Y6mMji+p528umrTQWVby/iQceZHQ6nL9QJHfQ4GkfIKBZoGr66ZTd3UioOxre9Yj+Wbv6XhvWPri7fhJKwGdhcVAHJylhmbGdCOotSbYRDYtsp+/xJEAMhpKThZ772R1Bcv//jPfeubX/2KxqZtYyowOF+UpWdnIl2Kl5eXddsuKl9VFSNZkowEEcqiKMsKE+MxVOH5h5/ypjk+WcPv/DD+1h+Uv/V7cutG8Sd/kd91/oPz7rvf2zSbgsIa3MuXp82zpzO1NXQvn51ybcdvvw20LnxwG4kaF21zJwJdLBsCESEmVGMlFNEciuEpanSOmtjkqcght5bAQFQlBO8cN03MazzG5H7rhz8e7vNXH/1lQM5LlnS7J2E8VQxs1CY/STYegUwpDBHFQEwBk4IYgAAqsikIpJwMlXGORDWnE5NDMYtJxbLZgxwyIx+AI0MwMKCE3KFbAzasnx7NYlWdO177YoOhwyC+6gSqBGIgKgZqRJEVENWLInBO+FYkwz4Ni0i0VUQhcoCkxqodW3I4BxIVHLSH7UllMGuM84bY166c8otxnzMgZKSkbL7T/hhsvYKS7Q2qqohGhCq8hvQidQ25UJXtqlFLs7IU5nVTS5Kui0VRxAjrVWuGVAV2TOwMUft8bFVRcDS6MftOIigYbQ28lo2Xg1eFplF1qpK3Zp/uKGpEOTwtxzZNN+x0z+rQ8oyYioog8mq9mc/nd+7ce+leOucWzhfsnjx5crhu1uvL8fa2W9efXWrU86a9d/8uO7du1+xCUZXBFyiaWEqonIisu5PUvb86//7y7CQ2PzJ3ucDNnRvC1cqH2K45tv7hXVeW5aYNviJAMVVCNCjYmSRD8ptGwKrZQi1JU3vvBc05B+Sq+YyLEr0rFgtR1dIdvPsW3z60yyV+eup+8FzqlB7dd2gpRnDs0Bddqohr7wSyY3qnjSTx+dswh93kdbMxfv7qZdcd6wFynW5BZBsSUA0tSQxMd2/ceufdL56cPF+uzlO7ARWHzpiy1plRz3OKDA11f2ziwkCjqZluylQRe9yC/AfsyrnpqKc8fPx3Z1yKmVYRwEwy7AcAZF/fVPT2179qGieUT0NS9yg79zjb2EOb6GrjvdPvx1GMXqftN/38k5nlShEyFHIb3z59wt7MwO5umoqt6ZDrus72DO99Nm8QUU4JecVM9L2avmu0xU7H2G9/ZtwlUetBa3bKw469zd+McSfTSR5vh0GbsYnPYbtMeewwWYXdVZ26uvKDiUghQ+WOGlJv9hiPUf1Ih+xep5piNOdCURSqenZ2lp/rXAaM6R+xs/Y7i7HVbvJRoAcNNcvV2qaep1G9op7PAgB866e+/vAXfm59csJoDx48IDY0qIqCkbqmjbGllJiohrRZrS1JCKFazLvUttIkTDE0R+er5XfPFjUVG/3wH/1m/bs/WH3vwweri/Ktn731tYdyuYr/7W9ffP9ffXYgFApJSRs4unPn/MXzxXp931t3a36xfsEL371cLcgnpJPNufcelGvSm1g5dkkktS0jBuTOYNM2oajI+TZ2AOAdAfbhgSnGlDozPzKan/7+n/0cEsztHz/4v+aK1QqmQIQ97MqE3Hs+IpLDuLeE0n9g1By/02cGpV6V9BUoiKqYSE5yRgampJbtI/kBApYtd1EMgDD0QH2s2TKgy5kHAEHqnNsEf+b5jHAFGuGuBH+BWgOIskP2CV1MsRBELBRBjKMBoTBGcpaIkDBXzMkzZslA5i00rG0wca4kdoJmJjboqgNrUNUM0UhGCQwmnmMBI9hCB+7spSGVjolwqCAIaqqKGUeV8lY0QEACJkLvDGSjmhy54BuTFKUMRSjc8fHx6mJT13VVzhfz6nn7/PxyhdEfHB+FougkRRFH7NmpSQ90qFsGsd32OaWx31Y5RYNxQLLx3gOAJjFTIsrupHxuI9f7QEchNHWTD/vXmalKSmb5YhE1s3vHt2tNh2++OX/trhbOzysoy/bp3ZAkvFw+Of/Hr/3WHwOAL538xz/66b8fVd4BfHlxJib+cA4AwoCBReQFblaX55++PH//7PwTSSez4mJedlW5mt9JhZKaX2tRFHPEua5uumpezd2BVUrMXEtMDgO7MhSWBMvioBVFCPOD1G42q2VZluFgDiqpbV1RAlOnlgiWm6armb73rP7es3q5dJU/SoEP5/H2gXaxSR15dMgQNTgpgGq83owB14nYfmnGD2avlKJ7t1yncwxsfZvkmcESCwY3rx48ePjGW2998sn7Z88fiyUmFMdk/dk07+Ac5ZvhDPMzsycOB+KddsCGSiEjz0Dsy7aN9D+eLbF36l0/D3uiFwByCbAMZLBnGdqePF8RwzE90O6pR9dO4KjN2KQBgPMeBg+ITjDc9iZ//DMf80aUjpy8JkPEwV4I57UrOE7jjuwbNIaiKHJtmhE5LZfEuzqucbxTzcBs31wxajn9+gOo9UHfRJThk+kVEanjquEkMXj63jEexQYMTJqk19okCWiarzddJ+y1u9y1/phkZkhX+kPDQfa6hXbOBVXtuj4JLa9TjFGEnXPM+1nUw529FKBssBUgnhB0DorO3nRQ51xMW0t4UXqo69F2880vPLr5+r17P/czAjabV+enz09OTkTEh0LY2k2KhIqK/TRBkrq+bIioLEPXNXfgzrP1ycff+f1vVHeefvf9H/7qP31QLg6O+KVy9aX7d2bV2d//zosnn1zgpuRj3/pE6ObE9cWMoQ3OhGgtR1C6RDFAa8KgLmpsW/bFzfmcCLq2NSAOvk6pi02SziM44nq9YYfOezVBz22Mm82GgZDdtz/48/Dj2q8+/L8jYszbGAwRFSwX0TOAoeho9omNuW8QQXIEhk0UczPrYlQEyGhOYMoQzSKohzqSdmBmwEBoptqoGUfqrZEOgADRokYRUwcqABkzA8lKl9i1JoYHm+BPS3rm/UvvVxw6cAqYjHIFbRIlAEZEiM6DpCHGGzE5AABTJTGgHqMCMAcJGZmp6LogZlcigloHYmjE5Iik6619ZgDMKJrFNLAx84DdjADKAIzoXLYniYARb/PaTZWYkBwlsd6ph8AMZmqCiojI7HGEkxet2S7nxUvBhGFRHGxWl1HqcLQwbH1RtM3q4vLszv17N+7culxddJv65Omz+Y2jm/fuIHOz2bRNR2ZE3jLeFWbnTQ5JIUNBgDEWfrKxM7+A2OVMDUaAJMLMCkbBR1Ptuny6SikB2GJx0HWd4wAAbbsJITjHaVOjaGCG0oW7N+88eqtbdkGJ78wvN8u0IO1Ym9a7ypzO375XhTsgzfLlS/itviczA5jPioP5/aND7FKdanHYEX942Z7U8fdPnv6rePn00DX3ZpdUrsDNtLidqsuL554xETTEJvVNkNjV56cvzNlmebbqUgEU2IHAsm27qtIhizmE0C5fxrYDVWub03juL5rS+efULWMzA8Qom2YjXfFJu3Jfee/+N75cFCF98sy9fiu1sUu20NARX7q4AGUNguDQpVfYiI0QdZ8hwsQjQMNZKQeCtAMsR59tNNyalddcZC4H3A0JUwwwwV0QZUSHXC83RTU7Op6/+ejRZ599ebNuVM9Ao2LKAFXeFZZEQJxD1aToYWIeSNISkfcetIeZ6WU5Q9ZUetXUtiYQAMjOmh5SOju1UxrscD0DyZxfVXMsZJ/cqL0PHobDqg2OFdi1FfHeAX3wa+AQMDHFtMhbEl5haLExx3sSN4BmgKi72Bi9De+K2O5XcBC9YtbliChmGGTt+JzcZ88u5fCIbKLIWjtxUhm1pXGwMPo0M7qJCA5BV3sxMaMeMNCX9UVDEDPvoonqk8Mo+xkeBgMTS/b4tD01CIfqstNx5QscB1UV1YwHOI5ldLvkMJdsCmJmm+Cg76Z4KKPL6qwCqSYAJaKAbI6jxqSiooyOjUHNUIwsqWSgFNXEzGbgsqoxKoC5u9lMNI5qOsI9o9DYRl0SYIeAiDnjSDnmvDk5oRMY8mPgjfu3j+/fOTo6cLNgqs26JIOLi8t177YfS2P0dbRFVESoT4pxz58/f/nkef3i5Qenz+v3P5kZt5erSs0fzm8Kpx98+vx770ftwsGcGcsEda6zYj3AX29YRyUfPECfYimQLZNd1/VZjeQQmRiYGcwRoffezAwkxhhTpwB/+KO/AD+u/fqj/8r2GiBgrhphZmZKiAJAOkSQZQ9ZH2pr1ocm9OCkOgI8WDAxVQGKxgYk1huYxAjNZ/pVUQRyiESr0PRUBcjIzEy+ZMQgLJ6id5FdDbgh3nisEZZUdI5Xji6cq4kjs4A3yzHrSIhGmMPrFQzUFHAwwm4PEAI2jXyeTkNeDmaGjEc5Vl7WDISXuXyuUZzPAWlPux8ZQb/ftmZCYOY+MXVQnEfL53gombISIlJJatCKXYgtFRaMwIRmKaWiKCTW3ntVXa1W84PF0eFh3XRt1+rlJQd/eHhYFWU0bJuGzEgh+2CzoEJEsAFIavfVZrmobR+LMl4wkRw7/CuPdLPZhBDatiWiqqqI6Natm6fNKtXtzRs32xS7NmKU6tGDpz/44R2tZqGgJjrArk2b9z+ZYVEZXtxdHb3z+sGtG0NQOUTvsBN3UbMrpZqdbOw7J49/7/Lsh6lbV7PHD6npKkjm20jmFwUl6T5rN0KdlWXbSpPMOXd+cbZarpqbrz3rmtXlEruOAckopSTJXFGkZjPaADLXRsRZUa7Xa0+8ODyIDhVhSdiR+RvH8O0v3v3GTx197UtwMO9+9Mlls75t6jlQYDDC4IICISSHEc1Me+/kv3X7PEP5sHajNflVFwDAbDZrujibzW7fvvvGG2++PHn6/bMXhWPQHOxKBGDEqirJkGiEB7XJmXhyxN+RgtM/d/8Foh0r9Z7EGm8fXzF1DUwfO7UN4HVZoNO2J0HGeRi/nL4Xdr0A01tg17IyXmyTY/B0E+0NisdbrlyQ30JjxuzYEyICMNzOw1XTzjjD47um2s90ZqZX2u5DFAYwWcgGqt6U7XaHf3Xg0zHqFViR6S1EOeJnP6Ila64ZAy0Lu5yjOj6HJlSPsK0q5703o5Siqi43G/bOFS44rwqSTNVAjb1TAO9pPp8j4mazUQEic6PKs1URBj1oqj9OSQeua+Ove8S3aRtmBgUgx0ighjEHsvWXnT797OT3XJhXB0eHvgzrdVyv101dj+YvIiqcV9Tskenj/L0DwBjTpl5fvrxw5+vLD57B45MbZSFi5LFT/fg3fwd/9/vnn356YxF8ESCaSfLBqaomGbz1fWSNmAIhIKEBETnnjHJABiIyEyAZ9IDZCIBd16WUfu6jHx+T8Wtv/uU8g6raydRglTewUfay22C1AECE2Ce29HZdsdHU2kPGqlk0TQNcR4Io2dCqmh3CAgREyUFObAFNAKamUUANKiZ1BOyUWBA7YkMSQy2LRK4LoWa+SHBBsAm+Rrws2QgVXTRTcAiewBGCWYIcsoq9lFTLpZ1Q+7BO60GUEPdi+sedM6Xy6T4zM+Rcv2G603Ky2M7uGp8zOhr2mF0G6qYBRwsmbku4wq3MDEQVoDE6VXiO6H0ZfEOxlZhms7lEhTls1s1qtZot5scHx3K5UoCu7c6fnUnbHRwceO+rqpKYctxNPjD3fTMYSjFdUb/AEJkITfMpGfNJYq97I8cZdM6eM+ZD0mazefCFt06fnxjwcVGtL5fPv//D26pcuu57Hxdml+cXsztHfPuwLrhl1E2sRNuX5+cnzwHezu+q7ty6ODn9+OT0e/XqX2j7B7I5CSAHJdi85GpZL2duEQrqXNfGaN1Fl3Qt3Z0WLuvLBMzmiDAsl28vjm6Vvr5YsiQVJWJQAYCi9Mh8cHiU+cw4HCIqy/J4PlsTFEdHFNMmpnT7cP7Ow7e/+XX40ltSVquioC6CyvzmDbhxrKouY0caumiA3HluyUrjV/pU/u3aTxhMOpGaA12RU4sIfOPGjS984QvnZyefffpxs1r1JbfMdIj2VxWH/QF6BMqcegyvFT977He6xexKVffrd9+gjkwfclU52BME174dd9veA6dfjoQ9NbpM+79nORgvmIZB7PX5mv5k9jEe0oYJIaIoQkRI2G8nBANUMzdMOExuhCHo22wfzGNv6q6dlp1O9icMyPnQVwe416bPx0H71AnYyd6Vqgq4k0mUWwghk1bXdTCcu6ZPwEkEBvTSCnOHM6PPluDDoxsppWRJxMDIzBCAnDezPiZjJBgzM3Pji/O851iSPbqcTsGr5o52UVlyl1U1sOuru6mlPkFTkgr4XuFqmvbs2ZNcQyFUJeMsz4INRdcAoHVOhnBIIpoVZVWhiKnWm3ZDbZdeXh5tWi/mOwkutO3GFWH99ORgHm8v5sApNW0ZCncQICUV1Zgs9YVjoA/DyWmXqCIA5hwjkoCJRkIzQ1UQiar67U//p9fOwLT92tt/LcYWe0OZMjplVVPVPmEVR43bMBstcv0JGMOVNQn2BYKz61KgZ0f5xC+mYhr76ABAgYSqCIbWkipYIujQHIiqGmBgHwrvnBPEBNpRYczRccNuTbgGbBAT2KqcdWBCvjOso3bE4kNHlAIyMBpgAgfA0EcVxEzWfSQ9Gvbex0xseYPC8O9eRNWUxznmQdmFURlARLMxCHpn6/YwlNtN3v+UWTOOaRojtx1CX3ggVJ0cOPqt28fkWtYMCFxkeqH6HO1GcEXhITVmBmohOFRLKcX1erNazqvZ7HDB3tnlsovN8kytS9XhImMBZWBis97zmXevXTmx7fN03P66t++mO1TVQii6rqvKuZnVmxUzn5ycLI5vLlx1dnqKoaBauovzZzG9/o0vd3ctrprVi7roZoGLRYFYBTxyWB2tHz9+8f4PR4Xj+x9//C9+/1/+5o3qhS9ezGaXcCN5x8Fbm1Jr5fHCr1t9eVlo91qSL/L86/ce3rt372//8Du/8eLxuihCKLWtbxF987UHB8mSaBGCEnuffd5QVnMASCo8nkG5d8mT96lt3LyE2ezi5CU9evDun/5l9+aDtcg8AqiWjp1au4xt01aoIQRZ1xJYjIuGQF2LmIvg/v9J4YBdnSPz2fzpVUaOPLS2bcuybJrGe3//3oNHb779/N1nv/97/4Jiyjp6SmkoN4NEnJLsna1h18wwVT4AYJKvuGMky+1amQSvYOxXv7mqIux92JO1e6rAtVrL3nPGf68l+6tjmc7DqwaFODEsTII0VXvwGGaWDH4DfXXZPj9+7yG7fp+rwhGuLA2MNobx/aPU1z7OJvcuvzobPeAKu7v6zVU161rRbAMC0WRCFBGIKMdO9BHNg9zZmXDYn3BkMrOUkpkwUwjhzp075+fnFxcXUZUZHboc45mjzaLE5XKZX+3Jp5T6clD5rbkiQ+7WnsqzRzFX28D+sstsaxkLyAyuA1EVZHbeSTeWKQAAUIRNl6KBodp6My8FRvCiwZ/UdR1wz2cBQAXSAH1Rayo2DW9WHmHmuIstcVBCrdvCOWbrLGnTOYRE6SI2hxZS18YYbRLxCwCOuQ/lz5BZiAIiIhrTz3/6F1816mn7hw/+ch54NSvMyLAHzEZDI4jS++dkOM8BExGBCeR0YzMBAxBG3xeeNjBTAdPh3AMASj0+dzI1BKFcXcU8uF7fpWQmaiAKBjAnUCYlB64QV7bO18Qt4aehVKQWeY2wRmqZxYXEFBFFoXfdshA5YxIAzuVQAUAV1JTMUBVByawvJJW1IzQwJGdmMOxJxVxeB8xg6jjHiRZiA3uyIa8qk5CogOVXKxgSoA275SoFwkQ821CrYSQbHOKds1YBY27q7hP6LUdIQAp8aenE0kPwx+wRCdSapgkhOEdF4WMM6+UycFgczKDAVErGImuaLulKOi3nBREioE3CuKz/b+fsONnqiugAwSzD4WyvxOFMA0OGW1EUAL0zNHtknXNd17787Olr777tHj44P3vZSlPOqma9fvov/+D219/FeVj4h6AIy027WcG8mN25KR9/2D5+flTLdDbauT9dHJ4QbXxRRHfYGkiEFGeI5Wl9L/FDd/TO7ZsPy+qe4o3DmczcD4U/AHoWisSMCW4UxYPq0HVJHBN7NTNGQFRCIZVcp97lnKwhOA4AnCvDvI4pXWwOb9658/M/E774XnQW1lFXtZopOGdQtInLSsHqs6UjMAysDAmUKRGhogNK8O9G5aCtArhdKRliOLbx8kO7lvvnYRqhqhLw4vDg4aNHJycnT548uXj2xMyIOc88swdIGd8lYyNtCXsicq4qELs/WS9th7v2DCRXhTrsuiqm74KJkLs6zD3BPLYRX/y67sHecKb/TvfFtKvTn64Of7tHrmhbPT+ZnPdgAGsQERoQe6dSFg1G1/beu0agsOmi4HAknu7Tcdr7J4wfslq5a1S4qlTtzc80RAYmcvlVonnvylxwCRFzfRmcxJNmS8k4rr0HGgAQwiRrMpmS6bqpuy6qmkPn2ecepgw9gGiKCmJmhA4Ziaiv8so9OlCvK+QAoilZXLvAOx26kl7cc/ZkqlERgMkHNkkp1uj8GMTRdCkq1W13cHwAkjJ8Sq5n2KVkZsh9jmg2wKhASmktksO1kbiN3YJZoFMQRKubtedACf283KS667rj2SIQb7QDxtSmcZh9t1UASJrOTFRiSpEc/+xHPx4k4zff/JsxtUmEuM9pzt4yM8swPGLK6LKsTanL/BTJxETNGBgg40lk9C0zMwQyVMPe5p9M1Uwy3hoCIgqagKSMuwEACIqmphtTUzVSMmQMjimwA0fiOYXQhrBEeilwrrb2LrI/9QeIaIiCLgGqkSKjMpiJRiAiBmRmQkEwSaBoaICoCOpy0XBVhEJRhxSMKZ3YoH1n0JZX8V8cdA7Z7orsVtgeIzJuMyKCqlgfxDeqEbarm9PEBNpT4CDpHe64exFRBmioPTofvkJhWoGcJdkAGAfjQIopxRC881xBAWrn55fr5YodFkUxW8wRMbZ1XyE5hK5D7902mQ3zRPWGFtiOeuxVZlI5BqaH8bDB+dKzY9qmzjrn6ropiiLGqKqzqsrBHOeXLzcfyqOvf/Xo8MH5vPDJDtF98sGPin/y3RtffHR891a92ayarlwsIqTL5y8uPnvmz+tFWY4TsAihWsxvdvSyNAlG1MFqvdh0b5H/6uz2ozffvOvCXeNbhceukdhEqZ89PXNPXswqIvZiOivLG2QzomI+0zUoATivfewlREkqMHcFA5uZikLOD2Ji4zo189nBOia9dRAe3ksWVyerG1C1DotQxMKl8wtZLv3dYyrDTH1CcewQGZxrgzdm1h8bd/HvoCludehe7QCDAcxjuyOG6zn4tm2dZwBg5jt37965f//hW29vzs9Xq0uPSI5Hy7ykfi9Mj8jj56v81nrL4r6RhbYlMPq2x66vbs/habtS59VZElOtYq9j09eN/46bdNQhrhUu02uu/opXTvlT+Zq3k5kR5ET0/ZHSpJw6qEpMOpgc+jOPGV7B6IQJA5l++TlS/6pW17M1xJSznIefe5TZ6xSLvWmfcrlrO3Pd27dq2Pj8sdvTlb2GHgBH341zTgBTim3bnp2djaHB+UW5OhgBiwgBuKIwM+lEVRmdm2o0owp57VA/Z0KvTvr4gRwnU+ccoEKKslmVaq8dHcFqPY7EOWdNm9qEkDx5y+GyiJirfTpW1RgTQI8pqdJLd2b2HJQ8IjapwViTgXSJCRBYCYhhURagdlGvEtp8XiVLCkaUD1Q0yC1LbfeHTn68JeO33/pbZABAyYZyD3knm2Xun6RLKQFl6HMhZgNo2xghMTAR5bRhBTNTshyWYwCgqNAn4qtoVJVczluhVzh0OBkL9N6ZnnQQDCFRUkfGzhwZB2UvrkzMjxHb4Grvl4wrxbVZS04d++iJiMgRoDNUU4hmFnPSiIFhDrMU7IHjzIBYKdsyABHBiLP9GCVjZ/XUQsiEP8nBcnuLGU7i3nF6GGJCA1LI+pWa9Hghk+Dlq+oCDjbU8UuHBENaV+bgObSlj+K80pSRBIystrSE2IIDFzjMU1MDQIyxKgpE1FQsZvOm6dbLVVmW5axKKoLGhgyGSdvVBsuCiwJBrXcYZ2v5kP+2t7l6vBzJzlAA6NHAKIxDG+00MJy0nHMqKaUk0iMFL44Pz84vTz99cu+9d4/v8vnp2dyFxWLRXC5Xl5fzeVnOKpzPgZw7O6+fnLRtS4zqtoLt7uHx/Wfl7RgvmnZm8U2qvnLztTduHNwn/4YVD2dH6LFt63azPj0/jQHns0PqMEGMgTQE6oC1KcmJWDNjWKNEIYcqhmREJMkIc2oHmpqKARhQLsME4v1ZvW4Pq9e+/WX64uvtcg2rDRQuWVNQ0IQg0RHSYiaBsTYIiOhAMTKtS6eOSC3+m4OS/2u3/KZXmDUAdtRfBWIwTakry/LhG2+8PD9/+ezJ6sN1BPVEZiASRYSJhkivHd16+s2UhGzXADDqqZM/tz3Z0wDgc0XOVQm0J+PHe/dEyVYQDLFT+Zsxq2K84NpXT7+8+v3ev2MfVFVxeGPOfjfTwWWx5S2II4oGqKmI5X4yDxbIvqz01e6NIN+wm7MzveZaGQpX2nYms2l1QkVXNa3pXE1/ms7/9MsJk9lCjqoqEW/naqIs7qClXaeGQpZEw5wn6frKsWq5vG0+QksaFHAjMMtFONTU2dTgPJjRYox9FsYV1exVkzXKAJqgu5hZYyoiAcCBWWqDwTuvPfj5r3wFfu3X843s2MwODw8JDA3KstpsNqvNJltZ2Dsi6rrOeUpx1LC2iO6sMKtmEWHEoChDYa1ACHVdM9tBtegUQ3k4R8DVppGtiQ/Mvv3Jn/uc0eX2m2/8ZbFsenKApECofbVAJEMiQNNsjEG0nKxIlsG+CFgA6rpWn8wMXa9Qq6nmgnaDmEHMmaLJFG3AZxAwQxMwAcsrRgQGptmxkc/0SERYzaroqQ3ceb9Ed2l8gdwgX4QbG9ANWDQC5xDYDDQBsIpZkg6y7YQQGQE0F0bXnNORspGDEFEybneGgFPjrAGpWYlDzwerA45Qttna3Hs3BpLdZxBj26qqE+pSUQIkQ7a+Qmy+ZEx/h92NvUece0zBRlQAZjMVkVdR94iKLQjRNIIiOeeLbrk0tK7rCu/NDFCrqmrbGNukqobIRTgoCq3i5vxyebnyBSmRESMamhIRIyCg7O6sCd+3SUh5fyKxIWsx7zKeGMZjjEVRjo7YGOPR0VHT1Klrjory6R/8sOTi4P7tg3IWAF+7/3B1f/34o8/c5cXbX/0KzMrT50/bl+dxsy7KwgK0E+bmAe652dfOXnz1zddu37//qPMPkGfzGYAWm3Ry+rTzBgDHGA6rA618FebrzWms/LlsIkIgn1aX5Gfk3IZghmhmjF4sohEBm0Tn/UbVmwGTgBGzYyeEQuRiAh8Wj944ePN+fXkeT9Y3sILl0msHDWoqXBcZDUAaTLNyIdB6NRBpiDaehBkUEv6bgZv/pC1n0OEV630m+R1v3fAhxraoZm3bMrOKMfMbb7zx/PnzBw9ff/zss65pyDvVTEronBvKudn0aVM5tKdkIBnYdDts1QKdpLqMsmd6Ptx7FOzaJ6a76VVCYU97mColo+k+fzN+Hq/P3XM9ANC+iWW0U45Cai+hAXaFETCRY0cMAH2KwO6k2a72xgCdJICtmgIAjggmFtNxgFPNZuwSDEJw7FtuV4M6+6dZvn6INgMAxKxtDOUWt1x0qrJcOxV7MzBOy9S4NVVV9xZrfMI0zGDaDCzrKGYmIqIJEbz3SSMaDmMhIEyWoohT510QjV3T5FczeUnJjcPI84wIZkADaNowuTkQaRBww4xPl02xLyQ2Um2P3y9ioVDii+X5nbn/Yz/7s19+861bTdzOiy8plJIFMGLd1UbWo00T5UQdZo+p8RmHWi17SwkdGkaIAaRyJQgaFmItWAxgjS0DMSFtYktEHK2JMZpEbf/wZ//za3fLtP3Ld/92jHFT175yZAHBJIlAzLGK5EgpqAoKeiRFKD23mtYxobKZsLFjRnVd16SUCDVlT4GIiERNeWmJOakCYlLLpROUMDIkgip4MzFNJjEr7EgBmFusmRmR1YrkSglV60MtcBKqFqFGukRr2HXOJXJJQfvC91gAqGiynKWNgkRZGd0uJTD5FJXRuyzn2KQPnUD0LuXSMISUVRFCcgwKhGxkOXaHqC+BqmaiCkzkGQlj73eBBbvt9tjRx9k0y1pE2GrrTi2TYTIDQGTH/a4TRIKthRkRMccl41jZkskNJtOu64qiACLTHqJNY8pmjymPyHqMiIQIDUbqEjOfcnkujtE6vZwdLGLTphhjl7gMblZ263q+8HHZrM8uFreOuy4x82y+aOsuxpi62BF79i54BOpUDNU556QvDZPGIywyGCDlEl4ZjNTUsiMLUteGEMxMpQMqYMB4yKijzjkFJYaiKn0R2Lsnz5cHHN68dev0e9+Pm+XtL33h8uz0crW8Re71G7dfnp49/YPvvfbGQ7fenJ29LIoCoxRFMZXP9cXy7bv37964tVgs5mEG3pr1Zvl0BapLgCjN4mDBwdV1TUzeEIj41rF77ObHbyY4smojai5hODg8iMtV7ArvVRUVrU84Z0KPogdVcbpZd4GOqsKva0ndJjVx4W5+7RvFo9fiuqVVc7Bs4QCe3eB7+Fq6fVSUBZ03m47p8HgeA3TJV6VIAuToeYOM0RWire9M+ao+mmnlmm0/AdjYa9P4jK10z9ZvgpxfDtCjdHA+qg4w41NB6EKR45pVlZhEU4zxvS+++/zs5YMnJx9+7w8IBT12TfK+NIEcGZV3imSlHgwzgumuhOj31NaR1KPmDW8elQwB2LEE5JGQ0SjAxuP7nmUFJyaQ/L2IZLwlyHZPImau2zaEIDFqX+sYAGjEXBjFMA2AEFPZv6eywCCbhtJCCMOhPO/WLKfGvokZEAIxEaaU1AMiJolsGJwDtShpItcmWk4U51y0nlGTI7QcXLefkIwTyFQaclV6IpnoQPlDyhM4GCZBDUQQAAhVhkTqoUrU1u1FSAPoSB7m4Kq3hGZDfNoobsm5/IeOiwUKgGgQARGAEc0oA0FktQBHskDEiUNkurg7O2MwpuYzELFX1bYTRx4RkVFRkxkkAQAHjAz5NDvulyQdILhsyZi8pX/roGnmE+TWfG1DweJpx0QEHUOfrzjOOCBCEcq67VDjrYPyF77xpdfv3rx5WFFstkMxs2QG/REfgTOmcF7IjIWpqkz5pZiRkcDIcuA/oxL++/f/xj/60R81EzUVNQNJSdESEYkQkfvpD3483OfvPPybWelh5iSow8bT3ilKYiomKEpGkBQRe6yLjBup5s2irMRUBIBQ0CKpFkjkq44zWjI6M5FosRbRJAvvc3CGIShbIk0MkQBrRDIiNOcAUQkMSBGF7nWOGsIlwqXnTVksyW1AW6REEBFr5ETOyAuSqs4UrYd2BUVAJLChjpnBuDfsivqfW7ZMjro2EWUfRz47Te8a91hPE3m1DPJZgUZ/kO4Ee46KBbwim1+xD5vMxNC/Ba8xV1offtQD4ar2hQbzZTkgWobUp1EztomFb8rpupR8Gdio1dSYrhlq4NIVKj2jGd8YQnDM0qQYY2y7eVF1XacxHR0dkGm3vkwptW1Ljn0IiC5X6M2lZACmW0mBcH9cQ2m+sW82BHT39wyx1ZkpX1xcIOL9+/erg/ny9KUzulkWJ89OupQevPlGOIDnZ6cPbt99ePPm8vTswx99QI7noSRTIDJJU4MPgpqmWRGka8+b2pJgPv9h5owcY8w1JwtXGDkGLstyfryYzcsVsXCY4cFCb/iyAmwP5nMAk5jU+lC1KJKazSz4dnXpRVQJXKnkltrFg8Pma289/KN/pDy+BYpQButa4HDvcLaMm+qN28a8Xn7qDmdFVbWxC9WCmYEIjNAxMmXEKgFzuDfJcPXPqwT5b9CuKYQ9ed1UJu31gZnLsnz48OHZ2+9cPH+63lwSOu8BpDd0me1X5Jlu3r2nvdJid51PxIYw1XG/43XbcLo10tB/Hi0ihDDI/nazQWZm1lxSRA1pi74/fWAuepyTA3Cwf4w7dK+fI0TCtOd5MjOCFE4OwBmzJyslJtJHbhmoqsSUWfY1C8SEqoQEI7eDoczyZBGnjQb8iJGJjVVaYMrZAHJXMy5cn4KU0/Eyn8wgbQZTtpZjGRExVzAoZ1U+fq/r2oYMu3FRRIR7rOKBgWQfRx9mP6QvDJcrAKEbaelaCkHcSYvdyXCdEEy2rW4XF3ub/WjjGcVHvmubljI+B3rTkE2EQVbishmnT2Ye9NNRdo2ENRqHAADamEDFg7x5+/hb773lpDVZxm5btcE0i9re3C2E2bCkmp0UCmCm1qV9i2Ju/4sX/0X+8o//4X8CAL/x//6yYQ6flF/87D++Slt77Xce/a2cEsLMAOiGwA6RZKDOk2TPBSE5jlG7FMWUiCAhorF3nOEsRR1y4UNpPoOKJ8NkYJZEEYE6UJFkhuwdBURFSglQGwdJU0rJRAmRCDlqNLEyCmFi34Zq4/yaQg0+IrdUqKOOaQO2IezYtwQphx0RKrEBARABU0IzMlQwS1kzQESAnPaC1msFO9t48E1OSGI75zD1lMCW7Y1X0iSHfoenay6vDDDgZOBOnlqvIeS+5MuytoBZD0OAjAaGwNtNteORgcFaQ0gwopeo5UK4+b1jr6caxshnx0NSfpoQhFxSHrlz/lknT8zeLA8oXoJnBAU0E0HnOPgAZZzrarVaXqxu3gyF85oiF35xtGhQ6rpe1xsgnDvnvTOxJAkmVebRhjx4Q3RuWAvNgcR9t2Fr9pxu5q7r8pmhKIrFYrFarS4uLpxz9x698eLs7OXy4riaF+ROP/wUu3T/0Ruvf/3LF4+fr58/LxFRwWJKlqoyKKLIBCUGAHKymCQYjdJ93BOYGbmSqcguQgBq22heDg+Pb4f5HXZ1VSZfHHh3mKrCFQUtcAOAGqkTosyXk4oZdBgZ7OjwaJVkfrCYHx7Vqws7Kr/8J/4DePSg4yJwaCpbaTzypafigNbNZy/Cecsn5/5wBsGrpaZry0UAUBy5G/079qV8DuoGGchPdiVAX5+l76QBmDFSCP7h66+vv/je408++uiDTTIhIhUTS7zl5EOpwv7PnceOO+6qujC++Zqv9kT17gOn+3r6jY17Jp8TABCga9vZbIbMIuK915SYOXUxCwLc7W5+wBRkUoc22c44dm/UqsfnTM0h022730QFDdRGo86rpGw+97PZkJPcT/ie3WVkmKPtZ/SY5KyxPDHbL53LqlWXIhpkhR7zm9XE1AGPO3zKjdH6AFIcLCUEILt8dRrH1h8VhhNLZrhqRkg2oC3k1k/yJNzoWla/1xSstyhnR+/QW3K9wjqmcfURHrsRPOMauSkZwSQd0UBgl7Sxr1TZ3z+YsvvPYtlcxtseApiBkiuLAuvV3HGJUha4Wp8WcbMdnnSU34VgZtEMAc1ERTIaa84kzQF0WQsZJcT/cvmX9ublF/7sv8L/439+db6m7R+/9l858ll/NO2nPuqA/jtxayEiZUpFFAAF6GKKKsjUw9BGYE9owAYFhTIU5OeqqmC5Jiopmhok0DmmmGPxFRQkdaaKAEJoROp9RFVDc0xFaZ4/m7WtQY284rDi2YarDfoIboWCTJbxz4wYiJVILbEgICuQIQFiQjJAw9r1R6HMFwTMegPBVoG1wbRoiG6wW/baw0Deo5DOW3L8PBHeW/4FU++vjnsM8itsV2XsqShTn/V56tsof8LxeJffAUQGfWrA+DobdnJPz7sMiAFlKPI+dbiO3GFLjSN1sbckJsalB/LP2ssPUnd3PvPtBgHQDHOVC1NgZ0jlYpZUVi8vVucvb9++Hc02m83soDo4umHIm9XlarMBomo+QyZGRiYzNdFe8PSbVnOJRNzm9ewgoo6whxlEnohC8IiYUhRJZVl677quOz19QS4c3bh1dOt2fbG8Mzu4efPmRVeLQ3frzo0Il89P67pj5mpWrlarqILsxYAmIWNIwVTRBACcd9NJM9WkJjE5gxCcEiskAbtxcHjXijur+gybDZROfOxMohzevNXW6D0jZJhgIMcZUb9zQm2azxeoWlQz9N5Hx1Vhdw/x5gxdKVEUuxuAfLHenHzqnp/YeUsHR+W8goO5pEieiZ2YAihPsBFz9WAbyv7ZKzjp57etANiNmfjXfc44ezTJMJqK0oODgwcPHjx6+63z87OTF88kJU8+Ysy7GXaPy7YbNL2rMVyfm4Pb0/OOUWSU8eO4cF+P375UVdE7UzW1AR0TAHJJRxTTKMk5V1Tl+dnLiqgoirZLiAi4bzvJn/tIuF1OMnbvVZ+nqzBNT+07n2dhnB81NEBCImJPGZ7gmgnKqXCwPcsPEZA7bGpPpciBenuGFhogLpiZhpAUgD5mdSvscTAS56pZu8McE0Wdc4ZY13VOnKHd5cPsqRn4g00Upr7gsOoesW7fMVnr6Z/XTM5kybbvNSBiGoC7bDDyZYpinL5n2/btKluam8SkmBkM5eCGyjIwcJ7hsNWrhDsECgDeeRBJKT179uyTTz55895Rvb4om3bswWbz8pI7IvbeM7NRAX15AoFe1VBVYfawjUjVHPH3qqm52n71wV/J4kpVAbBfCcwQkIY57CAjr7GggeZqyHnIpmqihCnFTmJSQeTI1qWYJKEiqpiAAwzO23ymqgTgiBDUKOazOHVGKqKaABOYoIojIrKYeF7arLxUe5GkmZV8+2Zx4/g7z87ErFNTAslBk4hqSlAYoWF2hZuaGQqgmRuDfQzNUAV7o92O8c3AYKrCTyhvMr37dLbHKdRsTJW4ej1ceSlODchuq+PuGRW25Ecw1ATsfb1EZLRVq/M7APa5raoxDgEZg7JPBgaWaxPujdom7uopVfe8Q3pEEENaOfpM4gnivAgEgCKQhEABWMwUlAJX8xLUmtV6s1xVi6rRTkSC84vDAyJarS5Xq5WZzRbzwvvOtI+fR3TERJmVYLYyjNPNMKjaJqqGlL2tvaNFpA9Sy0aOtm1zSnnbts8fP7mNr917642D+UJWNcAcQBpCe/+DwmgRSjFKqeNZWRCoKqpDYl9U4+T4amZmVVHmlH0icsFnZioiRVG0sYsqZVkUvvRaChI6enjzzt2nP3qfVi0iGDzT+qRbv3Vw3503ntlASBJzrupjirAo5k17udo0UHLXruvnK6rrmcX0L/7F4ulrtmzr05dct/D4rF21dOsY79+pvv7F7t5ixXrEQc6WpAEOZ2LGOCi4avhjLQ2vUBquCsVX/TrSJwDgxKBiuuXL17z0yqZT1ZRSWZTHN2689e57py/PXr582dUdzzAZom1lQD5c/ts0RNwb014IIV49MFwn+PtfJ9YXIm66FgkfPHz91o2bP7IftnWt2RBONhq8xxGM3ocsn0YgqBG4DyacZzTDTyXi9ZKr/w+SKQFkf0IWT5bDWGwHyXQ6HAWAfLyxnmtN3zXlDNMbs21jrEs6ImfmXQNEPTI99kaUPr4SMStb2qXp6myHNswwjnaUXG9r0u3eypLlb++SGHmpQcYTGCZwOp/jEW5CFVuwk+spB3Dk1VNqyC4wVaWJ1wV3K7xO/3W7smGrOarqGEBnZkQMkGNYthki2/2GCEa7qeeUh5ViRwZ+cXhyefq9j59I3HhO5Wpr4Wjb9caJc0EseO+BM4EikhFkVYYZMUpvimdGVRKR/9Xmv7x2aux/959nI8evPfyrmQFlHS9Xvc3CLENjISKgkgGAee9TyomFPVQfIBhYUhFTMRO0LqUI2UYnnbdEmo1HSpA01aaQWlqutC/XyaOTj4njBsFRckXnuPPYMkXHgtCopOA3zl8gLJFSNYdyhuxe4BwQjLZBkTk3NZCZoZi5rANmDQME0JmZUT5+ZzQxICJMk5nJFHnllDBSCRPFwfUwfAdwBT4PJxaNycO35tBXUW3uYQbjpuEQP2jEvcKUWdPYsTHeBLfm5D6qfKoiwGjHIyQAZM6wlWZmkwPl2A0YwtH3vhyvNE3IiOSSSFCCUJ2BfCzdQ/bOKXEkQQAFi2goqoBInu7ev/PsiZxenN+fhVlZdk2KkIqimB8sVLVeL9u6ZmZGYkfInoD6ZelTYbMqgQDAeYeD5eImhGSaQHNpvh4TFQA4hBi7EEIRQoyR0LwjwqBRz0+e1c360Ttv8/FBbJvF7PDl6rI9OX1ydu7Ebt261ZCJmisKTQnUMfSVnHIrioKIOHtRhlAeAPDeI6L3wXVOLBU+gFlB1AGgpNfefvP+8umh08v5AoI7vTx53L48j/URU0qpa2vV5B3lMF4RKZQ9gkDqWLyqW7VFku7i0v3o+ZOmS5sUytIdzZn58N236Gfehq9+Ae7ealNbbjq8qHXdlGUFnaZ5INAt9tzE8A8T3jpd4mtJdEqrn//NKOEyMWcmk9NYP8cAgtrjLuAgKczMRM0sVOXdBw/eePT2Jx981KzWlrf2xIa3FZwTRWHszJS/X+3tOBV712w5gG0liu0idu9IJlHQ4dCy6+Aws67rnj59enl5ua432WBgMILdbP3yO4JjspGv2hqn3d4bxXTgW1Y1cIMkKbDLW8gR5cPk6PW4ShhpzKwEAERQmyqs075NmadzLgeHjUITJzL+mhXJqXwIODzQT6LBcssxLApGjs0sxihmzjnOgcZEZj1upg28DxEdUdIR88im3DnjLg+8ULEPethRBbYTOJ3bCSGPNSbH2csCXtRg4k/J/ifoTer5+duFRjQ3lSU7i60IRmZ9VFoulp0xhUbf81Qjmeyy3epuKWGoqKxA0ocnF4WHR3cWU0XdcyjLktiTd8jcaQsCnKOvEfvkXkS0hMA0eASJ+f+2+F//J6v/M1xpv/G3v/jPHv2NBGZKqpKjavP2UICxDBry6B4FMxMwRUhoooKAMGQQtdIKmJgm1QSaMFuZLSkQGSkBqgEqczIW00JUiSPi2ofI3JFLjoF4PS/RcWRukBqCxL5B6FTbGXeqtYharjse9FK6i/MZiBEDBSUSI1UwQDMQrFHFFAnR94uuhkZittVSQZUznquObDHHVOaIFegXbKS2keZGT9mwuzK17SDljYS+x9RGJrJz/eS8bpNEspHP9nsVzMCyoWz6eoI+KANGnptryNM0fmgcAkz9qVElpYTQI5NmyyczT9EPpwB3Y8eywi5g5hETumQU3Ca40wQdIZAvuEM0U0EztQ6N1ACJuXSHN4+bLi7X9cFsjooJpeu64Nx8PndIbVd3TaMpVQeHuWhiSp2KApj0qTeMqkPcej9qUCNGkaTGaCAqpkAkqjCbzbquq+t6Gq7vvecCHbqL1fLks8d3Hr7ub98CxfjZU6zbOTvyVHdNnTqn4tlpSp4VCLs2nf6R37j1q78AAAf//dcv/uhvrZrOOee9F4AMhJy5Qbepk6ovXOdcbFpfFokATOD4+EjtANQbtoiX0r48fVGfvjyKFrsmNhtS1ZxBkBITSZQqBFLt1usuCYHvQF/GeMMoFeyPbtDtw/Sl1+Zf/yK888b5naOCXbu+XDTgkodVK/MAx3MQz5yTZBGHRFL8XMH/KoVjqD+8g6hhfT7BzqYYTiXXt1fpNCPBj4w7/xm7jpkPbxy//ujRF77wXrtereslkmUntY3ZJBOde/rnNdJiV9pdvSC3aXrCZGfvGwLHnvcQvbk8Ui6zAGBmse3KWeWcSymdnZ055wDBRBzgkBeTjZa9wMuGSxwMqzCAfl47b9eqerArJveu8d47Yk2STe8Z5P5VzxlUG9gL4BgDOUdVbKpt5O02nZ/psubYFJqoOJmNYS4/OQSx+lCMcz7tjA5vlCFMBA0RYFoOvmdWw100hL7ZQF+EvRC3bBGGvsM4edHVqdhO7KRXqpbPQHuLkp84JSGYmEwAYPovALgR3xQRx1021RkR2DmuqiozYlM0FUAkdI49GKl0OgESmcwdAoBHELPnZxdlcJ+dnT24vUAKgNssFSRH5IzYzJLKdBbELMYIoohoOpy8+0rIlJ0sV5uYERsomZoKGCgRQsYY6qGf8vg1Z4ZqBlVvG8jmTVNAJICkmlJqNRqCgkUVQxDOmU2qCgSGpiAGCOiQPSajOsw7gJp9U1ZLX1wirYE6puehY/KGPqoCBecrBe6SoHTgCQoENUtKeVcab5xHRAQEFdAWVJwpoamVor07T5mETAwEgETQwOXoZ4OM4KuKOci3VysBABFy1g87mFDJuKNGidtT1e42mPJK3SXW6TZg5hQj7kaGZjQRN1hTNUOyj2nVeg0vmFBm33hQuzOdTxPtiAhQJcqoCqPpNNQjpwM457J4Hr2w09hyGvLcnKPYNQrBsysjqVoD0BZOW0M2dJyZr/VWzTwKrtval/7oxvH52UtLcnx0xM61bWutzKvZ7Ea5WvNyuVyv14Z+Niu99zik42dVwZIMEz/ManZioqnlsM7e0JiNIufnZ0VRMPe56zG2db0uigIDBSEPfH5yetk2N+7chU5XT16Qroui6rqmayzMq9h2MdUHxTymDWQogknZgfOXL8yGOgMjzgoAEVVUNalpmZkgNm21mG9Sd/bidP7mO92Lc/Wybt2m9Hh5mjo3u2xW9UpTlNixqRFYSo6oqmap4vX5BYpmt2CLGOcH8/s3NgeL8Pp9Xx2Wh4ezb76Hr92O53F2CaHe+EWxappyk6Ck8OadjefQGA9kmul4tJ9taXtX3rxKAI8e7ynl75z1XtGuenBeJTtHWOeRdM0speTn1QwW9+8/ePfdd0+fPf7scYtAIMMJeHjm3nbbdnIyrumfowzY2konPcSJBeXaJ+x9psG5nudTe3kH3vtmUwOhLwsEAybpovceU4Ix5Av6gpSISN7bdRGXYwYZTIwEsIvDsbeOO10dxleWJRm0KQNcDpbm3eTPPUUBJupLPzm7eidMdLKsT8BQhWO6NPlzP6KhjjplbA8Ecn1t9tRFxd4fYVMLR64J51hj72YCgJQSI3rvU07tGXAvt7OhfUangYFBD3UNQMimlt18uVJpTwK2nedrKWqvKajqFkzFcro+YD7Sw8CpoE9kQ3mVwjE6442QjBF795KiQY4DJROR9XqpCKJC6MiTiWzqFdU9ECwgACZEMEVV6bOlMuhKMUsxVk6DdQdHhz/7U9869HpoBcBZT8Hs0DsDSwCMBFGzUmzQoqknFJQYY5Q2paTSh3Z6z8z8l9x/9L9Nf2s6L7/+N94pGFsQNlWTXA7cACwJIjKgiDKRIcYojXSI5jwzc0ZiUktiEqMIghII2gZqI5eIhA0ksYlBa2yUfG1G81lCvxGn5azhokb6/QWHakazWSK66Jpl3SQRIA7uqOtFOgNY7DaIGACUk5mBEJKjwimQiIpIRmSDXo46I+4T0sRy5pGamhgZozEpQm+hhcx0aQhNSBOF0szALAeTgvR2+UxAUQVNHTpPfTWHfhcZAABhj9tnvdaPAKYIquqQRhtY3htd17VtC9BndNrgNyGiwC52cX5YHRwcLJfLTdp477PsJyKRlB15O3FkjiTndlMO8s3kSxmlB5loyPhCRCJPwVS1qeue0MkUQVAIKT955GuZXxAQZZx2E0NUBCAzBwnNOedaZE9NxSypTMXTLj4N/JaraLkCdhuAYFyaqXYJHYFq7BRwNisZbzTL+vL05a27x23XUVEq2LJrqChvlNV6vV5drtvNuiyKqghVCGIYRQ0YmYlIUxJRz2hq2ajQ1RvnAiObmMNsxQUkTKYxNUTkiUEjoyFD6uogLgKAoYjB6vL5k+cIjIjqKeqGAEE1XrRmhmrLZm0OckDvjiX5ciXaioiAMXlyDAgi0okIbUpy0ljHqN5dtJsyhDmxa16sWc8vl5FT+XL9lcvmZ97+YmiX68vTOqYQQukctxuVTrw/qzfVJa0s3vSzzbpZ3T+6/62fPXrjkf/ae1SGCJ0/nEHXxLOVX5qf3YD5wea2q16s6KNP6XBGr90XRlqrS15LA+8tSog4M16TIKENavYoBkaZ8SqFwylYTsaGAd96qjhf1VSuPAgHQ+D233E+zRBNRW1Ivhy+RGTUJA7c7TuvPbn35P47b3968kl9eV7ioUFO8rbM7lWTxATEmYZzEoSZjPqEmWXtExHNEHrUBukBg3dPDmxg2SpOgxpklM1FMcayLMVS13UhBERMKRGgI0IiBZAM7I6gCKZKjhHRkrACqDCSiQI560tJAJHLHiRQNc0Zquq9n81mANA0TRQxJrQh41EH3xj2AO+8KxqzF2RUm3ptGImIZrNZ0zRAqITR1BE55FyObBTwNFRxAgBDIINpcWEzE4DM38aVxcEkk3mdDnAgI11NVajMRdUMiRKYCz7GaGAPX38Aoh9++GFeu1GK9/cCINGYMZZf4b0PIRRFoSldXFzAiAXCQ4k1DDkwl8kMIVmf65AhrzGfJIeZM0DpIhHlkpkjVQDAtKzEnrqV3ziCwRORqJiZ45A5dhebGKNZYvZguWKljUe+7GMZ/U8GkOsf2mj3BugtZvl1AybHBKXOJnk4ZgCQhSVAr3wRUYyditw4WJx89skv/4k/9pWvfOWD3/vuThZZBk5QIwQCRYx5mnMRNRAwEwNhFCBNKhpTipaa3uX2X/g/ycH/Z+7v/D++/ws3Pz6/UwIYiEkOqkyaRhbQOxIxI0kZMwIzgCmAalxj7ZBQcyFPbVRXlmpNwB1JGww9ICC13m+KWe0cimtR28KvHdcuLL17CZh8cBbWovHyMgEqoCoxMuGVWIHhHwMEy0sIKipDftNUtR/vItri52T3Yb6YiLJpbUs3A08ZoWqnz5nun5EBZUoY8+CnDNHMRp8fDuYy29Vhx+fkN+6F9I5Pc85ldaRtW51A4NkQtDt9sg2hGzYaaYYT6FCUZBuDPQ5n+l7Lbv2c8zkckmKMve5HlLNtR8HAgAaEtG/aUTA1SwbL9Rp8yYjKUJpjoKQR1bx30sWuE+fcrCjCwQGprc9XT588v3H7FjKt12tyAQBMtSrnoGgpglnbtm3sskvReerh/NAIegbax6O5kgZgPrXePW6AmOPcDAFwe4IBABEcPKo9FpSRiRIgGqmoaIaOhQyBE9shWG9i4UgGrISAGR0VEiCAJ8+h1MKZmSXzzmWjVjmfIdN3Pvjo/bh5UqT12em3i9mffPCFNxbH624z66jEstnENXdUQkQES4fhOGFN6AQtOLo1K49mAWYuYbtZsFOvq7ZZt6VfROeW8pIpzr/zBD++OCgQ3r2DkXHZxaoSU4CcNA2WM+xgJ8dqjxSv+XZc7r2LX33q+xytBQZte+8CRMynuKuNwDQmZC58uHf3tZevv/Hpg9eTdNCRxIhoznlVbdsW0dgxkdvdfThSy94eHw/uNjkAjB/GTTGyDuLsswYQq9tNPsojogKQc6CaTyv9zs18QbcJyVkojG/JBTWGLoAK5DjO6TSOgYeQz5wD9A5wnxOXO3p1/m13hsfPZlav1jFGTZJTVMxMwHKp7a0HJ4eqDHgeuT7VyMdyl0cTwh5jyYiUvbNjl1WOf8JUXKqqaghBRJ49fmJmKaXChz3vBg5tr4iaDgVWccJjVXUL0AKSU65zGJNDMjAjBDEiwl1nECIiEyD2cO/U19owy4UpBgT0yW7wziH0pfiyZHcuQ+LqgJqR2QCOqF2DpBuoC8DAehgJHRw2ikPdISAd1hpymq8hGI3zi4hTVKKM55RPwqOvCAA0JkdQLy9vHi7efv2NF89eqMKsPBxHUvhQON/FJqWUohCqalIRjUk1wWDkZFM2AxBlsyQZ1xLMJBEx/Jf2P/LVeVtQUrRNNNFkllKKIoNbbsCAI0PJaqnPEiupSIqlYguy1riy2EHOelaGVIa5gBikGnED/tSXL/z8kvzqkM375KkRMV+0SOukNJ8ddpwjT7cEqhnCB6EP0c4uAewn18bYIhxDkWk3smkUt6O8hMExYRMr997GmG6DqyFmsIt0S0zTP2GQc6PeDVc2Ng7xHWamZqqSoo4aDA8EsNcfBOjaNjtcOJcVASDEKLmMbj4SbNs4tGwCRGDGEVUPIZsNDTIiYE5GhsEhMeUQOXQtdm3fcyYFIKbM2zQJmCKiIUJG6vX5/7kGgIJaBG1QoSrnNPPlpm1jkVJEa0BmGUhDzbmsZEfnLJQlHNrLFy+bpqtmM8chdtFIiqJyzhWlpsgaOzBBRLUk0VJKwVHe3hCcDbFOU+Cj/l8djTrbedYBvRERoygREDlySEaIaAJKSkgEqIhMvqcZVCQK4Kfk1HOZqmQs+lVAN/AUds5toCP2iOgAnSAGd9ZtvvejD3/19OzXoHlS0F2FXzy68807931b122j7Er2VRkaaTuLZXVQJEov6tbHTQk1GxUY6vr8X/3Qn63C5eXi8EZ9vCjfeKs4vqOppeNwU1cXTz6G73wClxHeex1ncxODaDwzc8bGADoChSoIQQ95O1It/GRt1GF7896eeWNKVZ9rhd5rveSY6HPD6xAAPHHTCUA0K+7cubN+89Hjx+9enF8uT88QIadBxChEwBy895JskFUj0uV4qtFRegEAoJoR7MafDt3fJqOOew0x461iURRN0xiiYY/En9WJcdTEZGZZZ5nO2FbYwBA/B5BlbiZOQsz1sPJ78wFAVW1I6h1vz4okQF99baph9ArB4HrMLCkLBTDrNo3lZBDeBhkYQFLN8YgiAkN2sZg6oL2eA+xoM3tf5it73jhJuIPdk8+oLnjvu66DAGa2Wq2cc4UPNhiW9owoI+umCRhrBmKgQYnpNcXhwJlkAoGa04CRspcFJ6w+swgYXOfbwSJYL897ADG1HeKOKSm5vPfHztjwnGyFHa0j2fLdz1I2gFHv1nQjNeBwslRAzkgY2MMt9ZEnE8nHg9nQtpo+Ig4FR4adkJLMqqLbrLt288u/9EdvHx++fPp4XlTd8mwciahKF6WLMTYiiZ2ZWS4ba6LA1ouBwTLDzNn7k8tuaWddSsZC89DM3TK2Lm6CQAJMkpJGHXA8QQwADDVnV5Lj0ZsgImZFo2ltsbUWHQSm4JGNmuRq715W1XnpL0N5TmFJRQ18EjIKQrBOXTIPbgbALbdo6J0PwcwkJk1JRbOKaf0GzFsFIactad891AwkgJBjINpupLyRMkYtRIcU8OxiN7Oi2OYXTPfG1Cc6VRSuqiD5sfl0goiK+WQAaiBge/nf4+cta5hA/CKi4y1q/pTB2aBPjIbEnq4wx+uREQpYTt816sGOBloDoh4NZgwfNjOBRONorB+a7hxA0RCIe7xTdi5PoIIBgSZRSToCTmcRzqhAmpF8DcUsIiLh06ZZogPTDnWuos53aIcYohogBucNadM1GGlelIvDObNfLpft+fl8fhBCKSKpi5oEg2czAGXwxGBmXZva1EEiAIASvHdJe2Bj3C/MsRVaRENZbQU1MDUihAynZwhmhOwyFj4qZKbETADM5II3szEta7pSublZmRyqKhqg611mSTWKFhpatCSpbjpsElfF03b13dPH379x+wJmh+y/NoeffvOt+WKxetbOwDdloaFidiF5Tg0YrNQax3I4p1sHvKjm1fygXLgw4zs3+fZN4Hnl5t26bg6QF746P8ff+/7B+x/L8dH64QHfXJSdpKqKkIqUGFB7eBYE7APBdFda7A3tWlkCE22jn96JleTaW35yjWOvA8Prts8kM0nSNZtQFHfv3n/7nfeePj85e/EsuxZi1BhjNmLVbcvAYxSITXyjsGvmhMHYM2QVWPYhjGwftmxhO0ZV7aSbVQsaUjD6jWY9fyDoIfYAkRGMME3iarfi1iCLt+z0AQBmxN5hsuUJ+QSV77QBlwJGbQNRESxZ9nPRZF+7CW+c0rBlxzHm+MytfXQ8B+cZE9O8xRAxpYTWhwdOVYrRUju+dMrlxiun5/DRAzC9i5EAQJMQkWfn2CFibLtrYVNswLHYDqonF51iARMR8lBaBQ1xiwWCBtRXttr22SY2rS1THX1SAEo5thfpCqnnchOjRYcGAJVh7US32Sg2ktPQT+zPcToAf9lEccfsx4A+BsSy1qMwJWXYnX0zQ/BDsvWO+py6GNvmG++9+5V33+qWL4OpY3JhG++5WS3Xwrk+qqr2O16NgI1yuhkCYoKBLaoBMJBmRUxcSpCSAbC1hXpvBXSWLDLlMu6AvbqWiXhMs8z6cjJIYIZw5jqnEJRnMDPPsXAvnG1AVja/dPiiLM7LsgllIgRCIrzT8XJTO9HAQSwBWM7Y6aEwe3+ZGgE5IsfjiUQx59EZ5PhWYrWMxz7a8RCH8gTjnI+knK1/+cuUUmZA23W5ogTolSykPd1l/ClfPPVH5s02NbrCLtvFSXobXqfgw2R/5g+i6rzv9ZseMIN0yDEbd8LYbRVFItjhoSCqPmxdRWisKJCx8Ic61EMfentSJoQ9ptw/TURSypoQ9Rl/qNrbXsDATBBAkDqAT2J8xqnwIXgoUkQASG1S8b6IbSemjl0G7YkxIvJ8PieiZ89fdN3Lu3fvosFqtaqKgj0TEXgHamJCAD4weSK1lFKMMcYuqmRcjem0E9GeRTp/2XPYgUORdww917JcKTff5LK9I8d8BwWDHuAOAMA5x34LVYSF94QiAoA4hMj1Brw6biwBIRskFUFMVYHzRXv39qI64ro9XF9Wizkd3wxq5eayxMIvZutNXRXFwc0bn748fXHg3vqFnz/+H3wbE6yen+rpshRHi5m9cUtuHdLBDag79jSvUD5+uv7nP3CG1S/+NKY6JnMHMzASsAy0DxKRB4RWJMPpDP0YH8pP2P51H7Jl6K9+TjZb5c8pKhEZQIxtCOHg4OCtt9558uTZyacfXF5eauqQslGTdEitst7ksBN8OgJd7AhINJwo6K/qz1TQAkAXG9FEug1OpFxOHfqE2BxwANmwgTtP4z67PYuGvmW8iiy2eisKIgAOoHYDxxuMk4gICJLvJxwjd6/O6h5rMrO+kI2ageUI+j44bLChUl+VV7LsFJFrNMvrconHNoTU6DTxYqqFTFtKqQwFACj0YhGvVDAZOfnQvX2L9XSh8zUwAEoZAqDQAMdG0zkZXjHeqwPzz08Wy6dypCFgpVcJJoH8TDSe5TLbz0AjmTbGIeMVxUARqFfCDACcSAQAxYx5gdvRjwY6nEKgUO8TzIoZ2nRgNik6RwMEhQ/F+uzFrGDoNjOHeBika7tmOY4ELRGSQc6xEkkMqATZWGIK2fIDxL6fCMr7NFdUAQpMYIi47tZYqp9BrKDrWhPUHv4Ms3aG2atCXkTUBAQSWjQVJGI+tGjOd+wvfXFRzE59ccZ0AQoHvjbaaIjoQIkgOVYX4MC4A1VJ5JgciYiYMBEJq0hCJSKHqI4SmprmDaDYU2IyQzEAYJ4aNrdLNXrIRs0gbxgdUrH3THl7isVIx+NOsIkBcKSG7fa4sqPGAIvp+o6/Til4b48NfRiv35GORtjXwzRLkszMe69qOcxlj+Xh5MAx2gDzTzqx32abblaJiSWnqfe8LGPn2NaaAoN1J7O/bM5FRGJ2GTOFmIigj+sDswFBj1CAzqrFZ8I3fHELILkECl5IDVL20JBj7wJC27Y5fkoTVlV1796ds7PzFy9eVEVZhoCIXd14750LSkmiiBkzF8ygmvPvk2qOJBnPWL2AUdidkzz9fTan9ocEJe9wMDaPZpteh9NcWU9G6nLOGVH2E1M3AeuMnUtIw8GoS0mkZ9brtnXBMTEBVkez6u7tVb3CBLjptOLWuQuS1sT7kg5vJdcVVsGscJ4oakpKRXX87hs3fvZr6fAmLDt3ryxfLyFZBykeV8W8ONM4L6l89kJ/+181Hz9efOUL9Id/+iTArY8+m/3oDI4pLZxrEyXEeZAYiSmf6yTr88jZwDOy6Slt4ysA62BwoOyjM/67aHtCcfRi55ZMvfcO0CyqJiK6devWm2++efL43fd/8L2Ls7YqvWeISRXNhf8fa//1NMuS5AdiLiIys6o+dc6552rRt8V093QPBgCxEEOAuyT4QK7AyxrXjMYn/gn8j/hCIw1mfKMZSfBlzWC7AAk5AiN6emZaXHn0J6oqMyPcnQ8eGRVV33fv9mA3re12nfqyMkN4uPafRzSvMEUzMlUjMzI19V4gC2AyNufxMPf2S22Ue1N1cOcQwzr0d3fbgGQgTNFpI4QOSRdK04qHS0sZT2EaDfSZmUEp2SjoWDnnlIT50AYIKmUutW/oEAbu+FyQsgARAK32z10ETbvCJ9stSxGNaxUxRk3p0HXZ8VNsgeQRLUZL04PtkLDYaAPWtEb3ICMc1KlGhLYs0awLYZxnn0s2c3DI014ki4FXgyD3p1kfa2am5vEaIPDolkvnJROQS1GRK2FLgKZ121RZ4Mlgh8Eclw2mnICjJ/T4Am42m9Vq9fz514ixfQ4iAKq4w4uQloIdBhDSas0oAHsNuhmgGjB6DMLTTRHqzoVyj0+jiKrGZ35M4vv9OAzDZt33wdJ0u7u5JiOe9/UGbyACiCCe8+VBHGRGIDKRbNnU3PwFz5MDJShVQCCgmijwqLMEkzCdraGfYdhJ6RdipeMfEwUgMxDHtGATxAycmYlZ6ey2C897/qLvXnbDHfcJ+qyYUNyXEhGDGisSBKb4BrZn7z3KQHc326AYiCQJG2f0hpiEwBxCNsWck0okLCX+VFIDFAFEl/Co1VX1zzX5qyVH90DUG+rRQkQ7gGEfqQ641Iu3IY+aSXqg7GXjTg4MLGEsuMcxy8/NrbQi/Ou7hbnC9TesBwDRcGEEhB5jLJgJuEAJGVhBS9FAbEXfItVShedEj+jl7GYGrd9NEXipKTUwA0JVpEMelrUuaBMGxBCIiAFdQXV7kIiWWjZXcUiQvjD703H7luAqaJI8QFhh4IjjlFb9EEMEAyKOFAQSGkzTZGabszMi+urLL/f7fX9xISlnMwIkCl4pB4XJGnLgEM2E1RCHyh241BWZUWHiWHICDoHbegABAJJCUTQFANyeMMddUxUxRBScRQQUYowi2cxqjZ9f29fXPJdF0wWYgJkJcbg675DNk8j62K/WV4Yfbh4/SfPdOON5t530Nu8H7cTSLrIBjmmKMU45P7+97t59+vZHH4/7PPz5S9in8PQS3lsbwYRiAcMoTzTNf/DzZ//sX57fpYt/+Lvpxx+mlJ5+Oeev72jOsOLUWZ+BxADYQofLQQda8AIBbWmq4yvW0i1807XEAgpvql9/4w9+0+tIqNzzlzAHADTTGIPkyQBXq9X777//6tMfPP/6xfWr1yIGoCIKzEWbR0UiD2RUpEtRbwFYwhOq4DhG1GjzR/9Frk4RMxMVLxsJiCmly8ur6+vrnMXLv1WVGdUUCiV6N8gS+z88Uw+Mq6HVIxMFDpA8ofKonHNpS+bjca+JmoJp0zWjXc8DuoZvXP2bt2WvIewlDdNE0Eqql1bOJiVUVJ0BZUG+eSvrYi7q3VEzJmtqZ5bhUM5ZUvIytOgt7u61jbzP81uu2wZuYLG1iGiz2YjJNE1ZlQpbMDNjZpVSFdwOnog8E06PKdPMeEGYtHuqKixecG+X8/jx47fffvvZs6/skINScvhUBcISOHOu7n4WlZrqDEhkdRoIBGCEqAc//2EbCiN3gqvLVAqXoKmrUdV+GEAnM3v14tnrL35x3veI2M+Naj9P+7H4l7quUxBVpaJw4AIZo1D6Bi8pTqIqIiKW5t24D0M/6Zwpb2U/43w54DCzqap6J7UFj4G9P3wGVORgTB5mFKZ/8fjxxLSNfEc0I6HFoNArjNvOKENU5gymOWebumQB5/mjH340K/zxm5/lLOtV5wWoGaksMphlzxZlCiySl6PnhFjqmgHVF9frLSrNeVYONiF8v7yOFBbfRs5SVdcHD8bJCalnGxrTGRGt6bZcf3ii67RPrsfAm6LV+w9nYwnSYQ1A1iQhVQ8MEZHPxY57TBQJ5838FvRbDx6VzAzy0gvPgyGgAzqqQYajgdISSlPvu7hormBmOecACAEYAzOjWl4y1SMzELl2BIv6IojzMLwRkRhiRzYnTEBqKYshcgxexYqB+75PBjAlI9jtdnNKZ2dn77///suXL1+9etGF/vziUkzHcSSG0IcYo3spAwUksqwG0C2lXswckVJKpb5GSpoec8yGREALjgciuAyq0TQRsaYpWxBXs4yMDVVTkqwWcpYUYwxEdkChBt3tku8/U9cNXd87ujkRwfkZ7OdNP2wuznOgUeRqtfkHv/27//qz39+tuvnycvf8T7+4fp7fyjgmmvY4Z8wyBcoB7dFm9d33N9/7GN55+0XIV9M6nF3ubeZRz9cbffZi+4d/Ef7Z/7e/md66OM//85/c/PTDLvbDqDfj9fnz7fjRo/j2WiTZMEACmBLGCBmbEHAbjjxQ7INn5PTI2IIn7SvgNsJfX90Ql6/HPeRwsf4feC+RqKrkYRhyzgA2DN3bb7/9yXe+96tf/erNqxfztPNTo0xpnq2pYiBCZq/DhNEVRCpAjwpmAIRo3/BeAKhl7265hhDW6/X2+no1DO+9+85utxvHLTP3MUo2ty/V376wEnP7eNE2rDnFXqWyWO0awiHv5L58Lc/B4kY3LMIIXdYConPXVkYez6RKeq1qlCfHiJjZPM8tQ0PEQORdllTMIePawYgXqR4zQ2ys+XYKtrhGTnzP/hnUBEoNrYiAagghz6kaG5VSlz2lOsgjuloaQlWPb4zx7OxsnqdawAgAYmpm3tjZG2jDcXSmmFv1BQ7XBNYarif0WVUNV56++OKLZ8+euTRbAnY+5YPxU5ERiAhEc87BwTx4KZlFREY0AMnCXm+tpQTcf8kIsIA4MQABMQdQc+cOEBItUTrQwDTyTJF//ezNhnXTwX560VGUA7I5JJuFCJHJgIUEmTC4Qq7gWfdsWTVAylkWHA4zy5pTTjRnM7u+u02SJc3Q0ctH8fWloKS18SYh3I3RAsVwl3UUfJlvnl49VQmjBnny9hc9/oVO+7P+LgQVyCpJDAiBgSIYGOQJjExBZkJkoGhqMs4Y4Kuvvrq7256vhjvZpZyJGYnOh8Fj8HNKROaZNaoqVLigd4MzN6ADkS1ZPARVyraU19KcFcwuBm/6KmJgSCigbOjZ17rYIiWyiJjmefRS+KZ83E+mB+FEJHaxECuhqjoIf07JyWscxy5EQwDCtqqfDCAGgKWVGhRUNDNjciWmuOmqvjJ0HTAxUkpJwTybxxQ0i8MUIpGIkMHF5kxV9/sdExE6jLwiQameLiEPQ691Wwwj8byyku1HgZcELhWigICkwEAqigir0LllJiKSsrMDn3syYQUCMiDFkhAehPo8j2RfBPjhatXfXk820mbg7USqaTda3xmhK/yK0J2v59vJG/9YyoH5yeOn1/Hm+euXdgtd14UQNNuUZgkaYgzY+Ra7bEyihAGQs5hwpBAIOgIlQNEEahwJc1ARAjPTLMKMjrqmUOLKTJG6QNV3lYyZ1FQhIQZizgCjyCaimHDoIB4sSV2f9Ty4ashIMcbVauVxPYC4fvzOLk2vdObt9nJ1Div842ef//rz53827uDX8tsvXn/8ox88/+rz9OoZjtebFMfLyO9cbZXWH3730T/6x/adD7emb80DPOId7AMJP3+x/+d/ZP/uL/d//Mu3Npf6v/mb89/5Tsh4/mbKZ5CvhvXzDtNd3K5yotXqjM0AExiKzUxDnmbk9RT5FufOYpdp6mFJATitkG3FRv0GFg3DaQmttDAWAK7uw3sBmlPW7FpLydYDXaBsAJZC5mYQh8+KaEQYpzG7kbLfT8MwvPvO+9/74Q+/fPHFr3/5l2ASACVlB1DwLQcXHllzVjNDJQDwGhAAKG1z9agqoYofMwM2RBBVEUWmGIZpzl99/ZxNVPUP/+g/EFHXdSpgCsw0j2Ng5thVpcEH4J5GXLynRcNAjEuM30wADrheZhhjj8dZ7ZE5mbq+oWaSSx/vjhgcrdEOg/dlmzWX8D1gdeM54iG3KR1LRPU+9pc7PEzUVfvDygDUTuvQBDWqtL6vLVmTi1ZVDTNzUwcBQwhgjnZFKSVkqgYYLAEa/+1JKnfVM46QYREJgih89fwFBtYkKl43q4wEjAIinuZhyB4aNjM8ZHgc9MXCv1HChEaqalIiHIU8ATIBECcsOqWbxMFL/UvU1TwUhhDyDM5aDcGIGImRmULA4kL2o1SD34djWf992GlEROTGVbbMvw0ulRMXqJ/m8dnL1ysan57JJljQaZUUoERz8pS2SGL7vuskRnNQI893I1Mttto0iVdG5pz3+32BVQC1rGOapjQa5hACh0gaLMv2vWF3N2/vLCRi7EYOr1BTH/+3/83/8V/++9//+VfP0maz74brbNvM23FaD+4WCwFNAQ1RREShp7CEBkrmiycMrNfrDz744M///Od3t9sYO8Iwz7Mt9UJVu7clTsFLa48i7IuELvk7dXmrZVDPw9FeNJ4GW6oiywctSoaIOIB3VVYcbRRqUioiAOz3+67rYow+SAfGdm3GTWRR7ULcrDfe+2OaJkNABaDDqBQr6nlhtbAw8ZppusyrzGKz2QDAmGYRURUT9UZ6aUo1dyyEEImHYTCzaRpbqgMAKHp50cbbeSEiISPwkpyweGvM8LgMrC7mEos5rPmijTUezsO5Awwx5zyrzaKrEBUnBCQKKY9w3CHCdyf2Iec8jZOmvFpt+tXq8vIy9sOLr77yCr0QAhomSyKCRNyxK6K4ZEEV48kIADiiIy+RcNmsyBXEDPPs2w1KYS4CNdtMi6vY2SszGyoRcQddiEM3hNARiIAhcWpM4cuzRzAMMcYYYwjkmod6PH/a6pvdfr8PAxPh16+f/dGvXv1//uJPXhG9ePHqidDffvzJ28Pq5tWr3vD86gqGs34dL+LweLbh8gm8faUbttc7OKe7N6/gy5fxD35t/92fzZ99Ld99+uif/CP4z/4WXq3SiuI2480cO9DrW/jyq/RmG64esZhOiQlLbXNESMsm+n8J27zRv9b1oD7xjf6BhaTu9VI5qC9QYzTf8lKqcDAl99OrRM8uL957//33P/jo9Yvn29s3hMRQHAzQ8OSam3WAxD+eRctJjt5rAFZ6kCIgGLizE1yIAwCQqhoYwiFwcPJkO8Tvj9Q4uxfHqb/FxqY/GV77hKrW0D2W2H6oSSRO4Q+Gz47UrHYFEGFBGWhl/MkN93/u9zcS72hg9a9wLwOjfQXeG+rJ9NsxQJPKBgAOvmRmpua4U+2dbvSXcw8gBrTAgFqT83f6OvMcoOhY3dVNhNX5h14sVByq9efLh+qlJgDPHyhP9iz8YJAMyLGnzMx7s5kZOssj4urcdi1oCbLYwqodhQHIwDzQawBohN7/kgQo9LssX1zvt7OeddOmgzNoqlR2+1FRUU1ngy7wioEZlYhQUVRFQQ1VZjPz5P95nnPOagIAu5QADTEb5CwCIVA/hHXMTy/unt98HWaLoLjaM90R0MXZv3i1/4OMX27Op3643k0E4aq/2EBW20OBhAByyFQDUEGusToPPAGgqpqDZHvGfheDmTEHEc1532Jt6QKNAL7Hi7/Rjv2KJ2fYV7iNYixy/cjzdoB5BUCD1ntxOCEAiOjxwlbh2Gw2nmYsIuv1Opsi4jiOILqEJLnrulXXq6rjtAIeHw90+jL/Ly9M1cyyaQ9skJf7D0XXt7e39cx4kxQR0Sxd19WsFFXNCvv9/sSjWJZFwEyI0UxVrFZnUAGQ82W3nLOfL2YGUGqyvlvegUg1/g0L79Y2YdZtnZIUZ6nDcc57g/0cn4ROkB2teAI1NbZQZ4oEhhY6Hqzf5Xm3H1UBDLvVcHl2Gd6ncdzP82xefqwgasSSRglICRERQyRXColAjL20ncB3s1NVCqyag3EBZdHOExhEhLCvM8IF4AAR1ZJDYxFRjJEwxL4fhmE/TUPsujiIAfxlWfAnH33Yx6Ai7rSbxl3FT5t2r3E35/2OI+fAf/Lq1T978+zfm7yJq1VYfR+H/9WPfvJRF+76+fL8wmw/x5565llSmm7nbdi9ols9v03bf/7fd3/+dfyjz69/8RV+/O7F/+Efp//k+/On7+zVeoGYAoWoUcf5jm7e8O31lHLkLiDnJBAJGT2yVlwIhBaKRBQzugd6cf+q+3U4Vs1Vj1tVHWp4pVA2HCG+VLXjfnlt+8D7Oo2Cwqn4UVHtV+v3Pvzoez/44ddffTHtdsWtqAp4cMUfC9HTJ7ci/+Q0AQAuCBaH95ZTgIuH3JaACAAWJgNHpuXRk+8rBMs/yzot8vsANVTPJiKilkKLEkDxodrJylTxZgRoakZGSxkFNaBEJ5P9lqu68O8v2sl1okP4YFpLQ5fC0fbm9oaT62TpvuXVcEohrmwcNLPa/MU5V8mHLQE2K64FREC0h3qt2+JBZyQlT5A6XiVYRBchNXAgzaiOzxE2nwHczaAABKWnKsLSDpsWcFYfhMCCx774M5xqfLoGhmaKBkA+aUJXVshEVquViNzM8zaPA9n5QG8PB4Vj1mmaEwYK1oGQkWNue68absl6nmfvMGmggCa5gHUEUqLaEZaBgsXhy5FeabiNNJ1Fxc6Aksoa4//zX/0Bx060h71c8SpShJ0AoLAn4xfAEyJkCo7OfrLNriMi4i9+8YvddhyGVUoJALuuG8fREcnarExzh56oLRj4WPHkEXOjVdTNO+GAizaJ1toQTmRY3wKOfbvb7fISe0JEKch6yMe0Xg8AM8/zPKY5xtj3vcypvhcRXb2bpqlbDWaHWilrfVrL/xeFAMsqgQZAXZx2BqiAOI7JDeWAZIxExMrccB8zUzUEdchzXGrCC3SMgWfn1+PhXlYu2+fg+rrkPvrbtR6Mlhf4E5hL/BuKgmjOcpdOvABmtJiAgJDQxix7sBkzhqCIDOgJ6nnZvlZfIaJh1Wle56T7aZrGedicXV5eXlxdbfQspTTt9tvtdh6nEEIfYiQHtRczE7WcZyxZLExE7hhzzDpF9w8XfGvypFf3YJsJLTF+QmCkYttgN6xdo2JGIu/dCADW9z0F7rowpwMnevX8q2E/a0HZ05xzSpO7xO7yfoPUxRCGiKtht7172Q388TtrDe+fP/rBbX736sJ2N5uLzfr8fHctPOpZ15vJncz9fl7/7MvtF7//5f/vPzz5w6+3wYaffvfq//S/g7/3o/GtM824ln6V9nCrICn1QSjw6owvJT06i9ng4hxiBDNAVDAWUQ3g+fpgGR0Wk4D023FC6+f/QWlUSB08yALcSHWCcgaxqcVVANPmnsbpUZXyUxVHBNG5XqMTGOScLy4uPvn00y8++9Xdm9dvnr9Qy455X/X45ey4CvLwTO+rHXbfgFk+IKIpum1Ug/pVGlX52r6iWjLfJCnLajWuogcHxstzEEsK+YNi+KDW+5dqxEtC4WK0nMjmdnYnX96/B1rW3fhQK9u8v3r3NS1bIiMtw2lndJjpPYK8n71RNZu64+UPagpGGtCWGlJEM3WWRUuXbV06xsJDBH/YfSNQNDJEQjjaZVpMynqs2qctK7A8B6B4iZ1ysOBQhePkXwXgkkPdlCkiIikcaURmasaA3kK+MGgsnRr9AwAIGIMS2KQyZejCmWiedvlZOkw4EYyYBuSAQ4SQLKuiR+UNDkiXkqdpnioetoEkSSknryRD0RACxx7iaso43c4/f22zsuEq9R1TB2AyjSZ539NZ39uUWHC16nfzdJu2Xd932ETvEAGQAQWheux9JFRYOuWkr169BAgx9tO4Yw6+ULUPCCyKrTX+K1wSrQ4K4bHNcZ8PVrps1RH/s5mBLUu1mLAPkqm/s/7cu7R49bnL2vPzc3/+arWqSKk5Z//sHckBwFRdHcDFpnRnmZM2IIKBd/oAAFwYbRmSMQIOQylvFhGzMiTPI7HS1woQjamtwSFyNLBFKcFF52tn2a6bL4Pvm2ebembJyT2FtJq60zaHBg4ejnvn01u6GKCaoRlijNHmmZYKeOeDHrslwBBpvRlGnLZ3+3R7HRDCKrgCDWbn5xvbrO7u7l6/fn1x+cgPFBEhGaimnFNKm74HgSwCosbs0LAWwzzPzCxEHqevNMNZiYjxQI3+/bi4Xh0a35sj7piJIYmvP/7qw599/Nl/DQDw9fMX+7vCVsjPNTggxMXmIiBgR3a+jheP1pkGw7Mn75PYQF03jXEzhC6nGe5e3WCaO+bdZ1/BODGF7b/9sy/++z/QeX68uYD/6j+9/Okn89/6+O7jpwYUbsb1TuDu5fjmy0HCfHGRzx9RN3RMuFrZjLz6Gq7OIKAqABGAgCobZDBUVDAhICPHN2RYylR+s8uObDVYWAEcSNG/15azPqys3P/225Uafz4t/VfrpZpjPzx9+vQ73/3+8y+/un31Jo1pte7myZOj684ezss3Te3BzydfPiDssZT0w7G8bJWM9tX3NZjjq7TIsGOvQH0mlZqwBm/NIadMTx5UV8xPMwCgHXm0TtQgP9qe6HZ/NVpmW49MKwGx7Ui1eK9PVIeTN7ZqAd7Lk61fni7QUrz64AYlkRaKwhFkyXs7qpojoBjgAq/m7WNtYZF4PKP7e1QAFdWdhg3AIJS7rTrpW6Xn3lX/VlfS/xkc88OKCmG0NER2ZbFi5uOStFHkHKh3ZV9UUjQQA3YVXr27t2Kp4NPJi3OYBlOd07Q3hUWBuRae+mG16ikOYN59zjxMXLU5Act5FhFByZZVlj+Rt5oLxFEhJulG4e1o23G6ocvA1GFPs7ACBJpi0IBBZJLJAhjbNt2qKa3IWDW5dEL2nUJQFVOFppXossRIFNKsMawQeRoTM4fAOaeaqAGL8+BwgJnI6ATRq25P3XsX/0RH2oM/88R55S4DAHAbBAjcJeCZ2IeooSi43waWHAszF+2IOE0TIm42m8dP37q9vX358mXoqWpLiFgVjtxq1k7XRAqlcXYBHjZDJE8cVj3ksiwcwRAxqSz0d0CWc0YgIsyhwnjXBOGyVou6DIDEHugAIsLjpFooCkrjDFdtfbnl/CzrU1/Xsk53z1bYIseuMTNT64iGwCvjVTdgSlhukwJdrIYIrm6rZ79nL2rl9fl6GAZi3m23b26vX92+urq6Oj8/hwjTNEnOw9CtVk/241w3ndSYOYSOiFSEATXNknLNUzcJwfOwPAxUPDKGFVARBdCLLswUVC1QRAT3l7jBMOfZBHtgmWYBaCxzeP/X//Vffff/5jqZqhphjDF2XQihxw1EnhhkiBCH0K1Xw3kMPQdNk82at5Avz1bp5W66ue0D7+dxEJuyPN9v931/8Z2P3/77v7P+29/ff+/7eLYWkzgn+/WL9LNfTi9u85u7+E4PcR2ZOrhy7p4Dy6PHPI8w8LjEPtWAkQIEAQDNYibL+meEYPCA4/gbrnpsW7H6bfc3vyo1Wc0vEPCktqX916la0yQzUtsfyHUqk2G1ev/DDz/65NPnX349Pf9CgbzLdUO3xQ1YmMJvMH64Z+775StASx/zat7bPXX8aHbH6RoHsW10L4GluDzbzIaDAH4IH8XZxQnDhEXiLkmjh7K4B2fXjvNkl+8L+MrGT/SG+pN2udoH4nGEqLUB4Bs25f684FvTPgqduFns7kwzWEDYys3LdpQEdCoSgYkDESLOSxpQ+3xEROOSsrMoneWvAF5Zkl06QAm9tbm0y5tP18rz/d3jEsjIVUhTQzQ0I/R28KXUpPjz6xN9VF7+704cMjNTUWZHawE0hJIKCwgMqoEUgclETZVM6cAJXm3DC4ziSLmdJztbznNKaZbscktVxZ3cYIYqltVdKoQzWOCouN7NfDPhKDwrzBJ5iF5sk9OkoCaU1AjiCijlJEgCCICrfs2mu9u73PUIpetE3VRtoGmchExBMrqCG2Of5pKkCQB+1Etp0XIMKrXpwhBOUmFqNXZLlCd02SoxXhzG0JA4FC3QpcIJ9QckKB2LDRAdagIM9vt93/dd16nqfr9/+fKlT3YcxxZ1A5aCF8EjdPOjECaUujXzKKGnXkNq8rcIAFy1TZI9BBAWoGEfds7iwKm6oHJV35tPSuDA7JolajUwW46GB4Z9EcwRJmqixok4ade8codW/1AzdhQKACWIAj3ymsN518N+LK4jgoABDUEBCdHQseyyiOUMANQhYuCOL682IdJ2u9VJxv2W0GKMhMhdAABDXfPgDEtScS8xM3MsrU+QEFMt1QNFsUTkErmk6QMgM0+WEZWwhFKcdFVNQ+ERGVUQBFXQ6xZ1jsDM4KVMS++B/TyFGONqhUyEAQMDUFad9tsVbuJ6HTfn0A1dvBtWQWjmbo05jfvps19/3q97vJ57oRnyZPY87cfL/vLv/fTDv/m7qx99Hz54/HoDZxPgX34x/Mnn/Gdf6a++xvEOz/vh0YbJ5vlmfvEqPn/Vv/WY3n0L37oKIWZiMWBAIgRRQwOOaobMbAhA3gBKoWDOyhFTfeDCe1bm/W8AjoTmfViwI2BTAwBghQezVk+4/OEJjWBjKMlwZubwMUT0+NFb3/3e918/fzFN++u7N4FIQUHRrLSvKvWjxwR8f2r1S2cU2piUdRiIqJqa/FADOMSI70+kXbH68MM/C6zoqZpVHQbWOgaWRDFtRo6EoKczamVzfU4r/9oxVK744IIgHoH0tK+wJn50/7cnzOe+btHy0gdW5liNuK8e3X+yLl8WZqfgotabGXi4f7lF0YCcIcGSeuEXnEZ5mvk2Izxqp4DuLXQPVV2ok0nVz6qnR8iPQ2CuLqa8pIp62TaCy0UojqqyLgRkEJBgwboruPdOuIVGsWbDxrDO6Q4kIykhIYFZEsmw5I3u0+rzF9s38c7e6c7eu8KxyBUBEUlquURU2jNJiF7uCKDAY7btPN9MYa+D0iAYMukwzoaQGGSlYgQCOmVW2kUlCowhAIFq3s8ZoBs2Kc8eASlkhIiIxGAgpk7QZQVEVMTDmZZS9nBDylPf9/M8IkZoRHK1CSzQoXLDaZEYydvWHEjcjj2NJwfS8yFKtL7QXSlmnvWA0euXmdVu7BW3GwidCjebjftCVDWEcHNzU4JBAOQYNUsexHKuljE42rwXxqqWJm1q6i0QFiBblUUDczRaRTNFZHdpAkBWQXeTqplZCNHP58GtJUXzsFJmfaBsa8rGTo4NLkVUCx66GKLc6+ioS8X8fa6xpDg0nKL5H+QUFDrmLkRQB+8iJKNlH6modsVAIEB3O1Vn0qO3Hq3Xw+tnr/KcdnK32Wy6Vacq4zw5mONqtVqtVgTuXirKa04aiJiihEymBiV5U0x4UY2AQtktxm4CAEM0otKXQVXNYM5jjB0DmxkE6shBz4CxS5INcMqpxYo469cxRqQgYgrEwEAEAnG9AqY0ZQijjHl3d7tLu5fb6e52ezbifj/pmGPXYdL1enOt2yy0+sl33/lPfnL5u78Dj58KdHgnF7++hd//d9PPvwxfvMmG3Xee9t/9FHSEKY85DKuhY4JXt9PdbtSpI41bVYWo4MlVplnZwJtvYVhCaLXqDivk9rdfD2oYJ9eDCKRVOmLNfWtjAVbuKduDh+fcv2o7cuefhz9oAgQK3fn5+YcffvziO19/+eXnr65fxkC4JPCVnyCqagE4WJBjsFqcdKDz9kOttzzRhEQTUkAIAKbqS3nA3GzFZFmKBjbw+EAVS6sUTC73VAG/ZKRSzZaoY2sFf7UWTmWbuq2P0sAM2r3mZPWY1+S29iHY5Mm1c6xjaFM3Th54InfrP7WWCzSlhfdZTc30r+Np1/C+HlO81K1B6Pat5wUuy6iq5RSreQPZogCoWuP2u6/rlJa5CAD0gK8JAABqng3BaVdbXwCf6/0fImIwk8WUJGbwRF9mP0HqIRTyxBRPSsgTBQbUUjFDEQElG2oAILKlXbZ6Awac5hszM4uqKOZlC4GM63QsGvLZ7V7e3KGF9eXT+ObNmylNEHrGMG63U1KELst1iBFCEOwmDZN0swRR3u5LDSQgEgdEI52CgqERBUIKGud5TkkUKaF11C+bJIBAoWD+Q2DP4PUy4yVLO4iUclxsLjMIXvcBFgKLSOAuiQF13jLP7/dMTPXiWAcXZQrEKSVJGdUCoD7E7A7EdAwVr6rYB0ICRM0iql5Uwswwi7d9b09sztnFP4UAqKqaTQALpThpukTvQ9E7vcuuERKFUnOFMEtGRPUMUPZmz8qIASnlHEJwiB5ACEwAltIcQueSG5Y0DkYEQ2esrhHo0oGdmBxAbJ5nAEDgOR8KWxG9FayX7JI6QFakAlBaOIuSuYfKcdMzIhiYqDhlVx5XU6HB7Q9Ud4F4S86T9cfFdeR8GRFV1tO86856kH2PiDTs84SEMOfIAREFLKnIlGIMoQvMqKrJW90yzXNKKSPh0/ffnabp5ubm1e11P/dnZ2fDsJ7nOU35Zrp9Yzcev1j361U/xBhXnM3MAuelEbGvxt67BAQIiKCWUkKEDil3XQwhz0nzPHQ9IpgqBz7DVc5ZdEYmAAJDFUsiwiMA9H0/hKE1zZW7UQV0dpGTk4t0op6mLGmXLxMo25ef//LaVOXKhrvuyxfreVo//WAnaTinr3QKT59e/r2/dfF7P52uzkczw93q9Qv4Fz+/+4NfMOT1Dz6E//XfgbceaSQvvphVABEoQta0301s/fmaFfbz7lxVzsOsUwcdauxMAawTBtNMRqC94h0KAa9C2M8zLtlT7c4+qGG0LL7eQ8s/xZ9g0DrVEMCqS+PkcY2R5h8Ijp7fPgcAAtdCBoDiNTZEVBokZ5U5hO7Rk6cffPKdj7/+/MWrr/dvXvar9WxzVouh06SimZnTApWNi0vcjSdp+le3wjIQF0CbYuqUMw4CAmYoiIxEpqgKZhCRvfGT59NX6Vi7LrjN4MfZz5frC26wVcntSHe1orso655cj2CI3t7L140AWAED7/d7jgGZ55xijGpGhElybQTR9337lnZPtcHjqplbbcqdqrr16FyIiESk64ID6wFAST0wM7NAgQL5wuYsXg4qAGwlmaZYLOqaEKEJNM4YMK/M8BrPB0ixTRp12aNmWb1bCnhmWJma22NEphYRQAv8FzKpKnIJuTAFcHcyamtam8lCKSYiSIwAVtbnMDAizCLIbEy2PByAGNkz8OZ5Hobh8ePHqvrq1SuxVBbNjGvcQO3QmwMLTqgWZMaHolMABcGmvcRQa7nUQrtVKWs1zUoBBAUzFABAM0BEou2UP/vq9dnH7zHFgLTf30zzXlJyvwiGTSZOQmOiMeEsmJTUqBTX4MJE1NCQEQzJRcVSWMwlLNQ4zfCent5e94fdynIz87Q7TwyMMe7nycyylERu19nrwVMoYHza5BOoGTVmQV06p3U+7otTbrPiTVDVqtxok4jQ8jgfq5qB50Vi+yer7y37oOqTAo9J29ENJ+y4fmYkB7IMzoHUzIyXKhwq3V2Lf8gsUwN7Z4vX5P55qx8au+cwgOXclomUPSru5GoQ+Dk5LZBruQ8iqgoAeIpV3fGTX7XiCk1joBACxjCh7tKEZIMhhECBRYTMYoydhycX+ilZwkTV9PSyama+u7u7u7t79erV+fn55eUlnpGITNO03W53N7e38sbJ7GzoiWi1Wm3W5051jvgyrM4DsZetUqSuW0/T9Pp6u2ZOMPWx6/oz0zxPs5mB2BYmZA5DJKIJTDWZKoJ1mURknHPOuVU4xBF80IFMsiqYISDHN4mAIkVc2xvZvpS7N2nc73T3+bMf0urHZ48/sfXGdCczXZ699Td/JH/vp9Bt+tcJLKc/+Yv5v/sDnObhdz8Nv/c/g8vNdLmWGGCSkI0NGIGnZAAYQuwuIgDcjPD5i/CLr/d5x/yJbtaJJaIZwR4ESFa4OiGk9vBWkmtJCx66Wl73Tfcc0eox5zhxYNzXbNpnHv0JD09q36oiSBCJDCDG+PTpOx9/59Mvv/r8s3FnZoE7hZxSAjl0CIJjs/ubRnI6gMWjblbMreUG55DAjm3vj8Xq0IGTtW1P6H09r7LfNgHzaAGJxFRVq6BxBUJUKVs39GaGRF3XpZQMISy9DnQBPDyZ+MnK1/+2o215Zsvt8SEkRr9yzgQHPLFlpkfPAQBPtYF7bAfQEJiITnJTHhxh+W3RdpfWTiVryN1Xp51W2ofU59fRNnyJ6gd/Uc4P+zXE88m6LkkutaJLPxpXIbqu84i8PzwQLzJOHcHD6SpUuoGG4ERATUp82hRKR2NYnIieDqxQmsQgACAfFFW4R4VwTNxHCyyZQqCuv53zL5/d9fy6D0bKAGRmREEMZrEtDZJDyjjNYZag2qmxAqLlGrhSVVBwP4V6Jp2AZ6diYLKSUNBS5Mn5t8UbWUnthGG1dGEAzMXirOF2QCQiz98MSJOkmgRTbWtEB1Y9UjXakbS03i4pekRDvXDYAJGbRm7tCE9O++JIOMz3wSSpul9klptVain15CQELPDkHivxzyHG2XMXmrQP80Q/rLWvqsdG3mFH0MAO3shySheTERfzyHs1IyoRFdgkxaULoUdwsJo+2CiX7WQrohE07IBqr5bjfQEADgqz7vd7jb1Gtg47DLibcqSwGG1Li6OMAGCEAO46Ke9TNLOXb17EGLu+v+qv+tVqd3e32+32+33fbYY+bobV1eY857yfxt00zind3F3nnGPoz862q9UKkV3N7buBmVfMqpqmeZqmEPurR6t1oNvb2wwmaZ6miZm7PqacozAi0WxZk4h4OT4BTuhmEolIa1TM1zdOAJ6aY8hEgZnyLEgxRphl/vrNs9325lzgI97/I37rh1dPfufDD8+pm+/uLq0/34L+679YDefwu9/fff1y/G9/H774+vEPP4a//1t3P3777JrTmBT23HU9dZ5tJAD5csWz4Cxwu5fdiDd7ubkVSav1GXTDhGgORJwVgtJmZbvGGoODzDghrXqUHpRJ7XG4T5nfcn0L9vlv+Bx/gC5s1ms1EAGycCRCSDlp4Iurq48/+uSzz3518+L569evQwwdcxonDGjGtMCTn/C3+0z4ZPqNiCr8BGMwMzBSU7SSSk8MZrqESo9spPocq75D9080XZyOEr+O5PTRBy9v9aQN5wVixkyiGpGnlAgsxuidmXHxr5xM6kEO3x7zNqOrZWgtQ26ZxmF4HppRNbn3locVHTPDGKM1Ra0AAKVL1wMWb8t5xIr+V+N3huC92XBxAOMyKTPzMncF43tzf1CsQNMxyI4b17Wqr4BxjN3Qk4bSXdI5vGGt8pvHMU0TM4MqlD7tWHCSCNy+DK2m6e/zHp4n9FFvI3ToDkDkmrCCeGQgnuzfCYsvq7DMhZEiY8Y4a/d6P//pZ6/ON91FB6wx65ko7jOMyW6NEaNJJ8oG0btegWoWASQ2NPO8RkVERjIkAYBSSVyQRQAPqwMNQouPyUeo98OEy3Uid4twDSGp5Gl2g9WsKCvu+WBA8rwEBA8imBkQoqGpZdCwtE2vsTe/XKa2hFhCrWpkpSloexmdlNQuuwANGPOiHiPWaiOAbzp1ZgvAgKsgsEwclqpetKLDlX82hE0gecnTRFX1ljHQHHhmxgXqmBoNvfAvVGhr3FD9OWZGVBvZe1FYLQdYKGupd6UFrLNNiznZWcJwotkQ8YPCqJz/IAo2j6IDRKQMxEhZQUxjF6NZnmZUMxXQ0nDcSR6RFBwQygAAmcR0mkYiXq37s/V6t9vd3t5e391ub/GOr1fDMAxD1zHFdTKNeO4ayfXd7fX1tRl698thWLsn+eLiYrVa9avBRzum8Wz9lJhFE81z6Qaw253NJCKSBQwiRQq9r7laZgAKgRzM7brMusNewFRU1YUNhqBkmoGCAOWU8gwv7n4bNn/j/NHF43d/76OPVjGKpevtttsMU7LtdHu+Wt98+afpj/6dfXb3+MMPx//87776+Em0eP5LVd4ZEcWRut66HrowR5xJ6U0aZoPtnK7vxLQ/O4/ffVc+fgLGcLmWaZYxxdBjCL0RTiq2kLQaxYKUcbLj365k3N/r3+Q6dWksH/SvqbIImMclXbRAoRJgAgRFZNOsOQ9xePL2Ox989J2XX33++vp6nlMNjIq0x//bHDknfPgoPbPKAmRv1Lr0xRBEhJLt7/cfFeJWxliDj630Ornn5F3tP43QUXXthAl7grkZx1AjAnRcpNZ++BbmVsvfsHG32AEESCtDMDNmZzXVfwy2IA1CI/LqE8QXygjcV10KOjyyfORdMDO1dLIIdYnapBYzU1jychCWXnllVra4cmvUzNBl3WlCbnu1upcq1OST9q8tWK9zZL+/Ww0AoHfbnDMjH7SFZU2qltk+0J8ZmjEsErfBe2h/09xHcFRuRojm5Y4AEJredCcTaKfbzIRVVQwEA1J8k/PuDl5jDkBoKzVKGpMRQEaMYOyKr6GgGcKMwGAoaAQEqEyxXWhAdE8JgEfSsMqhdqa4GLU+3aritetQv/RfKYIiTDmtViuYBQC8MNLMgKkCVyAiA4pX2UQ0VTAjREX0tJgawGpXu2o27VCXA8DWmhQHI+awidhcxVIPXl3tGF2wqJ1HCdLYfFP/0WbJ3ecOsChtZlb7LPvgOw7cRWb28uZ6GxFWF5yCObAKM4vmQg6HFwkAcCBUdO62LAIuOLlGRAHduDnkgp0sJh4X0OMxIzuhcwc3tG+QFog4Wc4xzBrmGWAym1KOpkQIJYAt7HXw6GlcurzHD87yVOoiqmqe0zTNMqdhWJ+dnZ2tN/txHvf73e3dzc3N3d1d6AN3EZl46M/Ozq6uHgOApjzPeRzHaZqur1/7yJ89+6rv+ydPnqzX65xzHPphtQKmOfP5au0r8OjJWwRsWVpVW0SSSicgplDZ1tdlyhcfve/KLSJ7zZrnDH253zGGLqyGSN95++qnZ2cX/Vkf1292L6dpG/qQEGPKZ/3ZWvSLv/zLmz/fP/6tH5z9L34Kv/tb4XL9+OUMNwYrkU/WAdBmTdudbXdd3/d97Ejh2Z0RKpOuO1yv8NEFBKZp3COsZuNXWxkne0S4WRODjjP2G5RCpVTO1ak1f58AHtzib/nrX+t6kIqaQ3SM+eFO8gY9DNyHTAhgjBaQvDTv0cWjTz759O7Nq6+fvXj18nllaCU42JxiWDQAs9ptG6Dh/u2orGm5bkvAc+lg4k58MxA44N/4GSznpXUYtFer61ev6n3NoH5TkzoP3X8Wm8FZ39nZGRHd3d15sggv1t2JI/NkEepetNKtDrj9iS36x32RWe9U7zZ1D6oRAUoEBRWMWtmZUlrmiHDMqU52pF2Q++GNsjFWUnMAHIxemdnDaouVxYiWTbEpvmvX/563CReCbBSUZjMd90/BRIS7iIhjmkEUGTyzBBHDosNJyqGLnvvYmM1mZlXhOFAAU/QEw5YRQz0/JRiP0tLNAudCRIZICw40NVW5eKzKNSuIc9YEWsRHHPZp3iXw5t0IwSAocI8JAJdaXUXTktZKBVNbwBCJOKCBagIvzGYqGKrNME4Ujrri2Gx7paGWCNqLAjMGj2bp0sTVbc2cczf0ztYPdrOBl4d4B7Wc8ywaiasCUU+Fx+xFxMM0lYOcKAQNKTQS7R6P82AYHesWDivVbi4s82+NEjMrGUfgBXen1gwAuGOtPsq5gKoSIYsCIIhWyH8AUH2ADBoa06pztIfEP9eIIyJ6BgN7v7/iZTnKJK9HuupA7bpho1NaDTkRt98frcNhVWlP4Wuxz8b9JWLf90lFGRkgpaQ5e5mMh6KzSAWrdW0DF3fgnGZQI+J1H0Vke3sTQlgPw2Y9bNbDo0eXMqeUZMrJBcY0a0rJbM45B6RhGK6urtCg60PKOed8d3f35s2bL774jGIQkSgY+z7EeHH16PLRIxGZx6nv++xVTs06UAgxhG49KBgV19GBhFbvPQUARHZ407r+P1z1lowA55xCvlytepvSfnfbrQbF2XI6jzFke/6Xv7iR6fyT9378n/1X+juf6pNzMubr15lHusC5y/omx34NSGxgKYMY7PYoAsaCAJtVvFznQLMpzUqKHGn++jm+uT27OsNVnyEbUlitENnTEytxtmLm5AjX709I8UHBWT5/gyJyUntyn8F9Cw958DpZfwQ2W+rFzHKaYt89ffzkw+98+t6vfrnb7fZ3t0yHFtD3hTo0x/P+n05eXeVNQTKFwrVKz5Wj6fhQFSrY42IjtcetXepWuLY/ub9KRHQC2ea/EhETVW+aevD8PzyverrbJz8ka6H1ypzIuza02vI9M88ghYU7kpMIYvk9wrGPdlmZxWQ6YlMPzqK2uTu4N8wAT9OGlgEfqpaWhyCY4ZI1XUorFiMWjJCOdgTR62VynWy7A2bZACVLyjlbRkQyXW1WzHEcxzynnLMgRtc5CmYSmeXl+b5KcHBNL0tNiErMhMHM4+Be5VsWwwxURQ496BGxWBNVXrfTyCr1+wOFmVXnoyhmUCAKSCiGoASk3Bl55xI2FbKcPeeSzTCD+tsYsUMQIjRDcQQqc0yxQjuI3tUFVQvkWkvlLuxb8iIiN/7r91XgVbFU6a/k7mlJP769vf3Rj35kZp9//jm4j3TRuBGREIOnWoXQdR0ZKGbPkYbj08jMIQQHSi9VG97FlIiZvbrSzOw4e7c94SffOO2Cy9Tmb3U12tNOSyCmXgyHJo31tnZ9WjlU3ytZYMHYQDNP8akGAQB4GxFoEr5OTxAAAJRGi8sraisHVJOsWTNTDCF4fRKY2gL51Zac3OewJyKnnE9/8jewMJ/1GruR9Fcw/6ns3xtW78eN3t4iRZWcVRiAmEUVlq23YvowEhoCLjxooE3OmQw4IKOSmnr17H5PXRf7jlZ9v6IuiwmQWl5GAapmYqLjfisiXeqmaRqG4e2nT99++22n0nEcWfBme7cf51dv3lzf3qZxTvNMgGQaQ+w4FByeLg6b9TAM46oHwtB1FSPIr/n2RpOqmkrJXdeUzWR9m3ZposBzhmG1watLiCaQJ8ZNxj7rdh5/ef2aP3rvvf/iPz/7vZ/m1eVkhi93wUQVjBjMJBDNCgFg1cNqAyYp5zSPMstwdiaMvB6o76OqCnAI0Af77Ivp1ZtAjFdnqYfduA+hC/0GyXsgAYgXaAPaA+hJJ9vanpcHiO8eDXzTdb/Tyl/3MrMFOPrwJYG3qwUvEUGDnDQE2qyHR4+ffvrp915+/Wx3eyOq1nQVr7TdMt7703HirPku7UjUljIK8NNdVC5CU//GqNoG9VE1N+JEmsKxq/tEz3hQEQTHeTJQBF1KTP0t2+3W1RGXPUhIC7R/VQhalQKOOWFdk5NMDjsO7Jb1X1jTyXMQ0aT4CE/GX1SDMr3i5wAAz7jCBUrR7NDM4USVWeRmg8e6GJNiSv4LAzjyBpGZGRIv3TTro5kOkSNbvB2uf4CeKi/3ib8lG0fxRwdzMgDm1WqFIRY5IqpZFCASuWP78EPyzRRPGm0Wyw5zJua2ZLnK2mxqJVul/K48tSHc8pDmmxM6OzIXDMHNeiRLAil3TMohmyooU2abTbPCGgmJoJAhBDM2WII7ntdglE3B5boVeOnqJ1QzRe+VsugWjVZrC4UxHG3/SQim3MOcVCqb4Vh60P/Nv/k3X758+ezZs5RSSilgAcbAxTljZo5ikhfprsdnz5oKdfcT1lijF2fqog8sgBMPaPHQKhPe3lO1gGDeR+k+tuOLW/KY+Nqz2jIXXKq/6oeD3iNKTZE9LgAbVWkoSeYh4HFizckbabmqa05VRSQQ+ZLUJpYEaAZih7J+OFZxTq4TNmR2pPbdXxz/U59pH7ubAF/s988xP1azbKuuv8s7Buy6iAb7/X5WCYEpBsvFwiBPbF1oJmdljmS+Lxhj1CxpnplI0pzRQo8hdBw7RrWkVsBRcmQK1BlJiARqKUngLif96stn4zxdXFxcXFyE0EmEzfqtt8/OuqHf70fN0nMANciZmQMxquWcs6lrGDruFExmziqt/vfmz36ekuRZVJAMQL1cUadI0IXHj989o24zXCnYXb6bMNHr/V71q+2drvruYvPk7ffPdDN9vsPtl6vVGWWC1WoMOuAQZgh7nDaef5oNIEeyGGLcrNcIw4oYJNKIykixY0i2v7udP/tiHfv4/lvwZJ1FzkNPNOjtpFfMBgczDktPy9bir/z9vp7xTdeBcr7hfjtm2ocQpD5MdScqbPOH5f/tSOdw0CEAJTLCYCZdCCHSW2+99cmn3/3sF3/15uWzNI5UQHcLuszJ7E748NEAGt+hn2yXmsEAllIIWID2EUvOxP3FsONGRdYY03U8JxL6ZBfqBh1pJwCmKqZBlYj6GMdxRObYdeM4AgCFAE0MugZWTqR4O852DC2XuD+Sk9yy9gasadQLM/SgAPDSz8/zXZdfVbyTOkK4x1HrS3FBPi0P98aEBXoA0ftLqYrTNjMRZfXfMuJSQ+AKxwJ+3Wozh4kAAx4aO3zboTDQpamFpx/knOd5Hre7eZ4DliyCPCdVjUt9ZescLHzbzACMmRDBpDgIZTaOyBxFRLUYi16F0TGIiKghIFNJh+xi2Kc5VCe27xmAoAGTmnnVgQF4CaUhHopjSIMBiGZQQfMO8GXm6kjFAzEykapKNqLOwJKKWWZmMgJkWFRyR8SypQcXAEiuXh1kQC/gdleBJ2Y6OlYpHIUSQQAoQQQ8rF3rT7OOwn67JwYOAUDnnFab9f/rn/2/MaujX/TBXdComg2BA/uGp5Q83aHruiwH908leq94rGej0rQL9dow2PFioeQAoyWpz0EmXpAnoNSsUgyMi1IMboiL6FI6XwnO7nlll/96qgRAyach1ayq5qyOUNFwYfeeL6MtiYsSQMchQc6aEJlCScvwUAg7Qbg/ZsncVtXQdU4IHpGoa5JzNkSOkQlFEykjs5oCWIxFoQGA2lHdZ+Tam4djTpyoDZM6MCNcAAwq99nP2xijZZn3QvuUA86Web8HVy6zQk55mvu+I0ADAWYC1myZlPsIBJIySkZlhWzulxE1NUSKfQ9GOWfdpZwMQlKOyjGuOp2m9dlqv7U5JQAxwxC6lBPaPnYRAAADk+bd7uXtnarOJqGL++GMQjQEDDTGCKCRMUJIY1r3g+PiaBIR4TSnadaUVaQ28AOAXz376uLsInaxi4MRMvOjR49ijLyOqrrb7TKk/fTV7e01IwailLfTaj3/+GP88IPLbgM3U/7X/yr8vlr/iM7WY7D4+OL80WVSgPUGzs5Tvuv7S8iQU+jOzuj8LHcwMfb7xAY8IiDAmkwn+/KL1V98oXzB77+zvVhFiyuNenebcLQ+oK0QYC38OjArbIOtk4E1eHHL/h67077tQjjoGe4uW8jbUXOx1TZOcUUD1YRLMqgOtNbAYDyY18ClaQgYOGQTIYIBajbyXnSgoBBhN23N7MlmPb717ne/95Ovn7/85S/+uO9CGjXwKqcphGC6IHot1kP1vSxTIFVTBQyOMY1L/0IEwEjsSVG0pGiolr5y3iAJyQgISq9ZF+ESggMHJzMr/QUXyVoN6/bEOS9qlZLDDbiUfZqhGZlxJFWZ5xwCESGodkv4DxFL8pw7QYkRkJjH0YGAS0KlovV9n1ICJFT10n1Ph3aMIJXZO5znPDvTGsedNxZoHSH+wR3OSigq2QxMCDEgWkZDACIrUPVKBoyUjXJWAEf/ZCcogaJ8KIKAGRi7UgILNrkjD4F5fkKgkFU0CyISoGOoKICYkhvGJloo1MiMiczQN/okkISEqgIGdXYL2tAhHNmSMyOjmoIFZjAFUw40TnvwoADZmPZdCEYaqIPi+W5625gZEHoKbl1Ew9OKsjrKSjHVY0NEXnM4S64ZMQUyy48qlScUwebFGcdwcmUwh8KcxuWF4L0xq42JALjkv0RiM0NAr6mpv7qvx7UL5+pFhQA3My8tceFU7m9GAgBt3WktvhIRY3vy1uV6vb69vd7tdjGEJPnu7mbTrR/Q04+9CHUZT9eh8fOf/OTkHvPgYVEgizepfX47BcQiqnGBvdJGzT/WKk4jMvevk3npohyY1XYqxUhreU39oakBUClgLfd4v8AyZj22DOrD7fifzOy+jbBg8lhjatTXVZuvJpfUOZ4sPuKp1VtfW1UTEQkAmo0NhtitwipqUsZN189zSiqo2RVUMFPzaCibGgD6eTEznbMKECooAGMgBIrADCoEMGdVVAHR7KkwyqR5ThxDCHx5eSGiMqcpuzrVA7rNBEyx6zegJjmnlLrdZAKwnca8m/IMYMyIBnubY4yS8zAMJhqpIL5Lx6gGYMTUXZ7Di7IIv/d7/9BxQYjIUYmzyjiO+uqViOynKYSQJBPi5eNH8zxuV2+/83t/5/If/t3w4QdKQd5cz69ewXaL6RaJYTsiMSSBnJMazuPZxSWgyZnBpsMVg81hKyFrGoIhzB12Q9/d7Kc//qv06s3544vN1duCsKEOFPPd1lRDJEASURA8wd9y++nBjT758mFSh3v+wN/4KqpD+dw+qvGZtaOy5ZXHl97zSbqLScAuLi4+/vjjX3/24auXn99cv+zD2pIYsnpGHaqBiYGBEbtycDi5ap6Dd9TZuPIWz8FqRwf1vCtAyU7wg18eeBKRbFPBTthXO4wyx8Yt4cYANh5oWNiaHx+3rV2NcOEC97YYAFJKXsblTbguHl29efNmv98zc+nzUFnlgsGqqkXMLFcN5h5EZJtbpmi49FRXBLWF8YGHuLDZT6sWjpvcUACiVM3dcciEAITuBzV2PczdQlbgrxgRiMEj47VrNyLaAytQ+WFVINrFlMbWPWF0dXfa9vSOmcREROgY6v5fXUCZuxBUtQvRgz45Z2YyQodVXDZLQ0sBTs3UGNx1cevutiEGN/6GYViv19fbO1SrBjRiqVJzpGdVKziVjs3QHmUqQcJSMLh4jQoUs5kRMaD3UnEPmy2eQF16sbak2U6nXVNdgK3MLMb427/923/yJ3/CzDc3N+v1upJUJd92C08UGjNDlR9899N33333T//0T//s53/OrH3X8ZJsW7e8PVot1bYjb+88ed3Jc8wMaEnf8qNuxQ6jBjwOmyIXW1J9VRWZPYSB98pE6yvalSyxmJOlIEOoPslSMFY2+njprLaAajjLksSAuGhCAAbAni7Uqp51YIc1b/5IRFicO0eNl6oiVbthtZPSJqsGGiWj/efJT7BBqQcAIc8SUE+1gXGScZY+IpmJmllYsO9AlJgLoggSAloGNVFVBAhI4qUJHiTzNkMGREWvFZGcZyLNkM0sSpfS1MUYKfZ9v96ssmvPruD7gmcxMVQjxDnPiBhcRcgZCcKSJszMOaUYo8PU9rFj5h2pd3WxLGZWFY7Xr1/P86wLdqQh7ff7eZ7PkZl51a+QaLXa0NBNJhK6x3/771z9nb8VPv0YQs8c6PElv/8u34xwnmBKdn1n+6RJLGcFzGpnNIAFRlJL2zd3OsmGB+7WHIjWa5Bxfvmqu5MeWa6u5g+edsMZzTPs53w9i0i3GsyEgDAJaenph+BQQ3DE8v+jrpNfV4Lh2iSt/skty2/WUKoWfjjOi4ME8dsG2lK+LVHRJHm1Wb//4Xvf/e73nn312fXrN8ycs5QRMBEFADBJiMB8SNauB8RAENmOSb3hVFbn23RGO73uq++IaIY1vPIgW653+gfnMye8wgdTH+4C0kpRK7kh7m5O8AD6chmYmtIChsTMq7PVBx98oKp3d3ft4pf/GgAAh+jF9LisuRke57wdcenCWku1CGXnLU56ngSDByZzNGVEMQUDQ0UsMK9AyJV0bAnHeA2sv255QlxaPdQHFpb5kN3YSsY6jOpSwoNb6xDNaRn+kYCAQzWILSU5oOa2kJmF2M1ZiElmIcCu62JkVd3ltODJIgAEAVlamJZJ6dIbxZYizJxzLZ3ARfd0D4wPy8WYYqEqB//0FDOko8RMum8zLNNy0aWqXoRdltUlmTsfqRLcokeL1MRPPM7rPBH29bMnXX788cc//elPf/azn+WcO3fa+1IW8nPyBUTUpTdnVbB8vqb53/7rf9cNPRGcrzeqkOYUQ+curVbDgOIosiq3qtg70TnwmGgOXKbxW1RCd3eUgZW+Kg09wXF9F1alYHlFNqUmZeFEYJ8s2nJpq/wvXgwokeNl1nWc1dlAxzmhvHiXqXSx90IhTUtK/NGrCeueeGZznSjioUmRmaF3KaNYl5ea2rZWq8PmOtFNK+W0LL69jYhAvRk0JYDJMRDzPIrZKiAiElklY8fQQwkOKpxNdBJVMPW8KlRVyQJqJgXyhBwVl4AQZjAzRlDRnDXRtNvOkZgorFarruvmeQ591w8DlpzioAaiEpm7EOeASIQhIAJLQAACUxHKSkRI5OCkKSWyktvr4IAeF/v5e//X73/5vweAd/7kv/yTp//nYRg0ZwWIsR+6/uLsPIEG4q4f7u7uNucb6OOzl8/f+fCjyx+8F4LYr34xTalbb+jJY+46iDS/YQhM5xt+TGDQicGkst3lZ19Pr/f8iofH52eblVycy2p1B3gBCJLp6zf41XM7P8PvfdAz5ynPQTqO6c3Ndrs9e/sJrod5t+uRMKtZTcktvKwVcfcF3l/rUnwgIRQNSkZZ80350KRLWfNbxANFuV/A7zp5zoOXaxtOnGLGZOv1+sOPPvrOd7//4tnz7d1NCJSSUnE/R0DNWUWTMTkyIsDhdCMikSc3Hw5sG11t9W9Y+HNB5EOAJeK0nBRbJsVOQ3CsNMA9A6wsbGPZnhgV9e2IiEurdOboXSdzzvv93o0rbUDoW76KzEC0246ff/753d1dtcpgCdz4zQLQwmQRkYhVjn1//ACAhKJiZlyKO4oZjEwFBH55lJeOkJV3+nScISoIMrku47vPUEwwT5Ksq2/FULcWvxiWpWmJpJUa7V7DQwzwiLoax/zy2gPfNig1N0XCliKAPHR9zjnlhAYmqpoJKMbIISASgJJBdt9wIPZu4EbGCAGhBSFoff7t4Dw3xLfNW4o7HhHG4PpBLc1w3xeGiE0mUUmMbae6uDT8fTXh5WQtqhytI8RGg4Zjar4fcqtCaL1eI+LPf/7zP/3TP12v1/WvsNh/DzKmlvTJoQhCpyagsJ9GAOjiAGZpVma6L8zqFHy0FaGlRqzub3lLOu1k1bXjhdnVldJmst7p9zDskgdWZipgOedIhy617VBrhRgcE+jiu6p/KunrDISA0tx8At1R/S7+DRO5OkdL+rQ2y36geHxA6ylfHFYJcan4JXJt3dysqT+tCmhVpE4Ui5PFr3+S4+6RleQUJQITha3MN6g49MOw1l3SLF3XEYGpZrOI5AqXqGUmb6+MQK5UAUKeEwAYGiMasIISEQXOWRGtxl8YURxvx4CZu9ipyDTuxv12nNJqtcrzzn0PMfQxBAJUtRmxW58riKUsmiVl9GhmlpmBvRVvCH0MNqKJisqmgUt3mmlXXkRUgJn7EJWYY8xs3HUGFNaDIOxyjk+ePPr0OwQCX78EBOpIpj1s7/J6rZebgR5BElCbp5RzZiTIIpLo6aBbhayaMs3GMDBvkinoPL16A/tdv1nr+cDrGCyEWx3XBoKWZb1eh80qo1ofzPUkb9XcEI1iSeo6ue5RVnPdO/8lLgPoOsdBLNlpTey3aAz1zvKhxZtpHmi/gdpRqNS1+Ujvvvv+9777o6+/+PoPfv/f9B2HENDcYeau+iW8WAapFZeoPSN2r/8IgCMztweklW51/JVf+RnhyqzgmIPd56snJ6suyLGeUezbnD1HzcMPh+9hSSfXJZxW+JUZLc6AnPPXz15wwLI4sASjl60hgCknIiottCgwm6vgWQ85le3gxVQW4CYfPTFzCGSURBixdDY1UyzajJkByJJ0hwpmqp4HmU09ncJpjBaEb1gqSBEWU7jy+SaMbseKWvvZGmXOjt0eddPrn6obycwAVA+lIYuFv5RNuAJrAGSQc+5jNwxD13W7261myzlLScRUROo4lE6fzMHROcxICcgOKjAeG3ZVcrQTaEcjy2FvhaiaZVNvi+q7ZIWKjxh9MZb96C6AZYdhICJiNsWlMHlZ/JKF3o62CmasBRcuZZck4WmazGy1Wu33ezfsVqvVOI4EDr5aabGcNleqDgtdvRHEaZoUjCjEGEOIREwUUhpPzlVVMmCps2oPfN37lqztOEe6ni5ERFEwMLUTe6tqD6p6cM6V9TrcOks2MzFlPSVQW6pUdClCuz+LJvHCN+EoJd7MsqkXftM9IqkXMSLQUgpTFCJoOeAy4AcFw+Go2KERABTQUm29KfWqw8Dj5j52z7S6T+H1BBZGBsaAGuha5Ks0/qBbDf0m3V6DAGppUgXIRI4HowCaUgJRDl2MMTLlnE3znBMikrdZRwMFyZJzXgRmMfsUwAgxMKKhUkoJPH8Fse8CM877vQ8yq9qMoEUoJje3ImFg7CiELlJU1WoIIlHf992wHrpORCSPIoKeQWyWphnelNU7v3xkZiklNZzVzCDPOa5jNMQsV5vL1/N+pPDp3/gbq/fe0451NwmCdNHGjC9uO9vC5ma7+oK8ddM4M1m33uDQwdDL+Xp4+wmEaGJJiVOiu3FjCC9fxjTR43N952IHFqY0GNgm9OO4v7kOiPHdt4FtN41nZ2eoBpMpgxF6P3pvyP0fF1Jpf1RPyUk1il8nZ7DtKPsg5cviApGiXjTm0/LS1tVhjZ/kJFhDhmjaBQ6Xl+998OFHn3z3Z3/+x/N014eNgeQsKQkRoSmqIZosVTOquZoNcN/h366De2COMB6rpK52cFUOalZHw7uM1OTBU3wiPtpjeKJ2LN5lYy65jfv9PqVERAieJ77whKaRac5qZvM8hy4O65WIONCAaiZsWBYhGSEjKoQQMoAmpbKRtVIZ6ivawSMimceqDx0bamjHFk3OzBQxIDmrAzT0zsbLnpoZaoE5qBqtgCBiaTIgamrFyQHs6hQ4oZphk1SAx3bUQxta3ngScbblqtuhqsdiWn1JyQtcF94rIqgWQuj7fhiGaTfmnCwLmncmKS0vIKW8dMsLAAdNtlV/oNFodMHq9vAKNBIuxth13e20J0SHk6rCJoTgPkRXKTyabU2qNhTWYLoMABcpqwhkRZcXt9u1wIDXVWtldnWe4z1tuqpydd3neV6tVq4E7Ha72jO9bli7bSenwud+O970fR+ZdrudmfXrFSrv93v//YlWUWVku6lw7IOB46u+rnU5wlL/23K6al/cDxy0P3RhCe4huWdG1DsrfEX9VXlvMVl88Q8l+G2EywPIy1wOvrFWfgOZWpHLqqoqZgaoTHyyJpXuy2/vsa3jnfJlXwrTFydNO512B9sv60PqZsExv/OE0+WvpgDG4Ybty/3uJvSr0GUAzpox0QLEiRxRjdEQMxpkNUmZY3YzjIiwG9zfbZoRUVTVsqhicEj72jTcFz8QgZnsd7vD2IxSHhmzt25R1TRnE2VARkJQIIrQM0QKjNgBgSicD4Of5Zxz9twuV82HtR+hpZ4n1iW6ePupq6EpJRUjIgEbiE3SbHmbpx3j2acfbn7nh7BeYU7zeo7EIbCNM8UE2xl+9bWFOcYYuj5qBo4w3iSVsB748h24QHi0wsuzeLYC1enNm/Hm7uLmjtZriF0u8TpKQSeGs1/dzTc34dElBAZLJa0vEMxqiIoHJr5s5V9f41iuojrgQs0PBVaq6l0vWlSKB69KZi0IwonO8cCv7olsXOxRov7xo6effve3fvjjn/zRH/+rnKYSAFYD8zxGP2glBVJVzbLn/1qT+1X7plapvxxkOoHxBTiSZJXftqFhZjb1ngZHTKZ9TuXbR/NqnOu28FIfXvWalLApcAg8prFlMu7AAYCcc78aYg/M7AW03iTIzKChEChaHQzrVYxx2s27tLPF9AKAtq9QK7ChtRVVEU1LLV0RNwTFKjpdNwRFBWT30JoUG6mCQJqbYAhIiEQebVGw2iWh4GET1tpPbC5ofB4txzvhft+ii9ACJAFHaAUGULz7SOZhdCLq+h4RU0q3t7fb7TZnYebQ93kWx6WtEycFTRpixxW/WsA8u/DEIcaLb6qqQm3Ab845pWRcyq8OcyCquTwApblAMZ3b+8wdc2UA7KnInkeCQAv0ty89LnkuST2dAnABxarpzdCUmB5COU0yth+tu7u7zWYjIv5ParaqEWOQc66OjSr7EXEY+iwzIA+rAEzjtMs5M0WVo5/j4vjy5j0+43rSasJBu/FOxNx0UbdGWQnM1TkAzTF2sEH02AdCzQZCxJLPTHiQVESaH2gv0u51S4KNPJZSr2dWfH7Q5Iq25Hksv/1SVUJAUjNULUisSIZwcOco2AnfrYtgDXdjZm2Gh+irChVhva5nHUy9Ko97UP+oQ61huMpZzAyYIAMETpnvYJoRuB+6bm2yk6RCxhxD6IjZRMkAQDkQZphy2u/3DvvW9QNzmMf9PE4miAyBWRTR02qzqKo5EgIhAjOTzNMwDJ67Dmr7caYSLUbJKlnNLGCggKCacl5f7xVM7rYSIoYAq5n6DSNd7/aevR+RI7JIkimllCwbBnaOTICRDgg9Eigni8OwWq+9Nn5KM6QsgP3V+Z3KxXtP3//7fxveuXoT4Gwnet4TdHA7jjrqI+4fD+nF/oyfwNDZincosO4xdknk8vJSwhmtVimGDBZutnRzF16+vBwn+eg9HXpR617NF6sBVpQob1ThZt+JAoDe3dBmtVmtp3kuyCKIQp57/lCu2Dds9MllZg9+j4hw70/1y/u6wsnzDxpDk+OFePq6B3QOOjKsq1gNRJJyssTEq835hx9++NO/8Tt/+as/vvv6dd/3FEoXuFKGaeBKAxwr9AdtvhGf9x2c7QCORrZMCheLpd6AwIuwOVjbeGwKHkRDw1erJ/jEfNKloTyUlNEFXqh+s5xZ/1W/GhyAYL1mABiG4W637fse7nEGz5eIMfZ9L/PhgUU/O/a21vEXF8vC4tDRaVQNDmUTROTMlog0ZQLHpluWBcEINSuoOZCBGzaSsqoiIzVoZuoB9GUM3pPL0wzoiLcduWOpAS5rb4AGH+FkWyvTA0A6auzKgYmZQyQRsVx00GmagMm92tM0hRDFs87NdxZynlxGM7MqBKwNCrMSAHNEJkEEU7MCOeKqtBfBFgEMrkMIohdtGwFk0wQOCOrpu0AxMGClA0SUGi+slicfiI8AplI+XjP+gIkih6RSs/fNLBAZgGShAiFiJ1qFe6hKJk4XKQYvojEqFerr1QqykBoBMECpkkAwg+xpxgBGWGPA9aA6OeacQ+ju7u7Ozs5kErM0DINnpC6Katm/Rb04iqWdkAi0YnXxLfnnSvr+pQvUmrFx0LIRqsqFiKIZq63QHN2adxZ8kISOd+9KW0oJwVJOVYcDQg6sqlT4h5llL9x392XJ+SAiRFvqjZlZUjY0IHQbi9QIMYbgu6Y6+6QQcehXV1dXZnZ3d7fb7dAsul6rBiJcmvCBH1dDK1iiOft5U0Qjy2ZuCPd9X07OsQZfw4K+EXUXjFDUAKEf+iEWdFfPj67wM/XQisiFRQ3hNs/cr79I8FfZPrxczXuUz+cuxNBFyZAM5mkcQghoysOYRh5iSH5QdTfe6ZBXfc9Ew3pVN9okQYZ5nnwKIomJAcAgM1iWNO7FSZQIV+sAqCImuetjN447UFVyfGEMTDdpJiKdM0sacNjdTrvbV0O3ohiFWREVwTPB0zyKSATFVAgSjHIj+MZXWyZSzAoKTNDFHtEG6mkzb6fNsFp/+nF+soHd7eWLXdqNq6tzCfM+5WF9HjYrYdLLR4C0m6ZufbY5uwIg6EO62rzp8VyGDFlx7vdb+PXX6Vdf09Dxpx9MT7+zThY1jTDTPNpotI5pGrskK+zgySUgzTd7vMReeWLh2INZUDuf9esNYsZODSXbwmhORN03KRZFdJkBQGhkjAO4ndx8OMuLf9uc8AhP4i9N7/nFvjf4pjEcXYcAKSAUBw4DiCmSY+4Jo1w9Wr/97gc/+ck/+HfX/y0SmSQqbXEQmPf7/fn5eUmqW2rjW7HULlFlKVWKewgGF3eyLZeTih+rGEhrXbqAYkZEDAwqMYaURFX7vheReR5DCMyhSutq2deXQpPo1o4QqiaHS25WNoBFv1RzaAoRyZKIwFFqQwgppZ4jZOUFJ9BfFyg4r9NJbrc3c86ImFUFJLCjx7F6hU9lrWYG1MVSNoHFn0qo6vlohW9oJqLOqy7mzOyRBEQET8sAAzYwQCAGA5uSYEYH80Ca5wwAFEhETACBvT5xlMTMgSOomai/JRARlCCOZEPyZdSkQiXlgDwmAosyh8e+pTo7YFBUH1fLQqkUf6AK5mSGgQizKpqRQsAIQj0HMBAsZSklAVkw5zzb7AsVVBUcA5FK101VzWZMh8MmJV4Fdbgnbcd9uAyI9aAhEGJAqkGZVv9qD1T9t/+/d0appO8vzaZIVBbUsapCUNWUsytR0Pj2jQoIJ9xTS+uYl/EsWcTHIykcxPMf7eiHsHAr134cSabvezN79uzZ48eP6xytidHWcuLCQxYHTLsaJ+ysaponi+aFDH5cFEurFDtxLrVr2xwVIuK6Gkt4x/9UAgHHVIiIpu4ZLR0T6veIRU/1HBcHYqmrXdVnH3fJezJQVFmQ1lSVmfu+DyF4H7Jpmpwh1gG4oh0ApdoZtfiWvUcM0XFORr3TTtIeG/5eNWBaurkysyNS1KNYN6uOp7AbZhVBUGQaFZ7n6XpOq64fLs5BFBRQtEMSIFIjQutjJMe3BctZRdCAxG7GXd/3se8gOmydRWMzC9K7GmfZloPAYsZh8JEnSQAQSHy+OWUiQg6xH7rANetz3UX396jmDCYqIpZsD7ud92DzSKhzWyKCtCMiCoFCNLI26KkgKnkUYUQx5YnFdNOvXu/fGOLV2aa73tFffDFz2E9Tt1ql/QirbtMPSBHGRIE36wEuL1Zd3EUaV90wrHCX44vtFcbc3xADv7imXz4DUfzo7fGdy2k96PyVWsD1qg9RXyceDSaEF/p6BevNKqw7Bo4xCCKkKXYdVPhdN3UKMR68Ar/hZQ27aD/8tR5yP9vjN3/7b3gRYgURZubNZvPBu+/91ve+/+rzX/zsZz+7PDu7296EEJA4qfR9VwaGD8/jwZm2Nk89ZX60m/uzp1I5wytvIbfgcQl1Gi3YlC6PY4yeb3ny9hPdoiocDwqOcgOVehMAUDBVQcOcM3ShrKcVwvimtfVpehMJXVzLUACGQNLEzMQliwARhxhjjI5M88DjUKG4e48iKXX8dTp47IGog4ElrmFe93s8a1faJGXwRusx+iByyk70VDBhEQDBI9HFjkBfpsql63hOlvSgfDSvFhFd/DrLIEvI0mUR2BGrbPknM4OhmUm2gIjqlQICYKAAsnS7rFOlkm3rmlJxdjk6U60sAkCHEHKmTwa4NHo7mSGAJ2pUwUYLVZR3wSJUjJDsIB7Oz89DCNvtdrfbtZW6rgtLKX7A9mrI4LB41RVmVLxGLpwK1SKAweEB93QCn8jQ91988cV6vb64uJimab1ev/XkCSzxBVt8iXXW1cfTKgGweI9a9ahSHpf27kcuR3dIHTyVUICA6n4ffB7NmFti8it4obEtIepF7fDx1N+aWS2AaQ8MLl6WdkYt4fLSGoiq1xEQl0CSnyU/wF6f6XR8X/s+kPMym1b+AyEQHvxh2gyjghyoK82LPmoqcohkOeAgiLq6IyIIwETazMgaj9QMADkzQodxCuHrnN4wvvX4yf7NXuds48xEHBkl7/M8E/BFJEQj6Fd9JB63O015u90qA6gSQOg6P1iu8SuSqnZdoGHlWK6F/rvej1d12xZhYIqI0zQZQFITg5LXyxxCIBNdkHlMARHncbScwUrynbtGvfyEPc0+sAWCJqTCZKGLqhyQHNJRROSrSdYd//BD+NF3xvWmD313dd6dD3Az2zzOGPDiDM43EOMcWQPxcNUZbIglj3dvbmIX1lc9bKfw68/01y92v/wq9Xz+uz8Mn3y05nB7fXOR9jCrblZ8fsam0jMCTroPV+f9+fksppoCEiTJObFGP6oIgmqsnl73sIj5dtXhiE39xkqGPRgN+dbrXiOLh39+X8rWqwQdVD0icHV19cknnzz//o9++avPxpQIA2EAVLQi2NpH1TNbnfbtX1tZiIs1Ykt3BTiWoIBKyNDgdiy8HQHNwwRuPNYH5pxrscxvON/KJE9G6x9k+a+LSTGrzSlpqQmCBs2ilbXtyjSvMJFDa08PSNnSl7Haz5XTnjzhPlds72y/bCNH0MS5uOkF0Qpv08KQD6zSXbBV37P7CT8PXN+0zq23cwi2UgABAABJREFU6fgHAEAOR0gFmVRbYDREPfDoptCkTGFxPQRmNlVTzVlEFIEhsjF7kMkdDMWmdGcGAvrCFeZeIhcRXC0ENaMGBA0a4i673tSytpd/GQwNQR0bTE0WAcNdNMJsKmAYmIjEbJqmEAICIOERhAMVZadM3sBqPkqTQgEAnjxcU3tOtoQqAOCx2qSq4zj+k3/yT7766quf/exn8zz7mRzHMcR4sp2VzvQ4OaaSuxPuPX0Zl/9B818UKT4Al8EIBf+El/qRU03roVSM0OhlBChwMFzouB9hWUA4OCHrOnjnXvee1WhXPS0ICA6M41VeAIRIiMMw+Ls8qaW6NHBx57Q+24NnxbUiKwgezdJqE6tSs+KAPvi4wBt8Q1WkzEoPsur0c2LwiG+jHp1uny+XGJBZMECDicPzkF+A/WBY86oHUZ2STjNr5IDZzARlP6Fjza3W8bz3QNVuu4W7XZ7ydjfFGGPXxRDMZBaBLoiIux/QiJFCQBEJsUcCRAQ1M6mZv5IyM0fuQghAllJywUAGIZDZUvxMaIRmFvueY0TXFEUNybt+zPNERDiXleN4UDgo5ynPIQTEeBb62aTr+2frdPHph4//3u+G776vu4wv94a2B+3eeQyR+/WgIcxq3Hf9eg0I427eztNmPfAqXuxnvLmDl9c3v/4KfvnV2TtPzv7BT+zJeU6S/vzXsFqvnl4hRJB5vJvidNtFhvM49SyP8TycAQa+GSkG7Dl0KNQDI5iSes6gY24viQXwwNVq5CeXNHzvf/A6Oua/0S+OrjYF1ZovD+P8ZrucDCr4jZmleQ7MTx4//vCjT773vR/8wR/8+4vzDYgkUw6Uc0YLhfsfj/8hWQvW2N8tSyEi7ybqR6T5bclxbLQNQFJEICAv264C0kxSSjVrFRruWr+p/6yjIqp/8vtrjBjNzEUSFCxAJGC4t8V8nETfPvxg9WFBBOaA7vLc3t5llToFRM45S8rW5N8c6xxaa4Mrw6xsre6XLjBF7UxxiWSZ2RJ2MSbCaq8SJRFwMwmKCKMyMG92YWCmBVjL8VoUAQ6H+XjT23Xwyz3WJZ7VOpuRInHOZiqBSVVFFKCATCKa2/rL1ErixKJwMCwCLpSHASGqeIsvAlpy+x/Iyl4cF6UeaXEG+J885uzWtnq+7r3kwTJdPDyQlngN1HAGgICpeR0RImJKqYUAccZdPYonqiISWs0nasZfpZqZeXdZKZLRsAWQWJJCrLEA6hR0gUT7zne+c3NzY2aXl5cusbw9Svs6n/qJznHfF3df3Wk0x6OOR8sxe9jNe3IbNEkk/k/vJxdCmKZpGSGSHg6A56ygmjT1bPfjC9AQri3xr3qPq8lkJdu8QIY4kNqyqtgkiGHTTKEeUVhci7Bknrt3BxdmV04XHnQguHfxUldYh7cM+5Ak75rHYT2bA1knWHmHInIgVrWsI8BLs8/n/fMxPD07F0PJtp9nyFMXB6ZoZrqbNIiYToDSddjx6mzdnW+m5688n8mYBMxUGA2Z7q5vaotgV+a6rjPFjIZWuncyIzNTDBQ4aISIBqKIlg0UiFjNQHI5OYrZlCEQooghQ4yELq4CUI9oJiJjGj25R1I2VUu5ruH1y1e7ebq4uBJkHdZv0t6GyE95Q3P49We228XNOVIPZ318sp7WVyGEMAymgDkHDpBB9+PweG138/7Vl93Nlr58cfPzX6VXt5ebs/C//LvjR1fT4/UwaX89wcpyH3mA+XLT8RXd3endHpRkEkq6kg5kNMl5nvsnjzIqG0EXskqEgEhsSKakAIgABZvhwZPy7deCwvTX+8n/GJ3DHKOoQdr9JpUImhtsgU72TIWrq6v3P/roRz/+yS9+8QtQMVLItNijshAzABRRciIU2/e20rH5bXX1FUPaGva+QAkW96s/rg3RQmE4bp8cXndfCaj/bUZ1HOqt74XFl+AskQmJPAPxwUVrecvJ93VJVdUdQ2YWu2DJkmYAREJFRTXNQiE+KLldRBxJuN9sne9vLrTO+OXn1VujqrQktxKR4/oUdavU/R4G54Hmiv5yf8Hv//NBkYSIiCcdzgtO5+JuE4+XOLZZxZHLWqYTkohXOMQYyUCStnqN8+t2h/DYGYhY4Kjr6uOhH4x7uQ+5CAcNaLFZ/REnK+3KqcFhOxHRUka1GINyGFNWzQTQcVBRAHSVqd5PgNm3pxknLALMGldP2XXCB9suVB8gNJRKS/Owf/pP/+nNzY3H83CJjxBDrfpZXqoA1j7ksFZNt9WWFts7H/yMcGhV06zcQQOoN4sp6DIF9ZTeowx+fx4tP3GHQYnSMfo2hMCqp4V+dVtd2aLlguq2cdxfK+uIyxJU+e0JyLA0PoDmXMGin9VkK3MwQSv6LBOZ3+O31imV/jtYCam8lgwWBWhxpSARKrJRyWXmhZ3y0nCn8ojKiSJHjl7Jr4RhDvFVTm/y9BgsGcRVH9IgaVKEJDnPScc5xh4Qc87IhDGszjTEuHpyBYSKpYmiqhpjH2KvEvquJH+JAEBWyDmZGaohaEAyshnAHYF9t8HiowZVjR17XlEwRK91ZHJcYg4RgxlHIgJvNQDISGAmloaznojIQFKGnEANbsuK3uz2CTTsp9spWbcf1+H80Vvf+fFPVudXcH4OTx7B20+1C9sO8WI9JE3TPN7d9auuHyLkWa7vpje3+d/+Ir+6hl9/nT5/yTfb/nJ9/qOP8Qfv3a5wGPPlq9ldqqbJXt/l58KA8PgKyRQJ1ms83wASzOOUn1PHIAA9zzLjZER9l0GjEqKnWDq3VQRD+mtrAeQW8290rwte+FbIr5PrPp7Hb/7bo+cQatN8IIsQc4jxnXfeefnRRz/67R//8R/9oWRBpDQLYdCHCnUrVzl9+DHbqQehvcEW0KbKSB1Zd3mgqRSnGjObFcUFABA9rfLU33AygBN+2MoCaBh1xZivJxQKkjIhgGM64bEUqE+rbyEicEaKIKY5CWTdeRJ6CAJGga3UhigCEB+hJ7dKAy6FoOBY4P5eYJGk90Thg3Os3LvVNupmcVUIFsvZDW/vHU9ETAwlcm1qhrzE4JtNf3DN/XLgRNXTFGk1baJpR6LHFhWzmma+DkTEXWSKOWdIs4jh0gK0TI9iZAYjhBDAXdCNvg1LlKSVnYgFJtbx2hZQy3KTLim7R/eDB2WkPlnt4Dr0zfI+CNTshyfLeJTd273O81xBQcyMlnRuBVPVcARRVUSSD+AgSBahVWpiAco2L9IOF4dKfQ42sY/9OK7Wa0Sc57nve8cpQe84rofJ0gKLXuWxTwSa5kDt8yth1H9WQmyX8YRTtHKxpRUigsX08ISYnJJ4IOM47kOGANhGlwJSMmk8Y6dDda3CfRfk7ULqtQS5cImEMjMgPn36trfnQETPfC4+qQYctp3vSe5L9T37bvqZFjBY8jy4Bapt1gjJG1YRLl2gypkPrEtyllL5KwaGtgaveRiLaQBDRcDAHamNNo6EyGE2Wa2H8xj24zYQCwJznMyMgClIljzPOOK03cUYh/U6hBC6yIjZTFPWpBbk7PFVCMET8dylN03zOI4RKc9Jp+TdWERktqRmU84xxtBFN3SGrieiNN+E2Ikmj6RIBlUFMQCgGD0YShwihxgCAARVI+PSdw4QgYjgWVm6T37yY0HUSfIse4K3f/jpu3/np/I7v7MfYoodUYiGpHIuChNCug37Pdzs8s2bu5ev7j7/Sl6+GSZdffZcbre9SgSzPvRvn8N+fvZv/8PT/8u/xG4Fq7jrUZPGWenRBX3wBL77ttzu86brQg+D8XkPHPXuNd29jk9Jb/fw1uM+BpmymiEFdRvGMaTVSkUyobOZB8Xqg1ch7wLGVtwPv4lKYAtXv493fv/O3zyr9J54ODA08kzMpsmIqm7Ozt59992f/OQnz7/+6vNff9YPYeE8y0nTo4Pcil5oFurAq49PPRxZBVrBqbXC85fngBmolvanIgYAXdepqndTqy6WE1b24GezGhK/v5Xo+YC0pJb76WBdLCIo/K9KrpbJ1Bh3tgJ5joX/AzECQJoTMAGjeozelI3qLpwMvmHCp+vWvrpqG9Xdfn9edf3vmz2IR9wSPckGyduNWRNvOvwKACtcFyydhlqTe3mU47XDvQsXZ/AiQIupDOYwLVaxp5fJej0DINli9ysABCLKKgIWkAIzMwEThOAIhkck5nLEXdzH9KcVomNxS9gS4+/73inAljwXImI4KNyqagCqxTsCXvps3n+IXGKp6jSPnlSPAOLZ/gDr1QqOz4wV68Rw8RzcJ+IaE6FjaP26Q+3W1sKnuu7+2THQPNBji2YtDmoLAFiQduvT6nP8s0tcaDrQ4vEYWi7XatMEx9BGS5f6GIM1qsaB3BfvE3qQDcAHEJdck7og1qgU9RyeqBftMlb8HMd18CBX7fyeJBNgKHkHgIhMxMyPHj16/fr1OI7DMCBiSsmz1u/r1P7G+n3ZmOorUgMm8s63ark4P44psw4VFo0ZpDS1Wi71dHmEgmiz4NKeDKNuMYoKJoUUgUGjiM4is0rXrUUkm8Y+oAQOYU0XwRAfXY7jCGq73QgzMOB+uxMYcTenGPq+7/o+mtmccppG1TcrHoYBjJj58vJytVojGIFOt/O4m6dxRwZd13Wr1fn6cew6IUDEPKecEwEMw8BIU5qHfsg5c6QY+6yCQHFYIbBr6ibCXGCwASBEEtMQAkUi5tB33bqrKxAfX276lc6yHjZf77fxg6fw1hWPWxIcELtXe/jyhe1v0s3N/tmz6W7GlObb22l7a2nmaTzL8DisdiaPQuCug572Is///Bfdv/urt2m4O4MRYRShbtW/90767Q/6736wfvuJfvSxIJyZwbNr+7O/mr/6PATa//5fzlkef/fjaTetzs743ScMdDtNg6quIlM5NbZQM/xHXUcncTmbeqzH/4+87uscxVr6jXWRLNKH4OjdzlSNMOXc9/1bbz25fvfdjz765PNffxa4EzIwqJlRRKcy8r7AO9FFTge/fE90EL2mBgdBuDAdddeGqWqM8eLiwsxub69FvOjhJGjybTP/pttqHoMhEpb2F6hmoMRcF/MkXdSXAhonB7rKWGvUTZxlUSiFS1UwqKiqRergIfnSPNy1HXeDgRs57URgkeL1J/cJrLKdA2ibKBKC2pyTs/Gzs7Ozs7Pb65skufhKi9JgxKy2VERqQ3R2VI11tCAt7khzAwEBFA+N1ySWQP/xpmHxHJNa0pyzKXMW0SzJjahgCIyEqlkmY95sNv1qnVTG7dbTI3yl5uTtsIM7yJMqulMEiRQY0CEsBQwZnRDQrMfSWa36OdxczgBHIRWfrQMkZDFCCuwY54USDIbYgYFlYQOvSsimZkZdBLOOQ/Uu6pKW76vvvdlkafPmssQ1pBBCznkcR0SsOYwnORYtBGxL9PM8u8z2tMf6w+TZiIE1ZRFZr9fu4samQENVrQCsqXdvbWWqmYloF0sBjjbwUwAgaiAmS1Wnc6o+BHCYKTsKAwFYYFYzVUP0vE1CACTKSxJlkxfmncM8DucKkAZEYlYRIoZSeSRmhuZ0RVkzETKQGoioGXh8JgKDUygWcNhkNs/zH/7hHzLzarUqdBwZEI1AxAhLq1LXLN2bRXSkrlXVEA79sxEAeYGIk5Ilg5XEfPvSLCGEuAS864FBNSIWXsD1AFR1nmciUgSkgwriPxHMRIFzYAsWFGzuRJ/Qeryb+r5PaUY1JNlNIwlmpX7gsIpA4fxsk6dkKfVna8nz7d0d5pxMe/fSmQGQquqz6xHulBEQ9y/fnF1dri/P+74b+rMLxN3r6+vXb6632/n62rpAzJe9XVw+AqC+W7/19vuqcHt7+857j9N4q2ChG0SsZ+77fp5nBuw3m2k/EmPHNI27eR6ZACx3w9m03+MMgXh6fXMrM8BPfH2nX/9KuEMj7lZnY+q+fGH//D9cyx5FOenu9S3u5v12l9GS6aDKMXSBN5Gpi7nHvA6vNrgW3Nukuuc9BqUeNZ3hmx6Au93HT1Y//q3Nxx+vf/QDWA2qto0QCPtXO3j2avfZl3J9d/4C4cV194uvhk2PoZ8YVrucbrd3l0MvDFlthqnTiCkYD2h7As3aCaCh4SkrFxBsSgTroQYAkjZAV+RMy65Or+UJBKhLk08BB9M1gBLjK6DJDXd2lJrl85Jq9hu7vocQQdQ7i/jvUC0Sz/N8dnb+9tP3vv+DH/3is8+fffVFILI0u+GBBzFz1MitCrz2n9y0Eq0cFZo6uKzgOCGGgDF4f3ZiYEBVS6pmmjP0/UpkIgznZ5e73S4liTESWX1aPeDVeKsmUONfPMFuXtgyGwKaoqkiACqZWcSIiGbgnYmYOSzM341MUIMKNOLLUZsuofe0KSxX2ZzHOq8EMTYkZFt+daJteDZ68BCMylKJqiZH/ozqKjipCvThVWl14l8PISRLCmXwuoBrd12XJNfgrBZWRpaUAiMAqKkqgouBwiShyVqtRiYtCaZ2OjMgInX6KXwYVQ3BC5GSaAohhEgqiMgOLJmzmBJziIRZBREDqKWUAMAt/mlK43xdHRK4BCC4SSNlJHa8S9clG+oMTSCgnL2m7LNSDCHCkgRERKhqy5zzEoRDAbPFCY7ANfdCCz9YFgh5kSJ+ZlyNsEXxn6ZpqfyWeZ5dmLnG4BGZYRhca1so2+pKYwNK0/61PZzVu1X/W5RW93vPs1mpHbDFGxZjdJ9bCKHrukXJOORCs2sJZt5HCBe3GBHh8mrXBVX10HALAI7BvOuJrVRVx1kDhO21PKful88IqUAMoZlCaRppS3IQisg0TYoHfgSLSgfNYfYneJjgRIdTVQbMc/F25JxvtndENAxDoAOseDvO5iieOnXw2Giry0VNoc3JIXdlZSnhOwQZRcTUfMs8VYWD1z6g59AEsD5wCGHVKUxB0pxzFsmWJWXLoiqkYIEHZg6Buy50IRLa5XyZUpqmNI9pnPagBqhIGM/OVNVynnPa3467cUvPyMw2l1dvPX6yOesvL95zrM/r29sXr15+/erLV29ehhCGfv3q5mun59BdImiapxhss1oB6Lh/nXNeX1xsp1diEo1VKUNySEpVHd+8Hvq1ok1pRgRoqlTkZme0l5wnsZs313meU54D805GBIzA69VaV0ibwfpI1kEMEog4MHGXNWim3TxxiNgHNTRIRvvNWq7Oh6dP8t/69L2zt+JPfrR7cnmTdQVInXHe93/y5uaP/2xehbd+8DFk3X31lRFsBG9//G58512aZnjrTFfxPJm82eYx4XvvVtn/G9UF/k90WRuMwKPvofDAJS5zpG38T/BeAIBarAEAAIiYVEjw6dOnH374wfe///3r18/TuAc7KhiExpUr8nBux8k/TxhI+X5pMHZ4LAAIehg1IAGTmc3zKKKjjJ9//nlKKUuuiWuVnfoDa61ca9q1H+rg6w8Lt7F6T7lBJIUQ3O+bUkoizmwLUOEyP4UFJKkLztFcuzQA8Qr0ssKGZqBGgEQciFPjoWmXFBq3RLtZ1viw65fYNGGos65qR51pVSzqb6t1bWaOKX7YR++KWbtiAQOUTm/WgBTc3+iFovBknO0Nugg4qkisokzIzO6JUAFXSAAghIAiKeckC/ozYQAAF4rrYQAKIlIPw8GNc6x8KGF0MQYAS/qrG/Hgbo/GsamN9lT5ONFRs4GD7EEkZltgeT3QQ0ThOEmn7EQhLAGAWsPiiRS1bgUR9/t93ZuLi4vdbqeqTnw+HVcLGlX60DgRGgfAyVBb0dVG1DyfqBJTwQhp2sNSTRRAZOb9fl+/9GG7aKzlr1VMnkwfm8BHvYGOk3NPSL+Vpm1dhmsV1qqAx8liLccBYDcCakpUiaTQoaZLVb1Ort33KvgPFswCoQEAtOgiImKET548QcS7uzugB5Aij/fliDlWmNeqD9VlP9lZaDUhKEm4LU2WRRCJMa7X65zzdrtFIzSBUjppQXXTdT0TEyAomhIAImUigyQiATSLKglRMLOENMdIaErIXbxYr9xWExGRZGYpKzjBZMlzSvM878dZ5pfPv7h9/YKINpvNZrPp+/7R5fn77741z5++fv36+vp6O+5vn32VJfmoL/oLM1tt1sMwMLNv7jxfD55OTkEVQYExIKJO6azrVgi7OVtKq7MNgH75/f/Hez//LwHgvV/+N7/65P8+JyHUeDFswjmAUuBHhKvVioE75Jwz9RFjyEIp4AiwJ5gNcVZLwoBxdX6X5j1mvdh0n7wff+uj9W99Z/3Je9xFngOEYb0nGCflef8nfxn+6C/kBsLFIBdnaeAoIVxc4LAeH1/R3/o+hB53kz0660Txxe304g2fb5goNxsHJYr8baUj98Vqe7rv3/BNl9lRASEeArtgZidVcmbfUKr717+kaQKAUJzkzJxFzlar995773vf+/SzX/3l57/6JUd2EAPv573MTmsEqn3siRA6UTVOHMCE6O6ZjFZxI2ERW7Tk13ddRxi8cWbf984Y23dVuXuf3y4MrdU5vGh0+aeRLT2nAYTIWWtni1kSY8Qlcu3fGIBnWcIiZCuvruxueX5htGSADKAGijlrKdR/SIeAA2M5qkY85rcPkFl9FDWt2qERSdCwsupzrR5ZInKm3MqyZpUMEXUZ08mmH/1zcemd0Km7NwxBwVxaoGsV5H4TUstUwppYSnOZIBsFpsAiklRCEZyKYEQGikhMiGhLVUJLf0QkoAqWVMgR/YrZDWkqTXQCMTTWc7vElYm3Z86XxJ19aKa80DchOZQkMzHn/VjomHApSFnC7WZE9PTpU2Z+/vy5a6zMvN1uQwjuwM857/f7vu/ffvvtV69eeQlrpQyXUvAQD6ru93ZXilw8jnrikgfld/KxkGtJpyXr8/NzR4CAxTnhClDfd9W91oYAqv/ACa4+7YR6WoXjhIPUD81pObgEKuL4yU/wmKViSczAgwhffuVjc42qpQEnGK0XAi2GlpmBgUd/cs6h7x49emQIN3e31bnaPgqXuoz7Fx1KiI9WpeFWR6t0YKkKRkeZXK2eBIvnCcxYwQiNkMS6rOc9M8i830lKZsaBAZCIsgFmmKa9UyOGksGfpRQku8vDQWWWF1k/RAAgwEiMAF70r6p3u+00z29ub7avX+rr5wZ6NVxcXV4+evTO1eU77737HVW92d7d3l5vt3fTNOX9XRLZv36VICFgQXQGDIxE1HEIoev7ftWvQgiG1sVulDGjxE0YVhHVOjyva3W5eSxDIiKOzMwKkndzt16FVb/d7bcIvA7D+YUF2gxnKZJGm4eIZ+uw2YTNJm42Ny9eKHG36jbvvHX+wQd4vpmZFYATb0lpv10hwqsX+V//8fRv/0O3Gvi/+EfrRxerXz/Dz99sv//2Hs6e3EJ8d51pDRy7Hm070iwwJmQKV+cAyIherN9mL/7HXQ8emW+5Ts7gQY7eC5FUzqdNRv5/BDLpAVG3Uqn/E0BV9/O0Pj977733fvzjH9+8frW7uVnOhVbee3KmWs4A9857PSyttlEHbwAIjAhgBwBRAjIpPU/MDNlCCAaCiO7xbUMMfspOrMr743Rto92RNIs7VBpbQgHAG6BV9h6YRWQcR/cKA4A+5BOtbLmugIgRA3kO/KLc+Jf3tQ04sg8PQvCbyOP+X6toaG9udSCPtlQpYEtIpcVJPIRp6NAy3SEe+Rgw+mTwlR+ejAEquAoVvu8iWM0QRbKayZKwAmYmMhNgzlkREDjGSIGTyjzPQRVi7CPxIiFQs4mKxyDsuI60ADqpaXHSoCK4eglMBN5umw7qKhjzAeSuUrZkrcpfu2cKpY0yIaIaemM9AGs60BwWywyWzGcRmacJEL1C1cy8UNOLR7bbrZk9efLkd37nd7744guH1q+j4qVvyP2dhkbenGxM+9/2nupF8LY9VeRXnaY+0xfq8vLSsVM9Y6O6OszMIcDdFFjcHtJ6NWrppmeewjHXqGKy3t+ekGbM2N7Qcp9j54p7QY4WR1XqiQA+mAjVDDr80zyMWDyBig+wuf04ev5pFnn+/HmMMRC3r7vPDk7Oajuv5Yaj8v1W98dGh/NRkZWGxkfmjkN17Xa+lQQEihQog7HpWuyCKKQ55VlVA/rpAFVAYAqqc3WGQfBdA1PVTTeo6pz3Nha4IVpaA/hEZibCQEShizGG1fqsXw3bcb/d7Zza93fbX3/9+a++/vVA675fXV5cPX36zjtvvUNvv9f3/evXL3f77c32JqVpP4377S57+ZjSnNMWJoA7vgWXgESgtDLQvhs2q1UAikirblWXLpB0ISgxhTCrJIX15pyHDkPHEfrQcQxM3ZQ0bziuVk+uNvD4HN55DG89yo/P4PLsXQtgBG6eIsEk/TaBke1uwwWlV1+Nf/Dn8m//ZHgxbj54Sv/4d9O7l3y2ml/3Aw+bswvkFXC2y3XYKjyOkWX88mVHHC434ayDwG1TNDNTglPBeHyd8NP6pd1T33/Dy89Jo0UsWUX1hkUj+I+rg/2ml9YPiEgGU84MQAbc9e+89/73t9tf/tUv/uLmFpaD7FHZhncdlbbWJ58wvcoHxIyP3cAlrh8B7HAG/cSLSCD2fCzPcmvFYctFYXnmiU/U/6SqizXHJ4N8MN5qIDnl8/PzruvG/TxNE9oSGF3CCnVGbu7iPWcDHruoRRICMITIzB1nmR/cESqpFQfu1Cpq9xWUdi6tvG8XpzWBsDEya7aHB3ytKZP2RITDKwjBjonzuD/ryV6U37ajBXU76kTYuXPDiwYWngkAEL22XzICiEemc4GIDJE8SwBzFuBDB7y6ZNgYst4+j5d3g1lWUdUQo+N3FaxoL08tEz+Sc2VRFg82MZGamBmWsumjLTETVXHIDTeMPaWnaCVIBoQ05en58+feXMBdF8ycUvLMjK7rzOzNmzf/5t/8GyZS1aHvoTYLUJ1Twnv9gU48E+2fWhJv4xRmJVXbzMAONHS0i8tnf8ir69c5ZzHxno5qQkQcOE0F/Yka/M02vFUHVpblXuJCq2rcp6rF4lm8is1M6/0toTOzlfJa/6amZQAiMJN579LSbS54WrwnArvC4Wvl5WeE1L7LECo8eYwRk+zvtimEVku7fyq+6Wq5ldnpBFtm12owhYdqgXA96KNEZnZoywdAiAw4g6LKWuExd12WGCOLQRKVlD0qjMDMl48e7/d7k1xXUtVU7fbWYS7QWy8homMY9MyIZIiaTHRywH5A7iCspwSEm35d8n5Ex3F8+foXADSN86tXX7x48UUWfXRx9cknn5jx40dPnr7zTogkqmnKZpBSevbLz0TynEbNyUDmtBfIrDSEMM8T5X3eTQpmEDPe1EV7/auf9/0qcLc6P193PTGntIN5H/r1eVYY87TfTcyZ8f/P25/FWrdl6YHQaOZca+29T//3ze3ixo2IzIjIyEhXmkoZjItSSfUGlAwCJCNA4oEnkBCNBOIRl0oISn4tWUIqhAw88FASRVnGzspS2S7SJu1som9u3PbvT7ebtdaccwwexpxzr73P+W9GJiqWbvyxz27Wms2Yox/fkNfN0HppWGaeT4/54V16eM+dnfbvPGmASSEhBIcRkhPpyOGZ53/yx+5f/BBePsezBf53f4/eeYxX6eLTl8fvPorfendNbt7DHBq5f3gl48lRlzQMYx9D38zn0jA5lqjIApJdZjL1Wv9l4Lj+AhfeMHO37Hg/nqOIf+kuKzevagYA6dYAI1CH1DTNeugPFodnd+998LVvvHrx+uLN88nRnqrpt8yizuXm6/rD3DeAkK3ZljX8UlAU4z0JUARSSt43JkCKMFbv2XjF3hOrrK2iug4sg0ru/URLhzD7Dilmw1sRweB6Y4zjmJk2oYtpnFpE1n4McIfvTfmMI3aO0FrkpWSewtr74uauiGRP/c7S6e3ahu56jPbkhd5IGjU+XB0B1Skgpalq5lGYv6w1+TKblggWSSstICq51ocaPLyt115SkhgAI6FJai0Dds4tFgsiWK1WNgznnKFvExECpRAFVFJqiB0VnIYszETJsyeuGkaVT3l8ohUeQ+vyIKLjDCipAACKFvLZx87ao9p85woqxaS5hH5b36iqe9sAE2XIqkUW3SwPy2JaKaYx1cGbGDs4OBCRvu9N/zC3HmTnNqcb+Qo6KfeFXdfWdBb1C1Wc5E70aQe7Yu+oaEnsSGEAc/o5BwAhBMMAbdjV6iMqXZogA7BuMw8EQRASqNvtFQS711R5Kie5ILNtWWSN7uWbbN1xaqnIub4GEWFXWXbOARPAtju8FE0CITeyUVUDhdsbW25hw8iNV9UxRSZyzlFhHm+byHRGW9oAm1ecJM/uRH+mpoZOYntbLmOJyaBT4VEPc0pg6OIxRkxpDnjHN630zrnkFRUjAERRRCZEgtniMCnGsScEZ3VGqqoIEux0SMrFeIjMqFHFs3PMiuAUVTDGGGIcYgzrXkVmTTs6N6bYtG07n3309e+EECSqeYxXV9fXy8sf/tm/TOLP7px083a26Nq27dr5rDsI7A5/+zvOuZjCOI4icRxHoze+HPrVMiyXEkZSCApxssXr6xE2EGStl5lcfdMkJJmtInOc+82Rax7fb++fjo8ftUcH86OZW8zg4AB8B84l9rSYS0gakhK0rO160FfncLWSn37Sf/lq9vUn9G/9NX9yJG0Hs4P16XhveAgJHLmxdVHCiAoOTsYGOA0vX0Hfdw7doh1CYHKgqMl0cZxw21+/yPTPuaaU8Bbyu13nwJq0ofmjPUCB3Zv8hS+zuOpGEaI32MMxQALy7vD47P2vf+PVq/M//uevdGoB534VqLctUD37e9KImW1uW1YJCIQgopAIUUkxQUK16hUgiGMsPKy6S8VabVfBWR9xM3fhpkSsrxEYcNtzBHALLmiYEOv1yhok2VNjjJIAqNTn1GUnRDMwLPUUJzxKlBi8985TSlZPLkkAJOwNEm7TlvIjgLe5vRPHc/3V3tSmQfypnLUvVLEF03KhEl/Oi2kc1e5jqSq437tnR57Wpai/Mk/GVOFABAUBNdBnIHTEyipjMHgIRBzHaOXEqhpVmD2pSsg9ig0LyEnIbhku1RAxJAHFsu7T+YtI3XypeX9MTGTgGQb/VU+bImi6PQloC7mfC46Es8ukiAFEA+9KpZI7b2rJ4bA3u66z5Y4xAeQ6Ru89yrZwyKIVVr1Sc0ttTS224r2XiWNgGg6oBF1PYFViKmzX9LIH2eCmfGdP8zBhk1Iiz6n0FqmAZikl1zbjOKqKJwbEECIAOO+M/HKchRgIiZiYUbY0PVnkbf13JVAomvWUjk2HMIFd52T60646VQkUzVqzBznnyOeGinYApHwkqrWnGirgbpmxboFCVK0Rj/HB4taKuq1y2l3A25l1PfNVWyo/x0pFey4i3L3sHdpNobfvxxgF2MJXUQRFW6S5a9oQYhytnoWIyXtUISSURM4hOUNlMU6HyKrgupaICVhE0hhCCJKSAb0mVFABpca52WyGNWEopPX1EkNAEVIJktab5ZtXBwDQdr5h55vu/fceOqaXL58/f/H59fnLL15vGuC2bZn9neO78/lBUDk6OvHeO6CuO/BHPkVVVXnqNYa0WkMMUeVis+GjOfzjvKrv/Tf/phtDvLxmSTIEIuhBFSF1TWp8d//O4tFd/8FDODuEgyfQcnCwgujIO/SQGIDRjcqkDSsk2qzS51/GP/qR/uLL+a+ey28+wXv3gh6O4cCp79Bj41Ncc9sgAGyic60j0jECu/H5M//ywkfRkxlAooiu5QiKJT3zLyq5b8qzvfdvfvS2S1Vrj1DkYofsfafe/y80yl/jyudWFAj6vp8fHA4KJ6d37txbPnz89Id/7KUAzEzNjCl554FNuBzs2pxEFEW0+J53PoXcuDmKJEmIYI0VDw4OQoHJN0GDiOM4EuVaQgscawlhmHCqrFtLsWFd4bwj2z5X5X2oBxksz6PU1RvejCKidy5BssFv47uEZD3DMyAeT1tHSUzJJUAxfzkqIDDvGpm6qyTVdYOibQDk5IaqbcBbWFl1V0959d49a4sPmbRlqFkHMk0l3j0LglCrSvFGOn/+sgpa1WtBaK90AcX1C8XIRERFGobBoCVExDn23ocQ7p3dY+b1er0aVwDQuAwh4RxlkLKUkiAgk6XHYAE/h121SwBqJUhKiZgteMEKNlBBs+EUARkRissrX9kPgZCkUqElW4hITKlxHglyZMFKIpNkmUSoYOqzemSvoCKkMPZDN5+1Tbvpe1IVBB22fjPELfXUzjQoJtigdT5BRhmBIp5tSFr8UVXZUtWokrvUWLU9AE8QvkWkQcz18cXCntaAVSlYgiPI5gKIqV+txzLahl0cRosZCSgTkWO1QiymGIKh2FZh3zRN3IyI5gjZAa2ySmALsJXMcMoq0Y7dNq2eLaViBQKcmUBg2PSI3HSt5LxoWy5h5qgC4xhjNKUBESNEBmQwYHKjV0AyF7cCKJBZR5SyVpP7QStCAkVCVV2nQLotAbCjR4CMGCCV07JNnmLmcdwQkWUO1b5uVvJTQWXqOTdaFAWr+xWRCpVuFhoC1D53WUEEAvJ+1h4NyJevDtS7lCRETRpjBEkE2DonGlWVnBvHkcDN/RGiRkkCyowtqKWi2Ui48d57FWsKVRgZQpAkYfDe+7b1TcvM7vTEqFeul/1q3fkOXA+ikFYxgSZ+/vKKGo8NPX7nQ03h/Pz85avnYYg99BJG5xxu4pVrG8eIyI2fHR623RzJwXLWBVjcPb1YNE79O0fN5v5xVTia//H/KA0bh0iO5HqlmhaXcUgjOJjPGvROQYUYHFPyosTsO0+AwqzAKHHkCNhv4NVF+OTzzS8+dZ+9aZ+dx5eXwTv/Lz4Z/+Wv/Nnh4oNH8hvvxW9/Td+574TGJg6ODoOHIGsW5xCevxn/+OfwwX1//yFe9LDG8dSnBfrryMQGQbB2rneuDdQkvfDSECLs+xdRUWErcaciFgsXtmCWIlbyQwte1HIJzBwcrX0FKk87bCej6erNLpr0r+HVkImWQruaCVXXd/1ykWnm6RAlQnKNDxLSmNg3jx8+fPnue7/5r/yrf/hP/nED6BGCpKigSMgt0Vglb12H6tmtgcXKAEE1WYAV1ewlx9z3PZICau63IFbhSOMQI1j2hqugPADaND6l0HUNAMQo0wR8Asz+xa0CYcViUCQHABq+SsY8AVUDpSpLp4rguQshIBKTy7CSICqjSCJyoKQiKkikqIKixASiCprTC1QJMYmAatj0AUA1TTjBNJdiW2+vut3lpBERiQu3l+3yprQNXEzVKSgCSFWHYTD7MyOXT+p9quKIk9D/VpspaNH2TnWT88R3zd5pkpQS0A7uwzQ0D7s6sdWTbGNJkvtuYja8LYbFUWUzBER88vDJcrlcXa0sS7cfBwNB3oE/w+qNhAwEnh820eOmSlklCGaGuA+JagvREItIygXbyIAISLLztTTR8qwJje3TFA5kiKFW2wKAoBIiMvUluN4PAwAAU+qHw8PDvu/rClbOYjsHqgICYJ1WAUrTYRPeNRPTqMEgQctS1Bcwve0OR7itMqW+ritWSaSu7d43c4hRRSaF8qoKkuNndTVSiEGzWx4mu2Yv5vO5lT1bass4jjGmamrAjct77xyllKa+O1WNmtg7ALL1cc4BQzC4wwkelxRUWfZUp1ofM83Mr9NHtdyd3LWnclgGBMQECQw4nwiMckSjCDs35YYwydnenhnOqrqq0lemxcmNWp69xalrS8yEILFQphIzxjGY4FFFzX2UEVBFhBhEIlRkTwTQlGJUFevfY+ze9E5kxwSqKmpeDTQrre/HdiFt2yLhrJl1vlnM52EYm6bZSC8hyibKGCQmGIEiAuFA/WKxePrkXVW9vryIaQwhDSH42Ww9rrGPLbLvaXl50TjfdfOIyRO7lzPvm0Noh16uwwjw37HpX/8v/mfkD3h+7A/OuDug2Xx4dMonMzmZrTGiuLZtGUjGuJwn37Vu5lAT9IMsh7BZr6+X6Yc/az55NfvZS3j+RkOI87adz5u7D8LJbHa0gHsncHoYD2fhaO5l4S+oP527IR0KRZJ0RHNJ8KNPNn/yswNtBB10rPMmbga41gYbIp9UNEnwGDB3q44EXHvG/nluj71T/LYvqOFqFM9c1UZqHuiUxpR2sBp/naeA+cP/snEgLeaNSEKxfqKxaZpHD+6dv//+888/+9UvftoyAkDTNKP5tnHHoKp0Pv2zTg0Aat/HasaYRGSCOE1gDKKgjXMAZoUjormKrVVC6rqZfVMmrtk8/VK2Zpe1npcSFpiW5AJs+R4DWo4M4hY52oQI5O9sKzmstZhpP1giYlMxoQWKesoDYWI38o2uFHYJZCQPnAgL2HVy1zemt61PsXcsDRNgK5tgQl17j55uk2qBKUPU3YhVZcgiYkhoiltIj+xnulFSm8c/nY6oSBLIyb8pJcBJ7gGgiPz85z8HgNpH3QgshOBsjVRzxzF7jIAybZNxps+e2utQtAoR4ZLXipPEKFUFsf8EAIjZaiMtT2e6RlBddmNE1YYb59hkHiNJskonUEIUFBEFFUTH1LmuH4chBue9xUfatr28vOy6TnbTR2wWRCSlInm79ZMl1pJHXb8PALiX5FhycRG3fWUrYU23cKqEwuRplZhkoihMNJt68wmhZ6ZgfQKRAC3LVEBjjCg796/3efz48cuXL5fLpRXBm3sju3km15Rqs64TY52siDJbEZMm47lkmd0qIgm09sgiQCUSEUZnagQBaOlnZ0fB5kMKpdEaEE6AbiD7xu2O5tbabhSjakoiBL52ippYoYpYfKEWrEEAs1ZlZ3GmQkgnukh9cy/Vo74pKKoY4igaLSOamVMIFNR6OkDS3NQAQVVJkmgCSY5QRM01piIggESSD3wu+mJ0ZnmSMYNCITGGy/NzY/Ft28b5nBHJkWvc8fweKbGCJohj6PtxM/QhxnnjX7x6Pm+7rl0cPzmVGC4vL1VTGK4IPRCpJELxzimkVX/lo0Zu0vWa1a+cGxnGCTDJF//JP3agDBggCYM6OBkOR8I08zpvxDlFZu/Ytw0dUtdSN1NViNogs0oaBlwv4/U4+mbxtSfNb38Iv/Ge3D9OzL47hK6DWQtNq0xEmAASQPIQeHPoPSyvxh9+Gn/6Mf34k9nlGh59qK8ulgs36xZ+1vmuSzGpRJl3HnnNbmTnEgDAyMCCOzgYk5O1x6N3PgMAAC6ibsvNIDd31YmSMVU1jMK1fnv6xELEb2t8n6DkE+mWCOXGfW5e0xyO+uAE6kCJUDQxNw8ePFivP3j97MXzzz8P/Qoqjp+kqSNhqrLfZFn1a1USp5SiRudc27bO42azkRBFgYiUyNh8SgnAitgzSBgROcciYsp0jBXpGCvXhYL6MJlnduEoosIUwyN7JcmgcBTM+6vlvDOidZIsGo/kWEHWNrZ1OpClW6620P2qPULU6QjLix0WIYSIuVkJ34iwTF5jFQ3Tp0xZje7iBu3J4qmwUNXqlamKlfXOVNrBheJq4mIOwmnJHGDvAWAz9FtK2vcLlpFMIhbgiJh84xFx7HPBv4icX142TVMhyFRVCcixk4nA3ErZOo3dYN7NtdNda74KWiowqAKaPTyEpSmrpskxQkSaEvS2jtSZ00ZAQ4rotgCadnMEjSJRUtM0Y4qGKIoKSdJisdhD0KtnabtSAAg7EkhLtodOfA9WnTFdfbUIItVzstUndILxtTPBCcal7tpb0+SgSlimslh003Q11J2l1uLLNZfBNBd/7/6vX7/ebDZlGGw5AdfX1zcYbh5bjJEIjB3AVmdS8jz2EQCccyIFQJYxSALZqlZEhIqKRIC5Mx4AFFzlrfJUDo8l2BNidjlOelOVNcnzNdMBFZSQgQsLADtfzEwMRBSGDJgGqrURnd4oxpks+NbbdJPCp/zF3owSPXBMSViVEZgtW1YsEQrQCoWZWUlVNYXR8qxFJEZRFCZgRFAFVQJUZPMTA1ICAAFmy4bLaOuqCQBQBWIa4zBsNsNqzcyeXRhGt+klQZQkxH42n907fXB85Ofz4ePPyPnG8Wa5QkTH2LWLYRjGl+K9V03ma+XGA+g4BnZEjgEoKQZGaOig7WCdl6vrDpmZCGQcmEg0XsyG0I+4kvm6m4EfVUbAkTg07UgU2iYwI7vZ4nBxeIBzd/BXf9ffP+k+fArvPYCjQ5214FskCI0LIcVNoCQdYosIYT2uV/Dl8yaIfn7h/vAns198kZykQ+49tZuNLnteDjw7SgToaUBw3LJjQB+bNjnmBCPKyNAFiLCvWcJbrj2Nc0sq9mn5V7ba7Y07FCNEi/0GEydHpfa3DeAvcd1UX0SEvNU9KSKlFFMKTePu3Lnz5N133nnv3Z//+EeOKYRA7DxijKlK+ul9phxp+qfxJS1J987n0n1UdUjKaCy0cS0hh5CapiHKcYEqT43PlDdx6m1NE6Fbr9IOFCH3UANVxQKgABNlSERQkBCTAeeUGHFGWsiOzOrVqPSwLcOkiaU9FW0AgGixg1v8FvUnBihlbhbL3FLVvbjYdGH38snqPXW3JrFqDHtUuv1TtAb7qIg21dxFNE9tuqS7nhJyzlJDxhi2CgoSyPYH1tQOzbyzmwOMIK5t5vMZWPlryddpmsboxNTKrNOY2ZrAIF2zZwJ34Qr2iK8iipbFKosuKilpTAAADOYBUMIggjkTAKWInHRDb6/SLoRQ0SZSEsSCrWaLLtVHBCoaVRzA5fJ6sVg4REFonV+v15YcWqdQxecU9tsYB09cDmnSkXyaU6mT3Mlc5kslLLi7hVWrmJIR3OBi9c4wKb+sJnVVhlSLY1GsM3IutQeAGpY2akJEvVFSZUv65s0b8/pwrSsuff92tziPM6UUwjbNtqyYPR2Kr86QUs2e20PdyYyVSiW6/TwXntlJyOUDW+MTAdiOwy1KrdakawBgZGZ2jmKUSfQxWyfMbAqHLVTS7W7Cbe25JyPc6hx1FnX3J6uEtimW3S+ORpU+hdY5hMSAisCIqoCkZG1gRQyg30K1Yk2moJAxkGNSIC0KJZIrzDGqKuSyID5ompjSmAwCf0iIETFseo3BuYbbxrWtqKzGYfnmFbI7a7r5vGt90zQNJIkxHh4eD8OwXMxCCBCSE5UxyGbEFA/9PEk/DlEbWs4IHc+JZGLrHD1+wLMDJN8NMnNdg/56fhHGuL5eb676KNjO5rPZLDG23PhFB4/uunce0cOz5tG92cN77mgR/REvGpm1QUK6WrdrcTBQgjG99gDdmGDZ08UFvHkzfvls8/oVPT9Pl8P5p+eHR6f+2193X38Ed47T1VoXDR3PKQoMKRKwI1SwHoHimsBewBEoUHFC7hpOX61z7F25lrv6Msu1Bc8qVxZjutU59hP39FZXy+5N6hfK3entA75F1SjOPMpoEInIUiIECRZHx4+fPP3a1z96/uWzzerakuudY5GtDVaJ/yZ/qK8tndPYqfceHVo2pVBu4mie8xgjEyDicrmaz+ci1rE2O62t4Ug5aNua/73HTdUgc44iZgUOEc1XigC72BBlnNuYRcaBTKBRxW9zJraibcLnpebC31zzwsB2BOJW0bH4AlQy264evqUcWidlsXuu7qkcqe9TgWXa25p6f0vg2HtK5oeTn+DkUtWkigVh0kLwBicxHbTVyFa6N4nDiBauCpIsHTWpWHc7IsrIKwVB20bugAlTIbWJJpFuNMyc6hkTRSQHtCrV5llpKV6l3PPXyCc7VHaJAyey1qpCbMJq5Q+E6BjNd6ZKas3o1MRJAjw6PO7HYT6fB0mr1frw8DClFOM2BaGeEJiEhLKqVAhoOuVKhTlZAcA8fHUxdrb8xoGcCq36b/Vk7Jyi3aM+/cg+AxFTcew0OtzRlSe7sOM2qH+q6mw2G8fRfJshBKsitsLd6fehsLakqpKSJEVQsoY2igicQsMOAMaUAKDrWiIaxs00NoYZcoamZWD55gC5PkvRYMF14pXZpkOb5luWQlVlEp6w95nZEcc4Frermh4fA6aoMSWuq2HJFETWaXp6VSGUPTBlv+oht6KnPRajJlGSOnYjhEi47MOb6+UhE6JibtKYFDQFULVqr8xQiKj1XhFUooRI5CQnrZCFULIdQNnaM86eRFDVQo2QM2yctenRmMZh4xuVpLAeYb1BAFY2+js/OejXGyI6Pj49ODiQpETQtv7g7ruqKglCCJvNsFkvh02/HoNb9k5AUpSLNUFC8GFiEF332nLwnaCLETYIkL5Is0f3zn73e/z+I7h/Jgez1LnoCU/vR+/8wcItDkHJmoIqwjwwXPXy6kKkd6QAEK6Wm1cX+Oq5XK7Gz1+Mnz6HNxe8WbFEAjkFRzyTd0/Tf/2/HH7vu5sNHG4onq/dO3MaYrhYtUhM5MjRGGkIiXDTQiCPQkklUSJwmm3dHbnyF71ygA8LGe++nym/6iWVkI3ktxV7CDfUlJtP2buJPfFWnWOPC0lx4VHBysv4T5RRwGez2YMHDx4/fffd99/7yY9/6BD6vkc0h+VOC7HKGabXHsvCUkgS+uCcu3PnjvN4fX0dxpDrCaKq5M7MRBTCKCJmBBonnPBDItp2rqhEJ2WaqopaWYS5GCoIEIqIYU4CgOYO6VvPBBGoAjNz453xyaIZTFaVVKXqB9Uqy2xcyYy8ytAsGhFLczMCwrJNUHRFi6CRlqeUyr897W26pHVhp2pEZYP25p7b/hbtYeLJrT/b0zZgV1hsywlFUkozP7dguohMEeqm5GFiAkuOSIxxdTVud0SVHKNuR2ss1bIhHRaNDiZn8mbOYx0iERmNZp2uRkDMK0CKhv0FaE9jQFBAUTuzFmSa5nDsbb9zLZATiQYaJqAxCSJZy12sHvCqj4tGSV988cXsYPHo0SPn3GazyaQyUQy39G2TqltSfAlpd7/rHiOpiuQOgprBA3UCMY4TiEPcdY1Md3fKIHCitO5hW9X7IIA1dHUFviYOI1qWK2RShjIX1W3suBKfqczjGGxCFv4vBwZU4x4lweRQVbmbMk48ec+IoIKWJ08KCklEUjRLBXkbDwFUSOaEUbDsdIYMxzSF79khYsDsxQG0aVpOfF4Q695oC5MkKVigoXgdmYhVt82fACCXWYEZv0XH3J1mXbBJfhYahae0n4SbOQLl6q8EmghWMb6+vn53sUCQYMoBIFrNl0ZVbdqFIBdVxQ4bGxssSvn23DEzMpqDmogYGQAgCSEpQ27sjAhJvCh4iWMgH9VUxBgxShR1SIwUYWh955DOv/xs2c2aptkgxxj9C+0ODn3XKfn5YXfy4A6QDsPgZr/RPLof+vHq51/0n74Ilxdh6KH4ONIXX46em+Mjv+gSwuj5oL2v7pQWd+DeO3D/NHUuznx7MB/Shh1BSuniQjejH4FCGvo1LDeQIsXYbFb9+UX/+jy9eDO8urx49tz1Y7ce5wpt29LBDE7OYN5+3o3vfOM3D959uP7gEV7HszXh4lDenQ8uzLr5bLYAcmm9dusRAaBrWaF3FIlQaaSkAA1kYtoj8no6br7/FRoJaU551q0DAqpLA3b1j6/AEn3bA4wxZnfixHtaYUW+YqjTxxG6lCLi1mOaPe4JDg6OHj16/OFH33j18vnLZ88QUVJg5+AGj9rjYNPzYu7n2oTBfMmz2YwdrNfrXnrJPumcwPHo0aOu616/fjWGXsFSx7b+jOpwnSox9lCuxkQeCZsPCQBAtzgaoqNzOZmdyoaKCOSURgIApeyRTWkLez2dnQpaiNw5V+t166eoVMtJKzml2lK7SAT7iavpaBV8aMJ5JteOBlxlK+4GU+pC1aQZ3HWfb+dCCLS1PFPZMncbFH0WGJr9MLahtvibzcZwGW4eB8ScCmueKGPXFrQKMQJA2zRJFYnm8zkBGsC3DSNZpqpzrhqXU2VKd7Nb94hvR5DnNuuUMZ0Y8oscJAOPZKUW9n1nFRa6kzRaCQ4RE5iTgBGRXO5rhY5rnT0pCCiIWm8wYnzx6uXf+lt/SxD+0T/6Rzg5nFOhbjY9M6NYrRrWR6Pdk/bTBu2HlpJdzgMgIUINrtuBmKjDu0uUg0G7GszeRRNQL53shSuemLZtu64bhiGNQSTDrlUUl6zYlqvuS30oUS69sf52zrlxjH3fN42DXYZbf27cqvrB7P3G+RCCQU2oaggBokAS2ylEpJoAaydtL9kzs+ysF9Ul1hLtdtY02PaOcz/HlJJDqj7tTCEWKczqjNrmmhIcQgDYeghoeoZ3/UAw4QVVH62bvpcZPVXgCBkgEhEKg4OE/ToM6I+RCUQQlYlQWSFpwnpDy0yKQ47reeZQaA1LaQ+ai5IoxqiWBp+5oQAANk5SgvyneiJmT0SjRCQCR9poTEmTDAAAcpxk7C95MccQfOMh4mZYzmcHXQPD6mJ5JYrecP8MfLr//l85+zf/RvzavaNB71xsNi9f8xcv4X/+2pbF3TtLL8/Xr964Vy6AuK4DeiNv/PIXfxL+HwzsfNO4tgmO3dkZz2bQuBATJaWmA0C/WcMmXI2rvl/zuqerlQ4hoI6kT/1RciCn83i8uDo5gHt3ugePurOT06+dwaN7kR2f9+2XK0gEjOlgcRg9sBsbTIQQGmAGxtigi5QaBmIXqecoCChZRcDJ1u9J7puC/OYJLUJOEbfhlZz8XpxzCAATXFHSXFU7vQPiNp/j1qs++6v9MFhCm7d+TRHiKL5h59isBeMtIY5N6+7fv3/x5Mn9B4+++PTT2bwNwzgVwPUF3ZBSUBZw6s+2kEqM8cWLF4oJAbquA4AQgiggkoiGEAwAqRoDWgCFp4xx4uEonHmbh54NEpy4P9QSIzT7GZAQEiRQX7VJUaVcgqEq4zgCaN/3nhxM0jwR0dSXlEbjJMweS7cXVZVUvKGwJ/gKdgjSlKugFK0Id/g5TkzZW9e2SpCpFLY/uTQGnyYI3qJz1D26SRVT0WanIHfZ3VqY9mK1WkmB92AFkC2Ce245ixY+BCNmialpGnAODN07RkRoZ52Grc+sHj0AcH0KYIBFAKC5osxhDiq7UnyIgBmdgiiGQKZVaEJQBjRrUgHUs2lAZvozQEQjCFLV9PbePIioRAqAJBnnw3FWZZAsvSirwCgM6JwxEf30059+73u/9e/8b/9X/+Af/sN/9p/9/qZPMQCRU401LcNEiIp4pJHUlCREssw+EQCilMbSrVTatrEfNq1zvmuaZrlcmkgQVWQzKKUKtumxydBnZf9SSsAETKIAUkCI69wJrefL9CZZSScUhBhjk9JyuQSAIAkAPJBOIFKqoVYKepPqDhsVSeZpZKaaEus9m7dTVc0DoZrDE45JVTH/UBGBPQPiKoQ4BlVt2BFRsPABMaSildZZkxWl1M7RGnMaeeYFdeRqlJ2R38BkvQBIVGAhosa3oJERx3EE5RBC182CioI25IwgiTDGEGOwmyfIpVJoyfaG+VGcL2oNp0tzebUKL1WqwVTRYRiGYeCkUsI+KgKIhEgMPXnWONsMaUYjkuvpW4+fbuRqjsyeQFISkRhEFJHZQQrRgY6bnomSJPYujD21rUuohDGkqGBZfoSO2Y3rNWVaCoToACNADCFtxqZpnPdWyZZAlBC9b8KB6W0pJWYlElDVJFFFycekiDj061nbNiAY15swtm07c5TSiBIcthLisByaH/6J/h9fzt59Z3PvND59OHvnibz7FOAfGBXd/zv/Nnz+cvzhz/o//dH8sy8XQzh/9bH0EjAN0icVxsaBZ6URGgFEJO89JnRJD9v58eJQ5t2M5KBBRelPWnzw6PA33tfHd/Tg6QjQHh/w8eG6EZr79mTB3om2Kanrozs5ghOQFBPCXH3vpAVsFMfr3jsHjVMFp251cBzFjRrBkQceBUZRr0kmmqVJShNCU5m6x7L3X1e2CVBlVQLgSaQv4X4j4io/TKlU1YSgOmlHtOsU2SorJREyn1/afoNMtxEAgERQfasZINFiNhp9Q6oSowAhMjGDqnon/Wp5dHbn7MG73/n+7765uPzlj39wsGhDTERujOJ9M4wr5xgFYhTv2iL0dtz4FSjCuCsCtq4dhoFbwOIQFRFE9sSucRdvzi/5koiQGwGglpOqAI6aAICY0Fx9AKggcdJmpZTV2+4MmLKeh7n21VbMoQdBSImhHHlzCTgPWTkAANCoqtpwO7EijD8LQERCUieii8Xh/fv3f/KTnxhbBgDvXPYIZ4BWAsCoStQkSQDILlcCpxBSSgqMlD0iuT4GLdaTaY+ItHSVQ+ApbNJU4avGVSYDEfMQpNJay+JTli5juRdN01ifeu9crlVmlkkIKcsFzKXdKetxKAirYWPi1bdN3nfRaTqIlnJMk1YMub7ZM0MSpwxKMGKHnapevz4PzAbGMvablpokoWmcqjiX3Y5Y2bTdHZhyJ9ZJCYaqYukzVcSJ4ER5z+4HgL1Aw54SPdXxzGzQYpG01idit/jFkjaM1iUkILAGbJv1+v333//f/x/+3R/++Mf/3t/9u7bEjn3fB4TEznnvg6Q+jDZgy+ihTJdVbAsCeu+Xy2XTNES4XC67rlssFmPojZhsjxFRUtLihc+zk62WkL3+u34g+1dEQBVgR8/Vif6hE6cIEYUxNM6RwrjpQwht23q6vS7c/r1ZHQMTS6WMByeKyM2QisIEDUkybqZlEiQs7qV8bBSS8YjMj1Bk6+hDsnQNIwkyvFsDUZJsGcLk3+wFLaQM2RRKkkQZoB/6GONisWDXaEwak9vB74KdQ1VSbcpcMFtBVlZDRCWpIkG9g9ZJVZpD5ZLaLHZGVYGREaJ67lVjP9xT+Nbp6aHnY5gPMCZVNjefb6vhGFNKIUVJIcRuMRcQVR36vuWWkdmOkYLGFDVKoGrKmGkGRZtsfIakQ0Q255FBPpqIMnR5AFAlFUIcVxuNUZDAM4iOMcYYVUE0qqJDUquRcaAKmqR/9SJ89qz9gz9lcXh4ODy+J+/e0f/JI/x3FQC6//Yfp3/wN5q/9lcOAfVy1V9eHrx4Gc4vmy+ez7987t9cNde9Xq9iPwz9UsaA/eAjkGiCtBnW62Ez3xy7g5mnBWA7O75D3/g2/O63X71zevcI25MDaP3o4Ii9DgnXI1E7jJfIKA2r+cACcUg4Rp5zQnHI2HqzYVHRYHkM45/z9plIud2HBxPm/pe+3nYHY19UPR7VBQI5V9q+xtsEj93bZoN+cr/ynGlRLuzy1TqkKcrZ3gsDV3zw8N756+df+9rXXj3/PGzWzD7G6IiGYeMbH4fRECTFQq4IFTu1MijzlZoIHMfx4OAAEQlZt1h8CJpxF4go6wGa/Tww0cZACErOFlruoOVhTGSkhUMpKWL2LcE01QMBct27laIITNwk0/V527LYw7uu6/v+5cuXq9VqHMcSfVYRQd6m39m4UJUIKgC1uUPM1mBiy1Y3ABIbs5ZiDVVl9ha3tUaRojt6ar2mrB5K9kYterCVt9fm37WaeS0w56o5h9fQECbEtHXtqyoSIm/L37F04dYblTVa0ulKOOLGwuainHxxTr6R2iJYCVHATRujAABaFEOkFifYXlYnc176aaqgSYtKQ5MDg5Nx4SRMWG0FmztAjoYSwGaz6boOEXOi7MQbQwV/zmSJMdn/3n//f3h0dPK3//bffvbsZYo4BnNHeyYKMW7XFIk4+xitjhFKJxFVVRDXeGZGhMViYWGU5XJ5eHgYY5SUJAEzI5A1pCNig2yHoinXqcFXOk5VdY+2bnovcdfJDwBWLWJhkakOAbtQH5hrunQ6nolMBZzkYxbv0XQ4WSLXCJe58mKMMo5i4FS0bXNEE7enqpp/DhFzXbuBLGaAHS7P3eZY3Jz1dk0AVHKoJYm0bds0LQCGMNYQyXRJdzhINkQJAO0WCiCS+2OiCNa4vqpi8TmJAuy4IlXZwn5osMcApICAGPvkmkQ0u+6/lfC7pwscB46KTAAqSVSRBVTQ8L+cb4jVAQ2bvuu6kAKhouh6syR06Bg57zURw6QtgnE7mOigGQfPtI2U+VRUIQUmdi4nfFjiaUuOhpEYWBqNKYx9jAKYJIQwJkZEVEcsQQgRFXW5CopuNqeWY7xc/fTz/k/6xWIB8N/K4/nf/N1w77j5xhP82gM+avHdJ7NvfcgHc2gZQCCNMG4ghvFNr9creX5Bz87pzZVeLIeLy3615hfnAWKA4Ic1fvyaPv4Z/Af/zwXp+dPH86d35dFJvH9I7zxxd+/IfAbdonUJWg+ti5IgJFQJmhBSA/MxhsAMniVopi/RyBwJEyioECDSPpHs0Vt9Z+8A3KTMm1Q6vZsVu92829trUvYfYX9vQ7rFW2wXS35Kfdz2QXtn3BxyN6ZQOQARhhAODg4ePHiw/vDDTz/5xS9+/JPWoTUWJxAGF4FSUiyeyB3RUPhM27bjOMYYHz58eH5+bngEph6L1tC5y5ZA6QZqSTAWCgcALK4bi5iY9DVhYs8y5UXr0xVArQJhi3kIAOpyeCkBUM4mNACgfUWzvp7qGXUxx3E0TLOrqytzdQMAM9c6zz3NtcqOfCohB08BxIoZ7P5UunAQeYDcmxoRLR2w8mHY5WOIOAwbk7nMaMqNrXBNCrYvM3PbtgY9ZVqgufNrcgzcIFob2Gh8Jtss+dOaO0wFbWGHUHc8JSUuUUaNBR/FVOqGaLPZhJSa1kmuvVABdSxAhGLOZgB0efJJRGvwiaCKn4rHXoe+d5gZDHvkltNONTUPALZJi8oAYqIMoWmas7MzRHz9+vU4jlSSZQyxFBFrda9zbnZ6+n/69//P//a/8787OTkCABFwrhlTQERmMnTY+eHBEMa+75OKYl0jBQCRjLnZtt1qs7J0h5cvX1qdy927d4no6uqqJlhowQ1LKdWiZ5hId8zePpxqIVM36ldrspU1iJS4EjMRxRitW6nB1N8UuvXmlMuJ44RHbD3C09gN1gqJae4OpCAJLUekJBMBQIyR1PJXtuVbCgCiW/V/a5UZlZvBnetRy/qwYMqGX/4v/8yxq4tsrMZSj4HYCnqHYTDCnR4kRATYYR92mBERgEQUIPeutFtbQLeqdM7od5dKM2PVOmw0xzYCqMIsReU2qD5E/31yTyTCuNaxAbaWACoiKAAClpsek3bklESB+nGIMUgKDbJ3bY5wxVj3jhTUO7Ik2FIKbvQfU1JVx4zsNElI0SE2TROjJFWEnMOVUnRISN61jTKh5ROEKAhIjhAZzWUVGTBGURhN65QYheAyLGO4IMCmwUNPhzOFnMUBy3/+Tzzw+PuNtJwYZ27B9+/Bu4/jk3v93WM5W3QnR81Bxwf3+ayB3+yg8+Aggc5UW5HmOujrN+nly3T+cnj9anjxavbianY9+Cscv3iBb17yz93mT386/+h9/vr7w0HbHpzA8TzMHKh6IWDvnAsNwUWPoYf5DK3/ERIQK7voOBLEjA4IGZpScUpUezIGbrsQdyzLCWHsGOhb8YCw932zi6rGM5XWN48tTpyd+fBgvgkUh6ROalimXPXmBG6dFNZqghRAMY3h7Ozs6t6DD7/20WeffRb70TmWFNrGhzE0zm8Ga2+Zqh9hunpSQDYPDg5OTk5E5OLiommazbhRzYo+K9cCrBw6sAXMyv1WyJGZKUqqKgBcEhJxd0ZSkK+Nz2bhkvcASwO5VPiwtZ64fVmm21E/RcS+72ez2Ww2G4bBkvTzbhLp1sgqN4EkpbxDVVFzk3BETClgbqSKE6YCO0xbdzAXdFdxtNfmn9DSNsv4FSKGEKvY1RIfDCGsVivDurRvViHyFcJiCjdQx2NYVsUPt+MawTLf6UeVFVchDwAqqCk5otZzt5gvl0uBXK1WAvlVOpYnZ3njCq4L5JABEgJIRcdySIkxWk5/6YWIJekaEGtE5m0nfGcyCKAwjqOUQlZ7StM0WKoGIPtdEBQI9NnzFwcHR4vF8WazSSlsNpvF4mCz2agwES0Wi9l8Hq6j+UuIqGvb0A8GSm8qbUppDMPR0dFms9lsNh988MEXX3zBzH3fb/1Lxe4nxyJpHMfG+apwTOeiJXJR90YndLfPbiYF3HWJtJTj2iLUo25kVCmv3r9oAFMcDsvJ2HqV6lXvnx0BN8YTQ6xKSQZeK/ffp9ddlXnqelVVoi0dI6IB0KgquW2ieKU3xH2TtK6Jc67ve9MLu66rp0KLg6dg2+T1SWU8ZhOYY9MS6G6lQ5oCruxQZQIAQTR0DSk6R0duTInC+L6bfUQzvr6AxqF3aVxZ+xVnDRoLCKmmwI4xufnBQjU1TTv2apFy035sOzwxgqZkzVYYmB0xldZ3ImK98RQgiagmRU2EgjmmPgX1MYkVJCGzmVvsHfMCOhWRhjCEIGFUiRJTTDH76qJ6RD8m6FcAEB0u0/jabW97fjA6nmEKbgwukeIbef6p/PM/QvAMnXcttU68w/lC5p3ePUwPTuLZcTo5aO8cN8dHr54uzk5O3W9/yx1+r+kaIIbrAa42DtZ4eUlX1/jmCi5X0M3guJWG9WiBs5Y8RdDUKPcRrja8GeD1JXTsfQPcpCRACo2HrhXihKoIJMZ/wCjh1rDF23iRbsE7tu/c+s23XX8u2Mbebeu5unkSt6/3KRMEgcSE7a57pkRAtr+sA4OMhZVSWMznd+7c+eDDr//i41/+/Mc/JREisEI9U8IFjSlZU5MdHIgQwtXVlXOu67rPP//cePV6vXZNo5BUCXMOB27lcVG2uLguwBwb23FmQHAtPEEmmfgWjFZGQCwGuS2XKihPcA10K0S2q7nHXafLNV1zc9vkqP0kYcKzq64IAKCMFoRo8wGgSev5ykkKC926tM14Lhw4AkD29BT2DIUX2Z/37t23isvLy8saPRGRtp1VNm6jSimZklSF1LT9Sr15vfJuMpnqphPjDRVQtyD3aeLzVc11HuVu9Z4GsFwLPK26FMd+6Lru6OTQgD02m7VxNqdomqd5pbLqhRZxIbIkPlU1FGpVpQwSDZYCalYZAljAYis/bgjRqdCV6YCBJBMKIeIwjC9fvjQlo21bq7wiyh22BMQwZLzzKaXlatPNZsT85vzce59ETk9PXzx/fnJyMo4jEvV9vxmHzdAT5JSxvh88kSmDm83Ge//h1z/45kff+Ef/8e8/efrob/7Nv/n3/t7fM9m2Wq1ms1kFIrPxe+dA9rWEqSxX3Xo17bTknNvifZrKaRP+N8nCFIuu64jIiouMevrejA+tN5+k004LTmGSeUZF3ZapMsvM1vexhhgACgL55NinMagqiiZCSyi2VAxAJATJuv+Wjm3/VUEk2oksJKGorLsgttNjEDOuV13JbdXrfD53zlU11CrutnpO4Tj5SmI8B8Uq04SIrDSJsaC21SMk2QRGgLTL2TFn6GX9ETS/o8m5lE5C/PbdowfiLl+/8Ihr2ciQyFyBgKqSRABElCTpGFMMcda0QZSRyLEoCoIgEmYPFiEyEcQ0DGMi8sQy0SwZsHE+hDGFoHkOCKIhhIY9mAtNspHgrHRW1DlOVhyIZNkiKUQkZGIkUongksZkjd1jS8HiNXPHCiCC/eDJQclSlzevB40OiLnF1q+cU5cQwJFHHgPpqCkF4TSTVwm/ULL25L5LBws4XMw6Nzy8k57eD3dP8c6pe/CgefqweXB3wAN/986oQv3gA8ByNYbRzZo3mhYQmsSOCQjiZuM+fk5fnK9a8XePIQL0AWISzwBJPUQAIM4xQ1G16nu8RczA7vUVKsXNj27qxGJW920wgDefqFpAlidujOpgs2/yrSrS7kWlV+u+GbCrnFSmZMfZs0spAwudnp49ePTko29++9WL88uL57MWh37wTRclkCcgqQ5Lw4XCEql8+vTpMAzr9dp7v1qtqhUkIgBIoJqtHSyMRaeHXatXA7WEoFlVgRQRAIXNgQ65B6TNghRj5WfmYge1dpMgmiW/EqIBn4PmlI63ObH2BbDxQ/MiY0l9pVw/CAKFi6OaNCW06IMlvEs261VVtk0Bd59IURJj7kENAIAyXZPKmeu/X375pdlX5su3KI+qxrjTr6MMcqfpWtGNtjXGN+erlFOejSAdZGZax5CBzAs1aUpp0jF0MkfjqAoomHvXI0DGtVqv+xgjJCFikKRJnJYgEzLhtOq3iBwpKluMUZNEE5BqoXEByK1YFovFOI5hHCEJTDKb9qY62YT6JmbqExRCc2qZuMUtmMTo2YtIzkg1NxGhEs6aru8H57z3DTNfXV0dHx/HODJzElkul1GFmTtvuagSCWNMImPTNIeHh8Tw8uXLq4tLgyX5/d///WfPnllZStu26/Xakhjatq1WtSlDWxZTFKxMN7shkqxjZM0sK+ZQQwDZs3OLBrparebz+dHRkYgsl0vz+JmeJCWJVUsEkTlXnYjcUqhd+A7WgilEnNRZ5XfM2jbMlkpSlR4SQJBEmpNnNTcrmWpaVO5t56Fi9ml2kaIg1mDkjp+5npaM3TJZkBjjfD7vum4cxxiDSLI0t6pg7emyAAAgqoSGyANsfxIRIFIN6Klmz6Fo5f47eAbAsEUky1FCRLxGWmj/BPSjwwNeBhSny3GZhhk6gWRNflSTSDSe0jazOCbPDh2xIijMFwcMCEDDOCKiiqzXS02iAikJq0W1JZZuiMzsiFISEAEVQATHiKoIMQpbwRiRGNY+KJCmGJlZJakkq57VDEVPSRWYCVvVhlBMe1bViIoxuqgwjg5RFdS33rcV3VyaDilFGTbxKqzlAE4AkBgj6CYNiNi4dtbOl9fQqG8EW0VKGodRlsPVs9dzPdr86HVPP2Vm5/3mpLv86G7zzaf3vvVb8N5DeHC6bhqP5LlBIE/NKfW0iXBxCRfL8fyif/5GX1w264G+9y3XzSClcRwZ2DUYAWKGXIPcrA92LLOv1humFxrOzcQ3uf1oklpRDxeWiB4QQjKUniqcb7/yUVCAnP9RzIKUowZFtBfCrkiU9kO7ycQrvJ1jHvZkvro9XDWObjKs7bqT07Ovf/SNZ58//+EPr1K8xtooBBUoojR15eqotPibLy8vLdchpdT3vfdeoyKZogF2xKzB+R4n2S7dVrUXzPWtYHHYbOgb4yzRCppgCRbnCQAAA01rOxVzC2a3lS87zKGyGpy4V1U1hMClmzQUJYCZdVKjgyU6a/RgLhVbcyIymEHIQEVVLldPre1Ydi0TsUgSEYRbQniqKgIhGCK4R8RxjLHEXisHro8x6Wzh5uqyrbpIzWSYPsXaN1W8uL21IsO5wG0WPRKB1kxBmjjIJ/o0bMNw7JpxHPvxEgC8Z0Z0lp5cBSAg1sAKE0VQETHI0ulJqGkpMMl0BYCDAwtkSJJQhcDeUm4FDECFmlYgUUDrnSkaS/XEer1OKXnvzc+hCrbizrkEOo4DIjZdm0Iy7a9pGpHkve83KxFhx0TUNM2MGRFDCClGT6yE3nsAZ3oMkorIRtdE8OMf/xgRzathqaOm9Fg6BSJaqlRScc5BWfHpaRSR4vfbetgMk6t8bX9BiHc8E5U/dm17fXW1Xq0sE4Xa1jHvAFsVxcKmSbRFY5tuVj1UdbQ2l7adxRgBgkhpPlJLRyFDyCOW4iOiBKpRoyoDg5V4iCITg9MSktuOClh1IELI5p+AZpdLtIRKNa2RwKq7ATV3SRUQFUTGnBesSc5fv2HmJLFpGgQhVMcYk9SjNVU7psKgODaTiLBnNcur9KaB4mSyhGVbs7pDCBaqANVkgRXb2b7h+QjHoKfk1uMauW3DOOga2aUxhjiiJEBRUmYCgjH0w6o/mB3EjUSREMLZ4TExs+ustNxCsMipcb71PhTInTiOwzBYVIuZN/3YNI1vG2DCEDLIj2qEQI6lUAIxppQgCTgniCmlZu4YYbC8Nrb0aUNVF3PiiEiKqheXSphUVimiQAstRoS0Daks5C4oR8L5yaxbHFz72DLNXeN9G5tGF8d4925zcnLgWgSQzaa/vJDLa95sfD+2Q7yka2p86vt4vaR+mL9Ztf/0ufzzH62+/7H/za+1v/dXmqeP+oRs2KGXb/jlq361Sp+/xl88b55dHargu/fgW+/Cg7twNIsq683meHYIXecc9ymo6bc5NAumANdDOD10N7WNKS/WG//aT3jy/empv3mZRNSJgQ4ThlD65kAlwr2RVJWiMA+AG0hidt+9QEvVOaYHoU7WiIqZa+L57GBx98H9d56+98knP3r9+s286/p1ItfEYd34bageJ8ERVXn+/HmtrrfKC/O5orkXKMsTtSxAVfYNTlpUgiUkKpR0X4vc5HGKREZnqlQqfgXLJJPctD43VIJsWSOUtFMTRcZQFHZCS3VNpv9O37fdtNQNETEs5qIhEQKWYEfeFlGpLoeUbOQCoikpuZolSoSOsEZsk1WvICIzEaGBlfGN9ih2WUlRmrT1tiZ5hrRGpU9v/X5TqjtxW0iC09d7lJbZ+0SKwS5h73nPmBzvJHwUkrPaRoP+VsugQGsY65wjaoZxQ+RizBElFyRRwUKoPBqSgKgDRRP/qIGQHAkJBVWJgkiMiJxUSJGIX7x4kakKgYic5kJdclk1SaAmXAVLiLXM3CjGE5nVPpvNVNUAQwHAGqxUfSKE8WCxWIc1M8V1z9byG2AY+rxk5AitCRnRFrAc2XlFZIiplD6rIFm5N2EYZTE/srEIiCm8avmqTWOnq23b47NTEf3i2Zdd02iJdOSMFkJ0zKhEWGJTEKOAqGPGmKi0E+OiZJhPtfa2gVL+ZLFSQ15p2lZVyWHSqKigNNVwa8uYGMft9k2oKiRNSTkJkhI5om3wr0SLDGMuAigRRlQmRgVSsOMRVWKKJs4AIKogTODxMxoM5JoOQAEgSAqYRMEwMNiplqpuTKIxpeTQEToATSLOOQ9tiEFRiUhJlIg8I+LYR2JOAMgYAZib7OOiZDmgdSQmm4l81bE41yVZRoSqQoqqkgvGmElV+/W2YwioueGNXQbk4sY1VA1iT8yCKcLI3cVqdRyvka8JsIsceaCF8+hiSiqRFFSTSmrQjZquL1+5tgkETdO+fvX8yM8Z2fbdOdeADjH1Ity07GaHh4fkMEpSxKRxTFER4roP/bAcNmG9ghgbdq1jBAgYUHTmGhVRApx3idHN2tm1DAcuEMA4IqBoZOfmwMGDjiFtNhhTAt2kNIBo08jJER3O3MnB4Wy2OD5O2HSLI/YN/J1s49z/X/5P+ewAjmZpRjBzp7NZ6pzM2DnukC0eFTSFYWQFVpwTAzv1bkDsEU7WV5QQ1kO8XA3nb9x6Pdv0q5cv4pvRjw7+6Y8S/wAk9UFpNcAqxKtlu4449vroJHzv6fDOvebhPbdYpNmxWw50fn44d3jcAgYgD4KBklMGpIiSEAmA1Pjv7VGVKRe2o5pZbXEK7/8kl3JUPgsxR4axYOpiBtnMMZM9r1u+D06Cqlp8EFC9ejsBWcXCJqunYXsryyGtUfY6zYn9UxUaRLRGEJqTVFRS9Ij3Tk/f/+jDl+ff+8f/yaukRE1Ajo5aQSYuCo/S1uOICoDOOYvLmHmTUSnNFi7GafFcW/b1TpcQQFRAwjIzNXhfB6KqqEw6ceICQBQJMThi28vqIsrjKxyPAUAFkri8Ark+bqpebC0xU4uYgFABRoNL0MREnlmTJMuBcAQaMZe8WKTYDDCOFaWiejgYGRE0oWV9iYgMUNNFATINKUjKMMhIXkp+JtVcvcJIEQl5C7ZGpX6Cme/evXtxcTGOY9M0q+tl13VZH8MtYVva4uHhoRWtDMNg7+SdTAqgiOAAzYumhMgGXFxqcGAnIoNYFS+c6LGISCmCKrZtO5vNLKdHctG+mupWEnjAMWCFhDR1Bauvj7DuKyRr8aIOWeseEnIOu1NIYTqEGmiwBRKRKMkheu8RYbcCcWt5N00DxVVQBoqq6r23JiDmJrq8uhIRg+DsS+CtHjMtjmiYsBXc5iIRbFkAquS4xiQBZUcRttADIlrO8Gq1QqS2bWmCymKPyOmcmhC4FpebBWl6DOaeZ1uUEYPhmyYS14mYJmFOi6wvsz1oa8RMf7LlCbuWTU4q1GQ/rIjdVjtuX04ppRTLsTEz4hZcvEr0ZtmUP5PxJbtEc5nSlJvD7p9SCthNKaw7VWpoUew70bRoIUNf1pyaYFA5ltJVVxJL4YlI9dDmo2F2SAiWoQRY0CxSQlWFSRP26cLSpGn1dORRpPNOAy5Xq3mM16tlEhCC2QhEycpcFVwYxzgOIYSPhzdp6FVE1jik2LYzHOWq6U/9bBgGg6v3bTebzWbd3LU+Boipd+hYDGHQN/OF9/76zKeUGMk5QtUUxvV6vVqtaBzHfghJ+s2GlRYjYEzxev2cdTEsDmcdiErjCdpxTI3ym2GZkggSLY7o6JDP7s7unNLBYvb19/jhqX904uZdYlbvMIIbAf7Of2jTj//V74koDyP3IySBsEqvluHyKlxe64tL+fIVv1p2gwyX6wggjtK8dWeH/uHd7uG97vgovfNemrd6ck8fvYcsOva0GeevL/gP/2n44afhx5+5TeCuSQ7dWqCX9Z0Ff/N9/s678s0ndHgAicC7pYd2tYQ+BknALZmTTMHtZ1X+xa7KIvYIdSrgp5Tw/+NVDzvApEpl9zsmj7bsq745GY9OuP7egPdGW2XtdI7Gee4/fPjgwcOvf/TNTz7+qSrGELqmG0IO8FhoXnaSq3b0p/p6z9TZsqQby2bjVtCCUG4yR62qSyd3qPcxizlnwpUFUlUobu+bOzhNBrd7TP+EXD9YBm9luQAWNbBPt0jhoHsLWGFkNWMNlBA2WsHKLanKdQx5OwTE2pBhtrehyi/7vv1Pt5tbo9shhIuLC4MEBQByLKA3n2i/CiFUfjsdRkndRUXIGF+WGwGThuq33XO66fWGVOpianFGBUefEirlwkDckS5ioW8mE71UspSpKPqiO14gVa3F09t3VK3FqvMZQrvKg6iSdiczdbjVNaIJbJzpIqZzzOfzzWYzn88tY8NcSXvzr7eyf4kItu1VqaoU9ottxLPIqOnhqdh5NpJxDKYX27vm5rKFLlphWTeDd0GUGBWxYdf3PRQNoMZoRGTvbExHgtOEDAXRuCcIcXvdQhwAoKW807ap3nYcx6nWbHJaRNBxxrmigrFT+vpUOqFcfJtSSqW53VsvRCxu5u2ATfECAPNeppQkJABAMkMRVQWS+QNLZColo58K/AU3GGvdbtzNdQeAUstiAWZMybyjqYRddjzP9sVsqRbmYqQbRRKEfkxrJWwbIhjHEFJMQ2+BI0sWKVaahBBMx0shrSX28doBOfSNIBF1BwvvvfeN9z6qjOt163y/GgiQACQmELXOLLo4FhH2rmkcEDKj79o7d08P21kSEdBhCBITBdhcXo/rDZ80qgTIfYp3F8cd0GUK6/un947OwqLRx3f0yT28czo7PXOzI0gEm02SxNcRvrzQiwt/ML9eLWW9NYn8/+X3ZbmKy42sN3G9wYvLdjUsLjdxtVwP6z4FStorLBVBFMRwL9XKqwHgpJnDYQd3T/yTO9g4GAZYD3y5hquNcBrn1M07pzEirL92Qu/ePfjdfxWenm0OD/yItEoRxCU+2ARZX0NIRAhdK21DSJhhYwFuo4evJMutkK5kcGue3V/onn/ud7TkDeR3YJJHOtUblLCY8nAjqnJzpjefvqeCSEl1N05lKQt37509efp0vbl89uVnV5fnzEyAGqI6NokuKpQbg+z0joFdpYcm7RR2xjNhazuDQVKwzGLIrp/i3ofdaBSi9UnXbcoYQI2d3cRgt1EVpirFh76zaFz7v5VukWYjKWpKQhPjCifTrESi2VGEWnAvKcNggpRQRB2plPDE/vrYukF1lOxY4bRrKlfKNOvdEEWNH+4hBcDug0wwTemtSPP8ZVtXLc8A3unMOl3YvSMzfQrmhNZYU0b24t31J87+H0t+nLXqAIBUkY/yliOiAd2B+Q4RUTXFvFo7+w05dpBnYmvhvSfmGGOygr3dyaiqdcXlkqlQqaQKyPl83ve9ZVP2YYybuDg8MASkm1ddjq0IKbJnRzHaJcTp4ualIvTszaa36INhdEsMmPuwA9QAxKQ9cTneiggG/0JE3ntmHsdRS2wSwFqIVHdfLmYRUdM0suPEonGpNmTfEnRRGbdpzzsTsawnRNlGPgmJYggITIhJRIy5obmhwfALUDOyoQFetW0HRcmoots5SmC5ivkncItyX0N9mRCrV6NqbMMwhDAICiEhAkr2lCKi984Cz3WJlMl5GmMOY1UfsqiKiqIigQKkJABISGIO72wzMBGAhfdRALaJ3Hu0gTq1bAAALIOaEJyiU2x94xmPDg9dE4YUxqWqalSNgsjUNDODa7vvumEYgiQBXW3W/XpDgAezgwdn95jZip6siy+khKTPn78YhsERd13jmQkwhbjerOdv3kQdGZiZkwqSWhLxxezAe992nWtb13g3b/ioA4Bu2XvvtXHrMLSLQ1CM37i/+Nf/Cj36ehtHYAKJ8foar6/Cy1fL88t2lOHN1YJA+iG+eu1Hbb98GVc9wG/b+sj/9T+SfmRUT0AhxAM39iFFwVkze/qwu3usRwts2rPo4zCG1UqWK1oNer1JV31c9a2KXizD68vxx58qISNC24FIf7Qg3879nBdzuHPYfnDP/eYTeOf+8uDUzw+aATmILhpdYLq41l99SjCIIp+cQtuB8yoIqmaAazFjbvLKW87FjbruKRN4m+IyPWL7d9gl+LcpH5Y3M+m0UhwYW8tWbx1JLbhNsHP8bwwMK7XX+wNAyZXOX5ACY9u07eN3nl5dnz9+8vTy8pLJawIQzUGH4uxUyCCpepv75NZ/6+P3hlo+zQrD1ncidorTNvl88pOC6zxZ/9u4jd64AJIWOJb9b4qqMVhESQmMKYECIBMJQBLxSJbACoAitukAaqDEdsMJSAHuMBOwZ9trQ+KaeJsAgIFQwZI3c+0nFpVOsqo+pTGbkcX6a6C/YJMAANBtBlhVOOruaO3kUJM8kRSUC6hSeSLBDel6czfrjKZO66pwVAZrf9aGGjmJg0q5Ukop62oKiGqJ/qAas7xRUE7ZrQV7GpY93jlGhZCiBSOsny8zAxMTQNyOo2ZCSIH2wokmbpd3ru97Imrb9uDg4Hq9Mr8Nwy3EVN+Z6t1Ysnmnq3aTCqVkVttzxxC1aZioaVpbUIiAjlvvQwimP9plq7xNECmxA5tRGoP3/vDwkIgs/FZUoDyknBs1+UlZgdyeERHtC3XjseQE3TTL6gS3aLianTQiIqVsOkOvopg3BlDSBCacTCaXrjpY0rnzuIm89ykMUBmuPVPB9BgbyGRQArvnzf60HB0qGoYWW8rOtnVYmOC6IiKW5ixTyOHKRm8RFXYr03tUt0YFboORO0ICJ75dVUO5KKcnJmRtiA+7+fL1cz+MDWBDrj07cc6DUgghYzWCxjiC4Hx+wG1juqaKOCQAkQEMPo6cI3TsGsM2eHj33nq9TqBMHiD71Ydh6MLq6uqqX29EBCJohH419OvNZfrSAc64WXQHbTsTR9i21PiZUjPrlqugCq6PcTW6lvDPfnX1i3NZrduQmnHU9cYBMOJstULn51+8bmaLJBs5fwOvVs1q03R+ezTu8RiJEFtyHH3zcrM88Jv37y2++43umx/AvTt6OJduBtRSCm7oYTXgpsfVwOsEIQ1RW9c2CQAR2AGrMA4h0DjQZtAx9seNfviAPniEBx0EPcA5vLhMIsM7h6uwgp9+evjsjQ9Dv+zJe398CqhJxNzywpPjjPsbd5Mebl5Ttg43uCqUfIVf51a/zrOo6A31wp2X24/M6T0dIZsP8IYf923PwuLCqVyivhYRELl79+79h4/f//o3P//8y8166UQ73wQTrNb/BREBkBAVDJthb7mgrM90VEWs3KptZNMWcKt5WfdpS9SYzktUoaQm1J9ryVDZKmSlYnP6oMLKUrV26miNt2KxCUHUfJpbj3J+utT8mO2kDKldqeiKU/1me8muWQgABLudaXZcqiCQHcGaYayKGlF/nkPG+SdJNaTEk37j9fuwS8l12HWc0zmieX2LFN7+dneob2etW/eP3OhCuqd5OJRStFh2K6vSuYKg5LGa86kUE6qWei1SAlYyExukJELmRQFcLBbz+TzGeH51aT1BACFNsldSStvKCsRpsqd5jew7KmK1kYT4+PHjFy9efPniedu2dQ32lmO63LILIzP1sE3ptSzC9m6I6NuGkObdvGmavu+tj1rXtFaAajecKnFEXPSAHc3AtU2McblZI6IgkHdK1s9FDWpdCaOKqNgCO6jnZ2cjpyGAKZVXyNsbV9178xnmkCkiikYLNFApc6qjtXsKaMlgghBGzcVjZN0T1ut1328QEXhLmSg65RcAOsWkqutcWZ554UII3jflbGTvjr226lAi8t7Z9wEgBqntVKSA620nXE4U7tqgea1Q0DD/M0Xc0s5XVRlLT6liiaIlqScVjSLcOBejxM1mvezXQ9969uwYuHY9sNN7PofFyRFCiqu+IaakKcXXF6+aAfu+1yRt27btDInM2TOfzYCpYQZEASTnvPfzo0P2D+cinp0jGjb9crlcXS83m81j7uO6Hy6XstqEVa8Anhph6k8PMMVx0/tZF8U1AvzDz4c/++yIRUSoa6DruHVweATzzmsan5w5cjCqBFXoeujB+TFtz5S72Eg/gAh6j8yr3/l6+8692ZN78WAeEvnLhEEEN72s/bxpDud693AACajkmFwDHWvbSpAooo4sFdGF5DcpoaQGXdc45yCmtA4pxOsj5SPPITQvz90vP+dPnsHRAh6f+ZdLIcbjBbRe1dryatSSBbUtFX3LaZgQCeyy4+n7W3reFRh7V2X99U/EP6cl7NZgUJ1GSXaPyUTnoP0Hy0SG39Q23qYVVQZig6x97CDEpm0ePHj4+Om7T95578c/+OMRpWUKoioCYmAmZWq5knJ/EWB3PXeuiTi4+RPMBfZTSSjVH527IFlRC+QQzzRpFAB4AkOwfabq1Oukqobht7fdPBW6ZZyVb+ik0B8nHoLMByb6Z5WmUwZSTcDMZaoVp6pTBk65/A2mnAqqn2N3WEXi5M5Z5iqmLS5UZdcAOzKi3uPmQt3UP/Z3MG/j9pO9L9d/60JNtfP63BwAUkLOoiHLIcu3Y2JAJQWoSZSEgDBbzGOMMcakyZB2MhitYys41BL9tnzHuVvU55lwTmB4FTvTrsMyQ7BIwS32NiaJw+iZo8qvPv54vdl0vvHspqVB06sqXLeu5nTp6xfKGHZ2SACGYQRAETFYUiI3jtE6AVb/gX05xkjeF/rbEl+S4F0rIpvNxhwDNQtBRAzkw2pu630Qa8zFbrLNI5GSRlqHDTeO+oQ6kmqOlhLlhGRTMkVEQSj3hBOFBApkuTrVZTVxYppc997PZjMA6Ps+b5yo6RyqeoPfAMDO4YfC7KD4n6bZIdPFZGBVZc8ppdlsZpEX48UGwDqdrF0m7OumY/EAcW6onW9eSnWgtjyYcooyVCPQiUGiSMRu5lAwrGMEPDw+SiBDEIY0bsbrzTrKiAAtNPP5/OBwfnA0C9Q4bpJAGlMSCeMAoGk9uKZhDet+3feXSN7iTOSYhLquM/+WQ65XBG8JTJZNPF8cnt2555zDNEgIr1+/Xi+XYbXRzUhKOoSj13F2iqezE5rN1iHI0RwSNr0sZeNU2lWPqwGI01Uvp3OYz/D1Wo+P4GDh561fdDCE8Olz+OQ5/CLPXnjhnz6Ax2fwzn28d+oeHfmDQ4iSvny1ev26nfezwyPnfOwa1gj9iBJdjIzkmwaarl+vsetQxAOgaLpY0sVAmzDEXjWRd27eQteEeSN3DvjsuL1eNczws8/Df/ov4+ur2e98A771/otO7h/d0RDg9EA8QgqkDoCrY1h3ogm/7rXDZPH2j956vurvfj3/RyU2RGQAmfDlXZKG4oHbvvmXSOOYfrmeCNxWjKtK0MhHRyePHj3+6Jvfev3y+ZuXz1XVKYpiTr2e6G83j+rbliifrLSVPVulZNdhYD04EJQIYvaoTDkbECJLDlfkumLJdnk52rdb8DqVk7nZU24KxlM8AhFGVMkAwaoqVkZOlANJu+qpTiaIlbNMLpms+XTuOllP+yhVzlNWWaeN0yjX/1Q3tX3AzEmVANg7c66XlbSGmgXtsWaCTjaozgImJLT3Z/7alPZUMtTaWw7C1Ms+VUF0VyN3iCigte2vbRGqZtiwauxiziQ+PDw0CHBJCRATqEhMAq7WUWUkBkAEQb26usozJLTCEwVtGg8xOzmY2ZWNwxJKqHRTdaWGnYiEGAFgs9lYJqMFJm6uApTkmunyTemynr3620lmzTYf2OhylGG9Xg/rjaq2bcvsN5tN2+aQR82d3CJi5RTLLFBFowSMQaigmSFi9d8g4mw2q0Dm1TI26a4lTECUhY/lmULxduA2q3RHhapbnh0fKIhsedelfiNTT2nXcotmZnepXmpDzx2G4c2bN7UEP+aO0llXA+P4kxTRvX+lUKFOsjtrLImIEBhAXe33JphiTmi3XszOOVO7qmOjamkpJWZXNplqKMTsScviBKiVUBEAsnsJJuF/43e3BS8RIAEpwCDxar06bjzPuwP/4OG869rZq2fPX714GTY9iATUEaRlutsshqjrMcAmyJA2V5dt62aCm+tzEfFOU5IkQ1TQBDJqVJkNnYHfHLSL1jcMSIjzyIKwIVoSKCA3ntsGEZEPTp48OPzg60czn1LS6w1f9euX55L616xHbTNX5y6XzfxYWkcHzYF7CqiqIcVNGNcSNn5YehI/ewCP72xAHbdy7xA/eqThm4efnsP/+0ub/vi3/o3Z3TtwuNh4St4trjfjs0sYhmbeNSeLmGKKPafRNaySNAkmIRFJEAZGum6W18AsY8+AMMbhxQVdrJtB4cEZHs74mIEUhhWHFboETpqfX45/9pP+z37uYpL3HvRHs252fP9gHrv1sL7WloKMEMS7loBIGSdRsF//qvJyyhn2vjA9EVN14aaY+TWfuE9Udi4AYDqY8lgroMwxFN3/4VQQTgXJrc+tXo3pr2pCwN17D9557/0vPvv0+uINgHhiEUnR4q95BaR4BfYWYSLgdxaTDLDu7X4j60lrR86cmjUnr0qEXd62cwc05/dE7tTnYvY97/AZLR7iuuxagcyJTbGwHgvmN2W03Ly8YtvMYlUAAiADHZ2qODDRSKZXZdp5cfbyWAv8pt6gkHqpKiiklJCpaZqxGF3TR09XZk+Z2LtiLe7b3ZHpC7zVfryxEVWAwu4J2jtc9m/OLSA2gLZsA5qWmaQ09cbcgI+Uhs06xiAAQGgNvlXQ0idFLMEYEuROK+zYeZ/xHpQspYUUdOKqtTRBKEdiTJFKLdDWT646psDMs9ms7/vVatm27Ww+H2LQGC3dGoq/3Vw34xgQ0cI13nvzynjvnbNTt7VcMXtWnKpadxUAqP17UDPMPjHP205EQhi7xhNTLQGarriqAChzyfTMXjRgtAAKFMMFEElEvWuX12tmVgVJMKbYOOfQJRB2nFKKKg3nPGRGcs5b4sU29CCAhIoTdQryBBFRMfcCgMywcvVQDSFvO9AqiygzgoAVqti+ZOxbxTAEVSViyfA1XGCpMoCKAW0iIiBQrJ11EEATZOIynDGEHHiq1OnQiYpEQRTOnR0AUQmk9Tz2602fiUdCdIhIDgCsz4hloAAgEQOBocWTqoSgCMxEjiCaP6kANRfUEyz8gU0Dk6xkRZ/QTI2sVQspeKQRhhlAIN6Qc0hR9WJYn3l/sbmYHR58eHYKSTabdRwDqMYYL66vVLXvN6v1dUqBCK7XsQ8bgJSAD9rTFIcW2DkvrXuzXs00nM5O0Ps3y1fDeHGgTRhlmC+Ww3rWtHPfMboY07jseeka9OFg+NWfftHOF6cPHx6cnfUx9J2efv9DCgKDrp5dCM+ax6fD8mp98bJjnAnArFk/WLg7R/yGMbVLiUerAM9X/PCeP2x4E9IY+qBjwPbkSfq/3ef/xr8EgPn/ern6959w38vLNXoO86bpmnB1CRpBGySOfWJFWgSOAkoriNpSJ6pD7++fqi7ks5euD71TaprFvfvx/Xn/zp3FykNL6wcz51zTR9W0+tUX8//wT+CPPl6urvx7d917D4Cweb6UP/tZ/MZDaPxiNocoTmXoWlCEJKqxB2eYdIVvm2z4cxIvpkaIvWPdWTOLxHxay+tbghek2e9dwRcNx6p2wdx/pADClpMb/DBA7RKwbxShQ1Wtlnt9u76ezgLe4nKwd6YtzqsEZQBNkZDuHJ9d3X3w3ntf+/zzz188+4xC3zROISoSYQOCgIKaBkiMRGZST8tJRKUGEy1xVRQRFOFmO62Kkw0WiidUkajKgORYzPwDJEJigBQkJcbONhdkEjzdUbPMZAIABUyjMmb0bhTNyeMpaXtDX8zow4QIwESbzQYAFouFqg7DYIhDjKSKkmJCEBIlxBSUeEwJhZjZLBtGyKl5hGCQRdY+AnKyGBakR5hCHjhmJEWQJJAUiYiJNWOGiUqJrICoOucUIaVgqsI0pUO1pPyr9R0BIpKUm+3tO/trIGI3iMNajXCdIvYSUi2QnOYRTpXL7ZeJrIdwTeCotOr2Ehq2B8/IukCnV3JZr9dRUhQAQkIWNPRChEla3/ZwlXrR6UD3FEAVNVCa/PMSs5weJwAIIXznO98ZhuEHP/iBJyai1WrVzDpucjtTc7NX+AoANS2kVlVUyDa4wWiq8NOt+70oZaqY4UMm2TGIoYCI06Sf+56yKaWkGxEdu4oaiYimzTBb64CcHIukhZkk2DVfNKt2O/xounepdG0GIyQ0hBaqHlTTfmCLHJx/OK2CuekTqgOw5kO1Np2KQ6sSU91Ve6IU1E7M7rHMtTHxtLqtRlumXiXELce0gaUCmGaUtq2UgW1dVd5lJMGtUZUXCpCcizEZ6mh1ICFpKvWyFXoEEZkoSESxShUQzBxQQZGYCARVIagSiBLgMAxjHGMYo/ekICLee8csIu7Ir1arEPpVjP24RkgenOPuAFBdA8qL2SF2fo1pWG/uNYvm9CAO6cl7X7vnvvbzP/n/XPTLO3y8XksEB+olcTSE165h5CTox+Rdq4qrl29gCK7pNA7X15twEGc9KbmLJ2fH/5W/6u6enbzpx59/Gf7Zn9IvnvMfn7cPGWYsrVto5B7Cy1fDJ0wPjhx1Dvlg2W+OD6Vzq7gFRpv3AolbakFgPF+BZ79YAGlYbgCI2QVJm9e9zJuT2cHiVZ/6Hu4ugGH9i0/oxVX65GWDHp6cwnuHMJu59Yg/++zy8T1//24DgMOY5k362YvmX34KovBf+OaRV/cb78I7p/1yuXp26YbQfnIRPrgjECluO40iobQN/Od83WomwtvjN9Pv76gpb/nFlFynb07/nL7+igt3vS+VlU3Zaf3IFJ4Qgmvau3fvPn7y5IMPPjh//bJt2sOjxRfPn1m2+Gq18Z7ZYc3hsHTcHUaau/RqXheEpDf8hJNBotU8mrwjVREEx7zNqbKieER2jveTLXcni5MyPUS0pqSQU8UtqqBorE925NRUObMUw8ViEWM0R7JFLjTHOpCILN1eVB2zvQPVC4NICC27aF5vk9xU6lDKUmRBg1bdQuaqDymLBmIEUYkJISME2b2dc1avt16utXibYBLqMpZIk0wgVTWXORTlBvZIiFChSo2dmuc9wgMo9uJtEZk9ld1IouJLSan8sE+3gYCdU5EVnPpOrTjAlBQUGUGBFQATAigRpiJ7pskTAFDzEmqAYG8miFuUMERMNxyj9n7btj//+c/jGDImh3VgT5JKdeV8PlfVcRwNED0V6Gtb6xqqME/GVEfD7PrLZc2mspjdLyJaCmdIy6YaeimBNXOJKlISXYkopC3uhRbXHDCqoAoqgDMLQJKIEpLoFr2KmX3JOZWSOlObOdnXEigQkm6zWwyqAoBKrZ1qAfyzjdjLuwbTmWRfcdmnsD0OS5Y9tr0EIYnUKqF9HrfVmtVMOlUFQ/MGxF3lDCcWG06UKiISa5Mx9VZuS/Y0wU7NC1SvWMq+ltzXW8SSeRFYrUwHJf8uJ2mbamPVWIoMDp3h7UIpTmZAzvowCkJES19X730YE1Eus2JAECXvbQqDg/b44PHZ8VN9b329PH/1enW9FJHYj62fMzogfDMuD+7fuXt6Z3ENFzM4OT4+vfuIFt04yvKXn4Cgi9J2DUkCUHZMjUcm24M2iWvbqLLs+2HtOnI6hrRcL9frQ3/SRhk/fQl//IvwW9x882v8vY/wv/ZX5dXl+mefpY9fNn/0S3xx0TQNKPjLdfrBp/T6BA4X8aBzZ4tZ48Yuugmot7mvk8c4jLNBo6ZEijGuL69m7Nuj40hwNEhMA7xapp98MV5c+/tH5Ng9v2guNxAF3n+EJ0d9P7rXaxLg47mGzfxiCfP58OZq8+NPm8u+++ZT/O33hUkuloAMHXs+IddqEFjMszQVsfagCggMiVEKS/wKp/Svc1Xaq9SeCXv3lvURWYmf9AXNkFlvu/+NT2ohPexaWVNuDruTmuoQe+z+15na9E8ABEYJIhKPjo6ePHlydfnRz37+Ewzj8dnpq/NXmG2VlJCSRFJXs9lrR5gqzCqHr8zn1pEgWszS2M42vIuoCoIIyJDllBBm9rXlMHuiak/BKvoEgFrhQ65Qs2NuNbJuupgICsDMm81Gi8la5VFx4luVCxp6KikgISJpEp1UkSCjmRlJFEoDJ0AAyfmnUj1n+e4oIgIqKUdwcvWFmqa1DQzZv0Ra6ZxMKpeaD01CzFD2gosUnsbly8qgqjVKsddlGXWX4GEHTUxVRXdSQW/uBUzodip0pper9L1/C8m+QSAppAUAQORyyqGhPprc2o0YVfWi/ISqvK9znqQhbStEiCilqLd5CwDg/PzckgeXy6X3fnZ4uFytrKUqTDwZ9lxTLFSFCsXan9NTd3PMBqAJReEoFoAaQzGFMWeHME3rsuqjUUzZzx5dAFQFUkySi36rmwdK2mbVTqrwrqSOst3PfH8qMrwKZ9tjRrMqbFS5WL/SSi3FLiuKoNUeyOughHnMt1CSn+TWJCg5p6oRVCUxggHrwpaKAKojGrQC2RG6Ld3L9svFIZ32WHvZGrT1V1WHxMzxFuNJgUoh9ESDEUsmTYiAjnLVt0pSTYpC5CzVSnVnuRKoKRwIhI6JCAyqnziJ9JpGEHBMDAgUY+waCiGIFEYZUoqUUoLYMDO2rfft4ujIN60xtetN3wpurtepwQfu5M7J6fmb1b84/0Qv0u999zGPqY/r9772zdXJvWG9hpZmo1++ft2vVl3juOEQo6TQeCcaRsKorJ3HloVVAZxzp3JHtLleL5urzeY/+IfyH/9h/85d/+5j+tp73YOzo4+euN/5CP6178GXl/DqevnJs4OffwavL/0nS2jW4ajltsNxbI5n0JzU9SXRCNq0zqVEHYIHIW6oaZQgBFCBIQwXV+066Pn1eHU9Wyd4uYQUwbnVXNujhXt4N909i1frsO7bO4fj1+6eHB6ML94s//4f+svx5Ltfh//SN+F4tgFhoNj5MaaW2J8d8dHBsNmM5ECTgIAgMTF7ShgEwlZ4FpClG8TxF7puqgVvk+hZyuJ+Y/oph5n+do/zTO2rqeq8p3a8dZw3Pt2TvntfuzkSqKqSqKCcnJw8eefdD7/+jR/8sz98lV6h6NhvXNO1nSeiMUYrRCTIcMIAgBP0gS0r220RdevwUG/ZJsvqYCRmVCVJYOoCbddk5257KSlQgBxtdIhIwrn0DwAxlyim0hyn/tYy0ip+saUbZuWpGDpgJfXGKEoZ7XSFRRQgoSUjIlfbW0S4rFW9sqJZTE0yvBNJqMBIUvq8IyIA2agMkaA8sSxC0RiqbkEA3DQZ4Lukekzlu83JqvX0RnoQZMJDnUww24tl2etlDoW9TZzS7d7Ttzgc06+qapHQOXm2fica8APm4KMWn7zu3qEeHtM2LE5xq1pkOTlQXf1FusA0QAUAAIujQ1IIIXjvyTsR6brOCCWlZO8bCPpqtbp79+56vTYksXqriipW6V5ueNimhxMROSuh27whdIyZiAERmFkMv6TI9RqDM++93SqWtjLRYjE5lUSqKwKSyCRf1SGllKbmmpXRYqGYBMo62c6y4Cbd63QqFeYZ5cNSDgCWUJdm8HW5jTfZrUzFVNWS5LXtI3OLKUM4XUlFsCWqDC7r8eULk8qRTDyUEW9ZcEuXiAhMTGy5YnWbxJw8WMJbN1x8CBGRi5dvW9lk62Od54uRZVVUebWYmQ1TP8Q0jAw8ar9GudI4uNYTUhAGEIki0VDWVFViSooppSamoBhgdU2IRL5tm1lHre+8O8HGOdfcPzo6Ovrpjz7++z/94R/r5tuA36Z0lxHXPcy7xdHx4t7Z4HQWF+QbfPmGJDkGST2pYBJxhMRE2DnfNB0gKyEyd9LBmBJAezr3wcX1Sn940f7k057/xcY7OT3svvcN+f6H8Z2z7ttPZ/qt+PEr98sX+LNn648/lfP18Ec/d588d/eP4MNvbffUIRJi4zkqtEoiuF6JKjmX1ivdjJw0jRE+f6NXSyQdl5vNahPPDrsHR+7uqRsJltC+CnDnlB4/hEXbONj88KfNH/z0aFT3b/11+M13x09f4hdLun/Q+IOmm/dNiIpujKrKs5lrW+k3AVKCqMTIBMoOHSLvify/tM6Rqy4n75hWrLvRxr3XqiqIdMNG+upr2qtzTxH5igf9OeO/7Qu36Bl1DKA5wsgQ4nh4eHhydvat3/zOi49/9dmnH89mzdgPJNqxH+LosIRRIBdEAOF0CtMjOX3n5pXRE2oZhaqqJsw8GcAyPYvWogS4w5cql6gc24p+6gqgAiIp5uzMLC5VqUTMo8g0X3IYhqOjo+Pj481mc3V1Vfm2q75q1eINAFRrMZmBMPNKmiWZoiJ4ZinT5yKbAUzAo/F582H7rXcH0YDSLVMNCkhS/tQk9RRnKP/S6JIL5sxUZGCxb7fprhP/k9m3BSRgj4qw3KzsF2WVqC5+eX+nLPmmGN2RAqpu7++bqSUKhKCaPTAgmlvmVR2nVnPkjbnNjTa9cx7NjYNpmiB5lztBVx+AKgL4plmuVv1mM5vNDg8PQwjDOBrCh0FR1RoK59zdu3eZeRgGLJ69OlQrbKEJ8KrN3XQRVa0dbspEFEoOpnOMjojQexdBUogpJbA8CTA9g2JBFakQankDIPc5SykhoGMHqirJBDDl7qkZJqTrOqu5qPuiJbUWlFREAYgwWXsfBEQULCcwlaYDqgDgkEQlIVSyVkvgICm9DLaONdOpp6RTr5r1adOx1EudRDTqSmYBz9ub1+gPIEgs1UCooJN0J9q5CeJ2DGrY3gjExMXNOB2nnQ4bSYqpdM8CQgREVogwSY4pl3E042RacgO340cy3xg7x9ZbWhSYQWVE6tm9GMPVDI+Q07D0MbeGgRzWVVXKrVeCsHfknQIIahg3m345hNQiY7twXdu07a9evvqDX/zkD3T1szsHi+vNMxrfa4D6SCIgGEUijKlt3NHhIVBcr0FS5/2wXq5Xq853jW8IXYzRpQx7C86/Wl04gRbp8nIFTJtRFrMjUUQdgFL3Mup/9J81f/qxf+8hfvNd+eghfPtD+NZ78eJafvyr2c+e6Y9+FT95pZ+/wc8HgKd5yV6cJ9IRIYZw5FuIKV1ej8PgvV9dXTaKi651n5+vP3/lCDr2m8tBf+O9O//6X4HmAE4bmHdjBE+OjmcDifz8WfvPfiF/9Ed8cmf8N78fv/EQf/olXCzhyUn84iU9db476ZShVxgVNYWWRunnwK1zgKwKCQjE8o8L61Qwz/CvkV//a117/btvnot6VZ2j/jn96PY77wrpvW/uvaNfqc1MRftNrWXK5G/9YR4DADN33ezx06e/9d3fOT8/Bx27pkFAKzvyjRtlR8zntDJVz9sqxT09Ayfu6iqxAJAsr0EzqC8oqSCyBw0pAx6iKoIykVMZy533lx22Kk6uftdiaGXDo6TZ7W8BbMEZLAW+1gDWxoqTKeRnEYB5RLFI9zpfe3YdjS0IGfBj8e6booYAJCqgznGyxHewjA5UkRgT+tw6VFXNYkdEVUppnMwXENFMx1gWv7pVUun9hAUoXHPWkxIiCShadL7WFtrAShhqojQAABMxbpdx+u9N+ryVUO2GOx6OaWqJFmNXcAIqhUgIgsXJZb+9DcW9boMWOMsdytg1F3iCB6pF262f2tIOMbi2uXd4qKqr9doyOdZD37Wt6Rz2UOsp/+DBg2fPnkHBX6p3myYb3lwvu4OpL1anWseQJRxT1oqMMhAYiZ3DmDQmVXXMMWXoT5vm5BBCLqcCU6QMvh1ZLBqRqSrG6IhnbbfWTR25mfj2J+3mSGqJIGpKSAS4nYg1UbORuFsAewDQ8GO5nEkQ2cLq7ZFOnbWp59Xgq2rvHm3RPn8B2CUPGwAW4TDVxOsvtGRpeO9LA0YBgLRbf68TndJOV6WiQj8IaIXrO+YRTsLPhVzzvMZx9MSApDEaPprGJCE05JAoNt3z9Xi5kDniOGw4gZJZinagQDUiMBEpY0KJccgLyNwQ+QYbxcvxqvULt1r9ix/96E/G1cXZ2QW51+Pq1WpzNV+mcTmf3QP1uupn7DdhNWvb2emhtD7GqKQ0zHQ580jeeQ8cY1SEEUU6744PHv3WX02tj+DHV1ftZVhcjc67YbPGixdu3rk+XXz2DFaX7S8H9+mX/gd3r3/3Nb5zf/61d+Z3v0vf+Sb85BP88a/k5fn4ybMtMfzTn7SOQorOc0QAx56pUwBFXa5w7vsh8vOr5B09OIWISA1+76P0jQ/6P/k0rc+7R3dUE14O/o+X+tNP5E8+kZ+9iH/9XfmtdwE5/OJZEphtAv/kJbUq/hIUR0eMDpkSQbsZ4dkGROBkAZ1HJhCr1DJA+51u73tdP379a8rHpCiyt37n1utmbOVtX/t17rZ3TbniHqetb96q3OAkKf7m45xzkFJKERE249DNZyenp4/ee/fRO+/+/Md/hkCQkgA675kYWVChSm+E7OTAraaO05G87aGoBACkKVkQrDhNTO0hqgawNXXbel6r4Iddubu3PjhBPaCahFje3P6keLO8933fWy6/qhr/l105VVeWANPuLuyt9s1H1KEyQDIHD6IziE/AVApAUum4zjfS8OuDbiUYAjRtwuaTUpLpGHbrm1SVFRRAbhyT6SOmOXvFh471hvk+Ez68N/fp1tS1ctPf70jTSlElkmN9VU1SCtY+3hpVKW5/pRWKo3gXpjtxS34i7jh8klgpUR6xfUSIm2GzWCwODo80pir+0ziMOlqPWRHx3i8Wi81m86Mf/QgATHWokRpErEAXWxoqVdpGiybyLUiUAalEYEJYhp/RNM0oERG7rpvP5ynEzXJllTJ1LnuEOO0RUw8hM3ORo5ZGLZISqGhyxNutmhj005/bmDUvnTFHMM8fF8mdUrDyJFfKO8v6q5bMbWYGpRgzfMiU5iqzsNXg0gSnKgSStjhCUyKbnkatnq20k8FaCEAQMYbt1lRnGCImldls5ttGRPq+H8JAgFOYUeN3VeHYZt0aGJ/NRVRQIJvDNKF5kBRND5icoq2fkIhENVnisygiaorgnaK/ulyvY1J2KaWYksoU1gWhLGyvIykQEwMzIIJgSqraE4Rjj4we6PL66pmEK6EzODiAFfZCCss0XGyuZ91RM5+jom9GJmfV1ZCIPB3cPTzAh+F6hUkc+kZBUUUHnvvZ08fr3/mt+f371HZdwuHla6cCLGNaNW+Wm6E//HLpfvgzRyivL1ev3pwc+8OffBpfnNP5Zjg9gkd35Pe+4X73Q3e5gU9+Cf88Q3Fcf/liNgom8UcLWPd9Q3g4A0AepE0J7h+fp83x6fHhkzvj05MYpYvc/bXvw72zYfmL7u//kyYxvHjRx40bg1xu/INT+r33jz54hOdrXj9v5kfDo+Mx6ezV1ebzl7jqfZDm7jEctaGhTRjpas0fv3yzWc7fud/dP4VZKw5VSW4gYv3ncd0qyGGXlekNI+8rJMSt99+725/7xK+42x6jr2/uif8Yo4WkIQl5txnHg6NDJPf43fd+47vf+eXHP3GgYx8AkLxfrVfs2m0eGCIyYQ6ekslnQpTJEa4YS7fMKzcZSNNkgRSNJyE7FJEUrXX01jsOu75xkw83ZR4Cm+WuqIjImFWEKROuA4JiUFneAxaHfTVQy6Eu7uHcS8w4xo63VQwFgYjM85pERIKI30I4qjmls5QJ0XnXMoeUxnGUlIjINb7y28wJzXkjwq4GQMr4pXAqU1YKpAeU6ZibZKouAAAb2lrBbIQSKaOJCjtdasksdMvbazLidPH3dnlP7QCAHFIhKKofUwJIqA0z1qiPMXMFVXGOU0pYiy2LON+qk7vtN32RDVoUzLIcU6Ih0yhDCBKjFnM/pWRhEWaesYcxLi8ubRlijBrU0GmsYrPSinW1me6WebRya1PzuCAwM7Gz9AxbDHOgWZay7XdVLbMeFxMBELG9YKbWN++/+96PfvSjIIlLOpKqsq0MqBMSlTAGZW95DGjRFgCSrI4Z5UkB/hKRN+fnVGDzAdBTThpqmCUOxIyEQXKBpCCKiGdSqy9GJCZF6/sRO9/VY4UKVAqdVZKIECFDzpYVDQoRt1GVfLbNa8rkVSBqLMSONQSISAoMAKIqQRGRmHWMTIRIObvTfB7MSQIqExFnU9BwOwSZij2w05WRmfu+t1QylXhycsTM5+fnjWuN2GxVnWMU1aTAGS7doNjsdd1TVcUSbyonxxpEG0oKEuUj6omIEAisRM2IwTd+mfq5OkUODXXOpVdv+vW64TbAaI2LTen03itKiNF7BgFQQmYxLAREZvDqXWAU/OzV6+eizzxee54L/uAQ/no/jutI5MbnryVdrgB8Su7o8FoSIjazjp1Lo/ajElEzyNjxqkPnXAt8GJroIC5X4yef9M9+1Z4czr7xdfyt9+Lr6PrgjknfvT5YJXi8OfjaB+nlK3r+Ov7gR+FiE8ZfzN99d1i4lhTGMBx03LDeOfT/ytcBssJx+OF7l+sRPvl8dvXMd8dhs+wY4c7h1aNZo+zXaXb37tV37xwdHRHSmMgd34GjQ3GKXz+lf0RwuVJlVT8czRd/43fjk0NtG1zr2kd3/wiGTXvdDBLAcftqE65Ww+cv24cP08MTmbeHirJZjy6dRYBXK5jN0mLmBFAhshfwXlVzX2szGu1Qy239RHf4NZasz8yLJoKfAUxH1+Ki32OmYIHwGu0sMX6o2aAT2ZxfmHjQrZKUDbsMErhjcN7ULSpzN/UXAEG3+SWEuS3ctoRtN6dyIrYzb8+WlXOqGmNqiNNmmBGdnh4/fvrOt7/z/T/9kz+ixvo5B4fsAZKKoiqj5nRsU9BTzuu0CPhEvt6+/KQm8khJo4LBLIA1XkQQ1IAI5DOTSEl27FVbB8tYVM3tsfJyiaqqcMTsgzeRTAxomKbm1M3ykhSZFCFJUlJNg908DqPZgwCSUhSBtm2HITZNY5EAFQdZ8cg+WkIEBaLs206mwRARURRJkOr6G+dMKcSoSkjmxUNzHuW4irFAACjQXIIIjqnexMaZMc4rwVRtw47BblmoKTq27+Io26lxG+1SVSUyImRE0u3ZUTVC24dUsaofAmRAgx1XK0CSBIXIBUFLV7Qco7KyYAPOEUJFqDGnOsPpMahege0BuO1siMg2PjKxfVG1gkanmEbJByOE0DTNMAxa8Dpns5m9E0PI52dScwulj/CeZVBHZZhgWGz0qhUxE9DEBTtJ8dWJcbCHmzudnVHSmzdvxnE0VHJRaJpGShKlkULrvFUkW+QESt1z7TgzteZVt+K2zqWu+VRFne5IVvisDJiQStTAbhXjOFVsba4W7cnrDyox2mgnK7k/6/KCoeq5CtuPKPPs8qy8BTUJH7fBRcbdlVStGRQ7b1a2qKopqqpCQTSrm66qVY2zvyxHp1ZF2U3qi6rb1fkyuy2tAsDWh5Ttqqq7ZPw6ohCj+X3X4+jazs/mGqBtHDOjgkGWiSgyMjMhA6klGgBk1B9CRWTw1DTt5cVymeKAOKgy4nHTjgDIBAmW6xUFQsQF4+rLlYmHpmu7rkMD8yEcBgkMI0NyTpUkpESA81Z//Bk2hPdP8E303yecH0FHLQjRAcxVD46Gp6e4udd+8XLuxH32MoYeNmG03tzrIb25xMuVY3z1zmHdlPA/+Df8Nc5/+Qo+/VT6VRuj5wZOj4/eOVWSeHXdnB12h8dAmj5/nQDC03e1Y+pHPJ1fL9A/GzmBPznS3/06/Gvf55kbf/FlG5fJEUhKm36WjhKSiK48nHx6ue5D+vSa796hd8/iu3fA+2ZMYeG1YzJnGBMgR4cD/P/jusni4EZYdvt694fbg/y2u+stIaC3SuvdIe3cfxIDhRus+9afw8QNCeUsHB4e3zm7++FHH71++eKzTz/ufDOOY9v4FEV3mFI9qjv+87c9qL6+ObXKt6f8asrMp4d0yg/3blXbRdWnKACVog9C2ru5iFi4lgDYuVxkEHIagKbknYuoUrAVxjHk5+ywZKh7XjnnVD6qJerlLdkuRUwxBLDif5FkmWwiycAViQgncFvTPcVdhfIWz/FkYaFkddQhTXf85h7ZoAWm0QmYTrV+DTMDh1SAl5LkXvEwSVSCQqUuQW63Zui5OYkEoXqK6nCnoZap5LspJmEiSuHGxPIICpEwc0GkRMv0bNvWe79cLkXkwYMHi8Xik08+iTFqqWMGgC0iWdqqCHXRtSi/eMPbn1Kq8Yaai7D9c9Idrb7eH7m9ILLHXVxcHBwcOCTibVUtlizUqscQcz0W1qJgK9in+StFNk81050BlCE5JCGw04KICQQymDpM9CpG2WeI1XljCooW9QgmhUJlSGKJ4jdXoKLBTjUSW3pAAUDXNmhwn5JnKxPvBSKp1NDMDv3c4ERIxCmJdcsb+mCS28q9dhQOUVWdz+emWcaJq8y8DpUAbG27ruu67vp6ubf4lSzt5zV7txBYHqMwL/uB2nZ+dOz76MzlmYCVVVUUWcmxV5ScsWWeUaufFxWSKNqAPL+4OI/jpqFRVDDMluvP+zerx4/nzotL3jUqEYlayHD4cejXYax01c0WOgiJAFHyThURoAlCMaZePQN+8SzdOYhHhx79CLE7ui/MdDgHj9ER3pfmmx/A/LD71fM0Rlws0rzxffKvLujTlwi6+IOXAB/lrXE0v3MIDx8M/8UP/bBR0fR6A6tAx12PY3iwODo7GvGQhx7FtY7wcBbWfbvpZ7PZ8dHR5cH14qP7/rc/gm+/vz5dCGD7EGDzWXv3sCGnQaJ3AkJHNP/W+zBQen0hbcNHc7hzLPcO0REs56RBfKPzhtgROml88C7x7az217luaAxbrvq2HI63/Xz6ju6+M7nJDWE8+dVUFsJt729vOBG6lYHUb+5JlJtSefv0G+LfuEc3mz948Gi9Wr788ovnz74QEccMKVYRRApKSBUjdfduumtETZ+199ybouRt11TgTYdNkxRA2F2WOgCx6hDYGpA7uouNhAip9IJIaJGa3FFWRFXYZWOpxMdx8l/ZF8xtTSq+p5R8PtjVBe2q6JR18KpqLRrK4LdTq9feqtZrb8V0UqVIk+/XO3Apcpk+3b6WdKewwzwce0oJ1pwYyqn3oiCgAhpxS3swERZOVaM9DBBqxQ6om0ygDmLPrzhl09Pdnc5/K7On6stkMraplQhms9k4jqratq2InJ+fL5fLCr+tZkgjUE68xZR7eWzbE1ddwV5YHlCN8QexnFeApBWrIqqaTGNmAxU1c/ZtUh8spqNqKCASYozRmtlqcVSaY4NKipOqFtlfoLp2T9r0lFZDfLrUdRYyKW1SE243FKNKWLXmqR7nTMSElti543QlhLRDymorpQhYqlrE6q8yBrgNRHceqgDgSxM7VZVyZrT0JdLb7Dm4cZAAABWIaJRogdEYEyI0TSPlgtLM0spozT1mni3dVRltADYk733TNF3XnZ9fVMqZ7rXxFHtHJuBpHNUhIUIMAp7Yt83ssGURDSlEQUE/0cCYRMRA0y33KZ9/FRGMOqboX51fXIJK0wHgoCEgvwybpaTDhp1zi3Y29H2MwS88qoMYU0oJwNnaKK0oeECSFCUpIvsGRFMKb+IaWj/6dLa+lI8/HhZzf3zWtW1Yfk7s4c5J07F0HuYdPH0ycte83MiBNCfH2hB0jXvT4rwZj5vZj36y3ZF/7/+uyeOHT/G7T9PZQX/v2J/d114cM43Dgk5hTHBxzZdruHughzO87Ic3V0Fj8tDeuz9/7wl/94Px5ADWobsKMGtWInQwo4d3oAe8WCYiaR24rrl/EloPr6745AQ+eLA57pChCQqzjokJVF1rEd6AkhiFWHPN9ZT/w1+oOnaPp7+tU9qUX6sqTFgi1qDgV9y80Ng0qgJFfn/FeKYXIirmpLosC3B756+49tSLm39WRhRCOD4+Pj4+eee99z/75NNf/fJnM++GMSG5yo5UAZFIQVRFhW5zzb5tFlNhMf3VV4hPmARbYdc+nE4n16Pm0vdd5zck64CdisbGiFs8IprIC3OSILrGR0lJhZAwiSp4dog7taRTdYdop4aucnUqgTeBLScHACauaQbToVb5Zc6PKhdgV1+5JSdybwsQAcDd+FrlaTxpIIe7CuJ055Im0Z12oVQRqwmxKC45tghgqYSI2dDEonM4FAWrBZhqE6JRAgMzM7ERFgCKqIDShOC2zpxpCGb6Ymu5TjZAVaeCUCZai6SEBifimB0vl0tVbZumPrGq0vXpU9eLGevWNmUqyKfLVEc+VVDq4lLpiLaXFLN/MCirBZ54HEd7//Dw0LXt9fV1ra3d5v7cVpcFN2ilTnNnbBNlrpJL/rlk5F5DAk1ay2OrKrOtIaKdhNbtdgAAUA7vaVEj6jDym6oACYFRpw3oJ8uCAoqWAQoAtgLVDQiluEaLx6Uchx2ldo8HIWKMiqhs3hsiVWXmruu2Nc8VBa1sX72VJXDYNtVc4BomW6/X1jehPne6RKrZiWqWSs1ap2ieVQghLc6Ouq7FEDgGVBACBrX4i6oWXOfA6AEANJVKOgJIrMxOGPBqHK/RqeucsrAK+3PRizA8wHYce50dMLNAitkx5DCAqgpkUBFlbNjTEMchGkyqpDiG8dQ1dHrKZwu83viLT8e7R8N7xO28efYmAurxYbx36N59DMdHcHa0HMfjd+5E0lYgna/C+3f0g3tOZXPahn/WVqrr//GftFcb/bNT+oNj//jBwTef8G9+Q999GJpOiIck+qe/Cv+vfyrnq/GbD+G9R4vHT5qjQ49N9HDxO984ObsDZwt/eb158bI5uwNEKoMezOFgDjpA2/CsbbiFqGHR8AeP2odndHwEBy2FsekTAULjoHFJLe0Ik8iIOgKQQvpL+ThuPZJqVs3kE8QdKbJ3Tc/mngj/6munngWxAndOuVblnzcZxZQPVyF9M8q+N5ivHls97yEMbXtwcnr6+Om73/jWbzx/8WXoe2KWkvKlaiCHkKZOoa+8budgE2Y1ne90SXFSZbO31Nl6NVawVTSxYARrLX217DqzQ1AUKgKTaMzu/EmX+SJcgXkYBwZGxCgJJHmmGKOBKt02np35vm2185QpF0Vuv4aIk1D+zRvces+vWn7Joe7tqor+f3n701jbkiw9DFtrRcTe+0x3evN7+V7Oc2VW1tBVbKrZEilSJA3SlvRDgAQJFgwYBiwD9ADBsv+4/xiyYFiAYcM2Zf8xKEuQbZmCadMkW6RY3c1qdld1dVd3VXVVZmVV5fzyjfeece8dEWv5x4qIs8+592VlNUntH+/de+4+e8ewYs3rW5INfknK0MXA8TsvYi6amew6F7YSGUFAENBqmv5Q68rUboe1NHm+SAKb3JlsSAHMbMicnzNmFz3mwFJ5WXHvP4nMaVt0CwCw2WwODg66GNq2raqqGjVGwBgT2zZRpGyfpmJBBp5DyJrv+QrYLFlLj64M9ITbG0qaakmtGGz8TuIYEdV1LSHGGJumUUVnMpkIobWGOaqqq9pU+eJWjVAiQDSDVixDyiuOhzI73YihdpU2SAUzpptZRE1qbacnJdCRS9hFspOjZHtQcipKcjwMD3bRAHK6k1D+aoA9WleAaR120JbTeZcBtW6RC65nUjn1WTvsZUhZWkQGGaZGRAOcrP4nxecYzk79TH3fG2NKByYZtIyBfGYUBb9pmrLaIqBdeQGg73tr7Ww2izHO53P1sRFRZYSIIooQ1pNxVVV+s/ac0pAQ1XAiQUGWCGLIpZwyMhm3JyKiFRJXM8KGZG5oIwiRydHchwfCp6HFukGAGL1BwMqanALHjiREYDGMiDiZjGvrwASCDTNIH1iYnalOjt3TN3ns+INPabGZ3LoKVy73nuKnb8Ni0y83Mmn42Tv03C24eWNkMNw5cssNPZhT6/3Nw3j7smFroh+b47IZs6degg/fa8eVW/X+m3/Q/dGPptd/FF65Lbdv2KuX7Iu3AzbNg6U5XTTf9/xoQ0/dDLeP4MEaazN96lZsO3+6bKyrRg2EFjqejOo29haBxjUZa0e1GAAG1zgAZyYNC8jdx1UX6GAcJpVxRnofjbGJ6omtYULV4Z7AYC6+nsS1+dxtym32eHohpCHnHXKhJ72RMTGx/bdLYkSYE0eHPPMznrkn8AonGb60jPDCKZ+/EBEkrtfLo6OjzWbz1DPP3vrJnXd/9ENnHcbEz4uDoeBNwe4x/jwjP796w2EPn1CgSzlXkagl4H1XbtMHMAgLG1AkU42kUKkR3TLV/BVR3D8RAkKS3CBCgTfYxyAIxrqt/Znsuq1lArv+9bIRw1moxS+q4RSvLECGMC9TTiS0lxJQ5r7H/4f7O1yx859jdhjvWex6m1YOJ1kgFz2WSId8IUUxgIAUY7K8azhIzdmwhghFCIFVqinvJtJcy7LB5dqTnWXohaEXB1EaSlE+BvuR/S7pBh4c4Nl44r0PHG3lgHCz2RiBcd1siVGHATgUyZxRHIYa0t6yFiLQdGVWGHyi3FRQtRcezhf2Ig6DUx1777Wnrha/AHCM69XqbJUCQBqaGbaqGT42jS3v7nk2sUdSw2/hIDS4dVpoDqxsv5IUi9wMqai0ihZKQ9tisD6lJaBA1BgKIgFpxtNgBdLzGBDU6VVeoU8quU6qKBAgCITEYtK79ljMHtNJXzdbdRSZAYRZ1ut1Gi0R5DxZzeZZLBa6HVVVHR8fA8CjR4/ati0hnuLzcM4NT68M9MshtWvmBDMrshw5jJEFURyeblZrbY2JCF4AjSInhlw6rtragAJRJDfUZcsSzzabOYfTxrYEdWAQ5qpahfas78yB0S7H4JkdVHXNzAjgKmOqRK+ISIiMwJUhrnjjQwgyqUcnB+HFp+n6Sdd18uH9EQDOJnJyxHOBp65VH5/Cew/Nu/flnXtw53149qnRycyPrV324dGZ7di9cw8ODuDGldHjtnvuMvzDPPwvvTbHRdycNeOxe+GOrNbw8QN/dtZ896d0+Qr86yO6fvD4ynS83tBiY7p7ePehf/VGbRkJTQgiPhB3Fmk27mMwrhIvQh6YQ+2csyzso5CzBiRaiQixbaXdWGvBQY+hRrKIov5pITQYHEVDsstw/0mu849K/tfdG4bcoHz+GcL1Sa/beewAFOH8QSicZ++ZQ6bxed4Ig7OGA4/IdkhK+SJd39V1PTs6vHbj+guvvPrw4cPTxw8x+60lX+V1e86VcpqGT957y/lPzo9nONMLLoHUUE0z2BBwD7tShDEiGHWyBo6KXFkUjvJ+AMiVuqC4nQIUgj85OTFoHz16ZMnoubPWwkVbMPx1z4ws9SOloEhgh5CGK1l0C0hm6Y4L7TOIYTiGvQ9FpICgA4D2qlTho5+QyrWtgN5/oLav3T6tHIGCPysiIgSYW3xmD/RArbSkwIi5hkIfhgBN00hOJ1TBSbklyh65JCluTJH0w8Lfok8NtxcRi0WCiGZgesYYGcQYE4W1RtwhtZu2CM7iR1PhoUWw+sYyq73I1g6PECCjSQiclHQki8i4TfvAXUXh/JnRV7Rte3BwoE4RIqqqar1eI2Jd1+oT49wzrADO65rEFE8QkmTuD7ME9mhrj570QJY0T0255RghJ6sOuAAAQAx57innGVLX45gQV9UpMRxeOhjCICn1CREhbi1IGXrktr/uMF/N8Uz3ZMIgbc10Lswtg9S84awlA8tAKfajpGwNSuS1yXUiiOl0OplMVqvVer1++PAhIm42myFux5BOCoMbEnNpprDZbApdabKO994a8CyCFAk+fXj/EfAksiW0qsVI8p4VIoydguCriaZ47IJAgtRF/2g1n4NvXQ2VhRiiBFfVy2756Oy0P7iMiKTd/mpL43HoexQhawXJe88+gEhFGIyANbaaELXg+/ry4eTZp+DaFWga6tigk6pqxw6PJnXVhOplmN3r7j2uQ5TFEt7+Wf/O+0iGXnseBJd1nLEx3wty/bJ/6U4Tqu6tq/GXv2F++ysAgP+HxcP/9Zen/+9vwmIjzVW+NpHjPkCg+z386IPNp/fCG88cPvssfrDseImna/ujT+ovPQ11DaFdHpnRKUyZgBGm47N204xHFbppMwJXbYxQZS2gsyCGoPehqepewFT+2jFNKuoY160bV2AqNMgIRtgLehSPEqJcgM/8mdeTpMXeX4tv40KeDgM+O+Q2ci4G+nnHI7nIosjTQSLX8Ae5SEH/jDleIH4uEpPlB+coCG82m+l0enRy6fbTz3z0wQcPHjywIHsZZtpySws9ZGDul6WA3UXee1G5p3xr7379awmJlm/lLiH60iRGgDJDGjqnCQEEc6wcOBlPIqJ90TQEn3LcRW1XRLIkYuvq6tWrfR8ePHgA1iKD5+CcgwjZjtYRqkcEAKRkWshA4dAVS9wEAXIonHjXN5bxk8o0hwYw7abHwoDYLly6cmficlnh2JOMw28VOxbPpUvvycGtwzipyyIiKFqoDZpez9mnkl5KaCOIgsNbVVQIWZugxo6IhDQYY6w1ACaEoH2Ch7SiKzsejzmLcDAEKRWUEcA5N55Nr1y58pOf/IQAQwhk7dCs5qgYJOkjra2wChsRYi8BDGmzjT0CzdJoizuZytCNEQSODJER1Eukqq62QY4AIAYpe3G0ukQxMIio6zpdev2wLLGSpq61tVY1DP1ZRIKKwMiIoBDaNND6E4xYEXWpVQ8HAEQypuD6J3ms63eep2zNCGsAgDVIYQh4q6gCgmZQgkAlmLu6BBBVGSFyJJs0Kmetc67zfd/3tnIcYuqzCg4JEUyOpegBDimSorl5aINnTOCkuVNbrj+DfPRFxHMEQjEA0WtDeCEWwFxMSwZZ8zSZua7r9Xpd13UIgTkaYxBtCqCIMhYC9Z0iGEBkTWk1YMxoNBbRJTU+hwVxt/y4/KpDTcgZxgVt4UtIZPoYjbGsWfnGtL53ZCoyYb3pnHXO9r39yWbxOh+cgOXWg8UozMA2t1ziwCLiLPV9SmjX7CIEEGQzqS9PDz/84cenaNuRIZE1QdM5NNWjxv7w8f317PrBdDJfLK5ODjehg5UlQ8ZZMdYDQFWBtRJZvIc2mBG645GvIa4BT47hmWf9i7f40WO7Wbczquumur+k907XN69Pj4/Fh+qtF8lZeOcj6iL73l2eIcOmlnodcNOC39Af/gyunoBpVs8+U//SHH47kd/Jv/Dnej+L3/iuPL4Pj/3C2cnxMRxN2rjp//Cjwzdfhy+9EB4u3fc/YGjjJ6fuR4/4K8+ukUY90NgJCwYWlIPpBERwZMFZZnZkwFEvEGM0TFCN7bpbrzc0aapx4x/O8fGymk5gylG8EWuDQLTsal+No3FWMAqiWlogW84oKZX4vOzX3osiJWfiCUKxcKndP+0IiV2OvMfE935VBEg+H90YFNpQ+etF/gwsDuOsN5CkYnvhrUdzT9gPBzOUNxdqBiLSerSu8d6Hrr9+5eqDT++98MqrP/nwI7/4NAS100zf90RgKuy6XuF8AFI1FoJBYRAgs1MYgkkMAYhFJJYQISYHpYA1VvGORWQIEo2IdV0PMSe6fLQrqoU9ICJYQQje61siCTM756qq3mw2MYaaRiEEERYEsaj2kGE0RLWzQbtSAxq0AMpYIwJQ4J++81MkqSvLHJjZALIPCA5RgScAtmyZETHGbB1JksSWTB+3BhiIYoEQC8cKRUNsLCDiSwtSNCoQzcA8U1FlrWXkGCNZY4xLaXIUAUAYObc0v4AgCRFTsaSIvihV4gizVYUMUAFRQHjY0o0lRG1tkx0zmq4hIt57Z2uJTGgie5sz+gu5WjJq5QrH3LpT5TEISwQmlCSG89CRmStXNU3Tb1qtxRhKaPU8F55uAMUUn1vs+57P5kTEPtiqstYO01SKRM0q57YEo4y4qDXDD/UeTSoun2COqvTBwxNK24cSKJ1wIkRUOA3tAKfiqsSDkiwfgJbuHP6BDbE3/rLxwzwgSErGFitijzcNR3uhwoE5rlxG4hUxM4ff1P+RXCyMmPsCJP2aEEBKJgRmayCEoM1KgGV3GLGYcjjQbYfbAed4a1kWjd4J5A6Twxkha36WEpIOyVpbtmDP7uGsnkpUrDAlVE7J0kSnp6fOuTKvQjzD7R7SlQ+BtWJt0BiJmVPzORFNzmQABgjCZtJM0OBifbTa3BQz8WwI3XjU9Su6SBGP+b06nipFdoKH3rP5hDenSBAocjTWQugxBra0sjKvqGnM2eMNdqHjflK3VVVR7VzVVONRPR6RNTHGdrmAnplp9WDR9+348qXxM0/DzUtoGjy8hGJG6x4/eQBLT/PF9Oql1aGNMEa5OqoQG7d450MbGpocrB1RXdlmFA6ZHy7xdBlPF3K1ukRTef0OwIe6Mq3f9P/8y+bp6eT3P4YP7se7j+Lcm3VsAsfew3IFl47CX/nq+vUbkz94Xx6uurN5zTCNlZBCqbCgEIAQEhEYEglojUEDDJYsOAcb350+pkXrDsfWurhq+76no5E5mlBTcetJDUGkaFCBXjj7284d958TXNgj189zz8+9GT/Tt3Gh83Xvkl1/yd6fLhzDHrL7hdf5R53XNrZHWEBicqaGEK5du7ZcLV564YXf/a2faQK1MKorkYSMMRATSmGOVKSODbjLJwFAFQ4iQwZIbKrdYI6806BgyOQLn5SB60gNzhhi4MgMJjXVUesSEHG9Xp+cnDz33HObzebdH/90sVhUVaXJniwShVEgsoAAwTZVYu9Sr6XkahEAyFDFWsiy5wXXFdi6x1LfuYHgL2Kq7KNRhpjD63vChQaUIJJy0jlCcZfqN2VgTUl2mReBtbf4Za+HEhCycATYbtyFBFNkkD5/NBp1rQ8hVJWt61pLKIaGOmyT5AbAXwKQM/4YIHVJRQRjiBnYBzQyqurpaLxYLDSIrhabSlNyVjWiBNXHACIgQsbEGL33y7O55GSLnThd9kmJ4kQR7vWvE0ghIjh3FIdbmD7JYE1lyYZfVGFX9rugP6nCVNf1eDxWdaq0px8ymvPnfI8vDMezt9PDsz185h6hD0e798y924Yml+TKq2HucbllyE3itmglFXcoQxEFmD+n55UkUNTEoJ2XnvfBbN+4XRk6t2p7a5gz6FL3eWuZWZ1M2iR6T1HQHJSmro2zghB95OjznxIMOZyrN9lbijJHDwxEQMQgEVLGCTPjMJWZgIBA80ItNev104JfvXTz2a67wtYRiascdsAiIUYR5OxaRODIhkgYOERExIzPaCCebVbvcPeJJQkOIuLEAAFHZsQH3H8K3aXxZTMaVcFW0KzX69B7WUiM4kbN0bXLs+MjU7nx4VHsgwH0mw3EOB7N4Mrl9uSggnEcj/1o1GAl3vByHR6f2dPHRIeItVy9bE8uwbN3zPd+Aut+48X0Ulc11DaODZrHLlpYxHgpEht5/tmicJjvvFd/+Xb9hZf6S7ereW+XLXxyr3334+7jB2gQHixgMjLPXKmOxzWM+EfvzyVSH0xgGjthRkKwkng2ERACKwq1gAiECIFlsfKL9bSZwGwiDrmNrq7NyYRHFXcB0SAaIMPGemtEufkTZPxnKAfFn0qCnDGLPo/mUa7hKfv8XxzmAO496vzDP/9gQB2MAheuw/B1hRHt/bt36dQIhZn7vj8+Pr529frzzz//yfs/vnfvXmPser2GyIAcoxhjgggAUip6gBQbwm3oJ783qvfdOBVXUcP6MUb0DACAO8ezjG1raOkjMvMMEgRRQGKMgsXLwoA4nU5DiG+//Xbf98yg4W/IPIEAtBNpUo/OLYteRMQaJDWpJbqkuhcdA2TCUc5LiiiKWzgCUIuKIw/nVZ7PzAhokAhSL8w9dlfWQS9DjgggRu11J7sFLqX97nCvhzMa/qkIo6QTZIVDGRQAyK4ONhy2ZCNKobOsrZj59u3bH3/8IQCoy3/n5vzVnT+AIZvwk2RXQ5EYY9/3bdtaY2IIkLfcZvhw2V75HXlCLudUaraBAMhAyvLWGwUlaUAA9nrGlujJUL3Qz8usRCTGrScHNCuTt6fXAAruHLnhMJqmGY1Gjx490rqGuq6H2zNMs+BBxezeDyVdGXavcmByB8ISyqHde4ousXPeylUSTWDXm2IG0U390AAKoaRkJRZR9OD0KwCQMXrUvfegVb7GcKouyePHLO93dYsYQ97eMt+hFpQVW0w+FcSUziM5LUs3LT0Quaye+jmGfLnMV1+kPeittcZaye1nMd+sqaAAWyjV/ZDz3ghBjDGYaoUYySZNRb0m2oYXMLWQQrC+v9SFLzVHL6+DfPQJXbtaXzs4k83Y1KH3IcQQAknqqIeQmk6JaL5ogpxBQ2OCnz46e0/iY+Mc1B2KFzaG2BI7dxrC3eXqFRBnrQA1pt5IqOumJtv3Ica4mS8R0Y2a0eEUIwIa29QjH/1qAw8fhvVRfTyGpvG1q+sRoqXHZyvoqe3HfQWV6dGuqzi+edCcnJCHbrOplxE4QuA4M3zjilt6OZwsgCcdsduSKP30IdZOnr/W3ziha2CrOvTP2LOl/ehR/3AOkzo4dOvo6gm8+TzeOKysgDMbhw0CGCJHhAiK0KwFAowcIrMQi4Tg161IrCcNXDuBEQVgmo0qIECUTUAWVkAkQE/YW8Okbt4nXueZ7/lbNHKyhdb/zOfsfXjhYz9DVzjP+j9bRdhjVuXJO0ZrttB+br+67dd/voqmgPwEAIrSfXh4ePPGrWdeeOmDDz9ykwoR15tlU9dBkjGd2pZwec55DrbNoGJm/RURgVLvkfw5QGZu5etbQ7/wGsXMMGDIkrrnWTSWLcyRQ+loEUIw5PR+ZwyLoGihEBpChQ3kgbG0y/YDIgJpr3sEEY7gU5wXBQQQMzA+ARYPAjCoDJNSkbS3oZL8EHv5b2m2EvODdq1WDZ8k3guFmVMJYcugTll2K0a3jJREwdOHlV3lT8Kc8vyGnmg0xQIfGsmIGGOsHCmEVfGsaLkvbM9IevU22xatscYIskSOIVhwaj1IZAJyxgrzarksQk49WpD9HCqHi6Gg8h5F+r4nFX4hWmOSC3Q3LgWoRgZmRIXsh+cBDkSe3nBfcJD0t3dP+ZVBdNeLgllk2Fa5YwaAzWajjWdLjqHmdpS3FP6ibv+hnlHmcqFSWT4fJD1lRZvwwvGXn/f4wuCv+8p4IWIAsOkcpchLoXWNgmn3mZJWwsxql8QYtVFcwtfbzQPFbWgwI+OLFP/U+WErNZSq4z1gA73ywgIONAMRGY/HIjLM95Tk7ku017atiZZBoo/EYsmoqwwGephk12vZ6L3l0n9jjNtKMEo2aAiBMPmp9YFG0AgervsvH155C5ruh99bnd6fPP20GdXdej4SlhBjCKCcoiDl64GPAgCGyHNEotFk7AQ/fvDwvjGdbSxVRDH6VirsIyKZzlSLLtRiqaqEYyA8fuq6EbRR7MZ3XQcCFKVBw+sVC7bgAdk67uan+LMPp9eOZVI5KxErPpiYV57GrndnCwDqx64a1QaafrNZBJ4dnogP9ckx+LgJvZtvYOLg2iXpWGbNqO3cyUxCKItmvvZinNZ9U1erBXRB0IK19mAGs4O4XG4sgUPf+tqgXJv0l1298Q4BRzV3HhHZIBkD2lhAj48HMcIgghAZZVw5Y21V9TbaKMZQnNQhsll2KADjESFCJC/QOuwMASGCiSjnC00v3O6945lOpQgi7Suk/2yuOOitnUYCAOckzi96JQzp3SMGn+nDGN5Wfh4IqohIatFZa/u+n81m169fv/P0s1eu/3Dx+FFtnQe21sbgs3IAIhJZDCJoauCOm3ZngbXlgrIOJ5WIwodh8h7sOmBERJsCFN/GlnEZMkhoSFLMJU1nNBqp9m+tJbS5crAOfas37IUqgHbWYbuwuwxKxTszJ3gqMACZcWi3FP0qAhpJySqEPGjBXSROmpcaMrIt2sDshy8DGI5HE85YGEmQNE9V1R4szJ8MpCy33RJLyO5kRBQWRLSIPJBQmJ3lKiaGW1aUjJK6q69TxEtNP3jnnXecMyKiVRRDCViSXaz2G2YUQARKLnRmZh+U9JC01xbFKN57chnXKMahJWqIihqzPdUAzjkSiByBBS1S9qAMkEazc0qBcne93zaXYvLgoMqA7IoqkCeWiYYTBlZZMhEBERwUdOFgU4lIa0wUIVRXsFR7Sy5eKFrLUKpdeGjP60awoz6ne0q9dRnkUFjCOcax/XWXiIdHlGSfgRGRJkWXhjLW2ugTLpYxBk2Wsknh1nnpw9NWloUsoxomteycKGSOIHr89HONlSa1DxM0Yn4uIqAxyh20T3RpXLLPNyXBjjEze88gwJDyThARUFE8U6RzN2N3hxLyXphd+4KZg3jegpURSErwNgzE8aaXNw8vXb539umqvXXpxuGVq8u+cwh+3UqIFAVy1VVk5tzAKQqjsioRQjDOnZ2t31ssz0ZWyAkhEJguQlX7KETYkr23WPWdHzXVhr0AzedzS2ZSN+PZpBmP+76PPizO5uSkasZIFInBInUe7j3Adz8ItrdHl+z4MBwyTiZUT2prgWkhPQBXaKZVFdoOYmjXy2rUGM+MwcRoexcnCDVR4HrVd3IaBuvT3miAEU5XGJYWDXjEwJ1IRLJN3YwbnPcrjMFVsAEy5ASB2RIqQJsQaMdxFCSrwWsyzlEIofemIefGoH5QH4gFahIiT2BGFUSJVkwACCxGOkvBUtRAQqa+z5Csw63fuxARQEiSJXDhxYMTOvjWLx77SKUC2ydgLjD/PAPekx/nBvlzXr7DQPJn2WbYuVEPdAgBQIyxfd+Px+Ojo6Mbt+586ctf+61/8F+GsG6qum1bJA0hMiSDGxQJd5cN7qMlRRBEgVxzJ6J0YQg4p39k0QjCwjHjXkAOpohI4KhVPKqnJG4sgGjX643WsccYARSkwLRtawmGzAqy9UswYF+Di8iKRBbmWJgzkDWQ0jMgD7J0AhngT2jBBgICaEUtAKTVRhZhQBBJ6ZfbTSEEFjOQU3t6s0AEZAQkQvUZ4S7HR9SCGxQRZCSTMmt0jwAU3YizI0SS7UoIiDEjI+uObFeJgybQq1ikbFCBYjwKEdF63SLWxZTdDlikCBCr79S/xtR4LNCwL9xATBpjDJJEZjWFiRDQGOOqmpkJKWSazwD7UlsLkVHAWissRKhdw8v6cOJACieF5cTr7jLCFgx7ILML7Q5D9VthngwXKBA621mcO8AyAJPROXrv9fMET76roxQVdU/PgIuuvc+HpFOec2FYd+/r5ylv7+FlbIX2dF7krKZAEpIibzZNc3R0tFqtIoAK5hgjl2zQJzDcrGUGHFzDMW9/SJ0ys+emDDX7G/YCUsNNLNQ8Go20iQnnMq2tZqkxYGM4d9Qh0ZIfERCT7xzqbSX0tqeZiYhzNsZIgGSMBmsjSBSuTIqtqK1hBDAG8PHFg6Mbrlrfe1DX9bVnn92IrE7nY/Z95zVvw0AqidLJAqGxVjhITsFmhCj8k7PH70t3ZqdApkVuxc/EhCANVT3I2rifrc4+WT6+NRm1/QZirBwChD5sognGGALUOqON7wwEQ4YtBAIiCsvV8u33Goh4LZjLsVu3brqOIQKDceMZeuh9bDtgMRaZkHyHCwPgsBbYtNCv+zX75aYmdGtvwMtoVMjAfv8dwwaX3JsuVK7te2cqwwShr8ZjAIE+jE+miAbYwLQBZ8Fi9B3ZGg1hNKwp8IaABbT0DBEBrep2PkqMvu9rUwEwIBplDo2ByL5thcmyRWuYjEdiQIzqqIXz+3v+AA4Oj/K3bSvBDJHwRKH9ObWZPYNh/7W7lu7neeAvdMk5+6f8sLcy+a8XKDQAAMBETr8VgrfGbDabuq6Pji/dun3n8tUr773ztiEQEUIyZHrvITFXFBGm0ndXX7rvmgUFvCqNrgYO0OH4i6Fc9DEpGBWEBg2ovhJiclFo6BhQux9oAYV2uQKAyWTSt+tzCgeICJ7nY1sSUqtEAEAQ1KsmwkiDzA8F2USEqFYWlMa/Itopu0iugpQmOmAduS5ELEx+QB1DKVD4u0oPQNG+aXvFCqKKD7Imk+wSmwCgQVWwE1SBDEQGEFDBfszfC2ELl6WBqkTthrq2a+oxIk4PZn3fEiXzdWcweSJWsq3MIhE4dU8mQt5J2OHcRx1zNoMig2luBwAYJGYGTB0BUkaYiIa0EdE513YdAAoIGSokJCBBhFRPRTQDuwF3SWM4gRIrKp8MTzsR5WI39Z2hIBCn5NO9hdB/FXRSw0Pee+0Bpv3ih6+Qcx6I4dhERO1yGLxo+MXBndlVuOvwP88oh5xi+JA9fjVMMSlLxMxY2cCRIO0XIs5ms5tP3fr+H30PAJxz1tr1eu2D18IQiVsf3fD5wzZmBXNlOOA0yFw1rTnjjFsIMF01HcNWnaXUMyl41pjrer2eTqcvvPDCcrl89913y1Jg9rdIXhPlb7nAWBhECAETSAnRNqQyzAnf05OQBVnIsLUVZGNL82f1yZpGaoCFGXy4emk6q+yZxJPrVw+vX1vEntt+8+i+Gze6ClGYPQulgikfgjMWAHyMjsg4CwQR5MPl4h7wxqCg6cT30k+oOQveCfZgYlOdrtu1AzupzHpTRTQ9kzWC0Ie+AyltkN1sKq0Yj0QYUNA6g9CtV9P7LbjWjFoTAq3bOF9GMDIeU78mQN60zFyPqrBe1wBhtSG2PEZeBNPUiLF+tHDGCqH1nSFT+J/5vT/2bCp2VYwwHpFv68kEEL1s5NIsAq+BRpZ50bpqvMEZGJpU1QL6SX1gKkfOkjMRQRC4D0TUkQCLAbSAEkK/blUza10MjZvWBshCt9kg12iaQH0MqiWIISbgwJRB7D6neC4MHXFY95dm+KRHnNdjhpT/ebSHX/QqDG3vvRffPPj3SdfeEp2XBzJMgxUBSP1RQwiTyfjx48eT8fjmU7dPHz98440vPv70bgz9aDTadK2P2iIUIFepDJ4s59+l53XAwwqH3FnMoQRg3glGpOYmiNpLPMZIgogYBIElokQOCtE0dEWv12uTCzr21nYvx6sw7XQbgZpywBA121AEcW/f1cdToOgVxFuXNJaWIMMLc1WlLQiEOa9/T6LtbpnmhTIIZakQi8AcrnPik4PilwI8ZshEGQRcMvRlCpcUO7AAlREa3LG9y/PH43HfBTXUx+Om73tmNgM4PkQse2k79ohoyTpLGLjrewCuqiqKYObUuZe6AYAgbCu3Xq+fe+45Efnxj3+sxqhwVH0kuTg0eRMAIgtiRPB9CwiEaJCQJSPcAwKgQigapysBMblyCCk513KrvaJPcMEvB9iuDoCIECAKYM4pTsJIyYEQWbYWMGm/ewEEQyActHEtOqfFDpVzLCEG4ZjCKHVdawHFUIYVsi7BrT1CAQBnbcxlw4ypbJWMDhYEQAvZy3aanFWgnbgFKWly1vgQVK0phbUhd04i2YK+AYAxhjvviAiIIxsksnR2dvb47NQyGFc5MpHZWqsZfBBZm68SIonGFxgI0dCq39R1DULsQ11Vqo01TRMGrEE3LWp3Okj93QSBMTlGhSWE1GXGYqIuYQmRSwRkNBoBwA9+8APVbxKzoATsAdn5GSGBtqFIEDaIhiiG4GPU9sNFB98Pug0OJAAIE8c4m42byfjs7GzTbZyrAQEJg6rgDkkYux671bPXbo7v3KYFHB8cm4Pqcb+Ue4+b1XpdgThCAWFIdfCAgEiIE6QFB3J25E3d82Pspk/d+ODDT96ZL9+fjJZuPIHGhbUFWlDoGYi6BswiyN3x6GeL7pXGztw0dp04aaMHRmOMQQMR0EdLZjTvWg5mNuUQsGMi3simPp72DXjbNZtV3VWx6mnVmfmKpxWJbdt5sHFcVfxgSYsOBH3b9n2YdgBd3x3UzeUj6EJ/tmADYb4yAgDPJzr+6T3D7EUsOTTUEHqDMq6r6Sj2gQkOLh12jx5vDAKayboCHyLy0cEkWI89g++9ANXOjhsGWfed4WA9w6qLrTf1KLZraipsqjgemZGDdQDr14dm9DCYjx/xxGI1kZnpLXZ23JE9iJuV2Ricqv93T6AyavXivtEMACKliWXm0crLcSvYhl+U3C58yM331I7yGMRsPw6UgNQeedBD6rPVlOFfz99ZDOgkKVWPx9QBYHgVyt99SFYQcKdMXT8CAEDHAFpUZa1t21YbGE2n08tXblx7ev3USx/85Pvfga4zSL0AGaeFopS6kBT5rVUPjFgQsUREnLEICAgRmDkSIJCweE0+0KEaY5yrASCEgAq7AIBa3s/J29rFFgCMdp9GsISMMcaIyCGq4wF8CIRWxBMZQzAajTabzWazSS0pQhiNRmGv15UIQAQBZ2tmFoiaNq5iK4pUpA7jiIpMXsp0oyci5iiM1loGZGZAEg6ad1n2Qrl98bDFbCLq9DW3HkX74wEiBuEozAXyHG3CWEbDW1jSrQqFiCTQY0oyBUEAow4PjiwkCaYYMYIAqxIjZJK3EA2SMOT0LWaJWoibC/hE2Lmq732ITAgg0RkKvSdATNGMIY4zadzMFihJZdDW2hJvG6pLZQ4cIyAZYx48eDD0VEfFbC4WZ9k5wuFxOa+DF+UnvSWn3g4PCRGVNMV9/TcrHIO5idJo8nflrEwDiIhBQtlv1VnLe6MwgraSRdGqWgBEsNYKYdu2xfyNAxSX4VwlFxRth5f1pGGDOrnIvIgINMgq1XIePf6IxQEHkhH3OKcI4MBQi7mUqbx3b3hQ9GhmSa1HRUQYJD8qeQ4iABCShrY5lUsZY0jRmbTt+yCvRSk+guwEZbCYkin8KduN28lTkRKDKEZMLloeHqHhiu1Q0UAfvZCP77kcy96pmdJu+s7HTbsR5oTe07WjugFjN33ne390fPTiy69/7Ytf/MLlG8tvfLtHPgnIyw2BiAMSUzxbSnKYD5sYspER2aNwBbOjk8Vy9cHHn3wIsAStoIoMMRKQqA8UkZCsWS3m9x8/8leuWQOMbK2prcFkNxCgkBCDrPt1JyB9K5E5+ighEI+MrchUo6b/+EHsIjx1eX3vEX78sLlzGT3bvmtEoPXie2lDt9yMyAlKfDBnH9zlg7jq4qYjH6umbts+DiVf1RgEihEQfQhknRuPGWWzWNnY1EfH8e4ZW3Nw9RKhaxfLQNAcH0Bd2RD7xbyT2Ewnhip+sJCex0ire5/W4wl4Xi6X00uXR6Nq067rSW0i+lUHsxlUuHnvLv74/hSrzeGlyeFBt17YpjJIoe0BYFyNWx+HSX8X0sb5n/doKf38ZBobPmRPf33Sdf6GIQfbUY9+wbTRcrcBLKkbe5mzw+P/2crN57+WZ/OTo+MbN6+98NLLdz94d/HwPhHOxuNlt77w/kF8k0ojSSy4O5lZMMrWjb/lq4QY9OZiPyQ2OGCnRXbkG7KTHgwAEAmzsAQUA8AG7e3btwHgnXfeWS6Xk8mkqqqgWGaJABhRdSEEAB+6bPRLjFHlqCHSGn7KKZScL+1ooT9LDkkgoqBRVi4i2pQ7x1Yu2BoR0TRzymsFkKBWikd8O2tl4Bf16GGEAg6ucJeIqJpqfilFradBQpTEn8swBo+yloygGt7CgATG2L28grIvwttNLFJb77T67hgjc4AiNmJk3rLvkuuHiAQYY6yMnc/nIlLVtQAYa2Pfs2TMBUwBe4TiaUijOU/1pqg8pTI4U9KF8ymklgg3ZozZEmpBNEo1mMGmAPRZQ0pNQm/QhWhg02DJ6jDGnJ2dWVONx2Pn3Hq9ZubpdNrmZnKy9VZtRebeaIcrLrJt6VtOC5TyYNnaKMnkkgQfnm6LseglMsg+KS9iTAUqMOBoETKiRnb7oL6xsCqzbT4EA/GM2dvWNI0GmEi74zJTbsFayHfYY7M8aqsKZGaeHis7u1mWSAY4XeUTEigGWSZhgLy527SVUtyYqXx7Bs65nQp/IaIYmQQqN0JiER/ZH45mvuu9jwfj6bXb17/4xS++8drrb772Kq1W3/uDP5bR6FhIFsueW6RoAAJzBQosgZjxgpi5BzZAI1vPXQgko2b08d33f7p+/E41XjiLQixeJDJhBKRIYIhFbOU6iY/XZ534kSNjJYRgncmUwMYYYYEInUQgFA7EYhiwF+uowRGsl7Ko+aN7TTRwaeLnC/fwzI7d2Xo5ZgKGdr2iScNI825zdVojQiAwtaPKeWZGsKMaKtfMpjsW8OE0CHe+n0xGwpERTV2RMWMQsA4I1+NqdnAEswOOsZM4mR5YtJtPHvRhPR6NZqMxnK3g7NNwtnAiUNX1/UcwnsCormJge0r2kPsO2hHVE4DI4uVhS9/7AB9u4OVn6GACzkbfjWnkEJwxyEhCHHpT2e0gLwocfPZVvnKhDnH+wz0qulCnufBR2lTo84zkwtftPEp2fpDc0mLv5nIAf+5bPs+oJHIzqm7cuHHv3s3nX37593/3MYENvdcTSbI9YnucREcKAKriDx1I+m9O2pU0J0ndG4o/G7I/pnAG2i2/FJHM+BGEON2W9AGBgIiM9Pa7b6v3tB7Xnn3r26JSACQOVooHY+Ti98m8HRGIi0GKRs1BVovdpbhDSs+n5C1jhT8siZGU2mcXbXFvRwYiI9nanHWXveXlXK6IiFwSWfNlbOKoOa3VEAGzgBjtTQVCedEIAHKP6/2LWQCMSFRXtDAaZ1erpTF2IClSpqqIqOIlInsbbQG2zuetRMSB6NjOHwBAcwyByJHRfjmeozWGs9YgUIoRduB0RDTEri1D968yaBn8uhU8ADRs4lVmCBBzLCPNTcW5AZtjEJK17PTXARy95OfvcSiRXAlpTNd1ly9fnk4OHj58qGUsRPT48WOt2zyvc5SuhntkVLxBerMBFN0PzZ/l7RgCCGhd62DxiwQ1xsQB9G/aO0M7LyWEFHJMjuWtyiJpMJLjULibMTRkATKwHrquUxxSR0ZEvPfGGFtX7AMARBDJOs1Q2A9XFQa6BQDoIsPO0dqnh+FISKBYsVJq0OkCv/SQPX2GvMlPZmMss8QoJMIxIPJk1HTrjUQ4OTx6/Y23XnvrrVdee/X4+Jim09iMzPPPLb//brw3HzF2joSMjRyAhcQgcti6oxhEhGswIXoAHldNu2h//PDhj4A/HI+8NQ6JQkyJLmgIgIxp276qDNVuw9yhJuAgQoXJMEjQdgpEFjFaMH27IS+WTPQhBpHH66X0stlUnyxhNJGf3cX5vIoQ3rs3HTvjHIzrenoJrx6DIb5yDLODrl3S05eIXKytWCJDABiYkSoiAkjFhPDyHWI23gcjHKOEyIjWWoPEMXZ97y4dCCMvT7GqD48Povfdw9MRg2vEni7gg/vweMHLDYXojbBBO5otl6vp1SvVlZNOuBao65H0EftenPhHi/rjs6Ml26evwwvXyZqePQrD2aK7tKwnx7Hv/GZj60YJ/El7Pdzxcz/v6P17J/cz6OezNYMnDeZJY8R8BveeP5Quw+en053PuGTbdE/nKPO6YJwXFKf8/MuZioNvKnft2rXnXn7to/c/mj94ENYtEmeDfLtijKyWvcJRZaFAqUgNB3A/mCJcrJgrIJxZNAEBkPZYLgpH+VaJJoiIpk8m2RFBoCBlJ+FFhETYda1KRJWdZakAQGRfDbJOfckJpkjfGEMoIWAtqoeBVKJ8AUDJii1eCh3LkL/t0Yz+S7BfvKQ7vg2EFUa3LQgCgAJEAJAUEX2CYEK8BJUPMQUkGBEzGqogYglB7vkGOAIYJS0jEjWv33uvCl/xo2gOKgxMYtiFrbJFzCggVckKxGEVdfoCA4DN3ciMMdqBHTTGNhBRjFnpzsMtCtqWvPIftRdnWWvWwHyJRBThofYrkeKZYsbNHXoUMtmBRA1JoRqaWwISyRBPwhneBAbH+LzSs16vn3766WtXb2w2m08//dQ5N5lMaFBkPPw6DCowh1oRAPQxYFkWfSkLskTZ4prot4b3DKlQf1CUKskFHXVdM3MXPOT6kjIUXagdbaOsm2yrY0qn3HIDEYHJzUeUqQm4ujqYzrz3vu1Uc/Ica7BgkqG1PVEIQ6aw5eaSilqL6lMWajjHvQ+HP6CA4pjtsN1drlk0yAs0nnO2LyIaazTn2jnXNE3vN13X9T3YunnthVfeevNLb37xy0fXrrnJxHt/f7G6evXy9ddf/cF/9dt333n/NgZTc0DmEI1LfRDBCEQ9vgAAztYxcrvZVLU9rGZ//NGnP1ysv1/beVXXYCwISiQWiiBGHGT0DrFIdu19j8IiGJmJfe9jjAa1hVAgImOseI9iIkepq9HVK9V0FBzx4ZHD0LQxHhNUVfReKgfXJ3i6ZBZfGz4a2ZMj14yC97auwDXhxtH4YAYAgaNtRmDIe08CnqMzFuAnadFuXzMsTYgogXovkQ2i+Nh1G+kB7Yg+fhC7yJvgRjUcnPngoeugHlnfdo/O+rOlE6zqGmobDcbKVFdPLEA4mNqTo+i7Foic855pvagE4+kKIthXbsGdy3FSyek6zCoTQrz/ON666qupFzaM5Kz0/fC8DBnCHkP/DB3i/DUkyL2n7V17KsuT3vEkGb+nGXweVYB24zCZ1e8M+5/wGswoPS0KAyOg3Llz59GjRy+88vrv//Y3Xc1dCCZJyZQ0kKqAjJq5g3MNUe2HIBEHUkFEkLVFlBZ8lEBJHB5eGTAKHLRZEIiScZuyZmNyeoB2BRciVJglzU9XuAgi6vu+qioAgBzW0XECQIYcAmY2iIyoNRrWmm1cG7YU0nVdgn7PfE8ZI1knIsjJ5hu0e9jRM7a7ScAoMTt1QL0HLEVMbLf4PJTlLu0MlBv9W5ljvk+HpYpO6S4EW2gQACAHiCQRooQobIytR80U+NGjR5h65qVNFGDKeCGwrThJBq1Vm6nUYjAzwLbeoUysTE9EjLPsfQQBFhaxxnRdp73EtEaAJBf5Dk7R3nnY4nBkeaev4xjPw6ToLzhM6VKX2aBtGyR3egJRiSgoWwDjsvbDgwQlmSPjauQI2Tb0NZ1O33777Xd//FMimk6nzLxarXALGLrPvxgBchX7cOfT6j8B5xSKgzRhgqZB4jnDq+/7umlEpG1bRJzNZiLiF/PiCtPi7+JuHXLbnaESCgKn1M7tOkjkonINN905d3h42Lbt47YDAHIWve+DdznJiOGJLFLVC0jRxjKXxC/K9g3JID1zNxkq6Rz6M2/Z4J6GMThguLc7ZSXLn1R1rmpAlK5dee/Ho8mVK1fe/OrXvvzWl59/5vnZ4fE6BC/JdRn6fjSbyWQ0J1mJN+0GkE004JhFSAgFRBPFMGn6bMhaGtej0033+/c+/RHC3ekRA1kGEgkohlEiRmACZjHOkgFkwJ4lAqJ1EDej2cT1fYzRUm7LTGiM4RaJqAUwV47Hrz2Ht2/AbArjkSyXIM6slkHYohFkb8itg2nXOBvFk5mZjMOqD2eryliP0EzGOBsHFuuZJlOQCF3nqgbBD3V6XzcYGaxYiKYRCVF8jxXUo4bbvu86E0V8rHzoHy7a9sPxeGwr61d3xQc3GdXHxzwby6SmSTOajqByYTJtZtMYvSeqmpkaAUbQrxb14z58+rB9/ga9es0b4842FRlviOdz/9G9+ouvtiFwZWoD875tYMfJd37HCxXtqAW7h1FE8Am5IPv6xIC5DQlPJOFjPikn40l6wN7Iy8D20zLK/bDtn4Ko2Ze/gLtCfp5G88S/W+NDV5vaVM316089fvr0J2//6MGHH1ik7CTIDB1ZMFcvgvobSl8SNmSyCR8BAHNxR9YqGFCBrTBzp+RlFxRFw1RneeLeEkC2e8TMjhyiABjlOERawAbkqO/7GGNVVZo0CgB1XathW2bNBfBUoiFnbMk0UKubdthItp2YOW7LOkh7nuuvqecXqxlisgNjYE8OGCBkSBXJ1baIgIxCYAce9PM0nL6ufFJlIm1j5eVS9qSjBxIUBQkSEWFMVujeFaOwCeVpkf1yuej7PidEbAW5pivG2Of04eyIA0ESWzh1yXaUlPk4gC8d2OvMTABoU/t1EWEAowqkCAgwi2RPPlHCWNTHYtbtWARyd0SF+9oqDZQqU9Krs8KBLIwgAqzlztlJALTdp+TwSDWJaUFzN0gpIYaLD9KApxAl7TXGiARVVRlymrKgd9Z13SsiBRU9Yfv0oYwvD99K1kGlDJTQiYCW0uDgUTDQOSRr9MWprtukHi0iCszDhsLJ81ZU3nPsY6io4cC/IgPqxyyWReTs7IxDZGbvvRA6crZyqaMS7i8sD1oW7V3FOaRjK+swvLnQJBFJTsIv9xAAAJ7Xb4ZqxxPVrN37EdH30U2cc9i1be/7o8OTr7z1S1/60pfvvPLq9avXvI9nm402xrOCtTGyaR/fv8+1rW6dhOVDWS4xMtiGYx9FTO42qVtERMwSSZpRE4z55k/f+Ufd4w8mk42dmuAdoyfuicbGkYgHZiMkpkIjInU9otC1gSOKY5odHkhkYJbIMRXCs4iY0YiZkcDOxjxppK5i7SKhOT6xlfN8EBFsVRvhPgZrnSBba2xVxz7KONiTY4ksHIxpggMPPGIHxkZBJATTYICI4P/W191f/R0AqP6tPw7/+VcI0Ldrzcn3vXFknDXUe14s6fKL6/sPzcLXLVeny9j7WDs+mdSHxzCuYVxLTTxu3MEMKgciniM5C2LCph85C4jgGZyBRQ9dJ4sVt22UAK2veg6HtQsSl6sHP/zR5utvkDs0k8a0UcSDqZ+0y7DLlIf0cF7MyxNuLhJl78Ny247Wgnhe/Ksq8wt5PhBRzlXZ7HwLgWDf+w0XsaCfp2A88crnO1/Wcb9BZr9ur125fnZz/tIrr509ui9t6laaOBOkruSgWTYAktp+SNIbaEeHS6lXpLGU5FNBRECNQDDhtjtB4VcAKgP2bBURYZFIlFA6yv0xxtD7uq6JyPderfC0Vgk6Qh872EowqjqUt5MBY0rLgh2uJSLqKUFEbQLaB689q7u2BwABQkjNIPRNA81m3zNXnNYCCebLZK16GDWW4VeKDqSKxEBw5CXKGTAGINlu+VskaTVVDOFO6kPSUogA2ViMMczn8xh9XY+y1pWFbArtbKezZeYitmxGqvAZuOuH67j9kbD1fUkJ0fLIuq4REbKfQBSjNusoZTWLpBkmw5aTnF1PhmT/nCQRqKkr6lTPqxSyAE75wqDtddNq7SXaIOJQKsuQaHJ7WwQw2soyQvDeCjjntPiDmTWE0fc9GyTUpj87VTnqIdAlLVJ8sN9JrdQxmyJ9d7U6RCzKTTnteo8C2ogiXzHP53MNMwEBEJac0CRoddb7Xp6d1G4c+HhijFZQz6vWrRCRRCYBW9fr9ZqIqlEzzIeK2oR62BwnH1cseVi7b1caU61ryK/L3MttABByUhjuGpRDxW54leeUdRh+ArvfEpHZbNb7NsTucDZ79tkvvPXGl19/7a1bN5/uCBHspl27pm7qke87CX7UjC3ED3/208eL08PDOkZDG4ldaLkT41XFNtZSqnUCABDCru0s2ZX037r//o8re9qM+g1YisAQDQZDIJZAGHo2YpglIgdqmqaK0HXeRxoJffjhh01V106LD4EIBCEIe7L/k9/6//5v//m/OqnGxBZWwYgXg4TYms5UtjImtJ1hqAHiSMLU1b3gOvJ8YQ/GdPkKr5ZWGCqzgUDGADuILMYaRGiDqSbEcRgP5ekYiMxBE4WNQWcMd/16vbLjanzleL18VF87xjbAogMvJob1GOlktl637Nla20wPjK2i917AOjeysHx8Op1MaxOkayVE3wUSAPEwca529aKTRytsxmDtGYVLvSWGT3707urdn5wc3LCHY+59PbEQP0umnlc7BpSwQ0WIW2r8PE87r3wkwnuSavGEuMmF9Kl37b06MUwEM5A3qY3Ak0b8mZr3k+4f/lq+24a+rqoYQlWPAeyNm7eef+HFjz9492c/fruMVUQEZLjaWR4NOEM6mYntM0bKEFVZq9vZiHKWhXY2sbjrYZfPh+C13Xr+kzLwoF4NRTpX4CVmttYG4cFMEbZMjEQKigFQzpbLD2TN4SiVDyrIMKODF5uwrkciyZ1MkPEx+ImZNKzlftlgJhEF1FKrryi+2z2lbRebbZhJJPqS7aCkJ9k/qq68pCCgpsghSkwA7Zg1B70qaxXvKAQ2hqy1Mfq6HgdONQ0w2FzMhSZ4LjvYOofMMW8bQDZMQ+iJCDFpdqZQQ64L1ccba01qEFDkBGpGm2KARVUFCoVpD4UBykppLqBCVMNUrBWeRBiZY7RIIsIhVs6p+BCEyF6cxTBo9YsYFQc3RLGEgEaxKDUlU0QAWN0XAhyiCAJhAAnClSTHhoj2xAiIaCtHXiw6H3zI3YCSwmsSbQ2zY4gIIEluIBRONaIWyXO01hpIWTk62el0utlsvPcKhkHGlIO1jf4ACEBEABAU1qUoGkPKvyHDkMKNiFiaHxKS91lxQSVFPYEScnktAAALKPwGGWZGgJQnEiXGAACgNSyGIohIJKu512KMSY3sZctJVfXwEAtQjKbmEhFaA4Gz2p4VrPyrMQYGWsV2eVUfUlAg1uI0zqudz2eJiJEIp1xaQ2QzDP8W1wuACAMEAK4qC/1q1oxv3HzxtTffevOtr966c6cej3oA3/rNeu4aE2Pw3tfWUU09+U3LqzYeTi7PesTwwFBdOcObUBN4E3qIsfMjGkkXJpNJgNiRvzE+jEj/xQ++9V2oPhndfBygqtvGu66SnsQajE66znOEvppIv3Gmrlg+Xj36aLEAebqtKm7b8WhakesXrUQeH04Ase82f+33/r5O/699428BwN/49/9XcGCZ2FQIMTa17ZG976sOUBAsWYx27QAQQheYrTWwWiOD7/za1o3YOhqI7J0NzrjOgzVsTW8xDliPm1SxCgRTDJFDiIFN1YzrMUQG5tpUBonHsZ96lGitHROByALa2lWVdQAQvRfGKgTqYmxMQ1bOFhQEfAi+B0JsKj8+rmYzvnplHf20A7C85m60tl0keOmar/2D/9t/dvD1L57Nq5Nq7ENX4RZRcahoFl5eWJ5eMXJRNURka4fspjRtBfz5HigXO7SL4/ach09/VQddlo/w866S+Y4DhgAAhJTQbgafoha1DdR3yFlNex9CHigPZrEzr12/RplLAxQjkDGbfoNEJ0eTG7efefrlL33y6SePHjwc2cpZYwi73htnGcRzgMSTkjmkgPaiokjQoNXDLijqqdVNEkjVlTo3DmycZeYQAhhCg8xBAIhSq42+7zU8aowxJmV6GgPGUIyx7ztr7WjUKCQggEq9KIRC0EdPRNYayp57DjnRBGJlXAgBIk8mk9PFnIjqURN9UEGmFFYQg6J2rQfsfL/pWhFRedGGVeUaAPWaW2YUFmOpYIybQZtWTLE5QgCTRXnSzOIO65OEb4RgksgQIuMcgfR9r3AGe005QHVBL9ZSjCwiVFmBGGNEIiJ10DIPgc0B+hAky4ssd0yMojlwwEKARumSyBhD7INnRLSKcJ1gu9EWS3pwZgAGJ9MYA3Hr98ZUzgNFkOifVKFjjsOg0RB2M4VssJj+WT7lqs5kZ0cvGkYCAQQkIQFC6Lqggbdc7ITW2j4EC7a8rnAZY4wWJkqK+YBKZSLqOaHHprtZdI1U1HneomgAgEQmMm3b1nXtjFOaVh8DMACnDMyydJpAZIyR7MOAHCRK6Jy5ma02DanrerPZUL7SRp4zniDnf4O2L8rOEA3AcNJf04oN0xqYUzGLrrCCqOrbA4etqjSoUCVrmDnFd0pNFzNycSElaFvV6+kJllztKs7V86oKAEuMYVh9A4WdAEDKoDoXTUMERQ1Rt5kyVkrpvsMeuWkKnGgDAEIIoe/17QFFhKNEC2SNdVhBZAh86eq1V195/ctf/fpzz788PjwUQK3HcbY2oC1aQEFLWZicccL2bGlO5+O2NRy970Ri3dQbDnXjuO2EuRXfx+BqE5hbO+qd/eaP/vg7fXfvYBqcP0bLkaL0lWtcZFj0hmJTOSHhZdsaYACDdDA5gvnKRmM8AMCmawkYSYDQS4xB/odZ2yjXv/U/+/f++v/jP0WqGqw2PjoyDgkrAlsDiHjPzDBza4zijHG1jOuz+dwyT5vpYVVLbDteIhKBs61nFD+2LnAV+tRORX4d8C+syPQCB5ERCW0jRiJQFIgYA8dx5SKAcDB1ZYiAiLu+67rZ0RF3fdQxAOdotsBqI6s2rNbQBSLCcVXPZjAb08EUqspynBqCugrRE9lmegjUdOv106+/8o3//G+1v/WPn/8z/1I0sbImMA9jpkMboFBUIXLYOs8zESLsETL+PD9HeeZnfz68YaudfIYv4vNdT3rvedXh/NuH95yfIJ5XlQaXriflQLYjc3x49PTTTz9+6ZVvnf4uGBNCcM5ZBB9DYq2606w9Q0p9AGYbNdWaZuQ2Idg2uChDYmbIwhiyYEItCsvbWtQpKQ5v3G50kURwjslAFucxp+BATqrTPk0iggCrdjMajdBQak4GW6fyVpPLPuZhUjwA1HWtiktS/jAXu55ffAQkonMlP1tNMSsNw1mwsPYpIxZkEcU1QVDgkKEPWwdgySVZWbnFYj6djYmo7Tprqwtpfo94dGyqzaCAIYOIEFlfwQgiqWUdEaI1ohiSEWyR9LIbGdKcSRUnjCiSgwV5OFJawaTtREmFCFuwJh54LyB9K68UbmeiPAFRlA1hqq3QKaEIANFoNFqv10JIgIo3ZSySQFGAYGCFGGMQNKU1KaFIRAZJt1JnWoo4EK01QLjt3AFYFsRHVrW623QaSIKcaajeJxZBk4pLBYRDNMaUZpikrXO0rXGMEraJMiKyWq08RyTUBKqtO07rHfIlKRsWEbGowDjoMDKkiaHuJRoIVNw7xNSNDCDwtrkO4tamg0FNaTmWW8JCJIWayGEa/c6FPCuld5Rk8mwyPYmD74x58BwryJC9ornWqRTylAZv5btati3ZsFC3irV24zuQWDd2VDnf9/0mXr9646UXXnr9K2/deea5p566Y6u667rI7IhMXXFM+UAiQGSEhTkaU/n1afzkXvPBXSet6/veIAsycLAOWSrToEWsHU2RnSUxJzx7+PDutx989HY1/aRuGOIEpQcQAu97J2ZCVURYQRCOdYgV1Z3hDbM1xqNtRhOLFENPjesRmqpyTe2aETp74TJO/rUf7azqP/gXPGJbYQCsYjXGCr2fNTVUDrwHMQdmtHb8uDZ2uRwROjFkLaDjCFBZMgbYk7X11//d7C7/9Sn8uvyj/5CtVxaDDMBswAAaMK6XtXMOwYWu27S9AeNcNZqOwbfMIrkjQZQuRh9DZB8wRoqaGeZgNolHU56NuakAAMha5wCg90xE4Dk0Yo+PT155sRL7/b/zD6699Mbk6Wf71mNdM4BqDgX7rvAiOC99JQeqAWCQ6w0XSaPPeZ3XLXbeuPvw80N6whufJPsvHlththco7jvvvUDt+Aw9o1yZPyBqjz2R2cHkzp0784evvPvue/c/vVs5E0HQAIgwxygJdFXTQpULEUDIzGHv4amvIwAM8ugR0RSCN6QedFH0CDFD027LCraxipSEElQcDRZHUvAdRMRqu2D19SqrBM02NaH3yHJwcLBYrzrfkxhbuTjwHA+XEfMSUWbR+vyKMl5FaQyLzIwCMZX16cSNaIBDNZEhS8RBTcNw9xFRcsc49asVUFACZEhpD0OzFgAUdgsMEUjTNMpYK+cgK1j6+vKWZGvuUpSIAAsZY41FxIhRgogo4nLy9gkjoQVkrfrZIo0WeVPeoV/VyUnxrySAeAAAM4AVxcE1XKni6069V9JTB5SNW1+limihnRZu2gKl971ksCzv/Ww2IwPr9Xo42u2uZ8EMOWMggjAHw0iViyEwiEEEQyQp1iSEIKn6uKSYq8ZjrdW2Z1euXFkul5vNxjkXQwAt4gVCSokjqjdF0czr5NtIuSm6/MaUoJLnGNuNonZqN3M41xEXdtG0RHKGJhUXZR7wOYNMf44xFTDrAxXiPsaY542qcJR186ngudRniu6dRI7CMUYEMsZYMswsURseXvDevu+10BQRow/qSCMi4Z2bdcch45uR7DyNiKKPABrjIUYg9ashaHmzOluKUw0R9X4sgK0ICqja1Na5OnTt6dmjyWj62htf+PpX/9Srr7xx6fZTVVUh4mq9jjEmnTJGzWPTw24AY4wsTETzswUt1oebrvJroGjJgTHMXFU1r9pmMo3AUlNjq7jpD91sM199890f/5hwdTSNkSwYzx6NrSKtIgODB9NbXDp0FR240XqxxJkZWdOGJdTU9l01njQnM9OMMLAjZyK2i/X/4Jt/Cy66/k35tf8Yf227F3/uH15422df3e/9FUsVgvHtxlfjyVf+nb0b8J/7H/e/++8TkbEkIhAjR48swmwiikblRKxxwMKbPvo1OIHIzlhwDiSS79EYY4131owamk0AAJoGDqYybWJFFFgIgUiD63XTkEBcrT2Z0eHYXz556tatH3/3B7/3G//gL//b/zYqYLhGHxSbIHPl80pAoi4NeCfofYByyD6H0H3SNTy5haN+Tq3l/AkaXnuK+N495+e49+rzN5cPtnmDACWgKYqAfdHlYyAU7foJACEEdXJcu377pVdeu3//PloTYi85yYxZuT0RZMcGSdw1QYfPp0EzDYGdeyT7LXT8iorRdxF2Le9k5ySLdxt1SukaOauDB3VEImKslVwCi4iU360Om77v5/N56/uqqYmo897kddsutVaUQDYOJRftAABCjBJCrw26ERmTXE8ovmnTtkPa8cltZUFu5TpYt634NUgMApLiQcAiyroHK1xscrLWe4/MRO6111779NNPHzx4wCxVY7YvHeyMwSzgdgkp9eZI5IOIah+KepeEtdhDJ2ZQgb/2dKjhgSmajp5hKsjTKRIBkE3zyF5AUDHxB86SISXprjCzJg5sR5nHsCWXpN+oUcQAoN2qQoyIOB6Pn3/++cXy7Cc/+Ymtqz01MI1HpXH2uySaA2lySQyT9nhLnhjZpdcSuKGMYjuZTCaTyWKx6Pu+aZq0XFnBKnvgKqet7VXB0poCzDRFRPlLCfVrqKJpniYjQEldxu3WpgmafccgDsYw/BwySN9kMtHYzWazUfFMuYI8ac15I4iIchvo4cOVfaRyT/V8ws+5jDGapy0iKd45cFSW7QAA4K1lGQGQEgUnewViFBbWFF31b2gLASCiOBhk5kQKvsI+BB12VTtjDLd96HsieObOs2996Stf+srX7zz9wmQyW/d9pygyhipjIAeMYBffBRG1O1TX+Yr5uG6quPYCxMaiw9oIII5naKogrfd9Hdl48r3/xqN3/rY/+/GVo5WDg0gYR734yvpINHYVMIY+SJTKCzG0fWdq6JePLwUZd6uXRkfthx9/aAhC59YRA0+qsWtGbYj/08PX/oOzH5xf9qG28Se+6q/8f3Z+v2izq6//A/nt/yZAYAmMaKxLbro+gqrOTGABvHAMAb0RI8yBhWJkDiFESwiuUqjjHjiAUO3qxqKAawUjgEFwxAQRwVQORELo+7Olq6m5eePo8qWr9+7+8Ju/8dqv/sqt2y9QccdC4iSYS66Gm1h+SHAIu5I96/O/wLVnHuy9BYYCKX2a3rTz4e411LnlCUftSZ8PX7rznPLFPIwCdlG+WKb/GaebSMF084mTCEBNVV2/+dQrr37hpz9995O7HyiwlzoPVOCRUBKBIpwdkEMRM2Rie3MpvyWuzpp/lmoUFPPj/BPyr9sajbQsqm2eW/ikGRUvr66MSAHVaJrm2s0bi9VytVl7721d7+1s+jUJNCiOYx1A6D0PIIKM0WRHwAFQwlDyDpXjHbotihqUhnAAELEQVp6CctH1eq18GHOFo0pSETDGAIj3fj6fz+dz771m1F4ovmEgp4YfK4yTVuLor5DX0RgTObVZ1dkZhUPf2+DhhFNxMySUme0NW6MUWAIrGkw6yVEtT4CtglJs5VI2Uoia0CLEwRuJmJT0CYykbqPoKici2vJ4sVj87Gc/i+zrvOvD8SfaSsOXlAuST0haUHXTiAhh+n24jDkzBTPMS13XIYSPPvqo73sV3nVd6w4ryGZKxdztAIIykKbFe6Tp9ISkBSDWpPZsfssdPEfNoMQB79DFogJat7fxcadFWTrS2dRLdZQZCFXVji3159AMM1fWxRhjiIhoM7Iex8iQ+qdolA61CZ+1BehsO5KcRhNjbNsWc5QtJYEOmjOl2aVuO8nDiLkZkt5Wzybeex9CzOo+AEhGnFP/HA1K8MmQJkEbAtLIYvC+70Ibrl6/9oU3vvhLv/ynnn/51Xo0DoAehdDG6EWESCGXhYjquunDTnIWEQEaEcF1Hxcr36867oylKloAiESmD6PZ9PFiaWscmQoRN4g/eP/9X998+rOjg49cBV17uRotPQQyImtsGu42vFqOyY5N1a98h+gODx63i1t19a/dfO4VW92KUr13l0Zy/NwdWYZ2sQKqZicn1w5mthkBXKBwhG/8MtcNI9Vz301d88v7eR6/8CW//qTPn2S68+//RRHxHNmzEFSjUUPTsOpkA8EHEhBrhYgBgQwigUEkERRGDH2Qv/jn3N/8/7ElIKJRRZUVhAA9GWOb2nVRNgEuH7mTyTHCR2cP//Hf+zv/8r/+3yGaokVlLMODUeoUYKAmJ8EzGL9Izrn7E0FmXciLL/xkcP/OW4bnCHdNyV/oKmcE9gU27H64Y7HsDXXIn/cuItDaku0TWIzBS5euHF++9PKrr9399MMo4sh477WBFUBhwHr/Tt7CnmGjqYopjzJLHACIIIxAW+ZmrDXe+xI5UWaZp7bvRi0/h9SldgdsEAjDNuic/GQqz4wxq9WKiI6Pjy9duXK2mLdtOxmPedB243NuVmJQWqOHCpmaet6KCjzZ3vakJ6SRY4I2KegVikySnpMYKiDJpUuX2rbtuk5ENHEQMl6IWuOR4w9/+ENrbV3X1tq27zin5A+JgIVZtvRZfpAs+FTSZSwKAVHvAwMLkcKLR0Kyw++XnSMiQWRNESXCyCKsJTwAycTUrdJgESBCwoNLMCDDEyW7CrtIRpxIowYUs0294aDdRIyW6gAGEEJ87rnn3nvvvcViYYw5PDwMIfS+Y2ZDDgf4UWW3jACkHiLJ1aH2MktQ0HNGFkgBEWHGAKiBFUjeiKyjoO5Et+nath2NRnVde+/3ILyUFAhQe6hqFCb0HrX4AsBYq5UvjBBCINRIdt5axIDAIMNmj+d1STzHUAbMdF/dLmrHZrOBrGQUlavojiU+oo6cvedgDhxqIRnCdmX2tO+9gyGK7MIpl6IAsVOmydTeJdVfZR032x+aU4UArqoCCAiDMJTh5chLyfihZF6A954lWDKNqwHZdz0D11X12lff/OpXv/bWl756eHwFkDgKEkTfk3EsmhMOiCCEEYA5WjJBNPM8eTIRiX3oPvrUP37MYbPhVYO2sZaZl7FvxC+7FYNUYGqQNcIfnt79ndMPfzia9vXMdQG4WdvQ2nUjMG478/jxpSC3J9PXn3/u+uzknbff+0f3P/oINoS26sPzaP8bL71m+1bGJ2uMh8/eduP6wSf3NoulmRxUR4fkqr/+L/93/3v/xf95uOz/0X/4vze3WiMd2AbmXX1Yrf/ur8bGuoDQegDAUeWOmq5BuHdafe8jGjXrF6+5W1cdjO7+zf9s83/8m/W77yKEm/DXtg/Fv3CxzoF/4YIPAQCAvvR3n/Qn+Y1/UakKGCREEUFjgMQROZT+n/szSs3+X/nLAGD+zn8pIihgEFkACE3TjEcEIBvsjp+5cfRte0Xwg29/59Mv/eq1L7xqGjSVg9ywQjR5/wnym4dNUrNzGrNTZGh6PWkukN/yeT7fO1ZP+spFN1xs9/Mg/Hr++pwqiy7vMJ1u+6fP/CJzJEkQICICAlVVHx8fv/DCcz9775mf/fTHiCgRjCHPDEDaxjbXKlqGUBjIcDBJ+Ce5CzFzBBFhiZwTgKqqms2m46bquu7RfAHZOoTMedAQRx6oINvtkOxc2b5dXarISGiNEcxA1QCIuOm7atSEEO7fv//g8aO+75uqBpYEAX7OK4a0dduUJdV1xgwfoI6OLK0TH9vWGOZ6iyGb3U5Bbxi+EZNjD7KDQScFHAXMzaduPXr06OHDh33fa9/vEIKazWo6Nk0DY5nNZn3vl8uVrbYhGNwRRlmP2SXmiGovYMl/JUBBPDw4QMTVah1Cqx2EIRJpTZHOKuWX5k0d0mvBzoIsHYkoCMeY3PKavVkGkTUA/UHFNllriQg4qmDbMy/KHERAohRNlkGEORK885N3N5vNuGlU3+y6rqqttTYGLjkHJQUXEbVy0iZFUpElIiACZkdLSRHV+WrTPPWlFT0XAQBijH3fV3U1mUz6vl8sFnVdt9EnNNItGaRrejCrqmo5X/RtZ7LGV9ZWUo21MKjnCjT4kk/Ljg8QtwXrmeYKreM2igiY2yapziZJOSQBSf1FoRSqEFHTNN6rWU/GGGtscYGErjfGOMpdjFmstdalEXJ+FCJyiCGEgri6d2mRLZoMYJrjKZFjKnOFtL+Yk/uS6qbnM1cyr9pNH3wIAY2myWwJDLMtkrQ9LWu26D2LSNutfdePR/VrL7/6xhuvP/fWl2/evH14cCX06H0EDMBBJEYEQjAGNUCDOQILSachEonMxhAAhBCWH348jnx8PN4sznq/idgAYSDfY1ydnV66dI36fr2Yf0rhdz5854cG7h7ekc18BtaOZg/aByO7uNbKtc30z1x59mmxt6vq+cOblyfHvz9aLvHBQkJzeEL37z9+dG/Dm7PN42uHE9kE34IjaKKJHuNivfapPkcDKP+m/Nrf+B/9z7uxNZcjNLxG5Imwjdb6KoTRHCAwc+TG2cp4pmYlgPXquSvN0aFrRrzo131/fXrz4cFVvtkvYf7Rg//TzNSP/aYOwjC7CTfO7+/3b/0nr3/0b1y49Z9x4a9e7HHpvvkX4Jd/Ze/D+Jf+PP7Dfxh9R5VlNCwBAzioOIR4ZF/60hvxe29//NG78eHpt/+r3/xLL70g1kEGQYHMtaC4VMsYlFHmXguF0ZEAapPkwW2fU3LD7qMunvtusvzet4Yq/vDXz1YsnqCjbJ9TbpOLPtx7yGc87fxoMftpNOo9qu2Nq9c2q9MvfvGLH37wM63vo2y1AQCCAQGRoEVwhpwGlzmlR4JoVZ3bQg9vzSYRzRaS3BTNe98TqCl14aQGyyjDFS6CPC1vyn9DADTGkNWmDam1FcG2fxMRteuNqRwirjcbdRU8aYmYmWiH9e3KOBGJIsIc0LjiK9puxGATPmNHcGvVIwICocJHIgBKVL/73bt3u65T0cPMfd8DgDGmD752FQBsNhuDNJ/PEWk8HvvoIbdXY2P2XreVUyLKtCNHMMYSgWDxsgvzjWtXfB/ZB992qAkLkQGj9aGjQSYHGSACoWBAAaZyNMSBUYyNkLJtLBIR9MmVg9ZaNThFIgMDorXG2Xo2mz1+/Fgn7DnhW8ggRt71XY+k2YLqTyGTwDAwaW1iDfq2c2QUS1UTeRCIo6A1ghhS/augyVksuSgiOS3yhmMBtxdwrnLOaVDQEyjMhudo0ao2oPUmRCawdF3o+zgej0VAy00LISbaVVchy+Lxme4uCYQYEomz/gOS+67p8xUyEiXpPVpbT9ZgYBHJvYOxVJ8KpjQOUPGfvGcq2UkLX0kRLwBYJHhfFDIlaAKUyMBiySBg33Yet30ohBAM9aG0DpbKWVfX3vtN36Ghqqm998hQOdd1na3c9rtDhougVUciYgERwEYRhqiDFzGgicxIxpA1xBA1wVZnZPQwYew9iTig2EcAQENAGLR6mZNy5tvu5p076/V6s9k4qhmlC+vI3VPPPPPmG1/92td/5c7tZ6fHByKy7juILKhfJASKkCJww4RdAGAOAWQSaQ1R0KCPpkFZrDa+PbRVWC0tjCo3YoF1bE2ktqIrowMi89DynODb73z84zj93qUTBsTJpOvnZv7gza5/jes/fen211584ejaEd59tAkb3szntYzH8ozE39+0a3cZq4Pvteu/inQVm+XybDw5oL4XjAgMwK4eu9qGEAwmCvyP8df+xr9HrYG6qmzEuhl1karpgVluzLqD6TiOLBxMCA2IJeNh0fpHc1MZaYjHDH0/rqi/fQh/+Wv9dw/lk7ur9tPJ43CtuvSgkepXvyL/yb+K/8b/csh67uEfLXDxY/g1ABvAbqomXL7sbl0zx8dHz964/ddvPYlFPumq//SvdxcJa7KEDChCgUGQOQBZgm60wPUXv/Cip/t//T/6+NOfvvOHv/nat16+9cu/ZGl2Uh146YwztvWRsqszx1NKjYDm3g0tNm15eA6c9/ywLgggYnbR7Qm84W1J3nCmMNj6UQav23t7rgOH3b4Q59zST3pO+dO+1JLsTsSL33ves7L76bbLKUBEgnZ1Nh6PD44u3brz4jMvvP7Hf/SH07qO3iOA9v0RidZa9rFu7GbjgXzkZIsCYAzZkhHIIKUoCosJiAgcmdASEpIg8GKxnM+13n6gbQx6YmjHFgMmRhbhw8PD5XJpjAEOBtB3vSZUgoBC3PkYvfcUI2lfTURNiKSkPVAQNk0lIpFjgRPdMlUidRKrUHbO6ngyYLpUQMZYAIgixhgBYAbjqlIRWZ6mq6z2YQnKC6ZsiSRuxJQ7k1YnBFFI1PvL6tMHxtPT00RIg3ItRDSACpHgjC1/ijEIMqKUooGytskzA4IkBo1WLmspCYcQjeGgqJjR9/2dZ57uu7jcrF3ThLMzY1yI0TV13/fWoiUiBo3ia2v4lPhZiLW8W0Rwt2cBIhpDRBRjJMrYmjmMqqqoBu9DCIFzutAwIw+JmQ0Za20MAUpZUQaUHUbry2ErbhiODMmD4kQkhMBxu0ysgBnDLKGBOq9RBkvGWsuSyjiNBsnyZqtLoKpxMplaa+fzeVW5bY7MQG8tRB+FU+qaNgzKQ1W7mRHVJ4EpPwaHUBZJi1Qcd9iyu/R8Sr1O8lwSC0CAtm3VU6Lxi5LlMFTny5j3PpeBD1k9lpThYpi567q+75HFWouG+rYThMo6H4NzjncjsjtPRkBIveNJXTdEWqSzVZLzGq42G2OMM1ZE1PvinDN11XWdgS1fhhyRISIOUWt8TOXm8/lsNpvP596HGMPx8aWXXn3l61//+osvvXrp5JqhKqoDH3YwlIZj3lsiLYvTVDIkICFrjRBZIotgAL3EyGzFOOdqW0+cW/d+Vk9OHzz8g/ff+y3YvHcyqyxt+nvj5frpnn/58OqvPvv0CyBOoxUAAQAASURBVNOjCRKJrBePZ4ZqN+ooiODBweFBPR7HjYmxJbzb9T/42c++fnyl871hPyboOh88O1c756y1gsB+Kyrium2uHNYHM6gcIY7JQfDr5RKD1NKY2UFvEIEpdHjm+9WGrGlmUwbwnTdEYKl66qlLf368eeVO+/7H4cMHfr5xo8mtk0N4/Tl46mT5nf+du/+o/ov/i/vPrfv2rL999bC9GroeA2MMbdd2H38cP77LgPfBfLuqZTppblw/efpOc/sm3L5qbl+Rg6PmYDr6F38bLro6+bULP+9/5VfN734zQGQA49A5F0M0BxOzCVOx+NJzr//Kn/ru/+sub/rv/O7vXv3SG66ehRDEovd+VGmiXCibDLu2IzxZzP9Tvy60U4evO39O9UPhVIUBFz0BfkEfzD+7i4jatr11/cZ8Pn/zC1/89MMPMIZl19nKRu8JgCMHCSigbvzIfggsVUreEz/J1iKAuptNCHGH/4MF2gmalG/ptU1WiPHgYPbUU0/dv3//7t27jauM0cyhXAAhonYsIIMIB3Wqg0gAwNKnHqCEbnYUu7JxWXka7IiUiaSsEU1E2+61QCqkwW19KKZZJa3nMzwc+hbezVgo+Z40aFc7vHaU7FyZM5ApSGQTGCkIhH32PvguiIizBgAMmk46LUX03j9++Gi9XOu7clc8CBzRkAUhURkoqGWewrnmcOCYQsw1gvq+/AMJlABEvhTcM2XkbjYb1ftijMBcrPNyGWMwRCAgIi9SZJj29Evxl8FUz6v2KayT11E9B+Wvkh316QY0ggkTrA+BI0SbKj/V3USpmQuw4t8Rk4Ug/ez4Utd1634+amZegkGXJGZ6fiaj7LBNQ7UGEAXRJJwjIBGF70j0JCAx+ZJS10FVRPQoZRrP6eNCUpxo2TYRABEtQNX5RhDJCGM0KIqBgXO1IB0l6syjr6zTgIu2ONJnhhCsFiABxhg187xt21HdxAF0jey6ZDHpFZpdvCWkPf6o0c3j4+MQQkn70GOjqGicUFC1qxAiIGe8E32jc26xXumYnXMvv/ba1772tbe++OUr165rWrFglMzfEHFYBonnDNYyrrRcqd8wIqKPfb9cxt4rnQiIBCFAS6Yx9cP1Ywjxw/np9337IyeL9fJy1/5LNd6anXzxyvXXT65dsxXGsGoXi3bTOxzjhKoGGX0v4/F0at2hhwcRu8bcZ/zju5/8ys07dlOlvpKYWtmFwEARkBiKKAUjaIzlGNr1UsBO6hGs1tgFMx3zqKam4eidCMQgD5cCYk8OYDIWDgbAOhdFTOXg+VvVM9dG/Ruw9HD3ge8DnJzwAYQ+VD3LRx8/+ku3xfzYnRzXk2m4uxDTCrCzNA6h6TuKggDSch+8f3QGj+br77/9wFT+cGaODo/s4ej6ZflvPy/XjhZXxnVjcOrojafs4gCOK8SLdQ7z3d8jF00A6XtkQMZI0G58vQFrKj911/70V978nd9/9P5P3/3ud//oW7/ztT/7Fzvp0Dpm6YOXKvkhy6YOyxP+maoXT3r0eelRhOj58cjnq5rZOXRPDr58jif9yS+JARCMqW/evLleLp5/7sWfvP0jZnFaH8oph91Yu9lsRlUNw3ixsgm180lyOgIiGu2ZhMCIJttWxY6yiAgYt1JpcKmhqBUZ6/Xm448/btt2PB7H3ocQREBFbV3X4/HI+2q1WhljtAhGe3fKsKX2ICyS7FKzXziMu5jieV0yfCKhRJFtNDzdNplOVSvyMQwrRFLqwtZhczGRSGatw0Uo/xJRQYzdH1hm/rwLeqd7gIjAu+gV5YaBwQtCKmjAkDBKAOecQbNarK5evdq27f3796fTqQbEVUxbZk6NXGLMhQCgHYH3ZHay1PmcwGBBEIsEklqspZJLQTRRA0ipmoAIU8wvAqUNM4bqugZIuztUGCGXV5SIQHlp0QeL80fVhbJVuGsWIO4oT5zDZkWmUsa2Kn16DGBkvnHrKWPx9OzedDo+O3vsnGMGDUJdsBkilLv5ZaICAWBhym0P9cm6ykJAAkMnwVZzwh1ZuL/m+Roui45f1x8zEl8hECyJmRouFS6etHJUdEH6vldM1aK9gWaJR2bmqqo0ElRVFVmDqTRLymnRgRlF58/ZnVEbMwFkRTR7LTXFB/DGjRuPHz9++PBh13XO2NKsJw0vr1LyiIDEEFQlVeeZtXbdtc+9+MKXvvLl1157/YXnXzk8OFmv1z4Ii0cUQje0hgojJ9g5h9sfQIAQIhMRR4kx2AjdemMZKkKQqAmJQljXdVW59x89OqjGDzZn315++h70V6T5M6OjP/XM7a9FrkbNdDpGEz9e3oveg2Dk2DB1YSWEYKsYuTY4BroMdJ/lE2fnTfXhYtlHqOoaCDAGERJBAmIfehC751uKzJ57FuMssIE+hvnCjRozGcW6ZoaaEdsunM1j692lAzgYi4XopTIVkOnYB4iy8J1vjTHTKLKJvvNyEFu0JvhJVfO4gmtHYX4Slxu3wMnJxG4MAFTGxiibLpU+T67UKH7EHn3s+mCtw9GsNs302rF97ib80ov4wlNj9vb7P4V/9N35//VvT269Em+frP4vz118oJgliEVnJxUgRJTKke0jGQORzzgcPH3zmVdfOvjJj04AfvvXf/35V77w1K3nkMhaGzYdkYXoAUC3ngcxEzlXZbCnLv+i1/Z8fe5rz5S68J6ByPnFHvi5rz/5lPcuY8xiPj+czo4Oj1988eW7H3+8WCwIpKpsu9lYUyEhEVkk7z05q9GccsYBAICBqDjIRaKAgEqS3JVahADiYKYXaBsA0DTNer1mZmURp6dnIYTJZOJchlFAwxLqup7NZt77drVJnlQxiGjIikgYgCAlwZj57YVLTUQSeU9JTF0qFZeDEqpkhi6EYmAzszYiLUWdQ/qUjIc2rI6BrLvs0V6RaMM794gtmb/nhAiRERFF8hgCg6jgGE4rrXxkjoBVJLLKzSvXcOgVs+rs7MwYEzilSzKzhRQiAYAkikSAGa3NFl4ZTUI42MlnZOaihYtqEmly2VnOTLt2LbIMgwjrxUpGI0T03juXG5BmAaaIW5DZAQ6xQPJtqnOoP6ekR+gLCDEj25yjEu0AS6Rf8d4nDK7BJSKL+Rowrjf93U8ePrh/1jTj4FmYjL0gMDGkg/JzlsR5+gMfFwFK1qCFBs9JWNoC2eGRvvsEflKmT86a7B5QXW2YY1F2plAnDQaTlxQU23tY0lL0Re+9EdNt2ig8mUyWy+V4PB6OZO8wCELCGcwyXpN5cz9fKK6y9957T0SstVVVASd0PGY2zpptwBhIgBGARUlF99p7P5lMvvCFL/zZP/tnX3n99YODI8KqDzEKjKsqBAyxxQx9FmHrbgF4IiPXmxmBBwq3RA7rNQQPHMkBoYHAMcb1slt03cl4dO+T0/ur1RVDrx9c+TPXb79+/XIbfNe2m3bFPkCQ2lZk3YY7lD6EICFU6JjQGJxV1WGHExGIvBT4tPU//vTu00djw8ib0KEwc+UqUGtJxIeth2PTdiRsrHV17dd9O181o1pGtUchibxcWSA4XfWP5/bSMR1NQ61ZYxaMgRCtIWMs+M4FkPk6PlpT58eTCYwq6KkCFGG5fnL05/7U/PaN9Uf32ruLsLgH5MYBG7DAobKxF4gEHs06dm0Uqpx57uroiy9N7tyu7cgx8LXj+fWT6uohN25953A0IvzffH/5G//3lsQfVv4/+Pqtt39nuAXVt/8xjByY2PUdREPOGmPXcTO2E4jCEmbNmCxeefnF5/7hQSfy0c9+8q1vfOPyX7ncOCPGOud6kNL9c3BSU9rTliOdiy3+k1+/6FOe9N7C8hEHR3hw/4Wukf/6Lw3zAUAI4datW2enj194/qX5fB76RVVVPRGSxJB6wWue2Y5wAQAAESDAmIstsogHlIREJiKabpnvlwsPMCL2uacBAFRVJSJ93282G02HN8YJSPC8XC5D8JvNxpEtzgwZmE9DnrvHLQfDzhYUJhc1DEyaxEligpAuGM3qwFgul0XJ2DYiyRFtKEmaIDIQN0MNY8jNhkZ1Mq0H3YaH6zYcMGRXBwAYxUEAQaGhn05EAAhg/4AYYzgDLqgYUmSX73znO865tm2JCAiZuWmaEELpFqsrlTrZwYCOy+oTADNrTMcMJqXfJU0QTCIeFQqekMSmjNRhnY8hUwjl8PDwzvXrbdt++umnSiU6pa2tbAwNijn3BPxeWY1Om5mtWq6p9zvslmsPqCebzl3w2qKsZI3o/fP5nCXUdXX6eO3spHIjNhI8C4Q9/REz1GshehjE/8oAaPAt1W+YOWb61AgF5lFpw0BdXkSUhHJ+wWUqV3QvyAGpPviiERciK9PfS6LWiVtKTbCcc0r3en/bd+NmpIqIc+5oNr1+/frde5/OT8/KGCj3yEVEhTsjQG2AUnru5MJjSOjvAKCZ5zGUtSqNWuq69jFoHnvBq1aiN8YqGopzlSAG5i9/9atf/drXmAwDRWYEg8Zs+k6EiWzMeyo5IpWI/FwOSp6L0oIIaRdYqp0lwNC2uaxNdRdh79fLxUndfHz30w8/+ehlcCeXbjx35cZTB6PVo/trUxGDo7p2tQhzZAnsIoYYEUmYJQRjjXHmYDZxj6OEjYkmmrpt8CePHz197Zi66H0MJhACAmuPJGa+8s0v6FAf/bfeg+ZqfTAD56IPwXtAhoMjrCt0aDn60xVEiN5XzcgcTqEyIQRGMM6BAMdorIPFqiV2AHYTOcb+5iEdTigwtB4AN9zDZDR+89XR07dovcEHi7PvvN2fnq0en8Fiye0qUoRRBRVN3Q13Mp4eTcZHs+q5m/LcdUQD91fte++TAJ9tGmhhiv7aofuVt9qffjr6f/6n8aN7o4ehexjv4+Qp+Hc7+bUaf+33f/VbJy/8jZM3XnLP3cTrl3E6E8LWB3AOPHZWxErTS2B78vLLz169+aMf/fCpO1d//7e+8aUvfuXOdBwpzKYHy25lt5bxoCHiwGTaU5EvJIZf9EJE5AsEIezGdIZiYE9p+JwjGYof/eRJysc/rak96YoSFcUCgKbTg5u3nnr2hRc+/OTjn/34uwDJLbqJmxhBiIKwk+1VppCkuORMUSGVO4iogeitgoKpx9tOi7GB0O373lqrFQbee46g3dlMyqkjVN4rwXsfQrCONLBMBoRTqy+ihMSq1zbamjdO5dFwFtuxSDaxcsydIDXsUHtYRJBIMzcTc+bc2y9fOzoxbv+UxqO60W628vCeC6lih96yNat1uZDxWAEAjABSqdpSQ3WHiCTpHylD0SBHjjFoN7Fx5RTbQxCMMQoEkhQOzMaultKqplN6dgxV0Rgja/tyRFdGn7aeEMVA7q8FBUs+KYw7e2O2Csd8Pv9ERLdBkzb086EmUcR52drCKYYPH+59/jcRipw7cmlGmhWBCACa3qI6WlmT2lnvpTKuj8EaF/vgfc/Mtq729jKNIGuUDIJZliEiGMS4ddVIhunlRH0pCVkXP6ddQEpCBjSAikWDdAHjkFwtVpaoaZrRZOy9L1nK2xHq9pwPNwIgoo/BgIkcIXhjTCpejaK5it770PWeo77udH5mcnedsrzDI5G+Ltvn6zQFQIlNUvOLLcSt6vgxRo7cdR0aYlQNLG8KQMwxWtVHK8L1en3//v3lcjk7uea9FwnAnoiYxRhLRJ57LHE11eREzjfR2iMSZpbUVgiYebPZjJwd1RVF3ERvAB2RqyrbWjl7tFisTtzRrSvXpuPRZOSqqopMo0UHhIHDBjXYJwjcOLtqHZADjsgtOBe5G48bBxikdTJG59a1fOA3PKqkbz0iENmk/0UmDINUKDtpzNEBHE6BLLE0TYWTsUdja+sqI6tVXJ5JNPZgSrMJGoIuOIvWpTwnMRQ42qrC0IfNxvSBx3U4HGGFZt0Za4Glca4nAlvz8VF1/VL1VJy++HxYLLqz0365jKF1o6qaTcjZWsY8HYUQqAth2mwI6ZPTyXunzWkPY+EDG0yM7Tp+2rrDqf1XfvXs/T949B2enq0rYNv2sIAafw0Abv7Gt05/43f++GBELz978rW3Ln/trdmLz1XHh9ABCDhnwDIsu4jOPnPr0puvnvzgB7FyHy+Xf/g73zq5dvPwyiUUNsbEwRY/yUE45OD0hHvOY1P+07ouPIbl56EkO68hPelp//VfnqMxIABEtNlsrly5dv3GjRdfevnRvZ+enp4eHBwwJ/Q8773ksO+eFSQiJBQlNe/FbCsaMFEiIBcUxxRM2GvONxjP9GDWtm3newBwpo6hRySyJvQ+C0gjIpEjEVa1jSwAwRqLYECEo8bH7cDLLzKQ36itRXNlb0KSRNj6JHZVvxK6VcuHMQHzJkDqbNUnCJDsMJCL1Me9D8/fs1eQcu7O/fvVoYSInCofMd80aOoeVcomsGwonggQtMgCQQIaRC1yBRLEruu0G0Zd1zokY4wFiTmertNjRUHhXLNEu2muTyL9sjooAlt1lYW2ZyYJEkVVyV+tqkrzEzlfKoaL3NL8jNSjdXcYRIRQeo4TAHCMAGBIQRVAyz0GmRy4p51AyWAAcHWlklso8SZjDEsvwKvVqq4mwoIEAnE8qfuwO+u8LKVrCUnqPZgkHGHEnDwxUERCLjwu/d5Qk0xz8cq2TZrS9CAfdo/IMAOxxxj74GGzWa1WQz0g3TboDVuosHg7JKOCqsZZdL4YY+d7EbHGVFXV+n4+n1dVNayakexzQkTNDk7vwjRCAvQxMAjnTi6Uw5CcVextBM2QyZQAgyfrmyKApv70fU/W9H3/rW99640337wFdVVV48nI+w5T6S1479N4EMt6DtOih0s0JGlOWaogIl3XLefzh/cfXFqtjwjrUUOA2MWu605PT7sH7x9cun3t+jOj0Sj0y8Y6v+KupQChQgsIJGxAgng2QKOmkhGx9BwBBMF43znnKlP1EFAk9vFR338S+zUzClhjAL0W5hDZwor1Go3H0ZkYgl+vTazYIJDv3bQWqSD2iwWFYKylyWRZuab3JrKhBhh939txY6xZrVa+C7gOuOqlruxsbABx3oMnmQBveppMiAU2oQJAZOxDHAczbibXbk2EgBHEQiRpezng3kd/dzmeR4NNI7LpWu5aMdIfVTStrI927EJdSR9NPTr88q/0D83x3dNK+nW7gEWalD2hq9Fci+B/8NHy7fsf/73fO3rtlSsvPxdefhGfuRUblFEYjQ6papZTvPKn33rq7/z9Dx4+Pr585bd/8zeeffONN44O18uVOxhF73XHy3lPKoUh2ZXxFx6rP8GV1eKdQzH48/6d538e/iqlOmNXrd977D/F8f/JLudcCEERmbvgDw4Oji5dfvq55z95/6mzszNE3LQbERmNRpr+pc3PNGEOEckAcwoi01bQEYAmbSsKZFki2WojA04+tB8UokMtWM1LS/5XRATDHMkiEUX2MUbrCLdOe4kRInthJNoySZGi6wAADP0Nw03ZDkYysGFidCgiPGi9KYQCID6oZ30rSgBAUleKkiua8mVzaKa8Ds55uYbS7UIiKf8iDsHvkgRN2hgD847zKD9r6FxJuSAKYS65/pRAgCUKo6GRq1V2hBDatiVjbG5zhYhkEBOiEImeS2aOuWaEQQKzTRolCaIIAgkQACJzEERCY42JMXrfE2Fd2xgFEAQpgsQQ1P8TZNtoVoV98fADQNiCQOQbkussCdS6roQZUYSDegAANCCkddtARJIBZCibxSIizJR3lzPqFwCozqVEaYyNMYAIkggHhkhkqIIoa6Uc51zfB43WpJRHzalUeA8k9ePFGMlZypDeQau3WUIIjGiRmLltW0StiEqzc2RVz5VMIgqEJ7nDmuZAlRAjIyAhklHoK21dW9m67bu275xzRb0oCmJBoxtK3KJiq1KYDkmOKwBAZR0IKMxXBLHWIgt47iVqkEUzN7uuGx7C4lgiIkUKUeMmH6306iAMDEW7ZUXRRRCE1KyItrDGyhkcQLdeV+MRERLhbDL5+L33v/3N3755/RZa9B2isaqgEsTIHqnantHt+XrixUTIVAmKsevYk7Vja9oHj46dvXZ8iPO5+NYvNou7pyJChIfPvDybTiEyQR89Bw8ivWuM67DvN4jGWBtZBKwR4hY4eiBriDxa7HHMFY6rk+ib1pwdBNvSprYfzef1gpvGtYvF2NbaFBstMMtw8KZyPTOFWFd1O99Q5aqmrn0fFvMutHXlgCiGjtdz6ows1v5oWlUOek8VhbH4vhtbJx+ebUJPTYXTGpDDyrNBM3VkCZwTIEcAxAQAQQAJOgMCHBljYG3cQIiI/kHfLAOtJRxPzaxyD07NwwXzRsbjkRmDHUUDJBJD3zt0U+e++vo4hkff/IPphw/GuM2gOjl87myz7lxVXb96fOUkjMZ2NI7zvlrZNTIz0N/+Aay8f/Zo+voz4fDa8ZUTc++DmfBc4m/85t9/6qmbV65c2wRyaFlYcQOsta33tqrazhtkZbgqx7a8W5JBsqePDiGAIfUn2JVGgwtLWRkA7GoSRDvSolxP0n6ESjHazzd2d2TJ7sBKCkjxDaTx5Af8k7pwoiCDMFtDMYJvN1evXt5sVreef+vDe+uHDz6ujUHg1fK0qifeByLRqKsxDgBiiCJgTUpI1yafCsPGxCKC3iieN1HqDJbMm4wNMNyOoo4wR+Vho3GVED4JhIJ1pI1NqTKI6AEsIAuGqPIYCC0jxxi3YXGkQidJ0hRIp4FZzj5Kwro0Itp/kIgoooAI7ZZcICI6W3hv2TsiwsAheBExzoJCLWSgUjUFU1OHvMMxJPAMMqrGpWILzqUYksspUh2GARZx5AQg9B4NEWAXvHPOMCjGOKAU1U+Yg4i23xaJzAJCKeeS0WnSSYhUzDrhqqo4AWEgIty5c4eINMEiiuTsEinEuZMNC9lFseePKcun2aOCCSrf2i3Y1PAJSfzT1kQTSdE/GERwcqBtG09Jmp+wCmgtW1KCOO+0gMGh3ecLw6jY4IdY6t25fJjV2kHCqYiA0BBddPgQSVuRciAiSN/3IlJVlbNGXTspbyMmcJEYo3bTk931HD58+IqCDKtqQWkDQ0CQgOYAtUhERKveh9GTcg3dbrB7FS/l8P6YSW9ruhECwKgarVYrTfgtO1hCY4kDirqach5WvgpPH+rsacchMZHh6IYbiojWOWTpg6cYdTrf+c53XnvzrdffeBPRqAY5m0xPT08PZ5P+ooLyz7hCCMYZIm6919dtuvZsPo99uH//vjt7uJK5ZSCE8fFRMxmhM9bYPvaSbYgYg4hYhQyR7EkCBAAtLQagEELkqGipxpja1iMDtbFAwAI9xwdnj+3BmLs+Gqud8ADAGOxigcQEnIzG47FYGw262YQCYx983zlnJLBfzQlQjIV1V4/HVNWbTYfLlRuNDTlqmUOPxgXhqqntuAFjoveCYK0layVlD+UGzukIabmTZIW4BKw1icrbpuKmkj7IYh3XHg3R4QRGNViCLiJBFSEAU+z89ZPDX/2l0fVLi+/88f133oPvp0mdXru8njp8+bb9+pvjV5+D6Rg8UoDYo23IMfcvXlu+8/HqRx80keytq5NLJ1c+vEvGfdyEB3/0xz/9wh/hr0ynnQsmKmV67wlRPdV1lXJ6MNPV3ln7PNeF3AbyA5/kbiif793Bu1Uzf4LxnHvRHqP7Z+v/KG5RzG5p59ylS5eee+65h/fv3f3kvaPpIUtAND5EREIQQySM2/TMJEQCDFZJlcLMIAiSx2MwxwEHHrL6IX/bWYoi1FVal+cObi4uMTWQ4CLFDnadGVuzbdhFLfMyKUls53Ip4IKdAig9X/LUh4KGcr9cGBRwWGtKdYL3PsbgnJtMJppTX0oOOdfcEhoWFtaCTQIgax2QjewZBuJ5Z87bS1eu8LoBLjtoWiSZLRKaFier4LPq1NpuXMrWQZZUp7AvoQvbAfVhpb+qP0ZEAkciqoxFROackIFbhxcm3Mz0xQgCObVwj3SGWxJjht9H7n3rjNUcViJ3geAHwPycPVqJWTiVrcJsgmu4ARANkJbsMG69dOlOoZ1fz+2IOngkh6kQcTqdXrp06f79+yIp2yUlVKo1n8tfcUC4RfGCc5eCYindxAFYYRoMS9I2QCJsUzrO02thDXtS/Bzf3D8VMTWZTPNVl0bq5RuCCsW21Q1K7kEAgJgaRTPuWGA7pDXI/UZEzVOHXcsSOQfsct5PWYF6PHrvvfd+8zd/8/kXX0LEZjw1ZNuub5rmF1Q2AACEGcgySBQgImQAwoPLlz/w/uHp2VWGylWjcWMn1h1MTFNhAGHR5be2yrQXk0jOlo2euiCMRNkUgKICWmux31AIEaposHd4f3H21OVDO0YQJEOKOFfVtYd+O1ZHQITGBJCqdqFdVT5S04AzjmLgaMgAuhDZVo1QNwJENl0Mlo3psFqHtV/UzppxA6NaOAYUY62pHGO2yHFbrpOPWHIeiugEE5GQqlOziYxseHjmHq3ipoeTMZxMYVIFk7gvgnExQh8AR3B87L78hcmNy+bdZ+Hv3dc51f/9f3VU1e74EC8dhqbyHh0SjZoNzEfLiAbrLzxTv3x7Om9hOl4fV1f//D/32kfzb7/z8cmrV+6tl//47/69Z978Yjc5tAwOtXKt04Pgva+qakhVJPv+g71DsfdzKZa8UC34bHVBLhI557944XkcXp+tkezxTzwHhPrZ159A49FDnS1aYmYHeHJ4dOvW7UfP3//4o/d++u7bh7Np7721VYyMIgQmYko+g5xLzokvDc0hwYErGlIzBD6/R0PBMWTyw3uGAwZQWA9RxaWwuxJ1BQC13AonLUqAnGOVwxdt9Y+MYbzH6yTbs2XMw+HJwAGvXyNIvSBwoEEOX1cQPozR2DpOJpOTk5P5fK7aBmUsVEiJI+rAZyIy1gFA3/m+711TJWQlpGGISq3//OqtUxwoJQoUo1lnrZXLBGjIIGDbdffuftq2rRVSoGcGEMz5cSKCYhAodzBO+67/pQ6uGgHKCOJkDApoOSoRMYJIiBzVY6bwCzFbtIwIdp+gGQEHyCd7eaaISAaMISLb9y0AE1Fd1wxbQklEQahjHe7idm8iYyJZPVdJ0zLaLgSBOVvhuPMEREQwRTuBiy5EVJ1O1RdmhsBt287n8xi3tcjIqdA0hKAKTNKpdXV3gdREdlIbFW4EMqhAuajQcwGWYAHYtoEu3j/MSs/wFYXFDLNndghaR1ROXlYEUMAZrYmx8/UGnCMiZ1LvFWTBwWErT8Ps4isfbk/74O3KCMqvCsFVNkWf4KwjIu2tXI9Hf/Dd73zvD7/6pa98NYTgrGu7bjKZrNdrRcT7/Jcq4kGYyCJS3/ezo/ELr7/KX3hluu6v8GodTkeukohYVULAkVGAyBrjwCKykLB6gRG1JcvAdyWa9GqJCMmkhjIskJG4GWRDMkf+4PT+y3Jzwsy5DR4AxBgvf+MNfZr/d1YxjEWiJYQQse837crYmmb1ZrU0BuykAbI+cCtxBpErZ9CAc8aRMELfwarrQz++dAyWQJhBjLPWOTAUgk9VSwJbbFy1TlLRnCBqaXcqqpIIkcCO6wgxLFZu1dn/P3t/GmtZkqSJYWbm7uecu70lXuyRkRmRGRm5Zy1d1VU91T29DXudVSPNkBRHJEACJAgNIAn6q58C9EP6IYkQSEESQQIcUhA1agzUM90z3dXV1bVkZmWtuVbuS2TGHm+7yznH3c30w/z4Pfe+F1lZvc20JEci8r37zvXji7mZuS2fgeGNMU+GUBgBEGaRgEKAIBFMAI4tV2b46OXBhfMAv5s24GefoYWnRYQaXMuOqHVch8UwCBFB66H2DYndHjFBvT9/8Nd/adSU+//FfwMfHdKlzZfefvkz337+mV/7dTeeRB+Ms1qlL1nNQiBY5z9r2YzHto69rGghfRrOv97PQ3E/kf8JLOWTBvSJQ/2Ev67Jufzwp9RIjjbPEQ2p7dca03ofQjDGbG1t7Zw4+ZlnP/f2Gz8O3NUxUXo2ogHgekBAjbJaAwKX6D76I1n964pm2E89PapzQI+D9SeefuIUR6h10JcPyJEnj2/L161SQY+D9QwFckQeSeJpeL8XJY92hyGJXeWXZQ/Slw7YvVdjJpJdVh0ouTeyRhWCELzecESWZvjNzc15U3fHneCIwrE6cbVzdIQkXXU+AFgmYKZN1F+JiGKMQUKEiCSotu8O3AJ6oqgvtPqru1xcxhCFIZJFRInRh8Dq11UNMfZyKI52AgAQu/DJnsa6fEuXK7M0UUAUiGmqitfZCdEVNaVr2o0if1Ov6edqboLIEmIIIeN/rA0VftKZDJIwQLKKGls/3T9gHyRECZFkCVYGkDNSempN9+uxhKiDB0PZUQKdsrk8dbxcZ4Ok64MdFJiItMHjasur0X9XX0YeHUneKWYeDocXL168cOGCBnN0O7byGGoaeo+QlsTTe0aHYZC6BO3OALC66pg1v8gGUANihsNhPZ//0Vf/YLq3B8Ej86Cq5vM5/pTaBgAUxnYDQ2RsWx+Yxyd37KkdmIxsNSRrAZDQGiEKqmqYjFfmfZOjX6mrlwuwjF/JP2TXYaJAEiAUY4MxjcG90ERn0aZo66IoHJm6rvM47UIQDVQlWAO1x4V3ZHijQMJmNo2LRt1qYMiRaQ6nUFqJAUKwRWEA28Opj2FjYwOcYWHPkQnJGCACQuxgaaTXlgSAIIRsEAg1jVgQkIUKBwZ4tuCDGbBgNaDxhKoyYTpJjBI8cDAUnKkrDg5MFF603NumcuppEYL3MfgQfcMt1zVPZ4GkBV+3NfgAjY8xOrYn3Aa4cvvv/sLP/aO/d2kvPHhrvrUz/hdf/5eL9z8iYA6tRM5R59n3t0JOq5HUR1vatdVz0GdQn5Ku8D7tfn/6lN3+KdrRztc0/p+q9WMFRIQQhTl4vzXZOHPmzOmzZ554+hlj3HA47uenwHLWy2S3zAf6I1lVI1gQ4Lh8PVil1bWu+gxHulyYLAUIUkWq/qtXB7l+fb3fMh791tqq9k/TsVSnRaNS6mLnCumnWfXfomIxbwQAaBzhwcHBYrHonO+iflJVMpTntN5HZo3Ma5pmPp+r0eEYdRxWVqD7eXmPUnbdF0PQpRxSV7rVOaehsBFJL/vcTQNzzkj+pr6Dlct0/+b/YowsHZQCIRASgTEmxJjR2vvbv5yJSg694ne66tF9IrSKDNE0TRKcjG0TJCZFASPrfdrACqH0qa1PLmsEISFCXFGJsLPjpU86SE25n8IEAADqrIqQKKAsy5wURF0iiYZuNMGTs9hlinZxuivLgkdahFTmMg+GmRkkp/mISD8VMPt3rLXOOeccJpsb5e3IZwxWo3ehd84lskReLp2k/9STcu/evffff//27dvz+TwTXD+wLr1xNTokD1KjRHPtpaPnCpc7k1p2J2l8riPjvWeQcVW+8+abL77wXLOoYwjqVz6KQ/wTG4cIAGRTFL1zLgBM2/r2wXTahjpEoEKMtbYARmrYEhCgEYg+SPAxRkK0Zhn73jc1YXejzdwk259irluExNaydbYqyNpyOAAARYDtL1D0nqrSbo7AEoQIgQeDAToL+7Ny5otZjVMv09oxVrakw5o5gjXCDIeL9vCwjcEMShoWEmMQFsJUiEcYEG3hCBI24nILmJcwnaTFdkmJChEFjRmUECPsHdpZDQZgYyBVodlVFKVEY5DQEFaFGw9r9GiRAKmNsWmbH/yWzst84fcMoCVCEPBN2bSV0NAOGICaAG2IKOwMooTQ1M308HAeCnvx7/7iE7/217au3XsGBnu717/5jT9Y7O9ZRINikJg5clL3107xpzFsHDVayHHyZvmV49pPeMuRdpQDrDGcY/s5+sknf+XYb/1ULY9KiRmXTmG6cOHi6dNnH7lyBcjMFnPnDFJy4ceUhUGZrvonYnXYIsKgflY8RgPos5r+kPqnLx9A5ZZaSCH/13+1ypQsEdbmePRda3+VLsEtf0Jdzaxjh3q09S+leCQ2INNG5tX9PouiGA6Hg8FAEc+UpccuUMw4i4Y0A0fXQR3iCrqISdvQAr/r9oX8IjX25/En+NTek1nvUf1GL4R1XS/Li2FP3CFiSrlAoxElIohgsk+hv9PJA4LQAWcFkUhEaCjzKOpg7VXT6S90FieE6DrUqT7R5A3Y3to5uXOaiIxxKkH1gksC1Omn/WDy/vbnDet4Jq9tWP5Z1bFkSMgDkPV9PYZndT3rQmuKSoyxruvZbCbMG5PJeDSSThtN4+mtJCIaSAlUR6lc25oiCAA5jpoRVB3pn8b1ifcw+deYoPQsW8e+eklbfTth5EFRltY184UBHFWDUTVAXlIF4wq15N3sD2+NcegEScAirelhkkB507eY2RDFEJS6YoyFBRL/x1/7ow/ffcc3dWiasiyPGqt+YlMdSDUkFLC2EMQ6hFEx3B5vFqawtmBBRoVAN8gRgo++DU2t6LpEpD7EEGM+AnlBs7VJeoZDJT8CQxEhiG8CM7S1nx4cakW9pmmapumXxvbbAx64ABJBsHSAgJZg0cKde7b1tPDQeAkxtC2oSt14LC1IjPcO5WDuisKMSw5BSNCgMaRuVUQABI2g1hOaRrhKFdJdMBATpC8RSeVCU9P+oghRhi5uDMgVaKxERh+BAaOAj8QCYLfcwJGF0sF4YMqCeya2QKKlH9EaX9BM6v12z0Sx4CpTmHlLu1N3Z2ZnvmpjUVTFnYVsT678o7/5wJlz2x/unrfFN7/11TdffSk2cwlBoledg5n1mOh/PcpGoBW3yE+gkNXj8xfU5D7tJ37xWGEMR2Tksd/6idrJsa9bUxEskkWq63owGDxw4eKFCxfPnbugOFeISM5yqlimioBCKCxPhKxK5WOFwv10jtz6/OQou4NVcZBoQ30QPXM79BhXfu8af85qTfKDdGw2XzPSwz1/DRoia47tvz94PHJFhx5VZC6qAkt/jTFqxc0MGJ0fywPTpMKyLBGxrusY4/b29uOPP55u/sIovO7kkxXRkPLzOzQHTam1mCydii/CzN57772iOE4mkwz8xZp8i6I1cvqmpG5vdKF7t+f+ASAiY0gkxjYgorUggt4HtAYRLS3Zq8hKVRjkFBBgAIkoXwm5F0yAiG3bDgaDqqo+vMbee9/4snS64ooXi4SMJFmjXCVEOaJUZvpI41fkMgAiDf8AxdAltNghxPWIA49m8UBnP1eqFREgQ0RVVVljZrPZ5uZmjPFwOtVMdEYIIYDraq9kUl4lwUyv+q/parWkN3bWDuNsn0AZRISjcGnSwY4hKuROeh6X8RP6A3cBzH3qz8SaAb7yYFQIacI2dbgumaH0O9HC3wqJIZ3G3acxHYd0voYuInVF3ekRZBJsCBhjLJxbLBaAaK0NHJWWr73/3huvv3ru/AObJ4eCGmv207VuCukASxABAmfqgymEKG0EBxGJyQizgJgYOAaJgWNQhTjG2HpfFEWMESCZFmG5lcfIABGBCBjYMgljgW5SjUfF0Jq2aZrSORsj+5VyhnRmqymQm6asymI85MYTCx/OF6EtrQVEGFaudNPYFhDNoGTvQ9PERVt6MdY0BsQSBla7g+TYGmMAwHtfip4HtTIq9ehm8crosfuRgA36uhnULYIJzsiwMM6iNVAHCBHaIBwDcQQsMcD2oHXYWLBoSnFVWE7NVgWQgZYhRmnj0Fi0FYhtwwFHX6EtimIWW0SMxpQHAG2ctmZ06dxjn3/2x//i905UJ+d3915+6QdXr14FNChiXNlFbvU0eAQ6jjo+Wah/wt8+WWYfZUR/cW3tGN6vfZpnPk3Ldy1mlhDVCUpEdV2PNiaXL1++devGvTs3d+/eGQ4GAhT9epIaLpEil0qGrFpoJFMaAIBKrvXxZ051VNNKFaZ6pnTpPJuSLQoZJgixf1PJw8iybE31UVkLnQubiAAkxqgmmSXn7NQT1ASv+5g98npiZzqizgfBzCIrYQ8xBk4RoJr7muyyGp+xVDi0BjiAcTYIQ2RjzGAw8N7v7++LCLCojL9v+cHlILulWOHkKUqqAw6FfHVXGHFrqASAKBxi4IjOWVJECmsYtV5vziNCAODACCgSOQv7lMgKBChgwGhRYAGDbuBiE51LuTAaGIHdZUhbBI6AjoxBYh9sVcQYF21z6dKlsizfeO31sigIMRAGkdlsXriBr305GDJzYEEHQtBbeq27BoIae56KHefVI+iRssJ8qcJhTFwt7Ati1MxHRIqPqxYnZiY6QtOERCsiPJsWAaD13hXFx9evI2LhHFsrXYESiSCCJuUni/eBiMia5CoBwA6LHlCh+rB/jJaE3uXZikgbfBbqQVhYBIG6FK90aY1MRP3SZdRlaevnkig7ZdUqNZOAxqhYIt1o6QKt1U+UFTiLlKOjo0Q1MJI1Rms8ssQYCdAQIUsIAQsrCaUtHe4AYoGkC5hSGywjJKisyNxbWyIDUUyEeZTheHPhd//wa1+9+uQTprJbJ3bYp0q8QTgtbwzq2tTM8KNNLBSMnmNBjjGGEoYhcsvGSkMMlS1bIz6KY3SIjYfCIoNxxtkSNAlIC7Gyd9YiQgptISsiKNL6piIb2zDH1tqinS2kMgfAC0sAVBshZFuYu+3h9HB/A+KWlIt5Y5xxReFhGfDrTmwVo+Gi9nLgcXPsBwC7e8XerEWSwkJpGDwwD60jBDASZ8GVrpkfBMJhNSmrygeWoigMIQCq2xgAmIGlAAOs6nV35YB0H1kya0WAVaTCGMkVvJhhswAAKB1OxjIowELNbYUE0xrQgvd4+7CUXUDb3rCFLYqqgO0BlzbXdAQAcQ5dAc7H1lssAJFDEGRXDXgwCGUBpiiYKXgTAkRYQDu5xrCzPfnKs49/7Y8/nB6Ot8/9+Gtff+XRR5790s+Px5O6JFjIAG2Nvs/fGWGpQiClxU2BYhl6qRtV/mL365rAW1Gjj7SfVs/QCiXJl//pvromwvOFK8X2rY42QpYR6zecn6rlWSdznSHPEQCMhDaG0g1Pn7148eKNK1dvvvT97wBw28wmk83d3f2CKotGAAEhxhgUDQh7UIQMCNjGlroa5tZaTJIbQFL9hP7Is/aAXSI0Z5ChEPvGReqAf3TF1Gqe7BzMIGKN7asmnRylrhKUWqklAXMhdKUSVOgmdcUgdeklmBMjUISI2uABYFgNjDFqaSC9nIeYEtIj67kjdYIwGyRjjEQUFg4ah6twJnpjNHVdF4VDRBW4yVSv40bU4AD1zKMlAAnRA0rkeG/3rkMLqKu7QgNEACFE4bIsOUIIoSiKpmldYUJsT+xs3blzZzQaee8RTMZ5QKQQApFJco3IJlcWIREJi/deoSTjalW6vnYGq4b67tclrEK6FkuKA1XBI93lu/tWdySM0VqgniMKsPdlWaI1Ws0LRBROSkA+ePdd74MaZxSbfWNjQ9Myj56W/r/9X5WA8vj7czyWF2SKzASaXGKdWySLfOi8EktlnI7pXHqvFxH1fGWyyOuT10pVyPz1jMqVJ8u56krXP/bAhdTBAiKKeic5+LinuKTOV64OP3lljv6pv8vcIdMbYxhBCwbmmWIP8xT1VqRdSUL2BNHqst0Y78++O26S8NGrYRVDqKrq1q1bf/iHf/j3/+G/bYtyMJqw1/z+7sIhyouOh22FHqlDd/h0992gEgDPTDEgiBa1Q7LSXSCCiOmWkpm1hELm99CztQKAMcYgAgsCKAafxOiMbcF43zZNI2YgAE3wc2jQkADUbXP6W5/TgTX/81kwxgUp2LAz3Ho7X9AiACE6a6wFQywQgyAHsUhEHCN4Xw0HEQHLAshiJznvt8h5l2Xl3C4TBlSFkhglMiCbKOhZmMEWOCypKgTBTBtu42E9H4/HYp342u8emoPaVQiA0Zq4PeHJ0AwG+aUMAgRSGnAEih7IFqpxS/WsgpGn4m4LTfAjAGenpqjuNeAJhgV/7uFHP/Ps6y/94OapqSX63ovfvfjw1XK00UosyWiYvDXmkwn7/9/+FO3oeiKievEnw9GDFx+6ef3j6x9+8MH775zY3Ni/t7sx3ohBOXMEoBhjv7Yl9Bh4dhlkTs6rEuqonnTUjPoJipSaZo8aXzNPW3s+ZyPCKm+/X/9HJREAMKdY5sViQURlWVprVTaHENd66GBYMc80v5eIQKBtg7qVVUTGGLO9ub9K+ae1/vXJwhXqx1TzzHK+LYsxpSvbpiUDrrB1M3dlMT2cXr58+YEHLjTND6fTaeGqwWDYNA0cqZaqK2kDR2NTnTcRNMYgUegyQdaWTI5L5tZfY5CuLLzu7ZImeophrsyyRBrVMl3MAREHVVVzODg4qEZDdUZUrgjeI+K4Gqh1yLlCIczatq3rmtCCrFBVxz95bYR5TftzgePoMj8AnZjRjYRVDYP7FpHVZckKAWsgrwhjynjUnqPCkiQkg5XcUUYA5hzqyh2SWH77Gung0Vf3KuCYZKuA5YoDqOYBivySFSaEZaDT6sHJS5Hfw0kzWFqPl6qPDhsBupwgAEE1AKpjhUVPtiRHKagPCI5rayuTV0AhImhJZqCJElqTejwaReYf/vCHn/38Fz77+c359GA4mCBiF2KL/e6Pfe/aauuv1tpyMoqOmBAICyqMMclu1AG6IwsSWU3fjzGrdJLyIEL2fXJgIrKIzOCMZWMdGQcU2pbJla6wZSGEtizGW8Vi79BRYWHF4WW3NjxZiGQMiCGeze29Q4gxWGFLrMGZEKOP4sAIoDHogzS1mYxYIjgCBAO49MxJd3w7DSkhI8mS5NJJyYMglMg5tghJsAlmHiCCjAqcDKB0wgJtkChEZMoCACItkJGiRKkNGBBb+BZ2hfeX+CLoY7AohQVDUU0pEWE6s7HZ3N2Hl9/3L1+bGrZPXpg8fGH81OXm5Mjvtu6gPvPAg6OvfG7jWy+cO2cO3OjN11599aWXTp99gLByzhEJ4jqA4Z97u5/s+ctRcaR3M/yUX/nzHVhmSjEGRmx9XRTFzs6pBx+8dOvGjesf3+QQ9XYuEKKCVCMDsEEjx7oYeqwGu6TCoyJfW2bveOQuevRJ/df0FND+2+ORzEforNfLV+MK9zvaf/9z6sUs67fatkWBU6dObW1t3bhxc3//YDwer3EegIRjtbyFEkLnfNA3lGVZFEXra0Tc39+PMU4mk75+k5UMESFcGQasWv2JaDQalRwgTPUrtnShbkXEOooxBo5FVQDAcDi8detWXS+EcTgYe++n06kxhpaVOih3johd5ZgQgcUaa4xZC4bKm9SXcGvqSA5j7HuVdOuyC2qNEPuraSDhlQxGw2cef+xHP/rRvKn1ljydTmMIRVH4ti7KwlobQvTep5iUyGjWFYU0Wu5/viKb+9FAOaamX8442zMAIAg7MsY4ZBNjVAmdIe77GkxaGWvWajcwJmUvdjpHGpga5ZhNGuDyBqxD68J+l+dERHQj+7pOUuN6GPvYi03J/ZEoyk03ALV2SFINl1u8apxcbpyCGKxu3HIu97lJhOQ0lFTxFVO2vRokQMFnREhkacxYbUsWgwDZzJYrIQGA9E9dUhBb7weDwe7u3lf/6A+eeOKJyeYWMyspkmKhAyjCvzGfBHCeuYwAiEDhnBkPoiUsLLG1QhFBmCXGKExElmwiAyQJMXYZwoiIXcVjkQioEVXROYfAwKwVAiRy6QoUQBYiw8yLuq7bJoitBgONwApxWZUeRiMDTqxhAGLhaR2nC+OMGALr1AghDMQCUcABCFmQtm1LGgcWYbExIhpkLRO9LnIkAyh1iVTQZ6mY1GUSiP0Iu2kN0xoMwcZQRgOwBE1AZ0miYUqarzU8qdhRLEooSqkKKCrZr/3+YX47+wANly2DtRAih4CI8W4T5gfhpTfjc68X1/fHUeJb1xYXTwxuzYdfvOgfOAF3Y6j96OnLF7a3P7p+Z3H5wXZv8dwf//EjD189eeWRNgqQjQ4MHLPvRwXSJ7Q+wd/vr3/57djx/OVoOUdfKp290wCLyHA4vHD+wXtXdq99eP3aO69sb+8sFgsgjBysKSIIGDJIkaOsLiAixu7u2j/pcP8t4w77QY9vdrJoNGF+rJN16YG1rrCHcL8mE6mX/NirHiH3S4iT4+6K2gaDQVs3N27c2NvbR8TRaGStbdu4PpjerNOQaNkzGWjblpvAzGVZDgZVWZaHh4crI+8PdFXbyKNSj8HGxsbOzs6JZgGzpHC0jddQDwZpfPvAmQuXLl367ne/CwDz+VyrLjjnnCu892odERFmIVrJtLKiQiDly1r1XZnCLYsG9Zbs6Pig0zby8dNIXwBAxSlaTS5Nj/UvSB2aUGSuffvmm2/OZjNTuIRbAFCWpYhYAo0bicAcBREcmbIs67rO2k/uP1NDf8zYhVbk8WfpuLb6K0MlzMgfS+HHTD2sHl3ZPv0BrATdLL+4+rsgYOCsH6RQU0TNwE4aiYBW8QPo/tXbZxoqo0Zi0NLzogmr6t1c26w+NgZhF2Osy0JLAJyjzLR/WrjTPBBTtmTqvBcmLWZp9hARhiS6UEBYmGOulpS67QHRamEOTT7S45RiOwRAIAefpqEiWKTsmXKuEBHvvS0LV5Uv//BH3/7mN3/zN367bZuiKLjbO0OEYLoej2/S18OUWxWFGZQ1AhMSggBwFEFAQo5gyICyLQBWID0wqBHNXdyxLgiZaIxhCEQEnXbbtm3btp6A7IDI+ui997YaFEURZm2FVhCLohhUo+XZGQwIC3YQvHfTBU7nHkVKZ40R50iW5MaCMUbCYJB8DCAiqFcLBBGMrPvVt1ysNexi7xMVIcrqlQ4FCAkjS91KiGZzYjZHwRkJgUKwtoS2YWZAhKEzbiKOYF4XYGE4iEPrSxvjQbO3VDji7hT251BHYIS2jTFgYRsv9omz5S89Ex8+Hd+9Sd98vXzvNluZ/9M/HLz1YPz1z7oHrwTx1anJI6dOvfLmLQA+sb155+aNl1588RfOnytODAtjo0Pw6wz906sI/7qUiZ+q/VSDzKzyz1c1wRQFyGVRhCjW2p2dnbNnzl+4+NCtj95hwRz6FlErXXZsVg3U3ZDM6oz6gklWLRmZpfd5S78JppqaS9AwACAMHFdWANOdEKEnSvpuEUkMXEBSfg0AdPyqPwzpjCJLZtKbTtM0RVEURREj60UaAGazmXPL2DLsW+4jp7sBITKwCAqQJAgR9V55325vb507d+5HP/pRfzD9NeQjiXv6p6qq2rbd39+fTqcDWbp1bGEEAUzSqNq2ndeLxrcDV41GIxFR8CpNRM0emf4OaP6kFZHNrS0UONzbjz6QNYAYYzS9Devvrqwa65aSrOf9ki7D0yD5Diit30/fP5TFdohxvljM5lojDZumYWZkKZzz3o/Hw8AcWBht4AicUnvXdIs8zuyez/pQfrI/7L4xA1ZPaXpSy9J0U0jQ1CF0NqpOrHb993WvvNo5YHOJZNXTuYjIGhNiTJL1CBRYKrnaG/xRXil9aIcV/WldaTg6x77QXTvM+XPqGWz6z6hrI6+g/qwOIz3VOlGjKlBU3Ly0L9S3xGg8r9Y90lwJNbP2ahbmMsr9HUREVZq1Hw0YMoWLMU4m48N48C9+959/5plnd84/gIhEqEiypL4//CSXCiTlUgsZaSEoKgfDmQhQlyhKSNY4LigEBcsSlhCZAAyAtVZQFeWVI6AzzhqqcZacjeKBMJK0IUTH1hrnXFkUVVEOPS725kyMhTE9RuEZHKD4EA8P7N4cYpDK4KBAKrSokWKriyFEAgEUAWBjrIRYlAWaAhFJNBYvZ0ut2LqW8Erc454IJCvrttyvRcMhQlng1ohHA4kgTQuRYTEHRCltGBUwcuLRgQBYEANVKaXDylRjNng39+neuBEP5sFHWxYtSVOQtYPRxXPNZNCWo+LC6eJLz8CpHf6nf8wf3/DDcvj8/uH1D/Gzn508/QhsQRw7HJjD+SEOqsrZF779zQeeeGzymREWEo11/zou/f8mtz9fVaPfMXPUggwBsRoOTp899/CVR29df+/V117enEwEInRWRosEwoLMGtaEmC4aCCTL4DZ9OItzRIQj/D9fEalLu8MutgxWWeixqklfPB+7MitCsOscEX3PANn/Yp9r9T/f2Ng4PDyUKMPhMITQtq0xpqoqrcSUvyuyrK8Oao8E7COZxrYdlGUIQTnovdt3YusNpEISkPP8EaErfLM2kqwAIWLCxuyVi3WFXcxmxpiiKAbD4e07d2/dvqP6TQiBY8qDbWovEKmDAFh2zimvzYqItTZjOllrQ4ytb4mOTxHuRzz0P1GiYWY1cad83K6tb97q16ULJ9aiVt57iFFEiqKQEDVMslnMBSkApiBoY5ClaZrxeLxmYoG+KXhVret7gvKT2vLtfG0bIjMRaX6KHpujmwTHESV28lIf62Ne6V9VBcnBUITIKmtXnRp6nHo6Exx9EUAKv8gzyn+SnmupvyNLAx2iARTCtbTrtQO8hHXJBx5B03+UNXAKyVbxTDlQojeLZH5HpIxdtqI35CcFNGKU1TOqK3AkjzRPR80zKCkQVNVBLTsyGo3u3Ln1neee/4Xf2LSOiqoyxkRZJhDdr2GOt++uXEmNdi5l3CAaMjFBlqFzLnaGHAaAyIxgAQGBe8FMyyl3dpoobI1DQ6GNQdhWVUAJzNZYRIyt94vaz9vx1kbA2BoJvZoAbjiSZk51Q3d3hcUOB0VpwViwDrwXYSEBQ+AMCBFZBBSIxpSh9a6q1L6jvKzb7uXCri2IdBe/RMaEEDtKEwFm1XnDvCYi2hjB9lhKC3MPtQeRRYhlWZKzwBJaL95TCIbjzMaBMRwixgE468oqv5ECx1HJlYPtDTsqqHJ2YwzjgVnM425NzsD2pPnC1fbjj8r/x8fDyGBw+No79SvXyy9/Bn7jyZnju/WBcRcEeTIe3rq9+/3vfuf8+QfOnb1gjIE/RX0dXYdPZzn4C5Pfn7Z9grD8y2waxdW2rXOOo7d2cPbs6Vl9ZW/31sc3boZQCwMSGbRdFRUWZkFRJMAuwn1JeNr6XK7/4RoP7yv60rM3HDvO3Gdm2tKLzMgZeWvdQmewX1Niju1/7a8iUtdNUZQSeT6fq1eCIzS1t25dyiQBjRRBPbypNwNoiHwIWnt8MBgQ0WKxuHnz5mg08rws/X2UhfabfhJDzO4n7lnpF4uZtVQURRtaQjMajeq6LYpidrA/GAzKovQ+xsgiXFZFXslO3FMOqSREvHv37p07d3SsqmQNBoO+rgCdBpdb5vj6q2o30gPUylrVsYJ8ZddxmXAsHfBO9qgRkYr5oig0NxUNAUAbfAQZjUZFUfRpJUcy91+BHb5nLrXab/0Z5ZY/VDPXZDIZj8c6mH6eSH64DxSWX5cAkTrCVekCsEwlT29fXUzshGtfV8tKFXZxPRl/PW9tbtA7Ehng6Kie1A8EWVuBo2e7v4n9n1mBrwjVVskggqC4k4KgKDoaqJm/Yq3tavvxmoWpw9YXVkMEcx+mXRWlTHvY89blECIRFMIYY1mWSjk729t//LWv3b17ezY7jDEi3teZer+m78qLkMpNdYI5hND4sNQnDBljBJG74pnSAzfsNmsl0S5w9CFMF/N5XLQcTeFcmXC4R6PReDAEluu3b03berA5ufC7T+io/P/hjJCZLqaye4C7U+IIw8IYi4EDMEgCthFLAsAgzKyhFmQgeg8ROHTR3N0Vc22XP5mHRlgSZ9ojkdi0xhgzGcKwjEgYmAJjYHd+h7YnJVkboPJYCTHz3NdWaopt4YOEhh2FncmS8J6+KJ+9xM8+GB4/Fy5s8+YASjsPUx44d+4MVkM48P78icVXHoWHT5r3b83f+PFIwuawmL37/sEb724GGFUDNNS2bdPU1toffv/7H7737nw+1xJW/fYp1Yg/l2/9/0LLlKOgT5mBz+dTU7jJZPLwI1cef/opz1F1dMVNYO7Z/AEE07/QE/9rgukT9Kq+2FsTEH1JpFwoH88sv7Iogd5G9w9Fn9mujar/17UTlCeSAx9znREVu1oW6ig/h+4ijd2lNM9ONRURuXLlysWLFw8PD621m5ubCuEKPQ62tg5rq6T95LTh/mIai0TU+BoAVPIMh8Om8ZPJBIS8jwBQFAUAcYQ1dgc9dm0xIhiyzkbmedugojg3bV6mo6Ioi8b+gBxghCidUAwEhEQm6Q06h2UhGWOgwxLgyNylaVgkAjJoIMSBsxwaQJ5slJPJ5ODAk0PHzIHFB82TUyQ1WS1GjF0iVl7EvnBas+T3iS8HHmdxEmO0SN773d1dBcPImhAjODIIICFGYQRig1EYoqj6lR0xxlno+fAiM0jCrRKRqDDSsgy8RUSLxCEk2mIWYUyCdiUTRKMgEtqvBWcJAEJgFlKNhIgMWE0w5M6jRkbhFgwmnYMhMnKqdBJDAELKEkgAAAxgBFGHq9eq69aqmcqSSRAgSCkAU0MDCIEFMGPgdldnQk3Qh87TpH8zDAKi13rvPQuQ1rejlN9kkvESUtJvZGMoHxbTbVwkMZ2GPiwrImqCP5hPv/n1r/29v//3jbD3MBgMvffCQoR8H51DXVRGsUbTcG0TAdyotBO/vygQQTxLi1QMofTRS4wQWXxEVNw6aEwsPfSUIZEuUgdFXIUtSimDWRU3hzy+Npu7rVsDy0EGi8VsC02MIztYnN7aXojZLuJ+Gw6aPML5yfHw5sJd+yjOYzma8MbkoI0bowEJiHhoJHCkQWkJW41ONRgXCxpVAbASAgg+tCWWsRITAQnIkobCRz0XhgQhhmgQVRFUU3cKKyZjI0DkGIKPwRGZKHG6KBYNnN4KO2MyVMwWcT4LBu32plbea51wyc4ZPAgwDQZcuYu+CmEsEBEpuM1lWixORgWAt1IbpgGVkaBp7DzgnV2310AdZttF4c6PTl7e/x/+zSC/f/KPXlncusWPF/GBsxsHo1s17cJeY6NhaJmrjbHfn7703HNXH7liHVXb201TK35rCMEAgt6haYXXAaxHtfSZYV8NXSGenAGnjjNZ5kVlLe3YDo+2kPVjXC1cdp/Wl5f9WRw7zj/HttZ5nqAxRiMKF4tF8kfXizM7J2azg4cvXX7vrR/v3b1bDkoRLgZlYAYGNogClhLX6PvEiSgKx8hoiAxGZmssWaP3QGesggEaImOt3jeyp5u7tPyjOygiuvvcQQwof0ZAB0YHJahZch0GASF3mBtIqBFr2Onu0oXcJaFGJmDszDzMAay1kaMhwywcot5XNYvVOmrahaKSd0ZW1RdIRIIIIjp1IICojdmjCIsty/c+/BBAikEVRWIMAFBUZdu2zOKcgzb5DRZNbckCZAzTpfZmyLVtS0TGAPRiOBAskdE0PxDh6NsmFg5FxNjUg4B3BYqETqcxCmlhDLRtY60lsLavQK1RT1+5ywJDAwbXNEQAKLtiV32JiJgkgba+O22ZPdE5b/qvE5EQ1HBtYsDZbNE0URNJ1LuRL/dKVUe1hzyjzOi5S6PC7tLZVzVg1aKgH6qaRr2S9GAIWPqvSL6x7gEV1f0hrWm+uXGCuFnarTKPUBUtP6lXhP7U0gb1quxwBxQmjNArW88xQM+6gIjpyNByVP11W4sgSQgu3RCZeXOyEYWn0yl1RWHgOHamARl9/Tol73TawHK1CQGgcqWC4Oo6VFXFzE3TkFuJ+l4uJgKAQOICoowgcjTG5uqIEUS6ijbf+MY3nnjqqWee/sxguDGfzweDATNba5vgj27Ncn/z7QrBpH1BIERDEBEIiGwbYxsZV4PTiQhACCi2PpNfXm0RMUQhtICuIDOsCiC8s5jf9XWAsTHGgIXQSl2f3NqkEA72dmkM25cvmI2t/IrJGzfDwseDutrajgPXkgxGIzCmvrdnrQ1oqHRar6BwTgAkRjOooHAiwiGQXq10PTsUIxQB1iJrINIDQpFkNQaT72ugKcsokhMZGcSe2sJRFSMze0IyoyEgBxQrFnygwBiZxRsAW9gIEqV1ZUkDh64kJhgv1zEQWEvOWbOo/bu3/bXbcndWvHknHszqtgVEPLvpdmv87OXi564OHzo1/fJ3i6//oPr+23L2AJrp+9dv0c55Z6vFfO6I/KLZmIy++/0XH3nmmb/2K38jhDAcDuu6ZuaqqmIbCmvbts3GnmPP7NF2rBRfl77/OtwamfnAvyZLjL40p4rkNVFmcOLEzplz5x+5+tgrP/x+4xsiMuSIGYi6IDT11kH+VmfO7FJVUWMRYl0H2wkyAGjbtixLFRZ6X1djcF9ArCl8mVvqK/qly5IyQggINks1AbVVZ69xDp1X+sFe573VIEi1aZfxExmXjDtkbdWr+jEWXdeMSeNZmQLiEsS5E2Q9VhNZIoOhrNMwsyXTJ4/eREEwUqoyuR7dli0WSTaxwKqC3p+yc06z93RSVVUBgG9jhjZfbxpr2hcMaanvA+mtYyFjIEW4YPpPHdWrwB7302+4y13U1xoyaDAK+IV3rtQHVJnVKekKrnWyXOuugAUA5PAL6gm8/NjRA5k1hlz6a7kI1INdlwSiLqSqDFCnKa+pCGuTxb5ieWT8KguzVp7tSUfXTTBhUQij2rKyXiWiqZXdnbinNvWnnA8R9AyAOSIEWFCB/ASISINsUFJFtL4czetzdMoiklJoema9/DwhAeHBbLqxsTEejzVGulnMnXOmcF24+kpv0POdLZmA/iwJIUeX0cfoyDjndg/2v/WNbz548eGyHJVF1batCMYo8Ill3dI4ddiqJCN7ZDCEjEFBNpnR2RhrUfUUltMEQlhdn+U+EoqIRTHGDopq0R6+3xzcM+ARWRAMlIaGhgYWR4WRYelt3PX1+e0TAIu0cXcO3J1Dd2IMGyNfWTDWoYGIFMUa05RoKweicC8UvffAg0EB1rJEESkArCUIwhzAlADLWpTp/AIAgOk0Rb1eJ7DLxGVEAUmBBQgZgBHazaosS8cSvWcUKrQ6C8GihkVr2mgCRAwGEUcVEdPAcmWMOGCcVyubYQzKrf3wo/fsS9fKGwcwnR8u5lUTMxfD9+/y3YVZtNXnL8Ngq/h3/3b9C0/v/3e/Lx/fjG+9dXg4Byhmi+BsxSGWRJHbgP6bz3/r6lNPb5w5ba11ToHnl7gOn0QN96GQY/mhZCT4XuO1M//Tt2Nfd7/H8ilbO5u5rYqc+3Z17Hc/zbegJ6XyJzqq0WR89vz5R65cvX7tow/ef2dYDUJsBcSQ6+KCUt4aIi5rlWoQd8+jgZgSPbJ7wlo7Go3m9SILCzRUVKU+HVrfH0aW8f00Q5QeHzYGEQSXxyOpID25KaIxJx276CGji4gic+f4S0QEJEgWtXzO0nezdztkC/e67FiX132SyNxY75zSuRe0nJtzbjabddJhbceW6lonqZcAkgDAnOqwEBkiQoHk7U4gr/2IKN0mbluPiM65uq7T1LBn4chkoZ9k/aA3BxBFUZS+mRENGQDQ4BRAAEO6XYwgkAqzYS98UocE92lqQREtF0wmCnBkEVjMD5SYlIKz2yJvfH8b+uctm1Vg9YAdq6BATwDLamLLUmAgoCi2LXJHMmkMyzOSv6qLicyx37m+dEU4dU3NKkc/zzIMYSlo84plpwwzG2MzXRqD0AGE96rvJM7XP7pZrCAiSAKqQk1LUV2WTIw8m2k9WEIk70N/cbCDtwIA6SDFumXpJhJT+Hn/1SBgCysogQMQ2MJCAEFh6cctdUNXz5RwGiph9ykirngAleQiCApvbGx+97vf/ZnPf3E8HJUnKoMExjCAYnng/QmyTyQA4JzlktiSRNP6iAzEQoUhb7qcW9U4QYQV9kTnGGNcHVgkgwWZIGxF9mfzD/xif1hEgxZtYKEQJsZyveC6OTjcvXT5wWbrRK98EizqwwK9mYxnyNHhWIzcO0TjwFggQ6WBjhghchAWg0KIme8zIzkQL4IQOUtHZMmiMjN91begu6wn2DcRIyIsKMmgBdaE0hVICCKGvAFEcYGxDrFpZFZrTTsPDJbAACPOSxmOxmDLeFgPD1oeLHWO9r//5vS7bww8uofOwi89wQ+dnuxMwu1999pH8NIHeOeQnANX8bRt9+dmq5CIcvnK1v9kePCD77311W/dbg6K7W0JEoxE4IJ5ejA7deHMmz9+/fmvf/1X/+7frWezajSy1ja1d8Yxg0EbpM86V6juqGw+Ks7XntF0niWP/QQiu3+T9cvo8tWfQLd9Ad/vpz+jP9VwfnLrD3XNsJeHXVSj02fP7u/vX3n8id3dXYTIERyhj2iAgHpyp5PfsDZrrY8Yoy1cKuTJwCzIsJjOi2GlbmUWwShEFESYozkycT2eijyZQuOViQkBpFB6zXkFEO62ERXHhZKsVJgiAIjxmPCgAEv2CICCkv07/TEclcX5r9oTwErwAPTLdDCIwLJga8f/Ew+M0Tet7+o5hBCsXRaA7L9uMKj0Gh9COJojn/KWsyIInQItJLDCSPXO3Ck3MhwOrbXJwnGUdrELQZAj13SHyUfV/xYiNlo5poe1kuR9L/2vr1Qe1fTT4ACkA/dklrZtAcA5d+L06bquU/XInvqSEeL6FKkvymvd38VUK2S1RHVfCcjzSlvbqSzSOV9VyCkZESQ3E4ha2YQgpZyoIqK5G7m3VMUHIAFuCmAqtJaWRWMwRbrSG711S28HZNX4jmNf0quLp18xZDPD6pYok0n/i8L3M1FwUqo01G6xWIBa6aO6hPREYhZOCZULl6u6FGaYnE+muytLZw0qB+VisZjP55qJvgxcWnVgrf1wVCGTLqCnK5WSrguFcezDC889d+HsBefKza3t2FvFT2DfSZ9TpH6Q8caIJoO4d2BNwcI2MtdtjXXBarMlXV2RqEkc1CXj9RdWRALHwhBEDhApyHS2uCl+31ZeoEAAxLhYjI198IEHYlMfhube4fTkpUtw4STAh9pPsTmenTNjslwag0S1h2kDAxFnmIQs1k1tkawrI0djjCIDctviwFpLgYOTIs09xnyd0WJtyCIIzGwU86szbOj/+zPRdUNDgOiwcLaIdQsc2BkoDAbm+QL35ji00XtblkAUBTUwJBpEGnEDvKgFAc+MgJdIo9PvvoGPnqMvP+k/c6neHABLyUiPXzCPPhC+/JgnKCcjLEuqXDUpoVnc8NMTZhvOPFT+xuZZZ7Z+/OEE2zPl4KP6EMuybRrnHPsAMfzwuec/83NfvvTwI818QbZgEOOcxMgxwFEuu3Yceu0owazscs/kDrBamfbPqR3Luo8+8GfsHz61ZeVo67vRsZf5BRKH1ejMmbMPXb7ywQcfvP/2G4VFa10bwlEFTrorq/TqnUr3eVmWwQeRBFq9s7MTY7x3uK+YEAIQQmhjgN7iZL4KqysmwiLatbLw5UVRgaEJkgs4BgbQJH2EIz6U1T47ttgxYaUN1ZDWxrOU/YQsAskqn/i2HsRO0i9fQZLirvSmnphQzxKslWM7EwUhYkor62sbQgCwdWorxjidTkMIfSmBiNTV70ybKNRz6QOI6ds5YoxlWYUQVF5sb2+LyM0bty30qBZ7enQO5M5iIwsAEcmB+vkBcpQv9dLPqoDlBvS1gTwyZo6rpEBdRonePlX5OH/+/PXr1+u6hp4+pKG5a5TUbaqqY9jhOKRhiujbNN8qKxzQN933F6RLwAFQmJf8JxWWy/3v2HIPflt6vhXnXHKKJQ+IYGAWANvpEWuGpbCUl/1RZSKWVcBpTNTQZeGCuuchInRWB/3rfcHcUpoudpAhupICqHmzQL71QIRgjDGExgdvyeUQFFy7hHX6BPUwr0SEY1KkCFBy6ABCrjOk+kGM0TlXFEVO2M76hHZlcNVDp4svK6sEhJT8PkJEGxsbr7780pWHLz/40APzxawoqxCF7uNS6feDHRSKiBTDEY6GDbNxhbFiGi8QD5q6BytDwCJBNJbWFgUcOUSIqNm+MUSuyBpXL8IB4QwAnQ21p8KZKCNXnj57tj3cf+Dxq7sTux2j/U+TttH89jVjLg9ObvlpnAwGUrfhYEoxEhVIAqUzaAKrw4hFxKJBtKEJESOhI2s8M+Szo0dSRLRcOJAaZ4QZ+lWFswbJEkLQCaIhSZlKSdFDYQQSlnbRcO1pvpCmEWqlbsRa0OhjNCjs0JS+hHou3NYDuPfhvcnz7+Rl3/lP/zY8eiGwD3cPRjcOaVByaaMxMCjtw6cZ4gwFWTgseFZvts2Zcsh7B/PDWdw0F3/h5wf3Gv+f/1f7fHt/BLOBc4Ohrdt61pw+eeLurevf+NofXrxwDkyBJKUt2+ApBSv9dGL1vmK4o9W1z/50Yjt//afqZE3b+PMdzCe0dVZw3BhC3QDi5ub2qVNnLj5w6Y0fv4aMLbZdMYDESGGZlZJkSk79UzOb1mDyMRAQATpyk8lms6jHMWiaJmhqLpiobuKwjpOhnecCZ/rixKPIKkRyJ+NBMOFJYGdlWZug0cQQdQIQSvbvqmU6shoJRO+xRlCM9sypSmJWYaQnKHXKUeu86salPGEhUsc6JB5IiNhhlohEoWVcQWGsrp4GaGA/Crmznc7nC2aOWtqzN7mMqwosLJIVsr5JBUDFqy6Eads2+/cPDg50OjZTRuaJa0J3bUEZEnfP0hc0ERKMQjLrJVYHkw3p/d6UdjKysPK7HBWhCFHIIiFCjOryQeYPP/xwOp0ys3MOEvTWMkB1jb5FBJFy3GVfA+iXCuwPqU+C/X5S/I5aX7oM3iRUkgBcqUALkPIhKYPerwp47F3cqdMWqYdfrjskRlDhwrCzH/R056OsR3rRDAjLQC1O8URrs5M+qaSPssyEFLKguoRCYuh6xhhtF9jfDyvpr5sOIYrmYkDWpaSLcM7PECBTF26CxEgISIDOWEsGANq6Oba+2hqt5kXOATrY269uzVk4Lur58y8897nPfe7UuQdG43GAlYjRNRZM0t1LACQddyFnaFh6REATPUhTWxDAqHCIuldIBIaBiEADkpa4c7lzZiIKzB5LJwiHh9MFCFhnnIU2MgjFuL25Ma8XFOP5B89uXz5LDQLc06+7h08fHk4nsxONkbg35boOHDyGsVQoQCgQvILsR2EyFhGlbiUEHJLka4oh8Bp/hwQgLFrQQkRIUgVOEFnhqiyKK0JN4MCICIYAhDt6Yu9RGBhx1uD0EEWIMBYI06nUEQdDEDBkUQjqliLM5ndGTAgtvPHByT94mT7eA7iir/KnJ3B4aK214xFHaThGDhXGudSNjxJ9CWYQkfamcOewBSjuzeW960Mxfmvkf/mpk7/913/mRz/e+/2vzc4ND4dlJCue0ZHWj/nOt7711BNPfOaLX9ZsfO99YaygrJ+KHm0cpfOjNNN/OC0YAkkKbb5P3z+5ffJ376c6/ER94id2+2necmz7BJ1D+7HAImZUDc6fe+CRq4+9/967Nz9+TyRSFxXQ58kZwIqI1IvBzKqRhBjrtjXGFLaIPjRNc/vmrel0+uTTT+zu7t7b3wscjTHSZbu4NUM7AKT8xKRLp6tZYs9AaAFAbRGxuyxLxnlanTKsfIS9my0AMgDFZBQHRLTWIAL3OFB/ysq0uo8lC/L+LmDPwqA8v3/jEhEAaluvvgJrLZFRO0eMXNil6AchpDRf1QxSDayj7kVFdQKzjKbvzx20k1TRt2naDDx6cHBgjBkMRksLxxqVHMWET3+yBhTrgFdshH0Rrrw1w2NkYYCd8QN6cSFokHgZlLDmAUESAWh91MggRQrRPKucItGfcE8SL2eUe9OYR4ClHMpTzsJeJUT+PNuJVIBFYQExmQqEkzQGTBrWsmjNOsLHCqEjEoAxxD1KYk4RyAyypi2tjTPNtPtl5Xiv8UzRtFjtRHuA/NV+n5Qur52thkW0ZKtGwoKUZTmfz7FDAVEQXKTj2RBBQtBY4dEsxtq8zsvPexEzajzL8TrqU8vPL7/YWT6wM2nqsnKXvUxEAkuciRCCs3TqxPYH77739a9//W//D/5+27at94Vzn8BGERPv4e7KQca6wQALC55n9QIPDzdRqAAJsYt4IYSY0m2RY0xj6Ge3G2M0CJxBxFDbtnt7ewuMxhXz+fxEsTGDEEK4ePEiWnfq7EYsXPHOPX7s/HJgj1wYHLZ82BQnqoObN8ZVOTiz1cwPxaIrSggcfUOF88wx8GBYAYDU3gpEotgdh6UmoZFJ3a9ElMyDsES7BwBgkZjwUShEFEFjwBoQZhFkAeZoBH20s1b2DmnR2EEBo7IGXzYtRiAQQLRI0MbmYGEsFiUuDu+5b706eOEt2NmAf/TL8Fyy4giQiQBNAwJkjSsNGIR6Wh0uhh/tw7Vd2NsPvg27U7l+zxxWi2JOzYH16DZONIWJv/GZU//Bb/217/74Vjy8WxS7h/WmGx9yPZ/PN7c3Prp197lvffvRp54tjRXjy7IEEDmCz7HW+reC/MkakR8VtH9GbeOTR7LWPkHS/yW3vFBr40mXjSBshEM8efLkmdPnnnrqqb07N0M9J1qmRuWHNS0/WX9p6Zchoso57z0StW3LITpyIlJVQ81MgcjJFC1CAmTtsjr8as2NzkKc7aQCoPbpmDmnZmgJglDCOeROyujtrE8VfbVA/wdal6HjYGo7X9QN5XpYIv21yiyamTvWjbkGZ8f3VPJThxEgICiwdOBWroiQcIBERGFRSlcwL1NeO0YKAFC4KoSgvqMQ+2mxy1ha7FA9USR2loI1Edw2jd5BFotFWZZlWaaAm4DSAcEL9xC71c7KCG3bDodDDStTv06HOagAEAIAQujIgKS/WSDC5O9tYsirrzgcRGQLC106YvQcu9VXFdIYo3BbIuKc60SO4o0E7FJGs1EkWxS6DBdNZ43aFRHFmNAWYowiVBSFgrKJMCJ5751zIskkHELIlx5E9ASsm6pwqILMHDkUxgmRFVmWpdUswhAMgHTJsXkztG4AMLMPiOjIAEEMMXYqGnWPIaIlytHUvZ0EEQnAhshaJyJabZWSjTGqMYMMIAkiGM2m4YiooU/SmeZERHR9qIPflyCY0mGAmRUPtMNkU3cFh9AWhRUBFCmdA2ZnDDMjJPdepzOBgDCLMdRV6OhygEtDTDlwHQA4JBcp9wwh2F3ByUDliqxE5nVGRFlL29GbOcCwHIUQmVlYDCTrooYMhMhBQjEovv6Nrz/1uc89u73NiGSJo4iIJRdCsA6998YkAmY1xSEYQEuOm4jleDTZ2Y/SsAxqH4xMg3c12MLFGENoRQTRGGMtEiBhJErrjsBoyABhG7xBy3ZYgi2iHIb5bQh7pTukOIilm3HYKoyjsDjcu3dj1OxsPvoYUIjffRNgnE7NbN6e3zavXy8XUk0GeNjAYbt16cK8aYbgpG1Ng/PDPXtiQmCgroVBLHlrnSusUAAxbZRZjc5SG6MFJjTOIhEgRpAUPIca76yF97pLTQgYmR2JiBiwlpAhNIEDOzIutHCvhqZt2lBVAxgP/Xw6PKjD4pDtEJoIkXlY1DdvjMTORqW89AP7L1/x8xh//Qvl01eA3DJIJUI7m0ZL4LAgoGu38PZdeOUtef/O7J2b/t5s0GIZKQzK5tSofPQyPrrTDBHuHYa7e/Vsb3z74MTDj979d37z0v/2f317UB+Or3isTdyP5RYsBpubm6+89PL3n3vhK7/8q77xzg0W7cLaLsluNYWSOwAe6IH0QHdy1xh3x6DXP8nPrHHnRN7dA8dgCec+++a3I9W8j47hz9jWdIVP0MuPfrE/nrWrhf7A1jGzD35YVhcvnDvYvfT+uxfffOt154xvvLOuXbTOOZagvEya9sHLl2KMH3/8sSaeaMUuiqEiKwLIqCw0CgPBBx9cAwARtGQIyHOMwgTIxiJEQ4YlpnAQQkvOR2+t1VuWQQsGFAFCay4GST6RxLpELADrTZ8QEBlBTe5WjNKHAIICEGip8OjJuKKoOIqgIGJdNxxCtjR3XFEnQUIcI0QAsgYRhQVZCNF1Jg2jJg0EENIMYRGJ7CVVgo1KtG3sFGIhEHK2FJHgNf1YzThEvbpXIQYBCTFAXCFFZvaRi6IAAO9ba60lAsAgvLm5GYKfz+fGGDRGoo1RAKLeGLHDEBcR72ubsmk10KR3ifS+dc6RoZxxpHGnEFmRsJPcUjISYGYEEBZEjJrQ3x1I7iAXs0IQ2pBdKobIworSih2Wez/D81hSXqPjTpQurRd9Kai33uFwqD2rPpGVkuQgVON5jFpZXbvVs51tFdqtqj5ElH1yff107diLSE40zWp1+vraUCNnFT5/mG9RWRKnWR+THbpmUoPVz1fuDXIk+h07D+VqJ8vH+itw7OLnT4qiQBTGZdINIsYgAJw3BTuIthijJBQawB5KDwD1jWF5SGtXASLKpqgEbHrkW1HEYNJr27b9vX/xu5cefuTEydNJ4wEU0LAkVVvhfo2sQWvIOOBWsIvSAogaQmtcx2ElxhhFLJVotLxeNsgCIlrBBQdfEpZmd17fI6idJQ+xMLPZvKjLszS4eu7iiTPbpqju3Lk5HLjhQ6cB5jqMfYkn3rgDgevF/PDgYLKzbTZc2Nun4WAam/FkKLc+LgYu+uhK5+cLVw4xsHMQY8ROBUJMsGtqqc6fACIK5jxAzYIDSNA0uvI2ApABQQ6RmQ2I5g+G2ArXUJjqxEkQmR/uTWd3t3wsbu/D6SpeObMoXfX+rYJihIX73efic28VVx+gzz7ir57dH7pyb2ljaNuDokRYzBY/vj599YP46vt0fa/em2FZFpfPjn7pi7C1OavnOBqOLl+sP/dwVbghMhxM+ZX36YPr/tod3Bo9+ku/cO3rn3/t2seT0kdDaIcF2DouitLNm9lzzz33+NPPbu6crOvaFpY5CqiDfIWe89mX1ZsrdtbQfC76R+/YlvtZ//y+FPdXr30apYc5ikBRFE3TjEaj02fOPvLoY3uHBzeufTAaDGezeVVVapAWkegDM+/eudsE3zSNcdaQ0esr6kWuB8kvnUF9bTCZbSCAxobo50ueJukKLT0cIy1BholFdF4MBOAVY1hK0uh1CL1fEYHAQo+o+m9f5ZwCSRpq8hegdB6engsDAHrBJRGE2rYF5GwkJlIkDDZEMa4YMyRnbiZ3yMpQmZexgwgMy5AMC7Gt61qhTdQha4zBGCaTyblzZ997770bN26MRuPGNyGEyXiokarOufl8DgCDwaAsS5uqu8PKgYHOpaIgKjHG0rqgUBbdogtARMi+JuqibnRKPkZAIQHuEodU7QCAoigG1kI969YAAEGrq7uyaNummznXda3Bg5rL29/FLHWyNpB3sS8a12hOhQ1o3HLbqubVTyJQ/UMl1todIneexH9vk47qQwaAj3PxpuzByJFTPGy2py3DbBnAYL9D7lKLqbOHp1+R+lELmQNmcJjusGjSkvScMMesT3fGjAiv1rVFxCUYPvT0FTiu5WGoJTAKhxCKwllr27Y1ZPKYqUPkFbXPdNm2ORCVmbPmusap+2po2hcGgYgQ8nKtCAA0AMJR9MC89IMfvvT973/lF36eioExBlTdodDtxXop0eWLDKFxpnASvdaa06K2IERokqElsxVYKUGZgjmQDJIDWADj5hAGxfW3dz+U9rCaOLCtg8G42kY6MWtc02ye3jl55UrYPcQXXmvqCPCgDmODDWyQvLdrYzVhUw4qbyje3hufsPvgxYN3ttjeMgRCKM6AA3IOKhe0KCeSECl/zWnFnXlWkCHF+ooAQ9JCWDhwCJGiHjoLSBqwhCwkIo2PrW/m+yUarowvyC3qQvy2Adcu6um9g0snNkM7Rhe2yvj9t923X8FrHxdf/BL/0hPNiaHdnW8KNePloSt+9DZ8cAfevD5493r98R0n4MoinDhtr5yDn3/S//XH5cJJ8tEFhGpA0shBjWhhY6N4/HJhikW7iE0tO+e2P/vkqdffOdiod7EKWA7F+EIMSGHozTde/cH3vveVX/4lWzhhRDL9ErhZdGXtfI3O+2fnfprET2z3o7S/Wu0oD/zkhjnrhKWoqrMXHnhkenhnb/+j999V/AaA5H9QK7C1djqdKkxfOvsszCzGCqXoUepGkuUC9Dh292ZOSgcAwPJL6hNnTgVYNfsT9Yz0HWcigGgQA60zUIGVFcgvzYo8C67BdhERyPKu2y0di6DpvMQIpMGdXW2qY5c9llWhcXWUioGoPhZtWWDvbpnv8FkLWSPgHuJJxxAAAECB8pqm0bW1SFoiJ4Rw69Yta22MEZFCCM5Y55z3XuMfEHE4HD7yyCPe+1deecVareud0zW7QeiwHDnumqpODgg7BMKc00/ZBUUp5EG3IAJgh5+aZ2uMsbYfICJJVTFoaFnQz1o7HA5V/E+n0z6W3BoZ5fXpi15YFU55O70PkCS9sdYls026GYu+FyAGYdU0MTv2UqJC+kGrgQAA87KyRp/K1SaXmyXDzNJZC3JSRlEU2EM11fUxZAKHVartANoV2EoAAZCO4YBrChB29L0WuZaP0JrY7lZyGW+cu80/rD3f7zA/mU9UAUREo9GwKIrFYhGaNnebL47Uq9IuIkQmm1V6wa1LVUlEOl/TykVBT+/S99KbLJJBkBg9Ig/KonD2G3/81atXHj5z8SEwKIJEtrd9cD+2yQYFwTjLM4AEgE4ESKQ3mMiifknUgosxACquvPSPMhIScEsWqfb3bh/eQ9OUxcDbJvpRYeLtu1e2Tjz56KMhhMVHHw1o2J4eVf+nLR1D/F8NaW9Rb9hwfjSekt3cAGOJpSxLENqkUnZneGIDhoMAsW6aYlxNvR9VFZOgEBAREienKTOAYRFCYdA69SKa3a3eK4Euop2ZMQMYWQsQoyYxIUAIYTYPs0UR2U42xNDsYNrcvFtMD4rF1H9wzdybnv5sARvl/M335GsvL1547eDs5OR/+Df3T+6Ud2dVE+YbRdMcjloj//kD+J9cAwD8n93effpFERyORuGZy+bsdr09Lh+/QhsjGFbtzQNaxGpz3JbukPc3jZ1JkMDOh2o8gasX4o0b1dzPN/HBz//Mk7//wu1Q7w1GHrCM4im0bRxUFYb4ja9/9ZHHr1557LG6bQejociyqsOnkZ19au+T3E/8rqwZS1j+IvJm//Lbp1wBImKWpmmKatC27Wg4ObFz6qFLj7x79oEPP/zwxNZ2s1goY/RNWw4qEQnBI5K1FliTKFFBqlUaq9DOtbL6d0jp0jr0V0IEzCaQXMMBUZAA45pp+YiNJEWBdqFykjRySHUWuixF6VnWAVDx0UFQ62kzMyEgGfW7YlyWA9N3GrSIGEUgMBjNRNFE2ZWyR3mR9SLtvddbHDPGGK0t8vT7MSKIaNHGDg4EIEty7ANbcE80PPjgxXY0/vDDDw8PDyVE7mT6eDBsmubtt9+eTCbD4XCxWJTFQETAmIODg6Iozp49y8zvvfee3vAtHrmq6vjatp1MJhuTsabkhhCGg0GMkRuvo04+p07m5aEnLJTOFoVdCqsGrOqiTJtlSQiDaJDIUoSEukG93EjomQGO0jT0ZOQarefNy4INk60p1V7pu0i4Q6nLBVCEV9hBft3R5crU2Wc9iCiSotNXhsoJthI6341CdmZdL1OqRkdnWKpOuVmSztqo0uL3rG6ajd1tD6oOJIgAKMJLuEZdBFqOquuVNGCqP01Iwnh5ku/nS+6+ZRDFCSZ8uh495IiZ7t5vQYCjHn0kSjCmtstSWdGiOpeWDqqvUHIP8aJPFagXF2tiDIez+XA4fOONN15+6UeTnZ3JZFMisFlGCn/ypCIIEkVmAwYMAVsiwk5FQzCAERENGUNOAdk0iR+5c7XGGAhjCOgjHzTzumnHQ7Bl08YCDRVI9ezEmbPloDhz+qTcO/jg+y+cefShJSEZhNGgvXlr48LpadHYEZnofRtwewg+uoZFxA5KiDGE1giUrkiXhihUlJAD85iZNdNPdH1ACFgw3amWfqBEEIBCpCadloSFDYMDhBB4VkNdOxFrBxABiKsoeLDw127G6QHfuEu7rfwXf4Cnvuc/um7vzk/+3M/Ab/wcDAebszlQAcYO2zh87Vb93GsHe/sAj+sbq//FP5ATG+X2ZokElQuIhgR8hJmv5h5mQeIhbFbjjRExlJORiIHDliU2kzIsRljHQc2jBx974IEHw+s/lOE4FgUCS+QQuCppczx89523vvfCt8+eP1cNhproe1R17hPVchd6pJJ15T7hfXJbExjQZbn/f4faAcdZmtf+ihqNxzGGWBTF5ub2hYsPPv3sZ+7e3dXYRmaGhLREMbbKDQyggky6DMHdXdhEUAw6YxTOfKk0rOwmCgghIYlIFxggSzpHRCQNmRAEMKthOjn+bE0QdJCPyYy8JiO61UhpBAnjqusQAJASi+7LEREB5sBMTEQktGJjXvtXRHZ2dhaLxeHhYVEU1loNRmxjuyYs9GEiMCKIkoeSnzkiCAAAyrJcLBbT6dSR0Z8VPF5DPOfzuW+jtZbQJtMKe7UX3Lx5M8ZY17XGjdrY4Ybm7nXCCisZQmxbLwLWufFo4r2f+v2su0nn9xVIBqCegEuDp8jLeSTAkJXaAiIQgTUvJ8SIiNnkoHujKlvGBenTcV7rHH6RF1cIY+ScL6w3NdZ6x10BLV0y7XA4HBZFMZ1O19JkIAIS5tchpjLrIbTUtb5+09sqBFjqHKSmEQDoStJ3ryC9WxNzpLQJMXCpQXliktTvgCDIGABkwrXVEMYEottRj2LhJbMYqoBHAmQgBARYAWld+7ljsvYTJG//K2vUjJ1LJYSgNkycL5qmruu6KAoWyNIsG8+0sKGIgKAsbxf393kvX7pi7s5d9R8TASIIIRbWCrrQNuoN+cY3vnHp0ceGjw6Ncdiv7YT3LZRFAshi1AWG4MgBEgGG4DvXoqTIL0ARBIMoovkeOZeMmQNzOahGw2r/xp3bEPcNkScxZBnq+eLyaPTzX/6iJbz5/VcLxgfPPQBxaRTcu3Fj55FL5WEJB81oY9QiOle4KOxcu1jYgwVtbkAThBnqeri5Aa0M7IDnrSXiAhReoz8/xMRedYqYf5alQTmxBWNSahyJDWg4go/hYOqnUxIuy6omYyGwRJzum9u3qzt70NbYxNt7d7d3Y/HKR+7KDv7j35w99IA95PJQ9jYbMVy+/iF+5206rKvHHqr+3i/An7yl7y9+9QvRMzBAQEC0DFDv1QPjh1RwRSzee4reHcyhBVc6MFYksrXEsRoOYEBydx8mo5NPPTZ66UWc7ZOZRATA0jgbgwjUZWF++P0Xr1x99LNf+BKHFq3JhNdXJu53CrJr7xOe+TQtF3jr31IEAD/hO/9mt0/WutoYrbWDyk0P58YYYN7a2GxPt/sPX3nrnffeePWVzckYOAChK6sQApHVUt8iaMBoyaoYo6DWhWLVHpiFe5VBVwaTfeLKMQBBFMESRJg6uEItfA3I6k2M3ANsVK6oZyHXiOmUDYSVDcv0g5irSBERAZAOTxKcVZcw31Xp0y9GQEBRl4+eVRKTy5tktSbrNsbg9vZmVRWz2SyEkGUoauw8IIqASGLozF3QJhqAmAmYcHnDhRT1qu3tt996XzA0rRsM+vxW6zCX5UDLEmm1tqqqQiBhrNs2hDCZTJwtNYbUcne1zfxMfy2Kom3bdj9k+0SMMQdaqqphiXTa0t0A9K9BWJVGAMDYQV+EqEjYRFRYC6GrFssshKoXdFsCMcaiKM6cOeO939vbm81mZVmuHemjMRZrD2RZldll/hwRdYJakEVEjDGDwWCxWKhiiKsxlZna+iGfACvaT3oRLGN8tJmOBrOSIZ2JRXWwfPW3iNK9qOfVM5rZvDIF7nzvuoYghBaAhRGSW2vFxtPdVwkAUQS7kI+8dLjK2XrKBEEvwErXuK9qcKdrCqQiJmpmsWSADPfUD2AwkNJftcM8R2ZWDSC9ghHJGAsAoJfOvAV5zfuMXjvTnzPy7NqtFIEFoibMFtWAOQxH43feffe73/vOzs7OydNn+nOE+zP6VDdVgIMAAJBWWcAMHIQIiskhjKo+MYJFrT6gy6c7CKYaRGs/OLz3Nvm7tqQmhEElbSiQi2l9ejzZOXnm7qsfXL99a/TMk/aZSwC3dAzVyVF982ZVw96W2didutJF2yIi3D6Is3qBOMQYJfimQQQQicEbUwVASyYI68LpdEm5GTMYRflVBxACiDAjC9ISTQdZJDKKAKJtPLQBaw/zWhY1CJuygKqMEl0I1s/n779Xv/TyaG8RQljsH565Nduv7OI3Pzv4t75cnN3hvRlZmcn+xrs346sfLd65zo9ecP/oF+HEVl9Y4PU9U7m2cHZQCiOxYFs4hxiCm7eExrkqSgAf5MQWxhij59Iag2UDbIuZb4fogQfnv/yFp/7oq7uzJg7cHISLAVpkkdC2W1tbd27ffP7b37pw8aHtnZNEJfZsov2Teyw93I/tfHI7VkdH6IEb/VVun2YFRK9DLAbFGeTgXVnsnNg6febso49dvXn9o+hbNMQpjp5MFw7Z572IiGCA0KADUJe0MDMg5Pi29d0BTQVIegYAqZoBiIAGWDH7uldAd9EDUNguLbZgV51oCJjBEuE4p5J0GjwziEQRtNaCcC66Bp1lRS/xIsKGiCwhSESDaIzR+xBiEgeQOkw/e+9v376t65NBlkGWhvwc2QYJd0STRQC6lDQAEJSulOo6HfrGm6IsRqMQwmw2s9ZaMjHG0WikAsvZEgBYwBjDEnIZzsFgoEDpqj9YIOy4jCInLE3letUbj8ez2cx7v1vveu8HZSGEWsDX5OgHBEkm+lWyooRbmXSaLp219TErOGiocA6ticxBOIaoukVd1/v7+03TtG1bVdXRU70mMo+ukT6QN6CfTAtdmT4R0bWIMZZlqT8rMr8+RmaJ157/VVVOv96P98kDEln3yEhkIspZGxnPCjH5DpL/yFrdp1RcPqk+qR8NcEmaDScLU2/WqulzwvkH1JQdBJKEnicgpCcNV31hWeHISlUmZYXMyZpWJ1a7fxE6P7/ejUWvaqJ1O3r7LiJFUdS+1XAcNVnlTVGbQObsiOhsYYxZzA6h0zZw1UbaP9jYHfj+ymdFExGYgzOkRhfjXIihcpVzxYsvvviZZz+3ubltbAHZ8gT3bSgC2RbCagshAVB64GXsOqlX18dWfcbdQBAQjDFO3D7Ew4PdN+/evF6EdjwZTrHmWFmH9XSnqPav33zjzt2rxXjnS186hMXi47t5DKO70+jl1rQ+Pdma19PhxuQuzybbW8VBOxyN8KHTIXhb2HCI5WjEgaUw3hg3miA58LOV05EmomGfqQCVYu+DSGQ22XipxJRvePNWFm2cL2TRGiI3rGBYgiXrA/iamkW5ezdev0l3Fxyj1O3txyabv/Lzxee/GIKrb84semr24/de4W+9Z29PJzvbuDGD//Z5jgRVBVCmQf7Oc7g54aEJ22OyBm3JZ7e8FFQYGo+AqKHQAg2EpI0AIcRQBCYmEKCiIBFv5tOD6fbZkxfGWxt3P6wRahCwZRtqY9Baa50B4B+/9uqH77+7sbEh1hJpce7jbRtrQiUf/08jZY9tXVcIPcv8X9H26RfBWiss82ZeVVUIASE29Xw0muycPnXpocs3H/v41Zd/NKjKZlFrGotvmj6v03uIcy5ET0REFlMUagQAZjZk8qboJQmSK8FpzpVITNoGmo6HAeitSSQbe4Wwy10RtXMQIhwx/GafOHem0f5SdPxKGTIbxWoG4hDzU2m0KQpN2BBo3XvKmbISRYi6K+gqGxwOh3t7ewBQFAnxAsGIiEaSqT8V+kjWyduwYpIBBGdd55+SPjFWVeWbVjdO5aPCrEWJg8HQ+3Y4GLdt60OYTEb3du+MhhO9Njvn1MvjnIsxWtMyqMpEmLUNEWGORAgizXxOIjEGIqqGlbRBTcTCUaPjBIAEjHWLxWI4HC4Wzfnz5zc3J6+//roxRnkysgYVCyUfMGWrF6LCYzAAGEAxRiu7FkUxn88RsSzLHF1xNDwzR9sydij3IABilmCsmGR2FASgTupwB1oKqfCsvXdvL0YmsiEEi6T1YggJOKrWlG/gOmnoWzU6zRE6DXFNy1HgaOwSQTOFxagGFVIVJBMyGyMpmVMQUbOXRdhjNBqFJFo3BQHAsCCy994WRduytTYEb4yx1kGwMUZIpdTEGBSB2HpkIiLFpNZhpAMcVmM7Ms5v5ygQSeHliAqpmwrrYG8dQDRfMma7lIi0bWOtJUFkjVoiEdE4E2MdsxiN25BYVdVoNIoxzmYziWyMAUS1scUozlndPl1+5RQa3bKGViciISRjjpqeFJhdJDoi9r4si48/eO/rX/2DyxcfLCYutMFUg1YiACFGRkCiGIVQjCBzxMKBAdEKZN4bgxZM0INFEQkBkIMYQwCgZcBKKpxzwgohIyEyg5RlOZX56fLinbvvfcR7B4PT3o/nZjEIWAj42F7e2b44Gb91/cN2tvf0I5cGDz9gvvt2BuGYg6XN4enxtjy2PbhTzSduo9g092YgxM5g7QkR7s4Li9y27BwBtouF29po6ynHCMaasmKWSIIWuY02IpOJAESoBZ9BEGOUCMgWHDYxsBFiobp1LcOinfnFsG2IQzMZU7VRUAWWm2a/bOppU/MP3t344ceydzjzjZ+cGDz7udFvPeNOna298GK/vH333r/6un31Hb51y9MX6/PnnET744/iiYHZ2TIes8LBe4t2N5Ati1EbLU/9zJWjaljBZtWMDYyr8uRmubNxMKbxoqUwdLwJzCA1+7kEGQwnADjx0i72iohj594yIxTL4TaZyWKx2NicLBb1YDDa39//vX/+uw9fujx2djTZnC7mZOxgMGjqWtGTZVWUZnHCPZBA+NQSN3OA/Ek4WqXwp/Gn3E8x+oQHjn3sp/rrn+7JNB4OAEDOtjF03giYzw43x5uXLj28e+/uu2+/vb97ryzseFihhHxLBL0AgSBi4FgaG0KIEhDREkXR+DaLAh30fieDAJnZSNDKraieUy1DgCAa/o8ARmMlxCSoPxUriIjEIsASOXqPrgDgdJEAhBQzioitelUTR0ICFgwRrOHONMsIMTIAkLFFl6XCWv6NUnlOq2pHTB7e0D1EFEFjY5P9JhXcaAOjcbaHnYjGWGubxhuDIUQR0aLIqVgHqpgIMYiWX9Wbdle/nowx4GMmwQgMhoRQpWdVVUB44dKDk+HknXfecc407QIAnMHFbPbU408tGn/nzp2+vaBpGudcB/u46gXIiqEy6750t8q7u2zYrPwxJ+mCiIeHh21bE5G1JoRAGjCHIjnOtEecIgknSgAiSHZAdAIvuRg0jCiXRM8xg/nhTPAGUMkxy0XojFrYuyL3ry8i4lwJS//L0jqSVd+1E5tVHxGAI4ctCz/pYqNyaEj+MI02YZOsDEY6Fx1ByrZSUx4iosWj+VFalHJFCcOkihlBpFRKPoSoDiNjXIw5Y3N9x5djOK6trFtvvtj7GbpQXxFRS4a1tqoqAPA+9q90uU8ik0N3EbFpGjU7DYfDuq6bujGFizH6NpbOQQ8aIS1At199kgCAnN3TvShjtKSvDwfjH/zgB08//d1nP/v5s+cvtD4AC9mV5dWnWRgRhdFaG5gBGRE5RgQWCBr8q+QtKW8LETG2mkyeQ1XQEAmjLYbCYffw4CBiDYQSBaJHnJp6Mo+nT23x4eLUZOv0lQtT5+nazdF/mbSN5h/X4eqD/voeoZMFYwzYIAlBiGAQK9O2LbJY79EUHEGs1IvFYDj0s7koEgkRRM43OUQkJBaAyJHbrG+SDhUigi0A0ENsvdQeIkMMVcNAhsdVubUVqWjrYKNHQ9EKvvI+vv5WuHVvMZNw9oL7lc+Vf/3zYb8EwvDuj+13frj7L78NNYbPf+bUP/5P4Oc+D6YMA9cQFcaGMdQU4Xf++7T0//FvuRbJ69UsFuxxejBb1LI/Le5M8bXrM2Z39uTGxbPh0a3FsIlVW7ZYmkGsqtDWdHCwv2HHhxH+xYsvTD/+eEMKiy0gBkGSjfH48PDQOUOEw+Hw42vXXnjhhV/9zd/c398fb240rZ/NZtYYxTPg+1eRPfbzn9j6hHq/s/ZXqN1vHT6NotN/ZjQanT179sKFB5566qnvf/fFGFoW5hDJ2Hzzzj0QaWC7gNYUQTEgCR2XgUEY+jXOVtYc7mNP6vNAUAaSdI7ui6iog51hGxlE3RyYGFFXC0JEEtkoL+CExqQBU3rKgg/SXVsRUv1wOGI5w15EUWZ9WVJk55GGPOrDnEIVowhYa0+eOgEAd+7cIUKVtm3bGnLOYYbTDCEgWNsliva3tG08afiBwiqKRJDpdOprr5pKn/3OZjNXDmazmffNyZMnm6ZpmmYwGLRta/M6ZuvGGinkqaYAXUopFbzq9mfmoig1yGOxWCwWsxS3AkKKfMkQhRGQhNZMUlqQMxWm74nePIaczaHmAdXCpOewX6MnDb5U6lQBhr0ax/ej9U4biFkWZpVr6chYjQvJNJGUEki+8e4wLDOj+kScR9vrjUVWwqGJCHsKQcpM6cWHLPFe+8oTs3MOEYvSas40YJCkPq+g4uQsXJ1sHu1RhSNNkHOl8hWFKS8R9fpHRC12UxTFqVOnEFG9Yzoz0IIFGVAnxV6Q0r3a61J9ZADvfeBoCre5ucnM08N5GlinYDGzqjfQCfVVYsCsiwBA50tdkoC1dj6fv/TSD69cvTo7nIIxIUppzP0kgI/BOLvwHlkQOPiFQcHObacLoKYnDXax1jHHlHIvgmgAMEamYtTWsw/u3L4JrjHOGjEIYMsRxM3SNTvVvYO97ZZ2vvSAeeyBj/7J7wE8rANob9wZnzkPp8/M7h0OZlJzNJ7ibBrntRtWdjgxMTi0LXqLhpxtFdzdWp63CUu02zgSoM5SZ8lAir5iTZInMoAQxVthbDwEj4smNI1oejxSGFU4qrCqLJjGoAjgYlF/fGv01k344PZhCHz1sZ2/8RV47PT07m10sPvPfhT+8Ec8b0783d8c/MO/EU/uzO82wzu3Fm+963wzXCza1z8oGynLAcBZHeT8f/q/idbKxtCdPVk+eLo4sTV94hyd2izcaRcAFgGv7fLL1+DF75pzk9HlCTy+014825QWWijEmvFgpxi2tH/33r29xazaGpexvemETIEiRMg+gDMcoSzLvb3955//9uNPP3Pi5ClkcNbWjSe0jBBCAPNJiUurJPeTW58RrbHcv6LtE+4nP3F2fWZS17W19szZs48+9sSHH3748bUPy8ICmTYsAf06lTjZs1VrVke/fkiAASTnweoVVyPqUaArEqWulmMUvqM3IlCZgpgxwSBHXQB2UW6ECBYpQsLM01IYBEim8xR3LgwStYoAGILsxAEAAO4BLVJvZaCDs1ImKx3EpXSImlkQZJVFmRIA+NDoDyH4oiiUYYOQ914zaauq0k5iy7Ys1aFvhXKtu8IVCBSDOFeicYGlbUJT7w3KEo7c5Hd3d+v2dlHYsnRaAa2qKhWj9lgKICKAY/egUwv0w1VaiTHd8/RxY6htWyJSk5SQpiQBEnYVXnTbuoOHknIIeybHnANyJLCg+xat2yKlC7PgrmiWRcqg9/3v9n9QKz1zWFNBIgjIMSWd8gihd6jwOCwQ/St3kk51UkifCHWKXj/kIBFQtz7LhpiXK3XeaSA5KIQQ53UdIoUQBoNBWRaLxcLHYIwlp0p3sgOvh1UiLq/pq9OU1cSipabVA5jH1TAXtdd571XpVgrGfn3qTkvofyurd9k65WMgIlsUxln2PnDU+rEWLWEq2NKtPDGzMctlX66SCGSImPRhZyYlKIrypZdeevrpZzc3t7dO7BQCjY/qGVvrRBkeGWjbWiSiRA4tWRJgIUqlz3rmHhGxxjJHdTOn84/Utu14tN3MPri5mO/aYW0sxwVwDMjt7O4XaPTkzrkTZ0+VQrMPPt5o2+GZzTxyYwy88xE8ddmemtCUXeWcKeLePgMER0SAXqBtTFGKJWMtN35YDcAHawsyJgqrrkqkcbkkkVkiGg+ElpC7CDh1Z1sfgT3MavEeWawxVBWIAIPSjQYQAdrAVswAeX82f+fDja+/cvD2e83J8cbf+Nni0UsejX/9PfPDtwZ//LyPMPjZny1+5YvFuZP1N153b193hwehmQ/On+HNCRdFceoEfO+16RtvAPyjNNtvfsuBGHA4HMj2RtycmMF4cOEsnJqEB07az16lx843V7brg9b+q1eH378Gf/JGcelE/PKT5pEL4JDbBdV2UIx2fu1Ljz7/9e/fvO4ubjlTqpaxmE8HgxLI+hCkbbe2tm58/PGLz7/wm3/ztxfzma2qwjpEDD5mtIY/ezsq3o5+8hfR/qJ1mk+YQp9VfnLTi42gnD59end398FLD9+6cbMNsbDL0K6cWKDnMUK2NEu6Cwmwum31VrY6rsRkBRjWd0H/vhyn9AbfPb2SFICcarOpkx3T/S0bMNSgGtXakdEIobv/SEI2WxkeQp4a9e4GnSzA/Cv3CkRId/eGnvTUTqwjQI4x3r17F0AxnSMgNLUfj8dqmdA7att6ETFkNCHZGINhuUSGDAGmjFcQAtTgmzYE51xUk7waOYgWTUNEMbJatSHB9BxOJpPkUlmxjfduhFlXWhKEWqW7sGroiZ8sVEREc2BEhChBwWdxCgDMfZEGIhIVhairi5ahGvJXVLlbK+XFzLIKftWXXvqk6Zkrssa3JmhFRKtgrK4A6w4RUYRUwyxvuVa7yoINUTUqgCjZrZtXQ0M3Vym7F7az/JCZ06HKNhWiJUs65lR3cc6qqFprjTGWyDl34sSJ8+fPf3z9Q++tpGgjleXCzH347kRevcp5awpT+hBWFg2OYyLShXYqRGzTNHfv3tWTk5BGl9Gyy+9Sh3ynE+nPV5eiruvAMYQQI5euAAAOQUC1wXxoGYBF1tIUuzPJTGbpKctjMMa2rT88PPz2t7/5yKOPlmVZlENLqT479pyN+i1rU/UZgwQijJp70hmxDGLMLhg9FD7GiHm+aRWJQe7ODq61fm+4HQ0RMJE1wqdErp469XAoN7HY/tXPL37w7u1/+dzmZy7ltRr8zON3796hd98pn728+PgWb4wdOG6bcmMi4yEAWGOCeLIGjfG+JSIgauq2qErptnXJNbulaIMnIkUrSyZMYQLgw5lE9rMFEdlBaYYVbAyQIBoi6zgGMMglENf2gxvmhdewgsFv/pzd3HRk+eW37Pu34nOv3fvxB4vTZzb+1pfiI2eKt9+997/7v5W1r77yDHzpir/8tL30AFVlLcEczvjkObe5DV/rCOPKA84HG7AWbo34dr65WPD+vXmMgWjw/96yl85XX37C/NwTzb/3pcUbt/kPX7V/9Eb5jVfh8xfjzz2GD1+oxzDgUDz+0JNf+Nl3/tW/mglveD5gAyQQuayqhQ/KbYfDUQjh+9978bOf/ezFhx8OTeuqMh2rogixXT96vfYXLc7/zW/3W4G+UPxUOgcJAA+H41Nnz1x97PHr1z768L23EVM0N/bQAtMp7nwTIBA7VKx+LB1AQgdPP0i6F/QLWUcQqwxtdcz6FaAjw6ZjuZ9Alxto9FUALCnzKPepzDAVQhMJa/iKgKmCfJpVp4B0q5eSFXrQ0jm0EHqJkNA5tfXqrSmZiKBFCo0xRPHw8FDXs21bANSETYjAzG0IGGMry4SxxbyOtiBnowizgCFHljnkDICM9aD6iog0TRNCUKRyY1FhQrpqsYh4HKJUn3evCUI4IrZ1OTqIe+SuLrAu0JoYWwuI0oQgSpCGohKr/4Axy5418lY6h0V/tAkJUQQMWWuxk8fSCzjNw8jDXvsrAHRqlQgBAxOkzccEJJdoMRNmzOC4JGCQRSIwIIJBYRHoYwctZZ6IGOp0vmQiC4pZmfBEewdVRLgDc+jCZ5aLr7VbkwbK3C7qe94nUR0CAIpAjEFFuCFkv9wR3VPVEfsbulQ1jmx0nzxgVQeXHg6H7WrDQle6rxfXuczd1VXvLi4rmW8KYBxi0McK6xRS1y5Tl1WXWpbdOZY+Ffkrf6KOM2YOgYqicM6+/fZb3/3O87/0K78WBYaDkfQopNt6BADnHKJYIusIGiRj0CBLlChd0PUSAFZ5CqWKYBEABTQUBH1bX9vduwFw6EhMACZjChfbyzU8WoynLg7aFt68TSz21OTgzXcATqY+iU6cPxNu7rn92hcYAKFtGUFKAms4REJjqzISkjV1PR+Px8FHNBQRjCEgFEQQCcDATISAmg0FSIQAEqOuOWpuu1blLSyUjsZDGJZSOS/RMvi2ZbJuPORwEN/+gH7w+vjl92/O744bHsk+vP3x4Ydv+OagtOWZpy6FJy/Ce++H/+cflod+8/Ip/w9+Kf76Vw6r0fBe8N9+Ody6HRYH9e27fDAd9u5Vi7ppfbBBSMAQGW/AOTRQjWwoLM734/N34Y334Fs/KH/9F/yTj9T/8a/xFx/x/+T32//7H8Fzrw5//tnyK5/bv7JhNocP/PavXPneq7d2r5dbWKJbGD8oi6ZtI0s1GGLwi9m8KsqPr33wrW/+yd9/4EI5tACg10GW+1aR/WlVjaN3hmNuEX8F25/LLJTtG2Oa4Le2Tpx74OLVJx6/feuGrxfGpPtSFy0BevC5S6cHVUc64wEl+d8ZI/ReB4ln0hGkDqRkx12yd0xPAvTnJslhLxZEcnZKx9I5ahpa9wrEDqIXQBHzkrcFus6XSMqd0YVFgVCV8UifbXWrtBQknbFAL8b5ASIyiZ1S69uySnxYDc+uLJ/6mWdef/11xZuYzxeIYIyp69qaIngvCKIJBd0yPXz50nv37i2axlhjnG2aJkYPIBoOmO3cKrX1hyeffPLOnTsHBwdkYHt7+9y5c2+88YYqdh02AOaFWwoS6F1nVeZJcqYkEC3oZBIR5aA8LUaqy5G8X0QkOf2yZ+HATuNJ2uoxZ5iZNcqvHyqor2aQdZ9KEumASGCSbwWRDBIzCywND+tf61PVctbJAoSi5QGzlQO6ZzCCYEcugoCG1JrHIDpqZobs+kGAbg3zHVMzQDp9LoqAMQaZOQVDIXRBM9hT1UiWtkQtHQ6GRGQ4HAKw937v7j0GAgBjc3GT1JtWHDGpziEjGrTGIOSYoCVxJ7LOa7LUlmLnvTqqww0Gg6ZpcDUAaDQaed8sS/6JaOaO4pD2v97/2WqGmzUxxhACMIe2LUcD/Xq3m5yoCVes32ujYs74pEmhUd3c+5ZjfP7555599rMPXX40hCB2RfnGZZO2bTXHLDAbVwiJMJnV6Bzo1FxDYsgCJ+B8EQQk54wzcK9eHBSDhQVg71lIiOa7m4Pqc27zwoVzW09dhe+8efDxjVOPXfDNGP4odd7c3qtM6cYTuL4fShmcmsDdg2I89IVBCWHRBgE7rLS2s3MO0DB4WziwRiyB6sGCBCYRFSKQsWryiMIxxhDARxABATOswFlDiKWD0rFBtIYiWmugBUGH4ut3Pzr84+cHP3p3cDA9s3OS3/xw9+Y98a2pbDU5Eea139/f+2evbgxOuM8/eeuXnx39zBPD3RZfumve/J558ztmKjCTIhojBqBp/AHAYzrZQRiQIWNQOEQJLDxdxGIuaD2NnAxLPGFiu2h/9Eb52jXz+SfHv/XX5Weu8sV/SP+vbza//9ze/+V33Q/fLP/BF6uf/0xz5cLlJx97+0/ebzaaQ9caQEJV8RMjbhZ1VZUE8IPvvfj0s888/dnPxWgUiFptt/dnFz91kx7GT/71z7H/v/x2P3a6dj85dpr97xbGCFFgLsrBzs7Ogw8+9N6FC2+8/lpVaLkDZchZLRCCJJVF36WhUswkiKC1UlCTP1GjqzqjhTAr2+1fqj+N2iSwRLkUZqSl11skGcKjCCoYBqBmdhgy+QKpioB2YjteFEWAVccHyWicPVO9/pB8zb11kyNrmBUR5fDOGIhA+ntgAwiR33//fQWdQiRFJlVtj5CjsNa+JqSscFy4cGFY14um8TE4ckRkkIajhPfVA01I8OrU4WmxBGS8fft2Xdfee9shJuWkx2SS0CzeLG+wu4L37UtxmTskLEETSomMtTbGgIgsgcAm/h5TEhEAmF4QR7YtAECCSOpEbyZH6YOZdAaJtPTGSI4CWuX1tAK0hXrx5J7CIb3MjnzzRvX9ZbWm61pS4fXlKzq5tTxD/RXr623Qg/1YoQmRFKXXqbTUA6JAjUnSLBUEdR9QigDB7JbSt6vgtIWbzWaISJRmhGBFIgKBAFGaewg+cARQWD1hECAkawSBYz/QYWkGZF43fYlGuuaT0AufBgANWdUqPgCgP2jCc9dzUlayRsKplAxiL8NoyaQiS4iW7NbWVlVVu7t3Y4xr/o68zn2dSf9qbYqTBQBrrVZdZ2YiF2OsytIYfO+99772ta/92+cftMYhOUk3HoSeOS76plnUIQSOEGM01iCBEBsS9XGm4kEAEaKIhNg654Q5xkhkdWOLolgsDm8dHh4KemBDEc2wcuNh2D+3teOHdu/dj7agXDTNPZ7Du++f/udPp4n8LwlObOx9eHNUnoinN6t5iE1zeLC/deqkKZ0pCtdC0zR2WMU6NL4dbW40TWuMASK0xoOQoEFAQ4S644mxxdar8xEjm8jsI7GQQBgBOcOFgcJGkihcMhqGOtaGjRGQg/3m5bfaH71Z7k3h5KSezqs7u9X0ni8LvkuLaBZVoG179u/8+/HZS3D1wum2bb7+SvvGu/jeR5MFwMbJg6vbo6sXjatmd/bDgsfFFvxnezrf8t//H4M1woGbufgWxBeL6fTePfn41vjmtNqtaVK60RAF29t36cUfwUe3+Rd/jv7WL1f/+N+pHrsY/+kfzJ7/UfXeO/Ob99zf+tVH/sGvvvmDb9/c3ZPzo4LcvG1dUfnWp8BkY0IIW5uTvf2973zn+cuPXimEh8MxM1tr+l7gP5cmfTPeX/32KRWmnzhrEfHeg3UAcGLn1Lnz559++unbN28c7t+DFHiUnL/c5TxmJo9IkIMP1bPZXUQIALRE7JH3IiYc5/4Y9A9rA+v/S2QU80OWsfwowkCJZ3fczCSbTG/W+U0EGLoSEyCCWW0CYGFRx303khW5sJqJnZXX/i50IpKKoorsFb1Drc6LRX1vf+/hhx9u2/bWrduIGEJommY4HIYoEJgRmuC5V/LslZdeur6/X41HbdswQulc9GFvb0+ljJatBwA9RCoIXn/99aIoiqLQBIKDg4OyLC0jqSy3ZIQlRiaiwrlUh7oTnJ4jERlnDWAIIcQoAKhJwfomMCBiNOeGmTTPAixEgYRQpVUkmLUWVLcyhDQsiqIovPfzpg4xlbzLcqgrH5/Eia4OI6A1IOKA0l2sR9DWGMkyLMnLCKBAKkkg5V1J12hDuj/6+ZKgnenc8xR9EBatVIeGIkcJver2ISq+3ZKOM+2mivOMkI0BxBGEpQUpC2csBs8cBMEgCXMgrfODwAC6YalPZyKzMBtI79Lo7aJIVzFNTo5RlRibL2fMLMCUanlwqcXnWBDIGcshzqczEdFAFVr1eHkOZBwmK5fKaSJrEaStG90UQAxdXisRxRAIMYSWFBwleiJAYRZFqsyagcTIIgHRqK9R43attU1TG2OIDBnyi2Y0GilQ+sHB3s7O5Xv3WIE9tIzhcDg8ODgQEa2lJ1rTEbKShzFKIkkAZs2SJ8VRDSG4gjRQ9NVXX37/3TcfvnzVSCkiMchgVM7nc0NYWCvIEulgd6+ch4GP0WI5KGTelOhEIqdUWBCIwoLCEkNA3hA4DC3a0kUrG6NYYSXw0nd+8DyZ98djh7DwBkrC/dsnEL443nng5Emp4I0ffncc4bHHH4nNkhU2B7s4NuPLZ+1u42b1wU65wVRsjBeDclAMw96hCaEcj9s2SBtHkzHXLREIso+hAEsRkQTQgNM0NkROVyFmRq2KEiIAsEMoShoMyAG5sbfgSxw0jUFGZ3HOrmBceCrN3Vdeu/17f7L17o2tje29O/fCwYe357XYqrVxcvnC6NIjp778xXj1cnNwaBcLeeHF9odvFu9eR7Lx4ulw6Zx96tLGIxf45DZEO4ISrAkG4T/7ncRV/oNfEZQgAREciqtKOLRw70Z759bsvfdvvvgyvXntxDwOIsKjF3nh/Tvvl7d3Yfdm/dtf4l99Rr74xN4/+Z3mv/7vtv/3/2Tuy+3f+sW/8+/9u3v/1f+13d1/89y49FSymUnrkStLoWnZUoxcle7F77zwzGc+9/kvfFFCrIaDum2os5zRKn7ln05p6AuGoz18GuF9vzf+WSwlx/b5Ezv85Lnf7+t9i1G/B0JEYYuA7Bn47MULdw/2Llx7/NWXXiwYsfUYuUUxzoZZO7RljV4FMIgREbXMEQAnFMskR9Sgi4REJoqAiEJSIgOAlEghQlHaEDwRGOfaNgCAIRtbj6j1oKOI1pFFRAL2KZAiASYFESFD0mmmZBGElCX22akk36pmEoi1yYOveoiGqgNQ6kWvWv0VRgah2NN+EAgAjbPRBxGxlOQR6uQZg28QsYtpFc9BDFtry7KcTqd6IRSRwWCgKooxBgIPihJ46Xfaa2ZUFRrpBSzeexSwhbNkpIt/SMoQETMbi4NhQppQxzpzDMFb7hIpEwImERnDHfCldCmd1OEW5Ju6inPoVQaBzr20NA+IREzriACAECmF82Y1T5jbtmXmkJIAVoh1zRSRENAkhQEbY/SmjogJ1J7AkjHGRBAKK+4uUQzOVW8RdDpKunwnbSBFdFJXDj4fEsGcQZ3mGLtCoEaZuNZ/Wj1lqE4lUS2WtaQZIhlDShbpug9gUuQzRhbM9iRDqQxNTpdK4CXLYN6khzEoWkkOx1FrQd+91yf9vi9QvxI4ECgaqd7s1VmGMXodGIAYg0To2c/rhUWX+18zOyt9r3BSWCrm2Yahr0awetpiFGsphDAajWMMbetVIZ7NZsPhkIgWi8Wrr766sTHRL2ZwemZWfQtTBEmEXtwxy9GgP0TEGAURF/NmNB4YYz788IPf+73f+4/+wwehKI1zBqCua+ccgvi2HY0GWAdhJlH3cALfZEJk1tpFHLz3DCIOXVUWwiEwIBpnLCPF0I7Kzbv37r42279dYu3IRAGCCGJ9ODcqN8QSmBOPPVxFvvuDN/Y/vDPY2ckjdic39w4OxocN7OzsxYOteRHjnhsMAAmMaep6VBTC3pghWwARNGQIwRAZq0cVDagpOIqQEUDkGAXAodHwGSBEa0xhsSxgWMYCKLD14DRtm4X35zxl48Pe6cK9+/bNf/a7i3de3qoX9d6126FGbjbPP7nzhV+ERx41l8/BCGBxKN//Hh00cuMev3eTFwu+fJ4+eyU+8SCf2wZboXHQRAYJ5Js2Wr9kAvGNdxSSDkmYOVobd0o3qobnr8izVzd/9nP4xrvhhZdufeflyQe3N8ej8uSGj8zffc1MF9VXPifPXH7oP/ofyYnt27/zr+L/8b9FXGz8vV/5lW+/dPc7X7s3GUR0B2FRlCUCspaNdAWJVI5i0377m9988NLlEzun0BqCZXbVJ1zNjxD/n6Z9yi/+tP1/Gr1hzYR57Oc/bfuUy5Ubqytcb1mEo8H4zOlzly89cu3dN+/duDGuKhFx1gaORVEAoHBXgEqjvLPj0gB0nA06/r/y3mXaGgKgM0ai3gbBNy0hEtnZbDoajDr3OYiI1isAjQRIDFL6gPTYQWgLaPzn+gR1PGv5rp0NVbklAUhfpPa/CHKEx5IApjyMrLzqtAVAJLLGY5BWFUtV3UtrX/nRy8Ph8NzpMyKyt7e3mC7G43HLTTJRmIS3q42IDJpMCTkDWXMG+0TS6RzLwp95IiJikUXBzWLXr4bjDaqqbdumbRUOgYiMIYPU/dwBaHbyeLmRhpDIdgW0AjBJsilJV/Kce0E72GFCLEsW9cA/eiMWNddwQghNWkiMIaVZdxWeGcF2oTqaIECa6aGhGN1bVk9XssBTJ6FBzTJEHNP0ERMQktJ0BK1m0sUogLBikyfn23psc6KkRE/Y/Qe2q3nIzCKqbjDAErMk1X7r7lXIAKs6U2d4SFGfupam0xqNcwk03UAumIOYTExaz4C7IpnMjGapC661rPNlnSzG6FyBneMjLykzKxQqrpj+ABIOeML1k1RTBhlEfDDGEFrEYIwzhi9evAgA165dU1ufQvE3TWOt3dzcPDjY15Sc+XyukP7j8Xh3d7eua0Vu7RYGATky4yp19Yc6Ho/m85nWMyyK4rXXXnn1tR999otfEYhExIGdtciqDlJs2li3wowSjRZGJgIi1EJ0IqKAtmhFIAShlufEBFYiNBgMIPr4w/fe/D7XN8phTTKMqiPLMPhHixOXzj/Q7k9vvfqWPWzGw43rN+5tULHcghpObG3v7x8WCMNTW7Ux8b3dwXhMxkIbkCNYBEtEgMaIMBrDIIYIjAkxkiEQChIVJtiBODKk9hh0oCtjDQ1KKS07KwUZlEBirQFhYJDa470ZeoJBVYpc/5Pn5IUfThb3ZtFPAYonrp698oXimav0yBW5M/Nvv83zKYVY7x6Mb19D6+TUqD33kH/sweKBs0U1hqk95GllnXG2kRjbZlQHWixLScNb7xhVr0Vi3XgAPlUaN5Ctk2F7C7dH5Zc+U5w/Pb/6QPOH37l5/V61qDeLAcxq+eEbPjaO6t0nn9r+e39n6+yp2f/5v8T/+p+FYrz5b/3sV37w/P6ddvdUdRPZFRbnbahbLovoPcfoymJUDd5648dvvP7az//1075uyFktXyw9szb0OOnxB6Z39j+NzP6zyPWf2H6iRaQ/o5+qn0/5xU85ntilV/jAErkozPb29kMPPfTxI4/M7u1zZDQYQojCSCZmBw0nrUJDONSlASJETJDKwqYQyqSJaNqsARWcwkG8jgu7cEsiKIpeNXXNh+wcOAnAY8XdCnplhSSPDfQUkf7lUB/tvpL+D8kblPq31srqdQ1XKYSRERUpTICQWwUiAU5pugAAkTsgskS6plORgAirqlosFuPxBgDs7u5vbm5Op1MwtL29XVXV3bt3Q/TLfYkcc11uAc6xFr1T0Kcljph8Wr0ZIJLNeSWGCIhUihRFYZ0LMeHSZ5LKkRN9k4N+aDSMON+VUV0rDLg+lDVSIwJkZExqQa4Ku3YpZ44mOTeoKFwQbttWJNkAREQXmkUgQgvAzD4GVgw1NcyoVim9Xe/RfT+GAzNsBgCkMoTLKUTQKvNdJcBVDTc/iV1CVN4wItKSQvqYMIoIAjKwuhc1nEk9RJGEAFhidj5J52rM25Flp34yHA4RcTqdep+K7oqWB2QGYPUl6RctUoecqBCwKZxCRAgNIZJku7HJoGTYhVZAhyhfVZVJxZBWVkBEpIcMJynCC7ED/lyG4CAAGBFRPEfonLhEpIgxdV0rfYpICOHs2bMxxrqut7a2mqZRCLjBYDCZTMqyPDg4QESr8AlBjagiGvvS0ckaW6+qKgRGJGuMiFSD4vDw4I/+6KsPXrm6tXmiGAwK59q2dWSc5kn5lmO0ggRIWlVa2RwDkoC6VQA1NCYGISAsCscYfcOl7AwG9Wzx9o1b16iYFYUHBjYEBmIzCe0j5dAN7IaXj998zwbZHI69jeyWmnecHuzP9gbnz4S9fQxSPf7gQm9CKGF6OKwG0aApHDMzEoIYQ+w9iaAx3AZExg7AikQMIJAYBCJgESQU44wzUDq0JoJwjK4JTWVs4aCOi3qOe3N7sLCT4fTBYvzHL+3/zh+4GArZ2Co33FNPlb/21/jEhG/t0le/Lfu3xUZ2ZblH7sO6PQXFxVP4yP+Huf9qtiTL0gOxtdYWLo66Om5okRGZkbIys7qqu6oLjWo0GujBEAZwABBDYUb8AvIP8IWP/ANjfJgHGh+GNHJgRgOBAdC6urpEZskskZUyRIYWVx7hYu+9Fh+2ux+/90ZkZTUaA24Lu3GvHz/uWy69vnVBbW/JaOyFcFagwMh7mO5D5TR48o5E9ym4QgKtQBCYKQFETIsB7Ffw5L4dPnZbk3D2NJ47s3r2PF0+N3//pvzixuFHd+281Jlx9x+a7/9sdXBqdtbo33olPfWv8P/yrw//X99d+T/9s6tvv7LxrV9MM00T61yVMxqdcpYU7K0yZVllmfZ1/Zd//ufXr7+ysXUqs0l9NGmufwbhc9tJcvzM9p9V2oDe8fybffdvvXvPtKYARL6uohM+MqPUZqc2t1+8cv3xvUe3bnw6GGahdqjIBY+IOlaxpybjO5YkY5ZG2QCQplLBUanoKCoPACVaxeBxEgLkoq7Q10brqBd1gmYjXwiBWtZYOTqcxsLdlQlvri6RqY+hJnZ1AZfPQcTWlNIUucXGJxB97C1cBzbAIxit4VrHMLKOZbdO6qaGpnCsIgPC4BHSfAikP/70U2l5ST4cl3WRJEmWZYjYnyFs8EMg6qrYBSn2l+5EPmMbQbscmm6d+iG0kZLMXNd17VwMHdBaqzYIwIeAnardM1JFhiHRUMBLdTnmOEVpSCMBoRIQwD6OY4gJsdg6wJ+1I/t7pcsX6kbYyEDYWBc6vnWcJTey8DOqj0qL99BcoUYqbJwFPTtVrJnDbd62tPGJ0TJE1MBlNs9vMeP6JypmRUIUwxvJgyOn6i0vN3XAW9zV7pncGmmWfsEYP+F9VVWtIa4RAbXWIqELbmrHy51FJz4zAqM1QRXtB32SyixLwVSpGAfkPWutsZtCgOY0xpmWdouKdKvHzB3ILDY3NeNSSkVvYnsm5f79+8658XgcS+oAwGAwWFtbCyFMp9PZbNpIxlovFosPP/wwSZIkSdI0BcC6ruu6gaFTCrV+bl7SfD4naoKe6sprQ1me/OqDX/7wne/+nd/7Zp7nAcA7VgaRGrB5BUgKFGAA8N5rZkHNIVitjbHBeVc69mzIJEnCoVJKsWcvbElnynz65OFjCAfZRDQmDCTknE/q6WmrL00mYTHlSgZGE/K8nKqBWVsbd731k8x/9ig7cy5kuDicmkf7NktFkzBAxZCqACLAigkIyShQCpyLdE3HWhCKNBBiE63WybDeGCRBRFGEhBIYIXqsSUTE1zgt/GJhaoZB4reGg/nh7f/wJ3z/4cZomImevPgqvPoG36nVn/yZQ5oNrFrJFfmsYkl8+ZKh85frM1v+9Dplo0Q0llUV6pqCerqDnz7KZsFsroS1vDSMLVgQAMDFcyLAIqS1AUBjIGjgGtCx1OJ9/WTXlKxHI3j52vD8GfjSy7Mf/Lx891d0/6naXcDgED56365bm67Xl1/h//Pp+r/7/wz/9XfP/tE3L//49r35bGVze7/yVmVM3oUQiRcCeOdSa+/cvPHO977zB3/4D9M07bZOn2hIq3f1t9bzePMJzvSMTz/nhv952vPkks/v/H9iOyp8tDUZogYY2Bizubl55szZCxcv37l313OI0A6CEoQ1SlMcGwAabCQGFELT63mT5Bh/Pzqwxsdeu4qZgZAIvffGqixLFosFapS2UFqkWJ1Noy/ELKkl+OWIBNoEGjiJHdfwpkajE4lhJa1pP7RAANhkWrRCiUD7Iun9IU1cLDb/sMVdlSXcgEiPm9QSfF0CgU5tjLFwzs2rQiE8ffo0hlQaa8E1+r9C6keiYGNFYupV8ICj2zg2YQJYwl/pOviIDeqdU0rZJEHESPqbOAbEvlzW1VGLj25sLD3dFwBCy9Sjix27cQqIQADpR3wLM0Rwtl7Z1f4vssy5jcyPvfedeBQlVYlBHYQUoVOaaCEirbGDKz2xvzsmdIS5IhAe508dABzEGWHooE7i2JGF2TMAatVNt1oi1EE0AEWJrBsRKeAQO6AAoal1jtx6agRAmtkTAUIgjBlTFJ8cBcQmVQzn83mU/IjI+9p70jpWvMfeke4ksKVYLSLU2goDBwHsT343VzGiNkmS4XBYlmU988ys8HgMXWzM3E4jh9CKO43AFD0REYOneZfzlUBAIgUKgK21RLiyMinLUina3t7e399fLBYfffThaDQajUYRd6Sua2ttlmVxT0Zc5I5mtcOMx/UZtFJExuMBItZ1HZ01IJQm6cHh3nf+6q+uXbs2mayGAMYYrcm7WuWpY465td22h1ZgEkbHLjjP7KNdFklcCFQKMJpBlmZmdzr78f2797Q5RCuhSpQCrdD7SRVe39w8t7mmZ8XOo716ZMZplpRsfRj8Dy3O9796muhTmxfOwt6BWh0PTq0Xj3az1TGnlpm10lzWnFgXeAA6Ti1EWEARiLWHWDpq3uKJEpACUpQYRGHmIBDhSFUM+h9bXSxkPodpkVZixkNYsYuRZP/up/d/+YutPFFlPd5c82ld/PKH9tEcLp5KJmt2ZaVSsnjylJBle1yfW5lMzskklyQNXsJipvenyc40KapFzrA2hCsrcG5LTXIGpU0K8KhZoK31yjsA0sbEbh9Coe0KgsLC47wwriZfyrw8rAeJ1emV88OzG/XFM+FPfhw+uOHu7+Oje+7pKmpjk+35pfW1f/VH9k9+uP+0vvryxR988LPVOpQMoqWufOVKMaZ0LstT771SOBmN3vned1979Y00H6gk6Q77MerxRaSNL96Osfz/xAf+pnLMMbZx8mnyn8Ha0X+j0uS9ZxGUpqKYMTQaZOcuXLqyu3Pz7q17t29ZbcTXxmgEDxA6ZA5p0kmP+CLaEypRdI6/9AbMMSrC2nSxWKRpaowqimJ7e2t9ffXTTz91LIjMAUUax83zJiR+JtDAOcZgDlniei35Qnulod6M0b4dCJo4i/4rjs82NUAjkeU1eAyxAKdwvIKKIjfU0XTZPiRAoDYCURkVDclJmh0eHnrvx+NxURQoFDjEiMZ+/aDIhAAadNROiURpKuvC0c0jvfkBIGnlPM0tv2cRCUG3oNcxklR69nMFSKS4cZUtQ1oiZ49F/6jNL8ImQIUayFFmEvDCS+V6qZ/3/DUI6gRj6Ga8k2mcc0LLsaEAQQuXAaAAkTDEuBvEmM3BrXeDelPT/ZTWUBHdAP1Tuty40LwLEVFTXVZEpBp0/CY8SETC0XIeEb9iyb/7ZliM5yS63pbWjqbyDDPBch9HqWNZRL5N1O5WVRvdbC5Fy12tgH2bncXcoVbE6OD2qEhzbOJPhcAN3no7CoqsqIvNXEqc2Fvuoy1+2sk3R6Q3EcRl9LG01rIoHolImiYiMhqNNjY2bt68mef5ZDKZTqfxK0VRxLiNrswbLGvg8Ww2h8YNHLE9OOatKKVPknJEPHvu9NOnT4uiSJLEGHN4eFhVlTXpo3t3f/TOO1ubZ7LhOM1ThgCIQBhEAsT0jlhQDBQSKEWkvPd1XQMHo4xWCgM4Vwr51OlgrBrlGuFXn332Xnlwa2AXWjMXhnzQiB5OMb26sZ0YtVhUA5vUhIvajYxdWRl0HVbGzA4OlNY0LZOiImuzIGBsQBIk5QUQQBuyBkpESwIQ2hQ1X9dKKaV0zb5JBUBEJFBKxIDWMTwrZhEKAiEBKlDKeWdmNc4WHhEGGUyGkAjfufvRt769/uBwU2hnQPk4H9w/ULM9e2XryasX17Ohcpzs7wM4vb4B5y9Ozmz7xUwvQnJ4AIt5XRW198RBZyofb8O5Sb01KAk1KKMTSbLlVtGEAcF7YBYfGDFLyAKAVpAmkA9BKlcXLB6dTzGDikujw1svmGGqvzVafO/n+sHO4MG8Wq9rXeZ3Z/jCucVArby/v3L1TP7he8XBIsnSQjtMVR5QrHXICASBnfPZ0D59/PgHP/jB1ukzuTF4NLCsTwaP7u2/CT/+TaWW58kEz/vu59//vE+f96i/XZnj5MEUEcCAICyNk319c+vC5Ssvv/7G/t5ONZ3qiLmgqEUHl8j4pAlgQMdx55NQ1JZBJAQOWuvoBgVoBAiBWH9Va5NwgFp8CGE+KwLI4XyWJEkkJ8LEEbQcjsOHKyRsKyEg6CX9b/GtnjljRy+2IcldSkpEKj9aMhARYensJgAkaLIlgIBBvLTcJ1ZKwuhPB245jiACggCzExK4fu3FnZ2d+eHBaDyazxfDwaCaF3makVYtYuTy1eqoZ4qIFGLfon+8qz1mF3VkZtZdzCYAOA71fNZxiMioqM+PmWvf4GFg64mP1vslzkTo3POIiE6peA+2ERQNGHnnTeukIUJChGflu3cyQS+SoNEvNbbuu7iELRxEEIZ+VEH82UPsgKMbvcvKWc5Ry6ehM1VF6QoREbVuMoRjjoK1Nk1TrfXTnR2OScCd7yB6ZyAgqvhBt1lFuJW7m07GmuHQluvT0i5w/DiwqCUGVwNBDQIAi7Kw1hJSU19YayIKwsDcTyzqL27XuhwT5ujjRxCJO7tNpoIQvNYmBCmKRQgxM9qbxLah3d32Wi4NA8ZC7ctXIEIj6EDny4vLqhWJiHPeWrO1tbVYLIaj3FiVJMn+/n5EyQWANE0Xi0X0gERjWzS9xlBWY4wItL68ppwcNzL0M3zwAHDr1g1mIIUxKDVNM0RwzqVG/ejdH/zWb339/OUhM/vglKLKRcjwBgwAEWMEcQyUV0qh1RJIIYIwIAIyEadCU+a5K6ksP7x/9zaXD6z1ac5uFjCU4KzISGjD2unhPhg9gKx2BSPs1IuVcxtdn+0oh6K0+zVrmhvQ4ti5TOsqcELaVZWZDMlomw9lMdNaA4p3dZIkqJUrnVIKlDZGosDBAkAaSJEWIIUuSKRFRKSUEAoSEsz3DlYOKgihnuQ+SeqMsvkcfnF7//2PN0KQLL988SrMCbisN5WeDLfqCuYLfzhVBOFU6l/aklTjk51yLUnQa1+JVNogDzIZpW6YarXuB5pnYewBcgsjKmUZqkYgtq7r6QKC6CCojVKZwAGnwmuJW8lYtJJBVieGdoDAVVUGiayvLwY2RZiA2vv4V4MffJZsXYTrACmE4JPxhn99bd3f2FpbqQOlSHuhypOcAOu6Akjm83meGqLUlUVqk7/+9rffeOvtF4aDPg09Rk+PUaqT9Pc3ar+p8PFFnvO81hlsjrXPf+8Xlzm+iGDU/917F2lSvKgQRIJ3QZtsNB5fvHzp1ifnbr3/y9FotDvdA6sVIIiKnF+kI42EyFHr6Nao5UG9gEKSRuYQqSufZVlZluw5TfOD2XT3cNcY470n0hjD61F1+rK03oxYTQEjiAZLL0ZKdcPH3qQ1X++mXSRaQRARGiMyRIW/xyaaUYkIYlMLaUm+o8GGYuZZ62QI3CJfKhYPIoyMiBEOGYCtsXVdf/rJx1VVr6+tjUaje/W9xXxqVVJVFVSgjFYEXfE2VzmvJLKSqHBareVonYq+Yvk8QVYrAQIMRMKMIcbZUePHMgbbBArVhkf0FVZsEUgI0cXqJwLGmEj9t7e3nz59Wtf1ymQiPkwXcyRiBHZeGdPfbY1tVwREEDGWu428JFallzZWI7498pj4Uc0NXHeT7Itx1gU72NkY8SAQIqoHLH2u1BNTIuJ0TKkVES9LMRYAoIHfaJDaY7VM6YrBKoVEPoTArJOki4hkWO4VEiUNWjmTiscJRSBAjY2Jo0tzRRStECQW/iEEUiASU7dJ2jhpXALSA0BCRhwziYpJpizIoJV27JE6x9MywMU1hZKXbDiGDcYyiwzAFBODlSDGyNk6BEVKk0ZBTZpIBV6iqzVPoUasRIWiMCBI4Kawu4gLIUmz+Xw+HIxAxDtnjPVVbUkBUl1X2qDS8uD+Z8x84fxb0+nUh3J9Y1IsnASx1jrnI36GQgiBpa2lolSDB98h9DH7KAfHHYWtLVHa1mw/VgTQll3EmM2ltQ4kn9y6+Vff/rN/uj42Go1NGFApa5KEhtkMPTND7UVpIQ1ANQUSINEUggSWENGMIXjlsuFi58HqyvCDxeMPaz4YndpJfOoe5SovK58lbrM++J0Ll0+tnILDA1ws9o0HEk1ELlQPngC80Mztzz6zv3Mdrg3Dx/cGBUxX1GiQQaABEs4X+1IPDVjKdnb21u2AIYCA1YZ9IBabaCQIoQC2oJEVOA6KKDFKAjEgxeMHiJogGnadh7JKH89qa+zGmk10HgB07eYP5//vf7v+4GBtsjU5e44VEO+DkXy8Zs5cFUSfG7Q5Dof5hU1PVB/M9SBNE6MHazXNcbBJKVISo6cJlNeurhezQpt0AFxxcEsrgp/NfbHQBFoZr0gITe2R2U9Lni3SnYqGOaQJJIBsxdVaUaAQFlWWDMP1q3srk+xfT3d+9dn6g/vwyrafee2GfqjUCIdf/ftv/8df+g+/9/TUub15msyL2lZBjbUEMGQiEoPSIMJc//F/+Df/+7Pbg+FYKW3SxAehWNwYlg7yY4T1i1zpt+fx78//Vp++P4/En7zSsQf4DYSb57pm/mbjel6jtgbKMWGOOKyurJzaOnPtxTd27+3OD3cTo1nV3pm4AkiCbahpBHNaxuS1+r3SEIlyHI5SSlsVQnDOs4EizMmgEQih1qi0NURUlS4EiXWaOgVNJCZqNFldKBAYoqmdRLz3WuuoeXdTrcg02mnUmePkAAB77AIG2gpiGnUIET+pUZmoDXBERmkKLGDtHbeG3hjGYICkzUBQCMAs1EZBMIaY4KmEGcoiZFk+O5wSUZZlZVUFCWgUM6LSUZelXkTo9vbpx6gePHiQJMnlyy/MZrN79+5lmam9j5Vgo0LYbSpapppShFZqQKW7nRoZedSMO6YeeSf05CloFdYG7gkgy7KNjY1BmiXadJpfCGE+n0eAd/FNDRQhBEJQ1N+h3Ka9xBYtDbH3MQEhynpKqWhC6Ff/6owrHdvrdli/2911IkKtUDdfYZEm3KSniMdJ6JX8iMegyS6BljN19zdb3PsYB9AdsJO0oP/zma174LEWi47FPjBIkwLetkb8iNPbPkdisGgIQBiEXejt9SgkyfF/yEvr1LEV714UjQfee9/gax0hCvHMdX1oskuwkUKstePxmBxPBqOt9Y3RaKS1FhSPXEkA4cRqCWyMKaraBd7dO3j5ldf/2b/437zx5lcma2sMEnG3uz3T7B+E6C/rjHD99erf2d1zZDjMof805tC28Xj8wx/+8NatWyE4o6mYzbz3lBiTp6CNB2RCSgxa7aP0drRAULN2BHv1YboyUgFn03JPQ6FkDIlFA4CoUTPnQTbSPAXUSJrIVXUEqs/TbH447R44zRDu7hYU5uuDuZHRPNTel1If+NIpsCs5pRYS0gO7KGfsPDsvAQgUCknNvg6KiRWgQm2MMUYhgQCwIDC4QEEUohIEz1DVviir2SLNM7UxrnKjA4FBdvXjb/1g+ujx5sVzq5sbAFRO5wuNVW7sxhoAcFGZ4ageWBhl4Jn3DgdJmgyzIpVga7eWwPmRW7E11kVYeOU9gAApIaw8FqwYM1yWsNZP5+rpTBZVgKARDdBsLVls5jDJjSA9Pgy3H82fPD2o5wwCilBrAuTasfMmSVY31pMvvai3Nsob9/1njymznnw5m0tVqbXh2bdfSR3Q7mGuqU4VKGUdxuAwZsiyLEkSAJQQPvno41/98n0ENkaXZWmMitBBx6hEv8mJ1t8VJ9vJ+59xuI62k298Zk++CNl55gOP3fW5n/5nb5ETnz61ff78+StXX1AmYY7uAugM7R0lJKKozsVMyWYqGbvs2TjYzjvcsfP+nEf6gCStDX05RdiGgsZTLz1UKu9DmmZK6aIo0jQlImHUyvYtSXIklYEFQvOPpMlsBe4TK+oVAQ0ikdfEMItjyYPd6CIBxJ5pgJnTNA0hBOeJiEAksLVWIDx68PDJ48fCEDEOnjn/xug8TxHFuSpN7XCYE0EILqZGRn5tjIkRhNiTZfvbUkSWecaxi9J+0Cj6IYBIJ1tA3yqATVFQbjFc67rGRptEAJjP59HdUJYlCpCAi0VTI+zmUZbZTVaDUxlCDP4YjUbee+99NKQ756IFxRgTb8Ae2DkcFdvxWDUvRfHJFKu/QpPYEhcH22qlzeIxR2s5t+Gn3XaMgTl9qbOTk0REWdvfssfG2B2J7jr2pITuOrf1ZmOpIAHAxvi33KwQuXsDdo7cpEi1TyYUDl5AaSVtZInWmjmEwECNL6A/Y21vWwT6+KSm/rsopZpAkiYlqOvFCf1JAAgZxIegkIwxECVIQpPYQZLOZrO9p0+rqqq51sYohTZVWLo0SZl5Pi8Go8nvfP3rr7z8xttf/gozfvDB+wK6rKvZ4SEKWGM4SGc/bTvfTnIbVNQ/h6pnGIKeVtrtE+hR5HhdESWJvn///p/92Z+dv3jZJKnSqACU1uloHPIkKAQURSomEVN3uppN0tQjtETT4DbXN2c7T+7sHt7TfIA8cFSTcSCkSRfFNunz2UCXVV0UVqmUyMVd6nyaJN3EqotbcOdQZiVtTQYFwu5UDbVNMyA2QQypMF8AyGhg2S/AWBFBItRaQFxgQCRrmEAZhUYpDwgILBAYQpw+RIk+TWEf2HkJDOMRZIaTJAQHua4/+LT69++Qq9P1dfAIi0UI3myNK6OS0bAoa6MJAJjAc1DeQ+0hzH1d6Me1GkwGK2PIU7Mo+P6OBOa1kWyuaU0pC7gAAaHwwiB/8U38/b8EAPxf/1T+b9e5qkNdM6FCPbSneKhhc4VGOewvaFoqL6r2gQibAl8CwuI8pKkaD+XLL452y+rGA77zVJ89XVmQhSc2kKitv/P26X/zb/Inj8fZqVtWDGNWizeKrKmca/K0WbIk3dvb+9M//g8vvfTSeIWstTFkQGvtvFfPqrGyPBtf2M7x6/h9891jt3XUW3rm+uc9/Nh3+5v/ZDee9aj/kjJH7b1SNB6Pr1y6cPj48YM7tx8/ORQWfA5vi+3EGJd/djIKNmqewFGSCIFDtI53RixZTmNDAHvYB42gg6osS0QcDsZV6bitmwrtrjiuCcORngu1YFEtOHorPC0loSXF7ruHuoq42BTxwJ7WBwDRA2CTmNvvlVbOVwqRtCnrmlAro+uiNko33UHu57zevHXjhjE2scz8s5//FKAJpa/rupNsYvVQRIy5uK0YvVwORNRLSa3HPfrbt1kebBzV1MZ8dJyvqqrd3V1EDN4rrb33MVmxASxjcb5WSqEi5hBQNKln1Ftr5biOScS3VFXFzM45a20kAcu4ikjZAyMiiECIck+D9n3s4dhmZYRYKz6uU0xqRhAQ1EpEXKu4d12KFSX6Gzpukk6T7s8e9kD+EVtJuMV9e+YxOEkm4leaeDRp4n1EpImTBVwWjI27AhEYhCTEoijUAmPQ0h7TGU6iRKWUiuGBPZm9kztRuv0cd3Lj6lJdCno8bhKlzyBxexyZbWlOZMR6j49yzpVlOa1qV1baECJmtin96spqqOzu7u765qkXrr741ld++9XX3lzb3EyzQVnI6bOXz19++Nnd2zs7T1NllFKhruIb40+M2V8CoBA4IMXajxwlsrg4Isdpa/xi9OHGvd3nE8IIIKurqz/96U9//t57v/21fDAaCnsxJhnmdWLRWHCVBAAlxphQlRBYAneiajxsSDhKjNb69u7Br+bzR0OzMJQLA6iAQSuwZfHy2pnzwzEXlatqIaOMVkYppWpfXPnx78Wu3rz+56Z8qzw3zm/s8ospEM0PDs3ZiUpzZVC4ZO8K74gwmwx0koXQ0AsOrXhICpFAx2Qo4eARSAkE5xnRGAMIIgxtSpGyxlrLOUrNaaIWY6TqsPyLH67eempPrxhRRV0ZD4M0p5U10gSKGJkGA1+7ocnAsZNAqSke7qIw+QryWs4IW1U93TUPD0CrkGcSgleoBzmghhDKqhT2mV4aOTgh2SnAeUgNj3O68ZhW0mpzIOPMbI0hs6ZyqpZ6QCwCwSOR1RqQYmKhX1tNXn8hXfjweMaP9vH8ugKBg3kgr148//KX3/75f/yfQlFhAoEhWj01kYiUrmbmwD7BZDQYfvLRhz945zu//wf/kLWu69pojUTe+16E9rM32LErz4uZoGcJLv37j0kwJ0/u57f+bScFl659kUf9F2kiQijg3ebm5pmz589fvrw/e1rVgVrjNDN3ARkAEJE8WobW8XhiDi3pi49tMmbbhNOOCGBY0sB28iOdjSpNDD7Ehs5gPGQAWifBl0rpTqDJ87woKpZaK40IsWaIIgWt4HJM8xEEFiaKNecaatzhtLfIZCQi0EsXjXiUGDVFbMcMEKTB/iaiw+n+YDCITMoqFbxnUkqpzGZAJAhV5YyKvDKIQF/gyLI0aQu2dz4U7/1S02sxxztjT8dB+nNI0aaER49NxySICI/KAZ2rJn6rcSbVdV3XIqKVigjz0bTSyYbHn/kse2Bs0T0RJ0VEZrNZFA/j16mtcAY9qah/SKS1bnVibDc6aSvAHXkvgudQe7fMcT3GO+NBDdydfOmVYumudDv1mS4JEUFFqCiGHMZ/Mc21cwQcGwWeKGiCjWkBoJU2GnsUH5kB6On9AOCCD23ocnQiIgs733eI9Lt6bDm6/RBCCMLRodPduZTMjoqx8RelVB+IRkTKsnQolGlQwN5h8EYkQWUDkDIvXHvpD//Bf/W//Gf/qz/4+380WVsLDDv7e8I4HI03t7a3ts8obaJceMzxJL1GR/Hojq1R3zgJPSLuhd3SlxKYuXS1iAwGAwL81rf+4unjhxycqxcayVobEFFpTUYJogfkFuO8Z9qNzQfZTPODg4Mf7u58RDRLLOZJYVWNEkSsd2suvLF9ej1LAdgkNlqGRFEVPJol391+/cXi0/uyMYJaaOYOM8nznDdGzjuVmBhJlOVDbRIPCEorIYNaARGLArI2M0mGykRLFdculDXXDnwjXzgSjxKEnbATZkKyBrIkKCWakBE1F7/4iN/55ShJBzSkWsQoTAwJuIVH0K6oTW4xeAqxsLX4ovLOoYAxxkzWIEsDUjkvF7MCXdAeDSueFuw8W8PjxE0ymAxUYqFXQRC0UlobB2bm9G4BxDAvzMPD5PFMVQETQ4MUstTEEhIRx10bQoLAznuLNpzdxOvnAQAfHaRMSinem8Le3KXZlW9+bdumw8PpGACFglXeucYI2qZlTWeHStNokP7Zn/7J7HC/KhfsXGeF7R//YzThWDu2IX/Tduxp/Y+OHd4v+LTf8PXU/Psv1EgrAOAQkiQ5feHc1esvb50+J6BjrxAUoSYFgBydFM234nnnpfLcZxl9x2s3gYwghE1WOQA0iQTtoYbQPT+yKgkMrYLhvS+KIurbu7u71toYiUhHW6dqQm/tOgiNPuGFpdH9SCnTTt3tsvNizCL2qtAdJ+Dsorsg2iScc1rrKDdEL3kIIcuy/uz190jsttY6gjBFPEZsE1FjJMax7vVbN72NhePY9kNEL20BNmxgwj2IgiZjFlqaTm20h/igW+iqjq+HEACkD2LRYqMdeV2fAXSCRfSbRDCrNE29c8KcWOucQ4AWF55868ugnm+FmZVWwstNBgCxrpeKRXt6vCey8b6gQE2us0SMkOYWxO64iYhSy/Qn6Csu/W30LCrQVzWOCSjH74lJN+0bGwkRsCsb282iiCA2hV4A4nJJLEvQPZyZxYfEGjS2KAro7cj+nhBpyw+1xgNERIGuZg12iCZxetuvkxyxczSwMyDeewKMm5uZvfjobbepkdpPD2bD4fj02fPnX7jyd3//D86fv6iMrWsXvCgDqbEgLkuTs2fPX7/+6p3btx/fv1+4IrOJtEbFbhTSvHHpF4sLT63o2R11brHaEJG0ikKYSJPd3jyQ0AuXZZlmya2bN9776U9Ondoaj8dKKZVYJxCQMm2VDlDVLoQokmJYivbNIppUK3Xz8e2fldO7eV5pq4Dm4BMiCpxX9WWTXc7HUpW1d4JaabZZOp3PUCDP824+zaVTe8Us+dHH5sJZrVkPLV7ZMBp4qGig/QyAlR4OSMFMg7NgMwRSLOIBRYM2EdAVTJAocIEPqABiJRrCqBMAoepAdwgBwTiRQQbepQ+eTP/s+8mjpzLIYK+CPDUbA1UH3i+ryls0FDhRGuZlsKooZtam6EQJmM01GCW8NgE0OrGo2PigdQ4uKMA0eGIWDixCg9SMh1Azz+fdwJ0CszHEYcKFx8DVkEwgqr3sz+tYKhvJ6gAJkVagMADoGJ6NorVGhyFP6OoZXQYoHR8uWDMK0LRy0yq/fuXsaHz38HAYRoWAl6CRogk6sNMmIY3FtEgSk1j95OGDb/3Fn//X/+SfAkAUSuA5nPuZF39TmeDz228sMfwmz8GlbWBp1fwv2xhZnE+0Zh82trbOXbp84e6VRw/ue1fKUmFu/f5E7Ps60JJbdzS/CSE4KsPFDBBBib4SIOyEie5hLTsAFMG+wsbCIh7Y+YqZz58/XxQFIk6nU2ZWGpeO8pZGdQIQti5s6f5JiNAdR1Ujlhi0AKCUijETzOxDDS0SZr+fAIBIzBwrz7366qu3b9zc2dlBIhYxRrVJgsCMzJIkTVXk5jlH1EiazWYR9CgKK2maVlVlEx2Cr+saAKy1WlFMO/HuGbK1iDwjWGa5MHREBGNmL3zsmEXu3omK0a8R67FBlBbj8oO4lmMBN2VHntmisFLXdbTYIKJzDhHzPB+NRqdOneriUqW1WJzk2fSs/PhOFukSWDo5VykVhP1Rf0q/NduitSUcM9L0p6j/uu7Tfn/kaMM2wOf4KnQidfsQAFCAGpt6LkuuhsARbT1aPqKoEevqARqlW2cSI+JoOFyZTHQvKOdZexT7MnjXje5dnduSjk5V/08C7P7FjzSSIZWSTol0CBSEiCZr62/99m//N//tv/wn/+JfXn/1DTKJgGIGIvKuqquFq2felxtr65cvXbv+0uvWpq723tciwnhkMjsnS6ejxH/xz/5YljJoJ6xEs41q9A8EUEqHwF1g+fe+972bN25452oJOksgs6yJEQEVI9QRm6M1Oy0rG4koO3hSTH/25N5dgoMsq0kF55XnAKK9X6nDlzfObKIqZ9PKBfECgTUgek600T3wWd6ZrrxxdViDywjWB7mjOhTqwa6BEsJMS624BKlRQ5JilhuVGEq1GibJ6iBZGdEgxcyqgY1WDQpCDXoNkFLKNvZITUqR0tSoTcF7qAIEDr4qf/Ir/tH7ufOIaoEkg5wGOTAS02BtDfJMGwVlCZqYvQJRmuwgM5MhrI1lY1RvDNwkcQoA2ExSODMp1mydgwoBDg55Z19NS7Vw4AGshslwOfBpUU6LBUi5PqyvnEryTK8OaGOCk5HOkkQbQwoQpfaAyIQBG20UBRSRlM548ZPUXd2CSe5mC2ZgIl7U6R7Xg/T8+obFgL5WKMjBGkXCzJ6ZK1cyBG2VILu6HA6yb/3VX966dYvFR3/xMw0W/UP0ny5k4NF27C3Pe/vnX39mx575lqONTsJl/s/WGi1fJLBTRp86vf3C1WuXLl052WFsPcgAEIMxY2IBtHrpsWEuKTPGBD3xzE4aQyUQdtclihiR3rYZBtGAEdGeYmZD5DJnzm4LBG0a/RnaGFVouUkneQAsk/sAGnsNQ4TCFAZBRdoaZXTo/OA9xQkAFJICJHnGKgsxixeRDkRAawUgqEz0bSilyGhtiBQU1aIn8xxpdV2Px2NEnM/nSZIw897enlLq+vXrGxsbXa5JCKGqqujukFbx6zfdOV1i/zqhj9pQCYAjmnTsdwsaraS1IWutY9xsh4ugtSZF7Dy2wQSGFCiCcMRrEVe+C4aIho0ImsnMWusou8Qk2CbONj6cmsowscNdZGscuePQPvuIg2Bp1IpFxPsBw0sXDHVygA9Hqt5JL9akL99gV/Kt3UzMTQTnMf598mzACSkEALCZEMCYe9wdpChV8xHXRuw5NqijjRCt4wgURa7JzJpUnueJNnu4wxjDV1qIPmhMUXE3Y6viNB0KTFp14o+IAEvM5X2e77mbGQXdhDAipgJEuqrrJE9fun79tTe//MLLr6ytn0qy4awoCLXWNrgKgAdp6nxFgD74JBuNxyvXrr50+9anKM6XC2aOAkcQFhBqgqXIS+jLE93i9vvZn7elSxGOrFGU4nXjL4XPbt5478c/2t7eSkZDlSVJnqExrprHTH5uYeioe34TYQZM6t7h/o3pzizfYJMyOnB1DnrOXvuwJurV7XMTZadhppRSrJXw9OBwkOcKaTGdLafys6d6dWjeuHxw466e5Lu/+uTxzdtrgwG++2MYDUYlIirKUrUylo0JelVc3ADSJk/1YAjGcAiIhNaUVUnKKlKtDxlBQazYR91OaN18DOIZ1cFcW9j/1ce0s2eZoJLF2pqM8ooDPtlVJdjRcEpuxXu1vyhGw2permycAdKlBs61r+c52vT+oZ9X9cFMBWeGFiapr+vEaKjq2WwBNhkFLY6LpKDVYbqx0o07mzm4+QSmFa8M6fRqfX5EhKgVIiokUFSReC2DGMxEyBIzFTECvpHVyFSjV2dXjR4mLDY1Ncy4qrJSpjmfWV0zD3QIjoxJgGrAAKAJALCsKpGgjXauGqZZEDw8PPjrv/rLs+cv6FTVdW1MwuHZXpLneU+ex86/SGyH9GIvOtH55Feed/2L9OckG/7/k0ZE2loJrI2pnVtd2zh37sKLL16/dfOjnpoH0BFVjV0GSkufY7LkspK29EyhItLVgpcW75kENLUm+iNhNEuTvIj0OX1ZFjFk8ubNm8xcVdVwOIw94Ta7AlonjlIqRhoBQEMzlgsQ/2tui44MaC21kQtHdKJYMwtavY5hqVABAIdAWhmlvffvvvuuRkoSq7UOojx7TQSg6rpGRUoRQ1/fProFhMqiDoEBsK48gjI6KYv6F7/4RVfetSgKZj537tz169e//VffaXlZI75E3AetkFBh1E5FJIa0AADWrJQiWoa5dmy1M0ZF2wMiskhAEcIywrZopbWqJXDtjKAmFVXw1JrFYkFGk1KwdBQdZbSIXU2Q6CRrqmyILBaL3d1dY4zSunYOESMwC8CyJnv0UVlrOz7XcXSNZJWu4wLH3BBCjLVlhK2PlesRoRGQ+/k4S1efiIQGm7W/C+MKK6LSu3aHI7bF8LpVY78MGA4hCAgo6sRARLTWBuGiKJRSXQQvIBJiYK6D16gQURktXTlcaZgtACgAYUEARhSCAMwhICELoybU6uGjR83GFYFWOhQRJBJCF3wsG4ew3LIAgIrYB6UaL5VSKlZlxDbUpjvnqokWRZDgXAClUJHVxpdzo7CuFkqPFeHGuUuvv/nlL735W2cvXJyMV1Dpsi4MKQCRUBGBkCqdAyAPWoMP5Wxjbbx3/vz5q69M54e7D+ZgyJfVIM0r9qV3JrUSQlXVpJUPngCTJFGqwctLkqTD4OusoHHgKvqFYuE/aMBamFkQvPcqSQgwICibfOf771x/9ZXNMxvDJHuQDvcENhHKUKL4vMYSJUWaUUXsNwPVADPSA8ms4Ls3bt612YPMkuch+IOEhyXWyl9FfDvNLyX5/sGh11qCT4hrVIYouODYjVZWuiXwZ1ay+4dw/dzTIV6+8fDTH/74zGBNacyqSpcW85GZjAO7pAZ4PAsKFzertKxpkBdGJ1ZJcUhXrlTb50kZLJ1Pgs5TXpQQDKdWe1FWRxFSMKBGJSSexbHM0+RcsnjvXfXj99enthoN+cKWGSS0U9af3cuGQ3ttO9SLMYhflBhAmRCGaTXJrEltVZGvoKjxzm0oRVPAg1l1676+ctb/7itmazPc2Ze93UHwkEzD7mOqJQVDb79a5UucnsUL22a/LO48ML/6Jekq2bpevXLKn141wyGMcsqSRCeahANDVSuySmsJzCKN1kiehROnoGIeaRIQZjq7Qhpnu5+N1s6Xf/gH+NN3tqrF40maLTBghQhOAgsqMiIaQEirg6qajEZJMN//zl9++ctvX73+itYTx8EQRag76YUCeO9NL+71i7T+cesOFPYs8P0rxySPz3nUr29RSO45HdqHdKkZnUk7aucnHvB80QQRe2XSjvpoWkzx9tbuniOW497n4kWMMT4E9s4Sbm5unr5w5cqrb/3s3XdWUluWczvOZoVXoELFTCFEkCHW3WNiKEM7mYSwDKfo6B0jgAgDIyITiiwFl245Gl03NFZkaIlJAFFKMwsilWUpIlFQUEpFqhs1r/gyAe+DR9KIKE3hTOTAAqK1DozGWOccIRbzhVG6mC+IiFFYQnCeoA3g8EFEAlBTTrSVbOLgohYegmcOaZrErwgA+xoJA4Soq0dM9USZOoTIvuJkdJVntAHxIeJAkgIiIhWjWFzUWgIjqUQb2tnd//6770RXdVMmTACQEVBrrX2sW98ZyZvkiKUxBNo6On0bQP8XaHJYBFoDSWMvicUeW8eH9GI243x3uwp7VqZYMQ77ZrGu9l9Pc40t1nyJAlAnFUUUjT4sK/QiJxoWyxKEIQBppakp0t7dE/vfaRzS87d1f3amuWOnrn/xc9SR5dT5BmpTkfIcYjWQPM1CCEuTAzT46ITUBabEnzEwExE9+yMP7yJFWpsHc6yvKxiBreoasduiMY8TFai+eNQnJdES1s1qdA12xq0udimEEEAAIFGkDSU2DSEYTRvb2/PpQQhhtLFx/dXX3nr7yy9ef2U0WXGeS1+7ojDmOZAGHBAxBK+sOXXq1JUrVx7eu7H/+EHtvbXWewcgVivvPQGQgrqusyxDgcVioZF0YmP69MkHd4tyjEA3xjZqQmW5wUjG/f39v/qrv3r55ZcmYNLJyAwyWRwOs0E1n4OCUM4JrGIEVBVxJYKJSmxy/8G926G6Z3RlUZOQAxu0iNiqOqWyN89eXhkOCvahriSwA186h4hpkhDR4eFh7NKNr72bZS8/vXVzf//x1S+9sfP9H4Zpufny+RnB5Mo5P84ra8xoZAj2D/bUaDxa31ivgff3vbAoLVXpClYxN691JsZ4lSZxrdGsIhCvirtNaUNK42S9tLPpp3fx6bw8PeaN9SET7dV+73Bsc9pY9bkpnu6l0zrZGIVrW9botSTDYLgunWZME2SdlODXtE6pvPdAT2dYLxSJXRkEUZIaLAuuCz6c+k/v+8f7g8IldrnxylPj/A/fNr91vXrn58mPbsFn98zTJ3Bx3b72AjDXVVlNhsHqXFvpIp8iY27C/LEFNYsiJTanZnOVywqMSq9fuHT6wqP9+5sDKEIQH1hQIcYqg4E5qrNa6/39/TzPg5fvfe97F65cVc5lJhVYagvQeUhbmMi/xdYRn2de/5zWCSu/0euWLzomGXzh9pu+8dc+TXqBt0Q0HA7PnTtz+fILD29/dvjkUT4aHi6mWiurdZBACiPJwiasrRmO1qp7Qr82SsOkEWIBaIp1JPpM6uhwTi4EY0w5aT7tE/++VgZLTy4hyTFlvlN1tNGzxTyKLPlwUHvnOWhaCqBdCF9U8IIPeBwAN4ajLL0HHeeCHkPsRtfna+0QjgywM7b1HSUN3WjjVblBEFlyB4wCTotYrQNIUzAmzkgbZiFdMH/rpzjGdzEmdCDGMnLcY4TRBtAYQpA9B0u6Xf5nZIH216a7ARFV6zSJFxunSft2keVqQWuTjPAhURA5xuOxDYOASEca63EDs90r63d8P/UXprsSrQAEywVeej3wSHwQtzlCHUxQdwURDSkfoy4IVKw9JxBcx9fbMjltjIIXRkAVet2jRl7s9k33rWaxWRSSmCUkKIMEkK5mL8cAqFgRhvtbdjl13fT2CV9n64piIihSRseoQyFxZVUVCyTZHmxlWVYU1Rtffv23fvsbFy5c2No+pW06raoQQmpTowjCck6wdSGJCCkgUlVdBu8nk8mVqy88uHd798nTR49uJ9osFotYImRRzklpIkoSjYgcglU6plLHVOdu+RCXCyo9zJ/lhEfLTdQzQqwMKEmSzGaHP/nJT37x45/+vd/53fHauMo0GJUABdIBPUoglJR1MFCK8xjSQRII3r/78Yea7ma5twbF+VKMSQzJqK6vJivXBmO3mNfsAVAjuRC0iSVgxFpz/t2vN0dd5M7HH69Bkthh8ent2d7UsNrd2T/95VfLUZqORj4Bv5LoIuBH99WkgNE6jEaYK0xUolP1eAem+8H7EJxGjCeXQZiZAlOI+LcoyNETFFm10opI+wxqzXparadjeOG0Gw7o4yfweB9QaGsFhikcLGj3UGUDWJvUiHiwSM9OQEE5LRSBMcYlJpweYJrBUM/f+eHq4SE92XG376q1iTqzXm2th2nhDvaHzoFY2n9/9qNfqqf3AS7HsQ8/24e9GeSJ+se/V3/td+qffz//wU11+xErwGI7nFlTgyQPCgZNohAwHiWaFEP/pHWJRhEENEKmS3TphY3Ll6/85PsPN5z5TMnyDAkAsECUn0ErU3AFANban/z4x2+8+eU3v/xV7yptTF/B4DZ2yp8gGn+Lra/8/Cc+qn3Cr5Fjen8+486/gRj0mzZFhABNnpwg+2CU3trYvHDx8oMXPntvd4cFIcbUB0ZgpKWS3KKLHunqUQrXzkOc2BMsqfeV5ddioYz+6nf39Jl68xVq/OsxAC6CLxOQMaqqKhGJQQKkGzt9WZbnz59fWVn55JNP5vO51jrP87Isu3DA/oiwaUtFVE4sSX8UcPyj5noIwejGdg4nVvrYros/DWkRDK1sHx/EPoQ2r4eIsGe10kikWutf03UWEWjht+FY1McxoJumGC6il6bAW3/ql9uZIoy7EJGXvqMImFl6z7TGNEaO9tUQTWFtynt/RbuRd7PfaeH6WSbNeGecuFikWwCBJVYD7B4CnTjVWQuasQLEgERoXEuhV23u2L5k5pjtEheylZaOiIdExCEoIkDk0NRkCSHMy0InVsHS8hRAQKJAgxDhyJboIADttHcyByyrwjZBtaiIiGKxwRiNywABJEZrMAi0ES3wLPkXEOO6NP6mpjQaRFdFnDglAIFDBBdTqBHXN1aL2XR/f//s+ctvf/Xrb7715c3T57IsY2j6YLQFgLqu7Ynias3bWQRFaSMAImFzfeOFay89ePRkf/9R3UZrs4TGGyDgJcS44MSYWHKFj4R5N8Wd+mt95HU93yciaiRR6L0nZfM8n8/n3/rjP/36y6/lmS2UGGPcoqAgpQSlUDxr1ABYcJ3lSWbsvUeP3yue3ltfr5JJErjmwhNZJITqMtBb47WNgPP5QanBBLRCQgKKFJGr6r7zPifz9NHO+Wuvwupkd7aTbK3K3TsJaiyCP51Antq9A//+7aoo92ZTQwZ/eYdevJBMLFhbC2JZWUbSJhvkeDAVRCFoajoFRhGASAdREABFEIEUK9Uk/D/Zg70ZZClXvp7u62lZDDQOUzVIeVHoeY3GwuYYBikcFvXBwm54B5VflLlJwFMyHsL6Ciy8z5gTZUKAnYPqxx8CK/3VV5PTZ2FthMUECPw4n/k5vvOL4Q8+6wQO9Wfv8ac3Z3sH9p//Q/693y7/q68PVk7p7/6c5zPYn+qtMQPUWpT3QPpYJabj+gY2Rg8A8MGrPFtwZQKMXrwSfv7TEgA16ljBWSBwCMLc1jt0zg2Hw6qskjyr54s//bM/vnj5yoqsp5NxpADxVEBErsUljZWjas8XbMfkiZNP+IKiRkchf9M+HDkgv6GR4z+HjNUZKYkICJyvENEmemNj6/LV6w/u3r1//+ZwMPJV6VylSfXhgzv1moiO1lTqE0yAViSlo+y8+whOrEh/nC1naf6CoxyhFRSWXFHamAFmzrJMa70oC3bcmefn83kEnYppodKqrI2QsSyzBcxM2HiOlvwLGsbQjeUkVW+71B+aiLRZuM8x6mBvnMwckwgAkaJ7SCjG10Grgcfg9IbtElGM4afIIwUQUIi6mERpQ0rj9wMztW9iEAIS4ViRTwFKG74bOxitKhSLofQMGMzcxTt3QsCRyYoLHyWeFrsaeuapzqMWw2e6iYiP6sqv9AXAjs33X9Rlmfb3R1fw/dh0d7fFUi/SqsJ9QDWkI/J+X8Tp/uykKKVUXdVaa60UiPgQmpLBSRJCEKJYj6O/Yzo+JE38wRc63kQEAj54RMQWKqcL/o2SkAAEEYPPpiwxeveYnSOEgIoQ0ZCS1g1ntM7SlDW5uiwW1draxm9/7Xff+NKXt85cGExWtDYi4GrXrBSAASKtn1WzL26zwAjKGiQdfJ2n+vz5ixcvPXh456MHd+5pIEKsYk65kLDUrsqSFBC6iCroBPY4873JPEZQuj8RUQGKD8xsjK2qsqoqbUhb86tfvv/Tv/7O2+vrCQaRILVH4BC8QqyDt9QA/oxMXpX+Z7dufICwn6Y6qMx5T1glCqQaLOYvZ+nbZ8+PKnSElYjU3gNh0sbSa9XfRYd7+3qSz31R3j1YvXpBRsO9j24mpMnoodOzD2+7p3u6qnYHsndpRc9468l0Ye+b0yuIq0mekEpEIFSVK8qkQapAhSgs5DmIACGSFonhUCSKGEkIA5JWXv30U779FIzh3YXfXdRpqi5sh3GKB7Wa1ZAlTnE1nWbWUG4H4xGBMtNK5k5ycIupM5KRdtrU82qYD0EpYKEHu75+X80cvjWDq+dhlIFO5cIpdK/o/RIOP+vG7v7iJ3bv0bgo4H/8c0gsfeWN8JVX/WqufnVL15XZq8RMqy1SBkArBQgYNSpERCGU0GDwSoe/18j6mpRW6GmvtK9c9T8+e3vv6QAHIM39BBCixgwAAG0kkCdXjcfDTz/66L2f/Pgb3/g98QGiUhjLHfeKMP/aU/nM9gWFg+cJHM/77vMFlM97V+9bAbEpVfpMMf0LCkBHnnzkKw23e17/Ox4UrapdicqN9c2Lly89ePjSw6f3OSy9/9LL40NEIEFEQuIjgIfH7d/Qo/MEzSr2SXd3T59ZkECHEoaKuvsk1vRGhK6e5RI8dNkGg8H6+jppJU+fLhYLbJE6nzx5srOzExNQnXMR4aMbFC2DbORYz5u+tXGK3H2FCI9iU0Gk2RF2m5BQ9R/SX4v4V+fiiB8xc2AQ8YxA2JRP6Qtb7VuWk6ZDCNTz/XgRBaiVChJ6b2pWGls1N15U0iKqBkGk7nrn42DmADLIsrIognBn/xBm6EF693/xrZdEKQUxliUWrtcKIvJ6aGTDfn5HnMQYI6KUSpIk4sse2x/HhI9jA+y1SJ+aLbncWz1UWtWrrg6tUCwiSG0d0U6m6QN+HPVTIOJkMimKIuZEKICYbqeUaqN342npiUe9r0d4zf4wu35KK+1GphsB5haLhXMOQTpHflyjTuZQz3IuxBZB5QeDgbW2LMtQN/HCVhvnnBevlDIxWiIwiw+i8mz4pdde/8pXvnr56gvD0ep4svpkd1eBV0oxsjFGAQbn61CzDyoxzyRbxpjKewFCrkNV2TzfWFu5dOWFB3eu7u8euGIWh6CNEcHAcurUqXJRFLO59DKqejA+Ryb/2Ou6TQUASjeQZdZCF1iuNRHK9//4P7z5B/9gBMx1rTTWlQdxSowHbwgZg0msQfPZ3u7PDnfvDccORbmSAto0FY24ODxVVW+dvnRqMJgdPHYhaCJDClgYgkLNzEmSHAtCGp/fHqydkpv3uaiEHc8Xe/M9rcNg/9A4P7x2GdKkuHsr353qYMyFzcnqCITrw6l4SBE8itIqzfJQzBoTRpBQe1BBRIImVMLRpkeERBCjvJCnBwfJL+4OH89hkIKoyWQVxoNaUfXksOZgVMgCaAZW2hiDo7XDTz9N8iwMbDJKEdAGIGMhtTjIkgXb1U03GZJGQ6geT+nw/bo4AF64Fy/alU2zsjp+xZasqpV1+LjRaOvVrJzTwIG5fXv6rb8cSc5vn4PLWzhJq8Op7M8zJ+nU1SNUWoEIBoYIK4KE0nokTxxvUgZqUQLoJL16ee21lw++8+0hoveeBQhICBRTiEjvEpQyRVEkSeJ8lWXZIE9/9O73XnvlejIaW2MEoKvTzdFJfdRc/2tliGNE6Xntcx51hNn8TVuPmCzri/We/1w4g5NP+NttHbXvWYg5BD8ZjzY2Ni5cunj3s0s3Pnx/lCXW2qKuiFDaeJ5e5xh6KevS6iHcgrwBAHDztejd7rT+bnqb32m5xJ20Ia2oe5K/cNuoKc29ZO11Xe8d7EfM5b7/fTAYxL6VZRkBNhsWc9xud2Si+v2MApy0+i0c2STS71vL4gEFqDn7x558XIZuOqOizZ8BRChmVUQYk15/pNlOIqKh5dNN5C2zIkVaSb2kd/1okdAzrkULRBMKQMvirJ0QEECstePVlTiVcfAKUICPSdZ94VEpJYQcSZ9SIsi+yXsEAFCE7c0xLiQGLUaZ9/OzND+nUYtnFZ0XDAIRAV2Wh7zbqd2LOmlRCJGlY9JHFqpJf1rWDl5OZgjpcFQUhfdeaR1NZ/E6EQmANI4c6GhZDI3u+hMAiI/vAzgqY8UrSimNJEgIyL7dYbFWi0REGUTEflBq/4HRspdlWaxo46XuxsXMisgagyylq9kHrfXFS5e+8XvffP1Lb65vbCV5zsyLqkLEPEtFpHR1NOEAglY6nPCDQk8aIGXq4JEDiWNXWp1funBx7+VX9p7u3Pr4g8BBkYnxtcJotVnwnJmttdbaCO9vyISep7MbV39F+vPWntUmHEdrTQqcc0Q4WRnOHj2q79wdFkUVagkCwSv0xidBK6/FCw/zvCjr9+/d/1TTPFlnmYOuSz1ENpmrBqF+ezT50vq2q8qdamaAFBujjGipwcfVj5u569vW1taicoA4sKkkeuEq0HDpyqV6lECaLIzlySDbrzcrbbx9mukPYeel06cgBG1tsAlqlMcJEkHtRcXMUQHPVHlQXkTIqEAgiBoBVPS7MaACRfLoKd97BLNyFmoYT4aTESRWZoerThVD7TXyo6kGCqN8VhWDh0/GaQ5ro7C9okoHD3bZ1aig0JJbKzSAy6fd/XPuswdjVKgZykX90Q2TqoQ0X0ZYW68U6TdegCtn4b/7Vhz74P/4z/nOw/AnP1A//jD53vsyI/rgVHrtLFzcknFWj/JaVKi9EZDAvnYKmiFA42hsnCnSpI43GpFT2nivFm6qCAejF1/90vYP3gt1oxQFZGyzMyKxIkXe1zEwrXblYJDdvfvZO9/5zt8bb1qljTGBmxC3wHyS6/bZzzPpz/PaFxFWjp+dEy/6Ik84SbXaDvwGXfrPJG0AAIISCB3njqw0hKB0mEwmp8+cefHl608f3A1lxYYCSKzmDcAASzfEklzH33lJz5uh9RVgga70dJ/TYwOjzk3Vk6M6ZMe84fhaLJVV6BEfmybOuel0im36a4waQ4DINGPVsFYgoE4iYTlibMC2buYyKO0EaGk7dcdxqtqHsHQFWRpc8+VqRktIN11LhtgkcxIAAwQGghioIEsmBb1utMVXEaOaG0RAUVeRtTdfDZIrg3hEDQTSsOSGnxFBiz/f2BtARCTJ0vF4vL+zG2LcQBQ7TshKyz8URQeN56BAov0/iLS1ybAhH715TNPUWhvV9/i0iAjS7bP+iwIIISE1gKPd0LArXBeJDB7pm8iyhNtSIOjNIxERgog47kEQnpBzu3I70loXDg8PnffUgpfEMTKCRpIWOS2i63cgrZ1Y04oCR3wE0DPkEMVC2/V0OtVIdV1rpZTWhIiAqk0AXpbMfX5Ib5Zli8ViZ2cnpiLHyXLOaaUUkVJKfKjqWiFduHT+yuXLv/vNv3f+8pV0MBJlp4taRIDrPM+KqmpwcGNqMUIg4CAKj2O1xVZVlcoHCkmBSwAgMEtYXV09d/HSuZu3Prt5w9cLY01ZV0SKQW7evBnrfIpIWRShqyEExwWOuEs79xC2EX+xxfgp7Ex6RHVdW6vtIN0aD+vHT8F5BVJVFbJXJOgEExUwOPFk1cHO9OPdR49HWtQIZcppKFGZQ8q9X0V4a2N7Kx0tqgWmNkENcw/IYghBSBC1DiEkbdm2W1/69mjtykjB/MHjgUnDKFVGnb549s6NT7fOTvxslk+DPaPcpa0qpfLHH2yCGZ46XZ0aJkE0qHnJ5EOpRGtCZjEoAQEEPIvz4AMDUEx1IkFSEO0EjKRAaT3cLXcPDwHZDAfJ2ho4BYczZAcV08IZJUwAeZqkuWJgi5wlSOCD86EqoKAsG48HA6WL6RRHiZzfUC9fCfd2sHCc4WKkBk8W8O4NKZBR6/HEGqOUmWe9nXB2u3j18ni0cjhdDG99Vt78ufr4/eoXm/zSxXzz9ODyRbh2vjZeLZwAhMAhBN05RFlAdbgyjXdaKQVEXqMBo8rpQY7ay8VzFy8kq5/OHyaplsDMIaKfsnC0xktwSZKU5SJNbVUV8cq3vvUXb3zlG2majkajhphEza1XHPFvpeEJ+8cx1n7y7HxxSeXY044JLtAynj7J/bUP+VtvIQSkzpPOXY1PV9Xj8XBtc+P8hQuXLr9w66MPRQSUhlbpJQLseQq6rsbFWjKIwDF7YolvdHRGO6LacYR4QyyGAj1W0o9D79F/IIKItNmXYCLQeBdx6JxjAK111eIAOeeAmYgYwIVgepZ1adMCGtqFx0l317Gub5Fz9WldOy6RGAtCqrvOvRnzPvDRQUX+wo3pIghyzF+IKivhMmgX2vouiKjZNSUbgvexQHkZqhrYJHZ+OM3zvK6qGDAFAFopFN+griEqhdGegQLsI+ASBIjaESlCAJju7r/36IkxxlrrmIEQSbBvmRPBXoqpjrEFzBoQ2nwNgwSRkceKw91cYxOIGndkrPEW9Vrdg5br5ihipDSQlKp/PFpRFoCxcYtRrCOzFHCbfRYZledARFqbeMWFpsSMEiABQBIRdgEQFJFCghPGCY0kImVVRVFmsVgwc6xoTCIOYmoxNia+1m9H0MTNN3Cf3KS6dEaXKLVoUggoPniU6Pmrg4+SctxzCpA1e2aCpjIwCJCgizuEEAVaFxUiCLIk2mitXWCltHcMQkw61TTMs2K27xbF2VOnrr365htf/trFK9fGKxOgmMJeaoxpt9pF/PvAcUkQEQAhMBEBR1Dhdj248U0qa8E7DQCANZgI7Y5htrW+cfb8C1de2n3vJ++Oc8S6JsiAVTLIAFBEMALwEcbE+jRCtiDEmKw4CVpr7lWiISKBAIgArMmUUgNwLkRoHaDJLdVuZ+9xFiY2NY6rsfczX5WJGRbK0bwmayk5leau8D+/ffMOyH2tEfZqzHTJWUL1OsCT+e/R8Pe2tqiu1LwcAElwZDRrcs4pbZ1UVhkNePrdr8ZejSeT2cFBemHN33wMelj41fr7H3+6c//0cM3NJVnMpzfu7P31D9devTZ84wVYHwel9dpg+t6vkpsMXOS/dUYN11OX+8czO3ZmRfvFgjUcHu4lVNo0ScajouLMYJkokyQBCvGkcVBq0Vmo3JONCheVTdNN1qbgxSBhDACKPCg5tU6XttXmGs8W1WcPhpWInfhZEH+YIkkwNp1ACVBVWc1CGleGcOWCvL6/+NnH+bwY1ggra2VZhZ/fTEuASqnXL5dYhafTJXn4t98zX36xfOuSPHzT/Q+7ma9rksHDGX32U1j5CL56XcKcNjdxe6MsyuSwpozCRAdAWwMboBBYYSAIhpCEGAQACTJxQeECYRXS29U0H6h//o//4P/+3//306qGwTCIzhMdwgwIoELxmknYcaKyULGhTBwqMvPZ7Lvf+pN/8S//2/kCVzY2qtoXRZFniRJ0EMnukkafZNgnpYRn8GzRstTPInFvT8jRaCQ4wt6eK44c+whbeOAuR7R5PB2//+gXj6i/3afHRnT0K9EmH7l0QIC2BHYM+Fv25JktJp1Iw3c0AES4CwZXz+Tc+pliY375yit3795fzHaMeE1JXdda6xjgH3PjQwhETVGOCD/cBCJCLGbZ6OsMIUbAC0vE0QJEIoWy9KqrVuFkEKRGeIkKTGdIwNZvEEKIBBkBmhR0BAEJIViiGEQVIoApkQbAwDr6hJiNagAtFCIwB2CFWqGCphoBMbNnT0wM0OBktDGUwuLFW2uJaDabjUajDpIfW/wnrTUKtHBWBjwTovcBCLVR4NvagapFaO3Vf4gtydLRaHRwsF/WVZLoKEKx+G4GkICEohyvAwj4ppSXBmRmIWTmedmEyF68eLEoiocPH0ZGnmQWoJWlpN1VCCgYq5VGL5kiYgTn3HAwiH70qCkqpQg1tT6k+IzORBNzNbFLLsVeZbIejMexhOCYLNT54biXktodgP5JaAwDgTvxENsgo+YYRVOEHBEZpWc26Es5x94SBUPq7oSlBW95eBo3HopIkiSPHz++evXq+vr6/fv35/N5XddeuJN5+wQFEakt4teWcYP+q6FnLpM29EkpFRlpd4/W2rk6agmtHkBxznW0o/TiiuMa1RIazBkOVltlUWtFjJ4DajNe3zr1yqm3v/yVV19/c3Vzm1FJm+b6BYPJ5ASlPblw3aIDwMbGxvkLFw4ODj679cn+/oM0sc7VxloXImFrDEXQWS9EsIMSUaS1CiFU3imlW5z4xnEb+4zCQk0pJRb2DCxBsSQVj1ObCIELIUhAYALWZPTQF5WraxqODh49/XhxeFsDpAP0bEVRoLoqNMkLjG+urCeDvN45iBG7QAQtThwiWp0IMtkl8pXOkqf3Hl66uDm+dHb60QOunVsfXjhY3UkBitkiwdEffmWYJbs37q/P6+HVK4vZDO7M0o8f7iRD+/qZbHtF7i10UYlVUpaYrmiXVHUxHoxgWoJRNVdZPgaoKhFT1soiCIJzQAjT0t96MHu6m+QpGOW9V4AQIACSBkupFoX7Doqdej7j/bkPom1q5lX18MAFTlfHwNVs974oneDA1nY+Zxzq/GuvOM2H774/nldlAulkAAs3+8kv5cGj0UfX09X19KBYHpb/8dt4fy/93/7d9HfePni0B//f72JiKEl87bCs4faTBf5y9NorrFGPclpJgRRLbQMBIwGwQhRlhEyTUAegkBVSEA5ecrNQgoJrw8GZL7356O/+vb/+9//uMJWSfVE452qyGlFrQtYN0kyTXWWM1jofDN57773X3vjSG29/ZT6fs8jKykpVLuQ3t0nIswwSR79+hMd//ql65tNOtiOKOMrRVJTnfV0+99NnPPzoM38NOXjePDxvOFpr59kotb29fW9j46WXXvrRD78XWBC7aAnqVo2ImH0MPAWhzkfQMGla1qeKupyIQJsEQL0EzL6V4nn97Ihnd/+xX6ClS4DY5O0+Z1K7m7F1zYicYPu9m5rOIABhatKyLJVS4/F4e3t7b29vNpvVda2t+epXv/qLX/xiMZtTi1gRpyuGjJDRVVmAbgweFP0CAnI0sFcpFZyv68bDDq2S34UQNOyYOdpCtLWWRSrvSGK5PfAgoJRKKKrgaZrGgWitpZEHI7I2SHOwABFjVHdksT4EEQZE5jCdThu0eaWiBBOtRv2gUYS27pdA5NaNZhCWUjwfmdKlV4KI4mg7w5S0OUiRM3XyhxASIQkoAd+kZgsgRozn5faJtF+g+W4vxL2TOfodOLa3WBjbiy0UzDP2ZZdMO5/PrbVnzpyx1i6qcl4W1tpxNoz11Y49XERCR4Z6q955sjp5aClis4APrhW6oefk62IhGzmpdXCCCFJjWlzKOsYQs/feOWeM4hCKumRmreyFjY033nzzS2++ffbseQbwRGmalPMi9o9aKAM5SoO+CEE8eWcnSzHy+Qtni8Xizq2X33vvUCtALgBYa9vd2maCowD44OMYlVJWKe+9C15rTUgMzeRojCBRAgDEoKLlTUhiJCCgQRg73lodpAGLKjjvBUhEPDIL5WBLkqr2nz56/IG4+yu5pzzTNQRWoInc4GD3d7OV39k8zRCCcxF6Ltp7uamYB+jZGcx6AofNs43Vtel8kSZqePFsYRJ7eru+8RmN8p263HhS+BKy165tnDktC8fC9dowhyR783q2cdqHw8NP7tOhBOWTzUGyPXTg89qHsgYA2JmFQbrYqmyCwRqLWhUeRAMiJ1oZlAe79PHDcjobXtiGPAVxqUrBVwSKglMO5e6+u7XDhEmWZFrVxbwejTWoISRADKiBJezPEzR6K4dFgQvnxylsTcwrl/zOPtzeTcoDEIRahrOSbz0KpYfxIDgGuNpsV3bhl5/O/mpt+Edfhf/6G/bRwd4nt8aB6kFeW8qNtvMK7twjUvXpMayOxVphAyDgxSEiKhRRoAEUMAKBoGKtqPRYexmmRajNzGcpjS+e+93f/p0n/+Y/3izcdJjMAXJnEbTXRIK+pcgdkUFUsSjon//5n5+/fGV1bcNmmavLEAIZAz0lBI5SrS+47Y9ufj52UeT4CeqOxsmTdYzPnTxWv1GPnvfBs4eGfOzvXytz/IbdwajNrq6uXrh0sazmn3768aPH962CyPYaHIFlkgG2DreOMiNADPRtR4FATaK4LJGWTmS69geORx2yx6QN7MUSCAgCNdhXjZ3qaLRE5I3PKowSf+XAIo0A1MVkYMObWqgn6IFGtkvvnItxIbEOyZ07d6qiFJHowI09dK4OIShrNFHnXgEAkTajpe1P172yLEObSeuci/jjqlcaBQACQizNpp1zOvo7ympRlVrr1bW11a2NB/fuV4sCEe/evRtDV7qq8UvmiqiiJIXgvRdCpVXMtkREnWqlMVGpNAhdCIDO+RCCSlOAZVBqnCduMbGJCNocZWijHX0LpdJNYmymw+1o7UvSmxToYMHw2YeNBFq8q2X60JKXR8gsaBgmwjJpxfFxEtA8k4QRQjMryzf2o1lJgNtyw0mSIOKvfvWruq4DyHg8LsvycDZNlYlibNedxlKnCKDBnAFYBrsKYWBGQI0xPAJEhBBNtEW26O9emJljIb2laB/3RIhZoKY5h41LjyIrrOdFlqd5mikQQvSuzpN0dXX1lTfefuOtt69cvZ6PVwKAMCPybHao0bQ7tQmIicv2PDLXZEicoEXIgtg/582/xWI+Ho/WNzZefu31J48fPnp421rrXUHY9J/bx0obXxajviNmXyx+q5SKVPoYHUFEhRSQFRAiBEQgVEGMwJrWW6OxCaEsHTNopYQBWapQa2PGafJ0/+D9vUd3jBRpBqJAGyjYKT2kcGnhvnHuzNZ4cHt3mjVZaoiNAayTZQlAKrd0OhZVubK6uqvBf/Z49e1XKM3TudsLQYN6tJgpCOXuU76T5VvrwUBa+5XB+ODJjk9p9f7T6uattcTA+ubBfF97b3JTSA2Lyiiqiql+vE+a0sunQVxwwWoDAcDVNRFkGbE/fP9W8uEDAIDU+BjSEERcCAo5TwwTS20SKwiQGBikIUE6u11U9SBNQcIelyZLDeu0hHIxs4siT3IQL+4Qh6Ps1ZcO5ePkfjXngAbGGxMlunSBizpJs2747vKmBSW3n8L9A3rlDP83v4P/XukHhV4ZJttj3ByLq+uytEz6oHA129UJbWRR0JVEGQeVZ6c4SRJEct4LotYGuEJEMMqQSUNlKgfs185vv7q2ce/B7cFosySjMCmdc8gILKIAkSKAoUQAqoCIk9Hog/d/+aMfvPv3/8E/FOGiqI0xCErE9YnDM/d8/9O+mtrfisdEjeajE9kiz5Nj+ozh17e/Kajo53Tgebc9Z04a1e+ZOsazH8iAiFVVaa3Pnj27s/PkhZeu7x1MfaiQtDgGH6uHAgKFEJogYmlQMRCjSshN6iY0xozGydtqjNAzmWPPyHGyk32l9ORg29tYWovuspQ64jGD+pF5OeKbg87w3SiWhBKW4AsMy+R/7xuXSrSdV20InRb1wfu/Go1G0Z8ekxnrsmLvdWIjOoi1BnyzjdnHyu/LtzTwM0REJIExQrtCAzzd73wM2I8abFPUwwsDQOzZoip5Z6dj9tPpFADyPK/rWpixx/ipw8EECSDA4pxjCAIhRgNGqarVuZe45h0TamawcxaIqOhMaeUJAECOdaWOFpTvSRjd1HcfRUW26ye37PkoZW88/XDUNhAlDul1rL+f+gvfcWvpPQF1TMR+7rnqCr3Gn3VdG2Om02kASdM0wtlmWcaVO7bt+joK9u1DcmQf9F+9FBBjHi8hO45XjDFdLns3jVrr6Bts5jFWzyURkZXRiq9qV5UKyGqV5ePXXnvta1/72rVXvzRZ3fCoKhcYUJMyxOLq/pCbRBj6PLLbbOsTYgcfzfzultgajSjrG6uXLl365Oz5+/c+q9glVrvCRf7QvLFNiNVaj8fjILy7u9tVPFqmDiGggBfG3rlFFgYJTEEBACgB7f1Glg1zy2WNLiCiVYrEE4gnXmiX6eTB/s6nUD8gcZUXHWoEUUoMpAfTv7OyfW3r1KEEnteYKKUUCrW+OY5ELcnSui59tZzAqih36vn6xVeKe3v7T3bVy2vws90gPFss8iQbHMyHr12eXNyGwh/evLfznZ+N7MCsjsbf/BKsjCyent9/oJ7sDAMpp9zDp2p9BPPajMxCuHz0ZORc8sYVN4lJKsgEZA0wK0Dan/kffzQ5cGZ7C6wOIEmSYOnRQqo0e+dqBwRmmIeynM2mqZYkzyryCzdXWpJBmoxXsrOneG8GuzXKvKrqLMnByXxvPtiY4NVzLsHh2lo2SWWcs0mYdMgTvTpUgxH85Y+bbf9/+KdEoGqBST4KuvzSC6uHNXzvQ0hzdfFCPbAeRSkBa0GYDiqQEgaejQEvysVwa+AsgfUJKMP7U6krCrLg2mpLzo1RZzolZbwr09PrL7/1+l/f/mTkwm5CAdlVwVm00QktwuxFlIgEbtBo4qn/zre/9dprr506ezbNR1pr3zPNLlWR57TfjFW3KnH3zM8XKfqkpt+NZ0k28QMGABD69ZLHcdPFr29HqBl3HorGtNeqYNj72Xztc17XTbBzVZ7np06deuHa9Tv3Ht6/+YEmFaH/REQjNbBcRALELfhkZGfCLUI9Nhgq0koEjZre8as2koH5eH/6o3veiuNScGFoQlKWMkf8FvWM9Cef3zKl5aaSNsan45h8VEjt3OVRn8S2APva2pq05o2qKEmbyDRjyfsQQnhOYUJoFXUA6KJQOybYGc47K7tgp3GCNsY470MIhlTEm5pOp0/2dlaG42hmybIs2qyMMRwC93hbE/YQGYC1zvvauTZ5yVeVV0o538A8CBMRW2u8Dz64WJARWpcKyHLOummKwhcjOA5w4lzFox6BK6DH9eHoIewAQ5ecuGd7OCYZYN+8AUsU0WOrvux5L9sK2o0CCDFSd7mHpKmQ3o9db1yMrTMoTSwRhZqttS54OkEjOnloKRR3PwMr0yDNNdUCVazJhIEBEUS4LRnLWZaNVyZ1WQFAl9cjLWCaD0sgcAWIgCo6QeeFMYaDK139wpXXvv71r7/22huTyWQwWasq58Sl+SCEsJhNWWGapD4wHiVweMIIfGRi26U51o59pVsmBapYLFZXhlWxdv7Sxdu3Prn32ceJTdqYE+B2meMUWWPm83lje9M6mnO01kG4U2iWe69TNuI6tqarJPDGMMlIlYf75GLmKOogQUQZNON8VrkP93Y+M+iygRaq6qImq1ObcX1+Vn/z+oupSZ/u7WfKuFAr1AKiiQDQB0YAz6EOTJ77CsLqaLi/fwilz05v6ir4NIE88bMCTudvnnvh4aMfp6NBPUlgJV1fe+3Jv/3urZufvvFH/zsYJrurNp1sVLP9BDNfgDx5PBqsyjAHAKmqhHFWVcPay/5cbdaUGl+VCAKobeGkWvDTfbz1yBcBzw6ruvKeFIr2vmbWQKoChRqAYVagq4dCugaAkD14nJW1qx7jeJxfPQ2L+cFiL0XIz28HD84YsRYUumFu83RtexN/R2fDBAYpAIFj9AEC9yN6bLoC9bzWVV1Mhwc62R7zqbXZeqIPC/PgqaytpufWeGzqugBKDHhkCYVDx6oSqBEMYKpVnuF4BEJqXvj5AhwLKiTSlTPCRAhK1c5la5PBm1e3/nRwuD/LTo0WWpEjHU95aFEdKO5lAIAQmDlkib1/9953vvvtf/JP/3moa0K99E4+xwj/3FPQy2Y/dh0AukDR7s5n6DNHX9p99/lHLxpwj36KTTbp5/b1WFW2X/MuEfni5pPnzcOzGiNwRMpyrjp9+vTuweELV6/bScGeAAEAAElEQVTvPLxVFaVNLQlUZQmIgYWIOsmh1WTa1zXRAY3GisIxkbozFXRxeSdn+GQ/5YSRBlGwDcRtmZEAQMxdkRj21/tU4TJnsD8VnbjR3SkiHBhbxBFBOdaNGGgYZa9+MRCKKTAAwXljmjIRkcuMRiNElIODY3ONbahDaH+POeDMLMJADbZYvyAXAChEbtmurqoKjTZk2PnZbCYiNk0m66vlbCEiTfwIUVmWaZpib1KOzh1ApOPsmFEp9D4QQZ4PtrfP7O3tHR4ehsA+1MQaETWqbpvGiaY2hxRjAmj8qA1CkRao9Ngx7uIzOk0idmYZVdqW0+m+Kw0UYZw44RabnNsScctpAkR6hiTb9O0oEE2/SwAAPZsKCUAMCjkmMAHE3SAx9CaEytWIyCDOuQRUf2NBZ61ppz5IE/QqIrEGMfbi1LrOmMR2zqlYg1hbk9qkLEtURKJi2dhoaWSQGFpHTSQLKSJFiEDBVxX7sxcuvvnW27/11a9vntrOB0OlzKKukRQ7t5hNkSTNrDGmqir9HMTSz2+R8kXwPgBAaVQQ6AmR8ZfgOLgah9lkZfjiiy8e7O1MD/fqaqY0UUxS74obCURBfrFYQOvDqtsMZIAlJB+1aD4iwoiCsShusyU0YIJqOx2kgLKoLJJT4EUAxCsWwokZ/OizGz+eH+4M85COQhCoywTIQ3mmmP3h5qnzq+vlfK5mlUpTCE3OLZMCwGiTE8Gpr9bBbrz3lfhS948+AQ+bF07PDg4HJGYy1nPH17b5+zJGY7MsWVt7/LMbZ0HDJH94+6Eidfqla+7JU5NvrOUb8KQw+7W5crYwgk9LqEDXAfJEFlO1Px+dWlXnNlgjPZmBL30wZA2l6KYlra97Ys5Q51k9Gai5WCTHDIlV3lPAMpQ6S0BTXVZGk7G6DGVRFCuPlTN6wZwQGbKQDoaXV2w+DjkQaSKDaWptwt4HVyulYVbXOwv38CBThhLLioAZ3PKkhHGuPOmgneOyKNJiwyW5PrNi6yd6dgjWwK7yB7UepDxKMbeYpzozXDkIDpR2PihINCuYVuC8zEtVORGfaM3IGRlflKWhRDMJe+/5lQvXr1579JOf5OvpHEShsBcA1okRbqzrUS1hFu99rBxkE/Pu977/+mtfunD5aiakbYItnHb/8MIX4qBHT8TzTesnb+6I4ec/81k3SKtw/1ozZAM0/fn9/PwmItGL/qyHP5vePvfpsTxbCIqkciHN8lNbp69cmT6998InH38cAqOgMJCm4B0QcZumAQ1TiDGYTKgwVsdcKtHR+dK8uUkLOSqbfc6a9llkO2TuYiz6H6FA56+HaG4R6ZC4jwsuMXgTSXpWtCXaQss6+/ukMzzE7A1q65vOZrOYPVoVJRFZaxGxruvuCYhLcLM4HUSELKEtgoGIVhtuEEhb8BtEEgmdwQoREVXEbgBoXJIiglpl1oYQ6hCm02lmki7o0hiTpmnk+v0s0/7Aqqqy1rbxocjMSWLW19cnk9HTp4+dc1mWAVCxqEREzDImTmSJS4YCcc1jmCFGbG+IZR56K9Ry00ZJDY0/HtoQyGgd4RYjpT/yqKBEHVYIkSMYcsP44zvabzX1Qk9uJmjPdqfKdK1zAVCbn905CJ65O40xoe1nRI+oXJ3nuZRLH3BvyzZVS7rhUGTDJFH+AGzrzlM0/AZhYu9FRGutSdV1PTucuqquveuWEnsBxiax7ENzDICxdXWtrKy88urrv/t7f/fC5av5aKUKUgn52iskhaJNk/chwoGZaQn80o2XALENxXrmlH5+6yS/+HWrjNJJMT+wyeDs2dMH167fuvHpp5/+snGtQSNCAUAUZ31VJ0lCLShyahMAKKqSNC4Df9vniwhSI3TFQGZmUQyGcTMbDrWuGFJjgsYQHKgIAa6pCL+6ffuOuDodlIEKCKtZltZmx+9tFtUfXrvGUtfTxaiCw7QaJgMQ8d4H4QiOr5RBkFrJQKfdqPeePF0sFhfP/5alev/hI5vb/N5ueW3Vro9kd/H0zp1Tl67Y+/dv/OkPlJezL16hb3xpPtAH9w7sh7fpg306OMyvnYFz67s//ezseMxraT0vlMJQVdWte5O1FbmwDqnxnz2mg0PSmR2PnXaudNn2KbO+pq5t86cHpcKBQgTl68rmJgAr79OVUR28JkyJqPK+rLyS1VMbcPGcDNPBqXVz8Ww1SuvVgU2yUIdqWKcOqQbwWDsPhIosOA8ji5WoQ0+VByA7SARAqqqbAcqNC544HVAaClc7smvramVUVDcyb3mO5Y2HoyyF4bhczXhlMFwbQqaqxdy7MtEp1GRRQR38k323KCnURhgRVelLiyYfU1nUFnSqU1DOu+HLV7/8xts//9FPMhFAb3ViNKKwyfLKu7rytXMIKhbZAoDgnDWJtfbBwwff/e53r770ShDWJ5LF4NlsfrmfP1+SAIhZo90mbfIY+8/sa2InX/H5b4+/Hr3zbxjM8WubiLQPp6OCBJ247bl/do05JNpUdZEkiVLonNva2nq6u/fiy9fv3b07n85AkIgSY+vQAEE1YQc9XbF9P1Ik4ICRKWAbfxBJgUTi8ByElaVOe8LMs1TLTyBeEiDHjMjOmdRUtTpiylo+v2HBTdRBkwEgEJG+4WhaA4Nga4GIF2OIXl3X3vvhcFjXNQokSTKbzb7yla8sFotfffiBRn1wcOC9P6P1MemKejgR2MX/BQ4ctG6gpDq2spyHOBwWQNQQLeexEFcIzEwC4lgw+Dbnc1mUvEU6g5bjdu82Flk8oY73KEIRfPJk5+79HWS2JhemyPaY+RjuL3cTihLxNhCJG94J0TbQWTv6my/umziJ3vvYz2YzhWUxudhfAACB2jXVxqUVBQKHusVEjyGZcXRBxLk6hro0OVExWiwuJwO2OVe9/QT9xZbWtt/umMZ2E4WeEDevb2xcFPOtRSJqKmpsKlGxxBxoEXEcFFC8ruIBgGYbIjdyOSJKC3qvlCIWbIvQMjNpxSRVqKymVlwlRAwgvsE411WoR0lqIRT1ghB1knzp7bdf/vLfuXb9pe3tbQFgEQ0cQpUiRc4OgOKZ4qnxwbZGI+6lunhmEdYR3S8aVHq+oeWWiHNFGGUeagXN7tQ106tc5bxSae04Hw5Onzt9/vLVg8PFo/u/SmxGSMGLNqasFsYSWdSgIbCwGFKBKELDaVIBUROJC8ista5cneV5HXzp/Zg0Y2CrrCfnysTX5x1vG7P35FE6SuZefFkPdDYHb8ajbDT8yXf++t16/97mtR1kxkfrzjCcezycf+VG/c8vXFlZH+LOnBbgB1a5RVktjDFZkgbhKNO7UHvvh9kgeeMSvNtMxuD0qZWHO1W9SDbH5jPjh5NqJZfbj7J0UlaLg+lj8+ILqxe+PDy/uRA3eu1FOH1qYIfyksX333l08+DU738DNgfV48/WH+8vzp/KQQJmgKV6vDPYO4TJ0O2XcvAkeMHt3MycbKZVvoJ14KHSgxxffIn/3U8HNx7J1hZYk5lBXVfWDHdhOrRDuvskQOVVyMjqC2fVaxfCy5fc2llltbbKBwdFYe7sUunFhTzLYWBgJZFJYmzEUWAvWs9qbZWMsiph4qDLguvSOyf/09/Bf/RtAJDDmTZadOoBwzAR2gsL59ZO0Wtv8tP98GTHzEso2XmfH1pf1tONCalhnmZYGyh0wAqUAuZQFJn3AMwkhUU7DXohwR2oPBtrzXXwxBq19yvmn/72qz/41uzW493tyTzlyhWJzYZJFkIoIaACAlAgAOCArbXe115gMkl/8P1v/85Xf+uFV79UaZWRRYQQxKhoyqpJR3Pp0nmIDQgmAQBBG513VDDoGGIDi9le70orwK9rfQ4ERzkBIjYGPFlGDDT/Y5CjolJb6qFngegZ748INA1IKxBAEOk8L9E+QBQDuaWrWQONWUOA8JkGDkQkeYZtgADEYB0YlK0DaG2JqK6ry+e3d3avXnl556fvfpcUK+RKCpMoF4IyFLwTQaVUp6zGiC4JgZv8QQJoEDgihWdmMtoYA4S1dxHhg1tFn4giy0donbD9eLtm8qOII0dmrVtBilW9mYhQEXPQ/SyVaIEFFACj7ZtvvvnLX/5ybzGPNVZi5yM3wBNGbmlFkL76jYialKtqDeirGhFXRuObn3yKiJm2IEBI2liEXm9RBCVIEBCkZtMG4dOntkVkb29vOp1qrY1S4qOrGowxh/OZSRIAKKs6yje6z8K76Wu0516NXWxDDeLsy9EWN24IAURU9PwjMnMIFCUYZo6w2iRERAqxg+UnItWasESa5JmTJ6kfn9FfsL5Eif3Q0bjMz4oubkbXAlpAG47arVb3CqLWTBQ9F9j8AiKx/PHJA9+/8jnkoC8zxfd20lL040RnmIj06Q+2poh2ipp56iPDSoui0Qy2S+s6uhEDEwLFyq5aa0WK4qYv9wdKG/LlomDAV15/8/W3vvzaG6+vrGwPxiNsofG6zjzP5dTOdv/3RubrL+KvpZjPuyGEEBNKichYs7W1de3atWI2L6YPi6IwRjM5gaC18t6JR2x90nzUxBJDm7RShBJCsNZWVRVA0iTRADXHwhqgtca6TG3CZT3MB+gLUYKZmlalMnpo8/L+zqd7012himtjbCXJLKHApXny9Mpo7dUrV+qqMBxsakqpCXXsgecQA1eNVbnNlVLFfHH4+AnAKHbPFJUbJUnh4LDA7VVzWNWrea7MonZU+aHoybQUX+vtFdzZuffn3xmko/TM9jw1GfpTb7wGo6xezJOdORzU8EIGq5MkMH/6yByUIUmcNVVis/W1ZHUVUuXuPg3DbHhqHRxUxBJctrl+eHFl7Qnz/iysG7U1Vk8PYOdwNTX42R1Yzev1NXN6AlfPHVxeh0GWHWr19BfyeB8/e6I/uec+ueOeHlhSSZY+HrDPU95a0RfO5levpC9c1GdO42Q8G6OSzATQgaCqYVF64Dr4ZNqkhauv/Ud55x9GUzYiKJNBntAVW51ep3mpH+3IncdyMIdyzrNKL/ZGkoIaw/Z6sPV87yBdH3kNFbIYZUgRBwLRiKREQFCRMCMzRkbIQouCNjfe/sf/4IP/6/9jPJv7Sa5NUoqbzWZlXTIzKY1NuUYOEorgEMUaq7Qt6/pP/uRPts5eWj+TB+cRG42ZmbuD8PwN/2t9Gb/mXByTDz7/u7/2nmMNO3joKCGcTHZtoyH6V8NzfA3PfDceydI4/pXG79lj5/H54rmLiIwJCkqZwcCcPXt2b+fSkwd3Hj+4I8wKoXQuRso35F8kUg9gYR+U0dKUjF/2jogk8p02wBwVsfCxLIw+K9R0lBQfZU/dSPtfhJ5wAJ0hoWfVgB4J9d7fuHEjFqyXNkQj/v6cyVv2pP9q7Gp9i4hIVVWdMyW2Y4JvH5yzv8o7OztRQ+76DC0oeZyxKBKladp4JKhXE6Q/2m6ox0wabVB96E+HtDEW0K5iBOQIIRApbMAj4k4VEWGmzn5GgNiWyRGA0LqLTk5Zf977i9qX3aRXiae7uT86BdjY9ltuHWMpmuwbjgAdy2q0jWm0e7tqZka1LP9Yr05KRfB8QhNvIyLPwTsPMVEI8PO5cH8vLme7XYvmHmnsKEeccNBYa5AI0MYI4JiaFNOvjVWj1BweHkptzl+4/MKLr3316984d+WqttnQGGZelAUzR+hS8SH0bLwnSVhzrE8kp3wOZena82hib0+jJnIcmIWIhsPh1SuXZgeH929/evvwptaiAICdJhRPgNSoH220cCd3WtVYknwIrq4nKyvoXJ4mlXPBcc2BGZCVRuHaDQcjGyC44MvKAoomb3hlZQ2L+sNPbr5TLR5PRpXmBCBINifI6uLyvP7qtdPbeT7df1I7p1QKgooUGRtC8M6LiE2SJEmUUsxSzmb8mACuxGHOHjylC2vmcCYu6PVNLoMUFY/SsiwrDGOjZiMFlrTWwzOnx+tbt3/2/s133nnrrbcO3nwBTm09clUi3moEa2eZNZMs2d1bfHgDHh3IuTV74ezo3GmZpD7ROskFNOdaWwUa0QonBlcnMLTzp9M8GYZZUS0K0ZBadejrwetb9u2r00malqDRqAf7Yf+WfPh4/v6P3aLkqtTMeZZkF1ch+Ic7T5KPbjLIFGAKqhyv6IsXBtdfzM6dWX/rLVwb4/YGrIzdiHgOaqBHvBrKebfobjZHRJ2nkKWu9ggAqCkbUjrAlRU4fao6PEyLop6X8HSuy4APdmV1AKN0UGQ4GHGeA6CXahHqRECCOCda26jUhwBSBSBEJ4isc+vSwcrv/+7FP/7LJ7fuEJo9lFLVVVUFDqQIiaLQGvtGRELinEuttdb+4qfv/fJn731tPMYsI9DWxgxDr1r7ZT89vjXORxn82Qehz4o+5zj07zlGKp/39e62z3n4yWPY3Cx4TOZoXtQFIpx4JvaCuiKFfx5J/DzeSa3d94SAhU10JCmFSqnNzc0zZ89ffuHqvTu3E60rX4kEDiBNkffGV66QGISZDZEIdEH9Ub9tA/KQiLyw54DCXeJbn+R21PiYKrXkj0fpZDe3S7mn91FUdIUlFn+QFlQjtgcPHhBRmqZVVUXc5P5SYk/HhqOrfGwpm9ERKlhCU1KLInFyXZZ7qbdAB7OpMUYjdU55aGtlIOIoHzgOIqK1jnknuvFx9GSOFn3heER0g5mt9TEnwrH57W13FBGkJmmcOVZTJGZmCUC6/SZQm3kBANiVnDnhnjy2z7p57GaKWrzRrlja5zD+5i1HRQQRITkC2iGBuXVVYKuntN6SZ3Tveb8fu9h9FISFwzFKRHQEkKIvx/RxUI4sAUtn1eiuxPy5/qJgE2eNhXOJNsDeuTq1Ok+191BV1UFRr69vX7ly9evf+OaVa9fXNk+DNouyjnWTASBummi4Opm71e9zM15uRM22G89eymc+oa8fnJzGFlZE6rq2htbW1s6eO7195uLDx0+YF6Ri7QAwxgJQAH9cJkOM9Csx1pCqoOIQqqpyzpWuTpMBABNqIdJABlWCuDkcTQbDerZQSiGLd9VglK+MJvfufPrdvUc/HWVPx5MgYqwZYl4Xu+cXi390+sJXt88UOztEXNdVbZANESpUgAAKNCLG+ayqqqoqa0woyq6TO4f7635iVibTw2mWZGFjLTmo6mtrlNpS0UDrNKCeIUCQlYwvrq9cOj0uS9g4NcmyunaT1KaBpHY+BBJKnAof3zIPd82prfDGlWJ1kmsVACoJAUmvrzgK86oYoMIkIW15NDAXtwYfHIBWOLJTt1ihTF05vXrt1HyFbInrD2rQCnKHOw/1ex/6H3+SrmTD4YQ31h5Pd+/uPbWLg4RVcTAFBdYmQ2Myx4vD/fnPn84++Plhmjxau4Bbq/lrV7e/9vb6ay8lq2tsrXfMSd5NgkmGYLVTvPB1nqXIojxA7SUEsRTGw3qgbR3YEjqBJzMfmCtvDaNRXHqd6WGWzFGDsQoVAWFg4BDBlyjGLrTwUBUEKo3b2rj4tTdvvP/J/mH1ONVlximQUooJIz2NFhellAIEBXHbGGWNUn/9l39x6dKlC5dfYA0ASafCcTgGXdxFMPzG+aVwlIfBEe7yTOCvI6fp5Nf/Jm2ZpXL08knZSegIbHlbFe9v8HqR6MHtqXY9XSuC/sXQyOFwdOHChYOdx5+ePX+w+xiQIaCIcGtBh9ZuDZHeBpYuV6WdK0ZoSnIuYfEBWoJ2snUCRF8YOikELMfynCt9undSiIkqX/wlhv01mMXPac/TgSPfVNElIUIsiBgBMlpUks+zu8UHNnIGIQl2cK4dO+tGF5yPliENz3LyRa7WvwitnaSbzX6sLwBwAGEUCIE5ZsYiKAAMIXRo/QCACESERxN8T65QK3LEeW96cnKFuqnEnmEmChzHqnt3tx27KK2Fo8/U+0sXhI/0rX1A28Xlw58lch1fHuz93l2P0nS/VKxSqg+y26cUfVCXxvrHEoJHxGOiW+zJcdkZMBbAtRqDLxTBILcAMJ8dMnOWD7dPv/LNb37z1VdfP3f2PCpyLrCvMjKMTEQKm22APcSwk+2YJBFluM9vy9DaZz3oefRRKa0URJiawWBw/vz5F1965eHjB3fvfBID97z3idVl3SXad+HcACIkRIBa6xggaqxl5tFoxMyVC8RMiqI1HL0boNpIMq1VxWhMUs2nCJIp8/Tp7i8/u/+BgSeTyYxBQ3AWEFS6U1036o9euLZFdDif22EKhAKBBbmV3a1VHMA5F7yP5z/JklM//Foz+v/F7Q9vpVQ6WJsY54q6MsMEdmZ8dy8djib7+7mD4sMPzWAkScqLGR8cTs6dglMbi4M9NXcFhCyZSF0GAsrzfGMTKhc+vid1BWfG4eJGWbrsYK4WkA8t0ggMskKlNaAKlUPjksHQDwZVYujwYMbZ+ssX9eVTcljUd54O3qt8rvX5LQBX/exj9/NfyuETPJcsioPpozt1uQAOGPelMXpIKtkWkprAIEyEJ40ziev9e4ePb80/+Pmt737v6Usvjl+/PnzpWn52y65vd6scQqACjDFjVKg8AIJVbDQ7AB9gUae1o5KtRrIGJiNgIaUQgHMDzoeylMSYUSoq90ohKhdQnI8R7t3REGYIoVjsrMzTualPf+OrG//PP36wOzcXNzy7htVhjONiFCClRMR5b1SirRGBqqryPP/44w9/9tMfrm+dGgyG7GuWJdlRSj0vNXSJBHXCVfLM+7EJIzly2gFQsAtLPHpeBKW7v3kHAmCsvtEjts961wkLbvdBr//PUTxOntrPJQWR5z/jaUevLLlVa1zoo0Ews7V4Zvv0o9NnXn/jrW//5Z8BemZPAF1KfFyVjunGgpSNuTgWQAFBgCChgwVbanRtHc2Od0IMBz1qTe/z0I4vSM+wIa0FfUmXjsor3XO6GfbeR/QK6OmfxxS//lIekza666QUgrT+vhZA7Asi1veqXkRrNyLyUfjEaNuLWa6oKNqhReSIueJYt05y6H5SRnf/0bH15McW0w2xCfLoPbx/6iQcETg6iXV5/8ll6/ft2JJIr+rKyUkXwoh13farFWXaOJVm+ZvaxSeMKx0DPHoi+hPY79gzVuvozZ33pyksxyyBBVDoCFhIX7Razkk7IdwrUUhHM0GOBL3KsquJocAIwN5Vi7IIXi5eufbml95+6yu//+KLLyrAAEABAUKoKlBeGQ0AENgHDwBWaQEIrr3+HIrTzQBJLEaH4hsr5fHbflPdi8H7ENHMEFGCA63XV9cuvnDl4p2bO7uPi+mu0g3cmWen1XJRpHewkIWddyHEQDCl1OrqKhHdunMHPbPSIbAOwGU5MXrVGC9MLFXpCw5baysWzQ8+/eiv9h7cGSeBLJReEU7LOVazi7X7yqWz54xZPNpNk7yuamuMKO2ZCTQSSuDaRXQUEBFNiogqt8xO8hxOXzw/YFXXpSjyiRqhhfGYPrg7V7j45MHTh0/SJJj1lYWhbHV9sLa+u3tfn13HjfGZTCebq4dcsiuzbOjNHhjcne+t5aPDzcIpb4pFtvD4ZMHTWdBgLlZwaqJXcgQCZcg7rAUI3SiHJE3On125dppBirtP9LxO8gE/KcoXJgNYlL/44OCdd+HhvRKKukx3lEbh1OLQZiNrmFQgAK0SD16BI6gQlAA5QQ/AMBzNB2J9LdMnj/bvP3z4/R9kp08PT5/iN14BGDYTsWIRNQghI/PMKxVExChrjXIKEQEJLNFBAdNCElWmBDVYoyi1ZNTCLcTpZLKGma1AGDSAxtaB2zBngRBYRDI1hJ0ykJtcfemlL7316V/89dBSxhm7QnrnmpqTKCjAzosSrXRdOyAxVr/77jsvvvL6lReuiSQoAK3lFZBOChT/6e15zP5v3H4tBWub6owc/T4InhSTunzXZWYctHT0i5z3Ps1c4iwfcRkgc2PVNsb4skiS5OyZ84d7+9tnzt345ANDisV1iYeRvkoX9Rm4y2uLFDUISwvkE3rxoUuWAY3nGlppI26JXzurxy4eC1r4nG91o5vP57EzEUgjSZJjCvZJmeN58xk12GcuQP8qt4kuctSl0vFcAECtkNsIhxZ7UynlONS1s9YCoe6iMU6KF3DU9gBw3ISOR2XeTuDAFra5fbJCQGjSMlCaaM3mWwEhiHSZxKobxtEnd4EaJ2WgeKUvDHUC78kFaEo4RdYbzWsAAqAEoom1G3LUej0BQht0wNJyemThkzPWl9iOfconSspJl3ClqKtDSIDyLMvBMZmjWYV205y0p/V7EsfYXVGAiMhFlf//qPuvZluSK00QW2u5iIgtjz7n6rwybyqkgAYKQFd1T8+wuzlj09ZDYUMzvvOR80LjG9+GZpwfMPPCFz7QSPbM0IxtzR6WRAEoFLRIAJlIdbW+R20Rwt3X4oNHxI6zzzk3M1FVw6YbcHOf2LE93D3cfX2+xLeyxHs/zedra1tvvv3lr37tm1euvtwfrmitDw+nSqnUWFREWtnUusrHh8eYIBVp9o9FiC1mec3V2/HAbfSRxwctdmlx5ejXx0cj/ip0mNdFpCzz1CZbO9tXrl97/uzR++/Ngi/JmCABtRCqNjasS+0XvKs6LHMA8PTp04j/CBwZYi8GSAOcWV3bHg2VryBABdDbWE2G/YNHe79++uQXGT82qQhqTeRYimpcVN8Zjr+4vY15UeR5P1vxFfdIx9jr1CSsuCiKoihQwFprTQIAyFJ1dH/TvcPe+lidWcun+30AzlLYmxbIaRm2X72+feYMGDU/twoAaT9FoyezaTEv/e5s8sGD5+PH44tnxBIWAebMcxfm5ThN4OWXUreOvjC3HoenB9XuJBzMgISnM+0voToDtofKEmmFVHk3HKwfXthW2xuqZHfrofSVWV2F3OdrmRnb6sMPpt/7a//8ASbK22QKuAHDbGUgGjwBZykQRj8VAscKAQGYvWONqFJjtfWeiMgQrYqMglRFVTx94h48rD74BOB/HsfhwXf/anT5ot7awH5Pl2hNIiK+Em0INEoGmOk5YWYVzqogQSkUFjfLtQ+UGvSii0JPZlAUPWXBIpAGN2tonRCY2XlkJkSRXOZ7VIKM062bN5If/DnO94dqNCOSxiEKEanRFVpjvHBVesqIjHYcBqP+7fu3f/SjH62vb6ZphojUeDezSLOLLxJHtyvnxHl+4syHYwr5jnRpt4KlhbN8Z/dqkwmyVRtAG9W/VI6JJlqkE1u0sJNyAbDbWamtGLRQG3y2srRpdDEHNL2uz4qIiEhc+Qq2Nzd3z5x76+0v7e09L2YHCMpH6r9mj201/+3yj3IkpoAQBCKS5khfP/oUWXm8nd23sySMlj63dbY1LwmL9ua6dx2+7+g8sKQyOF7DUrVBmLqnX0VEFDOEd571omnZVt6GDhARY03zHWMLtDHeewZJ0zSEIJ5195dHoQO0gryNXW7hYXfSN4+P/ywo1USEWSrnUEc/nai4AyIihi4SXOhDui/1pO7BsZnXjnv83Ipe7sb0LOBePaVqWdi8AOkoVNpnNTq6RkqJQIyzlQgMl5vXjslxTNbpFC7d0L7RGncv9GMvWo7YBUbH3kvsW/wcOFrHCKBeNkRIRBqT+TRPEvPld778la9/69rN11dWt2zaC9Wk8ioxqIzxwSNgICiDbwl3ScT7UEGoCWSPvaMGDB0Z+dPW54nlsyg5ItRARAhBAaKiaOgZrY4vXLr4/On1O7dvHRwUqSXvvTEqpu4RadzdmwdFjkJoePeSJJnP5xGMM7OEEHxAskpgpdcb26ScHkiRZ/1Rsr2x+/TRhx9/+NHk+Z2t3qzXRxGPokoe2+TVQe8fj8+8pBPIXZpls6o0JpHKOR/Qak1q7itmVq1TfKjxaBc7FvuTyd7+5sV1/VzQVb0NC85XKdE4wVFSvDTG/Xxw4+vTvSd+aMUEnM+20ELuYTOfyXMtflyqcFCUAMnVC/OBgiI359aBBuq3H8OHd+nwUBkLwuA5PN11G31cHxqTISoOHkIAYLm4ubK9C1NfTQ8zUZz0SnFFPs22121VHP76t/75HemraR+16m2MVgtNPtWOg1JIKfnSI/hRf+QQhR2KNyA6QwAugQsoNW+Cr7SvFIQkQdtLtPjcVVm+oOL45L/8r/XZMyuv31i/fpluvraxs439TDEIgaDEGd4rQRKTS5CSe2QAKCYXD7N5ZlIogkyezIrc2F6SjoAVyzQ4X+9sAiEEBFBal9brvhpg4ieOh2k61CbMUhyWVguwFwnMwtAeZ0II2hpxVUxB7r3XhCzyox/96O233x6PxzZJlcF4KgjeNcq1YwxXranl6MQXWazr4x+Oy6R/+HKcmyu6GfJSIqR6B/97aprQEZrmdg8l0q03bjSXiIj3TMIE7L3f2dl5vvv0pStXf/7jH2ZWC7MiijnroY0u9gE6pEQRUEbPzSbyZQFopENp3W1PPRaNjrx9Nae9nSVocqLwXUIS2LCStz7IWZZVVbXksIidXZd5GdrWYl0YFClYpHUVkSO52Y7OQyJSjdGqxXrS6OYjuVHbYKWU0TrP88j1sLqysr619ezZs8PDQ92qU6LQbttaORdtRdiQlMWGnhgJGSUyAFJM2RW5KxGUogxtLaqVas3/0NlVpfXQiUOjlIgooqhhDsyLcBJEbMLMpJvFvjOmrcuu0Vpi/6nWwsVnEVJNuBbzti+gIrGItMn3GomuqKGfY5GGMgRArNKhaVjnxEwojcJeABYkKRAZurihOAeIrB4CsUdNWkLPtU1OQ4yOWSgn4p/Rabluc7NIvPfEgbRiwCBMpBARWJQoQVCKgKSqil5iU1T5JLfG6mz8yis3X3/r7dfeeuvsufMmqQnsY3odRJDgCAAEDKkYNw9HmXEbmLY8lWtgfDQH4mJBaiMiwgGg9p4BEQDhRitZ37+IrjlSeVubl4XpMY4xERVVmRizc/b85sXdm28f/Pbnf5MfPjPGeAfiQwjBGKNiflfvszSdzWauoQBSgNoaQsyyzDnXU7SfaOONYVWQG5WznUlZ9CbWaez3ijVtwbtbBz+4++RX436uM5nNabjCU7CZGlf7b+vhjY2Vyd5MJvloNEq8L52bapXZXqr1s/09haCUslmm6gByD0EQcbaycJZ0SvzD/fTRdH9jgHe9JprYqr9bCAb5i9/Q9TMf//b9cx886jl6Fort//Drfms4LcLg7A4Me/3ZFCoIm5tTjUNl8+k8AYJi4mZ76a1n8NuHfj7X62vQ11WCtDJiUL7UA9+DNC2racIQPKhRP5/D4Naenz0tM6tpiF4lz51LdG6M/d2Hxe9/P7cIZzb8YFwEWWECS2JtYrQTzgHUsGeQcgjCoFSqiaLSlRE0gEIgxcKpr4yAAlKuqlyRJ2mS9Gw7Dmeq/OB3v9l//zd7VlcXrqxcu7zxzuujm9eT7W3TGytI4ixA5xNUMNSeQ3CFCqKRwKhCKgyc2Gyg+jIrff5UKUU+UAjB+wDCiKQVaiXiNSkfZrrH0E8u/tNvvPyn/+73v/+12qgeY4lkTQkoME+EAtsqaGNQBe+90VoYS2Ek5RlWx2t7u0/+4i/+7MbLr5RlSdoqpcoqFxHSBLJYzvXuR3Wm7ji5j22tJx+a6w+1Wrl2kzKtUftoPQuY0MT5QzwCAh2/GREZO+muFj6EAHwyEaKGRTgodLbrAO0Kbdpbm6IW22Rd8bF0mF13tO4JDzvHMQlNovHAHSO4iNZobD6dj8fjMzvnbr78ysOH9/f2nmcIIqEIJWnjA7gqGEuVuERs5P6JQpeQmJl9iMmBsWP+5g4rBAAgAxFZqnM+KwQvjemd6h5KYGwoxlvh0lbblYxt4SY5V9cpBAA0KeikAytdBQgszPG4EvX0Ha1GQFCNpGizN8R3K4Hb3OOLf+NcEpaYX7RzPEOpnT5i1xAxgEQ9KDf6ktjmEIJD0MaIiDEmz/N7t29z5GGCjuIltrQ7uNgoObDjZNAuAG4e3725nS6nYcAl0Nf+0T6rbU9kiZCjKqwIgJZQY7xBOnaHxayNfzZuDTXTC9Wp3bqzfKlVzRGGY/QaSpu7tdYc1O0kjOq9eiF1VGSL6liwoRRrKTgb6BJff91+iLTrTfa/hWjvLtkGonVHmEgTqqjaqMEbC6Joo6qqslYPe30SKOaVtsnWmfM3X33jldffuPn6a6OVVeeDYwcQKV4XXVgaSTi5nEh1jEtHG8STNbRHb1l6xKLmBRA5qujqDkucA977fr9/8eLFh/furK2tPStnAKwYRNUlxpIhYjR/RgVgkiSJNl64qqqodHXBW2WQAynShGO0q2mfXdAeCwhjxlu//eDffvCrH5lq12Y5cs+krnRJpobsXvXpN1+6CiziQ6+XFlVeBZ9lWa/XI4EyL4ADNWx1TkTF3hEKwM7hYpR6Fzdxc+ws2tVBciiSmBVKxIaql/ziz74Xnty58PrLH/7299e+9eXCJw9//ruN9U26sPVc7yKWuqhUAckgS0Ho0GWTQ0isPJ3iw7vF/kwPDV84k/etTXu2nwWrbBFiYmyuXGAnpFApISp6StIiYdPTFhMTVnpucpCkSZUfFHduCTKP+myTHupSAyY20UZEmJQ1iSCyeFAqsVkVGGRh6iYEQSRELyWBAs3MwEqhUWQIiUq1MCya81s7gsV0vrd7kNy+ffDJx0//+nv27Nn1V66vv/nq2qvX0nNbz3vZwCSJ12FWgGdDmSjIg89KVIkRgtKXAGCHWgdfVblVVhiBlY4mOQJERhAFmhlC4dEk0BtcfufN8/duP66qYaZdjB8MrAOJiAMuuTJxD0EAAI2EiIqUVmo8GPzm3V/97Q9/8LWvfxMlMGOkjo4nVD6yhInkyM75aStlMf8BFqC+3U+Ol/bEdvL10+tf2hJPq/+0srRa/x7L8eYtlSjCoyZ/e3v74PDcuQuXdg92i6JKEqOUciEQaKU1AhutfeBIRNjuq9H4Dh153N0MsSM32xgLrTVzDTZq/tBmacMpVpK2wvYR7fbe/bZ9dNS7LHbpZg/0IdR+ckrVWJEQEeOcjAaytkaGE7oTP5/2ykRqBFK3s7G4MXOv12NmV1YxESk0+AGghjhR5nphEdGtmF96jDSuiBGwRGzR8nscFXW1/fs4yGhHcIEHj5kw4m/ae4gImqHEk0xiLbjrOm20M+DIzIhYtRbCtarAOaeQSKnjYvXEK+1k6j4dANo8diQYk4+cFBC2PBRdp4cIqFFqC0g7FNjoP4iw1WJF5nURaW0lR6oFAEZmERSFDS0HiSFViUustkoX05wdr29ufeELb7355tvXX3l1NBqZxM7mc2bRiSUQ58ouhwweReInlhYuviC67/jwnnZPp9RIi2h5AsBJBqx2DlSVtwbO7mxfuHBh7/HFyd6zyWRCRmPHObqdrmmacgiIaK1Ns8w5F1EIGZ27YkAkAA5Z8mLEaiMbWktuWqpRD6bFBx/f+VN3eHdrE5OecEWiwZdpqsdP9/7Z1vU3e2sll95LSCCw9Ho9ay07XxRlVZSptb7x80VEJKq5WLxf+dVXYh+ffPMnyWB9sLMdHj2zt33Y2Co0pQfz4Hyys3Vu+8zes+djT4z9tfGaYHXnp+/md58Op4ewOdrZOTPtaZwUPiVf5cnt51IVsrnmp3NVVJIZ3Bzj+sg5h6VgBSGASrWwAgQKYgARMYBwCP0zG9OtQfrurlICSR99qQBM8DB7+uTeJ6qn3XqftUmYFEmZqlTZeNDDyNsrCrUGY3RWbyNEulE6IigiyojIBvDeCyiSoH0PAGS6iA0utkeJSS3T6jxPIcwms8nBdPrk8a2HDz76+c/Gr13beuXK+be/ZlbXYDhURJD1wCbMwnkOBoEQgS1BkOD8HEkoRecDCRASsETO6rh7cygFJcwrTnSmkzPvvHH1L79/cO9+P9uYW/SCRtCBCCEoEE3QZESI0xEAMLAIDAe9Z8+e/c1f/+Vrr7wavO+Px95hEI7Oy4TYqK+bWL/u9F9aKZ2v2sVTe0h0vjqeabK7arhpXrfydsc6DeUsyUgRoVNyJH3mdf0HlhMF4QvAmVbKh0CEwfssy3bOnLt24/rjp48eHUwCA5EGVxIBGfR+kcVt8ThcHAJP3ANbiRlviGgjnuYlcmQDtBnwEBepHk7sFByT+tI5PHdFZ5AaGEGDF+ubG7UHNXthXalnxFoRLZ1nLbXkOOA4VhBqkBE1ZNi4BktRFMH5yNwKAIwQac4hasrbMyECEenuGXGptGYUEVFKpWlas253kFFEJHi0dBFG+3rab0/oasfctRQ/2Zo8ll5wjbZPgWPYwYnYaBpqlBdY1JFpqo5ihW7vuqV7EQAaglciIoA6+QvwkaFsHCdBYBHzvdTmemJJreWgjvbo+CRAXHCnLrW23++XrirLUkDQGmk0MwjMLuRFlejk8tVrX/vmH73x9jvrG5sxuqSsXDROifeMaJqQk2Pt/DQwFQcYlpWiL/7B6TcsYrhP2wePf26XpXMu1ebShXOHe1fv37vzbHe/Z01MKVcnPWYuiqLX60UA7Z2L0cgAEJhreGeUeAZCj5w4t6GSlLTHEDLTM/Sbj977+d6zZxtrk6Q3dtqEorCcZiY72H0VzJe2diifuVAqImafprbf7+XT2eTgUJiJqJ8l4KA1GzMIxnDxzrG+nEz4AQ9eW3OJmt25bwdDPVpRotXA5PuH29dfcigPb9016xuPf/jrQZptlwpX0qQMxZ2ne3tzfWmrVwhYWz5+VP70g7lieudGmgxpZ4P6GWQWNY7EwMEUMLdrY0/gjdKIxKwJo81WJJiN8eita/j+A8idQAizqTUKXAUPbs39YbIxkEGfwAShkCBpYqVRKx3Jf4hMYpVSQUSlmYSAIqgUkGIRICSjWQkpJQGocjHcNO6eg964HQq1vV0SCGAI/T1BANKo1zwle5PdZ8+f//7R7sdP3//e+2euX73yxTc2bl5T6yseSjE6y/qT2Yx8yASIlEYCRvYBEX3gqEIERdBokgGRAEhZDVApJYHTa5devXrjo9sfJ07ymFgWwYAKyKy6Ss1GLLEIggiwr8bD/q1PPv7ZT374zW/9MQRGg0cIJAAEThbep5Uu4G4+HZn/xwXw8p+NBXTJ6RI+w2r9jPcsPbqrvV76tnvxdDl3QrWfJXqTUKO4yMIZQhiNRufOX7j2yiv5073Dya5RYK3lgMgiPjCxIgOtDIJF6q7jDWv3pSW50H4bA0TrKFmo41y6bqfd7p/4vpaOfF2p2kpSaHXCiCwcFRuEFIm+67AaQfEBEEUtPIS6z+3OqKXGtHKu/rORAAqwNV0pRAkBWOIxNUYXY8cqgp3alCJE1F3dRrcp0XrUuiKmaTocDkVkd3cXGv0HNFAgpmxZwhMndqY2vnSGuPbI6Lw2oejSEWLG0Zbvoe1JxFlYO5d4aMjK2vmx9Bbr+IhmmFozEBEpWPT6RJTXBRyniUBEiglq2p+3E2LRqRdqF7uoKPKMxckeMV/br/a245uLSaxzTjgQkUZiYUICRS53vaR37sz5t15/+wtvv/PS5WvJcFhUVeEDCpCCJhONwzpv+xFd1+faYpbKiYtKBJbmyWm/bT4caUanwmVnqDgnlbEhBEDY3t6eXL5+7+6Dhw8fe1dqi/HVa62rqrLWbm9vP3v2rKoqiFlbY+BiNKkC6DRze3OVWgEeoN4ajQIEV4XVlbUnt27/6N7dXyoue0NTkffBpKknMFRdyKt/fuUNo3hSzPNpPhgNKbESuMqLfDaXJj9fXC+CGBW/MfcN1eC1Llab6Uf3y7Nn1NkNfvB8wAqcVHluV4ez2WTlzSsXvnZTzyq3Npq/e6tvM7U1CGeG/SQLT/YVIHgP8wrulPDweTIJyfYGrO7A6rqUFSjFxBIc+DmI9yRMuU3G3qZBoXhRWoAQrTZK7/uq986V8P5t9fPbFZSuRxZB9g/37t3yQ+XGaVB2oJKgFA5Mool0opRCRcSARMoaIBRmBgJNWilSWjQxEGpFRhfeCSJoZkL2gogKMAR51nFBzNY3CwCw1lgNul9KKAVIyDjYnpchL0NVzoWf7O49+7PvnXnv4/NXL6+d3bYrQ0httj7SVoHzLi8YxOqEJIGiUhSBfq1HjeoWQEQITEiJNkZ7ZF4ZXn7njdUf/sXAhSlBrgB8rWmUEJClPvY1zAQUzwSNJVuB/OB733/zzbdtmllF2iTBHyGQfvHkh5MWYHcX6m4CtXA6evNxCPIZy9Kv8Kiq47OXdsM68RF/2PZyZK/uVNCFUJ4DAFitAAQJKU23t89cvLC7d/H+u+/ulc4P+1lZuLjuuM5w0JxmOw+Czk7YHYToRoqd03Uk847WCm5+RfEQytK1qpwoa7BzSJZjUZbtU7BDfA7d98sgIFT7BUmQEAcn5hxfGv36kjQUag0qApFugnREhCNbt8RFGYOh29aur6/3er0HDx7EdGZpmlZVVQ8XIkWZizW4XuZg707QVrsQnUbzPI/7cntP2+0u7JJOad/T0iOOdKOL10VIURQdKBBAFByZ6N2qGlMOt++PjjJ8tz/ExkiBR72IqYmihiYiv37fsZ31/6IqCeL/6sgIAImWFEGIUCbqCfCESFGKelZYnmSnMe3FbIHYcaRtxy3KTOh62zT9nU4nVVkCgNYagYPzDJIm9tK5yzdvvvLWW++8fOO1wWjsWUrnJEZnBOecC+w0Ka20IHgfTkQDL9xlujcvlBztdHzxnrK0byLi8aSRx+vBJoq2O6SxMLNCkeBSm2xs7Vy58cqdWx/f+/ijqMwAgOhQ3ev1BoPBZDKJ4AMBorcQEUnMV+wDg5BRWBaZC8NxkmTpUGGYHP7iN+//hvHB6sgFSAjKFHQvy4rD9PnuH2+dfWfnbD6feMIsy5RVIJQXRagcsGRJL/LheBZmHxFG1Lhw4HC0j4OdrbCbs1ByZnt8qahSpceJVD0/zjbWx3mmYG0ghxWsDUZfexWCsJSgCA5z/vChejINmylnvWJ97C7u0NWXzOZK2FwtiPor/dl0qtMEJZlNDzMIBmGy+9wO100vxV5KyoBi0MQo6MPQYbU2DG+cD7/8SO8eJOtp/vyxv3v/2Wwf1oZ5LzXKkDIuVdKzmhUmhpkJwSaJREpPQG0TiQlrjEHSrBBJgVagFRB6EURUWsf8f0iamNMkaYdiPhrR6ijd2lCj/trGlk4zrQxXrpyVLi+qqnKhGrEty9JVlUIQY2bC1XSuiwrmpc4yGGRm2C8R5lVIAmiTkpQgEmcrIwAiMAIhEIcgokApLxycmN7NKxuba+PH+W5fQWIZmJkEEYA0LDQccRL6essCZHJBrLX3H9z73ve+98/+4/8EKi1A2JrP47mqeeGfKshPvOHIuuCFRqFdJu2/Io0/YfsVLuL8X/y4I2ePz6OK6P75gn3gD4BEi5+8ELEYYw4PD/v9PiGur67tbO7svnT19t1bu88fRZpzZkatMARpNvaYM3Zprz7e+FYOthtm7UyK9dGfYwo46eRCf6FNeal08c2R6ypm5sDWA7SWZdHUJYufx0iFBWNMnGxHTWNHZR105uPJSFdkISLbTnnvq6pqQVKUTxH9LCBBNEIRajpKQdot3YCUqqqqqnLOGWOiz107C5cEfHfI4ofjj2iXKCx0PPWdjPUbj68Kmx5231Y8S9QD12FqW4KEx3vU3g8NHUV7/cQenVjqb5vVG9NzLDaONnNa7FGjmmua2wHmTT3QGFwijQwxQBDQCo6aaBCBhenocb+dc3kxQwGNhBy8BwFcX984d/HCt772ravXbqxsbmpjYzoBpRElVKWz1g6yHvtQh/bUUxxbbAMLQX7qaByblguGn2Z2nvbDE8a53f1Oewudi3VGSmimEyKKcAgBCTh4VGY4Gp+/cPHGzVdnh/uTg2cAoJTK8xwRy7K8d+/edDqNr76OIRKBEESQmcGjMSZAsIFXRA3Tnu1lNnc/+MVPvvf8wW9WxpPeqCrmxhAq4lk1Lstrlf7GmcvWc1l6C3qw2iuKeTnPOQT2ITG2jvZSJMzA9axTSkHD4as6Go5kZ2OdrN7e8r2+XLsAvuBxL5n7ynlIhu7B00FFtLU6ffhEMU1vPaSDPMsy6Pfl2aR4tFv21kY3rg1vXoP1kc/IzWbwfBJDhGUyU9LX1gadmCyANsNQivOkFVsLSgNJwMAg5LyCflJMpufXzNUteu9huPc4PLz/+Omd+ajXH45UmkGSeEGy5ISdshpq+5AQCtZZAkgp0aS0QaUCIJOCRIvSlYjKMu89EhAlynsQQtLIbDu21dUvfWHlykWzvSXW+LRHWinQwDDgyMrsmT1M5kFTMATWKKWUxzArXF7s/ezXsrvfs2btzGayNlAWBBgsSCBmhsBRTiMLRXWH1oaJNYNUBjUGDZfPvfzqa7c/+N6zFXtoTAAUYQ8qnjSlYSKWZnIyCLHMJ6W1tnAeEX/wg++9/oW3rlx/Od4OAC2vefTf6kr9F8vphYwhhC4/ryxuOFG0Y6scpfr0BbXOXyJZzrI4PG3JH0uNVJdTkrZ/lvNG988X3/85iiKIGmKR4ByJtjrZ2TozuTy59OD2bHaQV6UCJKqT49QjQIgdYd+OyRK8wCbkpP0T2iwkDfSsJRzH1PMnHL3aCttBaAXQ0b33hLcTj1btFRQgRZE4BOpKCCM6gdqgHyfo0mi/YGdvHrm4/cgfUgs6BTg9ONzf34/HJ21Na8aKuoQ6HLH5lSajY+vjw7FpcZTHkb8sIoxWkxOrliZAqK2r25qlEexeX5Il7XSP9RfspfV8gWVbYxdvioj3XqlF4FC3VdSJq65/BQAdA03XmAJNtBJ0Jj02865pfdRBNZ0izRi1+jWz3mI6Nq1t0UY7b6Dh4ZAW5URo2QAwkpgCZQGMlqZImwNpefo2tCIAYK1d29z4yle/+pWvf+3Mxrnh6to0z+eV01rH1CYiTETsfCW+DpECFAZo9EldKNNp/EnlhJQKceQXS3SpCwBAJ2xby/ZsRIyhr8c727ZwCcVGF25kTyAoMhgMV9c3rly5tvvg7q/3n3rvsywzxmRZFkI4ODjIsqzm+QmBEFWTQREAEkZjdV4Vq4g7g9H6eAURH91/8Itbv7u9tnKrbxVpo4mxTGnAe0UKxTc2LpyxaV7lfFiMxissEqqyKn1iLanoL4UiYozxoYqppZ1zEkKctFabNEnb7pTDtGf6oNPqzi4KJST7Dx/3Pnia96zdpOL24+TAw0o/3HlMJsuqoC+ecWsZbIzw2jrtzrOzq3DhQiiw+PiJT6W/P9V3HioSyZKBIKRz6Bkr4IUAGEdDEmFAzwFZRIlXoMgoTSWHJJA5u5l8+wvF7mTvt78fzmaPVa7XVgWN1Rn3LJcu1cYLSGKFObEJEcWjSpIkqBUj1voMRSwgRukkZU2BAyojKECEKiZhRUBCpmAX7kSb77wOSU+U4YAmt2B00FpIoYprJw0Adt2QMDlRoiEYQE3DkRlB73+y/uQHP/nkb35y/9e/Pnv90vqNl6SfTL1PdCYeGAUDa4mLioGxKr2F1Iuoai6YaN2r1odXr9/YrP76EcMeQYHgAAKIAKMQBhZoXEBUE2NPpJXS1pbzPE2yw8PD7373u9tnzylrFChBBOywJgjEdX/y+jql1LvQSSerpUXX3eVa2HEaoD/lGPAZDuUnbREntuRz1Pl3KMxMiMG58XBUFAWKeOfWVlZ3zp67dPnKnY/fP9jd1UkSj7uIyHhELsYShKndsY8GKLRH8fZDlCDRJl53MKI6QAXoT6OoP67+P1baRxPRovLmfgIUkna7rn8CUZsmQUTV9pOF9oJgQSjwgucuNYx4IXyxucgckiSpilwpVRRFb9AvyxIaFVqrN6p3ZgAd+QkQ0WiNnQxt0XqySAHXUFwwgiITQJRWXHhjTEuqGnNQRT9/3dQGnUkcb/DeBxRQzYZCBIioFUfbNoMIh+b+6I7QzcDb4s0Y5RjN4VE8tzG0kWCjJRGJjWcRpVRUaXa1PRw95BQ1mYuxOWQDgGhrRCQapWxiQwjOOaWUr+baGq11APGVCxJie7rwKEBt9IoTukaa0UuDJRJw+SangyDEWCBDylgbqe7aLHRECgIbrRU4BhJlfEDvfZalZTGzmkZGF3nF4sdr26++8c43/ug712+8QtoK+8NZDgCpNgAAoIABySByk1chtjiyLgKRhqPbwVEQdbycvFF23RGOXz8+z098ApKcpjM9LZ5ZCQso1FpEyunh+nAwvXBxdP6y/vh9LucCThFND4skSWyWVjBTksY5E3EeABCAIhWMOwyVYRwxXHzpzM1XLk/vPfjT93/+p2j3hwOlccBoaJiTDYf75y395zT+zo3rNM/Z+/HFzcq7yfNdVUo/MZ4DaYyc+ggYnE9QoVdIkO6XXiOMe7qXrL16Lf1vxrEXk/9dcL99yJkFZ8LdZ9lu6c9tpEWJjw9HFzfLc9XW5e3pg8cDOUsbO6yAN8aznrXrq9TvQ1r5bOLSVKOX8lBNDpVLQTxgoIMpTAG21iCTQipETDIFjGD63O8p0OSdB9FkEjaQSxCnjYeAiVo5+MIrwfTg36a///FP8rKfgD5cHSDSJmTBqImCNOn3vKm0c0IKjbKKlEalSCujccaFWIOJAbKJskTkGZiFTbD9DEEhktVQVPmcRKVm5a03AN6No1FxUOxAY0BU2gvFlEGCMc8FIgkGNCBSU4cLCAWBAIggauvr30CV/vr//q8/+qv/y/UbL62/89ro1RsGAIyCfj+UJYGCEOPIgdAELGwgjxmAFfbJgcy/+k7/rf8ef/0oVedniQel2ONA1DM7GeKAvUcW1ISAzNFTGwyim86MQqOgIvztu7+49clXrpnryvYHg4EEBoCYn7lyTmsd2UhbDE1w8qJbXGxSBOBJN3CTZ6U50QBSzare7ki0CI87oYalI/Xi21NwQhtn13ahPW2fuE6X2t49PCyk4PFjdvNF93Mr2hsdrYiIjjplhNxVoMgzA6EEHg7XX7py86NPPpjkP9OKq7wCSgIbUyvKa5KJuj1c86F23Sa6ohprjoY6KUl7Sqwb3XAvcU3EuDjidoe3C2W6QxRFm1IqCIcmJJVQMQdEjF7/wQUvrMiEEKJWgzlmZRLSCgk0otG6KAqlTOWqGJuNiOxdM2CLQYsjhgtrfmegA3cHQUUByiAU1aYGAJIkcc4hEnMMYgGhmpAiCIsXAFiwmnCTMzZ2VWgx7VoFBQJICG30Sgsp2jchx3SDSyPbdnJpCsVzfXRT777a0Jg8l34bRySEYG0NAuAoQXVRFGmaMnM00ke2eWkobFvSulgfIjrnuo1v44EjRWuapt77+XyeZdlwOMzzPMlSEXHOeWGtdZqkzJyXRaptt1vSKoGaMz0iKqBmSnasXI1un7EDqpteEyEDCeFhEXqpFWbvKqtUQuzFG9STWdXr9W7cfP3r3/jWy6+8MRivxDSAp52cuoiiMxSnWkD+vsoJW9jnMW1+amGOxtNa4aGMWllZuXr16u6DV9/99c9KX6Y2CZ7LMvdcDVZ6lVvOQRD/NWZg2RGXjv29+/f3ty/97N3f/ujpI7e1ugtBJSM+9Hu+4jVanbmbIX3r9dcpeCW4vrJ6ODuczqZakDlU3qe9zBjjg8RZioBeWMhDZnl9kG0MaZBZNF0Ipd+9Q48P5lwlL5+txj3jjf3CjYIr/dEuXj5TjFUy5cG1kZuLAkvBk0DKFkvlXRXKUnuwALI307lDQZVlvipy5YWLZ/fubQ9fTV7anuczU7EIqVG/DBPjTAKA2mhg9oG9B0WkjGJkAhHp64RevoQrqb+6+vC736XDqVKola7QY6IpM4zINfM9KqVsmgBpz4GIbJoEUSpNlLYMBKQCKW/BAQ1sSkTs2Ze+kmDGo9ULm+PzO5Bk7WhYa8EkoHTtgRZt2LUsRYhE41EtXrMgxnwEKAiHoRrobPPNV64++erP733y07/87vinv9i+cHH7S2+k66vjC+fTjQ3WBrRyVbDGQCBklsCUKBhks7LqGeld2H7j2hvvfbD3Cc856VWlS4zFKgzFigStibl2wWk26+C8T5LEFSVihYjPnz///l9/d2dnZ7iSRhoo7z0RgVAkTOieNbs5j1rCg+PL5wXHgCVZjohLYlKib8FRTfMJC+HYIfi0dSonxcgg4ikH+xO0HceBzpFT+2mmnKa25SP+cdW7AACsjPsb66svX7852X169+MPU2NneS6kVJOUA2iRC00kLBTcR7t2IhOEdJJ+H+9Cd0uHzp7fVtJV1UOXIowXXskcOFpPyrJERIWKOtlZsUFpzVMIkebzIs63ml+884il11EP/olnPzx5HtZdanLwxhAtbPmyEWoM18gXDcfYWOue0xE5dHygIXDUWCxUCB3A0Y2D7crUWCGduFQ4tryOs20J3erWN6izlYvMzMIqhOgeLE2e2Dg0yhoh9IHjybIKvnKVUsqSZq75QusKoyqs8ZCVxigTlTHjwSg6ryBiDDEoiiKEYLO0KIoAoq1BhKIoGMRay/5IjpW271GngoAgwO2i4ppgdGlVMzMBCDduwYRACCCCMlzZmE8PLcjaIC3mM1eUhkQr3Ln+6te//o0vffEraxubSBqRXOCqmPfSZY3FC4rIqRqFv6/S3Vy6H/4AwHF8w40vVKlauSWIIYR+P7t6+crBk939/f2H9z8OwqQElUrUgMOy1a8t85kboQqV14bW1tYm0/z7H3z4ZGNtb5Aq1FJwIMQMaf/55dz9z15++9LmVvlsF7wXF/LDqS+qLOsFkoK9UsokVkofQojEKr5yA2PzwKhosDJm5598dPvR7jOA/zQ+XReOV4e5y825s2MXeP5UFJr1NXg0A2PA+yqv7Np4/nSv3++TQq0QlIB49mCCIxFwwRVBeR+KSjFrzyp3k2fP3cf3K8qS1ZW1jREcTN18rjI7SPuFiMsLACeKSCtCRARSAqVnBcohCvlE4auXN4f24sHk4U9+WrLYnilFjGk2LxKMGg1jlTUCRIKkNWmVGO0JcwgsQKiN1YlWCkBYCs8VsFkZrG2up+tD6CecKsIjGixkFgYWItOkQ2rnQG0GpkZCAkRtMgAADHWWi7e97MzX3jm8+/FvPvkIP7pNtx7f/sHfjLe3D8+eNWe2excv7bz1plpfA62DUjTqgS9cWepZSewKY2iQXHzjzeGff2+NA/WH1WyPOCejgVXM3ikiwTtEjaha87TSuqIKlLZERV7+9t13v/j2229+ad350uhEqZgdGqw2wiKd4wd2BdVJNuvPW9q990gljRV4qf7TgIUctY+ceEP3z3obPLre4aisOq3B7f0tTsJT+D+ws9ue1oX6gwAAGAXj0eDq1Wu7Tx4/u/+EgIc97VGqMo/IVZFqHLoCNxPt+K61tG+08rgN3oTOS+wCke4PqUOY2Yqe9rc1wohSFbDxdlygnFYNtmjGQi1UXwkh9Hq9tbW1hw8fxpZEo0TX9/G0txARQ/2ZMFJtw0JtthDoiyoatUjdiw7erAFH2+J2pLDDqXW8EUTkvVeA0oCPKONbcrCui2irb3hBERFo2qBwEVuLR32AkagbuRSvR7dWrXWEPq33htYaGqkTu6OU6vV6Lb7DTjgTIbbUk7E71EAQpdR8PnvppZecc/fv3xcRrTVzsNZ471GRVkSEzMxQwx3vFsnwoNVq1gfuCIYQmUWCYK1x7OZ3jSHgDKKboVjMPBAAOdh7PupnKlShyoV9CLi1c+btL3/ly1//k3Pnzo3H49J751w8RfV6PeCYk2J5kROZ7pXOWn3x6/q7luNQY+nzafcvle40aP8EAMQFpRtCCI61oo2NtbNnL169/tqTxw+mk12rSStrrT08PIzUI91tN9YTAlcJArEVGGfZr+988sFserC6fuMrXwm7+QfvfXQQ8lEI557M/6OV7be2Nv0sH6W9+Sx//vx5VbiouiSjNaFgDcdNM1E9uCovkjSpyuLxrbuph7VAg/UzcLfunRr3WZiUgdxRJZXRxZ27A30+57k+2O1vjXmkg+He1ijfPxjaBJQKPmAF2iaAAdzcrY3UeiazovAeCUCCSe10eqjL0HMQ5nMVBvz0ueolFYphnw6sGIoJ+iIPL3svwtBLQROUHoL4oipnPN7Yee3rfzR/8Hhv9+kAGbTyIOBDYrTWKsJubaxnDgjR7OiC94CYpjpLRGkQBSxSegghTxKzOuxvju3q0Pb7KOyLMuyXum8Wc0ApIN3F8SfMhxaEYPN3lPoBjQ+cqnR7a+tLX7jzve+n+/ubTGnOk3c/dD97r0Q73dp4fvli+vJL4ysv9a7fpPPrYb0fLFnCPqbsocrJfucrF//b/+6Td3/5XJkzG9shzA7Zlw5BvECXvSYIBCICpGk+j1GRvqr6/X6Rz//yz//s4pXr6xubJJRk/XhItTbN8xnpet4u2SxO2z/VKUNxWo6neiS78imardvIvqP77YnPRQA+9twlYbz4M25fn0ZN2v05do7Rn/2MtIRmjoMA7JgMIJT9fn9jY+vc+cvnzt//+Pfv9frGlTMigOase6TLx2wf8foSVWY7bl1nUuhoNU7crKgRam1ppacERq1aygkAiHqOthlWGxGJYlcRRNItWKhMVATiEWH0+/3WTaKW0SzQ8JTGftQDGGTxx9I4HNWuLb339q4aaNST6sgwAnSWSjtMUda2OGX5BbBAYIYajoUQWtov6IiB9rddxLd4AZ0eQud9RJcF7pBCQjtXGp3S0vsTXxPURwtI/CqE4L0jImttWZZlWZ45c2YwGDx58iQGKcBR3KqU6vf7k8kkBk9Ko+SIKCSqNKTRTEbYMSnyLMuYQ1EUSZJsbWx675/v7SbKHB+HOI+V0gAQX7oIg2qCcRBj9HPd08YcKY3LdJzhBILCa32LUgVfOhFtsjfe/tJX/+gfvXTt+s6Z8yGEg1lOgMbYEF9SdBc6fel+xlX9D1Hk6OnqBbLk81YbP9RTwnsi6tn00ktX9vefvbe2PZsfkFHCIZ/PEpMGcUu/jf9miSlS1gw9j08fPrz1+HHYWd0r/eTd97XHuRSG52en1b/YuPDPb94IYRYKxCRjhCowKq219oDKqCSxAOC9j9bRSNcPADK0eVmyAAgmHsuycKOFiJ37Kps6uzUubz9SZN3m2ALARNR4hR3ooMrMhmlhdzZnElyaknApgtZoYzBwQJXsz6Bn/bSwAZClrCqjtSvzMrD3bCrxkxlXzo4GqtdDZctyrnVf6wSNiQ1mYFIYFJDCOXHPWsUJzivoK7p++cKbb03+9vuuLLJhD5GQIaF4ehGuGfJrEycSMQejE2NSoKRkKbx3WtO4r3vp6MxWujbWg8Rj8PPSzQtT+YSUdA+0tf8BRZbSOn6lcSfHJqjvhMICjIk2AUSARhcuDl6+fPjR+/sH82yUpYQvUS88nxX78zs//MHzH/98fzgw5y9mN15a/fbbK++8KlsbYhLwOi3UfG3wzle/fOeXv5sjDa5eyHefPb99W6le9BYSgdZvDOozH4YQEpswc1lVg77pZ+l7v/3Nj//2B//4P/in0Y0fUQGw9x7jJtCxpMSCp5skPouL6Ylr6jT8sSSq44flxhytpytyuufMv8uucjLQeeHmIHIqFdiRriEAADtvbTIerV64dPn54yePHj6oikOtdcPrs7AzIaImswQIXtxgWcj75bHqZqFqD8Z4NFtKl9aBiAgwNJRR0PBwMgsSKSQW9t5rbbTW3jWG+0Yw1k9FNMbs7x+EEG/W3vsosLopV7qFmxwuUC+qjqXvJMeGziAvRgBa1dQx5dYyD8div5b2cc0j4w3QmItiDItIdBrFju2qO+hdudvewCgN6ysALDjEcJErddHJ+JPWgwY7BBUiwggheOQY4IQiEC0srb0q0p9FHNPiFYTlJmkkBRgk5lRjCYGREbHf79+5cwcAer0eAETvUeccIjCHlkMsYhH2jlF3Gk+qaXPj+EIA0dyrogq49uGSxQKOgTmhqQMAEGttCCG6YjrojzzgxYtXvviVr7/xxa+ub51JB8P93Wf9fj8xNs/zGL2MiHk+S4w6cTs+jtCP3/MPUY7O0b8T3FmqpH65TUcap3GQwB6qzZ31cxfOv/LaG7P5fjHfUySzSbE2GkxLt1RhXS07QfShWumtH87KO8Vs3h9qJ35aPuM8gercdPqNbOM7L7+8tbVRzvbzyeTp7oEIJ2niihKAlFLGWg9eONrOlDAHDoxgjJlPZ0PTUxanroKcsyxTO5ttSw56aj6Zrq/3OIGEjd4c4sqWHBRhaw0L7xBclmSFcSZdSTdAGIJLiJBTLokrr0IKRoNwxSEbDDFJPRAEgZJVv1dxSBiKR88yUkVVkfNMhiyi4gASglfKoNGEAArtzGFC4sWhs0w0D44LN07PvPnG/dsf57d+L8ElSaJJG6QAQWsTvEcknSWoTFxuaZpikgUfynLORGY81Gc29IUN3BjpXo9YZDZVk7nJK6g8gwhRJ806iHOiEIhQNRrQZktdvLujk1ya3SOQEJKvciTJNrcvvvXWb3/8892DT3YCJNnQ6HT3wWOj8Kzq9UyW708PD38/e/e9x9/96eSrr/f+0dvjb77Dq5uROGTj5sujwcBPdn/y3k/7nIGDoYKcDAcWkebMgAgqeEHi1FhjTFlWRCpa0K3Vf/P977722muXLl8ryzxNe4iqLPPUas/LiyHqMMLnWSPdxXXail4C+uEEU8uRzC6Lr07y0lj67RGkIiffs3RlSSAdP3vUf54yDG3izG7flwp21PshBAkh7WVnzp1/fOHhpcsvvfurn/eT1JUzAAhIAAEAhLE2Y59EArTcUwBoMou12Z676E1kITS78njpxBVLc9YlIsUsClCpmAU35kJnAiSiqI8fDodZlh3uTYqqjBUBQMwQWpvjkJh5Op3GZsTk2CE4UvZ4IyEGb3YO9+2w1+xP0dEiJvwSqMkpACLPeQs3F/Pk2OtYGPiXYkqXsGo7ytL6XSJyCG2e3Fhxd1iXZqc0Ji456ihAQAogND4f8YXFl9etJDpAxizeIEKN0kZp1ba/O3xW6dIHdt5ojcZODw6L2Tw0IYhc8xrX4S3e+729vfgKY9eMMfGrmLK89d6IhPlRorMPAJDaBFj2d/dYfGIthwV46o6bjxhJxDcQEjFy6IpEJNRV4TQGXSKCwCCiGICZAKa5O3dx6823vviVr/3R9s65wWgsIvOD/cTYMi8UYmotNmcOoxTzEafI/5+XpR3hxH3nxBteXE97EZsPLSoFAF85k1XbZ3duvPzq4yf3P/r9r10xtVaXVX7y7gYgwLqQPieikmdcPBd8PMvBDoAdHU63yuKfjDb+F6+/vdXLnj16GA7nquCyyHVidZoxkVGRVpNcqDnj2vhqEkCW9XTgJsVBcLQ+nB4eGpVs/7eX46OL/4NRySuzD277zWF2cR2elxlgtWL9dEpaaD2TshqQwHoG1kOqABQ4IaUwS0gZcBqck34axpkaZyB6TsDkQpG7jZXcPZpbHubl3sM7dGY7Xd+AQQo2AU2QGlIagMiYmFfaY9Beg9JWAXsHLigm5Rgd4tmds9ev3nlyx3tPGVk0jIIJaVQMSESalBAFqfM+TnwVrMHVfrq5kW5v4PpIBkmVUD6dW2Yzy3Fawjz3ruBEm3SwtFURESgEjYJ1XCAiCAjKSTkqOu+xAsiEE60qXzJh/8wFs7UjTw+35trv7u8XkyKUoiwDoHgFZmOQbno1e3a492/+8tmPfzr48RdX/vG3z3znW0Aj9+q1s2++uvnhr+7nOWQj3bd5cQC2V4cnAMVgOlKqKApkCRKcc1XwQOi8V64cDAbPnj78wff+amVtfbiyySAkoGvfQO7uGPTCyQ9wsmefQJNC4dMMH9DR9p9Qzykax+P7+Wl/Lq6c4sNxvP7jaOkFj1uUKCCk/Wu5Wuycy0XEUFoFRs1ZP906s3X+woVbtz6eHh4kGhgQmEGO8hHQqVvT4oh4SvB/984uEFFNJi8AiG588cXVXF4S+SOPMH/ED1ESHR4ehEbyEpFRejFcXRMSAAAE53tJnxRUVSWBASkx1ocq8q+0dozWvlK7ZQswyNL4H39x2NoKOt4aJISAkTNCjtwJAKCxyYRbHwhC7YJAQNJRVbVRPYWrIhk2EQXmyJMIx6ZLC1+W3kHT7kWjlVKRPfPEKcuNj2sc31Zj2XajZVWPGCVe1FrneR4jaZ1z0XCe5/kietYHIood4ZitXiCCjJi8HgBihEskOotMakmSRMZVIlKguKtrgUACiBTUwjkoQpnY2uiuL4zMDISoCJDZBwWALBx58IlaDRsqivl4AFFYABiYUeBb/+g/+Po3v3Pj5VdX1zeq0uezOQprYbK6Yq8UxXw3LWrsjhV0EGdnTi5GXkRiWOw/XFk6GZy2mP8u5Wh3QFklVQhQra+vbm5uvnzjteeP79/bf7a9uTM9mAGdrAc2Wlf7k53xxtzJo9mc0zQx2V7FxP6y2G8no3957dWro5X7H3+sKqEyWKXS8QoTsmeFKrNJFXxVVTrR4oPUplZCIudc5dyccNDLBhubG69dn394X41S+Hn96NKFUaLHOoPdedEvHv7+k0EO9Kv38OlhhVKtp1KWdlqZnn1MVX846CUGRSoQMxz3xytKOOQzs30dd1aSlRVgV+nQt5nq9UYbG8Nn+/O7958/2tt7+uTw3Cp//EHR6w3Pnk1fubiytdVb30KTIhGQQk2KjMvAgweF5NEiIlkJAqULA7t56fzer0flZFcIFSmRYLIECrbaKFMbmFHVU9oMBnZ7xbx0Vm2vszVcMc0qc8iJoLg8zHMqC2QnEjAAei8s8t538OZfAQBt/9/4+X8OzOwcJbbzluPuLAKtYivufYuplYGCsgQKCpG1Gp7ZyXbO+fvP7k4eZCqMI+eyNr2VodEpe8HJoevbkPXHpR48OZz8939197e3srvPkv/lf5K9evnCm2/0f/L9q2e2Pyxll11vpYe5QhSlNICEEJIk0cY65/uJmRVle7RNtA7BaU1pmn7/B3/9lW/80WhtoyxLAskS472L1ICtWg5OStd+ZJIfO/K/AJ3A0T2z+2EpcWjnB02deKRmguV6oGnt0tKG2tjx6W2DjnQ4fliNF0/LOsOdny9FiEAHE7QXUWngyjlnUnPp8sXdJ49e233j5z//KXERiUGZgRtNAUCt8DgOmJaa14q80w4w2FBOdDvYjk97pTXle1/LoOhvET8kSbK2tra/v9cyiE8ODl1ZHRwc2sy0IFQaHYOIEKBzjgJF6oeiKGox19Fwd0XzYsRYas7zOM4x3vskPNd8av+L7XlbGhtP20ftvT9//rz3/smTJwCgtXbOhRBAHVVSIgQO0VTRQmOltQ8hCjGl6zFCUO2oMbM25FwlImQ0EpIHpNqc0I6O914plWVZVVUR5UXeEkHwLYzi2ircorlIFq4jjQ7LItI5Kgas4WYEvTAg1NHYEZEYE5GERAd4ERAJ3pMxbUbc0juTJgLBiRNAalPbay0iEUAQ1l4/CFoAArNWrR+QAKAXBgFCrZSKZ5j48+A8ICtCnZhItq1JW1TCAqFOHaS19sXcEhIgkXnl+qtvvv3O61/95ng8zrIsz3MRMdYAQFmWhkFrC0309vJsOFa6s6mDQk493JxewpHp9mn5qE7berrXj4Hoz1FUA7ajFksAuQqEGksU7c+dOfv0+d6Fq28fHJaHe097Oswhay2fITgRNlaFEJ6F/Mo4W4GimMwm5A5Izctq4OhCeXDZ4T+7+cbNZK26/1xVwhCCDjDsE0tGRjO4snTOg8Z8VmSQogBXzpCyxs6L0jOP1jbGZ89PR2Z87QKkSd/2/e0HbRce/bs/v0uwP58e5LlKrLaGSD8fghobZSjIYaUrGYsCJMDi2XPDXqpiuvfUkqgQEkYu/CBN+sYO+4NSQxilnCV7exM3LVdv70meY+U0ANzBAkQAnisqN9bTzfXspfMbb39h4wtvJOcu6vE66iQVT0EUIbNCAkjJlTPBSpc63LiytnXt8dNfHfRLU/mezao8pAAVegs6BZ0yFYDzoZbVvn39ejYYql5fvIRiToiIgTTCLLD3Ah6wQvBGkVjjURhFyULiMjMGQCSsAhktqkMXHUO/6kLLR2pxbIhYKQEJLMOkd37lwa95Mxn0Sm1hGrS16WA1W8mnk1nIFYIufRpCkef9Xi8xGH7329sf/W7w7PFL/8X/5vIX3jor6bP5VI/Ga7nZK55qHAmJYxe1nhsbG0i0v783r2pQrxcHD3IeXAUu8P/w//53/6utrdW1LdS68mDtwJezNtwPAGJMezzInjzPkRbyqlvafrcbfVQ0wOJ6/QEEsAnQ79AE1P9KDRe65+Zu/Uu1LclRafbjpTiFE3/bvaHd3pv7GwxB/sRfYZwKJ/zw2FNEACAoJxJIUDPobHDj5VefPd27e+/hk3vv93q9vCyUMgRQeqe1KctSRCJHX/Qv1NpUMbbgKH12RNWti0Y89EqTmT2+xPa42+1pSxaFiM455hqhKjLCtbyLsoaZnz17tre3i4jxnJ9lGQCUrkz7lh0QIqo24BQJiQAC1FOIUHkXQFTw4D3rhFpzBAF676O9gpYoPfWRrbj7gprC2BB1aiRGYObAAcgjKMLGoB9pjpA1Ec3n8zagAxqdD/MC9cSTdxsMcvytiwjXrGqqCyqxMV9JDPAMfOKEiKloV1ZWlFIPHjyAk0rk4mQEBYB1MhgkIm54FFqMKR29QrdTrSKEiOTIkImIUBP1Gq1czjlA8N6TiiYxQMC6j81KIkBCQlxUBSwRLEiTokxrXSfAbclEgQACIgJitNIBoFLaKgMg3nsEsMYwF9W8nE9nGxsbN2++duX6zVe/8MXrN14uXc2yQk12PWx8fD5LOU3eL93zecR8987Pl/3ySC1/T6qOloAIjm6yLrjM9tNeeu7cubt3745X13fnB6IcBI75/6y1WicNU3VYBxsq540WULkLueZM6fU538Tkn77z1tXR9uxwMp1PPIrVybifbu6cefLkcVF5SRNQwJW3Ba5jss+Bne/10qDwcSgH13fO3rwCvUw5X96+e/uH358/358dTibzCcC/iq39UTLTq0MYnQmDxKwM2BowShjFKkysMmqoCRGBmX3gwwn5issZ7D51wc3z+WFRVZO5eX6QhhLmE+dLPTGZzZISYS/HgyID6mFikBjYo8RkZO7xIT6ZFO9+cvv/8+P9V26e/6Ovrr/zZnrhjF9fR4WiLQ16RVFQCDZNoMx9XtnVZHTh7PN7nxRUBSIkUo5RY6KMSmxgqJhx2Buc2zI7a5ykRAi+ctymckMABu+JPTDH7IeIxKRQGYVE3anKghKQCfSLJ3AdltfO4RBC1D1ESj5t1XB1JR0N+tuJ2/tkVuSoKBTVgd8rvXO+AqTgOe4DxlovDoC8D5/8v/6d29y8efPm+Ox6ls/FzkFnmjlIYGZrLREVRXX//v00yyID0ol7HRJYNL/+5c9/9rPXvvLVb45WV4lonudGn3BI6O6lRyZ5yxx10leL+S8drHEKUDix5gUoOdqFT12kp1V74g+PNPJTS+tFfMzKf/wRJ45bewMRBZCqqpRSw+Hw/PnzDy5dOnh2dzrLI6uTUiqa7I0xzMFXThFVVeW9B0AOtfg3xkyn0+FwEAkU2ufWcrjjEtBV/3SbjYje+3feeSfP8/fff98YkyRmPp9ba6V+v4uYx4gGmOvAiOV5pQkRUKROUhotJISadPRfjAfRCIOstYL1uTSGNGqt0zSFiHfrPD9HEmsQER5FhEeQR/NIbv5CUO1t2OSTEUZNRNPptBuFAQu8CO1QRrSBDTHU0tsUgRCCMLZwXFotDROhjno5Zo4sN1DbreoXwCHMZjNokCAfc82uQToCsARcPP64aGxf+YkgN45XVGwEEGzmBDNfuXbNOffo0aPYXxEx1oYQOAiiIJJIS4ol8TeR7pAEmEViTjWRSAMHIixIREorAfHeUwxbqkUyITKiRgQOYHQCyHFaUMyWWTmUctTPzp/ZeeOtt7/2zT++cPm6zoZFgDRRkegMOx7O3WPQ8gngmJ7zs5TPgTlEA8AxdvPPXf6wdr64LFLJAcQYWaXNzpmtiy9devzw3mz/mc8PWmr8NjwKERCVyUub2RIor4InUpb6B8X5Q//PX7n2hZVNPDh0rjL9LNHKBLCin08nonRqKRSFLysy2qem8m5jZW1vsoe9JO1nBmk0GIZHe7fvvps/fvRsejBPKR8Yd7YnGxfhw7qp+ttfSNOeTmySJIjoipKI0KSgiCEIgAJlFJFC0YLGYqik6mGigi/LfObnhWRpWE2ZCCazhNl4sXM/PAjzfJ6B7kOSAgL7AGKUAoDAIYBPRK2oXlHy01/88qMPPnrwwx9e+eo72Xe+0z9/xksAAINUFbnXAAa0Q1bGnlmHNGXvSo2iKQmggVDAe+8J7HiQnduCMxswSikIOC8MhFQHrrhSnNcVA3sKTkSAkJVGY9GmqBTgwrqHssgYjkt5O6ShKZCotquX/0LpQRSnATMrrUZbm3plsLv3mOaznoSV8SAt0AcJRhvnldJeWARMlgaQPM/jE3r37sz+9f8A/8X5nUs7ybvv4cCXWBIio2LmqvJaa6VUWVUCaK0N3teHuq4jvEiiFSPlk8nf/s0Pb9y4mfR645UhS4UYlvy44ajgXMIB9Wc6GQp0F1HtIL+0qhbW9eXKj9fQfcTSzoAdhfyJ9XzqNvIZF760RpWF7SxqYj5l51kSBLH9GtA5hyyDweDixYt7e3tPHnz0wQcfZEq10CEEb4wlwjgHrLVWm8r7aFgnpZz3Nklc8MPhcGdn59atW1VVgSxkXws4lmBc9zCslNrf36+qCgAiTSciVlVVh7keafZyX/gIaUecEwjA0WssPip6K9TJTQCqqppOp2maZoMkQi6lVFxOkeUyuhnUzeuOv4h8mn564ct55Kv4f4wcHjo6KEQ2i66oJsLmEdE3QgCiYDtlAkU1QDPEAECkqPbzRUQU5qgcgKX1gBjDdcqyDCHE3C7dhzSJ2xsYIp311okj7y7XrgPp0npo33QIwQMrqsnId3d3YxsiAAQAYREfQCkAFI6ICQHjEQpbqjHoMMQhYgigFAFIhKLYKFSt1tiwFzdTBEWEFPpQIovWupdZAAiV895vbuy88cYbr73+hcvXrq9unMEk9QzeBY+htex0R7vb2eOf/4DymTEHxXxVAF3YwZ9X23Fayz+v5mNpX47zDwCs1d5XKGxtduHChefPrj9/8uD2x5NUI2LLwANamzh/3HzeS3quKJ/7SoxKp7Odg/wbG+feWd8xBxNVuSxJJ1UePChlgoeDyaGfFSnpQZqkA1uSFBpdLyk1jEeryjn35HA/n7//2/eeQVlYrS+eq1Z34MI6jXracwqLmFiTDRjReSbFAFAFSLQBhaCQRXlhFBEho4kEqALxgh6sziqRxIoFbdEETtAFh+i9C1WlGdyhFwSreyDiQxCI3MUCAAHY6lQ8VFox8xiSfuV3f/LLj3/9Pvztr278838y+voX5cy2StIs6zkIc1ZjrVzwNOxZm0iVg6AHsSBCkYnZq6SXrY5gZQgKZ/NZiikGAxYidw1IwMK5MseyRBaQQESgDSYppCkYC1p3ySVrDlEJGLNDCwAyStyNamtxDTnqfbHRdQsgkUAAFgaPSP3NNdpY2b11b6uXpNqYXmac98E5glSAiDRSEBaEPM+Lqsz6faslyYvZ7Qfu1h30kJe+IqiqSmUWGGIcnIgobUzjaS5NwaZIs/jZV+PR6NbHH/785z//1nBsbCqoGgcCbhWxcExYdj8saThesNi793+WhfOp+8ZpmOP4b0WWmTdPrKGt58XP/TveH38SR5iIfPN5tDI+e/7c9ZuvPX22z6FUSiGJ0sgBRNiXFQRe3Vgvy7KqKgL0lWNm5z0A9Hq96WwynU4nk8l8PgcAozQdJdJstQLHGywiWZZ9/PHHSqkkSaISxVrrnIvcXHEyIEC0ckAndPaUVxAzY8U9DwEASRCEFFTOEZE2NBj2dnZ2jNFPnz6NCAMIGUQrZdMkhLAQvogAyy8Ujr6+6F2z1LHY44g+OkgX6+MpNjYkbnKUtPIbG02OUkprTUQhnIAoT5o91Mp1qVUtgEAgwCChI5BccEDaWltDn2UT3QKDxzYjALK0qqO289iJb36BiSEmh+oOmRCK4J3794wxaZpigygjJ3oAEEaRGCQbNUXRP1XaSdAALEKk6LEBCCDE4tu4WRFBZMRFpHVESdqIRTDGEtFsNnNltbGxceOVG2++/e3r16+fP3/epklVVX5WmCTrGcU+RPCLnXitzwwO/v0tfxeQ0S0RGh8hcYj/KuWqSmEA9pub6y9dvvrowd3Hjx+inwEAKYimaiKsKscMyShBDqF0BXopq7MH+deylX/xhS+MUaaT6UrSl9LDtAClOFFFWfYRvUmApCJWRvVNMlKaAB8/fDx1+e39p4cJmJe2q43tanWweuGcop42hIlRApJX//H/vgYcf/pfVgF6guBB0FjRpHqQDAcrAZMkIZu0S3U+neSzCaSpL4AZUFEAgVp1Rr3K5n6KlgsGpdBog75aSQYwZQZhBI0aqIlKA2W8RcDEDgidCUET9UFGNNj91fuf3Hm08uGd7f/w28m182pjw2DWy30gL4x6NO4PVuhwyhAAoEDOQDRR0uupUQ+MgioPczRGowUJLMEJCIAQMzpnA0tRRGISShJIFSQGtAZFoEm64lYDIEd2KhQWkHaXEwQWpCNH+AZtAHj2FHn2WARYNCarq9nOGTrzqP+k0M8nzgXtXF6V08ppD8oaRnAcqnKelzkS9ft9UbgfnCjY/eTew/tPD9NspoC8qkiHyscQdN8wH9bnzvqcBkfWu0hM8BZC8K76/l9/9/UvvGGzLOsNhBYciSdii/bKEemFyzL+hK342Bo5DVIc1098ll8tte1T8c3f8SB0vLbPe8qK92iqVcXGmK2travXb96/9/DWJx8QeZGglBKEaDfp9XrXr1//8MMP8zwfj1cmk0lMoUVEMW5RKXXnzp0kSZRSvnItwmg3fzpG8NU2o6qqmEuyCW4Q55y1NqbUqLFqZ7Yv4YzO54VGDztIvfWnjEI8/pumaVWVLRoGWZyZuzVH0VJXSoTN+z0BPx1ZfPG0z028pSCoeBYVAV3nd2idWo/ia2ro3NsP3Se1TVzg9wWwq/8TBCUIRaQFEEC48TOsR8RLUAyAzN45T0bFk01XOYMCzFyn+pXaUESAJBCYlVJEKqqyGhCw2KyWR6edoA39exzN8XglTq+yLCPRJwBqbTj4o0cmaOldT0GaXB9TSBqKouZtASDW+q74SoQFOShtnXPz+VxIXbpy5Wtf/cbrr79+8cpb0TPIB1Y61cDCIZ9Mkn6GjXFaGl5U6OxN3Zdy4svqfnu8fOpB5FiJSaROSBj7ucrSg05r9qeWeH/Es906nQsAYEiFwIlNt7a2Xrpy/f79+49v/U6kPqQ65wIFRDUeD1EVMPEm+MSVw8r/8eaFf7px7lyi3Sx3zk3d1OWFsalW5H1FGkGpUS/ViM6VRBTEP3jw6Pb9+/OtPmyOyjdflovr1eYISScVs+j5kI3zejZHIg8MjYbjAJzRepimI2Myk6RpmhjT72cyykxiTdJXiTXGVFX1/OnDp48VTCdcVCJgyVaokEzAgBhKDIGUNkkSOBNjyzk+n2UHwQhqaMLnOSCgAZ2g1jorXD6bFMYopWzhihkEAbe1uZLtlbv/1z+99bP3z/9nfzL45tvz0dpg+1J5sG9J4WhgN9emDx/6sgTFYgCVIa1qezN4X5ZkrNU2IACBUkoUEoN4J1UJVQXek2cAEMMIJAqFEJiBFBw9NgQIBIgS6iVcH78anWU9bwAkJlWRODM1BGavEFACBWEU1R8Ozp31v//ggBnyImMUQlKKXJFkPWNMCC5IqCrnJVibeR+qys+tXTu7jYzPy1BsrFeKBlrPXKWRQghc75CRUrYxccbtPCZAB4j5xBmJTM2P/OjBvV/85Cd/8k/XhsPIsq+W1OYAsETx1fm29flYWiafD0ycflYmOLYMFyLqaA0L8CewhHBOQwMnNuakRkr7HRyTOAAAC0t3Vz6eumth4yugEIUoejasbqxvTM5dunzt2dPHh7uFhDoQIAiXlWOEDz/8MNLC7h8eKKVKV5FSkTW8rIooCKLnn67ppKUrK7tDtNR971yb8ytN0xgm2RocAIA5dBPIHQcuTW2dCYAL+NG4GHIk0A7B53l+//69UDkhjLr8WKf33gWfGHu8/u6Yd3QbC1AVwW8Uy/GJVAfdCsTsHUIkAQAXyVDaydSN3mmrxibu9Gjwz5EJ1Iwydv9EpEbGo4gEDkCRc7PJ6qspBtGJCBkdcwrVwjJWzyIAzGHhbi1cO6kKAermwQuJKyILfWyTgXhxPeKN6DPMtZOtIDBIURQYSTgEoqFHQFqtUF1DTA9FeolTRARDkAAiHCg6+wAswFU9zqoZz/YQpqrCeQ7rm2fefPvtb37jW1ev3+j3hi4QcwjBCxEGFvbW2l4v9UeNRydOi9OmCxw7PH1q+XTMgV2ejz/cafT4c/+ONSwZdUIQjRpYQHyo3Hg8Pnf+/NXrL8+e3c/zPHghAq2JSGdp//z5c/OHd3tYKpJtF17SvT8+99LN3mj25InLPQUsSTBLWWtm1kr3+9kcQ1DoXbU/37/1/PG98tCvjAZfPLd7ZcP2sv7KKM1SElJBAaIENnmZgFKaJFV5hyvFJtpa3Rv1jTGklOpZtNYlOlFKkSGllNImSU3WQwUmTR4/uF8Fn/vSamBDorWA9uJQG6PYT5xGsgA8zdOcB4HidGVgBkYwRmkNGoLkXCRpyiFM3JScUqlBbfbdTLmeRX0zGz5/7/57/9V/c+7+f3TuP/tPp0LZcFUcl4lJblygRw/LhzNfFmnaM6RQgNkDBFFEiSGtoM7JjEiESoF48UGqSqpScYg7gQTmWnUhioRFuuEZEjwJoQoigsIEzMcmWx2DVx8PAtQbiIB4wiCBkZCRKO2Nd848R3oyn/QdG1G5eLKUsdaZYQeOA4tUwccpmOelD2F8Zm2wsfqsnO2uZIeWjEggVkFQg/dNSgQ0WmsvXKtpowVZUeMAiABYhqAAjVaGFGv+67/6i8tXr2RZos04qpDbY0yjcv5MNpHO6l4MSyOS4w2EC3XIkp586ay88HWQznH2dLTx6eX4bSd26gW1YRM1s2h03dqTj/5LVXUBmW70DZrIB/YIaZqurW9dvnrt6ZN770/2PLBnFwCJ6oTkd+/e3djaTHvZZDKNcZqRVeH6tWt3797Z29vrZ735fN46XpwklU9+fWmazudzEYloA6AGAS3aiHO6e6Rva17qZhuDHL8GFgCM3hstqTkAZFmmlALFWmsGcM6xsNZaGa2hJpc6XtoHty/uSEuavnYYNRvdfxvVjEok6Og2Usv7JiRmabzavrUTETq6rO5JOpoVunOUiIBZCRAiiyALKNJ64c8nAEHqpPbHY8AQawp3AgSE6H3KiFTPPyFbE4WFxnuojfbptlCaDMLK6Ai6ur1ApUTEGFO4PEbiVGUVNaXSGlOROQAgI+CSlqxFY4hIpCKMiUoOkTpKSiCivzoXAVHMzuZJTK9nX7p85Wvf+Pabb7+zurbuGWZlsFgEzyCibMoBQmDPIaZjiZ3qMqTBsaV7WvkDNAefhjliPfGGz+26cdoT28+fsV8n19D8lgA1aYWBnQMkz643WllbWzt34fze3UuHh4fz+SRJVUxrNJkePH+enROtTSCUMSWvpON1oWo2DXmuS20Gg1KC7qU+VKntZUTlPC/2Dp5O9j6ePHxmnLq0mV15Jd1ec/1sPRlqrYEZnahEVQAVBNW3aamCwoKdKcHMF4u83D8Qax0SWitaiya0RjgkZK1JjUkELAckol5/qEmpsqJ5BdMc2VcBUMA5hopnnCeIPlSJUVZ04V0QH0A7YIUEIkgm6/eyrO8LNz+cUihLroKAIW2IfDHvARPAZhiWCewL6xXT23v48b/+f3KaXvif/gsZrJZFUQ2z8c0r5cNHB7sP3SxPBiaIz5KUjAFj2GhIjFgtRMbaQOA4QBXAewyOABSQsNTaMcZok9AIGHM9dK0kzIABhaQlR2rEJNacSY39ghklCAACswhx4FAhILBXygJpTNTqxnavP5wYk6aA03JvcpBoi97PyoLnnEslhjjuEkSImGX9FJP5dPbu5NnDnnlyeJAMV+Yh7+l0FnxU53jvK1coMqQo7mbQiZZs9yJFBtgHz/1+31TVo0cP3/vdu+cvnF1ZG0Kzk7TCXpqT69Lhsp3h7QB1t9wXrKYTvzpxiR3/6lNXohwDASc+/aiM/HQs9bma/eKGwVG7DxFJtGUYM15dOXPu3KWLl29/8L4jCHMHCFpT5Mbc2tkuy9I5NxqNDg4PkyRh5tls9ujRo6qqolNdBArtu24NIs0WjV1B2RZsShN1uGAWh8bIILVSptGdd+pZvHGqI2uaOklIROpgnGhJqTM6GRMZ6pjZCxOR1iaqZ4hIdZN+HB1DaVp7vP2EkYHvCOGviETfvvo7AADSrBBAkBAimwVzZFlnkQjuYphQ29a4KXMnviOOckv/wIssrwqAxHkiinuNgKBRSqmuYEIERNZaMbNSFFgwhrCIAAtjDBJB0ApZAiMSIBAaJSIQODTKFFiQjQoA1Iyf9YFOEFEhEUX7r0QCRERERczsgrcCgVlrBSDMwRjdTJQ6CRyhJhUEFSBXvjKciCBCTWdBBBK7H1wkDVnKRMqIIpygCs5brUNgF/x4PD578erLL7/8R9/69tmz54uiEEFXFtZa74liDi3HANBiZ5FaOMVZHt8inLCwufttd34sZsNnW7Sfds/JPAF/l4K4sNAsLJMv/MmSnhGPMgUxCIaKrHFEJknYh2K2v762ev7sufnN1+7ce1j4oBF1VQVrhML03sNJqq8OBsX+7uVB9kc3r/UeHPq508rKQJuR7feyEMIs90+nTx/vPX16uH+Q5+XawL95Tp/fGGxu9McrnGiHAiUxoGjN7NEVRGQBYFY5RaEMENijqM4A+yqU+dRXLkmSNE2ZYYVMf3UgcdFqxQqEHRalAbYAozM7uq/m1fPD3X1ADEELGtBlEohyl5KWWaWelGv38rHPCqj6CkKoNGgEquZVKIMSFAgCSkCbeschazPvfcFlJXkIKsmGhQtr/Q13sHfvz7537vpNWhtSb2X0HEGr8c2XNz98wu6e5AWN+5VijaJtQkxVUdnhIFeSugo1ASCwkPckzAAViSXjM4Qko37PpBkoA6BAEWklXZMKYwAhRYAM4pA1EAFoqa2vEs8gtRKUBcUBCgmDFwUiXAEBiCMnXrzaWZezG4/z52uFXQ0oUM580GYErhxn6bP53EKaUTrhgiQYZateyjvJx3uzd+fl7UuD3U2baLPJfTUt2Whmdj6gECEhYkua3FIISqOVJCIBp42uqgrKkohGo/F3/+Kvrl+5lr0+7KUbzgdUWivtXKmQNLHndls7KtGb5LhLhY6r7juq76XyguNHK1o+VRUhHWvLSY84lr8znvbq+POFNgU64rPz6OY0RR1reP1DAAAShTGwsaO7jVqBth4E7OwQ6Jmjtc6FQEQpKqg8EO1s7uycvXD9ldd/8uO/EWUNsHgHoKLYBoDozpnZhANbowng6ePHiJSYJLhQy1oHGCWvgkgQBQIKFbKAgDRpjCXqGQEYKJJneGboUFE0c0a01oTCASAGCgiEOHSESimCRhHActT9kYGwPvIuzUARIqqYkRCEXAgkYoxRqJk5iCOiyLnanTEt0KhfUMNvCSxBmBGVVoAUSscBrE4AIhcwiAgjKgBEIUItIgGEBKXhC8dmmnaleJfiomtzOR4PEldBtGgiKsccNUJtbJhn9tgRIF2pzCwgwlD7pNfxbgSAEKK5rjUNRWbjhT8wHlP6dT8zc8zIqlEJgFD9UI0kSAsXUJFo0Y8WYmmCkYgouqtKU3OAoKi+IhCgds2oXUNIFm1oP7Q08C6Eqqqyfu9rX/va17/1JxfOX9Q2KarKJEnpXHSejQqMpY2mWxDxBVJYhI5J4e47+nzngz9MzfDvVcEmobH3Po6BUmpjY2P//KWXrl179vPneT5bsbYsp7rXE/TrvfW9333wCvW/dPaqBKb1wfhsfzo5GKbD/cPDe48ePz/YfzB59tjPi7FV232zczbZXhud2aDUUiAOwZYqUSpvVIH1rhD/COyqoGr3ZXAdYVBVBTMrAozMb76q8nmZJcomQEhGkzZBGL0XZhA2iRoOh/1+Nt3FRnPLIowoYFCVNAxU3X1qZ0VV1Ho1Hdl8mKOiH4AMKNRAoBRSTFMctyeFqvAu0dYYZexgoCUv57sPn9366S+vvHID7Ai0Za301kpy4+LT2VNVzntVMAmIF/AeEqOIgMXEPEcAGDx4Js/AAshACJlFUpJatAlYA0axxsY3f1GIomGiM6XlSCxbnR1WGEQgZlZmiTsEdFI1xcUMInrYK0UOZnPtVAY6TTNQhst8wpU2unBzVtaMesEHnSq7vTLLw8e+ujMyz4PLctsDCBaKXsJFXlMf1Q4l9UOw8b6HoyuIG+6cuMajO84PfvCD8y9dVdoOx2suZm9oXChaF41YZ1vh6V4K3RH6w+2SxxFG98oLsMgLoMmRiy16OHrb0ofFc4XaU3f3CcvZcRGgo+bpNnvp4lLDFIAXf+HSxafPHj949PCTD9/vZzYEhm6WK5EWDzBLQxjZNKE+zdcKKqQTtu5Yw4nbaVyb7efmAF/vHfXBmZmOqhACRB+EJjK8Y3kQrpsRtWTSDJxEydmR6dhYAEIIDQM1iXB3oFtI0B29+CtrLWIcEI46QYYA9Z6G3fEXkfrcHIRjwjCqXSYAO/OpLS0EafV+sbq4hJquCi6yzHMIDiA6kSGDAgASaY/pAABS5zwmQGABYoxs9gK1MiYu48CtRZLj+iYAAY7sptidpggAyIIIRFgHtELtL1uPFzc0Q0pJvQAwDlndzboL9ZgRUbxBapUMioQAiJE2Iz65TrsWp0w7zAAAJFC6KkkSYdFGG6UZZGVl5Tvf+c75S1d7g+G8KKp5oZSJnLVCgrK8vJsOHlF0tXw4EXp1BiGO3oJ19HOV7pTCY+rc/38sMUl67YEkyCDs/Gg0Wts+c/Hay7ce3nn0ye9JAXpUIFmSPtx7dsGY1y5efXnrjJ/sK++eTx4d5JNf7H7yZH64D8GPUjqzrUe91c1hb3VcIOtxH3qJZ45nGlEUUBQitgHdkWcwRHqbSoiQQwjhf/1/uhob+X/+335krAFQIFxVhbXaFba0BVcuCDNCVHJQAEaAiF98MNZYa0NwgT0BATCSmCKUIFoRHlZqf55UqEFSUZ6djpw8wAQEzAJsQJfeIbCgImUa9S0D0OFsmhmYzOZKYQ99TwwdzOcf3vW7h359W7jkIk9X07Xrl6d3bmV3Z0BojOGWbxdRnFeCogJ4weDRBYxkmgKotSiDxmCaQGJBK9AGFDEpXJZwgo11VTqUOG1ZiISYqlZYwAHHfVhidKwQIiEhaZT+5oYzahbyvpiEFBoTArjAB2FGpAVCRSxUaUQ9TGY99ckhv0fweDyYBewFIpYZV2WqlGcAintL9H7gZguiTsR+RxNOIbBSKjrxR3X3L3/5yzff/vI7X/pybZkFRUQcONIKdA8JraRf5tX4hy8vhi+fd3+QE/PgRkLpyE+KDa5CEFigxhdU2G3Mkc3wiPXphEpERHyhkLa3z5y9cPn8w4fT6aGmsPf0Uauhaf6ts3C0mckRVKR2jMiD2jsbztB6Cz2qkUIBOOpeKs1Rv3tyro8ozC2PVpTNiIs04DVLbOd0HadcPOcrXI7RbT40NKNNI+Pc0xojV1YMyY3ytX308aEjImu1EBZFwQxKIYMwt1xa2J20C8CBjadQAEBCamCdnKI5iJgDO3qLeKVR3NVkFY2dUSRyWCAjHNOwHcGh8THScpOBEIR6gNv3wRJlPAoIRuMIqDgtoQGhkQ8uKihq9EdIiOQjxapwCKIaXWVgJIWIhBqgZklbmrjtoBMiEVW+IoypqjruTISeAzUqwO6mEPcORkEEzz4Ef3h48PDhgwtXXn3+/HnWH9o0ccGTVjES+sSDwmLeHDNkCCMA1hHD7bTGP8Te0eyML4qR+7ylu2n+fdX5uUr09NZauxDi6aMsy16vt7K6ubNz5sqVq9OnD7kshlmaO5+gHXF58+qFjbUV4Qry6uHDR795+Em5nvpL5/Xa2fHGaugnjgAAtFGi1HrFDKrM2QtorU2aBoVlcH0X+SIAAJghBBEfmFmYvatEpEvzf/HCuSRLUMCVVfRBE2FXlsE5aJXPtUgDBiCiKjijQNiHEIBFkFk8AJsAJQZw4eDhky1HCrUGMYIlGY0KAiOwVtHxmRFRo1ZISulI4AsgISjHLk2zzNjDyayqPBAaZXuhgMlEO1BEfuaMr7CXJRubowvn4eEjMFYlqUpSjyQEwCxloVwIGCB4qgI5Dy4AACcayYhCUYRagVKiNBAiKAFi5i5SFhGUwA3mOLHU4WMST5khknYAIHAQCEKqPirHEMHhwCvllGI0QVxZ+SqAAigIewxj3S9TPPTlWn+9P1r7sJj/Lcjdns2VsUwMMNPiJdDU14RUDZ6IW63QYs/smJjjRYqZHKKRtKpKY3Sez7/73b+8duPlJM207QGAIuNDKYy4yKMJHTuhLK3NE4XoC/58wQ9fXE6r50S+jRcWOvHJRwXNQjQc9yyUhW3iSKlP1qe0nEg39bQwAhFRQmFs5oG2zpzbOX95Np08f3RXkXF8ZP9fDJcQCOBRgQpAMRoAceHMcGw7xajkiJaX0PgetQK3nTmICBB1jbW5rjWjx/rrCrGttCGqr5EQAkJM0iZNW6FtqnA72A0EibNYtQ0+/l4WF5vuMECQ6C4lgCKoiVCgtsd0MVD8oCXU6DuGHUt081SqjkRtW99giybNel1dd551kWA7vpGfCkAgCNehtUcnQ/vOawoRVUfqS61XZEER0Iu5RdFaEJ9I7UggtSezetm3wK5RVGDj4VFPvoaAXCkVPTKhw5QqjCB18h5mroOVEQGwdQhqeyoS4186OiGA7uZYu6DGjTAE1Gpvb+9P//RP33jn60rpEBySEhFrTXCeeTmHQgeZ4kKrsZgTrQFFIR3RMr54oznx2+66wk9TbyxadXr5ewQuf3CJBIIAICGQ0VZpXwURWRsO3M7ZZxdeenr79pMPP9BGaVdAEb6k7Nc3t7J8/pMPfn/n0SNcHeKXrycvn8dh3/T6ylgoK6gcEYmmSnhOwVqbECUuIIOuhIDZB7ZHogZCCBIEGOISTRM7HA7bG26+epMIlFLB+YP9/ar0VVUxiOfaFSC+C6VUkEBMBGKVBS4a5lkIwTvniDmklDjNz/b59nM7T7RQDh4Sk2Y9DD7kBQYUDRBIPAcQZiEC731giY7kVfAFl5nPbKp7WRLIGBZNKgkqzA6hmAOwBE8OeVrAsN+7dung7m0s5wmwBRAJ4p1owiJoLcCVBEbvIS+4dB4QhqmmgegEtdTGQRHkOmjfH5OpIgLLe8eiIGJM9ynIdUyssHBV570EQOBoj48nO1ZYBCdIytjgcu+rMoQeiRD5EDRlLrBNe+lw9WnJn1TTX/Z1ORhXgbVShXfekkGtZ5W3SiSaXFWE+yJA0cjaEZ/xgzSpNOJ+orXK80pr3e/3P/z9ez/7yd9+6zt/Mk4yBEYApQwJh2a/evFK7C7Dfx+W2/GytFGcyg+KR3U3uLBiQ/uhw+YJL9x5mvsXIunEARQRRYSIrnKbm5sXL730/PGDu598iGQllB1BUh8tu4ex9s1iLRqar06Qcp+yGy8hqqX7o7RFAUKMnoNRCMb4/yCi259LK4OOjF7LbYGIEpZJYrCj7ZD6YP8CcF//yoeQ5zkisixkFhHVliaBdtDidQ2B6+N07cMByBLdLJegQ6vM6A5Ku34aq9xCkYUkiAgh1FFhghixDZEBAvBLVbXvrFVuNMMXgiBohPoGjphD2rxhC/neiUxpwt+h1oQsOMQWzlzN4VIpJRKgUcBIc4jsZh5amitaE6LqLg4JIjVIxDaWJD5XIj6NDqsIpFWWpN77995774d/84Nvf+c7nh2EoIiC80opBerEk1zThtBq2JpvOshXqMuKgccUFS/ej46vyReDidN+9Rkf9z9awaPKwzo4i5lceXZn+/HuxWsvv7J/9+HewfNBogYab5w7E/b3f/brX92a7aobF3fefmNw6excy7rYvCqnhzNmTrTRpDn44LzrGVGoJfplcJAAkfNHIQAyBAIiIo1aiIEAJVibra6M19ZWAOqghixLUKs0TRNtxqsrRVHN5/PpPFfWSkO+HuWlAgxRV29tNT/M87LW8YbAzAih0DCYcHVrd+UQjASd9ufWp1vrNpCbzRgKEAYf6fMkCFttEFGJQoXGGKWRgsICy9IVauaBPQAHEQZL2uf5xJZ6QAApzKQKrAoeru+E8xdmH7+XV6UxSqEWjXWyAy8KGFnAOSgKKStGBIViDGpLWgMHCQzAgAysoiL9mOjBJemyJG8QUTjGsQQUL+KgDm0NSK3PdW3gaONH4i4cBCoImgOQ9ojTqnJAdmX7cZL8YvfgvRQPEmOSpCy8hhDYm6BIK68VooraaEWqK5mgOZ0vnRw4gFJGhENgreuoS0RME/uD7333lddeHwxHaFUITiklXpaUnd0NdjEsx749cf5/ygr5bOVTzx6ftZ6Tdox2G1lCJ93tReRIotx2jrRQNG76siy/G0Ery1t6I1yhttoIXLp44emjl27f+nh3/6B76m6bFOVrk969S1gi8djcyuzF+0IRWRjKFz3FtmZaMjK14YfRp0lqPqcj2CVeFwBEEgauPTmQGuULh0WuMQkLt4wue9MSeOr4F2MrhdtRF1n8C4KGNEpML6cQFHC0HLRuzs041wgINQJE0vEWCsWtLS7INuJr8YJPAuzNN9QhHGkjj5lAI2Kk2Gse3AEupNp8FogIAQGQRKLtNXpdUJ0rt31S3VjVmTfNB0KMSpr6TUAdB4zQQD8vHPPvYaOwifsOAIgEFm7CZo9MDiQSWCRlIFQtfIsvWAhEpFGtxsQvcetBagBmNK0BQOkqRJxOp3/2Z//u+vWr585f9CJa6bIsdSR4OcUGUU8R8HiSqqP+lqHFHEs+HC+G2Es3HAcrLygvwByf655/oNLy52KMZ/BBATKzuDwbjs+cv3A4nd378Pb++4cifphlH04mv3++Ww3MuW99Z/0LN3fnxcE014klCalOzbgfCELlpCwVQ19rIM0uMDMQolGsVZx12HhYCwERCcWdkKymlZWV9bXVwaAH8Cw2clbMlLEhBBwMTJKZJOuNRmk+990QsBCw+05F8jzP89x7HzxIACJCVjQvwq0n6v7BKB0kuk/W9BUYm4ZpWVWeQ9AAElghKtJxWgcvACESJgYIAGgSm9k+Civ2jkPwEsQlLDydT977aPTyjcHqDhBoF8QxWDM4e6Z6+AlXXoqKgg/iqPGORyTwjkOFLrD3oIhKg4XDrD5cMAdEwIBACDH+mxaiGllAIRLJEgxpb2gyJ4oIAgMLBC/s66MU1VkJQARYQAKXTjEYReK9c45sAoJBnNaWBtZ71L2sGA1+7/nnqb6z3ueMQsAEVMEBEMEJBB+UQpHQyWwgEkQEQNp31Iavd5MhEJFwDXxZPAisjHr379/76Y9/1B+MNrbOGJPUR/MlNerfH3R4cTl+tjz++bjwPl5JF0DAZ9NJfPYDUke10Mm3dfrNL3ioZ1ICBOyqfDToX79+/dmzZ8/2Dw6e3D7aEsEl3QXWUhyBPn0DbHUOUlPjMrEswalO16BODNKR2QAQKSNBjgopYIz+kU3Ke2mYaboWqKb+FgcvvSBYjCph58TdSvwGT7dndYNNDC4ycNS6MLamrc5zBQB0WwsixpS7MRq+vbg0w6TRdnQlmVKqacYyP4nVWiklqEQwhMCBWcSjtLkjsPYIqX+FNWCsdykGISJmzwgk0CqqMDoVQUw8vzCfYEPTHumEFtMRo9ULUCv0C/2V54CImjDas5tYZ0DU7ZtowBkJdL3AEACQI1U6CsX0scDsopNrdxAYRXxQRqOiOhNxWcWD7G9/9+4vfvmTtY11Qm1SkxgDQiFw5Es7jjaOwPZoLzzqz1Hf83mwwvFN5B9iU/vs7fmHKHG7BwClFEKkVCIUMBrLKu+NRqP1zYvXX342ebp35/ei9M9/fWu4kl7/8uvp61emRjPDymBFLO4GbxVpRFV6qliQnJaCgikrYNExKbQAl04JWlIVcaMtq5cVCGhEY0x/0OsN+kot1hEROeeqqgrCadKzWWrTtG+UcwEDYoOZojOCoshkYUSQAzCD9x5Zoma/t18Wt56aSUGrO2Zjq9w77IOW/bysqiqvtIglTSialCEjQXSWVKXXSJGAyFcsIsYYVBScR61S0lqTKnwIPp9Ob/3X/48Lajj41rdhlOrRsKxwbgOc20h/k3IxobICBxgUx9TNnskmwVfiPUaiYK3Fea6cljrblNQcvayYAQGU6h74mslzMj80NPuC1MYUAYnbWFCk2gVDgF5qDuL54YSdV2K89wGKRKzWRoFmEEwTpRM7GNz27jfF/P7K8MGoz+L4sOyptBAvPRtKz46NygLW2imOmyliFBLSuB2020jtlKe0c86qmHk70gNKfO8g4Yd/+4PrN18bjtesTReS40iURH2lOwL/44P4T4Uan1rabblbz4kdqbsvR4L/24FF9vGcV1+Xxc8WdwJAl17iiEK9aYw2kWUrtZqAR6PRuQsXL1+58YsO4Oj2t+PM0D5BiBD5yMa7AAQQsSY2Kora0NOGMiFSNyy21UBE381oQIjPqqUzCGCjMWGJSTO4CT1rBg3UIoDjiJ6GO0643XGQJoB26bV2K+l2zVdBWwVAIh7icR+1Qgq8cL1ofiUAoH0IC+4vAGAgiCdsju4XMdZOBESoNj0AiYj39TDFeqNu0PtAFEW+jqCeFK6OR2lmDyeTg0mFRARxK2lUPYyhYkJSZJhZK2n7DAs+dVIQyctDO2SIiIQKlYi0cSdEilCHEFAt3hAALAhVglhlNDbkqkIISAEqX7UoChEFhYUDh+jWEUJgdlArtYiQos48OqABIohg8CLCDForUBJ98WKdIkJKAwMhhtIjQnQeBkXBl//23/ybV195/cKFy4hYlZ4ItTZeKgSIrrbNtGCFxBAasNlOzahMXmieAACgcZHjxpIEzbKry2Lv7s4tRSauj/b+5uiw5BrSei8fmazY6F1C1GcJx5UEQFRTorQT8UXhM3QKj0inBS2RC0sk1D3SL+reAACR26V2Ma8j2YKIOElnft4fJK+cOzu/eOXBkyflbPrXv/3Zlg7/6p/8yeraCJ0EV6WDfimhh7aHViESCts6Ww4xWq+RRDAIEakmIQBjBQp80FZ5XwhDlVeKNIIwOa17SqnSlzf+5WFs5t73XwdmgbyqfH5wMOWDQX88Xt9IekOjpZgXShullOJIE8ogwsJAzjPkc850xrO94CuT6Kqk8sGzUPjhYJTYLEzm2nPhDkufh3mVkbKMIILWegHy0DepeCpcNRWXDvt5URIwKHU4maapt9aSViLiFLsMUSXDXML+s3f/q//jrT/77y6+8tr2xoX07CW4ejFcOtO78Pa9/R/qkA+0AdbkjJQlcUUGAzsJFTAGwUColTW9fgWAwWPlCASi47l4BkWUHJFqwCgBAqIilLg1U9Rm1oKZiMQxADFA8OCd4qBAgNALWLAAMMVyEBA8VBlV+QO7N13JR86K7/XVNB9l+qntrylSk6DW+x+m9s/dow8zKYar7MV4hRnNJZCHMCuZUFsrEgChTXvpmUkrkJrqICKM1umtNsGLaK05xDNVXK4EAofzydrG+t6TZ7/75S/Pbu8YpbKVkWfBICqqQxo/g66mZHlNHDNJdM+TL1hux8tp9yNLl/TixAYspOyJatqOKiLeEI7WtpSUoL4HIhkSQL0jRSc/8A3SXBarramlUf9jtNcfdb+AxtlHI3kRrbX3HCQMRsOLF8/v7j776INLjx5+NMxIi5SzoI3x4gUFJdJZLdBkbZsDLxgz5jS6DBFhJFVrLGrfHqqxhRcggWgykQ4m8I7TLPHee+81agAhwF6aTeczAUFFhoiZvWtyuRM4x4g6Uv8DInCltQqL6A2AzuEcNGqt26zj89lsNBjGqZUkSUxGSEQtUXYdUROzi4CKnRACrVuKFxKBwCwheBZlkRQBMwKKDwykyLKIVjbyadbGEWw4J5AXE7eN6WKuiTI7s6oWDAubyFHbWJ2hQgfvOYQAgEBRV7GYT9KZZ+2IAyxN69ZPdEEBQkTeR7tPjXiYJXAgonAkYQu0M6zlXu0uDEQUH4cSakVIbX/CuF8gLhxFpZnRcjQiGTrNRhaM5p3OTzrNaIPscTgcPn369Md/+6PNzW2tTIwfDiF8GmNnHbT9qfvIEixdun68xOjtI1ew7t3R67Tg5Pm0OpcfIfIZwmdO5hE5XhWcEtfe7rnd5rXHkvaiMYo8OOcSay9efunR/tP9Z3c+yKsvfucbZy9e0OiZvXdegwiI4yBCzAJYH1jrqBFgBGrTqjFzJEVGRK37LK6qAKPuTUCCA6T4e+FFS2I6SuAqSZJ+bzidzh8/fvx8/2Dr7Ln1ne3+cMBR+xgCAQB7QRZCheiLUlXOV1UVqtSS8WH65Hny1PVLs2r7/SRzZVUVpXdFEaoNVipL2IrzgQQUmTyVffL9Cqin2ctuPvV5qTRqrXujoXfOg9S0H4FJAHwggTMwoCKf/Pjjj3/4+zuge8ON1ddeOf+1d+jaxZ7WRsj7qnKBhIQDIc6mOcZgbxEg0tagVi74IEwhoHgArYlQqdpdbXnJxLWLICGSPwLwcdK5pcAWEMHAiLV5ngBBGCSEiqbvPzh0IR9lvbIaMqRKYanWqLeXBzx31l2/8Jtq/4PHT4uV8RRJkcHgEOvIoO66DrzYZxpg0Q03OKLKRlwEgy6JPa3T2WyWZMkP/ua7Fy+/9PZ4jLM5k8o6uS3a+k9FA8cW42nI4LOXpXV0HG1E6ECNk8QLmnTkVx39VXepH9/2otxGWowtdKTG8aecBrCOX+xeCSGwLDhhFVJMOn/x4sV8vnu498gqAqCyLFGj1oq7u33zRrihMD/6LAFkIi2dlKhtsxEXyrl2zhNRy2hZx34SaqNtmqylSZ7neVnw0UyrpfNaW0W6Yk9I1mofxHmn1JE09+3Ty6oyxiil8jy32gz7g7IstdbW2ul0Gr/q+EsskFDb8hZOwSkAtCrK4XDoy0oliVJqXhbaaB3heZAQt75GK3hE70R12hhozA3LLzI2phXi3caRMgLU2HExUhKhOnU2dDxWFt0gIkCPdRI0aGVHRGFK1StcKSXCgb2m1Ads5EqcowiANXFpDU6pdfCJiVm6+8WRCXHiCo8uG02qFYLoPowKGUVIgBHr7yL46ECcpqcCIInNivzgz//iT994860rV5LEpqe9v045GYwcX04ndqq+/sIHnFiOrVgC4OWRad1KZHHTsULHqjqxvAhzdHt0tIUnP3ORZ6B1s4mKyhCiQRBRbWxsXb5y7fHdj0abZ268/mq6MiwmewKAioA0IrMIojQ+OZFNsFWbc+xX7bMAJBRESIACR+MlCSnxwTFTVByy6M45NRn0obAHz59+8smHrnSbm5tp0pvP84d377giX986o6whJHaORZSKukUGIvBOi8+reeHmqenhZC73ng79IEFQleR7B+VsqouiD3qoEksAgqwoIEok/FUkEGbgM5OhMiFwMso0qfl8Dhyq4H2EdIFBhOIpTEGJaFTWd2UfuKfNweTxBz+8++DjX136V//SQJGlqBKNpASZtBIfSCmlSJhLVwqgIUVKeQEA4Yg5mAGjsxUyNx4ZncIgIqziWz4uSiVasTnynoEE4EjuKDHWHRCNUgGcIsSymDzbHTtZzcwcyv8vcf/1M1mW5Ydiy+x9TpjP5JeZlZW2fHVV22k3Td4hOWyaS0+KIi9BUqBE6OVCF9CLAL0IkEDoDxCoBz1IL8KFnqQXGYjkHZIzw3bTbqrt9HQ321ZVVlWaSvPlZyLOOXuvtfSw9jlxIuL7sqrJe6GNRFV8Ecdsu/z6rSWHyc70cGn31J75a3/95t//L+8+s3fy1a88/sPjKs4p5XRyClX0xCIr+fUoBs6ixhqFjdqqX2u2h6G/2IMsAQAQxWoyqepw586dr/3Rl1569SMXYjWdz9woMg5dtL4GxXlH48zD8uEvfno7U9p4ylvO6+dY4EBEXpW6WLfk99eNzR7jKT2T6D2l82dc36vQ1HsfVEREpvXk2rVrH/vYx06OHx49vq+G9aTulq3rEmZrLoOhHtnoydqThWK56GEjEEGH/NVxhcJBVELEsUyVVUABEbuuq+saevV+MJ8DAFAQVVRFtCyamwSoVRWL+6XM5mrg8+msWSyJaFLVqtp1nZl94QtfOD4+/vGPf+wWDsNVvIo6u7I1odnnbRzXXFgtGoFRjLntmuWp18LdP7iQu2VwyC9wMwYZICioqnKvg/ZEvDzdTFfYagD9PrFtFlamj0LOKpC6rCPw8XXdpTzJk2T6YYy2SOGabkQzdhnCz2BdVzFy13VeaJgZzU2aMHpOcWjZykTT28FgFQzMg8Gt10sQERxS3GxlAVoJDoMFaKOfiIgQ/KVqHoG6WvSR3c/MAGxnZ+e999770h/+wbPPXLEdm87mJWj27LYFZF4w+DYNqmd+s5qTc8OrbONYyigY20txjp5GYx3TFGEUZQQjzu9DRQPosQRWbxl7Z3FDghl5RjbaqsTU2WPw7CDro4LMLV790wbLQpYOGdETHAJev3ntwuVnbtx6Yba316Suk1wxedE0NDDNHIKDUCF6HHHfUVrRC0IENCQIgRxEX1WTaNclTTmnZeBJFWKM0esveLtw+RkTCBims/2777z761+9JSKXL1/e3d979513UrKDZy7vXNhXyJozIAKhqBBEAkMQlQ4gW7vM7z+ZPm7iYkJt7trOIIGmmjESQ4iH0NSAMw0UYyZYkkaEPaFuOjEzBsxmQAhVkBYFDaoAzKXeKZbTLmDc2k5V1c2yyUudVIRhfx4PnruGupzNqkw5gwhilm4aAhERBSMQMyUyYkFSMAVjLHUTRURyZkQgZEZFG0ftW8EyWrOMmRmigqHjB0Evi3gAKZihGTIxEiADEKsmMA5kR4u3f/HjvUlNOQMyzudvPWmPLj9z+W/+l6/+8//Z7KMv//ytX+28/NHn3n7/3du/IrK4Q7k1AJd0+v3jZBOKybSovKUatJXo9eKYd9nJEHkdhLvIHIjYddmLXFy8eOHHP/mT733323/uz/+Vab1Wth5GiubTRfb/viSMbUqy9uuWtHGmDnB2D7co0BnZJQYbY4eRCKKjpCXbykD5wBFtPpYJBpQLM8dK2d/de/7FF26/8+u33/z18uQQkUJd5ZxTymQrq79jPJmZimIYj8rBKBQRsoqJWh8yu4JtUCpQ6AYDIKjDMRRiEopPv0vJFqeLZtmrNGiiBkBEzIwc27bNmgzQCz5n6WAtzWRN/xwMJF3XEVFd103TvP3224vFIqXkkeOUEqzx+jP2lQscw/Zw7g5giAqiSZoLFy688MJzt2/fPjo+nE6nQaSvwmqGtoJmH55eQjGIPFQUwA/yJgPDEWz7mKc2XUqiSEVEInJF0caIF2W1/L39kGhU8YiICgO2lWjfv0VinEAPtFDCMFBdkR3QXoeTighETLTqIZYKrqvHbrxi/P3qMPR/0ogKQK/Ze7adi7QMyDE6oraNauMhMCJ43ZYLu3tf+8qXPv3pT3/q05+BD93QQzdGe2D7fG4fsPNIw3bTwSqwarQubhb/K8FKbigz0BsB+nchnCnkbMgTxTa0ZiB9Sg/7/b3Ww9HPBZtkeJEvWS9tEIAheyAnAQAjXL9+bboz37tweTabWVoyc6CAIqhWWC4Oe8BfVPKWiFg8hIPQiw3N59PLly/H2d7y+Ml777bN8ammjADMHGPY2dnZ2dmdTeer3sYpTvjS87O945ODy8+8+PKr77z95u3bby2a5bPXr52cHIU6xIrryYQQNCc1BcJWOguQNQHozqTGo6a583jnSPnwcWg6zJ0GBYTMYRlYQqh5PgkThtBo7kANkkoC1Wqya12eTaet5gbkBEXmNYSYeggQRciOpUUITAHTvAKezcXq04i6N7/0wo1Lz11PMdqsarKEujIOXZMQjJDy6RLIMHCIFQVWBNEMFhkVgEzUKOUO0IyqiBQZ1vlHAQ72g7aGbudA5n7GPSIVXbhEBVMxYw8fUjU1BQEOy/cf1u8/jrvVMmE8qQ6f6OlzL77wT/6rT/zTf3RYxS7pTg43r906/NjH37v37nF7iHOquyki6dgRQISIObVjeANvveQ59hH3h26TZDu2sxGG5XI5mUZnA9/4+tdeevG13dmecD14tD/kofj/YxuI55kkdNwGQrFBE84VlUZG6PGV2yLRhxe2eiUHoEdw8tudhzBiXdc3b9586cWP3L9z92c/+VGX07Suc85kIL2Zzem5iQCAqMYesABHbLiM0zWRPjnDFHt49KKeDSqr7xn35rtnloayGH3UBZpHFpZUXhMJxGaQUprszC5evHh0dHTv3r3ZZA5msBaBZwDQNR0ixhjbti32ksA/+8XPIwcXfJ++x3xPu81D1/l+IY7O7CGGEP7n//yf7x8c/Mv/4//he9/7XnAIRjNTFVUNSEjGsLm/h6AYRLIR3MWg869O1LowpahZs1uEsATBmrgXooxeStSXAUBB/IXRo8tnKM4qfwORq0207Jp6Ng11FTXnLKpiZWE9e9A7auNwGQTGggRugENGMoxnbSAfOWe/wL1l/RB0MPTZqJFX9uuFpLIAgUPwoHRNKUtBSuA+ujCkLs1ms/fff/8Pf//3P/7xTy6Xy8lsZ+w/G7e14zSOlTx/Z4zvGj6ct5/Gwy9T5nfomNFuejq8GtJARLY7cHbfthwyAGfIHB/YxhtGR8aSXpopedGDtIFlFL150AiQQE1RJ9Nw6cL+jRs3GSmbkVFfv5A4cIghezBskWLBymx4XrcyBjBMKZnJfP7MrVs3Ll259vZbv7z33pupPSWIMUbk6e7e/u7+3u7u7nxnZxiFeD/rGrNMYtjZv7B3Yf/Ss1eOj58gYlVVR0dHSfLliwezSaU5qeQ4qZWII3WWGK1K2Nw9yrcfwyPV05YBIhBiHbGe0qyKOzqbynLJs91jspNmOSGasaE0SrLQlLM01raBFjWfBrMQAEAVuq5LbSciWaUDNSbkQAcVWoNqMdbVtN65cqG6erGZUNUuQqsCNlWKATOaqoIoaFaxgIaBAS3nBDmwWVq2UAlBDVAk3EhETCA63gFoShCgVHUccmNXm4vAHN0QS3qaoBMQJlcyFBCzm8H1wa/f7O4c35IL/KS6x8R/7nNf+F/8sytf/Is/P1p2p0eXuvz89WupCvceP7h+8+bpT+7BSYs4c0NFOfhWOKUDB4y0lJVnAJFhzfTrNGc7+ooAgAOaUQihbdudnZ3bt29/541vvfj8CxKwqqqSy2BnHOQPPBr/ydaOjZO78aiz4Bs/4POZDccztPH91tvPe9pG355+5XkXDPLKkMlMAAcHl1546eVHjw7v3b374P67VaUBkTla7/ofi4NjV5eZZ47oYJMent+bxvwbMzM15T6wz1mJe21cVC2vYFLTVXq/ASIGYjMTFUPw5A8RyiktF4uUUghBB/u0Z4W7qQ2snk6Ojo6AcDKZiOnx6cl8d3f/4ABFY4wnJydd19nI/ro2gSMh6cyGiC5/Terq+Pj0//rf/t9y7n7605/O5rvBkcEZCmI9oLOxMyKA+qncXCkr8vzafDm3dmtP370eSKCkspZWOEEvwOJ6CMiI81GvKKxlLZtZ0zRVFYkIIItIb7Eo/HII6na5YajfuBIRznJAjHnYMK7hMyKSA7+MjUjmSRkFj5WZjFAVUNUr7g47ssfeR1XgGM2yiF28cPDDH/7we9/73usf/2Ssp+et5WjezwDY2D5124v4dAKEPSV1ej8mK6N7zw7z6sVDAlgFRo83y9rbbe0cbv70QbUiVjdujp0GGLSRzFE6PLJtlIeIZaSKDETEMC0XJ89cuXxy7XqXF5qUzEQzInsYB4U+btuMMBimQd42XWk8qhpj2JnO9nfncRoRpGsXWVIkEqEYwnRnfuHChZ3d3d3f+YH3JL35t40DxqpLCaqICGpaXdi/tTM/Pnz0+PHjuq4fHT48PHxEmnB/PwTCiGDCCCEEJGKxfO9x86v348OmWlRxUqNQhqqrZhDnT2iSprNubye+sIP7O4tIRHTAYfH+vZM7t4N2AY8WbXrw4N5R0OlLN9OlOU6rnHMF1C2oOzVrQQRU0Zg4MkWqZlNArpHnFKeREoMy0LTuwHLSZrGsTo0AqhgBqa6iWVbGjKLZkqkljl0HKjypAmCAChFZ2bFGGAUQ7U//An78qwBAz/0bfefvDtI8nMkOB/q02g9F4FBmMCA1igTS3fn5L0/S7oO8e/zss1f/6d9+7b/+R92lvR/fv5/C9ODC5fuP7kdM893ZzZu3Hr/2ySf376XTh0tHb7ESDE5EZqBqIcYBIkVH+IcbLlQsoWNFXMFRqST/Mue2qqquzUmMzFDtu298+1Of+Nhzr31qcNXjKHbtaZaD/578KU9p22aJIdjc1nXOpys257VtacNN3IMQOqbP2zTk6dLJ+LEAxYmzjVfkTUQuX3rm+ede+vWtF4+fPGiaBSsBCAYuKzJ6FNKYMLoSzoWjEZjLqSUYQBD7YDArMsewVQCAEXPf/eylyggduAV6IWWl06oBkWYhQEZsmqXbLSZ1neVsFxIAVFUlpqiCzNP5POfcdC1lrapqMpnknCUlCKvIChs/Yeiqnb3KRGSIy6ZlpO9//4cppf0LF7quC+Qw7WSI0UzIvT7rh2bYHKoK49LyAFaqDBvRJpy+SxuttGZIRJGoP3JEI45FSFCCK3BcrGiD/Uv28FVGLr+6ISiE0DRNSl2McbhRVYelHKJQcdSG5w8WC0Ya7CBeqxYB0FbRQEOcjt+lKwlpsMH4LFPOOamSscOheAcWiwU5zGov+jhtyjmrgpkRomb5vd/7vZdefa1pmslkAr952yA3Z57qbdFk/ee1y/5TgkvX2yDBnHf+z5Y5PqgNywewJuP2pYw28d3XucCIJrpdRBRFqwl37WJnNo2BHRA2cFQBpADM2UxzChHAyBR1iCP3/dNXNDSzGON0Wle1x4dnMwmBdmZTwrrLYoST2XR3d3c+X/lTkAliRVVdVdFSVgJrs+aMppP5zpVqIrnpcvvkyZPT09OKaH9vFmLMXRvbKZgSgmZd3H3cvPNgr407NMshLRSOKHTPXJy9+pH91z668/rL/PJ125lX1YQx7MymvDz98e//wa//7b+fPnoyOblvU7zzJB1FuHpjLz+73wVctM0kaVcliTEkZjFNWRFCCJwDz+cdqCBMYmwrfGJLUNtNASlWccqGbFIFZGZR63KmgBQCBvIwsa5tOrQYazKFECmE2AdRWQl/W9sNImKiXA17adO7PN5ehRKRiVkALJhgolCpdN37796Z7t/Sv/VfPP8/+afPfOaT905O4NHpvlXWmOa2ms0z2qXp/nKvvfqR13bu/fpnP3i8B6SmjKhu5WYSMRUdLJFr+2ulhpW+4cgGjIjQF90YLo4Vq6qIClgVp9OpPnhw/zt//O1nX3htMpk4cdM+G3ZgPNuHYjUb6/35TduZ95rZtlcUPcF3RFXG936YEz2QCNgSNbxRb9phQFlnEBtv3Pjpw8/AcHiLPulqMKCo7u8fXLtx8+WXX75//83379yOHAmqzvJYqBrcH2MNq19rRGCiHtxCin18YCUrGXnUcs6KysxI5PAag2RTOIiaiRoYWQF+wRLaqIE4VFXbtk3ThFiPHzvMz2KxmM5nAJBEUtfFukqS5/N5BXR0dFRVlYiknAeBY/0JveJNZCLaz1sZrwEYaLbJtHKZaWe+2+WUUq7rSQAAYvCSQiKiiFVVxRjcD90vgzu3PLncqISqr5YHAJUxS0sGMdSIYblo61m8cvUKGj548GC5XHoUiTrE54hYiAEQYhVAPdGehsrsNhoJBxSRLNmBMUrgDJEkCRzQUJMhABkQQVWxh9m6A8yzmbUHtHYa4aaXlJJflntxAwCQ0JhFNWkmFfZsVQwiIprMDNGGuBYzAGPAApMsPX4JiJkqey6eGAOpgQuyRBqIPKs85eXObNZ0naruXDj46U9/+oM/fuOv//W/7hJYJ6mqKgRKKVWRgUCh1+QQyFbncxXKsb5zFc4+ctRvGsPemGGm/cHHkQpWooIZ0UpFOt9zpakBgGIB3gAANPX39ocNzTztHN1wgX14x6CvCBgxjfvui4FanCAbIgsBkrFrlX6e0auCmpZIQyPoE6kBxFCEGFYBqwp9SmWIOx0KhMwIneKk2s3Nm1cv7GmTxDJlqQMQgedaV1UNmDULmLGBGoCSe/dS1xJRrCKJNCdNzqlZdsl0qlTXsxs3X8jN8ujwyfHx6TOXDq5cuFhVlY5ytWS6xxBAa6AMIRhG4wRdR9JE0IiQ4s5V4pQXhw/v0JMH+y88r5MLltGIkAHzQh8/WNx+hE2s9/aOF6dd98zp9cvhdz79/F/7S9c+87n64LKEmBnb1BwHBaZ0IpPLly//5S++9e4de+M/XugePTk9XGZ4sh/25mESkVSYmTqqeGIBTVs1oaqqkQIQ7ccpwy5PVKlFimEywekcZ10MhCaQElpmzIBBMppITqBMhMTROHCMNZG0OWmsKwKBLkvCriKsGWNGxY6IcKTbBDAIQaRhNsCgJioJkAs6g3Sg2TShZkwLTUtEhDgFlI5ypQxdA5VUkd/509vzybWP/O/+wac//4XppcvvPXicDbGqGzQIEBmCMWY5XRxfuDR7obn03s0Xj94/fPT2Tyf1NJV6e24RLiEjrvb4h5yLghGZzAtEsoOnqJnEyCmJZKnrmgi7pp3NZm3bqghaNFdZEJJk4rgzm3/rG994+bc++dnPfh4hBq7bNqlqjOzZYQPzgP5MDXFvg7SBW2bO4XO5YB1XY6xBDd/0pMBFwLXqo7DF7OGpQsZ5P40Qqkvpu9VhJ8LQBwiOCZ33aaRPrvXZNtOVx+H21qvEW7ihpQ3FbLFr6sns2uULr7720fuPHt6/f5hzOwuy7LoQayBeti0zx6pObYOgTNG98ByDqnrJX3TJpY/TBAbJRkiBQ+6Sw0mpqjORMgleaQAhmzjfKGmVkk0YkcAIDB1PFwYRwCBwbYZdq4BcT6okFplVNWepY7U4OQ0hIFKMlWZFokiBKjI1D91YpGVdR9UcI8/CbKgWy8zBE16QkFgQzLGJCcwKNyEoiZlmFohym808kFG8Zp4qhCHNwOUJKoUiZZA2BruNiOac+x28tod8T1dVBVKAbuq6FpH33ntvUk2Wy2VRBEWcuzMT2AouvaxxsUys7ZKNbTT8uW0B8/8TUQihqmpEcREKYIXM4zLH+MnUIw3LRqwTlGJ13Ed+gZkDCTiWcYnlIQYAr7CkBXqs58Tr1j8iKtG8q/AxMcUQqrZt1SyEAKAx8u//we+9/vpHbr38CsfaK1xIlhD7c46FLRfRHj/Q+fC0ZuudXJvPD2ds6Me5fTuYWdmI3mGnFluPdZHIe7JWm8ZGJsvxG+1pdpcNtcbJJcI5YhdASknY0JQBGRDRmDkEakWwWInLDvFArSQZPXQGFQ0MFU2RYG9vrygebcrN0nO+cs7tYgEAs9lcOBBwjPVsNlfVVnIccdOqqgADIAFXCEAiQARI2EpOSZNla6ch7O1dWBw9aY4en5ycTOb1rJ5gNyMMAezRL+/s3ltcjlcPJT6Y7O39tb/w6l/6nee++Of18qUnbfeoOUlLySJTrNKMuiyyzAY0eebSrc/81lu37y+7CzPjycO7s1k9mc1yVkKKFVgjRISRVIPPQCCuOCihISsSMIVYc1UDYhIjBEQ2ADXNYgXv0IBDMCy3qJmqkKGIGYmknHOmzBRcyxc0APSM95WCpaqQBVlMFEW9SCGBi5owdlHAwGAQQpxaZ2BiBFlFW51fuvLqX/zd3Y//2Vb0zt07nWo931NV7bq6riXlIkirhhD29/evX79+79695f2329T18IZdjLVahrXCE2W/Od3QEczosJ9V1Ys4hhCIoIO2t+wSBkZwUBcVEQN0zL4//sY3X7z1QuR6UnNV16nrBlI2PPbcw3BW27heexvM6oIzDvTq3iFmfLilECL5UHFXHyiUDKr8cJA9/t/07GGe95yxHNZ/3vxeYS0s5rwHdl03mUxu3Lh548aNF1988Zc//ZGGmohEBAHrGJ1XhhDUsiGUf+NlKoBlaAAOhK8GIqp9mn5v47BhyKAGNMZNLY2IJCuAMQMCqRoAhsDFnaeoxZwnUHBikoFUHJxhxboK5OV7wKwv0IpFmkPEwUyCuBbJaWbSR4CIKRAWoE0q07q5jv3+33ARhP6P3AvCpj3s/3icxT81sFVYMz8AgOfNU28gCiGa2unxEcwdvYM8bLVfBhsp5AJAiGyEQzwKnGWiHOT34SQPoaxmJpKGtSmFrEZi/vg5YyF3JXysi+3gojQioTtr1U2gRORSW1IholjkCxqHsPTzRuNweu8yIpbSxN4BU1M0K9Klgezt7/z617/8+je+8reuPHvhAiO7KTVHrlPb+SNGJ2olc2ybOj+QEtnITLf9E/SKUUnGOP9h42RY5y8wiA4IZGczexlS8cfbGjdz4f4TWk9NzjgGm92GvrIiFGdkTil3rXSdiWJJnDLw2EBAAwHt8Z5EzHIIVE8mVRXqELniEIK0XcWWczbR46MnJyeL4yfHy+WyWSybxakkSSm1bbtYtpO9UVwwAUQ3HwYzBGYwwooR1HJWFk2nSJPdvYPD2ePjew+Xpwtc1rPAy7atNHf3jo7ebA/k2cMLB8tXXvqtv/H3b/29L+ZJdZ/t5PEJqU1jNWFKgJqVNXQpieGTrp0f7F3//Ofu/vL2vYf3rxoThaqOk535sk1EoCFhNFACDeDYgGpCqAwYKiUEBGaOkzrUlRJ3aqRmwQKBeZoJogKxV9EkNGZDVCA0BMQMaDlTStQlihyFNYtgBjZA2/QaqACASiIOoFk1IgoEclZivbHB02QBqERUZ0JRQ5NgJpZPUuJ5+Mjr95pOEaSOARkILUnFoaZwkpKvdVYxs729veeff/7Jkyf3b//i9u3bsQIEEBHmYjEVBRvV0B4ogJgGDjgiOIogKhFK0biqCk1orPeS5Jx7Im4AAGTMjMT/8Qc//NHLr//OFy8ghXkVDZUogJB9MFrPB7SN2wcFZrQjoVCwkYVgLIms8WY6W/H5TdWhDX5ftIUNyvwbOl69fxvcZNPSs2Xa8SammjNzvHjx4quvvvb+/bt3bt9O7SKEkJOCCoUoIiKpqipHzx6eo24EA0MDotXrXLZARNVM0GN84wpQvAgfap7sZwCIxODUn80SFHNGAdsk4gKTUW6HFbgIUc654oCISbIrYIbgWWBqQ2JO320KQw9tYx4GxQ2LJxqhxEV75TDotd+Bnw6zMbDjMP4DEQYsLOidTG7pGJZkxLA3Vy75WQ0hJ1PJRDidTglDYLeRYW9X0a7roF5REzMDEOiNCmW11isRjBdyLHz08I55WCr3krhkicU20+c094724fmr/WdrjK58NJBBiSlJKGoEZqBJASCDBiIcOeTWNQ8cFAIbQeEODRGJmYiATN0JZDqfz7785S999JOf/cQnP1VxBBV/rIjEGL2ObRkXlHyijdDO7WOz3QYnxTgZYENwsXVj7IDWSwZ6/pEfG11oK5N+ZOABMwNapy+DGLXV1VUnCy5w+Tw83w/JEEtrCAArx9AaBuWoh4hIhJozGhtCuzjtFqft8pRByQDNUA0DMoGZWs6EkVDBgy4oTKb1bDap66gi1SRSDFrFANY0S1U5PDwMPH3y6MnR0WHbNJaFmVMnzbKr2zYv21Wf2gYAlRCg8px8YDYzChXXMwASOxWxMJ3t7h10k3tqOXetiUyfCfd+8c57P767oJvVZz955Ysfe/2v/Lnd53/ruGmaZadI8zglAGnaFoWqyIHULBLXk+o05eM27V6+ePPPfv5PfvHm8e23EgegCFzXk9q0aawhjhAQklDggvxlmAECknpQeAxcRYzRiMTMQNw6CIBoqAgEJsbIpSobYhQwIgZCMBTRlJI1TWTsMSvBRJCqzZ3sWMZaoQqIAAuQoBL2VY0KxdVMAw0Bs65jDgA5Q6rAsOOHLdxnBAMmRocnTilyYMCmaYipmBxEcs6z2ezSpUu3bt26+9Kr9x88bJeLWDEZppQAQATGNGrcihJVdFzPkiRTlb44Q1VVMUYAQI9oyeJxdoaAZIjMxIgoy/YbX/3KKx/96LW6NsKKq0KHt6y/8Ju0gVquNK4RTYCV52JNa4J1mjDiBWdDrX9gBz6g530S3m8kWm0wC3/Q9rs+ELKs3EmBANu2xRhv3bp19dqN51588Rc//WkNQFXIOYPKoJkMRYkRUfuUgp5vDrw146hy9UqVO0vXcoJM5mKH9V2iQeH3hwwKNpRk8pKTbSaTGBapMMecM8FKJTZbeeexd1qsm79GtNjAwJCwACdSr2SvgGfWJ9NrvowDKInYJQAAGFA0fHbcXgQwiCkAfRj2KjLWPfS9xyGEIF03MBKR7Hg/2nthBnfGZoYvoZV04rW0hfFnG/VjmGVvImlg8306E/j8D8MZbhw/ZEPg8HcxgI2+hD6rBXuDisMwhEiIFQAgkAMsj7u93md0nKixtDH84JvAzNqmraqKCJumuXDhwoOH97/xjT967rnnrs3nXTZEHPJcNmam5FKOJICNo0nnH9XtkO9x5zd+GhJwxxYLH6JtyQSjK1dkpST19K/e2AXn0RSFkYxylj/lzA4PRhdbv2z1umHsWa2AxDARtadNahcoHVtGFAaIketpXVUVqknuACOhMUIgjJHrOjIzoFaxosCGiIyxjgCmYN2yUcYnT56cni4IsK6ndYxmllKCbHt/5jtljD//G/lkaVm5nmCVkcnjqrxwMcaKEEIXcqsVV3sXLzW7M9GFiKBRPl3cu3+oF6688g/+yit/8+/wRw90Uj98nCCIEmgWSMDMMKkVbWkyY0idVIEIA1pOJ02a1bc+9tH3v/CFJ6enx5NdQwYgjJQ6Q2BkUgBAMmQKBKgoZmpiRkbEzCFg4H5KiSJSQAjFLpi9FDWIUoWInj2tgKaghIpklrucpMVMEEAVzK3TxG6MHTksJCMHNEEVACUVgIIZBmZgDiQmWAhukT8wCBCYdJYaUkINIGRc7Ve7TdMI5MhsYCJiRBZotc+JskrOeTKZPPvssy+9+vpbb9++/favASyEsFwu63rStskDtgZNbJvbmddYoYKui8zDxdjbYpNkROpxPNSD6BMAGcyn07fefPMHb7xx8MxlosA705wzI44T0HE9YNZG/+39E/85jtcPVWTgzDac+jN+GtlEP5S0NNJM1nny6jkb3wx3wkAlAMDOFjXOI0eIyCGIJBHZ2dl5+dVXHj18/7137y6evF/XNbq/OwSUQqJ72cNQz3DrQDEcj5jFGUNZ/WkwEgPLI4of378gIjCSXHAOx7er5tJ/RpEUKA4oW17Nx3rFi3rYMTNTj9TpS8GtigcgFig+WqPBZbDF8LGaTxrBaEG/yugl1jz4EcAAtOeLZj3oBRHVde2FXpqmGSVZDLNpiAiikVjAcs6IHAKjSW47xOBwih626ZIYc1idCD+JagBIGLJ04y6Od4CLCP79YKgoy7zaLuTpy1VVOS/H3o3koaOuVWxsuGE6sLfGj2Wd1aYEQae9SAXZXA0AMigPuDRnwEgUWF4brZBHYBEgEu7v7x0vTq3oPayquzv7333jO5/+9KcPLl6kUKOpGIQQTNZw34ceykoj2WznHeYhUPTMX8evGLINtx9luEaKBoHY0PO+x9JG7z8Z2VSeErG1Eva3ot6eIkKNhwbniEEbzaHKAYiJwOD09KRrl2yKImw6qcL+hfn+/n41mQQA05wFVEVyhypMEIJvLUWG7EXHEOu6ZqSma1NKR8dPlqcNIgOiiCWTWLFfsOqDAaQOgQipTTnEmqsIyIQGiEYGHl0ChMzT/T2ehJMnywoumMXuUTjU3c/9s3/20mf/6lG1c6QneCT0JLSXcwihjmhJVbIBM9AUWRgAgACTdEQUEaTp6r35i1/49Pff/NWjH16stFFBqyShVWEmSYFEgbAU3xMzMTVGZuYQKcZIfbwveeEDV9MRjciUDNSUBQsQHxqICoBRNjFFRgWznKVDIwRCBagAOHkJtFUlCCoWLCuCBaipDF5aUgHLqIKmCOqOUBDFIKakKtEQMpx2mpRrmi6PTwFgMokUuEtNJwqEsYqSsg4AUIAeG35wcHDl+q3rz714ePh4cXyIoQfmwezChOecaK+uFJXWqRY46lh5phOxRdMgWtd1q03rZGJk+PeI6E411uHbf/zNj37qEy++9CojLHOqq6lp2pShz9Dsn7Lt146V2So47IxmNE772lautl86vuBMXj4++mfKHE8xtW4/7fxGm5etP8Z6E/SQZbPxQDHDbDHGZJZFX3n5I++9c+f5F9/7yQ8fNV2LBqKJDALxsm0IGFQ9usA5qIc9AQDSWKV3E69BCXX37x2ebkNGGdl41Mwsew3nXsd2a4eqIgwQ+wjgGHeqqqYym82bplHLzOw8EYBcHAHrEakGTb6fmGK6WAl0q5l0CWNgDZsG6dEEDgEPbq0AgGCKasUhhFh6724ULBQCEZGIQqhidMF8ZWezPowj50wMZiZmTIGQrM8UckeG6zelZtU6gDxgcVeMub6NdsDwFuuDWAfpabhFVUXM61uVrYVr5qMzd+fwrvFPw9HDvo7McHX/i44F58F075sMEUv84eilXnfD+jb42Kq6Pjg4oBgeP37s35yeNsx8fPrk61/7o2vXb9547rkqTorNinAcTPGUc7ga7G9oa3Vhi0YWhfFy0JbRb22b9twbVl8BDDI6ADgyaenXCKh/w+Vhm44VsfMQzteamen6eAcJcnsWfJeE0ZZLKR0/eZyWi5oMJceAuzuTg/39/YMLMUYmCCCtQO7aZqHtMpmHj5upapM6T06oOEYgRAJDAFwuWzOLsVbVLmULVmGYTGZxnK7GxMQKCp2YNpoFcsAQgDzlRxEtEmtgBaMKMuamawxDl7Hj8MJnvogXrtxRPnl8GIlqwumFIMLQ5qwWQogxmqiJklo3DRwCgHWWiCtGzJKOu+WlW1cu/dYnm69/o3n0NihqNIAQcqWUkJVY/eh6dRI0qDjEiqsQYyDuHcBEhBgAECEQEqExoamAqcPjqJNDVQ/zzKaBvZaTooimTvsywe6FjWOPm2d55UREIFlZ0MSUAcBUwRKqugyMYABIoNkEs2ZEUA5atVkeGRwjWeZqFhAt57w4PUXEECMCdk1yymSlSBObqALEGC9dfvbFl189PTn82Y/+RKQLIZphn36yKsq1oleDtDHy5BJR27Z1XXddB6iWV4UhswmCaV/zuWxnhEbydD6/d+fu9779xsHBpVhPIcQEylucfptZPr2Nz/UZESHjPxEHmeNDCjTnteEtH0C7evI4vn6j59vfr7ctF4GTkPWE+bEYtfHMYX7UlJjNTETne7vPPf/Ck8Ojhw/efff27UDIzJpyjEzA2MNuFiVNDcDzOIwhiIqZ5zauxJGx3AXgQP3Qy6sj8CcDM3Icsd42b25EdPDSwchlJTSixEfMYn3r6rX37t1bLBaESM6ERLWHQwRD27JguccObGTc0n6f+IutFA8bLdmKkw78GkbpHX5MwtBXBO7DQksdpeIBEWmaJqWEo+oqMEIyGJbcB+nBDCkl0DyZ1KBeyz6bmZsfRURF1hBFzEzVFMSMGM8UigeRfDjVw54YctOtt2cwsztZqS/o7L+6LWQsrAw9H24fNqLfuwJaGVl0rCSVQK+tkyMbWg/JCsZuIl0tAKAiuDztAgcREdLJyfGDB6FJXUppOpkvl8s6RjCazWbf+953PvO5zz/77NVJPQMVN8+oriGQDlYEHvkdPkxbCQHrmMGr2enbcPA2TAtma5ksG0x9yCuDway7LiaOb4QtmWPo4Zk06cwg2bULcHXzmebg4UtVZ4Lgu7RpmpxzFSIA15Gn0+l0VocQVLOKIAEiE0MILJFAlEBFTUQs5U5VW0shVMhOv0IIliXnjMSqQBSqqpJsJycn+xcurkZKiCGwIWieEIFmz64k9qMvZkIxslKnqTIQy0nEgLoWTmcdTZ59fDpJYR6m+wptruTR6bszvRRjrdEa6ZJ2oaJgCNlIFFWFshKZG6HITrrlzu7s2kdfjVeuHr//LiqGihPGtHSQPmKOCJmVQAhNgS1Ed6cEZvQEHgIkwBhq39geTqamaCAGZAWSb4NziIiogkv1aApmiECIJmYyFjhEhAmVADSiqkvvYFLiAW3QBIbqTgAmYETIhmytNhmXdSU2I4mneeHkjSsmDGgGahUH1Wy9Bdd3rKTMzJcuX33+uZcWR4/f/MXP2tM2hCDi0e7lxIwVIe19KDBS8gZqGULwOgyD8gcAHHjwr/dTZAWn3YQIvvfdNz71qU9PpjsXrjzbdt28ihsM++ksfPNojEQN2KIbul2Hd/32MRX1No7h+JBCyZkd3siRKZrkSN8YGMF4FNsvPYMS9rM6fLGB1TOWwIbGHMmdgzlTDIvF4sZzt46fHL33zgv37t2rCBF0eXJaVViH6IKjARCijCA91EyzSM5mgiEgmYq4hGEB3ZexGhGCDlBYveDl8gMCBGZVVRPvrIgiAHPsx1VEBGIgDGp4cHBw69at09PTdrEkRPN/Zm5wHIQU6CXjIg2BI5euJsnM1BAInec5wphL0jB6sY0Aq3wmta87CABEFEIERs/TzYEqZFoul4Y4qSdWKpaRqxBuglDNAKuYl4F/qKolxGKhaRmRIgGAWEZFIshZUrtkjpGZxms9cCA2ANU+DmvsuPG81vFeH7RSMxYxRAqhGg62iFRV5RZLj0cpmTKDJ7UPwxwiOcbxqj59UKxAvb3EzYDm8GWO6WV9rwQGRwwBoBqA6VpXRTITE4fxjHW5IwrHx6dEFCmmto0FOR+tw2VKX/3K77/22sshYqimMdQD3PlKVCrZGDaCPR3OmwFAHqWxDQM0M3ILDQDgGqOndUCzfg8AYp/Y3p+BsnZYnoO2FjrUX7ha4vINl9fpYOrw/ve7f/zq4b8IAFacKa4EWF+mde0y5LBOVTyx1rDoNzIEXvVpUu2kwtxUYBzj0f0nzcPjKNDZEprjg73Ls505M6OmiCQKXZJ6QpPJVFNugLmqAEByG0LoVHLXqhoBax1DCLnrlqenFMOVq892Km3bSs7N6elONamVx84oRQBQqoIpGhIRMBhYRgUwL9zUZYhcdQTZupnadK5cKR7Od1u+JBmIhXCpmQEhL2EHL0KF2RIoRCQGg1QmRUGQESAGACdroMgWlsvFs1eu3HrtI996+6fvt/lqg2zdaZXqplamFJCAAxgaUVRGAyJTRKoMokEwqgWQAyToGIiR0Qj7+ApEJrIQSqoLczTErAaADSgAqgK0GbNwVsnWtmk6ixFnmVfiddd10xhIKwI2AINEEEwNhIKbEEDJxJCQIihBTqy6QJuhQGqXYk/yJMO0QlZZBjKQ4k1TKDl4CmJjOBi3RBKKKXG+cGnv+s1bH3ntY9/6+tfraJNJpW0bYuiJrKK7vnqOyMyOMoxEjoUAqnWMqW2DoyB6mA4pImpCZCTiwcRMRAGjRBOC3f3dh4/uf/Vrf/CPblxtF0exmqkgIjCB4+jHGB2zZOzHHJ2/Nf0dttrGiUMA65MmsDelbLPwscI2ZvzbQsCGpoFYwFNW3w+9U9u+i3uasPH90MNx/3G0BOvdLQRm+ILPmqjxoADAQFNOgWLNLJ1MZjEzXr9x7frNF69duX3nzV/XEwozWuTTiBNKZGir5SMSsySZiEQSRzZDlXLIGSBwEANRMVURZeYIZMraV1f39UREYDA0EYWhwL0RArhxkQgAQbIBoGvCklskjYGee+5ZYo0VEptYVtR6EtvURQhgoFhyK1zbU1BULpZ8t4P0Ls0YmcWGgmUu6XseQynpYsbMQAhgKtr7bkbGQrdwNE3j9VpijEQkqgBQVdUGX4eRG3KsuI/tCn7txk8r3xniYCNZ2wpjbRTKRhzLFsNLN7bCEMYxbJTxnvYBE7mPeSPoZLVNN3YqnNE2T9q4J8O9w4cB52N88WBTHeZwkPg2LCjO4EUETKbT+k/+5E/+6Otf/R/9/f9KusRUp5RiPEP3wN43fMYxO4surJOP38AMu/HA8fDhQ+tY23dBP8vjIZSYgad2b5sIrv067gv28DglXqmIOyyGCiFQTk27PCJpWDu2zDFWHAKR653JRFTUlFLyxXJXBQBIyu7pr6oaADxSnZkvXLhw8eLFUE92dneR6WS5OHp8+Oju/fZkcZq7/ZzgX/4L+F/97wEAgc0IzJMTPPA5mxkpIhmYKSAaiogisKW2bTvFpGwYAbkvowzu2XOxbDwzG7Lm9jIhogDNp7s3X3rlmxwwTjCidk1dT6FRT9EkQzBF1cEjhoGHxApyAJwQRD2LDzFwIAa1lJKkbIEhMBpADMYspl3KCpb7ZDRDMDCRLGAkmYMR0TiHysxATSGhsOWkjCgRKRooqCteThA8mSWbmWpmRRAERTFSC4CkhtvmsQ/cuir52WeuPHrw/s3nXrp9+/b7d98TEQRr27ZQzl6rwV6BGas3wzx7TSUz0+Eklrd7Acs86LvmWYuMqmpIIYSf/OQnb7zxxl/9639TNVOc5Jy1pOkF+KCT8j9cG5PQjWZPzV45j+qeuRZPP+nwn0qInvIK64MFYWSLatuWq3jhwoVbLzz/7psvLJ8cLU4fE3FkCkSSC6oKjKfFZSzuDV0IYCY5ZzABYw7OPQvTLHmqJCLEJcLDRi74MzusqqNycmvz8Os3366qu/cfPsqmTLHrkplFrmAdx0X76ECGUbAnjt91RgdgPanCBwDO13AtaHS4JtR1bT0ImogkySklQwz9RhnzfrNV9MXwzfAZ+j6Of8ISFMo0qmTuNVbLZ2AY3XvmqGwdhGP40gPa4aw2Fkdw3fgzCEkb1s7xAoxoxLgbq66Nxz6I7eMbRzNQCNBgaxreMiQeD1cOf4ZAs2ry5OToK1/68p//c1+8eOlKUK3rugT79KPc6PZ4As88cniWprJxwcYD+282p6j/vHb7hzzquKUGbfRqnLYKUPw+ij03Pf8NT0dCG3ySAxMIYmAauT4+fnx69MDSkqVl6OoYYwhDuHGRAok9pWoAqwUAZyHIFKkKXIVQ+Zd1XXMVJ/PZ/sULMJvuqV45ufz+3s7Du/c/+e5/Az8DAIB/+S8AAPH7BgBACAToKhJozkbk0isiMgSBwCCoOaUkYZJ5xmGeMSpSsZCWWVUEtXWj+NPEUEJEXHZ5dxoPrj6bOTSArQBCQARjIjVgQ5d6EJEJAJEphMBVdAsaMmFgCuy4qwCw6FoHANjZ2dmfzyUogReKNlVNbdNJyqaBEPr6vZ6iklUAIEkz7brJZLXbNXdNCxRnHAmEUDJoNo8lBSM0MLWC/WGAapABjDWBRclVl0O2KkNQOhsa5gO2btfE+c6NG7cePHj8+sc/c//+fZHscS1emrHrOvc7DyznzJkf/NTFsksGhk5XrcdhGqQWM2GOCKyq+/v7jx49+uEPv/+Z3/7chYuXcTonBpcxRQV7wLEPebqHIW9//3QSsaHXnfnkMxWSjcduv+Lp32zSB3was/iNpA0bKatn/GRmAOIG8sCqCiKz2ey5l16++87dx/fef/ftBWirkFW1r1G+SULNwekIARyXAwAHlNoSZwwO36BAhIRofdxa4TIlpBKH3o4ZEACMADz9ceg1xe4/euwWlxhr7PNPmQx7kzz0DLHP412BDw3WaOjpPI1CX/17R6AZezzILW+66pvqyhodYoxtbjziIcZYVSV7TdJmFDSUTaPjP4ezoboS7tZGjtwjo/eXASMQQCElViBLwFlabynf3L42Atcbt+GYncn+RaRkx/TeiDF3H+ZoY3/A1q5VVejLHwwD2ejGBuMcd2nsxxr/Ou48jpqZieSc8eozV+7cufOlP/yDv/P3/seIvDO/MOySAbt3GO+HPGa4aQg5465t8WUDOecpD/8wfRhfuf3YscQwOFo2lmlrFOUnRNwGLfU/VzAP/igDcsZEDEjHi9PjJ08gLRmEDGIoEV05d+5wVDCiUE+i9sh4qupxDIiobe+MZ3ZDZ5uTpea0WTap29nZqaeTEOOly5evf+cfboyX/p+fln/wIzNEKgZZk6GyAwEjAqMAEDGbpUbBqp3LMHvGaKoUFdCQnGeTKZY4hrO98Nt8wgWanHNWqWeT6d7O8Wl7cS/M57OmW1hAMDZJZlas7URMzMwcAxIZmGeXAEASqTiqKgXe2d+b70ynO3PPcaMqikhKqety27bNMZgqmQ0YBo55NQD+pmVShZQEoFScadvWzCYUUQOqmDKqAIoaGWR2501f2VHMAMQgB1PT0CZaSp1gAhQNwM7c9E9Vo9HyYnGyt3/hytWbi2V79frNB+/+GhG5ihiYYiBTNBUTUzTEbNmTBNSU+trUCCvtwsxGiVzbRsdynCXnyNy27XQymc/nb7/5q29/8xt/8S/9ZaaqmtREIauKKiLWzAP+2JlDO0/aePrAP2T7kGrG+HVPkRU2+jNQyPM6vP3nB/Zngws8pc9EpKKIWFVVJ0lEJOW9g4vPv/TKvbffOz1+8ujhe2wkmjBENeOBho8em02jFVMHgYNkqIN+jmIQh6HKGH7CzFNeEQABZNg/6ysIZi4uEKKXWFEVAEJVrKqJqrZeP1YgpcRhc+CeGKh9UK0ThpWeqeoANUVd7+8SVRxFIzgbIiSBleWjf4ACQGiahok84qFtW1YxM/FU73OEvvFyDpMyzuZApKIMIaq6d34cTrX9zIEH0KbK3L9lPMs0sr7YqI2vH34disKMh7AhxAywXRsnARF7vr6eVrMl2QzXjx1P4xkb7Gwbx8ZGpo6NyTSzlNL+zs5XvvSlT3/6s69+5KMpL4Ecq22zeP1TTiN8OHKwPcBhDscj3Xj4+Mv1eTv7DJ/3/Zn9t3WDEHjVlfWnrR3Lc6wgfpZsfJfDh3hyF3ESXSwWabmIoH2wMKFBzh0RiKac1BCY0SyMZwYAXOCgRKmThNmoCxY8U1JVLaUlmuZu0kzquqazOR1AqSNUiSqooAqqESkYl9qkuQNiQGgXS4VQ71/X6UHCIIgAZECrDMB1BKEzyfraBBogYkWsOV26cuna87ce3fvZi8/diMFyarRi0Q4A1DKqoQFz4BgNTREEDAiJiYjUTHOONdSTyc7efGd/bzafx0nNkRGRqfL93KYunC5SzimriEBOZprMHVUKhAAKCIicVPJiMQgcJ8dP5vM5ESETE1tiYEE0NFVEAFP1ghOgXlZHFNWAOQuf5rDUqqOgxFi0o7PX4bzm+Ydt27788suHjx++/rGPf+fwwfL4MNSsKimVWR2iQftaYGvNBbty2MlknOXe1x7qreKu4WCWHIiZuWnbEMKjx4ff/953futTn2CKsWIxd7ZUboHTc4q6rS33b+5r2HjCxocP5NkfpjMf5vazxZQzck/885lVxzZ7uyHinEmFiEjMsilhofApJcJ447lbz3/k1cPH7z969H5gtJwxYE42FvbdkwI4yNX9W8paA6xwJaHvQNFbxtxB+y6p6bZWb2baw2a5Jm8uzgIAoikgUs5JVUNVUmp1DB1t5DYXQsh9sCMijnmxwSoBEbbWjvqErI2pHpjawFMIEXd3d69du/bMM8/Ude3X9QEZKxvA6MwwIpvhxr+xUcVsTYVwVq6a3TNtZroeIEzm/85w95Xr180Jw3gG1+l4LcdMfYPxey2YoY3v2qYO/YsIzqiPsgld51rvYEcZvx3XLSIb5B56d+9GHC5QAMCu6Xbm86PDx//hP/xBlmQm/m/8CoDVeRs6P5oTAiDXTNc/n93OPPnjL3G9bc/zeQ/Z6OH2bJdH2erKtQnpX6QI43/i3vv+n5nJOS8B3XwXAGAARTg+Ol0en7CmaBIIlRDRxCSllFKyLGaGRozUdV3XdTbKSiiKe1YBCyFUVRVCKODdTIhsApasa9Lp8WL6+3/1zGnh/9dvmWaQrlR1IWAwFAPJINlMDJMgAPHpyZJ5znvP6HQ/ISqgmpfQFDNRBDDSdZCD7TncXi9EbNLyyo1nX/3EJ1qMFHfazgyYAhKR54SAE1AiYgZCGbyW/aIYQoxxvrOzt7cXq6pJ7enyNKvU0wnHUE3qemc2292Z7e9O5zMiyjkLWDZ1T4qOFw5AVTtZuVQePXh4eHi4ODntmlZSZ5JKeJ4TSw7IgSggVYQRjMiADUxCI3FhscFKemZMvznTVUQKsWvbnfn06tWr16/dvPn8i60VrSClbigHYevh7WubrfeuhkCOFzCmDway4h/93EYOKaUQooiC4Xw+e/Lo0Q+/9z2VxAC5Sy7BqKoKVCGC0dP/maL/Q2AEPvMC+KAk9A0i9pTzfu7t6515eoe9Pxubdv2JwwW2+ubDvWL86/aHwWWgqm3XDVVh83J5sHfw/EsvX7nx3GR3l6nywAufCi02NkAsxj8ejl2pUK9eQggAhnzjMSPoTSSrWsS+2bfJ5gZBXi2HkSmioYpINsIQe/TetTgEIwJgLFkn/tndoniO53FYbh2VFqHRBUNXt+8NJycnmsXMcvboDfBFWxnc17XVDSlm1AmyHpZgmD4zAzCHke+xxqHHyFnb0yWe1AhQNl4xftEmV17vyZlfbnR7kFHGbxmLLMPFA3XY3OVGGxMy7udYoBvz43EECW45XDdeYWapy2jCzN2ymc2nP/jed95445uf/fxvT2cXNnq4XYp9+0/cMjmM/vxQxOLMPXDeS8+lC1uejtEPZ/9aMlPG5orzH25m7vga7Bybd43wBqjnlZbT4cP7zeGjieYJCINlMUMWkTZ1gTAQMDATR2Kz5Mesx9TXlNJyuUxZmON0Ot3bu4DsYR/JzCQpADhehKje/cL/++q3//52z/Xv/bEBqQh5kXYDNCmlhWMgBCOPJwvdsgtxZtVeChPtPR3Qu70AVBFsZCncOE3jPTnMGnhF3Sz1lD75+d9+51c/PRGslAJVAZInBBEzmTIyMgGhAw0BoefBq5kCxBBUdbFYGNsO7M5259P5rJpEAA3TmpkZKKpSFbuUDo+PdHlSCkKA20TBQz6LILGuYx0ePgLQaT2b5uzfO4IQESMFADV05C0DIFA0AVBddLok6mjSYRAEBGEDMjRandPxTjlvdxmEnHMdwvL46PqVZ548fPbFl1+7/e6d0yd3hvgw6x2j28dhdNi1hyMZOKipmpg5arQvEgCYJwlnSElQEyISpCpUqeu+8fWv33zuxU98akrVxCtikkEpG2y61ffVuM4jOKthfpDocCaxfYoocCbXOfObp8kTH2SjtRIJUa58+ijO/NXOsv3YKm6UkMnUDI1dKMgKKs9cu3rrI6/cu/vOr3/2Y+tagoIAu8GhShCDgYeqk+cx+vNBERkK8NgwhM2UCG+IDCtXxRnHeX0mycyCAXINBoEKxC0iEgUY4Nj71yBwX5SgvH0NzRZw3JlhS6+ZW0bxFuexoXDhwoVmsXzy5In/UFWVO3tgxNLGNGtYzu2hbgtc3vU+cUPMtjxDW+u98fDhFaorU9J4OQcT4sD1/UMf7b+SJAYmYT1o6SC+jOWPbd6/1j3FAUtjPMyNWdq+YLxIgzA7SILj+PZ+BhgN6jrkrp1NJkr4lS//h9dff30y3R9eZ7ZyA9O567I2vRvj8o8bU/2Uedj4vEFex8LNeQRie2X9gw4C6einDwQVPXNcVnwoa8MbVJ9e8Ci/GHSS5eTwMJ+c7JhEFQNLKYtNsgpmAUbGyISMxEgUK7eTjVew6zrkCgCIKFZVVQd1pV1VFZZNg35D4DPjkAAATRFIQKGcWTVRAyVFMAMCJMkCZtZ1CahKENAQA1gusen9qFwaxiHtdo3yrQdwlbUr90YFfHh08vLrH3/pY5+894sfHMymZgDW+vVExIyM5QSFwEQ8NvMAMRF1XSeWjQ2JMFCsQ41VjJHqCpkJAAxDFVNK88Od09NTabpyEj2B2UrlIxtgsPrmNZJg0AUxQA9sCkwwRL0AqJiKQRIQWXbQRcqRjYOhgQoaEET5TXM6KEjOVQg5dZPJ5Pnnn3/48OGtF1/50Ru3Pe7NfRoDeRkTYhu1nEtdp6QCfQiaqiKGImas72dVretaUmLmnDWlZT2pHjx48M2vf+369ZvXbz3fCjAgVTWYppSAnuZSgfUjcx5vNntKWHa54Cl/fpiG63raf077z3/CU1ogdihJYkIiNTG1nPMsxial3Qv7t1586fG9u+/8+pcdLEOMTWrGs4p9ECZacbQU2BpgchebOUI/gNNAW8skWE9r8M9nkNCBx21QZn9ojFGySRYMXMoEmdK2awmccPT2ttLpNbvAmPPCiOBD3//ht3GqzvCBiEJKyf06Tno8ejSMQkHHYgQRERSY6hEPNjNzImJW8vq8AG6McW/vwsnJ0XK5jBVXdaUCqsYYXFIDAMZoVkovEoNJee+YVfupc/s29uilPviUkkOn+0/D92NDgv9a17WqmgmiEZV1HVLXNgQCK242SF03yDR+vdN3siIJDnZRn6vBBDcmPY5FNg4l2QjvGosavlTBIJst2y6GSQZql+2f/vBPfvT97/25371iQHEy9VgYRlNpqeCFI6zZ0ldPhjOOJY1n2DcMIqon+MMoJ8ghYtbxwVadtw0Fbm0vbo9ufCTW/lTsURZXMq4hSPFwrj2qH50hQa82QEH58Pg8BDErmGaeXmtMRCpiICEEFQHgyWTS0eT+mz9Nj94L7RGgKoUs7c40oqmJUogIaIpxUlVVlQ1Ai3ksJ1UEEWkyJgu5aXzhqqqa1JdiHZOgAiyXiasaRM2QjZj43p/5/z77rb87nqvTv/zvVGZExAgAnRohMMcqp8ZyAxhUUA12duZw8uSnv/r5cbh69YUdBppaVqpUFc0NhMoBETTnTFiNFmP1EQGglzH6WUMAiByXzYKCKeUv/O4X/6hbNo/fQ5zb4lGwqqKagqotMrQVT9EogVYBOs7MEQARc0VsooqdKWLK0YAmU1JDA4oB67mlJCFQYBGZ7F2Y7z0J9x8qQe4WZkJoWTMFxMiCWhm3qRlLnLuz3Yv7F2fzeahqiBOraotTwAqhAiPDlkOADrM2NkVubXHUnjI9mVxSnIhyABezUAAyDOCKiIgwOim+l2Gkyfl1AcQARRSQFl1bzafXn3vhhcfHj965/eDxewpJQYir3Ekg84SDQYVwTythcGxG8zqOwFZc78TEYgpGpYRn4TQEAJHZehgxRSCmLBpi9aMf/fhzn/31bL63u39BJTHHbEJVQFk7fcMHt/nhcILMbCsiCkbaQkk+8gNWjluhzMM+WrtxHccI+6fplrFnxVy33jvcaCOjpvdQR59Xdw3InohQqmMGf8i2FDJmZMOXw1sGM7HP8zCADADIxfQGMmyRVEJs9MqlK9dfePHWa6/99LtvNKdPquluk5oQUUAddE66hgMAFGVDwCRJ0QoQAYNrSGYGJbdbULEOJGYqaqaIFBkBUMFMUEYkdFCVTSTG2OVsCEyUJHsQCDAnySqCZpgL0yFE539qHgtPZpY0E9Jw4qjg9ZfGTKlLiOgmiR4IoII+1BW2hOUNZuEzHzZY+4b8sr1xBUbeB9+aYAarMAsbafbWQ3SEEEqkFK3luQCASPLODMPY3h+uQMCWSwWx4JyMnUk2yv4YYkIdOkxEhjrysJ46uzlHvYw/FGfSUabJMGmDVAF9KMbYuLrawX0w13Cx9XYOj2kdXj0QOzRgZlNR1ZwVAHLOf/iHf/jyRz5549ZzZkJGbU6KNq0nmjvdIgEbDc/XZs6cge3bN34t32yZGdYkhhHt3hCHNwWULSuajZ52Vm9XdqO1X0dizfgnUlETQkebVZOEwCD5+PGDxdFjTcsAwug5QCnnFOf7Yta0KQayaEEyQwyB206SZAQmyiLWes5F26aUqhirSkUkqxCEUE1CCF13NLheXfS89IVvA3wXAOBf/ouHv/OvmBEgqiqZAAbJSYEIUXMHOSGbSiJgmFbSnNy/e+fffelrk2uf/OLrf2HOMcznOW9a4Ig5BFoHpH2K3FmaiNSTScrtsun29i/81mc+/6s//e6Th+9xtQeahVqDZGwEtSAx96Gy5eGGiCIZAAIX/Yyb5mRxGhYTntaVTnG5oGkdYhAzjiHu7+0dXAjzadaltSDqgaJIwCaqWdrsNZ9Xvd3f359Op7WHyACoQyHGSpEQyJDNiNComEmsU2q4UooCpNBXjEBPXYTtaRho2vakQYkGLcWuiamO8eLFC9evX7///AuPj95fNqcxkOQUY2zbzIFx9FhPUETEca7g+P2r5Russ4SmICIBAgxYHQDEZE5zUvuNb3zj1gsvhlDN9mLXdcTctdknZ3jaat3PXPWttqEPbHwJ59OHzeN8Ptcf6MOZ7zqvnRlU8rT6L/9DNzJVgZyrwDeuXnv1ldce3XnvrV/9vEaMFYtkRFS1nHMIwTy1RDdpoKoHMUMviY0lCRdM1T0ViNxHJWzaqPy/xNzlHOuqaZqssr+/f3R0NKlqZ1JEhCPCqKq0RbELAx0lPTDSYBe4cePGL58cPX78uG3bQX9umibGCHYGeRkv7ljIW6Vlbkgb57XhsvF/YQQA4hcMov1yuXQMLu1zUze218Ctx68YXjQw5jFTtxHgmL+lgJ0VdFAdHjs8ivr6t8ONg0Ry3qiHt2+cvcEJshHFoz16OtEZZqjhvUNk0FjIG7t+tJjjxeNp/GlEVM+mP/jRn/zR1768XBwTgVoOpd4xnmOn32zjsSDyONPVzMaxpeM5KVFXW22Yh+2fhvkZBjUe+DD8cdtY+uGhG9O4/efG7t24bDVqE0YLRO4AiBxiIOna43v3lo8eWtsgiGhnmjggoDWdLhdt07Si4EWVEUvIAjFTYOSQVZZts2iaNiUiQiJRWDbdyfGiaToz4xjm8/l0Oo2Tuq7ryWQym82Gjj34nX8zjEUkSc6gGQ0YkNmRrDJYlnapkpMKY/72N7/1kzfvfP2Pv/ezH36Pcz5deOWw0CvEqKo5rQxpG4u+vS3HfyKiIS6aLgO/+tFPXH/pI1LNgS9BnCnnTC0QAgchgGiOaO73+nICgEhOWbJoFu1SOm2Wx6enbZty0pRb0OwRDBQC7M73nr1y6dZNrAJVNcc6VrMYJkSMRiQIZpHGjBsODg6m02mMcdg7wAwxQAjKrMACCKBug80CSw0tz4WCYBBg6dGiwWOC1zfexrRs7zQz64sVqEgigr3dnevXrz730isHzzwrYpGYTUAzIgIGD9lTgeHsOGUaKM/46Kmq17pVM0CiwExhg5Zar7wNqsuP/vSH3/3uGwCampaZVb0o5tOajT7YOgE/95YPuuDcDfb0254iu6z/6UYINMI+zFNh9Q97G93Gv/PamcRqPEZ9ys2j5lVINXXR8OozVz760Y+/8MpH4u6eiJCBiJAbYLJUoSYM4/Q0j8pkR6PaolplWhysAwmGBDQr6QsD8YTR7W72aNs2VHEymZyenjJzkuwYQrbF/sfJFuM+jEn0eLxHR0eLxWIce8DMVVUVB6gT+bPmc7T51acFNrqyzpZw/Cucs02xt+3gunVdVZfLZUpiBpItdZJSFjEZ5VnQVpLP0NFBGqDzMW0GwcJ6NwqOohn8fJqZA3I4RtO4/2NWd+bzh8navsafaWaO/IOjnLdhaMPK+cL7OsUYh5BDGnmvNqZ0nFOjADs7O9Pp9Ktf/fIvf/lzNMldG0OIXHVd1i3BcbTwdM6/0sfxSLeHf6YPb72VNKVxFowZ6noc7nbbJjerPTZ6nR+MjbNx3hPOW0Ezc+lNgZou55yrqiLAJ48fnt6/l54cRkkRRLMYSCAOISwX7WnTLpZt0zRdTmKaJLdt23Rtm7okuUtpsWxPTk5PFoumyxQCx8gczKDLqW3bpunaJlEp4R6Ayczi67/vvXrygz8fggsKbGY5Z8mdajITAwFH3jDV3KWuIZVJiO/+7Off+vq3qN59cPjka1/59w/uvb3oSkBAWaq+dKSbN87kBONTPHxARGTquo6ZEfnJ0UnG+Ozzr8wvXlU8yFhDRGIhAoLg6tawM8eyIwCIqYIhkyFm0bbt2rZNKZGZdMnarq9rJdVseuvlF5+9fm3v4kGczczTTDB4VKpbJcf9d43ZyQG6x5PIUwAMVZEEDFABjcBMWXAm9YUEUZHHUCUb+2TrvJzd0ONP3Dqr2qWGmS9fOnj2xs0XX/rIbLoLaoEgdS0RqfH6K4rCuvHS8XII2CqsZC2kdNPA4K2qomr++te/9v79eyrJz8hYmtlog6ncRudrG5R2o21P1NqcjDaYpylt3n7+M8+WUUYOoK3fvELB6l8pt7p+4/DhPEHkfDp5znvPaQrCjKgKOdUUrly58txLLz978wVFygoBKVJJ9VRV0MLIPRlkeAgiopZ/ZDT+N6KoPrDywRXasb7qS09EoYrIpKoYuEldPZtuUM5h5t3ggWaek0Ju0Tej9V03Xu6HDx+cnp46niEAeLKeczQbyyvjoa3LEt5+g/TI7eV5yudxp3twJBLRlFLOWWUTRqKs4si5sNHGZ28YiT+8qiqP28KRBsBc1B3V7P/NufMso2EU2KvdZiZmQy7TmaMedwyLostDFOrw5cY6bYtQw5XQu2aGtwxWEOyNOkSUUpKe7+7v7z96/P43v/5HTw4fo5lI8icwx6cfpPPWy6dhvF7rG2Dl3sKzmo/wzH+ey+DZoa69ialYSR72Nu7nBy76mT99mC+haACYlEQBkJFjSunw0YN33n67OzysRPam9XwyrTggsCrkNg0brOs6lyN7BGsPBc0pt8vladM07i8rwU9VjDGGEBFRRNqmcS+h35tGfo4ibRTC0WONqKCJ5gSS0BQtaS74e839R//m//Pfvf3O+0nj/sGFn/3yT7/9x39kkFzkHbaWk7UNvPwP07C3zTIzET9+crKzf3DjpY9AvZ+wRpoQBjQwyaaK5hFvCH3/3VqMHimKwZCVOJt2OTXLtmlaVTVVUCU1zTkvlgq2c2H/1Y++/vyrr1y+dm26uwshAjEgIyKqScqa9L/7F3e9h9f+zp2u68RZPhMRgSloRlMCCNaHGJccu2BcS5xloGwMxGOioVv8abxVzps0p96FYmQh0N3d3WevXX3uhZdu3XqxbcXMQiARQZcZCFeA1mY25vojelKOkhERee7MYLJFZOezwyHKKklyVjGz6XR6786dL3/5P+TctYtTIury2dDDawdhqDi57Qc5/88PuZEUz53Ajaed9+eZ9tLtCN81U836PzXTPlty/OVY0tpuLvCNm0/4edc7EgSCak5Z0nQ6vXnrhRdfeW0231EFisE1zTpExwyEgdP3Xvgy5D4v141hqz/HFvT+zzNXxAYjh0hd1znn4+Pj6XTqAkEIYai2MR6dM69tY7OO2wi9Avu4yTGPVkfZWqfSbr8ZXlRu75laMJOVzLi2Udbs7WfypFVv1gWZMQ8enjaKVbKx0cuTTIkpYEgpIazuXW04kZ5QOF3D/iEIzBTJyEBBQQHBwNQ0cAAzrmJz2tV1DaYCtuzaigOsiw5lgL0lzmUOXr8A1pkf9k4vn/ShpA1tTTT03NrLSw5+pXG0x5lHdODHneRJrIjIqzbMJ9Pvfu+NT3/6s5/7/J8BUQGrqpA1EZ4dnf50StEvKwGsRc76kq1dea7wf4atCAA2CpnAask3r99s6w52N1CNO7y1tdaHsyVDmxkAIpEfv+l0qml59PDB/XffPn1073KUnZ2dZ3YnOS2PjyGJNs2ibbPSgsEwEFGsQpzWk2k9ySqACYDAcLFoVCTnxBwCrqRPVdWcjZlCSb4fEqZmH/sP3qXuJ38laQImggCrVHsRNUYmQMsNEphZVumyHB7d/4Mvfelbf/LLJzJvkajiZPrd73/n9U/99q0XXwrTAIruNt6elvGZh9EGHk+j9cHXKbeEYXd39+TkpLJw87kXH7393uPbh5qOmDtILaAnYVaKZA7JA+R0h72UbqwMwMCyKWbFNp0sm/p0yUzzXWKKqklzVmIKqKD1wf6t2eTys1ce3r1/9513Tw4PpW1yzpIzqKGul1SkIIZGiJ6fotla8KJnYFLM6yXKEQ0tE4EMtyuNCM/2uSgTUoS/tR0JAG7+BgBEAlCRDBYqgitXLj++eu3VVz9++603NS+n07h8fBRCJcOhNjMTM/NkSKS1rK5hvYg8MTiYZO3Tc0wRRzqMqqZUzBjLLHvzHQD4/ne++/nPf+Hlj7wOYLEK0OtyZx4Q7YmwrqeAbczG0//cnLENF/lWRvr4+uHiIprA2iaE9XvHZQoGclI8LD0dWUV9rg8X10uwrr5f/wbP2Q8fkKVTXNIgpg76EGN85uqzr7zykbs/+/np8lRk6YFNFFmyEjIOwfWqMDqStnUky0+j3o7Kx6NJz316WarUHTRDwHbZXL9+/fDwUES6rhu8BwNdGGuz0Lsm4CyT2xmcehSAOORtOLscl/MtF6yzg4H0hPFF43nf3q7DBU9XRseMB4eUOQAwQmDATdtGXdfUZehLwsIoynqQuQBgED/WO4kApioA1nvns79XRKbT6f7+/mKx8AgXZ/lmQ/T4+gLzGmkbYFvonHMFI3vMoDmNg15hJKiZH3FgBDQFWSHIkugan9h4V5fzCoTNQESqGA8fPf7KV75y4/pzN26+4HV3RYSeijAIWydq/H0vc4zVI9y45imP3ZiZ8RoNkzP8ep6cUV6xLm3YKIZm+zyMn9T3cFvSLSc5oDAbk2JeNkePH999pzt8cFDB1Qs7F3en+7O4OOV6wga0XC7bZnF8emJmVQg78+l0WrtBIgDMpnXgiigQ4mFgAtQsGdvZfL+qYhUCYg/iSxxCcNSFDaSpTrJvCEBUQUMlMEGTTiMHCjGlDCini9Pj4yfvPzj8wZ/+5N98+Y9O4dIRTYBp2TyJ893b79594ytf2ju4EDnEWCMAmIKRavbKyxvzsLGIGwvh/gjVjAhodSBu23Y6n117/eXj4zt5cUjUAHeRwYwEAhMaECADEQIQMBAhMwU2D3WjAISd5MViEULIuROB6Uy4quvpJIBJUlMRFq4n89nObLoznU6fPHjw+P79B7mBhhSUmceJFCFUyIwUXNrQrjVInuUBoMBk6kUr3I+pqh1ABPTcNAT0mhEEiPShbT9l9tTJtFslCYCcpk+n8erVq8uTV19++2Nv/vInWZsYOIhoQDN1wA1E5KIwZVQeCNmYjpkZG4GpWoEzQiUzhVH4GgC4T4eZQdATYU4Xx9/61rcuXLp08AzPqj0923bcbwAsrPQDXQdPV1TOuHJ1SLFkxJQNtkaxbd34vf3l0DXv5yBz6BZET/90XP+iNF0BmpSBe+Nzhz4iOx/CsYKGTpw4hGyChgd7+y889/zd1z92sjy5996vkS0yA1k9iVkESm1BAwAYUiMBkAb5wyehXEN4Figxoo2CF2FkJKuYDTG1zf7unpm99957s9nMREs65Iigj+d/2xNH69lGo0ZA5iXjRdW0WF0K1/ZiCqMn01Ygo384N8joPFVpyBeFYaO4CX393oHuhxByzirlKlNSy2IIdWGQk8kM03HO2RXBbetIP4DVHi1L0mesjG0Gfk0IoWmag4MLBwcX7t+/532MMRRbRhHx1jc9kRmgWql+DmWjW+/4WJNOsFg+zayqqslkgoht2y6XS3dxjQfis59SGkfiDGMceOqw6mVhQnCb2GRSm2nOOcRS9mk22/n+d777mU9//plnr8ZqYiYhkOmHJRAba3qupWG9Pf2ybd16m9X5f3l9Boam3pONL3EIzd6WIQZr2egtW2s0fJbcVlVllhfHx4fv3108vldZ98z+7sFBdXFvNgkogrGeT2d7oCY5nzbLdtmY5hBoWtV1iHWIwEGyzGazqp5G4qMnJ22bUhIEEsmBeDKZVDHGGKsqcEBCQy55eoN5Y/Hjv+RBgtTnGRp4RKOoZoEu1tMuJ9V8eHh4//79n/7sV//63/zeYvfyO6eqcR7zgjgQTQ6PDn/y/e9/4r/4nelkvr9fDZneapsz/4HLBwDMLCKBmIEWJ8ehrhwa+Nnnr7/50/3TODOqjYkioARkLsnGDi5AAYmYIzM7cWAijiGEmFW7rjs9PXUTbdfmvb29ST0BNjYFwEZTc9qxhSrUz1y/dvniwVuo7z+4U84CkqQVC1VVcFedmWVRPz0GxowGFlkxIBlBX0LLBDEAIJTtYtDjLMEWVT1Tbh4IuoiEEBFBFYmgClEVTFElXbp06ejRyWsf/eS9u7ffv/twdzJLrXCI5lFyiMhIBqors+X2i0BVymAMABx9AM3EVE0RMfRuMmKOVTWtQrNYAAAa/OwnP37hxZc+OZsDUR3qM9f3Qx5z2DqYH/bXD/388XPGZPADrh8sGesXDn+dSco2vrSyB864/TduDnSJiMy5azXLznz3ysVLr7320ffv33l4/10mQWZVCzE0uWNj0QJFTbCi9gOT3ui2mhY8grJhFIpIsqmdehORpmkms9kvf/lLAOiadjaZytjc1RvJdJSXOjTsbfbuGi4X0OoajmQqSTIRcWDntrlbAaEOz1RVE82j4AHsQxfAE71olPcxOJmGErJE5DWHCDmEkKTpi7GxjuKoK8IkCQAwogGYIgOagdfD5SqKZMnGiMw8reqheNvR0REgElHTNCISsARgqioCi4unSAgk2lkxTK0SaBE9BwmIyItzm2qXW67g8dGDR4cPJ3VNBtIlMJhwpQqMAQ1BZRA+oAA0AiiAaVlUUxXBkQNsmNyS7GTmYsHe3t7e3t7du3fdhQbDEeqjcEyJmX1OERGpoK8CGOMqXXbYBEVF9vS/3AEAI1o2AwMiROGgX/3Kv/34J185uHSNYRYmM7W2bB1gKAD9BOCAFDZ4f3x9PRwV1o86YkkXdBULRgY1M8umg3KwEgoBiu64ig0vA1NC1E1zFyKiSg/yuNroqooMQ5G/Ye+iGVPQ9WQic5+u6PhKM0NcBW+Dg04Co6feiLYY62qyfPL47ju30+Gjg4ouTOJuvXxm96DiACo79dxM6grDZIIc5qexbat2sRSRQECoZF1EyyGqgiSdzebXr17JXXN0eBgCVXVFaEwa61BVMcbIoSIORqhrdQsKBEugaGaibZZGcgdQVPBTgAt6GkwfLvXeg3tPnjy4fef9Rbx5mKbToFkfASEAa9MezOv7hw+//K/+9T/8x/9kZzLlepY9bCAEyR1xHBOU8wj6sECkCogAIQNQFdVMiZsOJtO9l1//zDffehtCNe1CDZZMhYw8abOKzKRoLl6oqgFRZGJWoGTAdY1Ey6QpH2cRDmFi86ZtODMzkwZetESWrZFJC8y5WyJot2wAhdAC01gl7QQqmiTBKhuSMqioAqEaQkiaY8AKQ7DAGdGUgsVsXrodAECM+jKZjqiwNgkbNLd3jxbAU0Y0FfQKmgXhBZA0L4XrcPHqlYuPbr7w+ufu3nvUJplWfJxbxhAwmqHbxBWykREUsJYuZz+YrmuxmYrYkJ1ohggYgqmhoWmp+7BYtLPZ7Or1qw/u31fVQExE79+/+8PvvvGJj39MA9n+FBE1paqqunYpIrv7e6cny8CMHiXaGwy8nAyNjuFgIDQbCNS5baxQAfRFewe7Jq0hFOAWW/VlVVqVWiQD6OsGr4AtYdMaM0ge5b1rjHOlyI8fADh4FgB0TQTh/lEbHuPVNUNyU9/tfp8AqAWM0kkwNrDcLnZn8eqNF1//6Kfe+uUvHtx56+Di3mmzQCaiKCmpasE1B2NEQqQROuXw3pWQsSabElrvHjBH6VpzOCAzhZDa1jMS9nZ2u64DZyJaLBDDXKGB9LhzLkwPK+VMZ5tcSJJxwIeZiSkyZVAmQkDQPowM0M/ZOGBlwJ0q6BTQCyPDy5CJuSSvm48QJJdCcUhEQMRQaoiYmSPcmZfWdb8OGKgjmRiqeuCMFYiFkWiWpeuROUIIIKOpLOYmBICh0ICztxWbGXkuEEpFVzUjYBUAU6Y4qydE3DVtSglxFWYxZJGYGagggIG5+FmCGtal4+FPRPSICkdBefz48fHx8XK5dAiybVUJceytKErMsBhjejfM/1jBGjdVndZV17VvvfXWN77xjb/9d/5BSgmwRcgFig6yx/E7kNc2ZuBY3tzoJ5yDEAcAAdZmg9Z72w9hhfqKahtPKLJLT8hoZFckD9TwA+aWxj76zDD30kdZcVUFM7fmDTt2iN4VTURESKqatAMjJkKivTg9evTg8M570C32Z3EKUIc8n9chsJmZKiLGWPlxNbCqiqqiMQMAloQvNEOi4H3gqtrb23vmmWcCUc55vjOvZ9PJZOK1VLBPa0RkGrntT//0i2biJjfLOac2pxZEiEFyl3OO87mYnjTNo8PTnNLp0cn7Dx8nQMnqCSBOtsggcAiRFouTO3fuTHf3L1/dlZQ58vLkpKrDeHU2FuLMNra9WeG0fr5kPp/uXti37pEtuO1aAIhIiCXu1QiduBcgYSYk8mrxHnTgm7ZiYk5N06Wm7UIoAWsp5a4DpqSSLc8mE8l5sVhIzjvVVCUV/NFhiyKAGoiq59eREyKXTQkQUHsLAVHJYi37cPNIMo5MxzYyv6t4trmKWtG40MyAzo5MYEYGnM8m165de++dS1evXn1073YS9XwlFQEgZgZRNIu0Cu6GdW/s8AHWT1+MMaXklXKn02lVVU3TvPPOO/3pgJRSl9Ov3nrzm9/+1u/+7u82TTOfzyzw6enpbD5hVQdO2O588QjDqgPDS12pe8pugfWtZbZpXRh+3f4w/nNlouytk7o+AwP1oq0VxP6+9W5t/H/1lw2sZN0561cwoPZc3AMryq0jlWZ8/crFg31QqqKCXL58+caNG88999zy+PFy0YgI5Kyydgxx4GGjhw/P9zbEfa/+OyrLMIhBiKiu+PmJ6D37TiWA+lRHAwCQITYRgYEHycbZgeda+k7bXq/tLwgQ+gCj7dUfXzuIFgAQiGgymbhcP2jnIqLqGZ6buqP0T6cycHHPaO4xbUR9FsxLbCOQZyioKhAAkNhaWqxHr4Mn/CDrUOyuz3X2CCftS9wAFdLvHg9Wg1J0UYH7lFQzJpJsOYumrNH6YRc2ICKGK9OWqroY6MSTi3oNRKzrPsiBLji1dcEtpdQ0jX8YgHeGZds4z6sl6W1cfUzJalVxZHjYaEPwY0rp+9/57sc+/lvPv/QaBzQplhhVRc1QYFtARoxkHHSyTQiw9xMNX9oWWYFBbhgNBXrNwmmyv0hHRjbsDXpmReD0X4Z9OezIjVkak+CxZAl9Wc7Bg9jvJXVlxjyaCZEJwNRA26NF+/B9bo/2apyHyrpcV6GeTVPbSe4sp1hxrGfMHoFogSAQdGSA6hXEEhAYck3Qq8LVbHr58uUQOLUdc6gmtUsbHCpm12HQgBC1evXfeg9FiiHKNWaVpCmp5WBoIGbCSZ+k0+n+7sU4S027XIhVU5uzPEmGgIRkhch68svp4viPvv7lC5cvT3Z2Q6xz2zGHupoOhGM8k0+ROYo7cvQNOzPStq4ih2qhMK3mrAg5Y1aMIVQunAExO94WhUjM7vWg3jhqZqaWVMwaoid+aqbTmqvoWXaKallzziY5Ne3Jk6NSfcl1m1GNSgxsqpIyAFAMGAMFdiKLwGRoosiKpgAKiBtZBsMuGm/4YW8PB9Y3latSQ9HO82KmSU0kV5GvX3v23s2bj1999U+OHuf2tDxeBUARSSy7iOwKho488ePDuMEFAcBD/8bwhgDQNM1q8xNWVfXgwf1vfvPrn/jEJy7E+WRS13XddZ0YqmHOeTKZrKzrTugG9yNusxaAM/jNag6HCzbUkrNFig/ylWwUayxQciv4jeG6s3u1pgXZcCEojIJZbHjqGRRmfLv1ZZZ1FSYwYG0DmkFf0GwskJgN1JV293duPvfcxz71W0fHj9/65c8QAwjiKDFqPIHbW9FG7Yy5GrGVklDZBwlZj3ANagI9aHNfW8ecxvZ4qjRasmEdC1scd2BF7/0u1/xXTIoBRWXNltST+nFXx0MI2SROqhhjOs5t0zkfLTbgUo3XAJSIAN303ftfYMWZXAkwQgMx9btUzYUgtGyDzchILYOIQOgrNxJTnwwlItwbbQRKMpRvA0TCYnBZIxODPcrM2MDr3wKAZAMA5gCAKaWu67JkQCIKKlLisjzm3vdKUE9K6w0ea3xu/EZ/foxRVd3O4eQgxrhRLdYN+0V16jkmAIyjkjZEjQ2usMEzAICIui5FDrPd2cOHD7/+tT+69dyLuWOkmokHwK1IpIgA6kE3hKQlzwv9mzG281o3tKw8jDab9RGa6+ZLX/pVufZib9ByOocnEyCUckRKjCu5pw9Q8kM7PL6/EQD6yvLqewCpwCysytavnIDDZ7VkhkgVM6FJanPX5vfvVnkxr2BGVmHGmmMspde6rgPJxDWAKRqbAoJI8uLGoAXvssOsCJGoqqdE5BjwFMP+/r6Z5WVHdeS6CrHCEAkZEUFAZeUpO/zub2vufI2yIQKgqmnOqYVAIYRJHUmFq+ne1WuXkO6+dfvnv3j77uPm0TKhBUBkQPNUezVVTSIPDx/96u23PvGpT1+9fo3r2qtXN01bfAHbho0NY1vfZKSEDRIwImruQiDmoBapmnOXKTIREwdmLoQtMBKbIRJBLJZOJDJfei3RKqAm4mD/EGOs68jMFKJPiEhKXffk8eHRkydVqETU+9qrEP8Y8P9hQCAZmJ1goKgxYfETMLvakItlAs7Kcl/trrO+9D56eQUvP6yiYMTMnky0LbFZT4Nm0/rmtWtHL7549847795+G3IXQgAGEQFU8upcWny4gyyuI4DmYTmGQwEAXddVVeVh7wPqT1VVbZsAIKuGEGIIXc7vvffed77zx7/7Vy4uTgBxdzabLdvGpVIdpd+vpAR/19ZmeIpUujFv2F+PiKJn76vtVvqAbn4ffe9hnn1p9yHsdMisOfNpHnKHfdIN9veuCYjo9ggC15DPagTFyLp6OwAASO/nHewH3hlz/bfHkO2nFxaLk2pSv/jSK3fevf3uu+92zbLrciTu7YVlLLqujm5MPvbI2jBajp4El/+uDPUI6qBgRAToE+IQhQAFP2aQFZycCgBuZTx4raJ1ZgejBcfxpi2OsJGPBhDVjKFkcQ+1WoYx+o0hpeSAHl50e3CvIHOf+OCh3YqACorUx1shAhjqmtIvBlnFY6ERkUOAgtOz4iWCWQ1799nISOVInZEBQGBANBqiVJ2sbGKDuo0BEWGUoeDG2qqqQuA4qZkZu05LIRU0UEBFBBsoElpAshW+9mh/b50+/8mxGYjIaYGIuHarumaKHBbpzGYjMwCcdajGG7FMiOoQHts26Qc/+MFnPvf5V179SJjWyARIGVlnPgABAABJREFUggKAxgzMAJC6FhEJSFWTJFQMEM7sUjkza3V0Rx2gXgJb10h6Xa04I6FIVWXtyp9l/VQ0gwzLtJKsVXWsf4zngQnHZ813gPWJSGbmbizvRgjBDMQIzNDARERba5fSns4wEwlKR6kLMcxmMwqYcqqIgQlCqKrI7E5CBEJQQwNGUOZB71DVnKCuikjt31GMkdhijbGCagLuTzFAUbOE2eJHf2+YMdWsIiJJxBgJTRAtoOPwCBkD2cGz1+N8l7u2bdLP33733SZ09c7EK7Kqp377mTdJyoRm9tWvfvWFl16+co2n0zki5Sw4oghjbWYjXXmYaqIV4RvCysxMJE0m08l0vqwq7DiJTYtZAo1IzQwtECKTAQETsEcOlaZDEiAhBfYI67qumTmpJJUKymYGxcXxyf379w8PDydVTRyBo5n8zf/tfwP/wqfvH18DOP7jXxNBiA5WZCZDUVk1VcxgqGCMBkYFxlxVvdKujSLwR3Rjg8WWcHJHJGnbFkCn08jnmTg4AqJ0HYZw6dKlq9dv3Hrh5Xv3Hy6bNgRw4jCWj5E8nMtoS78cb/7h85BOT6Pak256AdCsQohtziGEnLqvfOnLH3ntYzduPQ8Au/sHZhZjRMRmsYwxbnR8/Lp1NvNUceGcC8aizMYQznlpH1fRP3ZFdHqN3HoHByLmc+QhK4o4jN9jvRWw3GI9nz5rvIWJ9iU5/avhJ1cYqO/S2ih0Ta3yW7v2lJmfvX79xVde/8Wv3rz/3u2T46OKC7nYDlId66i4ZXj2b3RkOSjzTO6UXYWqlFGUuIUSWmBmm5ahgaSv2+xhRYc3hzlM6uDfRE+W6XVpB755yrYZyxwh1tXpcgEAMcZQRRFJ4vDvXuDAozcAXLJgcOMiEbnFXnMfbRo41oGMrOvEo6TIKLBTBKRRxrSOEHAARtYmICIvnOOkHADdF0uMYAY6MrD3Ys/YIiAed2EMoH6qHd+TmYEJA5mq9JgwPCI3RISoMrhmAN1hRsCeQ789idL7z7wUigIkJ2FnGK6HJJc188z2oj5d8vCH5JxjjJI0pSRJ7t997/d//9+98spLJgkYAUC6lE0VIYCZmVuMhgwgXA/g2D5+g2tjTDUQUa3EmVpvbHRVub/XMf9hG5kU3CXWByb7cjCzR/YMlw1RtBv9ESm2EHBInz4RCclMRVREkZmR3P5uXQchMCNa10m7hO4k5OVUur2oyTKC1THUsaongQgoZVILzO7ABPZXy6AFITKRQVAvr2imAFTilsiwlE4FAeN6irGCWEOIvVjWgRFgGm0EMVWRVIDP1Lx6Y6xrNccTS7ODGU8nzDXI8sHhoyNlnu8FZc9f2Kj5Z4QqdvHixR/96Iff/OY3/8bf/FtEtH9wURc6MNQxQbGtdLXxSg12/tU9ABCiKKSuIUBGiIxIZH3kRFkjBWCiwD2OGTAzh+CV9BhWpywEErAmZYGlX0m70frY7dOT5dHjo5zUImbEQPy3/jf/9UY/d3/7xeUP33W1QRUxg6kpAkEWBRQDJBCXX8kw9CD5MMzAMNjNkfoSmeEgclGpwyaquG6QHz4MOc+qOt/bvXL1+guvvPart9997/S4yzpkrQOzo0AGNCJQNWJQNVN1VHKVs8/+EMQ6xhg0M0SyXppqmmZS1bPJ5L133v7ud964cuXKdD5LKSGQZAXzVxReMmI9Z7e+A2f/biNGtcEdx3xleyDjL1fkZWxiGU3sWK32aP5VcMbG/GDhuUYrI4eVqjXFdzDG5uktKCOBoySLFYQ9KBoOOk8eohrHQ0MDgFBMBlZEc99KVQyIVO8f3HzhpRdffW2xWCwXp2doocOHc2Zs7ZwWkgcAHhWJqP2hHlw/hgUMAwHdcu92CBvs6ivBixGpF4UHOcOKxXoF3bFl0LYhNHhY8T4fbG11EFGGsKT+cYAIZoGZ3VIHo8xSVSUm7RHe/C7Pu+u0AcewwQCKCuLdZs8uMW1zayLZ1OvyFnGk5yOlVu96DqebubDgLo5oADqQF3q6KqAhGdqKWbrm4iSCDBj6YtkKVdU7Yk0UFBnDpEJE7SRnV3kGUkhEgEgi4kiCg+Ynq8Xyrbma1iHvw+M2PHoUEQOGlRHAd8jaWBU2d7+NqTz0mUtDidptFaGEWWRjZuvse99548c//tFnP/NnKiZEtmCsVgUKVcF0d9u9gahlQkIKxGtAXmtCT3G1GPQp7t4vVRooQrmaEQDIhiSrFUIR9cHnJmZeM5HRSeRi0bho6zUmxpHMQ0/K+XKruCYmJgYRaXNyeSWEUFM9eMRd+YMSwyGAAgaaW22PYzqZYjcJytoBpaqO9aQKRkQUybji1EqMTIFCJN9ynmEejLwgsD8fB6RKIFXN0oERsgESADJFxYAcMUYI0QDIAUBV4+v/3mfr4bc+k1ISzZpLfpYPmQMrgGQRM2auL+5ZrIHqw4ePfvarX5+oZqyak2OuJg58MewGASOz5XKJHKoQvv/d73zmM5+58fzzKbWddJGq0XzCaH+tteErAU/+7i+2fjdSaNp0fHwcNbHlEJiQMlgkVjNgQkIRQdZAdZmSwFVVVXUdQsAeEI+ocPGc83K5TBI9SK3LCdRUIbXdkyfHyzZNp3MkNiCMZ0PLaH8q0YDAzL9AQWNQM3V0dxYl15hgoOxEA5LiSBjbIJdIxH7mmEMIUURzFgjBrxhuwcFrI0LE2SwiHVx85trNxcuvfuzk/feOj4+zuD0yoWIIoaAc+tL3tM6pLo1YmjMXKrkApeaf57OAa4YhSCdJlYnMNBCDaIg4n86+/8d//Morr3zqM58HSrGqU0rkOOgpj6nJqharjbfBubbYoUkP1TU2KEDPeMe884zdNppnVfPN7B3wmIlVjknvTLHRLU95YHnm+AIjcMHBeoxIxB7dcNXVYSkFwe2yOLIr+HMQEfpzUd4EwH0wFQKCARkWJ6ZqZ1BTuHBw6aVXXr/77ruHD+61p8fkMBCDgrdlYtkYC0GZDefcVuSfXiCgUobXhQIiAivun6LaiSgYEhXJq8RI4Bi8HEaiw3lzutoSZRLKWm93uGzslS16FQc9fkVYNEs3u2WRJJmZvX40B1YpqqSamYkqhTL5ogpiAoqSi7tMe3nKP3sR1JAzZBWV/sXgiomNgqaRwPKK6Q44V4gIYKKKZGShn6gSIAaFXg8ClwIABQZC1aK+hBCQaTKbhhDEMgMRkQADQEppCGzUgg5ecHXMHI0boBeWV9tiYIcAJZmNeSj3am7A1CIgm5t514NGsTgaVjtsHMg52F03dIVxc2UFEZeL5Xxvd3d39907d/7Vv/pXVy5emk6nyLHrsiFMZ/NQV2YGGP35HtnKzNPpNISwEQU3dM80D3tIYSUJiftc16ktAMRSuqsIDR45hSN4TTMv0GqqKl06WZxyDByDZBvmUBEIdJhhl60RARElEzqmjYgHQnIMsa60Sx5+2KOVTMysaRqqWE1ym6Bbcm5qTDNOU1QhVVFDUgNBiEREplmmVQ0MzESxKD9iWVQCBCjOYLcJFcaZU29+FHEPTwwV1xXQlGO0aqqEICrWqYr1sgUAtG2rmj0A1bmvr2OSLCmn1MYYp9OpBppO55Dk7Tdvv3f/XiY6adppmOSsBIhIjKRgjgwvILu7+6fLxc7Ozq9+9auvf/1r//DWzcXiZPfCgXabvmFfpq7rziTcvQJdArMGCzNpAFVQC4yybFJuoK44TKEPXDWETgVUAhYeGQBDCJ7v469mopwbJxGWQME4J78mi6hqTqlr2sPDw5TSbLajIkr4N/7X/9PtfgLA/FM37ReP/Hgi+TYTBIfR99wYFQFVzGLsaRgewEuEA8/l4iNcM7YjqloIRQ0AJooBcspWSI2fX+ylcABA4ywdeURX19XTyXS+e+X6jYOLl5qmUc0xBshuhCEMYJacPGLg1aEzt0+vLNvUx/+7VG1mKSWPFh8og6aMFYNajLFdLAlwb2f27jtvf/eN79y4+fylK3E2m7sFxbK4tcmGkW41Z7VnTvhaWyNlZz/tzOfbOos1MzXjXoD24IOxeKFj60dJ6F2JCEPLuhbrMMQWOHiJK6rkZExtbEDtBQ4Y/XfgO6A9HeYRgrONUv5KKJm5W8H7Xgy8mrLWuLN/4fnnn//l9esP7t1+2CzQAdwG6Pf1Ghcbg0JEk01gJb+GY7CRTcLMjBAQguOtQZFfPV4vICJ5mqgLMUPnIeVkI0V36MDIEtYbTPyWUYIPADCO4qtG63smbbFRMmbgyjwxBJjAQECsYN0tAoPb6xCxqiomqgKdNA1hYCZTUBAMVsYf2YKCCWVDVYMW1LIgGcXAAOpWj0hchzg21khWwiAqojnGGCswU0lKBkDBKZoBJkh1FcnAvDZKNs0aQpDOTWGkAJKyV+umwKfdoq7rKlQebBFC1TZdmzuwnCRlECBQIBMJSgCkmlXNYYLQjIouoivSMphnEBGpjpWpzOYTZDw+PhaQelKZ6bSKDkfo4cGEvQwBvkDsWo6qIhmzioCiAkOsmQglKapVIRJz0zSI5jINUYgxSjbN2TFIJvOZmzquXn7m7V/86r/9v/yfL1+5lEVOlifz+TyE4AVLiUKsqhijOXS2WSCuuKqqKqmwh3ASOivy7RFjxMCqqp6z7lUKSZiZnEwiOowmUVi2JyJShXqwxYmkEELTNR5LO5lMmHnZtT51i5xm9YSZqxgBQDoFQhGrC0UAJBM3jKFhYE0ymUyyqaoul8vpZO6Mytgm1XR5uqhCCFwpQps6jiG0MmW5NA83r1w8ONirmMCyEkHWyAxmKClOInFWxBAnDuKADOgSUs6oGCHkHiYhetGE4BmYRhiRERgYgAAYAlENEHTKFAISsKlJpylhSvVHS6m2O195TbWVnHPOSBYQqNGFdBYxAmLOy9PT/RvXD65eoryLugDrvvODP3nrXpPibuogEmvOQETAamgGhMEtZSeL49lsJpLriD/+4XcvX9r73Oc/kxYPmlJEmofoMicrrcvSiIgM6uleiIihA2VcSouBJqHSpGQc64pSq0+O5qdP6PSJ5sYChEA1QmPKHAzBgKqKQ4yoYogKJGApJUSrqqqQRAqIVDxQis47c5caWE52Jp75+fDh49PTZQiVgBADMf/+/+n//lf/l/9km34tf/SexolvWvX6ocFaoNq6tFgE2sO6SvZwCXKAB0vJZmYgSohMApCtS5pxQXVdc4iSRRWYmSGYWcZWQUW6tm1V6xAJKZ8uFvu7V5CspN6g01AxEwWcTKYpiRkHqjTB9Wev//Jnv3zmxqX3HryTW5W2C0QARgxqOYkYIfAKgKDQYkMTUDVCdkQTyUpEklKh7NRb13KuAglrNa81S9cZg06ncwA4Pj3d2dn59je/9md++zM7U4YZzqvJol0CgPDMeoOiuMSDGEJoQBjQS7U4mlnb5hiji9kiopZDCEQ9WkM9z7nz3C9VDSEwgyMCuP5GiIRouiaUgOthg/3GoJrVTdN0Ii6YuvueiJiCq3DMERGzChiFEAiyqqI6XAS6wD3EtQCU+DxEdBAGpJIqLyLZ494AVHUSCcz6PFWyvhAr9WmoujorQFYQqBHREFSLbsnMpsVL5VRONLlmpRYJ2xAppXTjxq1Pf/Z37t4/vH+Uw/JeIHK5GMycO8QYyAq0RGH7g8GJqZg0egYkpmYmDnZlHmrgfUcAyJ0xM2CmAJKSaZ5OpirglrnctaLKHNUMRLgKmInK20bBKwCBq+IyBsmlgBwAgJpmXcnEgEU/LHgqfQ6CDnJJ7z3HdbuX16tEVRApQA7Q269yFgCdTieqmnNSVTNhit7HPp3EUkqajQKaiXOXhw8fqioTS1JgQ/DgOEQiYII1FH+IMeSmA9SqqlSFOeZs2VRQAiEFLG4qZhEpQOAmXuHJ6+IgAPRQB4SEBKLKgJYlW9dIkdqypJQT9oXlzYxAC9UCIXK8LDHrkULQ7Tljg0TRkRBhsVhUdajruqqqrusWJ6c5ZyLOvXRZfAoDOtzKB4y+YGYgokABoc80JsJAGRAVc+5iZJea67p23w3CWjGnQag0hJ+9+av3HtwXy21u67pWsHbZAFAkL3fNnjOMgtLXrXXBJUtBdMk5C1hAIiIlld7s5B328ngAYLmkTpFH7aE5CKMDv5iZmlRVpVzi3XzPpVTKoYXZJBIvl8vUdqqKyHU9AaOIxUJifaiHoRKRKVbTidM+r/LqbMYTg/f29ibV5PDwsM/rTrf2D/7s5z75kc9+8pm9Wc1omjR1C2nd5wUgxGyCQNFtrZ7WgT3qmZhJymbmQfLeeSICJiKP/Y5AYGRoBoLIhEzgziwAH4Stg9gCQNc1bbcEIxERbZmRkqlpztKJTpB3dnbqyQwpyG4MBj///k//48/ePO7A6shZsOkwIhTnI7qehAZgVFWT5bIF0MlkcnR0/Pv/9t9961vfms/nIjoE62gfZ42I1mUK3CdKMCISIANCiBQpmZhZ5MBKqpDVgjx88dLlvdzsYQoMIQQlbnLGMCrTgIgO2aTlPymlUkCkhBBhjFGLi1OdzCMTI6lqu2xOT5fL5TKbEhVLDIeSC7rdNIuQYAFiREMD1Nx0NeScM1yu4pQe/vLe9777H5+En1Kcmlku/MVBerKITOohVQQBAMsCg/n+V0XT3vTbiUhdV+PknYE5KBgzd1kRyUXwqgpp+fbD+/dy2wTCEvOYc9uAM28nR3Vdm9lyufRZEhAXZTwxxtC8vr1PkfXRpp5lkLMaqqfaMnPBNgLlGIhI2vyvf+9f/92/+3cXzXLvwkGz7Oq6Nns8ZMdoD8qUAJDi6eKkritmXDRJVbOiKhCox/YCQEJfRyCixemhc33oBY4QAogsm5NhP4zLQXQ509o+KVtCF9R1nVqWGIeAVkRshlrqRj1Vp8YsRjRVlR6OAZGZjYmAAVE125BnYOQyrvz/2PqzX8m2Lb0PG92cc3URsbvsTp7mtnXNqmLJoiiRlCFbgCBT1D9gww+G/SLDtvyXCHrwiwX4QW4eaNKASZdkWxQFsRFJ0VUsUcUqktXd6m5zzj15MnN3EbHWmnOOMfwwI3ZmUd5IHCR2HuzcsXPFnKP5vt+HH2btp9KE+XBc8DSzFDwXRgAwaz4/X38i/N2rIiIxfDyydaKnKsFOCUoVAAxxLR4T7R8eY0pmdH01fPHFi9/+7X/8ofY6DzZOL/NPgtH8LJ6wJ1HLkxT0NCcgPN9I2CTgaobQgHKqShWZue+DSJjLqmUlovaUtge7uqs2jpyfnv2PPhz0JF0A4n9RRvLh90084mcUAjzdbh9KzA8fT58AAAnxfHObmxWiAO0cRnRyd++6ZFY9ewgh58wiTUfqhAwMoG1LkrVY9mm36fp0f3eL5kSopcYYT456Oo0j8U8OXvphCOoSKMZw/3ALlEiQ2UtRAxQhYXZEr6BqFCiytPLIwGpVQCGkdllRi1tEdDcmcYdazWxpGlKAiqhtTwQNHYLIJAjgUCqoo5+4kN66bQMAIHm6PJ6OGwBor2ueZ9UK9gE8VU3ttPLzp+cXANqD24ouJG/HMxEBgwF9cHszoJO5UmBmbvTVrmNAyjkTQVOlnspJPy0dHTH0fSVEDF0KFMhrDZ4QEUtxcicnBmlhYcyeLaXUCo72Xwpy2hBjcPc2UYDzytDMpDHNHFRrA5+0914z3TGztz8CALSUkgeMIZwijM2ZT5d362hjonUVrQ5AUZK7E5srgJprWzdUIkIGQ0opEdGyLF0fY0ohcq21zisnjl0w0G5KgfDh3eGyj//Wv/6v/NKf+v4XL64sH+8flhA4MYFbzdndkdTVwZnPpbsQe8st8FaoeztlnAgdmqMYn1JCEBEFEdHM1RDBUUwIBIkDEQGexblET+qNt//wF9+++9m8f4yxM7Pj/GCmumSOAQDIIY7jtHsWhg67buHc7/V3f/P3fvTl7X1RBQ8Vo6QjzAAIcE7iOO/idTUzkxhaBfb+/e379+/buujcS5zKuKbLEGhjDyp24t6Sg3mlmD6cemqgUNTM7Nofxh9878Xnr0lX82ISHNncw9Nx8iHzFk4FqJl6VadWF4YQkCjE6AhmpuAAJsTMjACMeFyPh8Ohsf+ZuS1uk4R/49/L8L/+q+D/k48PxNtf/T0Pya2eWHTcTk0fQdaHhwVU7XhD4+/+xm/+8l/56990F6bg7tqqfMczIxSY88eddFvVt2ugVckxnd74gZCIzAsAqJ5YBS2vBQAqVT8h1omInKDv+2U5uo95XaKENmpvX5ZE7CyNcmyCk7agOfnlvO3szZoNAYn0iajbdiJ26sDbUs4RRRCRqiqgMTMQxj798Ie/99f/+l/bbndqAECqOiZ+ei8jYmN4qGrX9aVkFjQzYAqSlmU9HpbhjLBrxyDieaWIIMQhBHJQ9falDOhpwHA69M43zhMpp5UabepGRNXtSdH/dHi6N0/ieQbcan0nVY1DxBPWxBGRhNuL5dMSpZ1XrZohRBSOfgZLtNVwexRVT1fvU/nY3rC56JlJeK6MDA08nvSLT4vj88uk0xdv3//5m0dgctdSskgIcXq4f/zJH//u2GFe0M4lRYvRhpNF/E9scOjp7yJ8Wtm0mqP9Im1SDELAk4H0pEgIjohMzSIbYiBiYHfVk/agwbHcAaAaCP13ao2PPuhUBn30KTM8fwLPMhQ8UTPoafl+kuW4nzFlf4KXSgDCrfFFMVM0JDI3bE2ahKBWgZwIh5SGYbi9vTVAr+qn4tNO4gkC82xupc4VuWgupaAQMkqUduJBY19Ae7N9qJ2W5YBkx+N8OGrfJ3UNMUYNS57VDVgkIRAuD4UDbadNjPH4uG+m4RMjlqG5IAG9/RxbSJG5ns/cyuISCJCKNm0suDqgA4MhgFbghk88rQHtLEqIpw1ru9qRkFohEVNXSjkej8ejG3hjDJ9FDK3IQMMPu/PSRFtPMLOTwsnb3rs9wdCMD25aXchDZJa+lOL25OLzdmARN/zUOQ4e0AFrrRxYRNyNiCAGNDdzYUYmB6huhMiBSOK6FncncHMjB1E4H83FPzIsEJ0Qa7aeQ+ZOa0sgYjNVbahZcvfmEnIDMnVjdFCDUs1bz4YA4IfDYRxHIEp9b2brWtQrkVRts6V2dHhDkqOBI5oCEahZG3u2xjfbPEybu8cHB7ja7srhUbz+2V/8l//09791NaZ8fFyXo7szxLW6m4bARCR4juRxb9NYOgPs2jsTzamNEc6zzVYrEwlJAOIzCRUQDMhBBCSYSGiJYu6tTIGPsvRqXvb3dw+Pd9O4ZaTj/lDq4rXgAYT5Ync1juO02RmxAk5D/IN/8pv/9Ld/7+Ao/dhjmvOyL0dKTaLwFN99vuANmAMRlaItsPDEXaCPtDgf6YTW4pQEmQT8fHq6uydJVmpEbrOiUkooFkN4gfzJs+sYwNfcxPEOegYBtnuQqF0Y5+YMzvdrmwEwM6CRsIigNCFzMTOrqqrJOS9rXtb2L4INPo7wb/x7544T/+qv/d82f/Z/+u/+/t/4lb7vLfWtMmY2ZrZWDgId7m9zLdbLJnC+f/iHv/Jr3+zvS4pqTUMH7Rwkh3btWQmgDGZa22F5qhQN51JKDAEwlrKqqggTkUgys5K1lGZSlfOFcHK9mjWman2UY0pJYU/o6KrFAAAJHZCZ1XIbcqzr0m4CZjZTAoOGSUVHIndj5hilaW7aYF+LqWnb04MTgPFTMgOquyG0zBfZ7Kbf++HvBEm1qnBUVcFKH0VY4Pl8Y/TvfOc7wPDTr36iqgg8zyXGqOVDkdrKhVa8Fq2BJcYoKLVaMW0HZj2HUD59fSQnwHNklTYs7NNlTx/eiB+0IO5uaGhnViYi0YkmrOCh6XX0g/Shuklj4Z0btnMZcXqlRBRCAP4QgFfLSQzatgatECECCf2p0NEGLzrJzsKpzLP2AD2d55z4aev6gQraiP9WzKpwF2JvBu/fvxchMTnVGeeReZvMK9Q2zWqPUoN7EBG2/e/5DEGrbdMPFQHxbPM8i4tbUYtAxIBezUAruSGRUHszmjnAmQnupyLnTwZ7neZK50wM/JMimo8+3E5zQXcAgg94vTZTcHW3Zm5tJ1bLjWp1h5SyigigSTjRvb0tZlAB2Sw7tAZPmAnA0dQB3NXctJ0rUAFNUhSh/fxQlpI1V6zsNA4TBvfiftJjmhsCGH4U9PCtb3/rd998Xe6Wvu8Ph0NCQQEUN6zEEjsOiZayViiBUkgUIy1Lu6UNyIVbi2+OTqDQcEwIRQtAa1/Awaq7IDuZEaMDUlO9uDkSAZwUCWQGampakYiMHdq4opmwT0Ld9m3P84FjYGbVAmbIDOimlY0BABCAkE/OG0JEi+dUPVRVbVwTAmJEQEA2JGJBZDQkNFjmmQM1qNTd7YNVk8TublUREeiMckEABG+uzXYS6WmdSd6UrYGYHUHd3Jz5pGd2ICRkEWxvbJF2AtViruZtqIZYEZARCLnlcrWy7vTeMDMMJG5QEVpEORJUq7ZWcmQCdXKjNvwDZzNDwmrgbm0ZYeBI2HXxccmtlVJDr00wUwHAGEg4UGQOiKzquaiqha5HElNg5vlwDEV/6fs/+B/9+T//7GYb0MtyOB6P5lijdUG6IDnPMUZA8cavUAIEJ3H1dgroSXxsZuZqzkhEp0YqMLIABRCGU6rWyaSDzBgTJmmPeFt0gTu9/mvtOXn8x//K/nDnoO7GBMLCALlqrVmz9jFtxnG721EKJoFI4P39r/+3v/HVw14uLuqX7/N8VxDrJnR62tSYmwMQ+EmcG6SUYqCtDpvzWt1EBJpa7vSaHPyJp+ctmKOeG0oAcLeis2crLK32NfRaFq9lenYxbnb74/spUhd7ZnatHAjaNuFcx/z/OZVOHeBKRDnnVCvHEEMwdyD3XLKplqJ5nec512IO7brSVi5/ZOZy93/2y38b0uDuTVImIkmYY5CY2qWbpg5CX+qSKPzGf/2rv/ZbvxtevDiui0FyOGkmUEnBgZiEUGOK7O6lVvfTLVLdgIFJKbAztzQnRcyqU+jADNGQqgC3Is8M+AwianekgtaaSZLpyoymtWpGZIldm2GISGuI4aMfnbszUvt5BWYiVlVB6mM6Ib9M7cxaPN3NTTZ4XpC3zp4ZgXhdl+ByeX1xPCxX28t1zV23abcjIjLgU1/EzHk9pr7nQMNmqupEwjHH0Hk1M23fbeuh22tsqjKhwBzcveRatCKyUhO6mtXWUkMjULeJqeKJg0l0AvWueT7NDOwjEiAyM54MBycoTrP+kVZsI7FTt0Ck5qxK6eQKdDjVKK1sAXckRGbpUivBm1GgGxI0yUWuqopEyBWJ1FYiMoWcq6q2DYUpaDydCqoKfqZ5AkhJehoetG3L2aNXlBPP8yGlsn98E0P3S7/0Sz/68R8e9kugQHSCCSA6ERCfXLXgTgDN2AmE7VR8MsoANF0rosJpFQKI5i2GgykAmp6a0jb5gBPRnJAQa230KTfXUyoJQDXDc4lB59HLqck8CcbxT7BM8CPLUJNOAcCTiea0BTuVpwYKRGiO6MAnQisyuLuUugKaCDEDopsBmDETM9a6mFf3gEilrI+PpZRVKILbSb5hVr0oKDCYVeZQa1Eow6ZjRisWBlYzA3X0NoiwBlSiD/3fT9/86GE5ViyHrGnqgLxaKVZQvBtDNwXzWpYFwBTKcT2WulYtwK0eVUd1APPsqHraBTESkhugsThKG/WLIxqooSGQnSyGTU5BGIA7IUAramutpkKIhHxS4344GvBMODF0QkdwZIgxxBhrrVb0ZFx0QENmPkFZT9J2P/HZwU5bEcJihagB4MApSAiOlo24xHlZiDmE4GgcAMBLzkjETCynwruxHJveqi1c7CmVx8mtOsN5vIAsyEy11mxZkIkZGVrxgOfVKTEoOCqBY1sL+SnuyBAFEEzNTqx+ckciVGixFUyCzGhqgGcdRv1AMTmBTs28Bf+c5u3ITLEXqYDOjlgN1c2t1XkaAotQe39WK+jMKogc+ljUU+q05MPt/Z/7pZ//t//8X7hI8e3XPxv7yCeWGJmjqi5aWdxBWzyyKZiCopvVttiipk1uvZhqqYUdQgChQDEAkxMbEhiByIm6A4ROzgSNK8oM1jQhgB+dFEQUY9xdXnZdGvuxZH0kLqUcj3Mf02acpu0WY1jVNtsBu/7L3/ydf/Crv/7Pvnrn042jSUcFPHvpJbqZ19Y6tNO09SNmaIjs5ACE6gZmDcDYQs5PpNTTZL4LEQDAkJy03TxV3V37iIgOVK1yFCK3xxyAnz97Ng3dw35B7pwaOcWjcGmwQUQntAYGtAau8PPC99xOrysgEh9aSUfMDs7MMcbq8Phw1yIoW11eTRHwL/37H6qN//r/2hGzA6lbUWvLcqkZYwqEJCwYULiiPix526eHH/7+X/vrv3xHkrYX8O6tnkHEBGwEqtYm2agzUDCE4lndGBgB1VSdERmcq7ohAxCYlarH9Z5IzE2bkY2UnJrSyxG0nuDLIuKmuS5+8veZkwN6iIzFkLytMhGxKWqPx+P5bmgRHoCMdCIeIyJ0XZrXRUs9iXLwJGZqx9FplE+GAF0X+75vwo55ni8uLhz0uBzMIO9LTL2ZE6EjGmBRaxhoDPEPfvITiVzdmDnFzo2Px9kUiEi6iCJ5qbVq8xSjAxRFqyKFOaylFK3M5nha55+GAYxgZG7Z1M5LGQSndqKgIYmflgPeGnwCZhZ1VQdAQgnooLaaGjA4IugHpkoLhnRkQILzsOREqnR0MOaTN9AYjRGa0qVWb9ojYzBGQkA3IgNIgZiCsdkp5gIFyRE9ARGRg6o2B1/7BoIEIjmPc84rRUPTwk6dDIKy3aSuG9pmqtZKwoTc1AiARC0DBMHMmpWknbjaxE+ggGfKB6I1Vc/ZRexu/jRlJCISh1prbdwlRkF6iiY2s7Nq5KQXb02LnVRQ5G7U9Gfg5K6GZ3azfVxw+JO8s5V3eEJZnd1whHjCWDgiPo1i4TwnaT5eQQZk4MBEUGu1YgDAFFjUAUBJtQk7YFkWVQ9YAZ2YQxB3AjIo7T1tAEaCkYOISMR1Lc5e5tJ0ecSOZubVgYE+TDgOx4el5hADAC154S55VQPthq6fOmIopQAbR5TAarXmtb2KNv5WslZ2ABgBqBcmZ4kSSNVRABs0jAEFEdBrNkNkZyczc3JnliAsTQICa66kTgIEqg2m9lEP94SLC0nUtZSCgiLSdBIhiZWngh2Amjr6SbLnxNB0bmh4dj9VQNbTYkyJkamVSf3hcLh9uI9RYoxMXEpx8iTSdnyqrUS1hg1oMxLDCk07zAQAHMQ8IwUSdlBAdAJgA1ZEQCJgsyazkNjOHwoGK1QtCILIiOaETq5Q4YRAMUdHdCQgpFJmM0MURyAkFOET4gXR26xA8aMo+VKW5MFcATBFTiSgajCHSGDugK7gJ8wxuXvqgUNVU2AryyIcVTmlpAIiWNXzw/zy+uJf+9N/+vXzq8d332y2QyTUurgrtQffGhVTqMkvEJ8WyW5NGYxPHmE/U3GbQM3QGA0oOKGTIDHGaMRGiMinS5zIG1EYAdwJ7Akfvv7W/yCvKwludxsbeiJej7kbh7HkruuutheXu10aRoiCQTClw9dv/pO/8Xf++Y+/PmJPs2XzVVeReBOmigUUwNBdTylAROTcELcooKpVq8jJqs3izaMHZ6ny6eRqXaMjB2EKtVZnQsS1VDQHYidUtGU9BMufvfzk+58+77loNIGqWtRDSh0ynfvVdhqfeiNs47qTqu10GKlqKWWe53a2SggxidBpbV+0OgKde0QC+nf+tx/mJb/6l7cNu/I080CipmOoUJt12RCYECL2lKDo/+tv/+f/5W/848Pu88P92oFkV28Ry0Rg8ORWZ7TiBRwcDVENjJBIwCswAbohYGBW1WoeWFxXZhBhMK+1giOhIDILaPVsCwdxBxIQRDMFFHdzNBZ085Y5g4BNNfXfnXAU97Y3qY0ugmhgh7xEC63j/6DNO1WyLU/bCcHVALzvuufPrh8O+6blXNe16/vDsg7DtK4ZGIjbRMGAvFFnDDXElGvmmBhxWZb9cUF1cj5dRiTMgVDwpJfH5uUxMORAIuQGWoFwWdt0DNHO3oTGNzt3xk29d4ZmklM1g6oVEc1bR26GwMzI8mQrYA5Nw1jMq5uf2IyAwK0yc2/h0eYObV1zahvaXt2trms9gVmbAbG1TyfP1NM2pIIj46l8dGNDIwKzWkCE2iTpSUeP0NqVkz6qPYOI6G4pDKXOALiumUM6HA6/8qv/EBFiTCyIBIZITQP2hJFyL08u2Q8ywSYp9SYKQEcCt3M/2Y5KAASUk8LDjJlTSgDQBHB2ss6e5DVEVLz1oqhqBi7oiNR2ou7NcYWO2mAd9ES5aBcfNu7mk3KU2oL16X9w0BamS4iAruVksD+frt58xHLifwdmQQAoZQVAIiDClEKtmMvCgl0azKwUNauEGEhiFCBENmdV1WEYiMitVFdTMzQUzLaeRU5IjIao1QDM4UPBEYYQqrXqW2LIZVXmwBxjDJGrFdUiAh5CN/TotpihAREyM0Z2QTcHRCJGV1MDIY7CXt1rE2d6QyMKoxsF8+rN+E1VtY2FmYCNAxORdiFTFXQwUKtnltoHtX/7mZ+4ooIkWK3kZWWibujWRcHO4DkipCaTcDZAAuYmQHOvzZqFxMzctOwNuO7EzCa2Yt/3OWMInLqwrqt57YfIzk/yJThBIsAdpA/tQTQkRmrTfeTgtsTEEsNaLdfSEio4QiBmJEQwKlZbygyJiJk7rObgpswBT3pKByyA7MhIDmZISAhE6OZIyIIG5qgA4KRINIRAROCFm2tLjRkQ0SvGGFZT9YIUY09equmcughGimB2mi/6idmU2zY4BVElZjDPDkQp9aHPh7lL/Gd+4ec/ffXs8fbNNCWoJbu6rtJ0V7Ww0JCC8kn2RUQUJKTIyKBG7E6NsGRNhYDCYuLIbeyhbdSDzEFAEkhgZhUCIDznFiFA1QrmZI5m/Or/0Z5ttTIMQylIBKYVlSKn1IX67FlMMsQh5wyB0zh12y2o/sav/5N/+Ju/c1/cU7TsnLpSj1ShP/h+B+Bo2BTp5/KBwUzdnY2ZudHJiJFErCxNsdXi3vCJMzWwFQNAYHDHql6tICKZa9UYOPVRqe7XeRv5F7/3vQHzeveuEw1UgTukTqIUVRZuEkAksrNCGrGdYM04B3CSKJ56HSs1U4ZmKWNbj/PhcDj3YdC2WX/p3386GOC/+o87xCd9HxO1HtS9Kpj6k+fFrJqtVgcI/9Xf/Xt/+f/9/9yPfdheBpzW/cGpevO5YVMynQADXsm1qY7o1PQBMTN5JWc3YwJGNs1Qi4iUtdlQRA20ABoJBZHAkTNkRI6xa/prd1ctEoODghmYFm25CgB4mnX7eTdEZzhKsZxSQsCs1dyZWVWXdY3rybqJTR6hZ8kn40kdgifCoohst1tDOB6PwJRP7lZ8POy7ri+68gkPZdC00m3pBcAxqFnWKszolJdFKNTqta6ImFJqgjkEcdd21gpS63tcLeeMWmMIp3PpLC+1qmDKzObngA8wglNhLkhZs5sRB8YTcosB0bxFgtU5I6IQIzme9QZPj7GZORoQEvGTLBrAAMJpsAb/ogf4JB9BAQA3N4Wm/T3VfAzITETMhqgACOZoSEQMBODFQLVN55t7UdER/Sz2Ov1qdjw2r/00LnM2sxijBGRJMUZAVGiKn5Md7+nOfnoYiEiIKjRtAJ58Pa7q1Mb84ATgjVbQcKJo3CL6xnHMOS9LOZezDi4VKwDok5aLmr+OHBG4bV2oAUtAG60bmNDPL+30gaeuqhHAARThT5jI8NR8EaCDkaG6OxIgtl0CeLunXJA74cCqxblStMO8/86n31uXg6o+7I9ImuHIAA41RbDqyGQReQgSQn40r7VPo4ubV0AfYiylAnE/pNvbW+KICI4FGR0ycIkxSiCYT99ojDykflmzmVZVMKxaeMPj1QiopjYfF2a2ATMetttRQ61rTUPnD6ZqGLpa0cyJkUDQDLAoORHEKEWrE4OBRB6G7nGf1dxMU2QGrtVBtWIJEihY6BhJVigSIGKoufSRsxUwVAXL7S5UYGBmjRolgLuDMovX6gAhdg7BXeflyO0adk8h1Fq1VgWFGOLYratZceGUc451RSRHAhGPsMJCQN2A2bXMM4OGDpBqiECUmDkSrSUjhxBZiUopWjWFINL2rIZeARnAKQAAJUIICoFEyDLWWglBiKXDvK6JI2eq1YotF9uLUkquB+5DBQDlJeeYErHHgBA5xsjA+8eDewkc3VeiQGbu3o3dUlcnhQ4JdJjSbjvO+9kCa8E8r8MYSylIzoYEddr0D8e7AvO81nGc6lIIVycPKdAEZdbDwxpjv8wVyZFq2291m77mEpnNSscdLPNFkJ/71i/+/He+X+Y1AplCQAZEF3dX90qAhrCqIWkwZBBBFkdvhWlgRdVyste3RDQC4BhLKeDSFgaI6gCVe4w7jcws5wbCwApqBa2is1s1U7QTy7z81p8DNdJDREAJCgJi2MmA0UEhyuGxMg6b3U57zJ1/9Tu/84/+xt/8Z4/3PPaqa7WceEgHYMaHTi0XETGCsmSgmJIQK/gaIjNL8zYjMaKTcK25uApB5OBqpRggUgzIJAlYWNfipbAHaMtVgGIZI1bxLng5Pr4c+V/97ndfvxzw4Q6RgSYTFiHCDA7M0R0A2YkByAn41LmWWs7CuqatoxPeaq1rmwK6q6oAQCklay3qgkzktZSPNykAQOA5Z8Ih9gMLInou+xDH4LR/fPSaXMK8HDfEkstuE//+P/i1//Av/9Wf4gu/uDgut1t5EFmAp6K1WrHzP65wXJe9UWDhdmcs8zKOIzHUWlDc2o0OMJfiDsxBS8EQFIGjl7J6slUzoavXWLtlPYZI5ks/RAVdjocwBihHQsxQq1UWypYJ2EouWR2BBA1NVQEIFdUtYCAjEBIgVfWiTCTARopI9pSRy+RuWTOBCQsJOxoKI/C7u/vHf/5bCmpmtdYQmJlDYMBW6wcAUHVzIGoCdTMrHlciQ3AGRSNXQITqpemr13LMehTiGAWwmBXgkmKPLAaKbJSUChDyWc2ASOBQiaJ0jBwYIGdDgArgZilSCJTzkl1dgIGbMU1EgKiRJ/F04wV3N0QhcXCvKxGbe3vUQxQAq3VpKzBiPlkSqsFpOnpy2J0n+wroAKrmIQQGJAUzb3FaDEjuBITEFAACZCxuyIwkWLy1+Aqhqc8ax5Kg8UW5rbPd3dyVJJiZKR7nFRE5EgCaa5cw9Hw8Lnmt4zgCatU5RgEJXq1mRcSUhJonwyoBUCAlVTI67ekNiRixrrmNJ9SsEQvVq3FVKsf8SCgoXFSBHLnmskJwFlnXw6effQZAP/nxz5hDO40B1QUBWAlMwRCk/W1nEhKcqwozMnVA7fpQNDOHqupA4IwIIlirqVnb9LsXEl+WJUnKuYiIxDjP8zRN0g0B3Zd8FMaujyRYPIeOY797eLiDgIKpdRgQHMhi4KJVzZC6EFNMWCoxnxQsIkInooE7WD906CdgORFgJuTQdYk+SuwLHScCR9PqpaCbMlNKzEK1ZndtTU5MKBIoWOoosLgqJ6MKFQqgErsIIoIAERE3WgsgSRCRqs5CDhVMETRE6bqE5kiGbu7EAqkTDpDzwgKEnCSwuJYaXRDYlVasZSnVlZwcLQqnFPCJKGruABXUuQIAR0dCYCBASUyGdYWlaEgybTdhjetSAHDJKxAaQIhyWua5hxCq16orYKGIIRAzQHUgZ/ZcVmAPHRgQKUJVAAcWicLM61LquobAhqyqRBBiF0LgINW0WWMQjAgpwBRjXlQxG+YQU9YjCU1d78YItRTlyDESsIUASACeRWLfY2aKTTZfK0VHxALzsIlOjOLDtI1RNpvosAJSXQ2YQkQoWGsxWzPQttv2LNVq7BlQpUPN1nddSqnrurv39xh0WQ4psANQAAmh3V/OVaRNnGrfpRfXL3/ue9+/uNxCXszMakXhJpNp8/2ToMxPLGE///ekAjODgE+nEpxH1ogYQkAhZCJuGg5hZoyBU9e2ZQQF8Jy/AA61uFashb/zN9uDXeeVsREgEBFFmNqMx6s7V47XFwOkIdvKDHd/9PV/8Z//rb/z098PadtUd6nv87qEyDGKe0VCYmCBEBkBiIEIkKjvBACWpVarMck4TSGEh8csK5E7U6UgErBWY7bYx/FqtKqerSzleJxtroBGJGPqc14CWnAjhB988a1f+N536HC0E4QUTj+ltmSk0yi26YbOW0dERHY9EWjM7OzxgzaBNWvIrwZlaVqEWmuTi34Y1gIAwH/6Hx5VJcXUIA3tYTar6919YAl9R+hYtJNA6pTCr//ar/zHf+WvvFmX/vLl/eMCy2qbDsZkS601G0LHAgheHcm7LlZ1IC95RWSK5FRJ+OpidzjM87KU4l3XEVFZs1uVGOZSWRCARaK7Apzoycfl4ACOFkNAIdcaQgAGAnFXbpEujn6OHMzrzOHUZxsogDILIYGhEYAZmGETwDgatpBIIxKJcor6VENEN8TGUzmpx021LEutXpsFnYibILBtT5Dc7SN5JTs1xF/AIKctD6JziAhWq7Wl/On9QE6CIQSJHITWtVxeXKmqalmWJcbo1nIhrO2/WlP+NH0BJiQJhO6OjIag4MLcZOzg5Kc5/Gl0cSoUyLGNa7nZuWPTvZ6Woe7uRiRIggCm3pKwhKU5hhsGBoERTxCO9vwSeq3Z3VMKANZ8+yRyckcDIFNKoT3tIQROZGZWanPbyAmnxydPn+op/8LVCd3R0Ku5giMDM0FLUHdY8wHQQE3IHAqihogSMJdFTUMkZjbNa80EGFmAiALBCejpbYtKSO5KQaCSVVV3OoW9KDC5e64remnmDyJHxo6jaiu24LjMVt28kp9uSWZAgpMS/YwdarOXBl34UP2frDDG4tBWMK7MZGrm1igPDuDQNhhqBo1QdXIjm3Vdt66rxCiAjrlZJExLrp6ddHOxe/v4rrgRQWApVrkTUBuC5MyOGAIjKZJ2nfR9v5RaSnFntcbfdQPfbHriM2SmFMMSsdtsNmGfP7wSMofqXsAZDJk9JO6HyOxqjgAxCjN7D8MQ1XIg94B19dBZzU7qDArgdBJbAYADuaAAQJNYIiqRNTIBEYhAiKhaEVTckanrWSIyg2sdxmDqUaQEW2ZzdUSEClRUMQM6R04pbrepua0awN7FzKxABjZ3d6kUQoyBGYmgVmMMKQIyKBTpedXs6v3URYVaKzAgQkjS953EaItJ8ram5GTMaCdtrmNgRIyRiQOxO2SvxtEMQJidMgpy5ECUK4QQmJFFSCgCAbvUkxGfow99D7g3Z5bQ9wkRUgoSyBTdVY+16zr3rFiMsRMqRR01RAD0EEDVqpeCueu6Wiv3gQSJ4eblrtbsOF9cd3UT1rU8PJR1OW5vNo+PxSMs8DhyiELLYc/Sm6/jONDUzfMc+27axrWSkrkogAlP7g7kxBAjK1ixZV1Xy93F9YtXz6+ud1uvRfPaReFTSJUZGp8Hgq28EKSnoeXTJ6FBA88fAOBtrtvoAggIfFqltgtfAnDXblMHB9Tz3sDIjGq1df7wYJsCQ3t8EJAFm6jN1BWs1NBtRweLfbd88/a//tt//1d/+3e+HpNgLPNKTN0Y57LEQWLEZVmJg0NxKIYGYOrAwilJ6L3WSlAjeIyYJk+d5wbkUQewIByAjscFUFPXSfCsBQU4OS6GVIUJoK61MFpEGsB+7gc/+PnPXoV58ePC8TRpdnc3cGnMgxpC14qNjwsOABCkVjrbGfDfptl4hoK0+fZ59aB40vvgv/O/+yAk/+X/YHHHWq1zCCG0m54ISikpRBBaNI+S1oeHgcP0bPuPfuO//T//5f/7b3/55eVn33mYXSxvho2yLeSxY0VkCpvNWGs9Hpfm9C6aGUNFTYEDh2oFtIZukyzmumrVtgiXQFqganVQAzIzw7YdgWqKrkDOTE4AjI5mVp2UkEjQDJiIQzPhm6tDi9qogByBEdCA2MncgIDd1KtbVTitB5yQODIAoCsANZ9Sq+GqnQq7tvN0N4WGz6yAzCKIXkrD2rJ7JWB1a5bm9s+DSCzIQsysWs0U+IQYOI3DmwYKFNBZUhyEmRhofzyUsm42m3mxmMQRSzHyFkcIiEInYJe1E7LB3LwpopiQQWJoKnVTQ7MTs7e9W9GgyR7RGgYHGIQBQJrNJMZIRFVLcw4zkRualVIKM1PEpmGqzdMFFRElUOvi1JxJW18hQiKRBWstRCSBEdDMiSAkqahmFvuA6HoSsho1u6YIIppVROATrcocEbAJ49hqUTduhMCm1jiVp5UF0dx1ra6qWTVbC5AnUCvEtN0MBHB/fx/DBGxEJyKDN2ufm4M2u2itamaG7FQRPHJ011rLCdkqTRfhCmqumtVc7+9v17WU7CoQEyEDSTNXmoM6EaAhpVqqNW8hfliaEAJgBawhjQFszRVqDTGCx1oXYmdArU4EzFwqLHNuvjlr27oWMW0mgM7MygQnfiWQoHpGcYdCbIjI6NWVJSiAI5MAsjiQVheOKXI3duX+sVZEcHMgNyBAtGkzYTwt6Hw/c60xxmEzSP5I/spAYCx04mAJSGARqV5zrUhOwmrWJd5dDPtDNmOvblZDxwCKlZjh/FgjQFNIk0iompuamQXb8i+lVGxx92oZEJCdkCSGfuyKFQAFMElUqxEDOWH1GAkA6mocPRiAc9fF2IfUsSG4UzVVsxjlZHNQL6UaG0ZMUwohaKnFMxqMU7/kZS1zGnqjUlR3F9uyX0OUqjmGIAIUSK1wkGRC5EiObCEFaInranyCiDuxp15ylZrV0SSRo4aOh01nZo4Q1WPkWsywIiAKpsBmsSWVuteiC0fuMXKAEIiIQmRCJ6Ywshh2U1jLYlVRHGMickNVMg5CgjUbMySnbgq1IiVz1zR2067b7/MyH652V9/+/Dtv377/6U8158ohYhpKxXlZ+l00s8dZcz5uhk0/phS6UpcC5VjmV59/8vbt28fjDAC+Ys7ZUYFBEnIzNAQba/j261efvXpB6Mthz+4esVank53MnP3Ufp+oIa2oP8lFn8oON8TmcD2HZTTlDbUfOBGgAAUHNhRmcX/y3OP5i5hDAazoRf7U32tPtf36v9Sy2huQ+PR/trBic3Mbho12oeoa7h9+/Vd/7T/7tV/5UV3S1VWdVSgQECfqt4KIEkDc1Ks0ISajKRpUYJCOTLxapeipj0RQ/cCWQmpRbGQGwkQos5OZUodVl/1xD+4BE0aIKG6Yc+bIPce8f7i6ePnzn386uC6Pd5epL1bOuGoDwmYHhQ/aczCrhqcxRptkkLvBKWfupMCQD0mEH2q78wcC/MX/zYfZxi//B0tDUACQmRG6iIicmhaoSpGsOhJtN5up7/7oj//gr/4nf/2fvvmqf/GsOszzHEKoVtR9u9uJQswETN0YrRCwgnldCzObVRFKXUAEWw0JlmUvqU8a13XNNjNyigGZ8zwPU4/CTubo6icMLiOxoLoTQ4HFXagjrhwCe20mSmBmcKxr1VrBMfaiZtUVnYBIoiAiqEoSXRUsI1QHJCYQB/bGjzGzWoq5N8r4WcKn7uqNQgEaW2ZelGVZGnYTqCKQCJkZIzgYNK9B03O6OpIDknAArGoK55EptjEDnqIyGSBYSCjClpUZ7x9uX3/xarJ+2o1vvn53d7dPneRsAFZrRmm6bGQwsifYgyICoxMjs5RFkVp5QYgAbERgrmZgBkDNKkFAbmCrAnNEQQB3Nj+zc1qVgudUHGbiyNRUZ8X8pF0iZqEAYqiK5i6BAUBdhaQfk6q0hEtkrjkrGAtHEvPK0WutTenBUchRmJrsOtfc5I8CXK08OXsdGxJF7WxBd1BEN/dSjSkguaEzIVFSK2qg7d8DVAKN29Fd7x5vURTFDbTJsIy8uroCkMcYACh7RTIORgHQAYnUVIujN844OoMzorsQqlroWKuplpgiohMZMDlBUyciOoIiciOtN0/ixyFtbuauyCBCQLiW7G5EQGRIJ9MKgDN71wnXAACHwyGEsNZl4GF7Me73+1KKcAiu2iiWoUvd0HMgZ8hlJvaxj+jN7uRCRuBrVZGYuo45mBkFDFFEIolz9UBSq9WqliuxAahBIKbAkSSHFCVwTPKRKxZikuhmauQMjiDIjChYdc11DVFQqK6l69O0ierRzJZ55UjuoBUQGlisnYZNYtZipBAMkTFEoZZe6hQCrTWs61KthMBN6NTEvexca22+cwDgwCDsQkzuVasoi0tHACDCIlh8QaQQA4FkrRJCiFxU61qRAU0oCApTIAcPTi4kwSMCBSMpMQELGa2YfIhhnuvQRyQQ0uOS+3FYVjBQYaLEw25QTXXN8/FIAVIKoEBESBBKuwIoDbyua9+ni4uLu4eHnLMIxo6Brf1wA3OM4sg5u61FAZZlmaYJooCYau3GTZshC5FETmNMY/SlYi0oSEl6TqWUvGgaAjNVhi727UYfOCH6mjX1AVGJzUmXsr9+cbHm/dUyXl4+e393fziE4wpdkRfPrm7v76e+r1WHodOaLeK4jetS5tl+8PO/cHXz4ptv3s3HdTnczwu19iUE7PuQYoRNf5Onz1++vJjGeiiCFNitqmKFFAAA2iQSgBECITM91RlPH6cDwv1pzgFnMyJiQ4oQcMCQPAQMA4YOKDTqGZJgu1UJEAxNzd38w6YQAzujI1FbybdH9AmAQlGHLhCEXH7t1371//Mrf+9rX5ckAKq4xj4gsvu6vepLKUyAEppaniiaQVl1XVen4gEodIIGSF0fkbyaKamLh6kF6JwovwGiKVDHjMgRwZAYBRiFvFpRcMgx9FeXm1/43rc79Idv3lwNY12zekFs9xwwc9Mh2im9HU5mt/OE41RJEJKTwSm3HQDQvJg+OQLwSUfqjoh/6SNbyn/2v6/MPRF1XQcn4qG6VufQqhA7LGbcD13O+eXzV4dl+U//1t/8na/+yF9eq/L+/jFx8AgQIsIKuna7XqqoAfKKBIMEUHuEOUHfEkCYwbyOfUhddFdMKmrVFdSQnDomwE4kJUKk6iYEhoCRA6EIE5qWQpHVjTsZhmFdjimlddFSFABDYAACVJvdrHISN3XHZiEAAA5EgmmQglYM0ZEcXAADSWJ3DV1A5+OxADkTEKFWR3VTdTZJCQBqVY44bMLV1eX79++Px2MTOgMTIZiBEGB1d5CWUVJPXApGlRBCjOqllKqeDcnYpHnrCByUGSk6BgNWrzpd9I8Ph3GTrq53d3d3azk+Hm9ZKAqauXlFIu5EAtVayc5mvKrUdnEOzFDFsTEJgREbKN+Y3DMbGiCIiEhAdLViZgiFQ5vsZ0eSSADkbtbElcGFMEQICZBAwcCqN5AFkjNRCOgg4FYb+tyRHNggoKMZKAsxGwNoNicIkdwZUb0UJOIIWAEbvska41mRNXSMCFTxhBNzQK8ufo52K4gNuUEi0cxArBFjiQmRvBgIWVk5hBhiKfn2/n0KcdwMBrV5ixGACRBQs1XXEEIcGJELEFbjgBIAgNSUzQDNyM28JQWiKMLJEi4QzCpFDFHcgYIzGwsAITCessPcmaG6GThSG5md7B3Vq4EHZowtBON01oVoEblUbWvfvg/X15dI9vab+93V9vLy8mH/eDgcnE0GSZxk6EQV3TtErF4BTTp2L8v6SKzIDqpajdBioK4b9nO9urq6vrjOuX7zzTdzXpGQgk2b/tE0r5mRQ2AzNM+PxwPVLoQAUaAtRwRYTOTD0cwIpSzLmtEiMpJ419O0SYe5RMNhDH3fL8vS9cBiITpTrLXW1dxd4VQ/IzWhPDphmzm7u1FJXd/1QkSatayZpCNWpELM0klKEZFMoXpFxFpz10eiBlIohsxRXFdgkIjIHFqiOjIROmHOK5iSSJ94t9uEEO7v7zM4UggAjmRQHJxY+46ZQ62ZAnIi9zxtAzPf3z2moVddkHOIgTl0PVWwXPZIjuQUKKSw2U2qZT7Csu4By7TZokGt1Rd10tAFEVFdqy+RqNtwb4QLMPNuN+Rc13XOZWWsFIiIFIEMoKAj9H0y12JsYHEIDpCLKgKKx15QHMXNnBAohm7ouJSKRtFj4tB34ziux3We59QFRDdH6bDCqlBT4tTxH/7R74LVaYo31+P3vvvFH/z+j76598N+3k79Oh+nT19O0zbn/ObrtzENgNwoy+/efPXZZ9++2l39/u//IcOqmmvRzTRtNht012Jlzd9+9tlunGwtlnMIsSVfcQwtRRXJz5224EcOzrPkAj5MHc6/Obfn52YdCUlcknNA6Tl2EFKj2DQaC6CDKWgxLaZF0Pl7f/f0xX/7XwYEP2UNUMP/+tkJyRI5hGMPcck//Cf/5G/9xv/3t+a3eUqTyMO6kljXi6rmpYxjh9mYuSMhZ4BmMa2Orugghr2FGHvp1DKzS6DUBgcrAKNEaouJkiskEBSMIATjNgGQGTgaZHWiCJwfDptp+Au/8Ke/uLku97eDRCu15Jy6c6HGTHRKqjSzGM4hQdg4ROeYSsLzyXtKgDj5UFpe5Xm1//Qz//DDBwCAcRxT6tuXautI87pmy2Xp+p6Z42ZU8hQ77vk2H3/9h7/9e+9/2r+8frceOUM3xLyqd3zxbHd/97XBoduOatIk/k36UtZ6f1jRCWyRICGCE/R9GsfhcX9PMes6Q8ghCjNwrBJCfzEsxxlJSD0GdGnRFY5kV5ebrAUIi1ZJ0nVBQi8iQJlKUHdiap4rdUJVdxRv3lrLtbAby8AxJCGrrgFO7l8Gik4RRUI/BnKoDgdbATVxF4StGJqTYOgBAGx1FzWuFCEOVBxV7WTxdkdr+0ACNGFkZq7oi+a1UGCORAyiVMFMG+e+MZOaUcKhYVCoGhpE6FKc6+Hdw88uX6SKh+GS+z1qzoIMTupARLEnYIfcsAPBswIqIiKrkTm6JIIGdz0xRxXMm5ITzBwIyc8TfXfXYpUDS3AzRTQWAaBa1bS5UZwZKDqIOjmhISgBMQCSgShKIXRmD3rKsoldSIlVVX1thndHJSR2cNcQIhKWsjopYptCKLoDR0Z3d0akiCiApEQmak1Q6qWyIBI23gsAsCARSmI/GcXVVRUViE2MEIMIM1Wv1SsqWmARyW5tOQkALATgEB3AY89pEHNnc1BCUgdzR+fTdwLoaETs1OxN5sTgropkoCQOWAGcIxMZMsIph6Op3JzEJIKSorvjE2oOMKIg9ZsYhlAeZ0QL0QkrCHd98MXXJYOIJBx3Xd+HanZc5jfvvjQE6oii9zF88/6dIGkKPG0ux3G4fbg9LA/FtOoMRhzAHLDBNMFIfLMb0rbeXE3X19v1uM7rezvUbkzThnEvx4PrXISFiEIIFJOZ1oa/9oro/ZCYdJxot3bwx6dXMowxAh0pk5hwBPRuCpdXAz7OxjBu5fp6W2qn9c70AFj6oV9WWA+e86LqCNwix5kIxc7xRk3S4t2WplHc/fBQdZ2JKQYjZonMHXQ9B0nrqlbLsqzo9uknn9Wa9/Px4XFe85FDVDVuzAkwQxPCGCmEUCnoXtW0mYQ3wzD0yct670cDBCZHSEm6xDVn8NpJGrc35rlaoSBEZKUSlHWpx/Vxs+mHkQl82oSLy+c//epr4WjHDGQVFkwegTl0uSSvfnnRucGyLA5ZVuNoKMoKY0yIFal2U6DogHb9cqvV9wfe32upK3J2CgwQQYqV3cVudzHlciwVQdBgZWZu/Cc0SYKosRdlQURJJEIpdQ6rlTL03TRtuy7uA3QdDENfTZHzdtf1Pb+/u99N4/XV5uH+6xc319mqrYf/3nf+LJbCXy1f5i+3fVrH2HfD69evf/LlTwm2JFHIA0Ot9fbdj6eevv/dn7veMZjnVZd53Qx8OXVD6vO6ai4/98V3e+ryw4wOoGZgwOBaijsRMDVSWdtyG6H/C5uUpxvu6ff+sbcTEZCQRal5eiKGEbirwGiF2g1iGSxjrV5Lw8I/fU1lBPMTOo6YxA0A/eweRYYQcT2+/fInv/Lrv/rjh3d12y3FhkgjQH+xS7Hf7w+A1aDEjlMX0qmLrcuy6AJJAvdIXLs+EOM09eaEpBIw56xq0okqIjkQQYZcC7KmGPtRQPMQY3Ur2QIiJwaFWOP15vW3X7z81rOb8v62Ho5Tl+bjftxsThpcPsVynklH54nGqdjAp8mQ0pl5rB+tTT9Ko/jwSUQi+ov/qw+QtL/5f4CnsUcgjkEUi5kCNEEixRgVCcwFqev73/jjH/7m138kLy7hvQ13pYBlqFnLxabvYq0TXT5/1m+Cqq85oxMDC4lmPq7pqDUixN4h5q6XbuQwQoqkVeNgFIgJRFACSyISVpgJoToQBmcDAM3FsH73e7+AwnePD4d8rLWWUvopgdW1Op9sjYAOCUNIAcydyYrWanlZuVII3PVIwQOaVvReatd+bs6BRJATpSn0MUnn9M6WYwaxLvaeZzMUQY6GCC4MANXzYb4PiQeKx3k2MyJp7RhK46CH08JQyVhdbOy71ImBiXJA0doogRwitu62RaRyRGQkbst8iz29vf1y915QbHPJz+vm4XZxJAQyJHOXAE4YAraFdiUDUnx6BBgFWRSABBFrVa/mpuQOUFXVsRmfzB0Ni5OxYIwtz0/OGiCsFcvijUrvDhKQkrY8NyBuEzUFZ3YMFRmCITU/NUJIFgcwQ64MTKVoyYpMHKkURfIY0LRNKegUJEBO7MgUWcg9RJLgHFvYOOe15lxNXETAqVbzE8LAAaz6kUU4cMNstQUQkORcIksppcwzC242G0ZaloXa8dVUvmjIKJFIqB8TJai1QjCJTA61qquFyGaGpaIAGSATMSJWYAoxdJrgpHihWiuAhw7bLssMoFoLECMio0zRJBABh0JwOL03pcMUebzo04APh4xSIjFAMdBxO4HkoovWstb9vD6idMMmVFqLk7qpVQwcUtxYJ7UcweViN7z+9MVu37+9C7f798tyNOxSHz3CEMbH+4dlWYtVJ5hGUTwcZ0H3acOhn7oxho4eHrIIxRiEKK+ViG5urkKQ9w8PbZ8HAYcxBOGLq/4aGeCULnhzffnJjlgAAETk4WHf9TxswqESLQU5px6iS14554Wg9IMsRznwqpYJWiQbCrME4sgiAohmNpciwuNGuiFoLsdQnAtH7wYETJQYyGPCoe+Yy3Jcy6q7y80v/MIPclm//vrrP/rJT2xvqUszVCYgt1oMayWRbkjDMDyUpfOOHGouy3rM63y5G28udvN6LMVQKKS42Yx9x4f7tazqUL/9xevi6/64v7zczfP69ddfX9/svnl3P3j83ve/FYj2+8O0GT95/RkFuvvm/lih6JpXrXUZ+jT2A0Imp5cvLmu1eY6pE4hmxKXWMXSSYhteJRakmnONncQYkXPNj3owdwBHZkEOU+q/+OKzro/H+dGhrqXkWlAo9uQKFSHF4I4dx5DZEYQYsE7DhNA/3B37ADeXAzOPKYoISXzc3xPXq+tdCPz7f7AfOlLLN9e77ZR+9PbrxHT//uupiwGtzHshE9CHh7ebTbp9//WrV6/e3u2fPb9ej8f3t293m+n2/U/2L7cvXw2pv5mmGASGPuRl35H3IW4udug4H446FzY00BhIBPJ6DCHAKYuAmLEp9v8F6cbHd559lCsBgGeFPCIIcCAUZSaklpkCAC0JuP1yNfeKbTX+2cmcUn7vz6hXbAxiFGAiMHQAA9UGDHQwvP/DP/5Hv/Xf/MHDVwo1hhSmUEu5kbR9/pyImjQs5xyHqeu7k8CbPVEMXUQQVVVYiQ3c0oAsMXUI6Lfv9g62udisB6vNAUmQi4PB0IfNkJZaiQiKqVsSYWDPapV+/vo733/1Or/5Bpe1Qzw8PF5cXro70HpiYJy3TszMgeCUq/KhYjsVc09yGMJT4i4REdlHWt3mNQCAj6uN/+I/ahyg4o4hhKnviKCauztzU59VVXRiMajz+sOf/eSf//gPZnbc9FK78fEwDwBjwk5eXl7stoOli6OUzdjN85xtsaqIHvsubnpgf6f3axFHrbamNHinNPg49PPdLKG3UlWdiLoxhBSzlmnXI1KpgMgG2rgaiPDZ56/i0P/oJz9Oc7x7fFjzcRinuqIejsgt2dMRmQMHCoxCPc3zuu6XIO4eYowS2byKR0viYgwCAA5KBFHoWPYo/fZquLwaUwrv3tyCSjfEiiuAAHojNUUmBVTXJc+7iw3Hbi2LFQMGIiAKyG1i1N4CCEDIPQmP4yhCtdYYxclbwUEo4xRPz3Mppa5RJEahM7WsG4JDWfLj609fLrk6qaOUogCEJMXUQBGdO1ZnAjQFVSMhDNgCtpJJNUYWAMgr1qJoBO7bTSrVWjguIJuBmQBArTklTl1k5pYDotVUOcuJY2ngRMCRJBARGFoI4fQNo7EAMKCjrouIkJuhInE/RkAy9/u7Wn1l7Di0kBRFDO2ti9SoXkBEIkQkqhrROVCInDoWIVU94KxWSCjGgCD19CqgffMs3HWJxVVBtZoZkIpgG8pmLRw9hQBQzSFEnBc78dNcT94wQUGMvSCTm1NAEUIjw2wAIVHN6qrYUlWZkcwQvCoRxRjdkciYWXV1964TIgGgkmsxdDciFJZqB2ZOkpg5LvBUcJC49CgDYDTzo2MlTl7rOF3cPLvqD4GIlrmaQi4LLmV3+axCubja7o+H/XyMKR2WOXQim20XQzg+vhd/9uf+1f/+b/3u7/zoK353927sI7NcXVwi4+2dzWuQ0Fct8wPudiENgkZbvLm7u7vcTfNyB8Ie2KPGISZi1dxNPk3psVjfh75zV9yOdrkd+wSfpcunguN7n998eSxDuri4efXm3d3mSqYpuR+GBHK1Y5HlcHj27NlPj3/sUD7/9MVu04sulleizfu7Q8kcQiDy+/u3zzabTz65ONwfAMJNwmp+seumTXdc6H6vu5srgj5EQc6vXlx4ycdD7kNlOKQ4l3K/zPPYx9cvXy7Hw25MQ0/zuuy2kuL27v162DtG6QbeXG+Z8aYeN5+9vL07Hg/r2zffbDabL15/J0DsxvTV1z97d/s2AAxheHG1+/K474VjJyW/++zzF7fvDsiH6bK7fVsl9s83Eq9vXrzYusO46Vz51fUzyv7T/kv6qla3w/wwDTBtQHW/u+RyrNvd+Pz6k3dvvvnRl38Y0pAND3Oe+iHFMYlsduHx4Rvp1TX7/LjZXR5v9zeXHdpcjSV0S8n7w2EYu5rvrl99kaTcva3H+cFNyARtbpPvsdeuS0UrQkcUHZbHx32QSdyfX113CVOo213YDNsg/Y9+8vUQ6eKTm37kwzJf7aY+Wh91mEjpuLlIb7756s3tGwQhGeIQ9vn97vnW3r9d5rcvr6/+1Kf/0jfbH3/55U+2Yzd0z4rWqvMf/vHvf/e73wXY31xvAsv9wwEZivr3X30RNeCimgtgdXBVrIiMLKlDtybdDTHEIMzYlu2N0HpSlok0l8SqGUFqLXjCjwowGQmhGAMwmpBx0NALR3BjU0NxLaTFS3ZVNyOoCOXp4hSM4M0OCeYzWVQ0JUNz00yIqOX9m5/9xo//6Y8fvrknWTdDCDYtt7shbfphnHI/XOwf5vnwbrO9fHZ93SegsF8XyCs+3BeJcnPdO+TjvIiEXBXs7sX1CwI8Hvf95XZ/OBAs1CeWbl3Uqm7GASZDLFXuL3nop83tfv92uetCjI6vrl90JN/ubsr9g5fitRLhdrsVcESoHuVsvyRCdTN3VOKOqzdJJwNidWNACkJNJAunvDEHUARHAH+qPRwRCfnf/F/uP8w2/iNsrpCuG4gk57wCGHZAxCyaVQKVUpyxp7KCv18ffnz8WbywKyPJArlbv7h68/5W0XUTbSx8w/m4XI5jHz2AaObMyujbXXh2eXW15emC3rx9XFdcS+6nkFIdU+1jP49yPC7v3h8AQyXDDStWzaVgdYWLq5v946wVuzTQAW0tmmXY7i62RxQquucwHh4fggwhFURyw64b2mh9mmLV3MmFEGvJTnR1c33yPiDevn8fQqxHC4QSgoOKsNp6EVPe7zefvH7+7GqIlkJ+3B+IjrvYWUMmuxOBkxdbYwxgvp8fJYZu6vVgzND3yU2LmpENm2EYhmWubrTUW/VD3G1UC+Q1CXOR41JVlSOo1+1uIjIHenzMMQozqXrs6fC470dJYWSiFOLlxZTE9o+56jpMo4jcP66OhEi5gFgodZGETiRCWjHw5MoQKiGGJMt67DqxVY73h89ef0rSxX64v79/9+6bageOJCS5QidwcTFeX15dXl7mnN8/vP/qzVehi+aW8xIiMoA6ckwV1mq5kvYDi1DOpe/7YRjWPJdSYBxyXsB0Grrdro8x5rUuy8puAcA1I9E4JSI0rNR5V8wUiKUbRzQHVOFqeeEgZtCNmzTKxeX4ePd4e7+UCmmKDjgNg6mba86LBMhZMdTYVyfoU3p4yGTMzFAtjpfLeiS1LoTArApuJpwwLhQI1BCxlBz7TrWGvoNEuaiBdzEhYrGVRLshtuhlkWldFJFEuFgJXdzEqM6coqO4+7IeJCAz9UNiiDnXtcwduxPWol2HgBxSF7vOQNHXJw5HCCEl2F6MD8tDTdRttmQOqrtPhpdfXP/kJ+ugXehqCOGTTz/56U9/KtE///bLu7u3w7Zfv7xT13Hq5qXKF1+8WOfDQQriDH749PVlN/gf/biS0zAMIXDXh+30bMl5LfXtN7cc6eH29voiXF9cC9pucy1Bt9OUawH1ZxcX7mhWu34sy7LpL17cTI+PD6Dh09evrrab5XgcUno5vgL4cXsl8/I49PKqu+7Gfrvr9o9d3/fu+q4unaTNZiMineAUeo7jpt+Msbu52E7DeDjUL3/25s27+1LqZpw2m9Qnvdj6s+vduhTAEGN89uy6aH14mMOnu3kBU63axSjPrkam/nhcGAlQHPrdLtzfHf7BP/jlv/jv/qWQ7obp2A29yGVd/e72UWCdeu+GsN11cagh8OE9fPLs8mLc7PfHTUebAb/47CpJj93S9TF16KhBcgjl008v87IMXd/3YQzsmz7nhdmvt91a9Od+4RcaO9hd13W9e3c3L19+97vP+wsXqfv9vp/X3UTX111VOhwOod9874tXAvF4r5fbgLL5ox9/9eLmRlffbQIoJUaa0rw8XLyaxkEDPsawbMbx2fVnCOn27vFnb/bG6+efvFyXw1c/+uH19fWul8vpea3Qd1PF66+//lpENps+dNz3G0R2A1Op833A48sX4/3t+4C4HW9e3lya2Zc//Ule8vMXL1OKTtVBP/3kuWuZpmEa0/7hngheffJiGrp1qdvN+sUXG5QSpA6vL9mVvZt2uLv+zvG4X/Px5mobunQ4bI/HYwx8ud2p4vb19sULOx7XSUYwF2Ru20s1M2dCRiFsW4xmfz1NMkQkRhERRAI4kbbpQ2plB42G6UBIJ6OKA6IjsSMCMgojMbQkPgC0SjV7nt1m0gK2oip9ekqi1x/+BUC35taqLfTyICEIUTN8V69v949/+JMfHVl8HC9e4fH2mzLfJsHnV5ff+eJbx/UhpXH55PL6kre7F5vpBj1X0/eP99spTcPg7tsdpBjXday1CvUIPAxJUF5eXTwcHsCWaRoe9lTNwxgudn2u+vj4aOZDiq93zzHEEELN5Wpz+YNPv8uLwWr+fva8sltIrRP2lmAghNwS3VqjA+4AjFSrNbwcEuJH9p9zOqh/mHmcHcgfy3L/zf/Fh2qj/VHbuZgZQCWiluiWhhSEOgk5Lw6upR5Z7o4PXz18gxsa+6nk/SC7YTfO+8OnX7z8+v2bRXNI1KU8JOqCCrvWZTtRqRA4Xl+M2zFtustpO3TC3bArWR8fH8FKz3yzGx9LDgho2/28hJiGPri7l4yEXdeT6Wbsh2E4PD6GIaLQ4/Htty9ePa6Y+gEgvXn3mK76ZS6pYwBKsQeAda3MrL4gQYE749pNDouGUIahZ/Faq5rsHw/V5svt83Ec1nWWQKUItBhprCn5ZorHOQzjrlRb17KuhSm6o3DkGOaVq9emS0AhSQKCqqpoAOqETwwJZi9qTDJud1MfczEL3XJca9EoJl3ImnM+qOvl1YU7kMg8H4ou7iDWPXu+mw/7qnOXevdFzVJHl5dUTRFWROyHTqupQ898XPYcQbVydPMcuoi4AqAHCzFQMDBTW4E9Tgyin3/n06Gf3r9/j1xv797WWjHQ2KVejn1fLm7Ct7/18rBf/SdW1N/f3YYhV5xD16XU5+LHZS5aYwwhGLHFhF0/mtWlPAACUGXmURIRRWngf2v8K1UPIUCgWovaGlIU4VIoDV1L7QKszOzmrjrtBlVdS6mwTqlL3XgMpRsHs1l1HaedJAoUmLkbn9ea98fHoo/bywtVXUuOKeVs5iBBzPZDh0K0LAs4xC6ig3tOlBpmFBGamVytEHXmq4OFCAgUQoC1BmhSbnd3Lx46ckNkY0CHahikoYYQmSmkBMoxcR+iKSL5sgIRxpjWtWit0zYiw/YiDVPPv/vjp3doP6U4FAyGq3a9RME+pDHFT16+SDFMY1eWI/RhmMbU4bSJf/ij3/sf/9v/FnK9v7+/ubk6HDOwGKj8qe+9uLu7q2Xabnv0hz7pxU6eHbpAY0yyf3gfMFxd9FWxWhzD2g/b3/md37l/9+ObTRoTX11Nc76fl8MYj3xFL54/c6NlWca+u797+PanL+2PDlAY0S7H4ZNXz9fj6mrzRxwOhNL3sEtdTEQhvrhIpZRS1o52ABBjDF3abreb0Vzt+nLXxdALllrnzQouButuezP0u7Gbri4mJKu5hLAFD6WuV7se0Tsuj4y3MG83u7VACLrdeArcRWSWYdgSwbu3lNhL0d/49b/7/MVNDPu+41evXhzerlz005vn3TAgmcKcyz6l8Lx7xpa3iTtJQ9w+3P1sf/jpq+98v+jLLuHFjo/5PpfD9aU8v3ldlhIwrutxStLxZl4odsOm//R4zK+ef160PO5vJXXaxzzvl/kWeXOx4c9ebZecbh+ceI4hjB12wh10naxDn4T3n7+ejnl/PMqz52NZqe/HTUemOXY3+wNudwMAJEHfdpvNtJ2eSRh+lt7U5X5OdrMZZ8pBuj/17e99cnVdal6X3HXDsebjw7uYuOvMPW/6RILujhqH736iuUxTv+s3IhSxJAJK8XI3Xm6vYjc9Hh6QKlrugo+Xm6GTy91gZZ/icLV9Nm1SnyJxmsYtSxfidl3Xsj7upqta9l3cffbJi8fD+zTGaRq+/fmLt2/fr8vah1jRpqEbt5v7u71ownv2glYVT2njEFlCW5hYw0CDu9daG232Y0/KU8zS03V4tqwYgJ+41+dQAEdADhJ6TKltSICQc7W6Qj2gHQkcoLZU26cPI3YEdLRSa1FRq0WRSUTWWg5lvV2XB3K+utkEiVoPdY9w3I6bm8vL3bT59JMX61K1HLOm1598LrS7u3t/+/B+SrDbjUPclFKaRJR2nbujOoM8f/Y6xc3t/aOVBa+upt3gdT4uBxFLAy9ZPRs690n+zC/+0lzWn/zsKzYdZbyO4/qwL48VjkfMWcC7EIBIvdYGOIsRmRuDtZUczWXMTIAMjX5zRjp+jGr+WJbr7syET3jps4e2ffyX/8doVoMQOrgrKBAAijQodZ69GwbNBaMwwQPmd3q49cfEQdE4QYo4TTe373Wzm4ZRH5cHFkDUulqKFZCt+HbstSJzuN7GPliUTrDis/7qerMu8OVPfOxHwnWa5DKOdw/hYuq+/uZt7Ppu6Gut4kVEoqRlzquWzWYTubdcbIXbhz9W+Gy3AXfWGnJBZ8BgHDp3327HZVmIgBlqXdydgnitMYWayaGmjruI5k4SwA/bzXYckhDA1AO4yDAvjyIyTXRx2Q/9jsJRqz8+7pec19U306iVcnGSxIsphBi5FG27LGSb5+LuoWcxdKilLLUGZjIhQCXiGMgMULBmDMERvO8lVJ0JHdZ+EFVXC7nMtahICmxRPG67i90Uo+Ty2MM2BO2GOi0O7iFJp/zweFgPjyhc6r7v+5iCyDjPcwjsbiEIhxI6cVcFd3UCQI2LPcTkQKvCzKEOYyhGAF7LkvqNxPj27Zvtpr+5uRq364VnFn23L9txGrte1et+5lCMqkRQVaDqhN3YL0td1uMwDKkXNAgsKcUUYlsYWS2IOk3D4+NjrbnruhAZ0cCUxRuiGgMejwfVnHNmpuuXL0rJ+8Ndsbl4WosqSkgx2hpDurrcMoeu66dp2u527+7fw60d5nncdLXaelc4SJ1nRIgSA2oMQcgYEyKKSMm6risAE3NIbGYEFcAAJEaRZIa1ha7HPkoaz3lJEEJQda+4LAugj8PkXqCoBHGvhnXsB+aBCcZxtLo+3B9y1nGTVFWEEAWAcnn49qefT7v+uB6uLkf40Xlwm4CjOi6A5fKyjxyvNpvLi+3Y90Hg+mqq9bGU3PVe6kPsbXcp37z/cerDFvq0CjPlWpFYLrYpyDCky67rslZf89UUnv/iD7xILvM3chSBi03M1ZH8sxefxH63Tf7+3cPnr67HcQyR7u7nHz8cLyeYXjzbbXbbzfWyZFezly+fP3/pdT4et+/v33s9oK43l4O76927p+PmxYur+3Fx934K67p0w1CKuwe4nEqpuZS+764uxiDLPM/jEKdhBMjzehw3NA6vbq4n03CxffX65Rc55+P+sbuOiB7DdHf/Jgj1Y4eGXu+12NVuqFgYOQaPYmFKXRo302UpNUDYpN1ms3nzzVeH+7vPXn7Cod/20+vvfOvZbj8M237sHh7f3T2+AZRxHFjpYb90Kb6/O0yDCcm7d3+422GMr59djZeXnxyO3XF+GMfN88trkVSOy+HIhBr7PgYOKQZJ8zx3IS2LeTfFJOpVLyuz7B+OEsqzq5HD7uqRv37zo+BrLzEiBbLb2z+O4eU4lhBN9/Pnn06pwyldLHN5cXm1LmXadKVer3mP6GB9oqFPqYtD6IaXz260Hg7H+2dXz/pX28vt9dXF9fPLZ19/9VO57IZheizv58MLYg0BSylDn/q+5yA1u4jc39+OQ3dztXH39biUJY+h//yTb6vJw8PD7TJ3PV4MsiaJ0R2OgunyonOFIKp63w8j2RXgZpwu1Lrbu3cH1U3fL8dV635MGEIfexFR8mXqaQiSFwlDqLUMgWSzObxbWZLNpGs2M2EMHJKIEIBbC4lrmoxWcDToCADEJn1t4WZMANDYiKeCg7zZLdzNnOgUr0vAgiECJz/19g6uZFUtk1fH2iAz7Umuv/1n3R2wmWYBq4LZejw4oxMa8VLyI9QlEV1OoedPNi+F0er9u7ew221fv/x0t73su+7RH7fjthpe7y4YLtiAcV5qmsaL7eba3R8f79VyFyIRL8u7GMYXN5/EsFmPPx3TdrfbXT3bjmF/WO7NZyCtlV5fb2PYEIYuhr7v1nXZpL7cr3dffh0OAPvKxcgxETGyEzoGBEIRlkhEBnri6yAhALP4CbAhTgyOhtASfs960j8hDnX/INpl5n/9f3b79Kd///+yKaUwB2EGUzhFEkKX+qKVoAUpOzfPIsMe5zUs44tx9gcn/+yTzzzH7XCzLt+gL1e7TnAx0L7r9/Y49ANxP4VN7PrmhkxREJQxX1/2qZtFjn2c8OXVbrqZ53dAh+fPr7Y9H9YqWJEl9cPxeBzDpksBEcsYvnrzdV3rp588Xw9Hsg4sHw4/207DMh/HXl/c9D97fzcMYUidiEzTkLPMPQLYPOtxfyDaljVvpk3cdOMwbvqBxRA4RiMbrq9ernNlkJvr53ldQ+C7A6Phxa7fjAHGMcTr4zzHoNXDYb9cXV2Ah+Ncijvv1QmFoChZS+UmnJeCCP3QgxcAQjfhjByE6BCcWZ0qtSBl1tQHx1WC92PqNTB7jLGqRZVhGB7uZ1PYXU7T0MfEl7sxJjbLqePjCmNPfDWqBabgwG5e8yKdIMJmE6bxIoT0+PiY84JUxzEaZ/V82M8CDkwEFALPh/1Pv/rhdnNhVrsEjsjZgCJ0cjgcry8v3fKbb366meD5TR/iUWsptB2GaUjD4+P9mh+DLcgWgqVu2Iy9eSHKfY8AsJlC13WoUGsdO7nY7dz99vbe6ipRmLGaleJ9p0Pfx9gxJXeo6iwgHb2/qw8PD2yFSOLAyQWYDTEKO2iMkciAyrPnz7oUzWycZHfRqc/H+bb6cnk1jVN0h2plnmlZliCp7yLbyenVDSGEUE1XnZWo1hxjCJ3ksrT5aMfYDbLZpnVd7+8fTcmtTOOmlFJK6Ya0LkXnFYUkOAtuprSuxgEkwrKs6BpjHMfUxbgZx/1R5xkkGwj3GK6urtAp5wowpg5fPN/d3uu0dzhHkFxcDjdT5Ail0tXuctMNz5/d3Fzs1jlP06DbILQclyMyz+siVa9uuoeHr19/8nkM3f1dvroc1lK+/PJWnl1eTH1sDBxxEeo4pNevP90/1OPyfjtoLUvqQq3pYf9+7GLXhZ//wffn/bLZ7Iauz3Vm2KG+lgCb8XmU3W57sy66LIuIjOOGv/je/eH24q4fprSdiGgRkWn6AOLYbjZXu3R/fx8JKlYWG8ZRJNZi87wWrSKS85I6qtXdq6OGGIE8RtntLi82+7zwbvPJ559+ez2sP4Mvh6GLMSrWYcJ5uWO2zTal7mY79cXKJgIiB5bAMca02z5Lcfvu3WPaps9effb27dtvffrZUo4ppVJtN46vb15O074W6PsElAxjSj0LJhy7rkv9eHE5VF+Ox/2aZ4V5E1TZMST0bkgxxY0t0m930mOMYc1zTEQE67oCALOEkEVo9D7nHLshAFLTdtNCJCGlqQ9WD7tNCkHWZSEm5rI/vhs3dH9434/Yw4AAYyJU34wxXV4Pw5Rzvr9/R2yHtaaU0BV5ZaLNjl7h5rjgZ68+ef78la7+5mdfpS5Ihxe7cZq24bh+/zuvczmM40iYTCmE0DxHd3fvU+ynsT+FNVwxAPXdtu82d7ePu802BpvX9yj1MvQO67oawHKx6QFgPlbyhTFE7sZx1w0Xx4Neb69SmImWi8uxlrUfvKcOoAL68fF9CCH0QsNu6MZ1yZHDtO31/gEgqJN6YXAhDkxwzuOFE9rglO/78QyjrVFawUH0wauStQoSNRTHGbAMhOoIxEABJCKxAYA5grWkA0BT1wZY5k//5lNPD6AtcLZ9S6q1aF5yeViOq9YqGC4mHHom0fwglCLKq8vdxZimzfbVy8+q8f74DbJtd8NxnnOeCThEvLraMW3Ag5Co+hgHllE4lqKebDdd18I162ZzzRIx6MuXz4N+9XikJWPWozt1aTvESy3yzftvXr58+a1PP398//ju+Obu4U2niQ0DhiBBkBwciEMU4sBIIEyA7kjujV+KiIRSrDpRCxX1j0YWTe7X/CxPNKS2q2o4+f/h//zx6b3/d/5PU21R0s0aacCIQcRdS10lBCLqhmSENISlHhctOixxwyGBrSSRby6v8h4g63YT5nlOJM8unq1r6bpu5IsQgsiUUo+IwKR5UT8Qa8lzGie8P7x9/82rF5c3Fy8I035fQxo2fQq8G9elE89VSeKdl7iLkUlEqma3/t3D3bOrT7pnzyLynNcgtYsO1W2IqZsejvcUOPHYemXmvqx9KSXP/Zs3ddHKsO4mvtxdbzabFEAtE6pRv+mmlHrrYRx3r1++muf59t37kMZ5XrvEtSwx4fXlpk/cByHp3727HYdNN4xabSn5dsBas1ZYihU1NzDz3AEApOQMOgxdCkwoWgExxDSFwCy82e728/G4LCFITJSCbKderYSAlzt2T7cwBwzr4aHk/OrmB89f3BwPd/uHd5efvrh59uzx+JgiT13Qistaa7UY43Zju11NiUspInEaeyJZtuPt7ZEF+qGm8WJZ1js08ACGANCnuI6RuAgtCiVFiyFYH5ATguThnmj/8vk1IXgpMcaX16/HuHu33JvymKbr3XS/6e8fbg/zKhK6ob+83D7ubxHKMA5l4mHoh2FAtXVdUwi7TWQOQt4lAYBSleDRTa6ubqL0WmG3ffbixcv7w+P9wzunypjB8xrRii3H+4spaRfc9XB8yHPeba62227qr16/uMk5u/vQYZD81U9/sn+87ad+HMTKHkWGDktWgjUGYeLNpiciBQIAElalEG3JUBYMEVMiWAEEHGoX03aXvvPZp6bw5ZdfHY6Lqu7GuK6e2capf3QrayWUfhPGvtvuxuMRNmNfSnl4yKq+mWi3DV2MfYJqeH29ITo8Ps4x8re/9Zo5fP3V19vNxXG+H7swjZ9c2xHgD05zgWcX9ztf1r2ucjX1u+3m2eW03fQ12m7XlxK78LJonku+fbhd8+P+cPvy+Svm9Wp3eb0bfvqzrzfDaOVCrnYXj1Hevv1ZqTqN2xS642Hd3z4CJAHYboZ19hg7GmMp67quDMvQb7fPnh8e701AGAKH1598h0mFx2dXX2jlu3KnwUMI4zhqUfASxcdd7Hpa1wW9hPBBnb7Olp5thFdVayCpWitCGIYpxn5dVwdQq0M/MYqD5tJAhBtEVtVpKHG7CRQT+3g1HY+Dqm7G6eH4dYw1l5kFd93gFoYBHg93gSNB6mRECCl1zy5fCvdaIsf0eHe/24xBWK1/PNx/9snz/XHJett3qILdaE4C2HGEWmvHaRgmN9y+enGc779+Y5tpurq8TIDLYlZrxJCGcTNdzQcL3JOsiJ2CIzEJwqKmJUpyegjEea3g9XKzSwxrLTF1NRMiB45xkOvdy6GXLsoqpdI8DjtV3R/f9bFH5hg2QSZaZepFCK8utkhDXh+H/hLJnB9zOZQ8O2Kuc4xxu0vbXUgdTwO/2b9Z69tE0+svrrTQajMzbzbjspTtNE7j9XywUgoipNhdXz5z92VZiAhUJRAiCvZdTMKP282kDm++OajC2I0hbtZ1rpq70IeQOtE+TeBcIB+Oa99vtuNUlbt+l8s9+CqUEAKwhBCYGezrFKjWPAwxEl9c3yyzMQ19sPtlZeNAjNAoA6reLANIRLWqu6MQCz/hN0QEhVG4OfRPRQULAdQ1O0JDuiITApEEIAEU4IShc4ot3xRNQXPRGb2SAxgaNFcZAID/8F8zd2QGJDd301KXOR/2h8ev3n19V+bp6qKbxuKr5Wpeoq91zhT6q4tLEnImRb29u4Vwx0F6BgdGzNKQKZCHrgOMqr7uj2q5j1NKCVcV6KUbiTuEEIB6UESbD+s0DY4Lh3UiASD0TiBx6BRqZLneXNz+8M389WOoiKWQARGcsl4IUURiEongWDz7KUWFCN3AEUEJnpLS8f/H1Z/12LJtaYLQ6GZjZmstb3Zzmrg34mZkllIFRSHEAwUSqkJCSDwAEjzAD+C38VogUKGS6qEkJJAAFWRXSSmLyIgbEfeeZp/tzWrM5pyj4cF873MDk0tbLvn25cuWzTnG/MbXfBk/vY1RAL8qYL9qZb9mY/6P/7ft68L/v/3v3o0xWCA0IsJ9hHsSZkZG0WElizMC06ZbcFxJMWFHrcel6WWuS8D45ccfEs6Xl87Vl2l2TR8//Flrtm1bfqDr7SK0LPNhmCKCIrTRcxEkDR1LXV74zCjLkoQTy0xspH2qwlLqJL1pILGPUsrhcBCk19eX/JtvTy/13XF+d3cfQzXuhRKYHw6H6VDb2FKZ2tBwKSURwVQLeuzxjXOOW2/HOj68l4/vyuGQPTqEEElKD/ENvLycl+kwTROzZZGnX25FLJKX5AidgKeSKbxwyvWhplpSXZZFfazr9e5IDna79peX1+fXSzdbUkwPS0qplMIs85SmnBJniJzLfN1Wh+gd5nn+5Rlct8TptBxywloE4lyqHE8QABQ+eiScwvmbd++PtRY6RL/4aG5tSlRSSXwEgHVdW+/LYTKrz89MDCXHtnUmiDC6S3fzxBI5S62P4Tw+eJJFh21tn7aYAYbT8/NrTVBrzrmSTAhpnv+pjXUpCWKEDyJPBR5O79LzE+P8cPwoPLX27VB/Offz69bsp/uHY5U29HY6ZZGaWUQSgrrNRClLpIT13d3D3dLGIIDTlBD5/u4dQWqb5lwnAbkrCReHwbBZP69iZpZle/fw4V6P27aN24/mr+/vP/zuz34nPM1Lul6vYYM5NLZ2/THT+O79Y8m4bT3Ajvdl4qgwpmn3a1kPhwMSX9fVzJDpdMSIIvA4xkCm69W3gX3d5lk+PC7f3T+UUu5rfnp9eXl5mSbuQjFn4iinfKqniCCM02F5/3hH9HBYptfz9eWlmMXhMC/LlAQZI6IuE+Wck9DtdmntZcrlOOPWzlPlJPCbb//sfbSvDcdxzh8fZdtiEn94OM61FjEdL4lHTcfC6bh84+7Pl2dhsH618czQhLbDBLUeGKyW5Tfffifruo4xVLXUlDIzFR3Rm87Too7EWMpEPE3Tcv+gL9efzcyHygx1SrkAAA0pQpMk1M7zdH+9boCC2IkgwnLO0zSliog9NOYyhXvmPxl7h9R6//FDCVAi2NqlbUNN86FMKQmsRGQ+TPuh5KGbaq81lzJBsDuUUi9nBYDL5XXbOgDc3z1kzpOU1/WFAxLIoZ7GiBg6PX40C4HpMH8Yzc0GeDiNwyxq5fHhW3TuowFuh+VkPh7v7lFdOOeS0YMRp1xZKE2pXeF0OOoAGAED7peHUgoOpuLMHGpLPQqXu8NdyRZOY2gAUECojRE2PEuqufRgtUCQpTKGTGV228iQSMIJnTnlw3RPHDXPhXcxVYYKfRsph6oXuv/m4c/bZpfr5/1gjeC7FQqSH9Pd1mCDwYw+IvNpqjORbDfcrkqGp9NpmsqH99/8/OnWb17LQfUCtQK6uyem0QxRz0/b6XSfpPZrSySYaN1eREijSbI6G8BFx+0wLwDHqZxS5kxr65tAKjwfjpkw965pftluzSO9v//+fPkFbSOi9daXZdrWASbffP87Cri+bAR9Pkzdxugw52OR6flp3a4WA1Qt76SBCAcnDPfYnbAjzN0RWJi+whjMDIiAXwKIIuiNXYq5FvAAgC+O5oKckIm4oBSQ4igABGDhA7Shr+QDfOyRWfL9f/r2FKfdIp0g3MfoY71cXl8uT3//wx+ex41P8/Ldgyz5fH3tmzbXQ+Eiy7v33zRtl/VV9ebrZnZOiZJUhiTBtRzvT392uT5tw7uNnDBJznnPwcjM8zyRA5kZEdYst8tK3lng8vxaJyGClApRAiDrTCSH6UTZbq/n898+//T//WP76XriktE5AwBomCBwSlQEhR2BIMjfjEQBfLdB3m8gCO0ekUG/kjYiAv/knu+QEnyZXu2E0K/rPue8P6J93VRDODM5EwghgJeaRTiEhmuLsdmAk8zvTteepCRASn4zv63bOR0T1a7u83SiODw+fNe7Pr9+Bmw50LV3uwAQ7MZMiGZayuTqh/nIsAgna5c0G6Ndb+uUMOcMFGw4l+zume6E0nF5TwzLNK/9+u7dOyI61IlSAE4A1EavS/XoqZcP77+/XG637YoIwpiEACBRBY+JWdGu1/elpJwpZ43AlGpETKWWUpZph4q62gWZjvdh7ofDPC+1lEwEwpTnRbNSyofpPQDWlM2kkL7LMwteL+unQnOW29YdYJqmZVmIiGgDH4llrovwVKfj+XrZxta24RBjpiU/muE37x4LB6GhJOLIBQA543F0+M3Hb3NaKp3AR5nr3eH7rpd+ey1zYYA5EzEUkdZGngCgMNyVUo7Lst7aHnDPgh8eHnfL2rWPWg4lH6osY9j1+tp92ymcJS/rh49r2xARUKZ6rOUYLnen5fr68/PzD8Tx8Hjq2j49/fBY59Ph47cf/twNX67PdS5q9POPr79cNBdc6mHdvCRYllJyNjPCypwIkzshkKSCiBoAXX733V8i0PW6hsH8sW7b7Ycf/+3p8fTulIKk5pPQuFyY0ZbD/Jv3H0+nj9fr+tvvP962n7//5v3Hd/9k3KaOl3Y8jHYN6Fs7//l39xrj2/eTEK0tretWaj7V9HhMiFhy7gMPh0LC6wqttQhk5pTK3eGDmXnEp6fPvWvv/TDNd3cn7Gsp8ptv3r071cvjfFvPZgkY1Ji5MJ9aW037cZG7I5yOy+l4//Jat/t7ICYiSUHY1No0L63jYZ7uTvXHHyP8gtG/++b+5eba1w8Pd999/Cb//PPX1fpwyvZhUSuqd0lKgIkokmdSxFbKfHf8gJSKlMxYU0wVGOHhkBFu3vwf//b7h/tvP30+S+8dEKZpWo4zEYXHsiy1HBLOOl48qJYyTFoPlhmx3h2WJGXb1pJx6DaGLss34Augrn1cr5sbLMtCHJLg+fJZvNRal8Np+K2PlZF8eOFfEY5pPm5cTsd7QG3bBd2qzOHEJhE0lUNKfLlc0KVkJGACzJIYiYJSKc3g7vTYN9xWm6YTkSBInR6EcfQ2JRnDUiwE1AGXKW/jlvj48d1vbrft5fXT0OZ6i0DGI3NmqDW72+rU1G6IIZHApNZlqE4klOu6XRHnxzvZtpF5KilVSdt2a63VNLl7kQQG0zSvt+auJfHTyzOhQUTJmZl775RLLSlLyvzRhs6nmlP65edPuda5zOpjmnlbG7KIyGG5D2tMWdWO9WFtPRF///53v3z+4yxZW7qfv9MpLpdrnfDWboelHk7L5fKaMsc4TEsdZWbC9ebH+WMpd2N4qYZdioQptWu7XVDw8ThPRJ/PV8k5m9nl+lJ4Buwpk5DcXl/ev6vfvv+wrlfAgS5IBuIOZ8nR+m3drvN0xzjndHw4PewIByLmnEuexohCUSTfHZn8QHAqIr1t0eNuntv44XR67Bt7T5fbLadDSgOwUzgRrWs7HR5ur0+vTy8T3zdVDoMwQgegN9qnmxkQ7dD9W/37alQVgV/g/bfq6AaIkEs1G3uYFeKuTAGEt2BWkN1lHHYXb1cVHBAddsD6164ZjIAcEADMdfTtdr1cX55fn7YYj99+zO+PKvFyfkLy5TAX7SlXoASlvJyfL9fL8ZjIB8NK8O2SHxPS5mfUQnqK1rW/gJD2hJRKmUqBQA7ILAX8xoDXy7OlXIsg0hjroaZNm+SEVj0GBGNKczmc7h6Tbn/7w9/91X/xbw86LVTEIgkTjkjs6oCUa6YqBu7mEW9+X4iBKLjHQ0QAU4TBm941gL7ycCP8jToqIjnn3bJsrzf/wf/mV+bW//s//o2IEJF5H1tDxJJyInQbEQoQGO6hkma1zilbjOP94f67DzI+rLeLUXp9XUkkT+TSofZiJadS80kHmIMkeL5+TlNwB9VRyyEcJQgobbpNZUlM4fLh7p4I1n4uHCa45BqgJExBfbRpPrjaVCsamvOcp99+/2e///vfD7DeuwR/ePeud+mqpQYwXjcl4sLZBHiG3lup7KOHe805It7d3wVWP2mA9r4hBQRlWbatQbTwOB3T09MTgB/u5jHGx28XH6WWY2AiSWM0cD8cTmExAkpKt+sGQUWAa8lT9rByx0Jxdzy1oX3YsizLcjQz98toW0m8TAcdyCIx1ZJkw/MvT58y9PfffLtt/d3dVCQolMtjHzdJQezHerxd9TC/y2np61wLP7/8LCm/Xz7ebq8WOsZAFCYOUVWL0YjS3XJ69/iR4f5+jq3dIqz3XmvdnfKf1r+b0iGnA1OtNVLi1i8Bo+SU07SW7n4Uka6hg0xHKuvr86fb9eXumLemCfP7b75jmvv5NvO7u3rfxvbL59eLbmWej/c+nz70cYGA66q9XZaJDnPeto1TEq5JpnAZw80hpSQ5HfijGxDlhwO0dt221yzj+28OIXA8HvoYNePdabpcF4/tMJc/e/j+4zd/+fNPT+8el8+vdjrINx/uL78UzznCrtcnwj60vH+c1n6ZplpSdoBPP3+WNKWUVbVta61V6H1Ke+qk9t5vtw0R53lJRGWegDCRjmGJpZSJkexqHPrN46PDQvz+Dz/+vUePMObFwgHicgWCOk+FIzK0u8OEEbAUTlPXEbABYB8mae4DLqvd3U/LjA/3p0x4XA6/offn1+e70xyjH5fD1wV7f6pxPw8ld79tXVWZMWeuiUe7kk3pLh+W+3AdemUah2Mx3dbr68fHkw7c1vPh+3/sQ8RQS5k87t1QqEqqJd+Njk4vYwTnOZfFt27hifKxPkgqQMbCI4xoPhwnhNTGLZzneXYfktJtXQkNgyWYaam1HKbFxnruz2YNw8J/DdWsMk1SwxBiTngXi7yen5FitYugHA9HB0hzFpTL7Wf1cypTrR+EFrXGBSY/mEpKFGls7Rwuv/vtv++68OzlpkPbcoitvwJuh2NRdR8EiLf1nEs+Hpdt25hLznU0Ag8S6H23iJNwToW2LQCUYFDC2+utlDRNU87p1lYSDNHp8N40t/G6nBywsZ08+uFkW3+KfLlqY5w5IeEBQYSrmeXZXu0JJR8e3q3rlcshp1mtT/d16GYKKc9jQzdLaBxYU1Zyj0FJRwzJGADh+Xj3FxAsp/z58lpqqtP9uq6n0wk8tdulUM6UlQFgRqm9b9PEy/1BBPvrFcWbcWCSPHdfP3/+/ePpu9E296c5J7PDMlU3UrXjYZYE4AXxNobd392dLxdJycg11uynbdX37761cZ7LclyOpSxt07V5REYSETH3tVnOGVjzmLdto9Qu27+F3cKZKnG6W77vzQ/L0toVaeRCRNMYYrFOUznND/0M1A+TAmpPfkXDfQqAsKdRRwAG7m5MIbjb8wEnQSJzR3dwwXgjfCAhiTCzj+4ODsAYgIrBDhLEIYWQCD1QAcRNiQZyj+bhvofn0Tf/yVv78tf/AxgcApu21jfv1/P1ddu2eZ5v9+n+w/sButkGvIUgz2gt5XI0s/X8XAgGIgznnDinhIQ4gkTqhMhP2x87dEon5J97u1VmlmTmSSAJpyTe3wP6oC2gOyFwNjUHRB5ElqSAlpzuXp9H5cdv3v3mn/3z//rv/sXf19fxkGuABYYHCaVtXUupZZ4wZdMQkT1HEFncPWA3uIavaTRmyJwI2c3DgJIEoapjGOyG1V+mKsIpSf5v/c//5uuS/9f/yT+uOREggvdudJi3bYMYwQwR4ShSqAzoQasGOjzgclguYy3n693ho8hYdS0lAcFUirsGMFVlyUPh89NPQFvXF7QBW8mFEVrE1YwO87tp+vb1/DPhQD5++ObPt9XOl8/zkru/IlMqmShYgghEMkYSeTMaT5CbP2+a749/sa5d+dP58umXixR5MPDRbynzxMh1HqOlDG6KmNAopQBaW7wmOdTpIZRKTaqq2i2AUIiEcTArho+23R1PqjDzoqGtby6bUEopjWHCKdUU3lnYFcxvy5FMDWKu5RRhSYxB3j/cjbFu2zZGIGKhlOvUtkdIsId20gFUG9NFdTBea/5m28Zhuc+PmYj6uNV6AoBpOiAG4PAYWRwh5SJTzVmOkib1lwA9HhcWu64/9nETOk35XU6h1sO8lIkImPvQNWVAmA/zN5Kyw2Xtn471FCZjjIEri6YaLDR6AXpZ+yug1KmEj0lSOS2jw219arHWJZVlOjzcEebe8eP73z7RNWf55fqHdXsNWglJIB9PJ6aytXMbz8c5hT+ICHMq/EBydS2EC3KiWJGT8OJaTNZ6WBAQAELCGCWWiDlnQopS8x0eEHld74euuWASXK+vp8OMt6f5u0f3sd4+5fItYp2m6WG+39pZbe163toLoB6XjznX+/qby7p+EZCbiGTCnLNH72P12NRW955yhB6YE2J8vJ9aPx8OhWBhPMBDfffu47vHb3rffvr579/ff0esZppSVh1be53zkRmZMlFmypd2NrDlWGqF9dIBcN3gtDyE1QRb5c29P84LYZrq/Twdl/nuevzUx03jlur0dc0WuZ/KXeamdsuSujZ3JZbwu8PdIfFyG7fYBELmcj+VudtPQ6Uwh0vOJQl9fvkbM5O5viMil7FHTetARoeQ8+3s6DUXSSyeQBXRa620mxns0TjuhL47+UhGt7G2Z2iwtgsA1DqnlHJ293MbTa2pPwFGKlAPvx4OCdPwwOjMlkr05rv4GMkBTXUg51rrem6mMc93zOV20SRWyqR9hMvp9GBm18sTgAf0rT8R6OX6nHN2dx2Nadq26BueTu9OB7mc1/PrbZ6BOZVMiMyUFb3kKaW0blezUecUiOt2QUo5Z/MxNCBYeDosD713qtnMSp5zOjilkg2wc6K+2f3xsZTy00+yXinSgilBOAsyE6FLBnc73U067HJ5dfdgyQlUu1qLGICwHPJoEutgEgiK0JIXYl23Sx9XwkSUCYVJItA03Dqg79la7q6973y9MYbZLhlwZgSGdb0CeGubxzClqR5zofN1DHWWIOTn8+quzHtiYoE3BYhHRC4SbpfraykFyWkURjjM72hJhHJYpLU21UPvWsvh9fJjKSXnrHrbti2lwml2d/MrkFqMl/NLRDAjCQCp0HdSMQLHuJrbHhBKBKWeQuP5+bx+vm637etTY6ZvPNGAL1lgGBEi8pUuGl+uf4D54z/QxxIzMEIggiMEAAEQxD4vYEDGoEB4i+QE2EVoEQb+ax4QIEIiRAg17wOBl2XBzAP8fkq1Hsa6EZapzJSoyoI2Wr9BoKTyp1RW4Rp46drNwtRFMhERg4isDSGASIjY3zgBm1mclmkHIjwkwiIQQSBgrne39dnIpmnKqf6jf/Sb7Wz/8r/4Z//y//GvYbVDnsyMgCULIzFSZdiNHUN3xGJfFzBsbyBY5B+MTnYPR4e3FPM9aJ6IEsv+M7s+yN2B4U+7jX/2v//tTuBlpADLVByCCUopEXF+flZ1ZnZvAcYFOTMewCdt1+svL2a+DW0GKok8KMIAgCUi0vV6znkgtev6KaV0//Ce4mixqW1tfL5er8jr3cM/OcV3bYPgm2rv46Z2tnF1GEmmxCd3U9sQOoK5R5K8byPbrVmM56eXKU+11rWVnGdT79HcdVdFATg67crf4AlzZmCPNnQPmSkISWTBwPA13JhCMudURCgsBXbmQGRhEsnMiUj6iP2XRzgAm5k7EHFE2DAiEkkECQB3IaikFBGAjDiVAkxZRFjocJh3utFuzE9MQKl320YqOd+d5pIXVeu913w6LkeRxExD13V7jeiAhjg8WuIlZUZKayMPIEwscuTH3j1JAUCEwYIEkVIVEQj3GA7OiBZkgy0u5ptw4pQ8uA8bw5gjSc2ptNGZdlfZ7g7Lcvfu/jcEh+fXv1u3s/lG7ACB6MjDA8u8EQkRzVwlgRvVcpyne+JhgYG58p3HCHNm5poCDoMiXIiQpQQYxC3SDaOg2x4BnVkiSYAREQIDOgAQCiJTXcxl90w3eO5qSB3iUKQIzbnAuv2yDSGiXJEdfPMUDBDCdZ4Oy3xa1tXMfI+PEGIYbm7Gh3xHdHdbz1u7EFCdTzlXIgBwj7tlWUan7RbH032tJWB4jFwolYUFVXVYICdKEjAAACFBMFFGt1w4UwYl5kQELMjkANI69U4eHBFMOM10POVtfUHSOqUseU9t3S9JxuIIlNIREYf3iJCcdz6XmTGZefMYuUTKqfdvet+yrCISgWZm3gOGhNWUM+HovSPJcjwSluenc4ClxETgESIUe+YkMaO4qxl9kRQmBBKRAHVoXQeABo4Ids85TapbH43YEMPMPIwovRkgAwBA7601C9yQfILZ1QjBoamFB8UahKWkIyIC8OgEIlO9n+rJ3Vu/QkjJR9ex8SVlNhtdn5m6cC6lAvDtFkLTPE05Td98/LN1u472vG3b6OHiRERYwDNCV1VJVIrc1tvt1jw2dyVExNTb1jeDYDeZ6v3orxG9902EtnYJF4/e+1nc+uhlUK11mR907AN938cK7n69PQWo2nY63osUU1Lt+xR85/Crre6ApNO8IC0MGBG9d0ISNqLNvQc4BKVUOU27JgoRWluJSBKZDwDck9m3dtvjaQCAGIJ8a1czQyDz0YfXWpnF3Xu31jYdwzSQOEkVnoQnkQrgY7SARkTDRr+el+MhAoUWjnmu75hlXVvN5bgkVT2vT1Cg1hzhEfaVQujuYwwCKmUSkW3bWmt7z4Eo7k7IY7SIgKCcjimV0zJfbn1YW2/b9XLrXcMAzAjZYkTAmw7irQn4Gsb2ayfwpRH5k3jSIMB406IQA8lbEFcAhgUyccaUXTLSW1IieAQ4eoQ5QcTuF/SFveF/9R/sclkIEOJJsiRymr1f2nblcjo9fLvc0zq2tZ+RfKoFY/388gQASPsiYghyAx3BYmOEWSCipIKAER5g4UJIIjmnjIi9dw+NkIBu3gM8wlQVAPacVQ4/LPev2+fuVoWE0o9//ft/8f/8l3KThYqPFkh1mVR1bVtzmA8LCee6SE7h4BTILJDD+tex1J/2cCkli7cHm4g03sYoX/Up+IZy8L/3P/tr+JOLU37TPREhsKofj4up9t72TGAo7mhmFhRewmboqakopW4wLtvrsBCpAW5mrRmAEwNRYfY9qP3LS2dC6d2E55In95+ut1+eXuZM3zLddbvc1nMft8Cb2WYONSfCKolVQ62ZqZkzFQD60rPStm1TUWHBzrVM7kDozEyUzAzQ1YYIBxh5KnkWEXNBNHcXnBjKVO6Rwh3cAtEFJWUmhuvrzVxZBACZkxsRCSHWcuyjIaJIEAlhCuSS5vDWdHXlVCrTWyAZM7ttZsPDkDhLYcpEAuDmbd9h9gUSMNSa+ZYS51TuTg9J5t58XVtKKScRycy4N42qRrw7gA9JZL71sbb+mnNOUlrrDunu8D7CW18jBuFbYFhrLSWIsIAOFAHW1fq4mm+n5b2IePAY7PuhiAnAIRKAu2uEM9WSjiU92JhLujJVi4vFzX18gdl6yhQORMSUEHGMgeQBW/fm6CllogL460ZEmBGvYzSRmmQy89Zv5N2CEPcxKYmIRzJ3ZnRDc0fc7xrlnFlShA29Obx2u071keFjzXdDN+IuoqpbkpJyRUVGqelAtCMnwUTMZKZCgIimnVNvvSPkw3I/TYvwQeiVBae67EWhlMWDmTMkpIXmuUT0dRu9t4CeMudUOyqJq/aMmRjcwB0IMwAK1GkqETH6TQp7bMQ7J3IQWk68m9VGRMTW+/P5+rq1teTqFa+3X5kPKJ3ZCGQvCuYQYZyTjXXbNkBkQdPWx2a+WSjhbBZJlpwm5oKIO3gjsectELeuNkb4BEIkQ6J49K5D3ZIUIgxwfCOQ8W5cJiK4x056xB7Q6p3YiM00IjBJHQrhRrDUUhPfU+wuUj98fSfX9llDIrqNIPIkh2kq5jGsM0uSFCaIlAs5TNfrFRy+++2HJMsvv/ySZGIkG918pMRIVQlUu7lZHAAhpaVOvD8BksrT85kQk0xYWW2NcBEh5NE9Zbzdrh5NEoiQuSKk/chrirUcEgVTSSkTiUg2tcBuQbf1CSJ5eNeXbq2P1aGZ38IlFQUMtyCSbVUPhS+ZVQCEkF1xqjWnGUKSTB6rrrcI27bbVI6lTBRkGpCKexvdksxmyY3CBTExy9BmvrKQqiZKEUYA9GXfH2Nj0d1hE1ASF4TElEuZWr8IB1Mh4uPh0d11xLqupRxYMKcKIADClNS23jsm26tLMItwBMzTfU7L48P7bdvcRCS9e/zw9PR0OJhHn+ffvL6+EkjKCXw1MzdKkjIVd2fgmg6M3WxEGFNu4xMA9ea1TgJVeBE8Pd79hvGnq99u9rP1FT3MLYZFwJdIBdibCAzY49IBnOIL8P8rLLFjNG/0AgwCZGRB2j0niHAP/VMCBsmQKnIBFkAGAAhDU3AFVwiDMIxfl6JjcOx2YZCYU51ByGAM4xWj+YYZ5rL4JbZxQQwPNR+Aahq9x540JJLdFSGVtCAiozOnqcwQ2GJEYE5hhExCREyICBHOzKrauwK6e299Q8RSCiL6uil3pCCi8/P5hz98+sO/+vt46gvmpWYVLIkdYOtdUpmmaZomNQckoES8c17CAXbM7A2r+OITSkQOgYgppVqriGi8NRl708OcdgLHThr9ev2L/9NfihB/iU1HAMBIORFCazdwlUQcYhAcxEstD9nyGNDde60ggkNvrgiQCROjALiDAiJzmuo8OtjoD8cPatv10ktmVU308P7ut8fp8nd//Nc//vjjPK2H+V24rGtzd+YpLNzMjQwHEROB9d71TETqu5UFSmKGDABqV/PursxJJFSVOCVJ7g7A7k01zAeCiAwGdHfExIgQoqpSBQiYEnNyV1XANUwBQMJVWIgkyTS6MyUUMhcCYtolPyxcCGvJ1cYFRJKkPfZCtbsaOqmd1Ya7EwZhjUCziPCgEY5fI2Dw7fCKOeedPu3u07SUMjPz7XbbDzC9j/1jR0AEJspDV9ehtpmvkvI8LRAFcBI6mvfwTUcHXNkZUSEyhAQgAHgMhDDv23YZ2jNvEExc9vdLDGbatO1PuPCEiOHsxtu2jaYesEccj2EeWmtlKuEGUYEQIQEqgiI29Zdt3FonZmap+26QMiNF75viBtLA1gAq6R64+OAe55z4eDho594HEwXn8B7u4ARuyEjoEMqE4N7aatFYIMlS0v1cvslpua6fhr1kObpuCAKRwkFoSSWllNTWiNGHmnZhLrUCwO12W9vnrZsweaAHAJKkKWUuZdq2zd1zKkNxvTURORwnt7YbC7kPgA6ewxyds1CoQTgHIwABEjIAZeGpVjMLVxbYbo05mY6hDRFzqnuqUYBF6NbOdeKtaYCLMOCvIG6YERFiJagEExE4jrdnCJGZMUCHE2YSav2W8qq2iZxyOh6WdyUf1/Wq2mWuyXUF7IBb6/bzz63WWqfSRyGg1m2oI9hunkokGMicItAtmDICqyoiIAo47Mx/dzdDTCSSc8E9FoupHu+P83Rqm/nvf92vzV84V3cHKKUsBBkxQH0MJeGpLuEZIjlsOQvCKckcEbfb6xjrsiyEfr09E1EpxW6DA9FFh9/dPc7zDACv56fWPSUCiG29ieQII/bESMy5sFt4jKnk1r2PizkT0TzfM5fr9dq19WbH5ShTQiRVvd0uiJFkyeKMyQwJOaUio/WhhGWfg67bDRHn6chQwhNTwdBlPnpsamN0mMo01criSeZt1SQzsQ3tVMCdetNSipkhyuGwbNtt3cY0nwYY59TbWG/bMNvHfl27cEUnxj0fMtzN3YlBbaUkAcgIIgvnSliSTBB0mKsOx+CH+ynC0AOhoTAzSc7b1iBMcHRrzS4YYOpLXdLEbV2BKPO840zbtqkOIr5e19YaEZh11MeEOqWCFM3XsOEY07JQTKNvo7t7pFynOquNCGv9wpQDkGhG2Jt7H2M83L9vt59vV7u+tp2lYABmkYX3ADV334PE+A0uDqTgP9FkYvyDCYu7f5XLAtHuHIFIQRHGgYKUkDPu4lgACAMzcAvvYD1cAZy/f/PesH/73w9wiAAiU2UgJAqzi20tDGoKWj+9/gGd1/Wq1lBibbBtGzMj+i6M2fEDkTzPh6neR0Rra3i4IXPKKRGRmOkIIlFVVXUbamBmlMsO8EaMCFMdHhuAS9jz0/Px4ShOf/i3P/7df/nDtNV307uDMwA6uGoQwPuPH775/s9SrdttfXl5ud42Gb2UqdQkzO4++grwVeLztV2GrY1SSi1zzlVEUkTTMcb4ctQmERFOfwpv/PP/w58jBiIGeOgwBoJgxggTocf7U+/9+fza2+AkYEiJsBInhAbWR8AIcykZgkqes9wBiPrY2tmjhzOhAGgEQjCEQLzFVlkj7aWm43G+4I0JYWgrmXQgYa15MRsAZ2YCaq135M3iYn4tdYZoXbeSK+HsTsS49ZdwEq7uzrKfstQDA4aIFN7Lfxqjm/V17UMbeAgXQnSzdXtJWQhcJJtxOLqKW9SSOpEwvSFeAIhMBGYozDv31jSY9kLLiJIl11KJAcAh3J1085RLBEIM5vTFHmXPHcW9AsObFZtHoBMEBiGp6uhaMtQ6M5P7MN/AwN1yqkjJ3RBFKEcosWQRRzGz3jVcmJOqeli4RgxA8/3kg+zGLLMaDO0pBXNiTmPYetsQpE45SU0yA9gYF/ctIiY5zdMDhLy+vr62S8SPwjll9jFUtW0GwFlyKhOjq287imMGhDklR/Q994c5V5mJZIdRAYIJPSIzGJoOsxS1pFrnuK7TtBwOh7aC2Y7VZYCDuwIBhRE54v5Bwxjjej0DxfHwuMzvwSciGXpBdDekEMHdNt3ARxacakqpnLe9EQQALGU+HO4gCKK8XD+llJNU83G5XMbogO4e29Z77xGWUgWg3oaZ9XEzbUxSSkmQodlbTCICmbODO2BAIkJ+c7oaetmauYO5sokOAAiIlNBEMiJDoCROiQF1jL7qltIkXMysj1+plm7BJIwZlACABcPBdEPylIkRVTUiP9x/mOfldrtGPHO8JplKqglLwuwcmauobWpXtdXMDvMJqfbRet9qvUeylEpbbxgIjsSMAQAgIqZgqm7A/EVqH06YSy7EEHbzMQBgjA3iFjTU/PWsra+tNQSu+ddDDydG3MuGiMzguCuJw9R6grkgsJp5jLbpYbmv5Xh+fWrbIIYIUbetraUUoiN6YkrCidDX7TIvZV3X55dPLB6AEZhrMd089tknq7XL5XXPHxfOOdcIYyFT793vTtPy/vF8e75cLhApgsZQ1e7upWSwU+IsRAgpyZxSSXza2ouH7rUMazEbbQsbVkuajrX3jkzWyRy3psuS7k/vf/7579xSBANguCSZcxazKHna/cGYsJQEMPfeELiktBym6/X89PzJx0gZWBAcd+t+5reuaAxPzFM+dLgSEQIR7XsNe+DuE5DTbLqNMZgrAkW0lOW2bSzIgmMMACvOHj1AdRgEI/Jbi8ks5ATw6dMntZ5Syjm9vr5G+Lqdu74u5ZCyIse23SxunEx1u60bWNRaU0rX20Vty1iJR++ba0ll4kSq5j6IGsL60y8vd8ffnM/XvkYoe1d0EARn9DeFxK8Nxx4ivSehM7MQ7285IsAx6E/4HMSAHMgIhOgAHsgAGESBjESIBMxAhADuhqHhA10hdMeQfr0IMXaL0ghAkATMrd1WV5MgSTiur5efQh0RAFW37ruFJ5UkwMzmo7U+xkhp34sHMwKaamt97JsComQWAHdTteGuiG8RtzuisIMNHmXoDkdHED7cPaLxj//mx+e/faUXSMSuvXts2qalvv/mw7t3H7777Z9/+Iu/gFJ++qu/vlwu13XrvY8xwAPMPeLLiRgB2UPDfS9guzXFHta1FzbqhB47j2S/7f/+/+L3X+/T/+s//j7AIRDC3dWJ0MAJUuEsiRCttz3bwkJ16GGZLeNlXAYGc4qow8NtMJ5IZCqPtdwFUOvrtm1967XS9XYG7Abj5dKY8jQtzBxG5utl/WPWyowPd78pZTbF4T8yc5J5h/fgig6XgG1bjZOCI6MIlXAOMKGEwOFoocNW4SxyMEOzlTkD+NA+dEPKuUwpVdOIeAF01W5jEGXmlKRCoGpjByKolD0RAO/AfsAK4ADmHqbDfY+ViVpmAJznAwT1rnt76u77fN0deu9DV49hGinlkg/Yb4QdkWl/qsOQoG0rkTBlkYzA5gM9JSJzTFLAZLTe18vofZoKoWlsCIkwklTmfUxGwgX5ZkruxJDCyDoQiA2jrOEaEUQSoBFuHoSe65yztJZavzGRMEBwTsPVUko5VcJiBqoNgUVkjwtGSCnNOQ9rV482bIvB7iEiy3wfEUnqDti08VzyAlECAgAZZ6ZClBKvuyWPiLhaW1dEZJEs3yBZ6Ms6LmOMUjrLAIkxxu12682GbsxIjLUsAHscOLZ+GXqDoJQKIpSSulrN7w7T95fLdrtdur4QgVmYX4nDKRxMsSPiqq25bGvbWx/A5BG9dwgBwCSnLJxSAgDVwcylLER0eT0jYQRHsNAyT2y+rusZgTHPO7trP3pEBCKFR0plRxlrrYi4j6fNRx8RzgDUdESgG7IUp8C3AYU7YBBHgEMkgceHA3Na19XsK2cO9tgHBHdQQSFiBAtVtw0AkDKAi8hUD6fjuyqHrS1gR/PVXS+3n2/bL0QgiWVsHrw7QMfp+O64vP/89MutXebyCNgZxQeEqSCA69A+YhwWRkTTgHD3scc8Bg7wJDylVDqhyYYEfVy0KREFg4619fXl5TMzf9d/zVKZ6+MNucdKUNyhSCVMOR0ZD6pKkYEQQlW1N7VCnsDMAkYErOuZuexT5N4UgpflCOBm49Pn3yNcAChJF2EE98DQEagBAJgisHdtbWVOOQXCNBVGYMCuY71ez7Us83Q6HA6IaGphMPY0AaHdwjlJIYapHhFyBOY0IZm7j25CeZ4eVNsvn3/c2nWa6nXdIsL3mHcPQF23l8PhsG3XyPzu8VszfTm/MiX3YErzvGzb1b1H2O12JeJS5nBjIXd3V+ZARvcQno+Hd+SMyGMMRBZ2Bs85IyKO4q7EiBhjWB9niOweU5nNW4Qiwhh96NXt6tHW1lJKkh7MB0J+Y1aSBGnhJUndtrXWiQhZZB9Cl8qHw5zTIuDMaPaiquqv6uod1rYyc855jOEOYaOU47IsHna9vvSxuu+5RBQBwkVV394g4W1tl/N4/TTAsPCyhbk2QsJdmAKOEfAPYzsIHYC/fusOZjHGSIm/DAV2hiYBUAQiOiLvXpoACMyRGDLDrn+B2MFG2U9vrgSA3/6f37r+3/8PIwyBAiHMgQRLBYTeYITZTstREOS8VCbv4wZADpLLAg77hwIwdizHQ1NSipJzzuBmw8wiGiK6p8xCAQa+4wEihBBE1PW8wzhEkHPdhyyIjElq8B//zR9++q9+oZvc0QGGEcPd/ek3D3/227/888f7h3BM02KmEfzxL37z0c3Ut62fX15fXl5enz+vr6tIigh3G2PEW1g8EdFyOEzzXGvduw38eo23+/zf+19/+hNs43euLdzMnMKFUiAHoZuRMGYJ923b1u0aYSmlwCiPp1Xa1S/gNE3HyIcBzWUkXwKZafbgN3N6YETat00IJqAsmUggyHz05shq8POmPMwLn3KqIeTbHPtBCTbAcB8WAylymsx7SXdEDxiMmEplZkYQRtrai3AWyRGcUh42MARQ1+0ydFNbkcmN3RgACSVLCCWELDznNInkvm5Eu2FMkAAT5yTusG4rYnIPYjT3PQMIAInVlJlSzhPhUGtDr0M70GpKAK42+tjvWzkej8IzROrjuufQ7hyMsGHevpyFMiJFSM7CzBD3zNK7TsXVOgKs68oCEILEEG/WvV/WiyGQKZhDTgtTOcz3U7nf2rXrk7cAoCQzcTIf3gFQaq0lT4SFKIuAo7pQTjOEEQoAIgpT8j1fmKiUROzmKwWkDJKXUkrvuvWfCWotxzRXNzAfqs2jA4CHEhBgBKgbE1bh6t679u4Goaq9tZZFkkxCGQCqSOSE1AGdpRJGa+en5x/ddk7lfgLMCImpKJjpZfRgBncgoloPNAYzjzF2V1zzYRaI4q5I4O5ILiJm0VsguMi9CO3B9BGx9pv7HqC7RPhuo0fEtRymeopgLZgyu7twJkpjNPVLrK52M7PRTYTDE8QAACQISLXOY5iZSZ4iLEwRI8EhIiQlQm6t1WU2Gyxk2iMCKVgowtd13YmVnPOu0W39kv36dQkT+dDNw5kmJNlTp4i4d40wAE9pIYCtXfmFI0KHm491ewV6mwGVPKmz1LqYg3tHIMKqg8HL42kiyn1Yb+EDAIFQInQ0jeQppSRpb5oQ0QyIQc0sUBUQcHSEQGZE6kUedoi1FhbGdb2u66r+a+tU87uap/DXfdsaI9xoWRbhaV1XBN7tenREznM492YiEjHW7ZZSquVunqfee18bc5nqsm5ncz2c6Lp+SqmkLL2vIpLS3DbDZO6h6jttcJqWiOijYcyH5Rhg19uGBNNUAvTTLz8AOQDdbm2uCyKXMhPKy8sLpwaobhHIo7fz+coSHq3WTCwAODoEYKkSeMH01AcI5z6w1hrQkXRr5629IAVLfPv+m0t7PV9/IpTW15JzOPbezdWs9d6X+b7kpfe+tcvlum3tKgmI5XpZRerH9+/BQlVHhwgqkqRKSsnMmrLaFcCYo+vqBswKQKWcIpTFd5FeG01tXbdnA0OugBMSEiAzE2amobYS0Rj29Pn1229PxAGgQ9dd0xURv/zyy2F5v5f53rfX8+eIyLmGI0mxwRjz3fG9jQQh2+qjQ7iYgjt5cCp9dE9SmBNTHmOkPAvj6/bamo7BGMgoQCPCt20rKQGGQ9CXavfWif/J9cbDVSUiZowvaaX7OHz/GSbA/XCEiEzAEilTygr7AnQAQLcIg7AIe2N1fHmtr/OafZAJhG30a9tW7Uqm3sGkTGWqMvSGiLXOAZV4Mt3CLXDn//I+awDwqTwu06R2U4Ux1oB9el882o7MKMDeMOnQiGB5Y06oRZIMkSCYKc+nx7/6F//V3/9//lB1oQYckEt6+HD6+O79h++/ffzweHl6oaDD43uoecXwvroDMy/3x+Xdw7etffrjD3/4w9/fns+7r4mZCcpeEnLOSOlt+rtTcRH3+UUQmtl/93/1K0nr7V65qllEBAhLMKXwwLDWyFSFmAVTSttouebD3enK0dBuYyMqE6bwsNAAzOloFhDSu47RkLzUVOrd+fK8zPejEdP0+Ph+6O3p9W+AupuQOOAg9gDf2guLEnstH1Tb1l5fzjd3v95uKeNU8jR9c729pvTInG7XxpzmeVbtAIEo23bbMadtHafT4nETnpGaOgOhaTAzOEVgOJNgTikCbQgEu5Ej5DS5e+8b7J/j21DGL5cbogf0OpUdRd576nW79BYihTnv/3Hrl6E3khaWU0pTTpxS75aTzPOEcfK3pD0DdHf1PfqHA8ARgxgRwAwIJaeyzO/GGDZu8ykRofn6ev7F3YQLczKzMRoAsIS7mkXlLJIERFL07r3p3TEjeWwXVWWSxEup6Do6DQDZCYJJJgBC0q1fzEKEk8gYY9u2kmpOGRJ4JNP9MK1bf7lcn3rXOp2meqr50PQTBCAyYbawMW4BndgqPiAiMwB2h9HbyhDIZMMAw6yv29V1vPEM0Hr7jFAJSy2HwI25CtQid4G3YQ0R53kWoW3t2gnCSz4iVUkLEO7paK13RE0pqba+fRapzFzqXetXgHDlcHTwRFzypCOGI3NOuRL7tl0VNxCIGObKkpNMQ1fTt2REiGSaRweiJJw48zzd64jentyYoIg0txhjN8TBXaEDAM6z1EWjqW4KHAAjghnIMwSWMguzO+TCrV2RAii7K+JuhWdmIZymaVHvra3bdlHd+E9UKiRhvpm2Woh43o97TEVEWhtqIyWNaLfLZ2291trHpevTrf2QCxEJRNrLh9wdv//88gMBmK8RNi/cegqn3n8CgNBrkiDGeUrr1okk8RHGEi6VjznX1q6bnZNwhJWSkdSjzUtVlXBAgJynlNK29ZKPzCUtlvjZf/g197aP11oWt6ojwARZ27qyvCFaZj5NEwbR/GdE4gY6NOd6PCwlt8v1tY2XWFcE0QjhdGvbtq5DN0q7yoZymkeP3ltr11JzWHVtra93p3fz9NCa9b5tra3Xnw7Tt0t6uI2rjvO8ZEFoik6diMa4vvR1nu5UNacMIAAtXCSVbbWIvrUXcTAbYJRy7foMgLXWd/ePnz8HKpek23YjorBa+KHMfL09r+tT4K2r/vDpX7sD+Da0h4Vh/+mHv2fBUur19nq5Pi+HvPYbkxzytymVnz/94Xz9Q6w/A1rNZbuuU/m2t08pE5OMzof6mCb84ce/DVy3/kvgRqwInNMSTm74+fWvCteST1M+dVA64OtlQ6clVcREmOelnF9ef/z5WcjX7RIO7CQ8lQqX61pKieg58WF+OJ/PT2u/XF8BDXDcrk+MefiTcBmqTLX1i4g4tK5hcdhW3lYDbO7Pc2FEwpHa9bDMM3gQmYcCGMB8Oj48/7FHX8c6ojm6uVqEz1MG0B1zhq/xaWFuhuktyEMtiJwCdvmHSkgiDCNQxgzgAYzCTvLGgkR2zMATco7A4AYg5EgWYA7aIZQxIsZbBf3b/xGERQAYRgTWk4OCoI0B5Jz54tchbrxuutnKWQphHerTUob1RGWapjb0fH6NkJpx6Ha7vTL+hOs0xgBQFgLwUkXtGhBdGxFIFiTe+QRE1kbPwhhDfZh3VUiRDvPhb/7v/+rpr5/z9U4GI94+vj/8xe9+czgcDDby8fzzL3Vejg+PIODXy5QT9A6SAkD7BkSS8/s/+1AO6dPfP51fni6v51KQqbwRAsBzYgSHMGJBlK+s0iQ1/Ff8EgD+5f/xd9u2RRAiqK3n89U00+mQcx5muMalv05LGb33dVuOJ1kSpOh8UfM6HQ/3D23dkIJBtvOtTRtRWtc1FwnvbWs5F3eY0vtMc6oknKepTChD37+enxB+AM3H43duDKm52+X10+E4UREIL/ne/OZ+YVndPclj19dajlN5TyhgL2qrKUIURARopcoYaZommgBJYxRKkMvU2pLrXdvi+/f/dL350+fXeVlMY6x6OJzyVC+Xi5tTKrf2CxGghIioam9b6ziGAQ7TgRQWyKkMa0hxXV/cz+r9+fpZ4wPjwSLA1/DLUCqCiAiRwia30eD156fXU/3zbT2v22u8ScQRMRCDuYQzcxFOERixaTSyRnxMiPNSzJkoBwIQXm5PcznmnJkzAJiNtvWAlgsLv+PM2npfN4CgvG79SQe11oZukkISDNOhDlQQuPctwty1jxYxHBrSOtTMOSKX9E54erj/Zp7nP/wg68+O+YehhpCQUbIN/fz5+ZzTDD5JSkjW9an1bfSNGUsphiUikGBsDpBystZ/Cvwk+JjzhHBobTW4SAbKbBAGmzCQCHoag9rNiVeWVumAFKUkC+9NI6KNZ0S0VZdlmul4ubq7iaBHjNECUP02z8W061BQIMIAjTAkIZJwHh0QMjMSSsCGBMgdfQMXCuAIVDd/iRhDu5lN9VDKEeK6bdsysTY1iVo0IBC98MGBDYWKAwxkQot5Orm7hzGItrGLoUPNXRMlAhIuwIjBvVmiAjYSJRa0PsA4mIB86E2tsUwe1LYW0HN2Zkb4dXrMmCRBj3brV6TTMt2BtNv6BDhYAAKv12stvMxTRL/1nkTX7anW7E4lP4aTakPeZBvPLEpu3kcftzGGA7S+omtEMCcRaWNbN3cvpSRARSRJReq0KwXMO4DVcseUHMkNmKgevsop++V6iQA1mZc6hgPq+JPh0OvreX2amVPOhYh2VV1raziqDubUu7am83RARCMjIpZd5QiEab1d3CIlAtgtoHZGvQoWFHaD3jezQSTqvt7U/XmeD3en3y7z43ob59efWfrpvrTtOnRT1bVd1rbmQi7e2shTRaCpyD4bM+tK4XFt21Mtk5pDUM4l58yC0zS19bq+nsNxWZbRTdhI0lB1NcKcU0aglLLwPMZYr1uZ6rb2T7/8COAeAzGQHClymUQEwFMqywJmNoZt2+tf/u5bEZAXyDmvTVrzd3fvsnxoW1dVZFPVxIdtu71c19vtptqZaut9jNizVZPMr9e1Un56OR+PPE99XVfgSGmyq5TlNLr1rg5ja+cAg0QAqhaqvTeNwDrxy+snVf/Lf/TvpLK+/vCHHR++Xq8BanEJ0HV7zmkq6R4Rk0xMxWHerjziUvJhWWofZiatbTlNZcrTPLmG2e5T7iICaJ+ffu5NrZuZYbwlo5uZK0h6C2z7iuVDvKEOO2j569n6DRLck0J+zaZnIiCxUESEQCQOZCAhZOCE4V/i2DRCMQzDIpy++0+//GILCCB02KHvN5aM7Yb5CBCg1sMa5wnBul7HMAhxdwI+nU632621XkoJkDFWVUXgl9efWp8BSDjVOiOyDh1DkkzoN0RzszAn2nlItNS76/UcEMzcesch2vrv/+5vfv79z6+fLnHlw+ndb3/7F99+uJvngsgIgsC5TGVa9hBzEhjDBCEgdhHazg4Ic0L87pv3c001595WM9MdiWXavUMkJWbebVp3lm54/Hf+l78eJ/7r/+yfmplH6r1T7LpN6L2vtxuCp5QYKJzatqGHSNr5etdtXcWMcd9/TMRDcZfdkg0dpuEh5m1rV6QFkQFQbTPFFtuuNfMYKaFbJszMTJwKgvswTwDex5VFcq7mpMbSZF3X69mnCVpbXV9yrkiWiHNh4WwWt3UNJ4RMWEpmN09SzbatKRIkPpweP5b0bqSfg57WlefpIJL2Z3LXKkeE8LJD63sfEDGQQBLmdKfazbsb6VCExCzW69ZfAEiYzCygRwQRiQinOnpcLhdhZWaRrH2srfXLD3tGRM45pYqQyIf7FKAWpqpbWwFgV7K4+6dffmJKAIxYiABAU+Ja89BLGwYhESyJObKam9mq51rnlFhS3TMxrtd1dCABQg4IgBAiLiUCdbi7juHmajaIHQL21zUziGBahZrabWtquiFFBEFwzrWUYq7ruu4QmiRT0369AkCE7SzYAAsdO1YNAILFAZlgD8zKaRKemXlrwWIIPDogMkoizDsLNMD3v0gSQZAbDQ2z3YwnAGKaDgDgJoRJ1W+3a4TOy1TyoW3j6q/7YMhD3IhoqXNHCjPrNig6flGJs9akpNZU1V2FElNKqZBlHWdTQBQEjggEEKGht6YW25vBQR83IsoFmxYENd9/TwzdzMLMSkYICofYV+PuJrT7iiASkZmO0QIG4ECSr0PnnYuJKOHSuxOJmUUk4VTKn2Q+Q0l8wNzdJGIMvXlsgZtZAAALcSCAjtHcDFEwgLkwW0oiIjoCgnoLaf2VOCR5dlEdz+cXM1dTxvBwkZJLjUilTBreWgNch4WaqnVEdgfJExH6iHC02B8mNTOPPkY7Hvm2PjMz3IIleu+t39L4NcNJJBFJKUW4rOtaqrxNz1FlTzFJM1ONCFX16AAewWZMmKeakyWACMc9SmM3IEopYSTE2DkQu+rvdtteX89tnJnTlBPjgWkgPJlfPYy4qN0MLBdW5y91ywhLlpqFmJEYLtenYS3wkjOlTOvtFsE555wLEc7zbH2sOph5mpbee9Mxz4d1vRLn3jdE3vHwnTSUZK456XjdtltAl2wIZh4cVspBhHtzCKxl6X0AuHv/44//Juf55fWp1lrhLjF99/HfuTt+/3c//PN+vYReb+tlme9zOqg7ix+Wj4D9l8+dQAhJB96f7uf6ftjL2NTdhl4DOoAw1ZofhObml23bHIfFhhhEOec8xuquKRdVva3PSFCqXG/Pf/XX/+L5+bnmqdRkpjlLHzdEKPkegpPMTFOSA1MWhtEtfC2lzNPx9dwh0nU9C5dS0+i6tuYOWZJqpIQYcLu+2CiuEWrgb9LTtzbiC28Dv3y7dxbqLgCBbyVwt9VKKWXKb9SNoIiACIjACAJCkEAJZKCELLsaFgEhAFzDFa2H99g1sQAAoL//DwEiEBEZd0csYWTy6G10C3dGCDQzIVIbQ0fa/Z2c3SGnNwu/fTUCekoY4LfbhWS0N+uIOadFB4zWl+VBeBn6anHp42quzG+6HFMQyQHYrYcSKl4/rT/813+wsx9wmu+mb9/ff/vxvk5pWCcSZnGkXEuZagACAnAy7YxsgQxEyAZ7eXIGlAQlU50EIfUeAOLue8NBu6L3Sxe33/D/xv/033z9jP76P/9v7nScXQ+0S4coxEYb2xqF6zKBR9t8vZ6X5TjVhUuWWpmiZtxcu/rttmrvjEGJiMBjbX0QJjVF8qEbD9pno8xABGOMrXVSR3IWIKgI4oHuFuGAHuCtDZFLxtmM+ujuwVSTMITsxjYQkjIhulrrXSPZurbr9YwEOR2EJxE5n19zIbM0+gaoHqPWaVtVh0uK9aZ71ztGU93ZlGQ2CBZhcVvdOuLOTsac01Qe1+2ybZcAIMw5HUuuQic4DyQXBh3ufiWSxJF5smCiIETmYEbxlPkOKdytNTMfESWnOcm8q4fUrg7drEcMorc5ZDiYGRFBQMQ21AN6gIqw+9UcwwVhJ8kxdO9jA+4eHFB2YbZb5PBS6tAOMMLJ1Jk5pxQIiCM0AIOZiQBQw5RQSKj3XnKepgKun3754xhtjGupgHxnCsJzkgza3K8QSAySwLx7uIhkecNdeh8MAyW7YbgjJ0YpUg/TsY9mhgi+s+/VmpuHey6F8K0LBPRwN+1Dt0KBkBAyuBBgSszUI+xwOPW+tdaYSkqJUNQ2oco4u51VV6RIUkQOCNlNjscldo8mv5l2JEcyYt/FFSI5wFwNUFKaklRh7m0gKEK8DffBPNyxIYGqXm+4U8sDCBiTzEiOxgENyQB13wK7vuwTAHcQyYRvJYzZiRIRBphqN9+QjDkAoJQpEPsIxd3uvYZzStADMVKSnPlXcQfCJLwwFx0GEUOvgAPQEAgQmHeMWdUGOOdUWu9Is8WKKI4ALDkX6EmIMqEjpHkqFnS+vKSUkIDf3AYRKOVa7+/fq/pPP33yUPPIeTe1hAgkyGZjn+XmXGud3XVrNzOqh0PvF3NlIY9+uZwjAglLrr9iNZwQCIFyzgDU+w3hzSqKmQmFiHPK1+u5j+bR38yGEZjqVCvLcdtWsxER+MZCYsTdam1EdDOVRERS8rzMUtzd+LZeCZ8J87LMXZvbjSkut1dELJWRlv2JpEQ7IT+CRWRdr27goYDBNPfmZlhLFUmqpjoul4uIzPO8JzQOH6p9nmup2ay56xgQgb27jih5WZajqs8TKkvXpwAd2txQJLd+Vi1M2R1qLapKTPM8W9wu1xXQ6nRMmnSwql8ul/Plp8/Pf0hFz5dfkDrxABLzXuv35pjz3MdVh4MEUzrdP3x+avd3j8Mut/VJuFqgKR6We9Wbag8YJCCyfwoFAqfKpUw51+v1xQOWZXHD5+fnof2wLDtVImIfLsp3335T8p9fLpedKwoA5hsRUOpVDvN8YEruqM6A0zBsw1ydmZOUlArgZja0K6OQEQG+ES3ckEBEGMlj+9pw+Jv9F36Z1P7/Uzr87R/cNVB7w7EfppDT7skBlIAFUAyJENARw9E0fIQP8BFh8v1/9vbQ4k5bYOS3mNkgQgbdtI2uECGEyKwcoBBoFkwxTXPJhz7IjfddbDcpU9t9HbjWWbL1ZimVJBNh7v3mHu/evdcuaxttrNEDkfdVQ5jMmVPtIwBjLvX5l8unv/mlP48llseH+48PDw93S86gtjmQJAqDN//EQGABkiAi4QCAQCAEJvEAMzTngMv55Xa7jb7tZF4AEMmchEX+FC4iIkf4J/+TX7sNABAhs3CnlFLAoECGBILrVdX6aN3VxtZutxsRnU6n5XhvgIOBp3I6HHy9rtu5bQPB94gc1V2kA9NcACBnMRs5Vx3m7iJYppyLtNbc31LikFIEtjb2wNqdd6VgKWGE9bFt2xYx0t76cR12ESFJAdjNdNtWd2fB3jsA7PAkhADsiFkgVMJmsA17Pt/+rm8EQEkeYLqZN7MQETdrfd3T7IgsAsyHmRJjOOw6bdWxbZd1u+Qy5UQpca1zSsH8fYQGtD7WMW6InVJFRAsgYklCRGAOyLVOtUzq18uFbrfLfrsQuruZDaaCCTnAoyMaQUJMCDJPRxbU4b0PHc1iqLoDMlUIgeAANHUQAiA3QO5NQ1UTce/NHWqdpwyEyd0jkNABwCx2rZ6BMAkzBrjZcANhFqEpFwAIZ6JgcfXOoZKB4EAQTAVBIIwwIQUzh6dwD1d0QeAd3GptrcIFpgBhZEk5XAiZaWaK8/VKOO7v7yUt16t79FJKztUd3h5mHEjmOnrfACGnlFNBFKK8H5zG6H2ckVAEI6iWeZnvWmuqSljmiQJG742Qc85msenV7QMAlFyFl227qXUh3J2NPDRChZKLC5ecZkIhpmk6IqJ5j/Deb4jJ3M1bSXMIjDHcABBUu3pM6bi3C30ookUYkQBw10Zh4YSQeCcH+b4xukf38AhDcgIC3AFgyqlSegNlUyolH904oDPtSG/aDRW/NBwZo0Y0BIo9CgKTECCbecO3cEcgBOY0TVNvOQFvLWKXwFOep7ucFpnro/nWmiERYiAOEXLXPYhJA8XMbTfuFeFsUcMVgvYa87bXOAc2xDfmV0QyA0JjIhE9HpAZc67bqsyCCJLK13ey1NnKbGpgkFkoVSGCoESJSCBgbA2AWJCMCGXnb+uAwEBkCHHbAIiZdhYbBAVAyZMHjbGOcQuw0SPJPE9HCxyju4/r+jNhIhLhKSCZRWvDXVmCOVmAIxEF4EiZ2jYieF1XAEbIwjGV96+vr2EjyXy7bdt2TZkDQlVLSYjY2hph5rq1q2q/3l4IM4C3rZut07TkgkNX8KXkROHmm7oiRJKUZL5eVoj28PBhtxhBjD4akXDC56fXXHJKLIIi9Pz6Rx1/PJ/XeXrIxXqzd4/f5lw/P19MYb2eReAw1VddAf04L6795fPn23pN4kTQ++YCARkxIXIf6w5+MichgRDwHE5TXfbugSgfl2Jm2zrm+fjhwzfruo3Wl2XZtu3p6UlNa/nm7vjbsF8A1exs1vu4MBOA53zHVLatuRHhdDpOvd9u1zaVshxPwlPOk7b2/PTUrh09a1cwECIDAwwMR0JhGfprS/FW85C+MDd3Q2BX1Ya4G5//CnikRCTIDPsXEBADCUgBzkA7sAkUAOHhA625bwT6NrPZX3SnjhIGcrAAMRADRO863JwRGAWzMIeWOS8bdndXS8dyCtO2jWu73m63aTkeDofb7fb88hlAp2kZoyUmoSWCVDXCAIfHamajv/Z2DmtJpioTYmJmLNN2O4ePRHl9vf34+59efz4/5PvvTx/nmh5O8+GQESOQAlF9EJSpzkHU1XKuAGRmSTLYHm5ASATxxV5CTUd3Ux/q2kMDmVJKqWQW+Tq3ords+39w/e3/5d8jol1TkxIjaQwlDHZWxraOK1w4SURITg/v3z0+vpd6aNpf18837BxEwqXOzMgUYcNRA6OWKQnP06m1Tii1HEUkfIxuCMYURExEEQyxa6TR96C9IGYyIE4L2DCLCGMigJ1MejaLUnpOJSg8eusGwcwSMdxgmorIm1dYRAeklNBjOHQicZtZYG2fxoCw+bi8J4IxuqoSTQAeMTwUnBCRInk0ImYmABldbzGG/vF2ewXUPLEa6e3NSA2BkdDDEfuXDm/39ku7uIkYGQhCRvfw0cdww5QKIva+9b45AoAnPjFiQJiH2UBAQiZKAOgGX6aQQUBMFQPNM5EQZwAMBx3mAYisdkNzIMwsRNT7tm6vZmOajkLEWDjvOWSbgiJiyQcicDPzFoEIWWhKnHI6jtGGboEBqOHDfG3NGZNwYSoASJhKnnbzOsJjSBUwpHDXMUxVPXTdVkATzikvQr6N4Rbr2oj34AJHMgDan1JJ/PZOEQLMvQMGM+YsRMCckhQPIUyI6Aaq9vn5j4flhIQBZhbMLDwhBMAQKcJHxr63rWrrsNv1lsyslLqL/yOCkHkPPhwjPOjNx7lApN5CkjKlaVr6gN63AENAJBecmLKURMHM3K1v7Yq0NweZqbpdHFx1YypEmUMEM5Awp5qrcB5jjGHgau7gGjYoEYGYhwEiJACOQEROMpU8Jandwmww1d2S1e3yKy5A/MVELoiYiYkywmHANQIRLEAJmTntyOfhsARUovDYdKfEBiEkyWluPSC4K4ikeaop0/X6sgvhxItJv91a7z3nIiklPKr0CO1jMxu11t1f69PPn4RLa2gaIpmZI6K1XusRQdbtkjMxC5GIUE6/IhzH4x3dP76+vvau7n46za2lMWw3xOxdt74BAIkwI0uepgJAt32wb8MsWmuAg3hPEigpJWKodV43BSCRPE1p9BhjEPaIxAQ5g7sTsvA8upvFNAszXW9Prd84JxFmSsEqQsQeoGYtwlhYJEeUebrXQQB6OEy/fP5xDM1FUuK1dWZ0j7VfS0lE1Nrae08yJZkJp3k+XC4vAeN6e+m9f/fx340wdyIsQs4YOU9MZZ62dW0RsadFlDLtng9mYAZEMbQxpZShtc+tt4e73378+P58+aWt6f7456qqvc/1PmfqYyWGaSruqZTUx7reXihH7305zKZT7wYkJU+3bTUzIhGmJIUxQzBDCgck7c2QsORp91Y6LIe703t3B495Ph2PJ6KrazGzl6fu/oe1XXcDOiLK6RAOzMkdWuutNWZJKc1Lfn716+1ljHGijCiIU86ZId1a92bt1mw4uAlFmBlqAHno12qHX07Yu4nWvk3vc9M9AfZt5v3lAiZkAuIgQkIPwL0ukcDbPIUgAHYhfQyPjXYOxxf2hv3tfwQAQBxIiAIogeiBEm7dIIgTDXAEzig8HRAocc5TGcMul7Xd1lKm0dqep/oF5+PYJxw+TXViKvteUKe8tfbzpz8k4uvt2aPDm6UKuQUhhANjWtLdy6fnv/4v//b84/nd8eHd9PDx4Z5Yc0EiAGAicfTe12mpeaqAZGZhu5Q0kAlI3tJhvnizumprqw/zYao6ukVE+jKlwj1LxZ2IgJEQ/+I//JdfF/Vf/+f/LrwZTO1KWqaA4QpuBAEAjsBEgXj38CHX9Pj+AYA9PAQ6WI/Wzp2SMBMxENIYTolyzjoAgnTgtroOlTQJZyyG0IhI1QB0V2kgokgVclUNR0kZmMAsiTC5G6gFiCMyobmDu+4TbXc1V+GyzPdMpfeu1olAWACauzGD2gC0dTuzaOY7smNNZWsv0+S9mfnm4XsYyq5NZWYkaG2FAkRORLVMIimcWttMY2uvgFqnMs/zaLiuNwCXRBR5r5FmBCAp8TTNOR3Wvqp2M6PAvQUxGxFoSu4MwAD4BvqREYHqQDJAh6DdSn//gPq2AoO7AlKShJhJyZzAkTnVOgunMcbQW0Amzt2Bo5Q0zdOcUkMARgrQdT2PYTnXmmpX7aBujQVrOZiNbXvpo6WUSj4QMQDFoAjcts2iu5uOJgkZ0pfHBnozc0NMhBBOzIVToUJIodrcXVgpCMUASA3IovkYg5MUCOpNa5lTxr3umsVb/gPuxvpJFdwJAFKuUz0M3YQzEbm5xwAHQGemFBLupo5BBBQGYcAogKYaLHmulYC3/uIxppqJr5f1de1ex4zAhDnLkQVsqA1XU2bc7ftMzUf0/bRChJARDQIBCTFyPrp6zXNJNSL0pm4gggA9pSVB2bbb22gjDAEgKmFBQgR2AwMzHx4a6qq6O8ChMPObc1ctx/Do21DzfUXvUEc4SyIRCv8HfkNIEWHuDmiAgJSJiKmodcIg9AhDQAQys9avUwVAz0UA6tZWBN3a2czltj31vgFD4kQohOxm7hR+2433swujdu1DOec8129rkYC+tREQSLsVR3wZpoOHIqac+c113sWN1lubpmme53Xdap33HmW/eu/usLfk7t7aUHU3BMnh3Nq59WutGcExlKEkKuHIMCACXA2GwwowdGgEBixTLimnLzYGwbzLk1a1psYlH9SCEFNOJZ8SH67RB4x3Dx8lveWYk7xl5ryhrN0iYtiWC48xREoEtnadppRyXZba+gHAw2P0yGlCQCkpOqeUJMbQTuTHw4eS7hmPj4/v/3781fX2uY8rEhGPbXujKANOYwzhEsHTlGK3zMbYzUJEsmmULHcnVN1MY/gWYGa6rtfHu9+llMKZsLy8XPf2SBLknG/rWduWEu2OFKUsiKMU8YGJF0FhBHVnFqK15AMAIDICMTFTyiKIOEYz23JKgGPdrjnN83SK4Ou2OpKGf355poDj3X1K6fX19eX1J8SwAAgSyYflTgcQpXW9rOsFvthz9THMR+u3nR0xzWoxUNF8YND10myoDw83cA0YiG+9wO6A9KcNB7wZjxoAGKGL7IBH3q+pplI4JRLeXTMdgRAMgQiREISACRH3+Qu7gqtbDx8UA9z/ZPXRGxdrdw9DBuDACLW924YsPTb3IGARaZtKnk/Hd6+vr33c1u0iyaZp2h/+y+WyFyRJAuA5UylTOCMSM4GDCN3Wc5Hk7pJykomwjO674h/6IOP18+WHf/PH8x9eH+v9b99/V4EDe5kKJ7BwprTPmk7HJdWCX97mGE0QhBKYAiIGujsBYXhEdNVt266XdYzhGoQI9AYiuju/uViCQXDE7/6jf/X17vzh//rfdve9vVPl2B39AcAjzIOAmefDstydPnzz8XD3DSUCQlAdOm66QgpmDjVgAAZVDcQxmpAg4rY1BBA2BIkA4cqUcmI3eCtFoXswUQS+/Q3DzZwIECWMsyzMrHZV3c++xCIlV3coZVovV3AHc2ZMVAgLikx5Ol+37p7T4j4AoLU1QCEoyx1TNfQxbHQ4HI9CEIECh5QyIu4q7jfk2GKf9BOlnBZmLhmIRLU7zACQcyaoRJ4EJYFHC9cIJkw5VcRgxiRTLct1OyNikV0+Q+7AuxNkOvZxVUMAYBJEjJ08EV2HRjgRCGckBkB0U1NG8FAACpDdbh6CcmEITpJrPRA1AAK0iDnhhLbb1hWM1bLvZJ7z9eyOe02KAEIJMvgimWYm1LfWnyi5kfl1a68vrz8Q0el0fzp8SCm56vBOOzvE3Y12D3YPXMerSMq5MmZEAy8Si1NejqcxxtBOnN0wUzot7wnzdbsSG8RorZt5zhVJW7ewQEbecSMCIslSmPls4Q5qm9pbi4zopaTD/JuIaNAiIucCAO4D0RKLjTVsTbmWhAgTYl4OU9Ot59b6pW0v7jBPd0wLAXbrxI5uHmFGER2UJWXixXxARBJGSGYGAeEehmBEIdbj/0fVv/5Ykq1pntB7W2uZ2d7b3SMiIzPPqVPVF7pb04AQCGmEhNBMj0bzYebPRYIBBAgkJBBCAnEtdXd1VZ17ZkS4+97bzNblvfDBPOJk+5eMjFB6xjY3W/Zenuf3DG1hgGHajZMLvROeJzk7ILohohCZz8L5OKhr2464HACPQA89sHUUR6SGIOJULq3tEW8hrGM0wm+nKR6zeQf99lC/baLBA7q6erTED0TElFGYGMwGgAOQ+fDmXV/epkoCandmru0VQuT59pPZOJ8fTss8OtbaIhQgYwBSmDf3Mi+JSO73+/V2Pc+/QdR9r1+ev9R2n6Zpnk8QlNOCyECMGLXdt/01wBDjN7/672578miXy2WeTs/PzyJc+l+Yqb2Nr5hFfgOHgwgfvvPovZuNXIppIB2q2q+fHQIRVHfAISnMvHcdikIGmGy4eUfkI67sdruVUg51RWu7DiQML2QpVIEo53RB6giZ0yxC+7572LKUcKl1RLhqz0W2fQfMbkEyOPFe1z5uYzQRgUOGEjJGO58ee64AHiBEgsSjyfuHH4QeE116/W1Ol1IKse/1um07Os/zAxHc7xsiu0HXynS4VFht9K7z9NC7DlXhZDYA4pgVz8tM7F9e/7GNlwg8nfN9/RlJpwWHvW4bMCezcUSMLrN8eP+d6aeAnvM0OpnC5fxhrWtv2zQt4OeIMLOh6hZMQAQiyDyJiFo182maetPn5+fLifd9nabJXVXHw8OD2bDaECOlcuxBj+U3ccRQdwgYfUTO4g7hsq3X2u613c/zBdiRtI97u3cYibmMNoRogJs72DjoXAhHbMpxGwT9Qq7h7sd7MN5OLI+IA/97ADEPbZDj15x1JgQAwq+ybY4I8Pgq/TAMA7cIp69RbeO3/yYQCBFJABlJgAQAIfyIjcucMSVozR3IsW67pKmUOYAD8Hw+j/5yv3/5+PGveu9gsSyLSBqjt74DxEHd0aGlLBHRu7KkqczaOyJP5ZzTYgpNm7lG4NPl+y+///k//H//7vM//Pzx9N2vP3ycmVNEXtLl6eQxtFkSsaBQneacSjZTkUyIvXfmBIljDGSOiLBw8KPgMLPW2hgGjklKTggURAQE7iqYjimmI/yzf/P/+fY4/+n//D9GROa3tul4UFNKoS1MAYExAJJI+fDxu8df/xq0AFprWymTELS9uViIn6YFhDV8uCXCgWhmw/Tjx4/hskzvzGLb7ma2ba9EFDBESK0fSxx3VXURcYcxRmvDgpIIUZrKZVnOX17/DhHdwz2Yj5bXwadlwaHYWo2IgyWYUrpcTrVt5nWe53V7Pr4hkT88Xgr/xuHW8dN9u9VdS76cTg8HRCeciRkgzKpqCEspJ/ByJPqGHwE0RyqQLPIwxhg9zBQAiRJi1P3G5EKneXnIeapNeq+9a3jFMNdQoEOPSQQRZuqIiTkdcZuqbnr0tYXS3UxVDVGIBJFMw1wBLcDBhzogELObHTYxVGtDSzpSZpQRiTgRMKJAsOvhCEUICIdSkjsysam7akQgcsTY97VMKRfxkK81KiDiuv+UEp4u8pXgHoJsAwxvSMJMIikimY83fR5XDx0DzMwNGDIlJo6c3gPszHpaJrMgT+fTe1PgtOz1ZW/VPUo+LcuCpCxQ76YKB3+CMDEViKQDjhUbAKgf9G8GAKYi9FhKmXKtbYs4XAtGjK1pa/sY+1YjHJkmpmXUBYJmiTnPfaz7voMBGOmwMfaU5Uj5BRwUTInO5zJN32/bPcJSZnerdRvDEBzAc5qmaapbM7PTac6zb31t26raGc+IIlRE8hv5N5W5LADhduS6DZZghqFvvVEcY18LAGIWwkxkhAOBet9VNScizqpgZuaj9079L2ZS968yWxhmW8QGAMwo/CGOZFY9RP1v7OZ1/8kUUiopU2trLtJGE57kEC2H47ZVplJKXpan2+32Wv/RDZlKb/jDx78ZPer6pdDo9pM2re1eJkz5tO/7unrOE8UUpO/enyTz7fba7usYgxEBj6jxpKp/+vM/Ig1V225/sRsQUzhJOnU1t2SxvXv3DpRKmfZ9J5KcZsICxPu4ggzzwbJIxm27x+hI6DoNTY9Ppw2/qK9ru2efybEU5qD72u7rNs/z+XxelsUsNaum12U+B0G3tcW279f+x98e7LxEEq5z4d5t7I2n2U2BD5iPfPfhx73eAvoYkzu0ZrVuT+/OAHGwdGzY+8cPjqDDA0ZKwpQyzSJwvf6jDkckgAYR52U21+63lLHudr/Vy+UpJ2ytsnjhp/v6QoS50P22RbB5BQDiUfu1tmvO0xgyT0/vnz6+vHy53p6fX/708PBQ+z0lKlN5fv58Os1EYhalnLbtegRxXa/3cGE2AG/jxRRptySzcELAJO+GP9MUrem23SxuXz7ff/zhnyEGAAldppxfb7cx+vmydNvCVAjLdBrD6tqYU5I5z3Rbvxw54ynJPC06rLd4fLg0bRxBxKpV+76va87L+8vfAFHhPPP59f5apssIv/68EXDvHdwYB3FAEDiEHx0Q8FGOhwNAAAGCveXWHXZPkMNbRBIi6iaYRLKkBMCBGEwWwTyF5JBJZSFOCI7ewRtGoNXo1UOd/jLeEDBgBpGgDJiDBTEAI7Ud0Dbc721DSEiWGCpa4rwsSx3b85/+uNVnBH06vy/pHXOqdYNAwEiFRusEo9Yt55znBwzQfkPkRJxTVqQxYpoWBqHIZUqM0rXlafrDP/zpt3/7D7fP+6/e/ea75ZJNiaycRAR610SZCcws0EWyauIhTPnAQotkIHTTYORATilMwzsR1f2+XW/eLFzNDBBTSsDkQIeXkKQjMBH98//i//eL2Q8UBgXvaobAKCklDk+AOU1rNyefpmm6zDLNaZlAERB6OOYCYH27buvrS6r83Zk6ZgIKK5l6126ObsSRMIdMt9s+L+dhKqLI1UYHykOj900SS5p7h2Pjs60RgSmVx9MH5GV08+ivt9+FC4Ad7+l934aSCK37leDgYScE7noTroHL9drVPCV015TSul1FZF3XDx/OhNS7mo3jj/rY4h72xl8WpnQszlJKTEkkq1ut1X20fkdkkRSe1YZZMKVmL4ixLA+tjvv1GjBAhnA209HDNZnt6p8GmtCTQjMzpCx0RpAIC3AiPThLw/ahV7XGgQCJ+XtJWW13CJI5YijcQQbZQnBJ02QafVThvMzLGHpaLr33va4V7xGhtjNzOEAMAE7T1L1raJqnMXrtFdGIJOXCPA073G1g5kP3CSVx6dSPgGjJKeec8wdEenf+KwsgZNOBxAYbwcmdgsAsVC3naZnPZna93sxryno+vXOcIAqLd33dt5t5ZbFWVyLpg/3Zfvzhnw7nfd/Py8eAvtXVwhPNppay9bFi6JRPSEl4IoLabr134QxR0IkIE7Oqtk0t/RboiWkp+YIYfaxqX/poPvKyLNv+evtyO5/eB8bn198vp+l0Os3TxeHM8G4S2/r6fP08L9OUpgg1VMDexh6Wp/xdxCNLN98iIjodUb4AiCDzMknQvm3expxzpkJYKF9ifPr0+ecy34lBRw10cC2ZtW2tQe+9jZduV2Y+5e8xzim/ob0OClzvHdACZFmWMQZomtP7hEsfuxDljOaVmHOaTf2bKhwAxtin6YfW0Dzl/KjDUcVCymIQyQ0zsdoG5nM+T+UiciRstFCcy6zaGRMhSpLT4ZIyM4gxTUtKaZ7nfX+iJMuytDZu95ckOWUwj95HSmkq52PudD7bYUYtkp6vr89fYFoWtzJPKScLtZ/+9AciAgNtat1O0+O7p+81/aV0KnnqzENbO5bEScZoo5qqppQ+fPhQ6x3A1dqRKi4i0zznbH2std1zlpwTUwYIM3M/VGPy4enjNMu6Xe/3jfD0/unj+fSuN9/6XTgTzBEYDgEOAKWUOjpyZiqllAC+3Wpr7eHh6fDZSmIAmOfZ3ZnSXitRJaJ5nhHfuKVJFlMsxW63m0EAREAcypXeOoFt271Vu1wuy7IAujvoMAtQDRGRIoge4WqdAgB6ztl9XF+rWTxcTsvy0Juqkdm1985CqVAuR/2acqHeKALn6TGlpKqus+u8PEz3u3rAspwB1c1r3QIIQVSbG+Sc53kGoNaG2ejx815fl/PTMn8Mm5r+jLje7p+X+ewOSaYIm+acMta61lqXZWljRMQRKYSIKXFKadsXBDgtT63t27qVIssye/ScTizY2tZ7zzmdzuWwra6rTdNy4Nh779bfqKCIGH9hiR5QUPjKMAgAf5Ny4jfd6Nvm+tvX8U2+TQXdnb59SxI81BtEAXCYWAAdIcJa6ABXBC8//m/ehij/4T8/rLDw1jQwAAEckd+4tbtay5NAgtZq123optY5CZJMhc1ETSXRMp+27RoxiERt7Lv1UVXH0Lac3zkkO8wklAJMPRzoNM1HIlrvrY3++PjuFJeffvr027/9bb+Nc5lPOSUGQShJSikkwhgAzgcDHwCZKMmb6gLeeBvHCQcApp2DDztxmI3W6rbv22Zven5EREKBr5ZjRET4y3l0fP30f/lPJRM4uHf3t/QDJKEirjQxIZxLSaUUEgZk0HDq5G4+tlG3Xju4BWitKWJs6q4plSOtDclV+/X+E1Bp1R2rmT1evn/3cIpBX9Z/O0YjkvW+IuLT0/tt7WbARB4jYkxL7O3WddSuLKHqKaXe6xgj54wAvQ8iVnNEIuS3bp64jjq6ERYPRvDW6rZtj4+PpZT7bTsv51rrXgdiPi2X8+l9RKyru3fEONbzAHEkNrtrmAmh2gggxHC1JAUSSprUV0kswscqcJrOx1scEc2H+818RFh41oCUWCQhEqEQUZLsrkcOohmG+yHGKvJ2/0/TqUQ57h83MD88R36MHXKa8mmqdWt9770iosVGEiyutgMAi5eSAABCaq17faMP5DwjgjddyqTqPjzAMmfG8ADEUI+6bkhw3ES9DwBYppnTlFIh4lYHAKRJAGAq1HW4kZlBIAS5Qa1j31frAwn3W0/gP378dUrzfX3+8tyILADAQMOZ3R0HtHV71kgpkySo1cJ1vV8lzVOZTYeHHoPNcHR0EZmm6fVmgE4UgMDsSBExiMkMWxvglYmmaSqZx9Dabo+Pj0gK4DqwdVsm/v7779Va6/fz+Xye37tJrXVvfx5jx1rny4MZhDMgM7NFtH693uF+e4tyPGAqRBRm7i50BnP0GGNYH2ZGJYEDeMhh1AQAIOtupgSc03xIpvxYYTEfQehAyd0lZ3ff6y3emj2tbQP0MqWcc2swtB9B4uv60zzPh2mLf5H0nHJRTgANEVOSlJw8I5JqZwIWCRzhu3lnd3U7hsrHXBkRO3Z3T4mFaclZWt8j3L3x4Ps9WusMT6WkDx+eXl8/39cvCDyGARBpydOEgq01DExpUtXaNy54gCwfTh960z4qU+QZDjLuskyAITKVvDw9ftyWl2+fBJEOhEaEA0Af1cxC4TgITqdZVftoxCqC01wQsfXd3ZEsFzTV02mZyjnCaktyhGVQGm7i2Vym+QNCfvfur54ef/jy+X7f/zank9Ox+BcAAgPm1Nr9mA9nYXjjNE/n81kH7HXd9rsOSDL13iUJYWawsMGcM2dhmaYpp9Pr6+o+ImKaJzO93m455/Pp7LZrv4mIpTduj5mZKQBBlN62UmToftfq7qoj54xo0zTVCm5jKkvOi7sjRQwRXqbpnDO5Re/1fr/WWoljmjNTzulcytR77zMyIWAQkSuIJHMWCSaepnLYtXOeAL6heEaEzQu2Ya2Ndw9PdDr1l9vh/Ki1HtvY3jswAcD9fu+jSqKUkoMwhmo/qtqcMyIA+vGfRMTQiqSBHLHkXPb9PsaQhAfsCLAwT0kKER1AZXfXXvd7I88AhEEABnAIPB0AAR3eLK+OSASOKIcpixFEWEQO1R68iTwEkR2CIgyOPoIBGUjgWyHvDmFoA0xdd9MdY8gvtVNvQAkBTkA5gN90kWCAUevW+hqIGtHGHtADhulhG1O1oapqvq1VB6qqh4eFOzBPU1lw9lLSPD0lKRjjACSYHRuBNqcjvQAVww2ur/f75/Xv/+638BoLTUuRjBFeJUtZJGeBr5TAo+YKPJSjfOQUfFXAfCvK0PmYHIWZ2hj71g4/85HcdvhQjhRTQKC3hFv4J78Yb/z8f/1PITCQU5J8uBsQzTUAsEg6UfJIRyQJIiC80Z/AJQB6G9Y7A5wnATwC41QtAhAYSVISogMaEUCQEjFHSrzMl9P8vVUx+LztrwGifdfWy7tCc6m7MVPrt/u6svxUuzOlY65sCssyRSQienx8VNX7/Z5Tds5HQdZ7N+sp5VJKKQVCAJwOWlMp59ODTaZq2/4aESUvRJTkBMAAllIC1Dd1LaB7mPlfgDHoYzSG4JzNDEARGdG16/FD770ipHk6R4SpQJh7BegeRnR4PktEQ3AEMAtTZ/LDtCIiSQiAUIsZEL9lvEGICOfDWqwGyEQ5IHQAYbgx01IymZlaD/B978xs1g+95YGCMA3EEaCIFAFjOIBHRJLSWidMwBSHK8YogObp7BnGGKpdhPI055wjwiwwMA4Bmioz51zWdQUIRD6QCAAokkWk996qCcc8n5hsmT68e/oRkWut8/Sk/ue3LJJgwkyJ3Hxr196MCOvee68o7A5tr1OelmWJOCYJCfEtCQ+QHh/fAcAYba93pMHM4ThNZ4BAUgAGHEiZWUQEWxo+EjPJ/PA0x0BEnGba60BjdW1tCE2n5QkRWWLoXTgBAIcDMjNCNPXe9aWtmlLKMhERsREhuYnwy+fPwjxLXqbi7ikdnqCWUkLEPlSQT9OlU3IbRDCVcwQCDeaEUejr+urQuX2DBRz6jN77589/Ppa5vdfee5LMlNb1jY/Ve48A+kWMAwJDvJH9xmjmitYgRCQDbEfP4rAHWBtj6I34kTkxs3AmYmE7LOLycPnAEu4eMFTVfGgNCHr//sPt/vL8/LmPNSUiwnXbwvn9jz/M0wkAdURECJeIltJMZHOenp4+vHv6+Pz8el+vQoOnSXWYBsSCEFlS2+vt9Q7jL2oUVQhHBI7o5gPRPDClBIFmwyz33ltvKTsiHYarrlVVW78Rqw46nZxYVZVZDnn2GPrar621iDgtD0QZISUuywzzfPKojMGMByQRAN4yeEYnbIiovR7zld67qo/RLPR0emDm46qVsvgYjw9Py7I8Pz/v9a7W58kRo9a2LKfT5XK9vupwN0BkpqQAp9OpFDezMQYiHrb1cFb1aYLWt977lPLRcx6tOVO5nPP5/DBGu11vLIjATJnxwboBEOVMjKVwVzotjxAlghDSNIm7rdttdD2fn0zB3fd9m6aMiAi83tfLwzLl0vq+3u6qTgQs2FpzBB8j57wsy8stOyThUxCWPBFR84HEAFDKlHM+4BnM3FVdFRHVRl9bEouA+20jkqnIut3WdTuflzZq4NT6ncXNWq31yDoSnlpro0FE5JxJfZdONCLikHEiELz5wv14mzoGvuG/4vhdBIAgJGSWJOUosQ/e17cvJAKiIzYFiAE4DqqgKyCiD7Du1sAqeCNQ/PGrOeXv/3NAdmRGAcpACUEAAEHRAQ6+H8W93gZaKpkpD23f8KO1Vncq6cGUnu+3p6cHQjxeMEcXq6Ob0mjCyEwYfjAfp96rmYUPQB+K0+lMnv7w7//0+3/7B9vsx/KDgLF1jMEZU07MaGYAgcDHrAaJ8XCXAuBXI/Evf41EzF9TUSK0D1NlYDhEl+GIeMSdB77pytz9n/9Xf/vtKf78f/uf5JwDjhBwyVkIxd17jGDiKVHOGA4eYApuAI4IbobRwIJMgwByIpomZybqHkQHtK20Osw7oJk1lDNiLjnlvJjtW/2s1vo2As3dWWCa8rZtLy9fSn4AQHcv+YKXhIEEY1kKoI3RmPjIKzlO4WP1lyT33pmJGXMuhxAIEYggwFtrYI5Mp/MDiVgEMY2+l1JEThEYjqMb4MHJTd/Qq2YWgUgOwEIwRgiShwV4gG7rmlKiXI6b3Mx0tJIlyTyGEaKkRCzm/dDXQwiRYJj5WzV4/Dj0CA91z2kuZRpj9H7oEggBbvcvOYt5671HYCk5UTFvOc0IE0Jp1c0gXHTUobuIqNrxN2dKTMmNVEdEP8bMAKiqZkGUUmIFIhIiYWIArLWpOhOVLImlduijEfGcS++63/dpzr0buIYbp5IlP4+VmZkTEEYgYc65pJQQaZpOSRoRIYK7X2/P+77f7p8CqscdgZASYU4yiUy9937ACREPiugss+TSm/bel2VBlAgnTCg4RttrNTtiBABCjsmKmY0eEE1SIAaCmjXfVyLoo6mvt5WnadZuy3w+vzvf1+t9f06ZnspT3fuX5z8yPT89vZ8XAXqqVY4xW0QQZgQWEpCdBW8va8onlilCxzCzzcyWZZGUXHsfGqauGnROlM3bspzcfdtfiKjkKacSbu5Kkg61XCmTB6rqGEYymBIijsPXI4TEqsaMyD1AhjazIMacJiJqrT1c3h3FHCID/GXEsa1r9C4ixNl8d/dEQiiHWSIimENYAMQNIIikIJBphI+UjmLbzUymKR/+mWPk7O5JZCqL2kpsan3oTkTC01SWh4f3iLjX1TT2fUspuScdHhEQKSVyg/v9vm3XgKq+39YvowGhACoiJylvtdW+/WLCwUTJXdX6GHVacN9WTMtUThEYEcwpJ0xZW2u913nKp9Nc27btttd1np5Ux7rea60RwHzk/Po8peP7S0L3vtXPr3dYty0lrhUTTynzoUgFANOY5zn8zdSw3l73fU3pobXWeycCBJjm7OaXyyWlEmHr9ZbkNLpv2xagHs23TiQBRoTHtvJYMdzva6sGRI6AzOHueKB+Dj8EMnNKqY/hrkHlQCMcMj4ALHkpee69994LMbPltDAthJKLSIrW7+v2siznkpdadfSKGJLQow69t5aWOaeSe9fwrgPdABECcutGIixZslkMYswluQlhAEG3+96Nmb778KslP7Z+f7i8a60hKOekqo8PrKpIOsbY9x0A5lKObU5rjUQBJECSFEQmMkTsHdVvr9drrfXh8ULIOU85ZyJZlgt41G0LiFDrrWs3DDoQAXS8ygIPiBeAfW3d/8KeOsoSVT3qgGOS9O2LOH2rPIAIkB0ogAgpkBAAwtAdXMEGWgdvCA6/ZG9EAGFwDhak5MSIgh4AHDDAPAKR+XC/cCqCpBwGqE4Unqksp8fTctbwvO8IR1WER9HWezdVpqXkIz0SiAERjm6slBLd1B0NYkC9t+tPV1zju/k972ZW3fdUKKWSEgPAsED3NwRTYCJPKQWgmSPF8ZZ9+2Dmzs5OR6g9EwUwHYl0TKFEidgMkZEJEOOrW+df/ld//+3K/P7/9D88PEcIBIQESHhsqQIhpUl4LiEEHjFG+JuxBd3BB0Rv3foYe8Y9cFOF8BmFUFhKzllEerubDYvaxpXAJF+yTAQzoa7rdeNPo+7CF/M2rOYiHtl8pMQ6rPXt/btf/ZO//tet2VpvfdyQK3NAFFVVHceTlfOUUmFO88xjjDG0lDRN82EjqrV+416IyFxmDNJuIlKmJCwQgkApk4eOMY6k4GP6hUiHopxQEBFcI+x0OvXe31Qm+33BZSrTceib2fAhkkSkNW3jxSFnWAhPWWYnRQqkIZhjxFETJpkikMhzKvd9ldyBsjs40MGBjIjer+rgruYhPCeZiSgGHe0QorgRABPlnOdSCpH0PiCMKU3TlFIZ6onNHHrvqsacSpmTlAMwlTOoau99KjLPExEdmwJETilbaOtVVZkTISPQ0C0iwLv5cBDkWtvzPJ8ynyNA1Q8rMhEy0/l8KrncbmvvfaOrfWqqzaMOuyPcAaXwI5EgJsIUADq6hzHhMs/ubuYYVkoBiHW9u3uSOaViNmobrW0RMdFy7GSTnAEbMTJ6SiUi3ISQjyBIYggw5nCwMTpzNrPa7kO31reUlyRT5+Fwb+1zXF+W+REhM81qz2O0YZ5kKXkGBgBybyx43DOIdFD/3X2aJuJodWtmYAoRMCCojNEnKISC+PYAHb4SAO6911rdfZ5PSNP1flfHfJBIEG+3+6E8RRKzNk3TMpXb7UXVz+cLo+z1nlJZTnMc/lcVAGD6y2vawxBdRMxVDSGYKBMlIAiDcAUUxIyQkCgihBfEUKut762vxzlGRLLuXw6gxXEch+MxjTEbiDGGC8+Hs1QYwoEE9n0z18Aq+Zxy9GEMqdaaZAbX1+vn2tYsMaxv++tp+S6nSTX2unkEiXh44F9Eo8IzUzkghmVK6/q6b5UWOp0urfbW4Fjt1/Z6ZOoAGksk55wz0und++88tLWtjT6Vi6TCzJJGSRMRtrZv+4u7i8jrfb/dblO5IAURH0GIZiMID7hWq35Q0l5FVBUJUiYzVBtbXVPKSU7ff/zYu3758iqc1nVd19v1/vzu/cKCY9ShwDyrdR0dEU+nk6q2dk8yE4pp5JwO6b5a99CU0lBNRwoTMkKC4JTyQfUPJ0QYY6zbTbUfCTKAME8z09ktkHTYvdbN3ZNMY9hxv+obOqFLOgYbO4IeTkUIWubL5fJu2+7X2+f1vs9LKmWOQBGZ54L0ACt46La//Pzzzzn7h/cfe0OIFAFmTsQp5WOaoOoRdICbS0mc8kG1F5GwDMHn07upPNzv23k5zXO53V6X8nq9XnvvhImZSznAHsemgkdDwVRrv13X23WPDRIwvBUZv+Ruvf1bEDIgADoQvE2GmOg43N8o5m+NO+LRDwYhEAYCAB3oSDwAUeEQCt7BOx4gcwj/umwZ/+5/5gjEQZyDGDgjJgAOUjRADNOxbtet3wZ3kkKYkfO7p3ev99fRWxYq5XTQyim85NP99S6cELHkGQCMY57p4eFB6LKur+qDwGz01vYxxvl87sjgyJBvn7af/+Hn/qU9yoKbjr2q1YQWuQCQxTFiYHPXb9csKBzR8UCtQgQdS4tvNQcaMYMZeNjQw6Zb5gkRHY6hBvxSQYbwH1G+jk0zIjIJCQcyMEFOZCQQzALmSADm4YEBBAGh4QOsA0W3fo1RgTaD2qu70wScBJEOF4mIJE/qO6BpfKGggMXdiWTojujE4dFS4m1XRD4tj8KlTPl+f0mJxxhm2FuY4rrunDoAMx9z4yAiVQXwUoq7J6YwWNdd+6696LDROjMbxjTNRzNwLG2TlIggBkQy8wgjZrM+RkckDzusyEz8tjU2UPWhDZHSNEdga7u5e6DH4RjKiR8IDGI/ctcifNjVvJhF4nPOU0qutqs2Dx+jIwEfe+GD4JSouIXjMdxFDGaK8AjPhdQa4Nse/ag7VXWvt5KtTKkUPjQBOU2Xh1MMfI2bkRGJSCFiAmORoElVv2X1EcrhaglQNfXwEU1cUGhazszMGLXu67qbWc4FmSGAc1EfhI4U1puObege4EB+oHTcxxiqVltfRXLO2SCQ5fSQShGzKsmJqb2a0ESYc1nCRYeH6xjjEOi4HyiUaGOnCBIwG/f7Pk2nUuaUWK2q7YCac1qWBUGIZN/XPlZJAdkJRfh03B4o6KFHoU6Ygcfo+HC59N4/f/mJyIXT6L6xDQuWCLSA3bwQkHvixKoYYcw8T4+I5A57HdNyNgsLEs5JEsnsbqmc1u2mPpghz5MQE5GGOti2t5zzPJ8CcVgQvJ2N3/D5KRUHINSIcANIMIbV2t29lBIR4SIyHWwSM1MdEaO1cQyudJCInJYJwFlevj3j0yTKYTbU3I0YF+GzGz88nG/3L/u4IfBpfhReWtN9383e1kDuOrQeH5wly339GZFTzoQSgRBSSlEd93udpunD+w+n0+l3v/vHl3U9nU6Bsa5rHyuxqa9b3c33tkPOyxEwfVhVcxEM9U6MpeQTIrnp6NHbej4/EEX8gpl6CF4OiE3K6K7Eh2Zq6m2MYVM5T2V+fX0FECTf622tO4KIlGW55LzU9haNuCwLQiaCnKVXZSYP3fcNIMqU3M2sj1FPp4v1sa535pDEwyzncmwqt20TEWLAA7cKSVX3ugaEuyFGhNW6bdv2cC5qjcVzpj423QcRIRLLpNodKCUhhjECDzg60Bg9AgHcDudVWO+GHADWdTDlUg75wSQivaGDBMbwVtctwoEoCAhTBKjWvd6G3j1GztM//Sf/8nq9917dBxIg0eHlXKZ3RKLWTCuglzIj8vn88P7ycas1kB1gWJipOoBDV7dxBL4IQmJOtV1/+vkPGMu7x8cxRkS8Vfp0DJ845zmnBcCJSK136wS0zHPtQMxAEoQGxsxShCrN0w8El30lpiUJj76ZOSJfby/LNLv7saQ8ouL9WICDA/pRLzhSIEBYINARxhZvAkZEiQO8/R+rROFrdjzRL2jcb91TAmQ4xiQe6Ao+QKtpIw8klK+wL0YMZmACScQJWAwEHTHwWEMMXbf95V6ftcQyl0AwxTQtOb35+o7Vde+jaSd2kUTEvbfj6O+9qmrOwkh9VI82xu4xzCwAiRFEEnHb4uUPr9c/36dOZLq/3jI7uEHmIyurN0/ogomY1QLAk5TDqeTg+S2Z6U18fbTgZhbhBVOY+9De2hiDRWYRYq61HpOWQ7cRERD0L//rf/+X8cb/4b9nZtA6BVDG8RZ8npMwCrE7hHsz0mNfY+jhpqA9vBOojagRNaHOKTOV8N7rCHe9p1R8UEQBQOYEWEpeMHpKxV23/YUY7QDPWyCOUhbC1NsBIMJ9q4hYytTa/uef/nFdb4bdXcWFKNExNiNKjJE45wSuo41bu5VSUn7Lv3V3RD5oDYkSCDRrWh3zyCK1VgU/Eic8dGjrfRsjSl4i0N1NAyVSEghS1zGGhycpvSlQRnYGenx4f8wGcirCJScm4gjrYzNvOUsEuI8RG6Cxs5n3YQwOX9FqB7ANQSJ0mR8i8PCDH3BMdzePJKJ1AwxObL5ve1XV1nYCSCAOq/qIiNbfwtJKSuAKEGat1nGUZSKCbIhAREebp3qQ6A5JkIsQgK/bLZxFknAmgG3bWmvA4UCqqhrhmOSUE3KMGOZhQmm6zB44DjgwhaQ48JJDK9LiDSIg51JKqq2rDsSc+EEkEVEqZx3exm4QQsAZ0/zudrvtrR9yTERUHwdg9PjbttZqXVUbUohM63qbp4eHy3cln1+vnwKqeV3bbZ68986CIqKmbm+MPo6SGI/+nIgYo+RTuJgiRGI5Jzka9QW9dHemRcTTNzkFMMKhDk4QkGQWKQichBAxJT5fuOUpXBMhIpoFEp/OS2s2LFIpx8kGTKYdPczsSKIIBwtgmgAdwMO5t1HyUsrMzGbGeWJMbm2eHtyVid19nnMps9uburmUYjYOptHXrsLMezhBYE6neXp4WD6YJs5Yu9bRKSUpU5Ki4ThcdbB4hB+K5rerxEn2ej3EsUMdIYlwSqI6pvyoXTGWp9MPf8Cfa10vF3G33isxzAura+s1IiKmeZ5P83Tf1r2uJDJNU93G6JDTZW+q6hCUylxrRRY8hEx/+aJpWvZ63ffdPKZpcq+qCnAAJFTVXl+v4ZRTkWy9N7ORUy55nqblet1qW82rSBbJvdkYShxjmPtbj+vuo7tiF0mAOs/lda/rur57d5nmZFtlZhKaSnl5vl+v15RpOU3AMHwcj/TpPB9Dwi/Pn0qe//qv/+r5+bfbuiMi8VsDzSyjW4ibWmBCigASEUQ5FkPb2FprZqNM6XI59V6fn5+Xi7gDkZzOD1Ph3jsREzECqTozsuCow3yICBEzTe7usQbeUDZrqipMC8A1Ir5dWgSBYOFT4O6q5nrwx0wl7Etv+Pr6mktezhOA3e8bMzKLqo+xnc65tg6cPn73q58+bbf7l3/6Tz7G8Fo7ANS27X0vpRyq3vPlwVS3bV3X2xiDBSULMIkAM+31qrYH9vu21YHunvo/P82X0zJKWnLh3tXMSiGglHPW9gaiYWAiNndAZ3xjEUO8yTgQ+U0E/xWufajMviklAd6wYESUUjrSp75WGw6HKo0FOMXXpUyAhzvqcNNQA/wG+ID49/8G0JEZhJEEmAAZAhyBIg4lhNpu0Bzb8dkBfN938iRzEhWMrr0JTpTIbGxtm/kS4UMbSxx7nlq3L1/04UTMIYT7VvvYDpnRdiejDE6ff3r59Idnagjd120jHc12Ic44I2IgDQtrSsNPD+fRBzmVLETUdIDjsfD65lJhZjP3cAAAPbZCYWZwTAAAHN9IX8cdflQb/+q/+btvj+5v//f/+njZepiLR4RHmHntDYoAAAMSAgWAjmMdE2Gu3cdOYMjQ9qY5rCRZ5pxTErntqGi9vUgKgKRKEGyGgLnkC0c+LU+tWhuVEJG6aXf1lFgkn89P99tqSqZDJB4fH9d1l0QkO6X7sO10OYPP4DPzCiBqw/14m/a6t9aGWy1JCCAgplxkSaNHRJR5cgNMfMwPSGmaEzM3OzpF91AWJw52ZOY+zA2cRwQxATMjGiIxZ8mp7n1ZTvN8NtN5Lp+//CxgzJJkyTkPxTZeWuuqrWsnIgQjUnIXOZUyl7Jov7EQEUEwAjHniBhHohSSMDupmqqO40GoO+ybIfcIOwgranWMVmQupXTF1o9APurNX19fSyIzyzmrG5gfkCSkjNg9VJgEwcmJPCII8bauZpbSYVUjSYmIh2nbay75cX4XoWY2hgZQmefRhIARGCLnRCnnNJ2eX64iIyVOb1VXrKuqNjPO5dJa3/bdwVStVs0pizy6Hd3FFFgDDCmmXEQklYsOH2MgAic0t9BYlsXVIqLWOkZrYx26Hw/C9XUdJ5+npzFsvbdU7Li8L/e/P4DaheY+hinmvOQ0u7PwdL2uU+any0NrLadTyQ917BI5YokDhK2SGJnDhiCUQ9tbaw2nY2dkISnn5fQAIL0NJEkpEWPvI5wCKJgRESIkTQ+Xp+fnVzMDYrcBAEe5MEZ37dM0EdFwcxORIoLmg4gh9N3Td4+PT/u+994Py4KGqHZCPvb+OgyBIjznZGYRNnQn69+e9IOnR8zhDEAISXhhzM+vn1VDOAPE/X4l2iKMZBBShHkoEZVyEsk6QtVlnp6ET1O58MK3+xe19b66Djg/Plyvt9b3z6+fL5dLgA6tANrq9t33PwDAqTxcZtHhIeCGr9t1vV0RrQS/vlzNfZqWda+TA6CrDiJY5mm9XRmXx/yXGLov13/wZ4+IU7kgylR2MOwN1nsdw2rdppnb2Fg0l9ldEKy12xjj6VHW7fX15WXo9vg0u4/R70mmdbuj6+n81HtHxDOf7/e7Q5ScVfWSHoSotitSb/0+Bvbec5ogsZEC9j7aND9dzu97r0xZ4zafnko6zXNRq+v2uY9U5u8ezh/r/ifVmjJJkn3f1vX++PiY0uPt/jkXmOcHU3xdn+eFarsBSAC0MZhKStOXLy9JytPjdylNX758OZUzo7zcXmodD+fvEz08PWVm+Pz8e2aQRN7Sxw9/7UZh7edPf06JkBLE2XRj8s/Pv2fKKQGgtNb2rc7zZZ7TGHbbX0+n097bMj+czt/te2t6X1+/JCnv3v/QWnOHlFLra6JkPobfP32m9+9+/cP3H/7whz/GOM2ZHx8+1O3+5cttPhcf+/X6/KsffzPJ/POfr6inZX6neysZAkfd+Hx62tsnRFzvPckkIuEczq12dyvpC9JyPj2MboeenygA7fHhPRGt6845pR6IfdRR0pmGfnW++rEzocCIoIOji+kITUWAo2MQeUOOMqecSyqZhElQGJgAmJwESJASAUEEAocfXF7AcDBlMwBX4fTj/+Kt4OCGkkIWx0c8pFKRwgFjABqGmmtDofndUsST9V2F92W6GIz0ZmMpaU5b2wfoGHZeHofutfdSioHWNgC9nMi9B7w4lr32n75cf/zu/dPT0/PL6zZMxJ7//rr9tp9uJfrd7EZhxEQhhIQgAdw18kFRDNz2HhEiNEBdj6Q5tlBEIWIAUFVTFRH26L0PhG8JfEcGhKqim7zlgIeFm9m/+m/+/tuT++//1/+CGcfovZob1hW++/BgvElidqX1Tgzg5uCIcRhjzAx0kCmgN9Cqvaa+g5tLu+81CUsGQnJiOutgAFXdAX0qJ8Kzbks6aa1927Z5nqcy1UDC3KOH8zK9q7WKWG23acpIvq43IkE0j2DmJb3DKH3oPIEa1T5UW5mSmfdeU0bJretzMy/paS7vejdJKU84xjAlIuq2GwQwdVPunKQERWs7ESFy20noYU6h2hiNGRBdzVtH4TAztT3ThODzwsQWju76et1UGwCXHA4v9+1oCufeK0Kc5u8A0Cx0uFMSnhF5XXcmT1jAZQyHCBETkXl6GMM8qscWMTCUAgESgkiqcn5qrfVtVV9bv5s64eRg15dXEXu4fHy4fHSkxjuAS8Leu6oiDbW91Y6IaEvbVhEZg5nZHc2MUPa2QnQbHgbgUEpBHseeF7LW1lOazpf3zKxjQNCcTy212u5r78Zibsw4dAOo59N3phSeR1eWcOtvSaROwlDrF9vcNHK6QFhJmaeLWmutIRkzr/c6Mn734d3t/rztr2XiUsp6H6pWStnua0qT2s6kAeYGpbyb5wIAy4Ip0br/ubUhOU6ns9kYPRI/2KgEk3YMBxEx9QENUQM6p7jtm92NOTkki43FdbS3RhRiaDUnABjRAGAMQ+xmnw+FGfpEw/e2thRjmAcvcrren82bdpunE1Ho2JFg3/rlzOu6i5BqD1PwMLOceJ5nIrJEgILMvXeAnlJSH2ZW5GHOs0Bpq233GtDTmUX6fgsgY3HA3pqXMrfWEDHJ5L6rOoSo/mUyMOUHhcnUiGCMxrT+/Pw7iITcWWwomFnEvt/X8/l8hJimVFRdOBNK4ul8Wu63TRAjZxmjm/Hjw7vee60dIbe2i2Dv+6dPdZrK6TS3buvaKNfaXqf8fpkeAahDbXZf23NrjcCXZRqjbWuVnJjlcnkctTGzatv3phrCkySAX6xUEs+bwtB2W5/Ppwsin08PTQ6BRZxOc4Sp9ghGCngLBWdmBkBTeHr8Yej9dMrbfl/XfZ5oWc5j1DFG732e5zFGKUUtcpogdGuVbkxEy3J2VweUVEiSpAyAIvYVQokRse/707tLOCWZSym1mbu31ta1JiwpJRGQhL3XMVQk5VwkxdBtby1nSmmO0HVt08xu5GHzPBPmiCCCeSnTNL0+62/+6p+P0Vpr67ouy+KwWfA0/Ti0uhtSiEi4jdEQEwJhTJfTh++//7G1/be/+7ttew7vyyIAaKoIhAhPj+9V4/OnZ6KkqtNUJMHr9RORLKfl+fk+xvj85bCAE4CbxrY11a42hKd1e/nzz/9wvb2yBCO/vr7ebq8RUWuvu44Onz8/E26v11uR8uOPvx427+2VMJciy7J0TV++fBHOSYiIciY16h1yzpLcvOdSVLW2m3klVkBet1uWcoz6WcaRW0ZfQ1EiggDhbWGJROTghHwwyb8OOQ4ZKRHgV33o199586cIkiAL4C+ssDgAHVwhRkRz7xgd0TB+IVlgASnImfj4zw93qGP4sQo3HW3sETafT0FRawUQImmtpzSNHswQjElKkkRoAFB3dQe3ISKAhIDCS/c6RooBkk5Pj++ReKt7EBLJ5z+83D9XXY3bQN0RNAIw4OhnSTjoF8ASfFt4HQDfb1fm+OcxwDiQJxHhZsjU993MDteM09tS6sCZH9c/Iv7Vf/2XagMApmka3UperO8///Gnx3cfypT7uIMhmCoaWQR4hGEAJ3FXN0NVDNOwHr17txwapgHDMTmB9jG6mS1zERFVrXUHdF5oKjOEm+7MlMTGGKfT6enp/ZcvX8z65fx4iD2F81RObnoYjk2DBRExnADBoXuoOef0QETX288RY57z8/PLbV2XUzkt7yEyghCReb3fewQiYsnkjn6QpEWOazLGaP4ytDNzTiWn5D4CQFJEzBAOgMu0eKTee62bhzKlvlZmBGjH/FWtsqAOHbpHYGsN4hg2ADGUMqkqQDClUqaUue59XW9u69NjnqZ8iP/dfWijIwcYjZiFwJENLAIi7OH8fcmn3vX55efb/SfKp+lhOZ8eh73W3SBSKQUFrTdAXZY553y/31trQ4e5uitzcneE0psh6Twns7Zt23F/TdMUYTosIkWgGZQ8JZlKYr2uo8e2deaAUEQ03UwDAKYps8ZBugRw1X69Xh8uH3/81T8F4M+ff3YjFlftY1S1mlIRgd1a750QzycbdletwrBv99vtOs/L6TTf7q9mjih1V2EiSiUv4ZZTQWRzI0qIcjrlaZ4DvNaqwwlHzlNKaYyx72uASSKLfFreAnEICQGJOaUsPI/RW9+IjUQjhgO2UWmcIoAF/KATAhwhG2tdRXJO0+XycAzLESFlbnYjgr1ubhHBGxzQ2ABQj9q2xgIBY1i973WO02n+Vfb8Rlpyd4MAV/VpLtu29RERodrvqwL46XS6bbfT8phm1jG613W93nbPhYQKsfVRh+IRlXBfR84T8W4HNNSb8F+QAPi2HWXJ6UCqHLEAOtxciTgszDSl2Z1Smlvbj8EzIrpr6zsREYeE2Xa/TeWSKIGBYFpyGSOeX3739PSUiK/Xa0AGDACb5iwJe/PeK0QJZxTKPAWYqgolItnrilTePX03zyeL+FI/CadUFkeCwCBE+Y80Z2V6qHw6z6euEQDu55SSJFfV+TS9f//++fkLUoCGdpJEJSeDMA2IPJXy7un7n37+vY6GIKpj3/eUz2bQ2n4wu1TVHVimcBldCb3WipKKlG1bPaJIZuL7tjEzoYgIHKYIgtb2MkgHqKhHP+aTRMkNNmvDIiAIuKmpU5mXwHS9PROH9XZfn5fFkOx+axHTw8PDvu+lzBDUWj98kmMMiPN3H371+fPP11svZZmXEuEOa91ea9vqdifynLNbbPfXUiaAYPGUSpbT6L4s521/vq+v58cHM6tVEdEcpJRU0qn75y8bETBDLqxaP33+6VRP5/PZjdT21tfjxZNSul7vY+i77x5V9fPzn2/rM5GcT4+q8NOnnxFDuKDSu6cfS1meP/1sdmfkaQmStu0vATRNp/Xe933ft2YKSQSCjqBqBGZOOafWN9P69PgdEt23qraCGTOfT48InKQgMFNy1wBX7WFve8RAIDjkGcichvVjFUpfb+tjY8LMhCFC3xjncdDKDyUjM7I4y5EJFgCHPvIsbnsAAQAASURBVPQAjJpViBEYiCG/+m+P/6/+478JZpQJ8oSc/MincKRwhIAY4V21g2h0RyhjKESKYOGMaJ8+fWGWx8fH41Y8OpvWd7M4iCMih1WdUuIIMi0HeY+IPFqAZ57uL6/XP676olCVVcEbgAszOhNjknwIMo4r4A6I4BYizJwADoUoHWvjnLO7U5I0FUD8xvXqtR0yQGRAOSJUg/HIwzB3D/tlmgz84f/4369bI0wJJ2t1mc/ff/cesAsCSxAGuKupuwYYABQqh5aFwCDcfGgMRx8J+tBuFkhkBMDh6mHuads2d2PBCKi1IkwpTSmeWl/NYq83AMu59KZPjx+nlA51AAuyzK3thxjocIERClFY2IFVsNgECqACdrVwJ5EMQFnK6IiAKB5hRA4Y4MQsZm+rqINlFBEU6B5oIUiMVFJimvd977VJotHh2JQlmYbRVCaRNE1l2+4+9GtFh4gEg1PGnIOIRjfEIyOqgwHigbp3gCPVXUQ4F1lO+XR6tywLM/emtW29d3MD5NDxVise6Xph7mpm9z1LXtJUynxqevbopZwlnxgIsLkRZ1Hre73Xvg9fiyy9a4QRQQAg8rGazCn13t0V4RjmN0DJWRhxKZMLns8PzNxao4AwG9EiIqWJUFq7A3SicO219mU+5Xnh4IOzDmiIWNuVKA3dp3LZtu2QE5lFYN33XYTC2Y1FEgSo1dHjenuJ0FxkmfIyzcs0EabaPaW8rvepPGTBQw16Os+I2OoQkTEMEafpvG1bqxqB38Qox4+ACErJACdmDrAj3mzbtogAILNApJR4mi99bL15koVgxgOOF+7RmYSFVHvv9Xw+MxWiRDgRUriptzEUGXJJqr2UAiDhyExqfVnOUzkj7MTR+jVi3+tdUqzrbQwrNjNzKXNKSbUngbpv4QhvMKSOh6UsRplmwPF6/ak3B4BcJEKJpLe1sAzde9PL+TvJ0zxJKXPKaAZq1WP8EvxFmEc/smoniK9L/+GIDBEixGz7vorI6O7OxMWDmBiZzX20dnQt4kb7vrqhZj34u4hkXg8lR6AC2nHVIiACwS9M1sf+ev0ClB4fPiZZEr23ZCml83LRwQ/n9MP3P9z37fbyAsE6kKic5gURW+ut2rb9JUslAPbNmKdl+lBrnfL3RERgGL2kJfGDjfVyOj8+nT99+jTGzkly+Nr3Wttcllq7O5g7IB0Ow1IKM//0042Z1nUtpbQ6fvzVD+6AYMtZjp6ZRUTUzIahAwIAEc1zYeYxutnoY6vt7taOVKehWURS5iST+xtGrfXGLDlNwvl0OkNQeD0tDxGhCoTpw/tH8OuynLOk1foxmE2pPD6+C8daq1q73V6Otubp8X0bVyJobRe4qQ5mNlMAECG1mkFa+9xH//nTfa9/aq0ReS5dHA9ounAuZUakbe0IIVwu5w97fd37fZqmUkrOmYhOp9Pr62utu2qb5yKSL+d3puQOD5fTut7cPwcYEpoPxGyqVbfv31+eHr9nolKm83xu9b7v+16vf/8Pf/unP356fHzKManq7fbaWv/Vj//0cC5A8OiGKCVnBGitqsZxZh0misM/vCwPYTGGt/b24iDk3rW8HQEIQQEAgIgCyIFMwMcom/FtvIGIhIckggLfgGYHYOpgFgAQIAPxkUUWEaADw8G7e0fTAKeD1fGX+5NCpkgzyoRc3giybhSGoQAWPsIaJgkWVRgDl+W9mTFNU+HPn56fnk7LfK61Qjiz5Mz39XpgTsbQ473obimV3jundDqdOHEfRFQIuLV2/1TjhtQxRVCMCP0a0UqcmEoCJjiMrMTDDT0O5dBhzqSvEa+HG8sgOBEcrlnCINS35Bl/c7d+TXn9per2X/zX/+HbNfnt//Y/sdrH3ucy/fTHL621H3/94zynvV6BAgMiLNzNBoYhOCKCKYZBeIC5jx7dMCJxpz7QFJmOHy0RMxHhV1wNSGL3MB+qXUp5OD1cb8M0Gtj15RORlPxw2GTUOoC7+THfEiG1oaaImYSYUgSr1d502+6nkwEO5D5Ur1c/Lx/P79/t21B6EU7MnDIEBgDocIQA8K8IWzp2UoIEAPc1pTRlySWdMy+g866rEC9PJWXe910H1k1Pl4fECwYBbCklInhDiJpFxLpuRELoAHi8RSDoaGGZEmEAgJldry/3+5U5AURrbd+3r9oaa31311JKomQOgAwOqgNwAA7z9nK7qr8yTbXuDhsJOqytO2FmmoUxIoYNIGOJMXrb+5sPhSIlBiQmOqCpIqR6ZAVDSvM8FRFxg2maIPh0ms31vm4eI5xavyMtp8uFJO3VInSaEqe07/thHWAqJXOEBQyEdN/+/Onz70e3Dx++v60/s1hgScXc8zxJKVPvmkRPpxMAiHDEYIbbfU18vrz7YArX1/XDh4/ThGM0RALAI1fdnY7iTIefTqcDd/RWzEmGotM0IeIYLSJEDmmW53Tqo0bAaVlUhxsQiY4A3I4sIQQJmxLN5+mvGM+OL6q99X30ALSJwF37qI/vH5nLto51XUuZRMR627ZtXjKCJCHmJHwkUQynyOmMMCWeEbGc3oH/vG4vbUtYhpkNpYis6geP4HQ67fvOkpjR3REjl3QY3ff9Fm+jFgond5im6Xx62OOWBCxZq7c6+hRRphRutQ61OkYNGPMvjIEIQpgd1I3cD7gUm1rvDgiqnlJOAjlnYVM1Tm8OeiYhPKJp3Mzk8fJjTuu23bft029+8xsiuF5fPGyaJlUl5lLe+I/h0HtfW398vOTs+76LSM5i6hEoPM3T6TS/G03MzC2NTr3Fw+W7Y+KXDy2PjPW+1/3zL7slVf306dPlcjqflzJN7g7kWuv1XrvW6/327t27ks9un1sN5iCapsJu2Hu/3X+XEicpagA4Wtvvd6KvieRv91Oi5TSbQq2d6A1xaMYpT2K+rrs7kNChpTpSjOHI2z1SOZhS4jdQAROA3263y+PDgYOx8EDMZQFMrY3T8t5sJAazIXy6nD+MNj9cPuQSbmw+xugAyFRqr/f7Nk3T9fZJFU7ngmR7PfR6odaQMCV2fxuNb9u27zf1sfd7759f1z+o+rKcprJ8eP+rtXpOE5q3Ps7nh+eXq0heltNUToiBtPTWnp+/5Dxdzh/We1NrZpZSznkizCUv09QRubcgLO/f/UoSbNvWqp1P+d2789Zp27bzyfNUwllVxxjLMte+1nZ7/+Hh6fHjurdlQUQXef/D93/1+fPnw2Dp3qY8pZTu9y3nQgiqNsbIuZB5rZU59WYEDCra+74fUrtiaEzp7bWHcITV+UFTQ3YA+otK9KgO3iwYh5312IogIn5D5iG/AS4A3shh7gQGbqEa7hQUFPTD//LtzvwP/xmKeJoxn+FbxmYYgkMohMHBj9HWCVgmRyDJjw8f7vf7GIYs794/5lRq7bX2o0U+7IhF0jKJChGKmTUbrkQAI+59BJlAEGF6/fTy/Ifn+5/v1AmHog+Cbm6BhIiSKJiQ6Ai/PdhcZhYI5WveNL4hqHMu5XgTszCmt/Xkmwe+j2NHAF9x8l8xoABAzPw3/+VfGF+/+9/96zGs3taSl5fn65///NP79+899PnlnmYkZsJ0MEvBFQ68N0C4BrjZcBvD+g42EplQA4+UUspELJKYWFBHKAWcpjnAt+3aR13mM6P1uu2UAjqLL6dU6zidzo+X72633YfXdouwnHNKF0Qc2tf1NaDDfGbmMi0JuPcjIXIv2cskwlNv1ZUQMuEU4ccqNsImlYOz2VuITOfTO0JBdDcwVQDAlIiolLmU9GYQiDiOSgRIKc1zGd1aU+H5hw+/caPbtgL8XPLcR3UDIgxHRNq2WvLCHMKJMB+YgGOddaA5iWiMsa5ray1ny3nathvAwYRgERJBdwaI4/5CTIgI4MxIzOYubGpra63WeliIc87zkntL4Q6H/9ksp1RyRoz29QvQ2IMYw8EsEMcY44hEEC6Yc8mzcA7oDGXo2NZ7bdfr9fPXKV0gYIC6IwAITyXPGHE6RZIJIUmSkpe3lRCOjx/m220Lp9YqH2x1rSwEMS3zcj5f6q611rBACggZo5ayACAB6gjCEsH3W+WMQ1vOqfeuA3Kepinfbq+3+wsi5iI5TapjXW/+htzOiDFGU+vM7G6t733ww/njfe2HQe8QBZ5Ol33fA3ofddu2oVvv+nDOh4/D4dByJqKhql0NkJKU6/Wes+5bJ5J5LpKYuESYGwBgzlPvAxNOp9M2ViYAsNZqlkfm/OHDu6mcb/cvvVcAPVoCVe1da23LsvzqV49M015vqg1BiMD0mNsRF7rdblOZHx/f6YBWPacTxpQ41e2VZF5m0IA+NpFsHq21YwX5Ff399WSNuFwejl/c7z38zSU4zycien19Zg5mAcAkk1tLSSKCkA+YlggFOECXnC5j6DzHYV8WIcDQUR0YIBzikMmktIRjeG7tM3NhyinZVKac53t/9VDC4kYWnNNcrW51HDf309PDPKUIbG20aogpZ2Qp3z5J3ffa/L5+BjrP8xRgx7pu37ecs0dyt8+f7+t9d4fz6R2xD92I3NS2/SrJtt2W+WFZHgHHn3/6/bb9/PDwdD4/9F7ned73HRE/f/5zSvP9/tLHG+ITAKY8pzmpRkRwktZa3fsxdEkp5yI5Tzb8aDW2/UYEiFzyed0Oe47pGL2OMTTRpN1c3diTLN9/9+HTp59enlfGZXR7fbmxeASbdjMHiNb2fa+qWiY0rR4xzcunzz8HWAQRyqFEO8Q7hzEvIu7rLafT42VWa9t+RYAsF6EL+mPYCwaONtb7LlR0jJIzhG77Ok0ZELe1JTmflgdT2rbhqMxc8hkht+ovcd+27RjGEtFl+SAiffsM6CVNgM4dpWQE//NPf9y26+WcWXIAJFm2/fb4cH54eOj60ketbU+y1Fpb2wMMMDFjzlkkE3akIpMgcEqQcu4DiO464nZ7XabTYSpZb5trHM8twDEICUcAJoj4luRxWFGOgx4DAi3ACQ9uVRxZ6pJSSimxEOORPv81WR7BA8Ip4sCMoim6AeEv+XpEgjJBvpgsTPkQW6B7AKAbxHDvqtrGqGxOZGHu1vpa272r5qmIMFK0tiMSgO97BzB3r23N+wEok6/NlopQbfu+44fHH5fz49b63/3pdz//h5/KQKwWfccYhA4H3kGScHIhYHIARCLhQEAmobek1mOJQ18ZaERkEJkZhCHczTAg1A4m5THhOH5x3PPH/fBXvwiD/Yf/9p9bH9o1Ue57//TTT1NOl4dFteclsRxsUjoAmxAGGBF04Ocj3Hz0UZuPkagJKYUHS87TfAoD9DfMgTnmlIgIwFNKaq31DYAIyxi99VsbV0Tf6+oO59MTYhxB00P39+++m6YJcWz7Ta0Tm5n2sSNyYCKi8+kpHDHmuSzh1yzbvMwB/eX6e8QoJY1hqsFUEFF1j/BSClNiFodQ9THU3RmRCCQF4FDzoRtEcgfAAILr69AxbfvmxpfT48N8HhHbthExIh/4CiKe5znbpOoln0QkAkxj35qqHmP8dV0BoJQ55wmR3+DlKan2nLP56L2aRUrl7ZEAPFC8iAQw3oIFOgaltDxMaRFqtd3dzEZxnXJOre0QHgZDVVURkYiRIMnMVIbufewxNCXOKTFj7x2RluUCQdtWETLTBImRGNBra3urDuYwmMuUpmHU+soy5ZISC6JoV8I0hvnYp2kuOUWgGyFMH9//+vHcjxc5U0EQCELP4GRKdfeclmV+eH19HaOFR7iEw7unH5h5u92XJV/O72rte31lpmmaeh+IcDqdUuJ1e12W6U3dRXHYSJZlyTnf7+u27wBQSsmZ91r3fS8leXRmdIdadzN///79+XxW1du9eVhKjDRqfynmr+tKWHrPKaUsOecMEEQuktJjWu/VDSMcwDxa74iIDw9P+6YROs8FohWZGFjbCNCfbr8jPP3wsQzt207r9nrkIpm/ATZSyvN8yrm+VQPndwB0u39u1QBtmoowEtIk/Hn/NGqf0gSRKErCc4JTnvn15T4teLpMxzSRiFgoBS/LQgTbtiKu3x78oW2aSkr5gJCOMdwBgpfljIjPz89179M0uQEnZObeNyLhJGauqgDJXcNBXq5rbfv5UjiVrVpOKWDu2h7mBRH39YbIpUwlL+t9MOXzifZNkfGgOrZW+6iI3sx705TKebkwc9VdtW71tm7zVBaR3Jvu+/5ttPvLM32eZ0lPIuSO9/vrtl/NuwhIEjd7eDi/vt73ur57+vjx4w/r7X6/3wLG0Kqtz+fy8rLO5f0yfWDx/VJr3adyhsAx7IgyGNp/+vm2LJehiizaRylzmG/b9vT0blmW0W2e5ynpt4vrbgycBNb+qmMQRe89oLkBnA6QcJdEhwCCmed5rnUIZ/dhJg8PT58/P1+vn6epqMXr9fnjdz9cLpfbvQdg69uX51trjTlN5fxl/dJHzfe43T/lnM07YTnYsZxSKkySLJySwACLuJyeACBgOZ8ec572vd23vu07YSKU4w44rvHt9trHbShvWxOe/snf/ItlOf/8858Q933f5+mh5DPhbLpt2hAxYDCl3vX9ux9ymm6iw+6t763fEQOA9/0mAufLbNHTVH744Yc//e4nxG2vmw7POQNJHwFBr9ef1PcxWm0gkgGNekKCMQYzMgMijNHGGCklMzPbzZlRltN8vxJiuA3CFI5+vK8OPShAABCRmx1TC4wjLD4YICBYUBIxMwuh8JFCdNxyBAhfE8vC32IgyBVioPbwjhGAzF/NKfaP/yUigxSS2ahA8DFXBwAEh7CwYWZqpuAo4jZUWxvrp883AAjibd9M9eHy5OFyxIt4qI5juljbTshEnlI5XjYp5Rkpx/z9u7+2kJ/+9Nv92rD54tKiqzdCS1kCUqBwTsLsKXESdzjmHEcFNi0zgI9xWE4YMQDcQxGYKDsCHddATfvorUVXekMpwFFwHFPJQx35yxGSuxMgBjCV1/XLNOUffv2ry2XGgueHufXt7el2iwiH4AMP7iZBTjbGaNpVMKbkkzRGcir5lPPStmFjoJDwVDgLch+VyOd59mjbtjH1y+UUZvve215bq7XW7abaaJ7O8/K4zJfb2g4k81SmN/cZOgT33nXcDPCg9ZQpjQaqFo4lnw5+/NANyQRyKXOSiSmFkjApNh3hggiJGRHAjY4UK0TY6jDrxMDM5EYk0zSlxOA4hoGbh9b++g9/+tvRdV1XylCtTVNxU4SU0/lWX3M6HWZ40zDrgC6JjgiM1vqhsTlo4hGgIxDiSEGCkJzOOeeUMqEQCYFvuB2qfEcQFsRghK29LiXn+SJ8KflsPnT4/aoPT3SA9VTVuhJy4tkdDoVmLpLSxFTUepKS04ykWQ4MZYmII45ErQsiAKSUAwjJj4MRgZPMgA5BZi0izA0NiQgtmdXhFckidHQww3k6WY/ttrV+V9sYTTgv8yPh1LRFxLqueOLHx8fWGg1w9/Pl8X6/HxD0WpuGDm973/a6T1NRVUJBwHBsbTClfGIiMTsYE0SEy3KOiNY3tY6IAPlA47gr86TWWACQW9NpKiKybdshrz6afkl4v28Hbrzkk8ey71VTKWkSEXc1CwB8OP+QCyN+aW2rbQsn4YmJmRCJw7GUkjmN0TwGYghKTvlymre13a+f234vJeWS1qoifMiKz+ezSPry5fOf/vTHp4dfHbQ3YmBOh1QrAojy5fwuwtyhNw3L7x4ef/PDv1zr9fX1i+ItwnOWMbx3FRGzUWvNaWKaENK3B19Hj7b33scYR9c2xhCmfWsseJDaHh7PR9W75Onl+ml0YgIEYQIIczOAkDHGPJ9ECFE+vP8VQv7y5eeSIMl0eTgl4pTSGHq77ts6fv3rv0HOP/38e/A9FWVWQBLOSAlwH63t+y2z7HXb+5oLP707Adi23xHS8SgSEeB/dIQBREqFSHR4zhfDjUmJpBSByPs2Pn74WNKH2reU2NRr62aQS04ZYBLVtZTy9PidKd3vm/AyFVrvFdD2vZaJpinfbruHAti79w8YsMZ2gMxfXq5LmUuZh4+X522apvP5nFLa9/2+XofZEdpEJNNUkM5D8X7fzNWPpkfQXZkRUXKe1rWG42nhP/7hjwByu72OUc13Ekbqah0g7/vWx12tHX7ojx+fLpenn376rKrr9jrN7N6ImMgiSERynoVz732vO2AwM8C+boAw53T54fu/6b1t2x8d2lQWRBTJ85xqrWaGGO6qvvYBzIVInp9fW7UxtPd+uVwezt+9f/drG0J4G7pLmjxaqGmr5/k8Tw+ff/pyW2tvu/nGlD9+fDpYQky43esYY1vr6PD48HRfb5+//NzG4NR676/r8w+/OpWJWm/rupYDwQJpmS/ubtaI2H1s+yuSTVNWJSR1rRZ8Oi2SgAXMBgciJHwLSTmyEA/eKSSQgCBAJCQGQUQCjLfwlLfdwVeW+fGHBzksDi2SGQCEu2NHGxE9DmbaL3iaAAjEQBLIDkyIb4hTD3CLsGODEwgQlIr0vTl2JG1jPZ/PQPTl+TVxTpnXezOzkufL5dwa39c+5YRAh9L7gF6PMYKRaUlwoVj+4T/8/v/5//7b+6frbDH2O4oTGGKISFA2R0AOwlQyMw99y4A1d2FOKR3MfvhKCP0myEgp+fHB3ccYo9bR+rHWgK8ml6PmOGqX3/wX/69vl+Pf/s9/TYjCAsC35z2l8v3335clpSJcaF1vqSS3Y6p/nMj+TbqrqoY6xhimkDOXhJNYWDIRyRTio/XmiXMpJTPcX15UDVBt3/a6eijLkZ0nDw8Pkuj19fXdu+/Op4daByHN0+V0zoAWTnUf8zQxFeYkXFJKHgYAbQwAQ3RED7yt+5VQcp5HNwjJab7enmt9/fGHvy75DIA55cu51KmqWm8qHMjCjCk5WogwEZT0ftcbRjCm4QoDCBGCiFi1EtGUwHz//PyPOefL09K6tD4ulwfCBiHCZV13ZiQ6Zszq4TklZh6jDd2XZRnjcI+ze0AQSyplNpNtv7vH48O70+nS2mhVUfL5fApPZiNgvPVyImFTcEeKwwY/z7lMS93H/V7H6EcRbl1F5PuPv3n3+MEU//jp9wfHg2g6LRkpTNEd2q4AKcD2vZod/GIYY1BKYSAiEVLyucAyhrmD0MxC7ra3+17vQvz4KI+PH1pLe6W13gDMvPXhTNM0zR7r5+ffqa1lonlJCISIoysJpZTu9+vt/rycch/bkWJxaD/v6woHQpdwr+u6XSHIzFXr5fzO1Ldt37ZVEpdSRNK2VkRGjDF0ve+vr69A7cjpVeutxfH4uKt7d9fe2xiac17X++12n6ZlOc332x6eMEqi95NcqjbBy/uP0/W66nASTixjUGt7H/X944/zVHqvB0mdmQG4VXfXAO1jK6WAHPtlLFly/rWbhEu49l6PYEt32Lbtcn5k5jHGYTs4ppjX28v1+pIyPD09pUTbttVac85Ccl4uvVdGWaZJ22Sd3MkAKKW2ttrqu3fvSj6pGhGb7ff7c8mnaZpD//Kmdve23+uuiFjKkTE7kAKRIHCapnUdIuJu9/s950xsvVfzNJXLASuvtQK4AARC7hUupx9P83cRMU13aGq6oT3Myw/3+2uZ8np/fTz/+Ncf/we3/brP+7DXfY9leZ9kuu4//9Vf/chAn7/8ZKO+vP60b+Ph/DjPJ6/Eec5piaC6ay5TKWXb7oLXvxzqCMI5F9z3PagxOSLO5cPlculdzwu+fol//a/+R59ePn/+9GrlfJpzrUo8DmJSNr98Vx4enlprf/jTzyL4/unpbneeiHjKWZZlIfi4DH//7seSp9vrneY+Wt/rbS4fhibTnvOi4669QxSMmVG078Q4hs3Tw8PDuwgnOFG0zs/bes0FkevrdUXgCBCeRvt0Oj3eruvevpwv01Z/Pp1lXj4SLG2PkuZ93/d9Nx+fv3w+X0rECE8vz6v7v5PkzJfEzEkjxrEp1LgTT2OMg2wTcUDblizHBMymyX77u3+n1qepEAtTfvfuw+26v7y8lnJi8du9mcFc3v/pT3/+7rtHZv/73/7f/9W//E/yJIufAdOf//RF6LH3sa7rPE9Mpa623j+7x5fn39/v/144/c1f/7MxxuvrK3Ccz7+53+/DP+/tz+pb6/T7P+gyfQxYAHD4QO7LskSAiBJ2hjmnyxoqnJlZeDblPNv1es9pjsCU8hhdJCOOoVUBPzz9lfWkdbJRUl6guZoBv21QzB0ACYQBDVAoAhQwiIoDcIRkhCDhXFIqkjK/VRuc5MCZe3AEUiABhipoZ60GEcHIEzLgj2/qjfj7/6lDWDnR9ISpZCA0DVfvxuIBClZpVNJdrfYUhsCpfDhdiGjb7ofIkVEeHt713ofuKZ0AaL0rI2VapjKxoGonjtau2vnd41+X9PT88vev8fLl7/4ff/y3v4s/f/qgNsbghXk4TDOgK4SQvYWmeEiwVg0zYDYay7IcSHJELCkz4CQ5AYFHmDviNvZlXoAZ225b1UOjiyAH6cv9OL8O3tev/rO/VBv/+L/67xwS3TGsd6sxcpFOQ5iEIQCF2bpmQfcg9u31ep7Po440YdUVtHePajFSKfNlkJym07hf3dBGe33+/PJl//7jP8nlidjV9ik9bHoXSdN0eX2+BoTmcdVPimFKl/PT+4+XIziw9koyST6pkeRT69e9/cxpLMsZIZ/mM6DXukVYHbcgun6pY4zT6XJaHvd9eMV5yUPX3rZpWkSyO5QyhR+4C16Wy/1+nWYcus9FerMxRgS83vbzeTlNp/eP7wk5pYQEr6+v9/s1nCWFA4mcp2na9/20JFV3TYBtWebb7aYDlnlubeQ0T1O5PJRPn3+K8JQSQoYQBBRmhGmesPX9en39KvoWkUw8yQhmZpnqrqpGHOb3n19qyghkOsyRuiGKPHx4h89GJPbmxUij+xgDQMNnoikCp+K11peXl3C5Xfemnw6P9LIs961O0/TDDz/8/PNnBH19XXOaZZoAggRzmcOBrLjrGJ2ZEIhpAsZuiv50v/1JpsgyUzkTina97V/A566x5Ec3KXx+9+GCwl++fGaQkk/nwmXKGLNr0c5qbUqy3a6ZhZnbtotIazWlEmaM4q617aVkAK91P1+ODJRwhzFa6/vHjx9Lnvd9vd3uAHA5P7p7LnB5mK63n2/rn86XwpRahceHJ5H0su1udLut9/U1pWQW83R296H96em9uxNNJbNa1bZNZ7jWZzea82kuH6pIkSIiYzQkr0f6Kdv9fnWHx8enfd/2vZ2XB4IT52E+ojXTaLAP7zlPTkzBkun55aecc8qwbS1AImKZzw8PT631fd+3bWPm9+8//P/Z+pNlybZlTRNS1VHOyqpVuu/qVHHj3ggiESCfABEkM1KQbPEyPAJPgiBAPyWBpEELGggSGcWNe6pdeLEqq2Y5aqUxfe99IsDEG0vc1zK3OZbZmDpU///7CbWPl92+Mbr2MRhttBKYNTO4mVMW1nQxzSFelqUglb/+OF6XN6VUVTUhqOCxrmspipQy+lTb2vm5quCw3/46iBDJ+UGqirlIRWtLT2tdQqqqmqAjSOfjC1FRmoKflGpBplpvJemSmTnnuHi/yHePv0Hkz5+f69pWtnV+5iLaZjeP/aX3hGxMvdtVKaXol2F5OZ2vqZTt/jYVvpyXzUa3zV6QBVaADRYyqt7cNYgy57zdfk1SE8nKNqVwCKmUsulMffjVpRJctd/8oWrs29urUgpgVuSJRPTBu9Q0HaHtx76pO9/muq6FaJCK8733C5Hc7NoYyhr28XD3rTZCC4VcFQRIC2QowWyanRS2bXabZmvkKYTgw3J/9xURzMsIuUgpu7t7AAwJ5il1mw2iWDU4wfucMGdG1AL1u4eba/86L9cU7PvHd9fLcD4PRej3j98Qar8Irfe20s65aZp220POICzc3Nyt+LZhPKVIhRejy+FwOB37z58uu+3ddnM7DFelTMxLjnQ5zQCQFl/ZqjY65ahkSwRvb2+Hr3bzPBst1yB4IuVdspXOGd2SpzGkKNq6tY2+XN6IBHB+//g7IYQPS1vfACsAFcNS1cZaEULMK+CGCyKVTFj227aTuLnZKS5UYnm8u7vdp5+e/lTbm+jpej07J3JRCHZ7eP/V+9+8vLwUCwy+bqqmrVIUwc0SmxQZWRodc07b7SZFBCEEbo00CPju/TtEfDu+lJLrRg/TW/JQspCiyuXifA65KMjyZ2bGL46JNSFECULCte2Rc8bCSMCZpJGrqOpL3fCFRSq+ACuEKEIiYmH+9dQPDIhAAPirKhtIoBDwM5Dil26BVJiS57hAciW4JS0ZuAicpulLAw9Aa50yAJSu29RV6/wshZZKSEmIoqRcOCGSNXUgWpYhJ2jb7WF/D6XKZX889eP56sYJShIIGXn1Bq8ZQIgMQMDEREhrruOXRVAAWuvVpQVQSEghhBRyLSCUUkJJlzKnhPzlPP1FGSrolxVenw0A/la68dN//4fVxiKltKYyGpWpkFgIBCg5Q/l5dMIZY4lCASLG4BBhWWKhApBTyaCMsLo57Iqkfp7dEnb7dr/fGiNSLEqDECLE6Fyom9oFr7V2fu42dzHNDMAIMURm4b1v25aIpunKmG2tQhxycbk4H+YcHTMazTmRsu04DbE4wKxMUVICyJz0N1//QQozTT6GLCT6IACKD6vulZ1buEhmzAlcKfNUNptNgRQ8M7NUxBwzh8U7KgrQEEnAyhijNWm9ynXLmtWySj7btjmfL9e+bzZtjD5EByy1IQRB0vk0pIvKOQhBq/XVe+/DZK3SwqaYDR22XYMIzs/RLa7MLKiqlZLk/TgOcylFGykEEJoUC0PMOeeEMUxrhlpJrJRYww5jXFJKhVNV6zX9VyptjJFSj+PI5dQ02/f7/8Xx+Pr6+gIFhay5iBi4a7efPr507WG3vS0I5/OROVddU1Xd9fKppBRjBDBCVN6x0dVvvvsqBAc0hTIpJStb54SLu57PPaFr27axzTRGLnLT3Upt3Qwlj4vnEEpdW2RDUkspO1NfL31OJEXFzD7SdrvVKp7P58PuvbEq59z312WZOKvabsdx1EYYrUMIAJIZp2myWghBkDyRDHEqBazVDHmep2VZ2majbYfMJSMTtu12cTjPgxQiJ7C2WpsKgtRKcL9cj94vVa1LSUiysU1OpFC/vH48n4ebw+N2+8Bcz0vfVAfnp2E8N01TSllFqVoDUrYWQ0gCQWuDCILIKiq5eO+k1IoUM68THCFQa/Le1/WOUOXkEdFYAVAAkpRKq2acQymlrmvvl2kcN5sNZPbeMyBJJVAzFosgbUhwZvBSiaqqYzSlQMmUUimZHx+/HseRL4xIi/O/7ABa28q2XXsDLJyfvcsxxuCzQKQllZJIMKSytuFX7TYXiDEiiFJ4np3zM0CRm/Zxnqf3j23TtMFzcJQTARRb3RAqIJGLmxcfQrhez4SyH71S4t37B4LqiOPt7aOUYlmmTXvgoq792fm02z0oWfXnq5SSQVTGWGuG4coFt5sbIUT88VeXys3+od7fF8h1FQCKwM2mNlrrYbwMdL45HNYhYq2bK83Bx6ZpNt2d0e2IPRLXVTemJTg2prm9udFaQy5apFhybWKMXkpZVRUAcZaFq013N01TXe3XfYFgcNNc6aqyldb6dL2ksFR2I0inCEZ3ddWOU79aNwWp27uDlh+v/Zsge7P9xoh516XtZn/Y3AzLhGXbtTvnnKb4eGuNMTFm74JE3bUdQ7ye0822JRmcHzbNzi9SiU1ltkpsoCSjmml4U3Jz2D4gkgS93dze3t6HOB1Pz/M8aLk/7N9JGp1zQrHVSAJKSTmnZco3u91X794vSxBCVI2ZxhDjomW12+3meRa0VGaXAlvb3N3cAXqr0xcOhFRa6+3m7rDTMcjdblcySaFizMMwSbVHyoftd5W5nQUrMdzuN0LyPKW2ehe9Ftge9ptPn/96vb4ZY7Rqa3vXn31VVe8e7i6X4/n6NI+ZSDZ1NU2usrtxHJxLiCyFZUIlLecxR5C0bZv7ts1C9kgBJFGk1WzC/CV//pd7v0AEErCGXzEgslw7+FgQf+VS5AK5ZERJhCAFkQAEyIWxEBfggkQoBUsu9IX5Ub7/r0EEkAqkYvyZ7b1WMBRLDqIkAvAp+ZAc5QUSkgQWQz8vy6JWwSMqa6pSkIvourppt0po7/0yeWMMUglxcW5kKKvMwocphaBFE+fTdB7SPKuSBJBYeZH4JSedSCGIdQEIZeYvw5T1xqa1rqoKAJizQCIiJmRCkmJVaSTnPSARRefXiNq1EmOE9U/mgoDf/i//Ef7mwSS+CD9JSG2VNOTnlZUCkBnWWReXUlBSSqEUUAJidFpQiJ4FcSmnfty+26i2G0KxuhFCRO/O52spqe/7xbmuTd2mWWYVQ7Gm9aYc9oe+vxz278+X53549dGjEA/374XQ3sVpdiEmrUWIUwLIxTOz0VaREkLlxDnx0+vLMFw2rSXBOScooKQyygYnArBfCIC4cAqqZB2ckCbmlKN3gqqm3lW2DSEowZI2QmWfAlJGzCkHwLC4ua660bl5csxUV61SBkkorauqYhxi9NMwAxaUsiBUTcfMiIIL5hzO5xNAAUwpe2BVMklhlNRNvRVidm4uBVJKWjfvHn7T6O3xehyGvzAWEgWF8m4+TUOM0SprjRGiIBUGStkXjoQSiXOElB1AMWKzHvoBopRSSAyheL9Ysy0ZJCkEY7QIKkupHx8eJRxiS0O/KA221Yvrn18+huBmP9umyZDdOC/TIAS62XDixV0E6ZxACdM190ljjDk4NJWSUvZ9gHWuS6RUFZNHUDFwwGJNx9mWpBIKrToHEwpFQlT1rZs55hxSQikE1YTC6DqEED1Yvd92VfS6ZCWwrWqtRPeSngiwrTfTUMZ+ub1tlUilBGC5LN7qJucMmG1lBFEIqXDihFqb+7tHrTZdc0gGrpch+Giruqqq/e7Ghes0TcCai1BSGmOZ2TknBGuz6g0AGAXowsUNXjW02bQAZZ7nqqpzIi4meh/cta6rnIv3pW60UjLnABhIgPchxZJj1Fpba0pZSikxOQBAFFJohKyNVApDXGrdIouwJIaiSKXknJsi+bbeRpeAkxACCUwlmXPMceUgaKVCmJdlAcyZiQtqUyMlpMIQnYuCjBAaQREqraqm2QrBKca/2W8FsNSqk8K4peQ0r85tkuj9TD+3RxGFEKoUKICmbpY5jvMVAJSSVdMhsVRiU1J8eLgfhvH5+VlIyEkAlm6zkVIraUbX5zSRsHVNVdswERdEtFpXVkuCilCk6OYltt2BhH57OynRdtU+ekopEZK1TYqu73skbku7To5/uZLNthndfOnPTdPkEsOEVldttVOy4SKNarWuEWTMyc2eTaltBUyV3qpNE4IDBi5JCmF0LVASKCmlagWhCNEvy1TXtRC4LF5KTUyzT/Pk23aTE1lrD/v2xT0RGiW2Vum64pzZLWFe5pxhu7k9bO5Kfmoq3m73wKil3jSg5ZZQ13ZvFKeYq6o5XQYhzO3N1qot4XUcr/vuoZ8uXChGBgbV1im7nOTd7e121/7401/8Um4P3+bEq2mzqXeH3X30Wgrdtp1gtd/fchE5plqb1LGbi2RaRrnbfDXL2Vo7L+Plcrq9vcs5z+NLyWq/fdy34txfoYDAWhgjsW6qu9pyTIsQcL4ca9vtd3fjdAGAmFxKzqtidQ2lUqpj6YBpHbnlnLWWIThE3LQPbi456krfHG4brdX53EuqrdrW9zcpT1K8aoXb7rDfPWrVSZDLsjCwmy9d/RUiH252bdv217Gq9fPLx5x4mqZSSttuS5Kb5mus5HbzdVMdtlusqvN0GgXQmuK6nrzXAmLlaaQYUREhY2FGRkCJXxgSQgitlTHGGK2UQSmYEEgUErgmpCDi2jpYux9CgJIskW7+zz9/uqhIDdKgNEC0OruYGX82dkoGLOBDikwsNeZktIVCyKqtd5vNRkpKKSHxNA0p5BRKjEtbyxjLOISqVkSQUhjHMUTPzHWVBDU5quE8vX0+jq+nMs8l5CWFErw2a5+CaIWlItEXGAkAf2nWAEDO0ftFqC/rAIRl7QcRElEpxftQYgnsENF/AZ7wl8yYnxWj61L/bbXx4X/4h5zzKjfhAjln4JiyZ86IjAQABLC66AoUViRCDoIYS3RcGEVMxXu07cP+/re5bi5LEOpwW1dUdnN4CS7nmIyyMZQUWcnGavSh5GKF2G02XVWrELGA9GHIxcUALIQSjelESqmwN1bEwBzIKIMaJApCK8jarp2jXyZCksFNzMqYbVvdttUmJFUySKq11sxFisbojcBG6qSkLVkQ6k13sLbq+9EJNGqjlEI3AKSQhpK9km1OOA4uZ+Yiqqpr6p1WtZTaWhtD0UJBWcg2KYfhmphRKam11kYJqmPIpbAxpm7MNF3P5+um3e93j4RrVboQdJJk8HGeLkp+Tjs3LRcSsXC+Xodue8sM1taHnZZCT9Ps3GKtRsycckoJAZSsG9MwYylJisoY5WKYptFa6jadFP4azimikvWmu5PCprwypv35PEIJhZOQnEvKGaSkmEpMvqqNEBTiHOIsBCiJMSx+mRcXlVSCmsbcburHGMpxPh5frj5fYppiJqstZx1CKsWUVG26gzGGGHKikkkpmwpM4wwCKruz1u6695c0c3bzMixTkdAYVbX1NlUl+ITcIpuufoh5nKZJKdW27TjViNg0zc3N3bL47eYgBM7zKIX1YUpBuQVHP6fIWucUIWcvpVSqrStl1BZBBL+EkOvaNvUmxNGF0NY3kpplWQSptanmvY/MgmolUZAQmqEUiUpr4X0sUb5/+PrTx5fr6eXd41e1bZCJgKRuuvaA7FO4QhFClFTSsiyNrUhTV+2XOcQYgUkR1JuOsXiXCLXWNsYY/OyWEGIutWiabruhEGZkGUOKQWplxytsm3dNV5+uRxcXEnkIl67rsBCzmJY0TClErJtKmSpnRlar9aGUDJhWUA9hPh17W+m22eTiQf2aQFIyMJN3pUggNIKKlEnKJAkA1m2aSvZKGklNyPP1Mu12BylIWCuEAihKY85JOjcTUUxxHMemaXJJNdYMfpzOzCiULqWEEEoiQQaRrFXACoCsrao6TfNIRFLqlBwgKk1Iefb9CnIxlUCglJdpuQJ5Ienl7Yd5drf515FKSimX2Pe9MSalDBgAY4GIxERUyoorwXHunZtt3QBmt6TKdm3bXi5hjZm1RitNixudx7ZqgYUxxrnxcj0i7XLO4zhuNptr732KMSQhRNu2AjHmSKKEOCF1AEXIUji8HY8pZSllTP7Uv16ubzc3eyGYma7jBRHrug6+9H0fQ9HaShlLKVpL75dlWazVDN7nfvGXaZqW2X/11VckopuvgB4wI0gtu5gcGS10MUadTm+rve2wvwVAKTUkcksohQhYKiGl1tr8zKmSgqySNULgIrkoBHl3+zDP89Wcm3qzLIPFarPZNU31+nQumTfNZlgKYKqrFlEsiy9JCSG6ZuN8nyI1TZsilay4xJRKzjGllGKWUmqtFanMa96bVHqrlRYk6qoAUMmy0tXb25sSm+3m7uZwp2RbshDAdaVnPz/cfXd7c9uPVyJwc9jv3js3N9X9btcOdrheh213J4W5XC5tvVFikyJqXVnbFF5zSAIgAmT4Wf9ItIo7UWspCLAwgUBEo1BrKVbmhNZWG2OsUoqUFErnL72K1dSyIp0KYFljY0HQL92T8uFfQxEgK1AVCl1QMDOsJk/OyEUUwMze5TlB0ZWpOkLs2ptlcdnkqmqstQDFe++923ad1Uvf99Ens901lZz7sEyuqQ43N9vaDufzMed8e/Nu2z2eT/Pp5dNyXcDlmqQxCKKwsrWxPvlVhkIrrB2JiQrzerJY56lSqVVKZoz5xZuDiCgICNfwU0HEK3syJfw5bvTXTgZzKeX3/9WvYbA//d//IeWcS16JVwV48TMzEgYiQgLmkn6GkDKwi0FKxSElZBTFzbOqN4svgzf/8l/8T+v7xzGXfa2MrrU0X6n7cXkIcb7bM2B6fvl8fLvutrebzb6fRgLwDoxuhuu8zGD1VgoDuIpOFJBpqwcpzevr03AemraSVFlbKaWoSC6C0Oy2h1ttjfwgBc/LUGnT1XslawTTtjKlgkDGVDHGmBxgsHoPUJqmSynHkCvTaqW1RCUDoSZUwApREgAxWaWI/aYtzKhV3bU7Ij1PLqXMualMpUSYl9FarbVaERrjOLbbG2NVSiknFkJ37VZp8cn/VJmnTfPu/vBb7+M0fDTqsNu8k1KGZZmX3vvw+vYUgmvbjbX1NC4hB86AmLXstLZ+EaFQSbKqBYLmErmoSt/uNo9SmhhjiFNd19JNywRuSdbIqurs3U1/XbRsmuqeCwQ/aG2Ikp9j4UVpsekOMfkQvTE7u9lLHFKZjOq0tlrmpvKADAVKBsRtTtBUt4f9N0RViL3SdWPkvJAQNy46IRSRtBrrukEEa7qUQw4erUgRpJScc9PaEItSyphK4tZq3dZyXqYYfW2aAiCEYB+tQWCVgqirHYr67e0tRUAAQVYpxUVXdlNZLrkYo61thTCElRbysN2F0+zmBEXVVVsKG1MZXY3juMRCBMCya7dVbVLK59M0L+PN4a7rHoI7Kam06oZhIDJNXZdM65FPC0o5BLfY1jIjift9+83JBGCndbXf70bVO29SCtFrSdZqQ5isVpG8c/NxHOqqu333sGnx7e1tHAcEoVVt6zqEMWfKxSBZRMnglLbX67TbPtzfHsZxdm6GTLWWTdNVuttut7MbgUe3FJJBaxl82jS7nETwXomdlpumNli4xFAKlZLEl+jKnEsoMTGzxL0QQimxDFNFv7pUiEzbHAhNyULJGhFJZKVF8gkApFBZ5OhlZavKbN181kpw0Vrp7eYGAN6OL26Oxlby7fz9siw+bRGFkmYaLvtDc7leUxkAyI2cmSBD122VkMsy+jAKsueTbJqOMUzLFVFUtkt5vg5uZcJ3SX08fWDOm22LXPmwzHMvJChj/TwM06kJ8y9X8nL8Y/kKL8NPIb81TdPYbcjleOlTKiGGRkhAkQr7MLpwufSXmC/RC5J3BjYunHxYnHMMXcF+GM+ImFKXEzab7jSeLuMJ9QIAPi8y+tPlhKi6duvj2eT8fHx+ev5QW22Menrtm6Zy0Y3zJYTQNA2XeDx9CCHMy0hyXPwRWIzjeLjZEeFluASfvY+/+e4PmYvU0cdpnucQ3Xp4zcdjjGFa5s1mh2Ke/cuHz/906j/H8jq7r41tDdrnl09dVwHKS/+5lDJOdWXbnDmmMUY+/3jZ7Q63t7en6zhOF23k5nAAptP5GQB8GHOJ2uD58iwktm2DIk3u6e381+tleP/Vd03TIZXE/aena9/VyzKRKCnFGEpVddvNbYigjWDG9ea0MgRzFsHHa3/ZbreA3Pc9olgJb6lM2pAQWNi7OaQcvPdK6gwUY7y/e2+sMKYKLucEs592+w370nXdNPvgOWePVIIb53kmIY26pW4rcd6uDvLeW9tISTkXLbGuTWUUpcLsGWC1gvztydsYY4wUVKAUYCJEQbgqFaQUyFBKgcIFgZBAClQaSRZaFbgFSoHCAFAUoUAEoMP/6efPlgAillbIilEDEBQmAOTEJVBKyAUBUUmydRQoQEsQ2/peiWVVXKZQfIjeR+/DdtfdHPZ1te+HyahdXdeHXXh9+6zxOwmNFcu+vdNGbjc3Jav+9GG4zn5ccHIIEYhzzgjsYxZSMBKsLwQFkwAAxrIWDdbarutQitWttzZDjDHKaPjZe/JF5JX4F8bXFwNLKStyY/3L/6za+Lnlg6scpJTCXFJKSpXCGQr8jMj7ktWSYhBaMWHOASH6GIJPsaju8Td6e5/RkgAsKMgqqlixDB656ja1EMUt2bmFSLTNJhUwujHGKKWmJUgp27Zmbq7DC0CxlcwRmKGt93ArY5oY0jQuyApL1VRdZbuc2eqKUR02X0kptl20SithQswlIVFGgC8uIZKESggNVpeMWtYCMxRPaAhkVXWlkJAJABCUVtrozqjdikaMaUwpG1VbvUupcGYlqLYbImm0XcHqm3rX1jcpp/PpQkRaWqspxQwgBVm/eO9AipqL5qJKzgi03R72+5uSRY/jZvtIMvfDcZrP3ld1db/fmcUfz5fX6/UYvXu8293f3k3TNI4jZLZKWAWEVdfcb7o7YJxnZ/QshMja7jYy5UAgBdZ1U3OZESShKViAlVb6sNuVwm6+ElHTVCmn1+Nxdf4rDP34TMVqak1lmHMusWTIIW87AYCV7Srb5BytaaqqIoLgU1M3DeHP8qBVd4WtvbuORyVV13Ux5BgyKbq/v1/mkDPHGKcplALW1kqZZfFrDR1jTNEZY4wxPgYSZNWuqVigyrHU5s4YE5MviUyVnp+fY2y01sCKoGqqbddtIoRpmtq2vb29z4lXls8wfA5+bprKWKGUWoUddbXfbm4JTVPtRlka2zZVM/ZFktRKN9tDXden0xtBCWGJ/gxglNKVeReCUWLXHlTwbp5i8DwNCUAmwu3mtraYc5QKlmWe43lxPufSTbxrt5tWIFelFCm0UW1bdTlnRLLWSikWN+UcL8cTlEqqjVGGoLX6RkpFKPfbAxI9vV665j6k6EO/6w5Pn18aba1tJAG0xBxj8suyCFE3dRPiwuyd895nIYvWurKNlh2hcIv3rtjya8GhRGvaRyg255JzokRSodZ6DgsRWWsRBEFnjKmrNjhViyClUrKypk0pWR1j9JKkPPd/fnp6epfeSWm9S6UUEJthPDM4BgohNfUuMcQIRGpZTilFIDNOZyQuJeQStarH0c5LAM7zMux2O1vfPb28LG4IxQrcOOeYWQgEMiRY6jhNb79cyevxz8vnMMxjLHW3+3qY3Dgf5ykgolICxUCkgk8hJBef++NVXISgKpbT7JthuixTISKgaZjj4q4MeZ41sPz0CiGElLILR2uNtXaYh5AnKarEhZmfXp/P57fz5XXbVdtd65bcha2LIYSkpJHKLMsyLSODZ/Kn68U4UwpO41JoV0ocx5lIBF9OV1oWd7lc2rZt2ybE2PdXH5YVLyGFPtw0w/S2zPH57Y/j/OpTjcI19aGu2mF6WrxsWjktz03TpHI+X6/eewAonOYUpU/DD5/Pl9d2297e3oeYx+mydoOkFDH5EFxKoW7sZYg3N4d5Hj99/gAs6232cRdCWcLr9TqcegGQpCLvfYpw2N/XDc6zi7nJOYfoxvlNCjstJ0HKe+/D0jJmjgX9dZxLhlUsIgKXkpl5nseVZ9U0VegvKc9Ktys9xvkYfJYo53lwfkTKl/NorQ1x7IdXAKqqBlj1w2mZvZTy2r8x5HbTFMyZZxfcMJ1znrSiuCzABLjeDgm/zEC+yAVKKQy5pExMUohMxMy/HOvXoz+WkrhgzisRi6RmZk55LWEEQtbyP8OVMiGiQGFBaAS1NpmAM3CEFDAtnANDUbWurfA+hpAEYD/3UkokyCVJSRoppqQNVbYz0piuEbL2s9eK37/7zhi7bb+SkoI7K0mV1Ua2S0o5cw7ZgCIiC4RYQCKj/hK6AYRrOhdQgYyIhABrKSClUutt/ksrSEu1lh1rpMfKMEFEF/yvUFH4wkyDwkzAzL/9X/3xl3X4/P/4V6uddW2ZCiEAC2BCykIyc2IGBgZYcV1rvYIgSymplFJSzGUuAG723f7u4e9+P8QggJWtgnNGSZA0LwuLIKXJjCmV7eEG+7OLAed+NQoqXZw/Ay5NK9eEZBvt2/Eoddxt7/x8/MsPb8aYu/tt8NIryim7ZRAgN90OsYS4FFyQSohRSpmBc55TSdrqaR5KRkQlJa2U8XVNhCyFPQMIuUJbQEndNgQYU0p1hXVdr0kcK4B8cdeUitZaK5vinHNOOU7zWDjEGAEgxiglWVunmOu6/ZkWKlOOOc8x9+N0duHEzEgxlWlyx3F5AlErjUZt2k4TUcqxtjfmbg9AXEQqYKvdgVRTb5lZyl1V7ZW6YT5HP0uptJFSWK2akrkULiVZu2EoStJ+VxFBKZBzTl629coDRSKqa4soAASwrCtizgS65AXBSGEqu+lqKSXFyEY1lalijhIyF3TgK2PqqmFg5xwRmrpZM0T2u3tjTGIYhqsQWFnLjAjKBcfMWqngU86MKIVQKbq62k3ThAA551LSskxEklB6F8GQFLquSSrKnOZlzDk/3jw0lV0J311bCyE4RxSyMu2mW7Gz4nLpc2ajawRRmXtJ0Rhl1C5CXjdbJbrN/mCs8n4RJJVSSnRr8KEUVUrJmrDd3LRNG3eaOaeUJDca212jXAzGsNL7wlFK6uoHKdRu81A3Zhx7gbK2jdU33nspzGF/DwDOzaWkSNTW6v7+3TzPJSkUdnfotpt7KXTODAKs8s4vMfq26ayxwCaGdHu3VfrAoITUUrE2goiW2Z8uV1vXdb1pOsuIyzTVene72aYAoDpac/Ikj9M1R3Vzc9u2m3G8jtMpBiRbrW/gzWaTooox5pSb6pbgV/CX1XdG3SHInHOIXim7IvKUEIioRGWMIawQ0eh6vzXDchEkre6QFUHeb63zc4xejsunJbwKvZvnK4KpmurPf/23QsD+sJ2mCVA8PP7mfB4+/vQXLQuJ7F1p2x0wpeBcGoRAIXfzeN527zfb+uUl+TCM89s4PDNEhIxkkVJlLQCMYy8kI6XEv2o4mnqbZH1zaBGFUZt5eAshDf1krY0Z/OspxsiMOUnGIfPVLTEnOYzHtq2UBs5dW7UMbvFXF64xLQsIrS1jTYqMxvP5dQn6Ru2ji1IJBHe+jFVVPT19Stnvb8xwfS54bps9SunnKYQCaGdXFreQZMBQ0Ds/2XpXSl7C5fV4nucxxqi1XeY0Tse6bvt+ILmP+ZwiGqumZQaU62fm0+eflLTL4hmcqbK2IfP1xw/Ph/2tMn6ZF2VkKtM4z4VTiiilJEIfXSpl8aUUUBWQiK9vH0LMDMP1eo0x3tzcKCWmpQcoyznHyCiGy/V1mM+3N4+Lf53nEcE4/2wqAYC5BEYACowQkno7+2kMdbWt67Zw6odrVdVlgRDcssybbft6OvV9r5Rxzhldlay6TZV9GMYrMy/LstnUQsLn5z8JqqzplmV+eXnpus4Yi0KMw9yPXlq8Xpfz5bzf7zKPb6cfUxnfPX6DoHGYz+ertda5ue3qyrzvryeB2fn59HYMUySMggALAoi15lhxRqtlhSSt8ihkkCi1UlpLbYRUQmutfkaMfkGMAaQCCpCEQOCSEwAgMYBASVAQb/6P67uxfPpvGJEFIWkACbRSPAG5rOwN5JziwpyVqUWtKKeUi1Vycdeqqk6n0zAM2+1GG5myU0p47/v+UlWVMvY8X2PM8mYXQuqH493N3XZXX65LTHMGlTkt/jT1U52jBiSGDCkDS0G4amOJCGVBghUlgoxItrJCCGutECIDr1BRrbVSah2GCqVW+llJKeccYgTmFef1xUPBAICx/Gd0HFhFpr9UMKUU5pxzBihCUklrb6MQARIAcMqRmYVcqdihJB/irOsuTGV/cy9qfX57w4AdFok5xeHT6RlRCJvqaru4uCxT00mGfL0O4zgTRM42J/zxp78CFGOUD05K+fnl43V4alp6//7b4OTY565rl2BTUHXdbTc38xRzcdN86ft+mqZu0wDAMvvtYW/Rhuj6/iyEwALAUgitlJBS+7BCjXyBCQAIpTE1m5qhWpd0cS7nspYmq3mYmaXQdb1Zc71X1xggC8EkEpdwOj8hinmeiWC/v4mBN9025zgvw+K8DxNzzsW9Hj9M8/nu5jfj/BrTPE6XVMZUUj8KSc42EAMvczK63e0OpaR5GZDA6D0RSClDCFyI0NZGiRs7TYsQQKIAQAaOJQmJVacxSyICEqWsOWTo/ZqnbQDgfD7l4iujlapKBmBc3CSVYEjT1Me0SFWcZyFE09oYitaaMU/DOUPR2hQqMYpscgjee2+sWpbgvbfWphiUMohiTU4FgBACcDFWTNNQjK6rTgg1jS4VJhJcQoxRKtKaYo7OT1pVWrVr6RZCCNH5GGL0a3bMvBxLKc8vn4QQQt2twDpjTPC2aw9SEkCJ8QgA2sh5GXebhxBdCCF4RhSESgix39/kmHabXYh+fZPH4hB0yaRMfTm/lqSQbU4kqUoppbAUw8CiqXdlWpRSxm5PpzdCVTJIq42puIDR7Rrp2tRdTm9EOvgUY4wpKKW69ubd/TbDctXn4HxOkFPmIrRuCkMpLiW/zC7EpWkaAqlVUxkVQtCyA5ApziHMzEUbmUuc/UiKKtsg0v3hW3Wnhutc373PZWbG8/moSDZVxSYllxrbIGtCI0XTNrhS2rzLflFKKQQ2erPb7YY/P/+yG7TNDVMHgIQlZ9a6trY+LRetc8lAqKWwUnBKhVA3jSUlL5d+WfMaAIzRlZGbTsrN9gbBHl+Xm8NDXdvr8KJNJpGBppQHKfXb24/L4n28hIRN09R13bXblLgfvFV6modda0Cox8M/3+xUf/JL9h8+/BTwCQUdr/x4ayorP3z663a7lYoXN+/3e/+f2A2EVlZQhSj9zAI3XSP/8Pubebn++3/7/845vX//HlGO07FpOi7t0/OnbWvbrnLOuTkBORmWZVkY3Hl49n7RcmP0pjay6zok0lqS4JgcQBakkPXl+vzjx9e61kKqlEjbFkky8/V6nsZ+f9g6d/z8+ceqqpq6m8beVk27uyGlve+rRvf9Naa4pM8u1UbePzy8H/rJOSeRjFLzPIa4tG0lhCqFS4aqUufLcymlqqXzWpAGwN2uS2W69qeqarf722lB77NoBSEWdtfhGEL49ut/2HQP5/NxnF9fTx9y5t9898/6EaQGkuLaP9WNYlzpqLTd3D89ffKx79ptTqRFbWozz7PWhkjGkAFkKSClFjJcp8/Pr4u1bdPB/rY7Hi8uvswe7m4fhIh//eHPqL6u6l1kWMYz4hInL+idjQgA1tQpJTaIRRlRhTw/v/61rq3R7TLRt9/8FymFa3/MjIBl6BciuL2rl/B0vQxt20pt5nm8vX1EEQpcfep9crnXtNXtFl9ensept1alcZymQaJSUq/ZWauBlQoLRgnUIFDOAgQKIkQJxTKoBFYoQSAFKwkkkaREY1EYgxIAIRdYUdslAwqQxAj8N+HFGRNRhWoDQgJhwcQSoGQsDnPAHCCmnHOA4tx8fL3OHG3bfJg+V9ng/v708mkOJxAIS9FyO81VSP9UsgRWtzfvYgmc5XG4XKZT3Yzx9Jyjn2e33eznGX/4p+8//uN/2OQpeRdyJFE0SgmlZCYuIIQxZj3Jaa0BwChDRMoqa621FRGVlLTW1lglJAssJRGzJCUJOMcQYgiBIRYGLoVzYcayZsbnXBL/3f/613i2D//DPzjvQRAJsZYdpaxxqQWQEVkJLAUTc0oZvjRJMjMvmTEvCiFhUaYbS1G3bf2t8uk8zB8yZ587pNqd3DAftc3tsptGtbh5HEelsHBSSviYoYCPigT34w9MPlxd1+4pq5fzv0kpSbM/XX5Y2TSRdyTfYVB9f65s9Kmw3I4Be//Su1dfDsqkxV+mV12ZQyl4vZ6k4l23BygplzS+OheU0sxpGM+QqW22yeM0odba2tpW7TKnabxaKy/X1+2uS7FoW60tzMmv0UhKGzkuVyROIV3mlLzTVTlfPxQsp3G6jlVdbUJuBGCIw9vpVFWNMWbNJJJSDuMJII/Tmw+LtdqHaZ5ngCe8zsRSig7yDbZ1cim6OeeQYxFCAGD0ZXSXUmC73QIAkqubNmdeSdDn4VVIkJKsbNb5DjNmzpMbLtdzVSvKMsUyzMcUSrB1W++VUjHkkLKLASmEPJ0un7fQSbPxntHVSgkXjn1/nZexbbakkGNOIg2j67rO+Xg+91rLnDNgXBY2dcUcAZLz/nj+5ENft0KMap69rr4iU+dUQhmwaAJQZAGTUjYE/3Y8Apbvvv2tW6aX0w8AVFVVSTnlUDi5MPoIBeqm3n16/etmW3cpvh2f316vWjXffPX37x/eD/P5hx++f3t7++67787T6/Pzs9ENAL27/0oINfXDEvzhsNNN+/J8vpz9zc3NPM9KwBj96+unh8ebecwpTJu2Mopen5+5oJSyRBACxnHs2oMAyTk3lXbKjP0YlbK2saa7XE5SCkGistr5OWfMKQcRu659ee2rylTWxuxTKm72QMvb+W2cLm2zIfVVozcuyJfXn0K6xrR0W70S21bxlVBBKvJ5GJcLeXlnH4fxWre5wBBSzD6TSHVdR3Cb5k6RPJ6PQIsxrRS2qTVCVbJIOSxzQLD77S7EKUS3YuDnKez2m7bZEJqSfk0g8X5Z+mNdt1pr5syEGbyLY12p3fawzHkYMyMDccwlLGl2Tqraey9EJBnd5K21Wm7l3eFdDk+iFT70JCIRlSBI6eilVlsiOh3HEEJTb9Y6qK3qUooQ1HVNP445hxCntrt7u/6751M8X4+kqMDEzEroknKOcpqvzl87tvMEiGocJzecfrmSaRnnedjvbCnxdL5KVVDUzuvL5RRjACzGqvTl0wUhhKqqvvr6nffL8/PzevovYyI0pUgrd3W1YWbCghScv9ZNt5YmMUYCXHJ0/nNMs9ayrttxnLeb6uHh3YcPP16vV621VHQ+n0Jwl8tlv7+Z5ymE8K6ppZQoxLIsqQRtSGo0fCew3Xbvbm/ulRzmeXYhW6sIZYhuTZ9HFMYYH3ttICedy2ytTTnmEpraTpNv2xaR5nmepmm/v9tu9lLKT59/iDECUMrBuTEXDxgBfS7h9fiDD0FIcdgexv46TtcQ57qud7tdycMwvTRNQySv1+HmkEioab4UTkqp/eEmlfLy/GatbbvDMMyknFTG+et/+Me3ZfFCiO3mkHPWkra75nDYfPfN7/7DP/7HKfOm2/75T/8Wadjd/F3fD6fT6eHhndSY8pxKGKd5t2+v13NK6e7m8ePnP16ub0SstFgxD8aYPFjnfGHYbvbjtEipL5eLtXZtnyjZ7LaHy+mzEJjjYpUGz5xJihoCR1Y/h3Uy5wLMkjEBUlbERAxEJAUaVFIaIVUsCjMVqRgEAAEgMuHaIhcahABmTpmRMmcEJkC6+d9/aW98/q/yarUlLGsqBhIw4CohKQlK4riEuFz9OJzmq5+FlS5P49R7wYP78TpdgXiaq2GatL4YXdV1l+NClC/9Z0QxuzzOwMyfn043hx2nHELCMX344S8//enHkgNyQmLi/4R5upJSc0xQWBm1BiMpJYUQ2hilvsTTAwDwFwB8znnFfa5fA0BK67l8DcFjZs655JzXX9Pf/7c//W21wQg5ZU5p/XEEUEoQARKthcX6nb9oQZh/zuaFJABiSSmnJcdS14e7/aeXp4hvl+urUsJajTkP03VxPZJgo17eLiEEa602tXOZSCqtxuFUQHKEuu0AupoZWADL3333XzKzczOU0jbGez/Pweilq6Vi5cJ1GBfg6528y3CN+XydLiYL5yYAuMBnLlg4bW3Xj66q7BL88+v3Q790XbfZ1iEukFHF5H2q64ZUdTy/pCOnyAKlTyR0WkJ6ezttt3utpXOzNnsU8nx6YkjagFJ0Pl+9DwCMgxcqIeHiegFxWcZ+FH5eSBQfY0jnOm+MMbtdG5PUqmuaJkZfxtnHy+JjKaxkpTDnhFiuC54KDCmCD1PKXs3bttlYawsEEDmzGCY/jiMzz65almXtwaS0ZnFxbezKmc05M6GU0oXL63Hodg1zXpaFAKXehszXYUmphBCMkVqSC2cfT86nfoh936fs1q3Y+yVnTnnwsUkpKaWX2Z+uphRQSnGSfX9h5vfvvz5e/urDlHPy3s9Ln/LkEp9Or/v9rezD8+tfuCCiaJqGCOpqG1N++TgwR4Y0TVM/fr453IU0TtP0egyCihDEkHOOSgly9fH8QVeuoPvjX76f5ynGYnI7zNW/++Ofnp+fU0pfffUVqeGf/vynaVyMad49vgfRXIbpej77FEFuqqo6jx/CMUX+ep7d11992+2woAaMr9dPSpoI/vPb0bmglZ3m2LbdEpe22X18/rGUIiWFN2+MKZQP97CEz/M89/21ruuqqqY+LstyuNmWDEApZHcdPw7z5+3m0NTbGHNI18KLC9fFDbnMIS5KabeEcT4qXWKOz685J7GSk0NwH59S07RaqzUaYpxOQ7/cw7a/LlLaqjIxemstgiGiktyK+JzmIZdIRLnkmNLsJ6mlUmaczjEt64yPhHR+uF5T0zRIhfFXDsfl+qTxfT/2gKWUsCT0PiKKlLppuSDomF3KMxEubvAut9sqhiWXYGvLEN18PZ4/5Z+KPJ/7GCOJsrh+cb0iWVe7zWY/LKecvLJWGlZKI0JKSWnRdfvrZVRKNE1VoCnsL9fXlBJg9A6qpiWRnS+VvLWmGUI/9E4Z3GxNysvQ8zff/FaZ4P+Gbs4lKUVS5XEcL8NT21Yxj5frW0rp3fuH8/n17fhZKZVSZja5rANRO899zrmu28m/JeKb/SGEVAoghIweMPXDq9Zaalpc6K/jfn9jbNX3/fH8oarMfr/zPucom3qfEyIoU7Uh+JgSQ2ZClOusHBDx+elVqf7h3VdSynm4MnlbUQp1ydhfRzf9mQsKIQAISFtrY3JI2YdRKQ2I/TAKgTlWtpJCwjBertdrXXXW1nd3d+fz61+//76qKinpfDkKIV5eP1U1aVW9vT0zv1aVzjyN89n7xcdRaUNojamcCwDU1F0I4enzC1DURmx3m5JQSnJuGsbTPPdtuysl+TCVUnJx2jSH/W1O4vsP3396OtV2T6SttZvN3Xa7eXs7K2msaa1uTufLNPp3j98Imar6UGDsx+fT5ZIyA0YGYC7Xq2NCIrHdtTnncXp9ev4MkHb7xs3L+Xxt6i3J/evb7Jb48PDOVsIHkVIquVyvizGmqiolKwBB5GLKSKCwmscQAxFWIEQGBQCMkEthZCWEUtpIJdQXbLkQQgkSUqIULGQmCAIQBDIBkwRJAICYkRCJkLik8nPsMmPB/J/NESTS6jglxLVkKcgMnDCnEj1ACmlZwtT7vkg2hnLqSxxHP6XsMpeuPtwc7hn6mJZ2o4yyy/IW0zyMYb/fo6CYcmWbVqrCi1R0f+i0qi/HlxgGCYAlIWRBhehLyAUhAHxp4yPCKs5AYm2kUkrbaqW54xffsPg5FeVLpnnOeWXXrubeL8jRUiAXTokzQy5/W238+H/95wDwS9IEQInBrZYXQM65AEBKoSCWktYI5TU5JZWUcxSEi182m82cAlS62rVzcpfhLBUzZiCNODFIQXPXkq7EdXha/CyEEEoC+cJucc57zzg1ehM9EBog9e7hay4ipdw2u2t/vl5PLlyC94KquqJl9iVA4SRISWMEAaDPaUKI2xs7DvM49UIgYE4ppFRI+Jvt+8Vdx2WKKbadRQrDOI/j0NUboWo3XJbzqXbN4oNWFojuHr5iSDGVaRpcGkySLhWAcru7Y2YfYj+8Tctka1Mgk0QimJe+VgaRoHihRIgu+ezcDJhj8SGkaWm79qCUCsEBKyEwZRfTWGBm9EyccQxLKaVgIcjk01GQlEow5BTmgqeQ65w5RShwRRTjOBrdMNrMmTEDFpSeqeSSXKK+v6ympViy1oaLSBzmxZEoKDIAh+zzPKSISlYxTbMHqaDvL0sYhZsZ22G6ZDjnnBEUIjHj6XqSk2RmIgmAWllmUUMbEg7zMeecPx2v/ZFENkZ670spSDwOYyzDdRzP1x9i5LbZCqFGp4xRs98Syut4zTkilRBcGNLuBrpt48J4uj5phVWtUwqIgkBn8MN8tpUep+vT8/dt19RNd9hvno//ZhiG1bGVQHx++/Hz83PbdkKHJaY///DT9TpIAlL0+RVKyYsb5tll+ulyGRL8vm3247y8vC2J51JKXbclQ85ZmN2S5jyfL6fl/uHu7e1NSlJKzbO7vbmztv7w+d+utf6yLMNS6qpdE8QKVcGnYRiq2gzDVQgx+xpYtM1unC4pLykviMxohrlPKcd8jslVZJSysTipKgBKnF0anU/a3s197Pseke/vHx+/2k1j348npRSKbpz6kNpNdzs7EKRICYE0urPPYiWECqZhPitZyahOp6OQvJFt34/AMoOb3QL46MI0u5dftgVjVOJpmPqqFjG58ToNw/z+3W/6cQQQXbt3fp6XQSqIITOjjjeAJCQgxev1OI49IjZtLU/nTymH6xA3m40WmgtYa5FSXdtp6kPMSiFj8cHN87zZbNySY+Ccw/lykSpXtgn+yhCbtiNSla1P509CmLvb3yOo/vrH6/S22Vop9fXaxyiVZqWUNc2vezzivPTn61MIs5BQWLgpCrLW1EopQH47fmrbpq1vicgY1ffTn//8x/UCqqqqmwcfi60ECUDSKXOlK+bcXz6veM0YI0NK2Tmfp/mKVKQS8+xKVvvd/TjE56cLEd7d3z89fxj65eHxhiGt6YtG2+xH55IU8nQcFueWxQMtKbNgFGRjXnJKWmshMRc3z33mOZd5XkpMzlhFtIYr8t3NvbH0/Prj4oYYfUquqr8KYZ7cq6252+jT+TOh8T6mPLWbXfB+nsecQJltTHOM0VprTCWkCQ4QVNcecgk5+xi5rpuSmVUiVCBSLvMynxCpxLLMKedwOr0pTUqp0/npcrmULKRomrqSouICwLgsS86vy+IdM6JY5nA5LwJlXW2m+cpF3T8+lswIcrfdAitBytR6WTyIfDyeq8qUFJlj26mYQsyjQDrs9kh66CfnfNt2XdcgZ6XU9Xq6u7s/n0/TPN3e3qY8+mmKec4sgJUSigWGEksWCEKqRiqlrDHGaGustU1Va60lARGBIPUl1Q0RgDlDLsBZQAQshUqRxFKilIwCf8GVckYugJkI8WdzCn/6rxkASANJEERCrQd3WHmTOXMKJS4xhsAxy5JTYgmAkTltm2qKBF4/3ryzpiPRWINSGM6qrNP04lJZfBSVbaw0dWOR5PPnJ2TWWs/j4saxUjI6R5AIMiEA558BG8ylEAOUIq1GROAshNJaKiVpzeEAAAAhv8A6AFlKtUac/4oTBQImyJmZYa05mAn5d//tj/CfPnLOhVGQUEbntARkIhCS1sH5qshl/lKpMZSSc+YvxYcQBISDXxbI3fYQJfrsUCHjVLe25Dgtb8ASIAopYphzLsaYlELfn6SU6x1CCHHpr6UAgrVVQ1ATViSlECmlQiibphWSp/lkjGibnXMBkooxBh9RiKq1iCiEAhDBR626x7s7bcTp8vF8eVHS7nePXbN/Oz4x0+3t/X539/b2Nk2D1qbd7KytAU5rhKaUsu1qn/zL6bOUdDy9MnNVtSmFS3+uG/Phw/+4aqVTcS+vH7pue9jfs5CxTNogYCmZuRQPfSlJSpnKlIsTGhmdCxlG2O/ulTI+TRoIKBVILkyZ59VwlCILQUpKjsW52dq6oUYIDHGZXTKmqqqmMIYFgCkXhuhRWCmllByi83FiiCS4Py3OzUgZBJbMOtZde9gf2kt/FcxKU/CLj1yyyIn2uzugdO2vJEopSduSecgQlXXz+JwzKlEb3ZSMixvKkqQSWpmq6jKnZY4MrmmaqiZmfnr5sw+jkEksCIRts2HmyV1zcZiLUqa2mqSfpisv3LbtOPdSGqGUz5ObJ1tpLfl4+UCkxvE6u1cSFrBBYiWllPT0/BGgGLQx993GbrdtSrnAMsyfl7DsDgdCfD3/lBPeP2y7bhPS8Pz21F+uiHh7OEigYRqWZSKJwojeTUtyP34e37/7LmYcXA+QY8yLPyqlg0/D9DJNkxBKK/P55YUhxgihyJj5w+dna21OylYypZBLAEhC+1BcjvnUp6pqJjfMsYQ4aS2iU84Fnx9KSUgllJkIiHWBUqicrn/KqSyx6to9sOraPQD6EFNZfAzjRFpXTWtKySRKTJPzs5AJRU6lhDgqhbnUzs2loBCktSTpmPjSX0OcY4xKyZJRCDOOPSJPi06xaG0z91CaftyfTq/95ftf+wKQnp4+Fg5Aepr7kKLWVQjzMH4qhQvc5BIvwxmRlVJ1Xc8zIghmFKJKcdGKtDbGGMl0kaSE0I8P75dx7odzPw5CAEoBNBWgcXGrWG/xfTz3Br7e7w9K43/8j89NJ40xRrdKmuen83bz0LbtMCopFSL2/cmHQWmY5qSMFaTbG33pPwFTrX8tONqm7jGfLy8k0v3uRok2hfS73/49Iv6b/8//M5WrMsCwaG1TSis25+34Kef0zde/6boNAF0ub/31GSUKpZDEpjvEmOpq1loDy66rm6YZxuv51IcQ2rZ1ix+Gy9//3f+sa2+fPh8fH75iLlyiNd1+j029WdxktEIQgqRQ8O3D3bt3X//7f//vh94pY43VIU0FgkAVU1QSfAjTNCHIM7wihZjcPPdaWymJUCLInNK8XBefr9fzOPYhLrxKHIYrCmesZJhjHucpVlXzzXf3r28fYgBrW1vZnP04zErUt4cHKSWgGNlLUXWbdnHTy8vnksX7d99h2frQ//TpP2QejcSUR6MOh/3h8d0/G8a3D5/+mNIkFYzDnAvud3cG7n737bfOhdPpRMR13Yzj6L03hhjKpU/W1kDxz3/9t7t9K1VelsWaCgBKKcMwNPU2Y9ZaSyO27W6apqWMbbdVury+fSQCq3YplWWOUqiH+7ucY9/3zNlHlpK0QSFzjm525xigZFpcJhIxxKAKibbZGtrYTb27vb231lZtY6tKay2E+JI0m36xYgIicF5T3wsiMmSIseTAJRBk+BJVj4AMJWNOmBmhAOLfoksBmFEiKRQScM2DJS6Zc8DiKfuSl5z8eek9p8BxXMYSAKBVSEobS7Kt3v/u2/9iXOafPv4Tg2+aJkXqr9MaDs8gj8fXuvJdeyBa/ILLnJXAcQjn4/n18wmmVBxrhnWIwz8DMpgZUmaBQpJRiplLzlZWShmlFK+HVsS12bOadJhZCQmSSxEBMafCjMxYeP0CVuvC/y/j6/v//vc5Z5JCogRAZMg5llIYUs4+Fw/MUmkhMOfIDCREzqUAQy4rliMkryp7Wcb9u3fbdw8/vnze395ehn7sZ5IYY6YgtZEogJmiT0bfSEnOzSEuUtK8jPMybrdbZDsOy+3t9ptvvlFiMwzzMLzm4plz13WZ55hGIUsIqS8XLiIn//XX3242m+fPH8/HT+dTslYbKeZ5qm3TtTdKi2G4Gj1LoVOE0/llnK4hBzFCKeVyuSotttttTP7l9WNM8+H2VpAehul0/vz89kSidF137a/bzc1mt5/mOfPwdnoidiXTbrffbDabzUYInRJzKT5Ndd3mAKWUwmkeZ611Xdfb7Rap0bXor8M4hFXDkTMs/rLZWmvMOPM0LTHNRARAhTUhQlFSK4nKmg5YuBBReOdn5wcfWgQiklXVWKPcch3nwRhDRM7Nzk+lBG1USnl72DKkZZlYoBAYo2dmBp8yi6KIgBkEkdayafX5PKeUFKGUgiFN89V5DNFdrueqagRp7xcuBFBoxduXFONSsgQQa+aL94vz8+Gwd15c+ud5Wrpuu9aUMcam2awvMufsva/rGpFSSlKKnFNdtT6sHVAbY3x+fmaIxmgSXEqJkUv+GXpXSCrhnBMkd9s7IRTn7Oa82x2sdUrqzJB9UtLudjfTuDy/ffDeKym7riu8+MAkclXLmJOtVMmw3dU55Uv/WUqdypwTPT4+LosvpSiGaRqkoru7HaE+np6kKkQCQBijLpf+cn396vFfHvb7t+OnxbnCHjAqLYCT1pUxqrCKaST2IDgWDnnxURljtFY+hmvfkyhSobVaSrC2Nrq21s7zEtMipRYCl5QEKeeC0W3btOM4xpDdMqUUtBFIGSkrjYB5Xi45c4weAGylmVPhcLy8pBSUUnVz1/dDnFhKSaKQLI01zl0TH7nML2/i+eUjuddfdoZ++jR19WZbX4aneRlsVdtaXoYPOZ99cOV61lr7OPrg6tqCsMgDosgJlyCmeZCSmNpUjCzsueRNu+Wcz5fTNJ9jGg83XfQgNRNlSOkXW38pkHNsWrMKpLVqgFnKEkIhkTJf+9FPy0mQjDG4uT8cdAwELLvt3rlFyHw8vXGRG/GrwRewWCvv7m4KB0IhhRaEpRRjFAkQKACKlJoZVzW41rKuKyLYbJuc0vUyuzD5cKmbisHkqL0PMWZgoVWVck4pK6UQMedcODOLeV7u7+/bzr48fyLS33zzzeVy/vjpB2vt4bA9nV/GcZZS3xxuSmGxqYhUDFmQurm5Y/AkclV1hZ2gKgU/zwsibrb7pqmOxzMwSWXGKSFySsmHRSlDRPNyKQV22ztjzDSf15E3ESnVTeM555xLBOS6tsfjcZpcZbdcQAhBaLTqCLWkDhlj5LqqcwLnwkp9KBnGYfndd3//l+/PdbU97A+fPv+QUvr68X645hI4eNaq0Zp8GEtJddVZI7bdN58+vkopf/PdH67967U/IeLj46NQ6XI5PT39lRkf7t+lFJ5eP7g4sate3z5ywaa1yzyQiN7Rsvja7n//+7/LCVNK0zi5cBGEQihrNlfXPz58c3//eL5cXt8+p+xP55HRfv311+M4juPQdZ0UphBOgwPeaVWTkV21227u6Z2sTbvb7K1WKL7oEhiAV7ImgFArz7tkAGJAgYCAPxtH0WjBFkqGkqEk5owlMUDJDJkIZIEMDOLwf/hSazz9a2ZG0kgSSDAW4IJQkAuXTCUBZIaSkht5iZwGN4Yc66pp2xYyTrMfXP/NV18fL5ePn76flmdt8zgdK7tDUCSgFCyZ5ilwcTkN4xA33d3d3SNxkVIb6TljdsUURcX/6v39GyWHQFJSKaVCSoKUVpZQSqEzip9DceGXgqOUggSIBCsrqQAzlvWavjwz5lIQ4Lt//atQ9If/7nchZqHkSvEPIYTgAUAqAVBi8il4RMwZiSQzAzIw8C8VCzIA+pJyYqxq0XVTLiy0lBqAchEhEBRBWiglc44xxlJ4t71DZOfCOCy2Uta0Wuumbrvm/u34PE3Dpw/fK72Z54CYGR1zKsPonMvFx+iJSCnlQ9Q2j/NTgWGcX6TxzMnHKaVyc3/jFne6fNTaSKkf7t/7MJ+vn3J0OUcX3eIujdsY02gt5+UKAD6MJc1vp+lLj82isnPmKfKEMmTA0yXmnJV1p+tzV9VV3RIRCrPd3lyv19fX56bpSAAyLcuMCMYqpZS1dWM2DlTKs5uDdyxFtd3ctM1mmpbjdRjHKsYq+IQgK7uVUubEBdFIJUm0zaGxrTXt6Po0jyUHIRQA5ZxLTlqvJFk/jH1Kqak7ay0Aa61zRgS4ubs1xkzzFSwi4rL4YboKodaCMiVjlF0zhhBLP5xSKtZapYTzwziNPkyFg3OzMW3X3AihxnFe2+EkcNWLeB+5cGUtIg3DcL1enZ8fHm5JtCF6EqYym1RESKCrer97ZM7LMseQENHaClHMk5NCE6mUSsmkdRVDYsaqaoTMm83Gez+PS/AZUQBn1Pn9+68v19dhvGqtS5bR893du5zzOL9uumqaXU5FqwZY9td5muaUstZVbSujq+QdCSlIFBIFMEU0ulGyBoDj8SiVc26KXsZ4IwQKobybjTGHw0Fr7WZQSpcSpa5zkiiq25vqfHnb7Zvbu83sXgtIJMw5riTC4Nn5MaW4ChPXY1JVmZSX4mJKxrsYQhIyA4LzsbI7JSuA9VDEPkw5c04kyL7/9utpDOfTdZ5nItrv74DF8fwBEJFzziiEKCUN05sQKCTknMc5xehDCOM0VJXpNp3zPQmoG22MTnlGCpn9dXhLfBJUF/ZAqevsL5vDMP2YcY9qP/evTHEJQypDTiio+DjEfKnrliSJkkMc43AhekFUXIgCMecYgFQnyEhJ3bQsQ77O45hSUorqZltKUcpIKUNwJQsoWmq76+60tsktb8eP0zTFtORsiaiybQjOFzoPH4eZjN409cbNw6X/aOtHJXZColAxL/M8hJzAGFX4V9Lo8fRpur3T2iJUOXGRQRv69Pn73W777t3d5QqLm6SoS4a22aTspmkSAgHT2/HpepmklNpA3RitTMyCSA7jpZS0yudyDM45a62S9WFvvHcAYIx5eLi5XJ9fj8dNd/j+h/84z3MuIc4x5WkcB++DkhWCzKmUEk6n0+fPn5RS2223OMg5SlJuCaT03e39Mkfn3GG/M0b012W3vZOKjTFay1KISyaRkRhJTWOQotlvu8puUl689zlzIx52Dw8fPv3xcp3+1b/8n89z+I//+MO/+Bd/x0WGELRsjGm0BARFRIicgG8Ot+fzcRjPQhZjRWG1LMs//fn/db32WislN4LasV8+fXpCrjZbdz0f+6nXBkMoguxue9O2m5fXjyHGuj68vH768ce/Gqu+/vrrnHM/9E3b3t8/no9v3s2zW879+eHx1urm9eW43++1ljmLlL0Acr4HKJ8+/1WQlVLEnEqO2812GIaP/Z+saYylYTx+/PhDgaQNPj1/uL39nVJq6KdlLpWVoHZGtJ3Fym7adtPUm81mZ3Ql8EsYPHzBX6a1e7Ee5QGASwYAQCCgL1QJRESMOeDPcE0gAiQmiYWBHa/4biEQFbIukH5tbqyRaCQANRAWAFECIAIXzAE4cY4hzM7PQYTZzz5OdaObpmIEBgqFu/a265rPnz5ers/dRttKPj8/S2G7tnZ+SrHMs6/rrq5aLtJae3Ozd84NlxFg7vtL9N4SEhfIa9HEyF/GFkRIJJQSQiAzC0SljZSKCwEpQlgLDliFoGuyPJRSEH7WcDAzIq2qDsZfYvDoN//NX35ZgZ/+u3/GCEKglJKE+LJyyCgFCZWLLykyFAAMIQAE+MJqzaUk5sxQSi6lpCzFHLNttudxKS6gkJdLX0nN7YPRDQD4MPgQYnLTuBCpl5fP2kiA0jRN0zRSaq1q53wM3molNIc45JyVsELCvHiUfO3HlIKxMmXf2GZ/6M6n0cfheHKL28S4ICWknFM+7O4BYJ77nERVvZeikYpIMIODrFIK5EkpU1fdbntXSpkn771TRtbtBlEQGiWrUCaphCFCzFaLXFIIQSnT2Y14hBij0ZtV+Q9MAAVlqFpw8xdyv5BYSpCSBIicxG57c+3xep5yIkFKSr0Ov9u2LQW8D0KortsKWVJKMc4FCiBlRgAUZIkEMCml5kVKIeuqXa0uKaUYivd+mq7MaHTlfQAgrQ0jlZxTSn3fz/Nc1UYI9NEBMGCRCgFkVTVtvQk+LcvCmC6XqaoarXUpMedcCtTVtpQErPe7Q1VVMQUhECUifXmnGaNS5Fw4xni5nHOOSLlp7DRNQmJTb+p6R0QuhjWKbBqXqlZCCFvJlNI09yVjVTWlFIAyeyeEKjk57xFZa82ASlaCKjdlhoyYQ5pBkPPFh6uPvVQdsCxFKlnN0/X1+HY4HH5G3hGRcDE0XSfUvRQ6pwRF11UtjXR+LDnkvDBKKRrORgjVVBjTXFW4aRvv/WotTyk1TaeUOp3OiGAs+BBz8SmVnErVENB0vP5xdN9//PSjVPDNN98MfblcLkQyhEUI2TRNzBxC1LpWShvdXC69WwJYJUVlDWjDJGMubtM+pFTGsc95IlGQEmAqRXIRSilENy/Ddrtt2zrnnGKK0cWUlKaUYs5grfWhL7ys2MZ1E8glai1z5r4fr5dxtzvsbg8x+f5ydr4vHJnZhQvhnHPebx/bZv/L/rD4yzBlISEEp7TIOac4t22XYmKOSBSCq+ymsl0/vIWQpAK3zESybbqHx/tpnFPkYe4lpqarqlxcyouxKqXy+PjN8fV0ucy3d62SChmYpcCtlk0OzNBfrvM8z4ebW60q7yKRBIDzuWca99vNYf8QPPf9k/e5rg5KdOP89no8epdytG1zqGoJr7/G05OMQjIASVEbZVO5dpv9OCyLuxIwotjv7hBFzuXu7u58eX16HupWEIl5HqdpvL3v1jjMEApnbWt7ub5knrebRyEBA2hlBRkAqhvd1HztX7uueTs+l1K+/uZmGuOHT39u6m6z2Xz6/BJOfrffVFXVtXvvo1vStJwfHx9e3z4zeOdRa0Vk/ewru0Guf//b/wmh/fOf/ziPwzROUtoUhVKya3dS4TAMIfoQFyIypqpsK7CubTOO89vxWtd1Yq5vHg676h//8R85a6Pbl6fnf/b7f4Wsljka23btTc4cORlrVwXf7e0jYHk7viL427uNkDLnKKVI8AJUmuZ9bfe7TbByquumsTttgIi1kLvtVqrbcRyDL9c0fn7+y+3NQ0jD0E/7QwcA4zgqaZC7ZSyXc7y7+Q0RIU7d5t4Y5Vx4uP92u92eTichRClAQtwcHvrh9fXt01fvf5NSUhLG7F9fny+Xvm5Rqvynv/yPKbIQIqRALr17fyvIvr6+hpCt6eYRw5QbW3/79d8/3t4CgJQAAM4lVCAlpBhIfGFlyvXf4IsbQv4M2AAgQPgCsGJWAlcI1Re0FUgEAAIWmRkBWQIBIGAhCOsTppf/DcO8Yp5wZf0i5xQQiXNhzpxjjt45Ny3TXE1LnApGa6p5Gp6fX9tmb+uuNjfX67D483bXlCyN2h52MpcAmNeYb+/9YX/bdVsu9M0334WQjqeXqR8qY8f+HP3UqY0fBlGABCEVYFhHHkQkSAghmJlzQUKttSBVynqBP2PFmVdOFwn8hRy63oqA8ZcE3fXbMvDv/qba+P7/8tvki9RKSYFEOeecEqyxt+yklJxihrJWejknLrD+LwXyLy9gxeEPLu4e7qlpq5sbu2n74eKmSWmttGq6PQC4VxfTLJXSmpWsSaRh7I0xu/1WkE4RBVkEynksnDAHoOh91hIaVdV1vXhf2WYYU4pZCDHP8+fPH5clMsfd9v6we5fC3A9HhDLOY7AihXA6XYxu6qrLSV8up+twydB/++4PIS5Sd0ZXy1yGa7G23m2+0Zr68TnFQZBp2ltgOh+HnGQGlEISaOKms7ex8HAd6uYgxbzMCSFKUcZpSiWQDLN/jUEJ0nf3D4i5H845ZJe8lmmZybuEoLq2YaY1z0IpsmqLSFLoqrIxTTHN+ct4fmYhIEOMcXJL4pJyMFYqee+cI1RSVCUHYDRa1tXGWEAUdbVZluBdVFJIoZiy8/Oq2cxrHBqCMjBNZ61qoxtrbV1tgr/GGIVkH+ZcnPQ65wxMSprtZptSQjAAchimEBepitY6pZATG1PNSy9FrbQ2WiIKREIqMS6IChGJJKDIOSNi4dSPZ7trmMX58ur8WFVVVTVcUKqaUKcIiHw47J0fGYIPy+V6EmSaOtV1U9dNYR/TeL18Kr2P6StAn/I0L6VrrFIm5TBOvVKilCQkMTBDtLZOy4JCcSHbNClka21jqww5hNS1Xeivla21qsaevXP7w+FyjVoprZRb/DxOiCL4qIQ+xWPOJcGrYo4phKKtOgihhuHSjx/6CZWWs5s71WnDhYNz7u7uMZVLykthGYITQm26G7ek89FpY6Sg7eaGC12uR0AvBRIVJaucvPcxJGfsLyg/GUs5Hl9DSMbi/tDkxNfruW32SovCSWvplhRj2e83mUU/ToRGIqQUmZFIts3WORd8atu2ZBiGwYcJkY2V1/5qrbnpbryPCFlKmcKv89aqaq3eElQEmDw3XV0ycRaCilLGWu19RlBNvRmGK1GyuuMUBWlkk7y9nntCreRWrorf7EVb3yFoIwWnrVashE8+lJI4cVVvH+6/fnt7HqazNgIAut3WhYBCRE7zdRZCbKouliBREwNyYQi73QYZj+ePizuHuNwc3m8O713AkjgG+cuVtNUGzVaKprKbFMH5/vT2lBNi3cZcNrubUrL3HkEuIbydT9d5zELtdjs/52bzUHc1c86ZpZDjENjFwnq72ZPoQsra1LWpU/CLG0Gn2ihOh2E8ppLarv7LX/98c7h/fHc/z/MSBmVxCS7l7u/+8A9Pn08+TqHMSkPOUSs7TmeSYZznum5N1Tbmd+N0OZ5/cn489Z+M0VJBcpeY6zgAEUGhsES3+G++/s45F5LYbrfeT9fxFNLp7rZd5thtNu8ebl6PPzaV3t7sX98+kcCqbkuh3X7v3Ly4kMqkDKHKKWprtiG655cP2jAhOr94l7ab29ub92+v+7P74+0fdiEAg5VVGt1i68em63Rl56XHIltzu7Hvr9Ppcn0mrIB122zdErUyVVWldfiM57e3l7ub33773X/5+vo0ur+8v39/fE1WhK8fbq/jlSBabdZ0N+f5/uEPXIQL/M/+8C8+fvz46Wne7pp3zbu62Yzji8B8u7uNaR7dszI10W4ug0k3BDdxwU2zf/fu/f3DV11zAICygoEAZCUAIAGAqhAQAAr8YmsiIhJ/gwZlZkZAxLUfgqC+1Br08/0VmJkpARIAYhaIRIiK6H/3pYKp7jAsWBZCgBK4MIIkEDlnKFmWlKcBeD5Nx1f3FoQpIIUyOWckritlrDjsuuv1OJ5GJXUMCFCE1KnkfrhYsXu4feyH4+Pt+/u7b4jgL9//O+c/MRwQuerUchlFJhVEXGZZwHHQoHRRVEgwEYMilHq9QIrMSphCiqU0xgAhoVxriLXCyD8Hm+QEP5tXBSKWxMwsCHJikgL/dgUBBKsiS8EiV38F8/rbKAhEaT10IlHhUkpizEwcotRaIYBzHgBiznPI1lb223dDzoRp13VCVkrkMc4v07EIU9W7pmlJmriQbeqtkilBjDHGCJBScpXdCaoRdNtUOQ8htVKIpqnejq+X/lmbB0SUIoYQtOS2bVPKp9Mpgt92Tdc+Movol5xT02zbtgZ8m5Y5yuebu31crNa1qvjz5485ng43rfcZoaqU3XStFuPxckTKhFYZELPJKJq26aeeRN5tzTRVIc8xLUaZbXuz2+yPp48ClzBnbbWb34Ty47yQoG21TbkupVzT0+3hNyg6N/dKKW1o297X6n6cLkKoypgMkQgBSRuMMaeylIxkOwFimsbMEwkep2OYad+8u7l7JDTAssRYYplcNlrebN9vNrvz5ZnzsPizZv3+9lv38jINQUv5/vGrYTy9vn1CxKZpOZMyWltLRLIgM6eYFNlYxun85vzcj5/9EpRsjb7ltCm4aFv68TmF2NSHptmMw1zKFMonJJPK4peFSXnvm+qeCwkQJaacvan3d7df56Iv5yWn+NX73wH659e/PL38ieSiTMl+FKWkvCzeGUsh5Vzm7faxxGYZxXZ3P15flMbj8TXnTAJjjFpBCcUImRZPDFxYCKV1XZhm94rIdd1GL4dr2m0rrSoiqk1X2+p8PpcMTbdB4pzGp5dPEjKAU7IBFIMb5qE3psGiMd/05+DNWUqdeF58qhvNzBlcysHaxvtojNEGmlY5N19n9/YW9pt3Wjda65SXzM4YAxgRCDJhtq/P8zKXuu5m74zaq1otywwsc8qfnz5myN67B/ttUz1wNk+v/+jCW1VVPqKt1Dj11tS/+e53p/PLMF6ttTEgQiqcPn56u7v51qjD+Xz18fj1V78lhkIypRLTEtLIGH/8+Gk1eUhpBenVQi+Faeqtkj6lsrupvYuXS181JpVwvS7bzQ2CZMr99Ha7O7SbTra/8jmlpKbVCIUZ62onQAK6EHoiMMYAsBBCCBUiS7nhpIDx/bvfDsM1pPP3P/1E0HTtIZdR+jAxF20EQ0ypKKl9GIWEm/1756eS8f7unlEP/WSsColsJYHxdDpqXRtjc0JBdrc9dF33cozexePxXNm2aw9C0NtxaJs9F13SuOu+7Tbv9Rx++vCXR/pbSHsdQlY1lpJCdMsC1mxFJZRSeZkvl3MIwVh1e7N/ef0p5eX2dq8NCaHqSm0391rbDx++r2qjpBEk3z1+0w/X5+ePur2EEA6bm9lf/BJy4nnJj/f3d7ff5gwZ52mcS9GEJkUMnhkn7/JwTTe79unpLaZl9k8x99vmLiX+7pt/+enzX98ufwxhDs7+89//g9bV2/Hln/747wsvTdMQkZI1QSIireXz8zOiuN0fDvtHZhZCvbvfff/999baGL2b5puvvpIiVrab3Mcffvp3JGPK3rupre+cn4iE935ZJhKdkPTycpRSKlkTziWjNqJtu+DneZqA5eFwO00TEdzffTMN4N0SghuXNxTu+fw2zI9DPzXNbtO+Cw42+7YjP7my3Rzu7h6tqXM6shI3hweG/Pr6PJz426//vmtvUvIhXfvx0/c/vRi9k0JPC8dY6rrZdDskZjimFOqqTakopf/0pz+RgN/+9rfPLx9/+9vvIFN/fiEy2+0DEKQj5YKLa7vqa79IyvXXX73/3W9+0zY1AOUMUgDxGm8C+IUm+iW/FOjnRFOAL4kq/J/KPWFlbP/6s/9/HsyQCiEiEpD4Ja+M0/+WcwIkzBqgMELJUAoCZEAmzCBYaHA+OA5JirZ6V9Vqcf08j7nkTdtsNnfRl8vlrykVNhwjvHv8drs5OOdKKSxSP/Xj7JTSLo2fP3/6/se/fvvdu00n7+7uOJcX/zIXb4zJg5dEkgUxFE5QGIHxS1AdMjMJQVIpa5T54oNlZiHESuBeD68M5YtRhfnn0QkAADL9bV3yt+nzP/3f/r6UIgSCwNWNwgg55sIZCxdOX5555ZMWXqPolWXve+acS3A5Ri5gCFqoa+1TBEFvx89CVpzL2rK2tUUIOU3DeM2ZSxDWHohlzp93ux1SuFxOOef9Tkkdp3GMOQCUtu0ON3tbGeccSTUMQ0m5FLSmkcJwibvtgYhSTFrbaVqul5emrQESg5+mq/e+2pmUEmA6nT8j54fHeyVvT6djVQMAEtqU0qk/Lv5KcgwhXIedUqqu2qo2i8OUM3IBIM41FCQ0XbsTUgOA94uSKKjebvYocZ5n733btpWohmHQqgkh9NeXeR5ynqqqqk0qMpDIWlMhEiyFMGvGN4AkLIt3y3yylU45LM5pLfe7+1RngHS5vgbPwPT/Jey/mmRbsjQxbC3XW4bKiMyTR9xbt0RXV4uZxgBDIw2c4QA0438iCYNRPPFf8EfwgQRpHMCMJEDMcBo91V1dVVccmTLUlq7d+RDnip42Gv0pY8c5mek7d7gv/9YniqJkSJyzhBDGExJr3Tjosw8m5/jp0ycXJutSCDZDoAwJhZR8iDanJJhgjOUMzrmck+C0LFrtUvb5dDoMIyzaJiNom8t6AVhqc845Sykv4VCEJs4pwNK6ATFSSqNnq3YHmWltIGIILmeH+GiD8T45GxgT69U/n83zbA6zeabC2kCkLKty5aImRORMpKirqiFQAsrbFy9dSFywEKcL6U1wJXi5aNp5mPRsAMB5O88DsLxo10Uhu/6YEkQPkqtMyTid/KdZCKENWuM5kzbaC40aMWOOhOUQXAzUu0sEfOKMGh3nydd1E0JwbnbOWTsLyWKM03RAIEIwLph3IWc5DtYYn9OCk/Tq9lcx+g+ffm/cgfLgg67La+/j7YvrRbuajZVSSCmen593uxcXz03AhJBTjoCZc2r8ATKHzNu2Es4HD0rWZjasMdrElAMhpKoqIYSzwRpLCVmvl3VTmhknPRJCxunkzOTD6L0N0daN4lx23VCVi+VimzMKIQixzjkXzWKxCJOdZ2NDxxgtKhqCYVyS3FTFEoB0+vF697IpW0qpNuefrJ9czyEEt1peMyoZY8ZG5wGAMMYAgnPWe005STgknHNuf7AqLstSiSUlwljPKCli9Ea7olBVWRHCvHOzngq5HHr3m9/8Ror6dNaU5Yen75wzVUNiyOM01MAIYV9++VLJdhrNOAdGqwAaEed59iFdXV1JjuvV9tOnj1fr1csXv3CBetcJieJHBzPwEa3P1IUIM+Hw5vWfOKdP52cfJspQEYGIZVFSFh4eP5SlqpvCRzdPRop2sVgNvRkHW1UVoZCSm3VnzJghanPGlIcpTJORrF60V9aksfcFT8vF+jxG54fVapUgT9PAOe0GrfWMJLWLaprGGH1OWFdLpUrBCgBYLtfGbRxrfvXz/9HN9jfvP/11SkEIcfvy5Wa9/eMfv57nuSxLH+aHh4eu67784hfbq9thGA6H59V6edh/xOyut7dd1+mp994zQiHlP37zW8AAGQnK6Mk8hbIqh2FYrdu63jDGcs6UjE3dUsqMDpQhY6QoGsmV4NXpdDodO+9jDOx69zrGcNJvhcQiLYdpLwU1bkSShGRKCQSw1vfDJETdVsu2WcaQm3othDDGn07Hx8enq13DBWjTaa2H8SRlFUOanM946Ppj07643r3hXD4+3k/T1C4upmrxdDqnlDabtXPGWuu9n86mEA0XJRVtu1w+nrSdXV3dENu8urppF9dFUUlJEgDkdOFG5e/9RDNcCKHfu4tmAEyEfH8ozxn+oSkWfs8n/eHKP643MIQUEgBFZECR0P/N5zeIQKRAOOQIMUIKOfoUfKaBpBijJlHPujuMx/3Ue04WXFAicmKMScgpZepc3D8fZz1elmZCSNu2hDDvQ4rE+L6g9WK53e+f7h5+G5O9fnGtipYQdjyelZCQ6dBNMgIAeO+lYpgypgtIQy6EWSQspUQYykLKUgopKcVLcymEz9SWlFK6ZLoywjm/IBzfj39wQ35abdz/17+5uJUjJzknIAQvKpYcY/SXQN3P7l4ABPAS1gY5A+QEkSAmyC54T5EpGQpp5j4hKFGfuz1BURSlKnhdN2W9DiGogpeKn04jxfLLN78xM358cKfzvXGnDIEWOI6jdxBj5hyNDbOe7L3RWnOppAQAgowXQnjvjQ+r1TrGeDg8A8FzP6aUXPRZj97bnCOlVFXKaJ2TE4wO495bvd1uCFE+0GnSi3YHSc7TnBPTeprMXdMqhusQQj+cY/IpJUp4TsG7lCIwxrzX++PHeR4n/eT9tFxsQ2go5aospay0nkJIAETKQsSIKUQyCBWtJpD5PM/BPklJRzOEYBgTBFGKitE0jiNQXC5qa22IhnNOSEMpR2CSOedcjFlIpWSpVHkJ+3HOHI4PpzNM8zlkk1JAprTWsiSUZh/mYTxYay7kmMViYYyz1ho7I9ALvZQxVhSK0C2jdVk2PszGjhRTXRWAHlE55yATxpjWU0pQluVy1YwDm/wkCyGlHLoQXJFzLIqKgbRWO29C1Od+NHbOORdF8W//+l8Dmn46cMGqWsbkpmlAmFRZEEKUrAWrcwRnUXIlRfHw9M7oHshMmOeE55ScjbFgRVGlFITkAYgsi7JUSql+6ARbOIuMSaXEMO6dn30w2+K2KutZT4RQRHpZaZVSqthCdnrKjMi6WqeUOWec8+50ut69appmGIaY3DyPzs2ASUre1tfzPHsf27bwXu8P99aEtl0yFQuiUsbz+TRO5wye0nK9eEFJkeNMsbQuz5NZLBbtovZBexsoxZQS55zx5H1O2QGQrn/KlUBQbu5SCrurN4t29/79WyTe6NFa+1njljCE5L1vVqtClYwxKdnpHELWKbuquELEsiqcy1JyIVQMVIq2UHVMjhCSE7HGIQIhkJJL2TgdM85SkRBSU+2UXHHaEAobgc5i8qV35Hs5PQBAcDw4XpRquVzOk738cZ0z0zRkIIgxBOfpnI13vgtpUqz13nsfc0bKOCEkpRCjZQSKql4759brDQKfpikTxmlWSl1tdsFnAjj0hgukROVMD/uOc/7i5rYoGqO1MZqz4v7h4zgdhGRlWVZVNfeaUIlAlOIhjT5MdVMO8zCO4+Pz+5g7404/Fhw+UMKFkCHanFM3nnOOIXvrpmQCAKFEAtBhGC5OeYjorB4nzZZynI59f25aIHQ4d53RwdhDTrBYLGK+YpxoPS3qcr26rsp1CnLojQ8zoB2nExJPaLZOZ86sj9NoGIP1WsV0jNEFT5vitq3XCQYf5qfDH9q2ZbTopkgpP3Ufv3n7bxjjVdUQqKYx5ow+DBljjOzTpw+3t7fXN9t+mLvTCACn0/NsDpv19TzPlOLL25tx7HPGaRqrci2EcC7M2rf1br3aPh+eQoCYtFKqO3dFUdXVoq5rrXVR8tNxyFnGmJ8fn7bbbVOvhmEqikKxYre+/e3f/VtKHCdFgu0//4t/+fR8/+7xr1fLatanbz8MX335Z1I0Dw/ZRUrb7Hzuu5HQQhXlNM/nrldlxRijlMcM+/0hJfzi1V8Worj7tNfug3MppWTd3PWn+4ePMfqyLGvJffR2nt+8eVNW6uPH87Jpx25kVKpiw0SZM+REWS5L3i7L7aZ+vVhvpGQRIEQPKXDEjDlDkT/zHhEucoofHM0BKEK62I0CAKEAGX/MVP9cc/yHoMd/MBKCTTElQgT82NCDDBGQAKU5ccAMyeElxh4DpZgjpBSN052etA+iarQ9jnOwVhMKlLGyKgSPXIbYx0vrQQgWojb91PX7GK3ANI1m0V7X1ZILCFEvFxsp6hjRu0gy8zomnwhRhEWMiX5OQUuISDnlnFHOCUGghHFJBaeMIWKCnFIESBjJD2F1lxqFIEX4Kcbxvd9XzgDw+l/97oe5f/q///rH25NizCnHDAQyxBhtiI4QgoAAiQBmQkgmETEAQE4xAieFc2bojU6RLaokqsQVZTAOZxdDTFA1DSFoXOi6wczSez0PYwhGCMY5d856Txgu25rU0GZwOeecCKOqbep+es8YEYJpbSetG8ZTAkppTJi+HyE4a+0wDFLK4EchmVR0miZKJKVCcGHsnDyp65oQYt2YSJjm4XgYBK85WeRYcqaKSgRwXb9PIS2bF5Kuh2G4WHYqpZSsJOeFXGs/MWrneRr62QdTNyVlJQEZY2aMQSZSMgDo+55S3G63gHQ2Bx87wSQiSilVwTmH4KP39hKkmSKVopWqdP7B+U7wIsaojc0QmqZpmw1kps2QUprHyVkvODAqvcshMYAwz6MPs89OSl6oernYeZ98PC2WpFAVpZdjPQ0hTNOECZ02fX9GxKqqCslSyvPYc7lrqoYyOJ0fp9EB5wTK4KSQhBIBrKQEGQNjRkJguVwul+uYTMqaICsLwpkEQEpopRrOzDidJjMAhqoqyqqQUtrp2ftQFDIMBSReFoU2gypoDDAOplC1UsU0TUIwzuHDp6+74Tn4ibJUlqqultPoTDQx2bJppmmwwWo95ZytpZRKaxEQpFzc7H7mgz6cnrkUi3ZdlsuUTNd1hOYL+SmlBAmbtp5m4/xYNuVysXXO+WBjjC6abITaFLRlT09PwcF285IxOusxJVWpBqmZ58kGoyouCyUFN06bOTw/P57OTymFolSFateLL/rhWKjaOD/OGhFDiPd3T9Y6iJlQCMGJglBKfUgxxJzjbvvazowQsFYjSYBpGE9C4jj2RkdGy7LgkFmKyJlidREi9OMkOV+2L9ebm6dDN+m5LCMFZEgyxeRDhFjwui5XZbF4eL73wTBGtPaU4uFw6PseEeumdSGEOBDCQwhStADYNOXpHCHymxe/nPWRwI8qlavNyyNxUihrgjHGGFNVhbU+pWSMi9ETwlJEHYxzjgmCDKZ5jikxwa2dvZ8IMp8cM7Y3thdCOF9CdimHc/eMGL+4ejkM3ePTXSENAFsudoRmKdnz4X3wcLVZOheGobfWLtpunE4+9iWvrNX9sF+3V227vjhkFIVsV4uYc9efnLPjdIpwauyPKhXOqRBSqXKa4jyPGh8QM5IUk3EuKNmUZZMipIyb9Q0XBMATQiD7DKbrn3zUi5Xsh9P+8FTItipbKYuqqrp+nIcZCS5WC8bxcHhKkTMqX7785R+/+3vOOafk6enp9vZWCPbp47uqWm42K8bRe0sZSKGauiqLwgXz9vd/bBclZSmDoyz89u/+O85k3Qjvow/zNJ+GERjD2WhkSWv8xS9/VhTFd999d719o6ryeOoI2qKoCGHH46lp6mZRPT3fMUZVURRFs1gspnGmLDgXH5/ufDTtgqfsz91ez2mzudZ6Oh27fjgvF2vnnLWeUSt4UZVtP5yd82VZEh7f331z6g+rDc+Ebq9fXm+/eHw+cM6sd2aeIIv1eq3n5GM02pVlqsrmfBq9DzFmQkhVl+v1sla78/k86xEyf/P6TVUuaeZVGShhUMQAetY9IfD6zYtCtZRI5+cIuV7Uxht9npAhpXy2hjOSUAkp7+8f//a3fyRQ/dN/+j/ebl9Mtj5qg7MuC6EkJ5nmlAgBc9FPYAbMBJDgJc8aIkYkcJHBXcoGAMgAIlOASxXyo8H2P8Y2fkgBBUJSguRTtImtP8MbOf6vE8QMOSMDCiQjAKMiQcJgA4CHgNaEyQYbE+NqUS85y+NoAVPXj0KIpllYZ3ww26sXF2MDqfB0frJWd8MdQNwUu6pqAFBKdbVt7+7fdd20u1p7P796+Tqa+PXxO8lKltBaV3IKKWWICMA4uViIXjK3CEFkFMklKjbjZ80OXICfzzajSD/Lv1O6ULl/wDYua+7Lf/V3/6AGSynnnCBmvAS8Xqw5EgCkHBAzQrzUfwA5pZByyClcHNOjnQHSZGYTjVo2fFEHhkCBi4KxmTG6blZMlIfDOYToAV5cvUmgv/nur30Yb1++KCry7sPfKdmoogbCQ5SMixCCMdb5WSbadafL2a4saUZSliWlHAC0mY0x6/WaMXE8Hi/K8GmaVsvKewdwgfF3N9evHx8f+84SRinlKQXvPWK2wRkPzaLcXb28e3xQhRcyT/ORUbFe/VzSdUqJMVFVFaUUMjU6KraoSkH0i3ZJ+Qs4PB1mfQYyMk6MTkChbdtJ62HsLsc4RHpRBHg3uzBlEZ2nxhgAoCwFx6UsOJM5EykqQG6MJygB2PncZ/BSFrPuTqdTToyz0jt8+fKNaczD3SPmgmDBaC4LEQMlHLSBMHmCvK7WbbsaBzOd90LQGL1JCZEUqk4pzrNZNvVy2XKB8zwJSdu2dc4dD2fKZshwPPan87Es6rKskSjGlRCqrlba9JTG5bIcxt6YeRwZ4rRcrrXWfX8kFEmYFs1tirLveiYZFy3zKSbHaQGRDmdX1Y5yEjzJUOQcx2HOCVMEyKyp6/V6SwjM8zBMe8bO59NAJWB0KREEhaByDoznqkFjJutmQoAQ8DE+PD3WlV2v18dzVy/EarW6f5hjBJqIFE0MZDKDjx5zVEq54BmhQz/F6DlvGc1CljHG06lzfixKJiT25+7+AZp64Vw0OnLaQgaIIATxYUZEH5MUBSVSilrJhuvGjoPg1WazOQ09ogO0/fQJiBSC2UEjZiFk8DB2ljG2Wq2cswYSgRxCjAEIigxZ8Z1qeQh2NgfKUkx61GfrxuATQSFFoVQRQrDWM6oELwBgmDpHJopjUVRFUTufc85ccWM1IdSnFF1gNGsbi5IjCEqwqZuuGygFayNjgnOOIHJiMYAoRNssMcnT+XmY7q3Li+ZWCPbh05PyP1qbv7r58mN48M45mhhVSjIAlEI5P86TDiEs2g0jjZ76ELkQKqXg3MSokKLQemIUKaWzsQxofzwer6523eAZVavV6v7pqBT33mZIMdphPFzffPXFi5e//eN+nm2KpGmrnHG/f4opEipiMmVFD6dhnJL39nTeL9ptTuzCQqBcFqq0BgRrp/GxUPXsrDHzT/eEC8QHQBiVoozTNAXjnXOFqq+utmXRnE+joBUy7IdjTAEAKCOUJIKBc+ld9pbsNl+2zVXTLAkhIYSqmo5Ot02VYOqGk7XB6LRo1yH8DJFcbW+6/khQXu9ejePQ1FeU5uDBWyrVIsJk/XHcf2zbmtO2LMv18qU2A2H+6lpMo8PMGFm5dIo4Z5KNsdbGvpu22+1mWw3jMYSAiGXZMBpimif9dGloXe9eAMA0z4xLJbmU0ofxeJqfn/e3r94ACc+fPtYLNRmdE82Jbda3i0VzPO5zjlIUzoXd9sUl4fqLn72hlN7dj0VR5AyqcuMwXd+sQ3CQiU+H/+v/4/+ozXm5qY+Hs+RVU11PY3r79i2gL6rEOW0Xdd9XZVnmHMdpGMdeSGBYdv2pbcumFfNkjk/nX331py9vFtPchzTcP3/rnEaScmKlWqVIh2G4HLWf94+fi4SLwTYTVbV1Bg6PvSgWv/yTf77e/eLD8fQ4RIZ5qTgTHDXhAMAJAQgQ8BIakhNgxgwEEgGk9FKEfE43pUAvASmXrgr5qQ/E/4/xuQoRAlmKzsf4j99F/N5QAinJmSIl6EPyZDZ4Gvx+8IbwshKLZm2tDl5zvlivFmVZLhcba20hlz6OXXcydkSSjRlj8lwAInIml4s2JWKNOR6n4JFSbuw8DeP+8clNUfczzzzZgCnn4BMgAWAUGWOMUaQkIxJKgRIkFJFedK3fK4SRIIFL8+V7wfClcPi+0vpckP2Uz3EZ7/6rX8QYgWREJBRTQvz+v+MFzvjRtSNeAIWYfEwhJB+zz+BOfXeahswpVQVXkXIsG6GniIRKWQjJz10/juNqtaqq6osvvhimp3cfEQjJOUbwkcyRQFtLG2ZreiaqopSAaRzPsR8u4bTzbIBcDOYvQE4exh4AjDFCKAAghBESQzBKttb11vmikHr2MeA4zIyxkPTz06Fpq0W77vvzNM6C10XJbByN2x+6IxJj7FioVd0sKCm1PszznMELFFJcQt6L4IkxMxmhbhnQhAiz1iKKGLiQiIgxeUTknHqPzpnD4VlrHVIUoilUxQlPEYdhClGXal3X9TRNKdLblzc5wcPDU86RMMgZKeVCCK3HceydjQj85vqLYdDO+qbd3uyuKaXPz8/OTUhgGvppPsUYq2LtfXreHy9C3BDmfuhyIk29Xi7XhIAx2njrnAnRJ0zn4dxPPWMiQopwejrcjeMckue5SplCgnEyiEtEzJnO0wSIzo/Oh5hECKEsSykKxgSSEGNUqizk9in6slSEAmPM2JlRZp09n7X1jlJy7vZCEmPMMExXm11wTAhe102MXhs96cN8mKSUVVUP86h4IXlZqIZRmfMQgp3mw+lghBBCSS4FiZTSybrJh4JziiQ8Pn3Y75+UrJHEruu962w6JfQpOXQ5xlwWdQZmbI4heu/H6TRN49jPlCKhEdAtFst5HsuyXC4XF4tM731Z1rLU9w+nnH2GjCD60dcllbKldBQqTfo5ZSd5a900TzEKT3m0LvvgC1WF4CiyxWJZFNVyuey6U8ohRmu0TUCaeoGIY++vrja9e0QExGytBYjDeKzUNaU856z1PM9zCHm5UJyViNg0CYF3/V5aniIURZUzTPOYc+aczpMnCG3TzPPs7J1xlnMKBC9xVJAzE/ySyJgij77sdKpkNnMXY/TBSVVknL95++8+fvzmlf1xm757+sR2hfPBuTgOMxfU2tkHnSFBZlIUm/VtXW0Q9+PMCAZjpxyAURFjBCB11QLAuY9snDokSQgGOQ/DUBTF5VDVddN63X769CGGyYXu3eMfUjaPj3c+9rvrNWPAOQUAxghgcs51/ampeNuuqrKtik1R7IbuLkZUhQBIZVmWldJWMLXicy6U/2EmzsZLr5RKmnM+HR84F0XZEJScS611DDl4LZmkiISwlGnwiRKRIhFKpEi11kouXty84qzy3vf9gTLIaJA4QK6N1rPlXHIB1vd/+4d/wziypKzrm1YYO/TDUZU8Bt0PRyna5arOOJi5m80R6BnC5tXrX5ZqaR9tijTFsFqtcmJDl7bbm2F6PB6PhBCl2qur3WKxzkCDPyWSNuuX69XNx48fnfNNWz3v7wgnV+X1MEx6tpv1i5zj4XCIqQdIddNYN8eYt9vtMHVFWb99+7ap14iwPzyczs+vXr4hhJ1PQ1m2ZVm/e/fd4bAnhJRlcXW17bru/vFBKaWnVFcbQPz0+MfRPK/X63myiETJ0lr79dd/sNbuXqwen/tzdzgcnn2w69VVPxxDtCHqc2e9tTGnhOHUdf053+7+are5efvx95S7YINzrqqLlMPx3C/bvFq2j/sPQlKAzIHlnKdpKouWUp69eLn7tSBVW9zIdhfV7rdP8O4xJEoXhag4zQQIAGdAKBgXkQMFJDnTnHMMGD2BhBkYZsgZUoaUISMgBcqAkMQ/O2xiBiD/oOj4AfD4BxcpRc6RYPnq/3C5Mqf/EjAhcASAH8y2EAB5RqSVBGPQp2y9l4ZxyXnGhNa7kCLNoq5bIUR3niYzSSmD15c81Rgj55ImvlruOCcxwOPTx5TSarWFzOtqTVnWpuNE3H38ZAZHCYGYckxSMEyOAkEkjFHBGKGXV5RSmimhlCMlQBhSCogXvgjB7+/DT7oqP70Vn0uNnF/9Zz82U979V79KKWQEAnChpZIL+zTnDPHiYZMzSdFjyjGHmHyMISQfgvMxpBQ85M6HVJasKQ2jhNK6alXRxOhm23uvu86NvWnbhVBinMc/fPNvuuEhxEHV8jz0GYXg6tSdD4fDcrlUZRMiDYFx0VJuZ9NfEEGkjDEB4C/4RAghhlQURd+PQoS6WljrMePVeiH58rIWee/H4dE5N05nxnNZqpMZGC026xfOps4ekvCT7oZ+QhJm3YU41k3BBGbwhIIx0zR3KXkuKDarul4sFouhd5P9/b4/wL3lTCnBVRkpDYiUEDqOfUqhrsuUQkwBMFs3U8q4WBSqFKJkpfA+5JxTihcXZmPnDDRE66zX9igE47Qoy3Kex/N5cJ9zDAQCnXWXUqjKpZTV0/75dNinbOum5IINkyOElGW9Wq21CcN4yjmkGAmNAAEJQZJi9M6FWY/e2647UQZKCedn72LTLKqqmebTpTKTlHX9wVpbVys9X1zqeYzeusn3WpteCIXEE0I/3b01xjDG6rpVcqG10dMzofFwfDJ2jNEjgiwEIgpBnbMph5i890gIudrsymK1fz4zHvaHx74/E5pCtFLxQpWFaiYdpagYZTFZHwAxAUDXDQE8xGCGmRKOSKQUNtr9+X7dbrWZum4MHhhjAMR7N+kuUk0ZOG9C8FXJbAhSqqIorLUZnHVRyXqzXQmmjJmczz7bohSEZO8t45mLlCFmiMfjPqUEkGczBg9lvQC0h9P7fnqfwe9PI0H58sUvIhY2GJBimjpEdM5VVRG0iT4wJkK0QgitNQJlTIXRECIuXQxK3DgdrBurWsYY5ykwKgq5SglS8tM0ZPAxxkIt6rpuqubh4YnyoBRhPMYUQzTg0QSfUlwsFoxx50GKarO9ygmfnw8hOsrkOB0JzYDhe8MeOB73VdnuNrdlUalCfv30e8bpZvWGMqnNFLxu2zaf3A8rxvHwvPjln2nNGBME5TSNMSbnXNMs2oYxJhbtriwW1qWUrQ1HbQbBhHVaWxtCuqRBcS5ZodplWyCoolhQgEKud1d4OD5No8u5k1LOcbZutNZk8K9eX/cjhKj7/YlxCgBlWReqmidbt82q2UlRVXURPfvi9a/NnLXvx+mZklLw8PQ8MYl26qe5Xxc/skadjZzL3fVVCOGbb/5IiVourpQqBjZgBq1nazWnOIynoiiasgjAnNeEsBgxeKQ0K6UASAjBuc45/fHu66blORrvnKWiXiyDm6zxVbkIIXTT27pW5pyAAC/l0/5bRHTOpxCNi0XJJvNJ23MGV5ULa0Ila2On43HvHVs0r40xzk7OH6+2X9SNenq6H7p0c7NDxJzHWZ9yWipZF4Usq8XQm3myMWZnw7l7FEJ0/XHojdaWs4IxQbCazfOLFy+6bjienm6uX1+tt5Qe+v68292URYOYD4d9CIFSam0wxlEiQzRaa0Zhu9s0TTXPs3cxx/Lp8WmxWGw2q8PhEHxSYkXz9e6q6Pp9yo4JYNxxpcqyNTNM83Pbts7Gui7neRSCba4W1s45yaqU83wepqdR+/sn8fffwfPhHSG0rmvGyWazSymdDvM0TdZ+8t7H5FarJkxunqfLbhdCqEW7fxiaQq3XPztZ+td/232aCC43PEPQpi1wW5WYc/Aec6YyQZYUCc0BU0rBZe9zDBkzSTHHBDFdMtSQMGQcCbPFZzNvQggi+bF18o/GZSeOJANl+Ud5ymc+yMUwExAurmCYMX0vgkGhZLMpKCjiHIx62vvn5zkcCWUZrHVDTMx7H5KPeo7eckGELI12hDGjdUqMUZai5TxP02iNJFAhcmt1iFMlVdu2tt+TDMkHEqO3rpRAESlSxihjDEjOiEgJMkopJ4xSwr+fMmbEnBNln2PbLk2TnDMh7IeXlys5559SN97+X/7k4tIFJF9Es9/7I9Gcc4gJABHTJQAWUsgphBh8vFQbziefUno8WqKaX/3Fb9avXnZax5AI0OFsMnpKsWmrEAIX5PbljfOx78+n9N2sT8AtIqNUpkwpK4w+BO8JWiUX6+ULKauUnDWJoIx5QEJTghTBaOe8KUsVc1qvrxBp8KkoyhSJd2693r64eXl4djnNlFLv7Xa7BsBmsZz0sS6rnChBMY0uRmBcWqvfvf96Wb9knEhRV7xKEK1Jlvtp2Ds/M54ZY+M03D9Meo6SNmbO8zwA8YyhkHzSWiVg9OI1j1pPGXII7tydnDOr1QoAMBFGy0K1CSjnzLspp5QTraqiH86Xp+/jp2+ttQBZKImoOBcxRmMs4wQQU3aCK8pCRsMFAARjZkIjwXzu7nPigE4VMvhw6s7TqPvhwHiWXAqJhEUETMlpPacccvYueCDABM8kJchcsQT58elJMLVobwgh49gTCAQ5Aq/bOgYTgmOcCEmBIA2JsmDsUBe3w3ggTAtVE+S77WtrQj+cCY2H4/2sh7at22UtJHrvkRqKfjh3gpfn41zX7Z/88k/Hsd/vnwjhALlpK87JudsrWW2vXlBSltU1Zn84PpzOz1IWZVE3TQs50dhrbbzDupIppUSSc3NMjuXmYjhbVe3xcGaMVA1BOscckg8heEolY2yapkI1QtX9cNDmHDMrK1VWIlo6jS4DZjBCiONpnyKE6O4fe2u1UioFGRMTktcV6YdDxmHQx3GeFH3BuFssqJKNUqX3I6H+2H2sqlvJ6TRNlwitlKwPIWU+9JP3sWkqKUUMGYAWauldGOcH73Kz4DFBivx6+zonZlxj7RyiMdbFZAghXCClEEJIKZyPj5SCkgshxMUXB1GkHEIIxvicaM4wz3PO+Xh65JxbN4aToyx773LOzjkp5avXr/VEzke7/OIVp0zJRir+5tUvn57Mef5Y11VZLODuR1yACaLN8Px8enn75a//5M+//fbrBJWxJWSulPTe9904T36YOm2GcT4RFgCStdaHmRCY50sGXsnevPnL+/tPUjUZybF/2t1e6aMmnMyuu3n1VcghJJpSkJKcu45SbOp1DIFRzjnPAhkVRVGvV1AWLRdU63EcXV0v3n/6G+/P11fXABRJ8Hk09jyc5pzYsr4R/Y8cDino6E13eJ5Gs1ALl2khytPpASBdYpwYU1JK79AGa4Op6qJtNuPYcwExjTlUQijv/fsPf6xq0SzrL796/e7dB0bJze6N0QG8UlTVK2ZsJwpww3GYi7puKaWEROud5I3XCTKpqwoA+s4otQaIq9Xq4eEhRH8+n7uuu9psudKy4M/PYdG8Kivx9t3vfOx316vVcrdcbL/77uuhOwI5bDZXCJJz3k+fJvchoSaQi+IqBb7fH9tm4x1kZJvtTUgoCDNTChZebL98/eJX+2Mn+ZIxs6zLshR//Oa3CPTNy38KfnU+/jHTu2OX+rNdLurFcmOsAcTn4533/mqzS7lJQLtx8NnIGoZhsElM+8A5h0y8RylRKvjw6Xf99LFsKuuPgPzp+dPV1e58zm5yyXNH994QQhhjy+Uqe3v87R/+nzfXr8qqOnXnpl5YTVbL2+srmXPcbjbTqcM8Bz1LLL1wp/n+8fxUVz/jcchrYzi8PeX/z/vHU2CsaLj3KkN2fXO9FgSc9QVnOSfwwIKhgJB89i55nWMkmAkBxBxdwAA0A9gUjSfIQClOx8wp1iVUZQQGJBNAhAQoLkf9lH5ovEDOkbDkJalWn+GNd+N/GWIKENhFof0TmARzxgwZdSKMFWIlbggRnx6/HaZz5+flslZKZALWTdGnGIO3ri5Lx13fG0rEbndrjSur5KLTdlzU7aR7rrIoCz0nOz8DpLpsiqo53p+yyWATwZxBM5YwQ8RIOQVGQ86IBClhlAjBM1OcfE6SoUiQZErJhS7wg374+y8iAKZ0mQvEEN/8z3//w8ftu//zVyEYSAEAMGGCDEgJpYJzRAw5wPdE3QQ5ITHZxRRzDASzc0YHYzE+Dodm9+Lnv/4VV8Wp2wNRkEgCQqnUoSNMGgspAxX88ekjInIeQ46rzW1OyBjTWsc0749HZJbkhAm/vP3zzeqVD+b9p789HZ5kRWfTMyqkVIjp3N8zRlw31dXi+uZWCNn3IyJ675khSpZK1SH/QdvzxcXIB1sWdfBxHmiKHRclozAMA2JBEUOii3ZpzIlGfnN9a53e7x+appznc1k0QihnWSHLGASq1A13337qr67WQKYY2K9/+R8zpr795u1mtUbM+/0eaAQiSU4AmVFeLBtERVARloRk5+FICAENCCzGi5q3QBiFUD6alHTX7wUvlSocOOccY6ypFyFa7wfAwFggNKXkJ30MIST0vAzGzrwAgsYZjJ45G7rz/e56LcRm6KeyVN1ZV+VV3SxjDM4Z68/9sKcCq2Zp5gyprIsFo4pRebtbL8SXEe27j39cLXalmygDLjKj4KkihOz3zzHpsqaMtYg0g8ixvFp/MYzHFLGpbqRojT4xRif3WDXV9fUXV9vN3cMfx7EXQnFWZxx3u5vD86Bku16+ZKSxpjPGICxfXP/cGHMavpGKEaTesswQs0hEJ5gyGsj1dvPznMjpvGdANzWhlMbgQgom2m7oq6YGtFy54AgCbdv28fnt/WP34uaNwGHWsxDkentzOri23lKWutOTFC0hvXNT1z8dj8dCXDWL5TAMUmFVqk+f7lK2TMS6qLOPCSQTFgL86pd/9vDw5LXKNnCwu3YpJES/3KzenE6nsR/W6+Z4SCQtKFrBRVU1x+N5u9kpWfTnE2PQz0+r5aaoSqthtXpjjAkhuDA4i82ChmiTX7x58R+VxfL+8e9jMrLIfoxlsQw+V+WiKIrj8VhVlsv0avFzStQ4DU0rzt0j5dH7wVrDOQ9RNnUbQvj6u29SSsvlkgM/Hp9TdpRiTI5LEaJTRAAk4/bGxudn4UIX8rktbggqpPtx2qtypQpkFf3JsY3Nc3r9+k+k4n/4+nfd+bTb7QQvAVJIXfRH744ytwAh5kEUtuRfEsJHOyvZAMQMQUqVs2D39/fee6WKvh85k/f398ZOhEZC0jg9+6BD1N4zQnDoJ8553XLvfUpACFJKUw6H48cMKSbqplCWJWNyHKyZp3V7o7VWJc66G6bBh5lSpJxmiCn9WDohITF6bY0LFpEKVV78y1NKBAXnSgjBORecT3Ow1sWQnQ0ERQyBsqJQ5TybEELbtil7hpzxoq4WddlcrW/GQVflSojicDoRWc22Xy9fHI+9txSFSpCMNoKTumoJRkRaV63WVmvbNourzXYa50vP0hpnjOm6U1FUZSm5yI9Pbw+nu+ubq6ooco6n06koKsAwm5FSwijRejgcH5HkUpUxWcyEMVZXC8ZY0zTr9ZWdrdNufbVxfkYKqqD98DzriXEUHB8fnstiJenL7W5xfbMZOte2rbbh8eGpUMtLs8k6471fLtbjOMZkMhjIaewPGcJs56pq5imsF8tx7LWelSrmeTSGnM4nY5yLoS1XzjkEU1WF8+NsTkpw402KtCrV9urqeOhVqb784k+m0ecYBcP37z989dVXm6uqHw6MljFGEGyYbLVqcqIFFpy/ItZIuPrqV//TzLdf39lvn+bJi6YoFqpoCv7u/fHlqhIgwYMkws9hOB8KyWhwDIFSSklGwlFyQpFQAikgxhxTipAw2gjZBzqbYkxJCFKT3CKpJZYSBAkJ2Ge84odS4wJpkIvu44enLmQIgIEQ+v21HyNBPv8zDpmmDBShbZaZvGGSnE7PnGmE5MPsfeQ0pRRCdNohYaiUkKIGSCF6ay3QJKXcHz5xGaQsEfl6tfJl5ZzJkZyO49TpoAMGQnNGwilkhACIlFIhxCVb4JJPn4FS+DGeDREBE6QMCJSxC5IBP2mmpJRivBiW5J92WAA+U14yUooZKPnMYAEI0X3GfVK45ODFEGJ0GCNDzJwcj8ecY8C8706qbX7286+sc4f+PlMuZFGqhlE0ZgzwOXophgviEgmhAAlJMmbkvFCqDiH2Yz/rHiDRvJAL6eLTu09PSDLllojU9SeASBVMkw4hEBS3L14BwOl09j4F76zxQjKAmLLtx+d8H4ztp2nkgjb1EoCEkFOKqmDeeUoSk6Qqq6IobJhPp2MGL9jVPLmhy2V51ZScIlCWBC855xPRqhBt+woAyBPPMYyDL6oiBnbuTwCMClAld8746MKopZRVVZWVLIpCG6dkM0+eUtr3PUAOIXRdt1yu2madEqQoKdaM5pQzpaEoipyTdWPOuSxLqYS1KbsMQJHGnCOhKV8M13wK0SMJAMA5pwgxWEYjY8VqcXN9/aLrn8bxm8Pp7tXtn1TqBSMNF7Qf7/rxMSbD8ws7y0WzThEJxZubGz0b51yxDrKSDpphOCVIzjkupBQFI0yb4WqzyiCt7wtVcVoHj0IUGZCzUjs/jpMUp67f+zCJQkWflVJPT3cxull3SII2rm1rKSVsYR7DOD9/ujfWzk2rlFzU1ca7Q3AMURDCABOlYGYXEyp2U66jNsPz8ffex3mef/Gz34zdmTMmBTt1J2dsWy+EUlVVz7qLMVZV41xYr9d1XX755Vd9f9bFRAhJXiwXi6JQx9NTWXGkU8yd87OQWJY7TgRktl7dDNOnd28ffvblbwSXf/t3f8OgvN5uvYspEIqx6wZrdV0XXFwckvQwDj/78g2As+mparjPHRV5u3tpTej6fVtfO/vgQ1TKe+i11m3z0sdxf5iUbKOFpmlm3XX9o1LqfD4CwG7zIoMbxn3Kfhp11dDlYk2J9D5xJjmXiNS5QCnjXDLGmSVPTw8Xza21dr265qxCFCnSFFPbrGJyMXprT5M+heSvdy+UWsaApboiyB4envb7/W7z6vr6+uHRPD/0kAqaP7k4LxYLQsjpdF6GH8MftDlSvvju/d8whoRGrqhUEAM7nU5NWxIw8zwm4SETwRaqXM1jYEyu11dVVXXdyQftso+XxUQI4Zzz3jdtZe0c0xyziymce0NQAPoMnovyMnw8I8FCVlIUMcauO+0Pj21bVsWOccI5dzYSVJvV7asXr3/3u995by58SWNmIZkUJIQ86/HHFRBihDjbeZq1975uSu5oCE7JWsnG+2RNdFYz5hljAEXOwBhfrVan06nvzylmxsTFW/Dp6eF8mpTCzfKGcz4Oehh08PxnX760jsy6sy4ap262u7a5GoYhpdDWdSFVzrkfHihhiCh4WZXcGPfu3acQoGkWSinvo9baOeOcyTmfziGkiTJAjF1/il7X5aZpGi5aKnJMNiZrrbVuXK0WjNHDwWyvXiwWq/OpQ+SUCj1OiHSatJQyJh+TB3TD9ASQKZGYw2Kx/qu/+M+tSV9/928en95PkyZQEKg3m0ucm6rKNuZwOu/rurbWDv2R0Li+Wv/ud99JxWMeC179/IufX/IUnp7uc06Mw3KxdH4+n4+r5ZWURYyaUqrNaOwQgmWVSBYWi4WSi+NhJFn94uf/ZNHeYJxuXlzdPXzz7v23xg6Pz2/P3XOhmmEYicQCytno4CLnPFhey+2f/uJfOH77N98efn9vbWKrWr5Zldsl745zw8qKif4wP/z+A/Vu1TaCACnFqpSUUsoJ4YQwChwzRSAEciQxYkwQkcRMKhdMiDFCiARycCkMJsXEkTCmgDDElHO6JKsAQEqf+RwZQBb/+8sj99vn/8JDdgACkULGS8rZP5TVInAkkBPkDJyRzeIKAElS+9N3PmkXdKZeLiXjYOxsrWaRMca4INZNIZqUvSCcMX70kws+SkzR1BtuI4keUoTsCDqCDomLJIacPOSQKEjOL+IUxhjj8hLCxrhgDH/IZgMA/F6Y8qPVxvfj+/wUzDkTwJ9SN+7/6z/PmEIIKSVKIAOkHFNKSLL3gQBmiDlHuGxw3ofggp9diuM8qaboR/vp+XH3s9dvfvVzk/3z4RhTaparDCGDZYIxEWMgOWdrrfMmBMeYYoynDLMeIDNKZc4kxmyt8y4iiVXdGtu9vd8fDocYSFOvtBm4REZU0ywQ+DTN1poYiFSUMTqOI0EWY0SkhCapkIsQ0mDdqM1AaEMpDR68D2Ulm1YeDh2jIqVo7ADEOudm3aeUKrVqmkaKWory8psAWufnS3OaMVZXyxhjVS4utznkmVLUZixUS0h63j94bwmNwYcYqfdunuM8j7O2q+VOivp4vvfel2XhvY8x5pxisjFG6+hFAJwSUCpXy2ulirIsjQ4XtjsCK4sWoXReh2CySDHGnFwIkOEiS/rctcwQyopRaOrileSL4A993yOJCMz7iCyXrBC8KtQyZSelZFT5oFNKTVlqu394fpCieHyGwrBxfprNSBkjEQDAuciZpIQ3rZz0PM5eilKKWvFSCEmpLMtSz57RoizVpAEp6tkXql1vVuP702cRAKYU4XTMSHqAiEhCitPsuaDtolyvrgmqobdGx2bRCl4CQIgmgk2ZK7mQisYYjT0BgCrIaX9gjEgpvbeUsqKo2mKTICpe55wo8XVdD8NU17UxBAB22y8+vL9rilWGKBXULe2Gh67rZvNMGeGcn04no7AuiNZ2vd5YM5tZX1+9LFR7Pk4hzt4Ga3Xf2RcvdilbH4eUXMzcmuCcB4rDMAleNvXa+aHrTqvFdco2wshErBs1TZWSdUJKeGutD2mKxpzP3fXudaHqfny4f3y3Wtfn00AIWS6ulsvlNO33+z1liVJ28QZ11nmfcqIpISHU+xB89O4spQxRGzvW7cKY2RpflywGwlHFQENwi2Xtw9wPZxv6diVjFIyTlIAS9fL2S2PCN2+frq6urq62XODV1ZWPPSXKuqmfjiklVbSU0pzTj+shC87P1hokhFDPRTHPGqJYVD8z88CJXDR6mo8ha8akt1lKWpWNd2SeYopU8DqDjzEzJEkpFaJdrVptpgSaMM9FDp5wQThj3vtZd85r5z0PedYOMipZEJpCjMHDanFzfX3z9PQopRyGQc9ptbxpmsYYDZCttUJCWZYxzTFZY0zOtPnJ0h5zoJwghQjORz/N7mLmsV7tqnJ9Og5GD5ThNO8Z4zlnaw0XtF1UnHNGZc6ZUnpBRIqi6vtRz67dbbU9Q0xVLZ6fHhgjmeDh+IA0klxyXHQHp9SqWaoQ51kPzup5HqUsZCjKgs3W9v2EQL/88sv94Ulry7kQIgMkY6eUAmIuVLVarazV3oUUXQZ3Oj9TSlww3vsQfMqBUlYUyrmYIoVMp3Eex5nzQlDIOQvBl4u1cQGQOBtC8ICprBTkLAQTcjFN2hg7Th1x5xgzp7muVsN8EByLQi5XzTB0s+6boMpKQl4tlqKu67IofvGLL/fHT9oYRASgTb04nfYxRsaoVJwQUtdtXdfjOF76avM8pwhNs2ybJYAqi8a75K1bLMpxOu33p6pcTbP4+PEDInof7u7upSyEBH8ap/G0XCzMPMeYOStTLjfbP6Xq9r/7w7vfvT+FYv3qdvXFkt5UIAU8zk+He/zwd+9vl/iz22XbNGVVtZWqFWeMIAJQkimJFBJCypBTooRlShEzIlKORJaihhwjLDB4H70PMcYco7WCAQoG4mIaFi9VxPfcDkw/LSdoyogR0COVkCDnhEggfw+LfM8hvchXUswpIyFNuSBrEWPqhsdx7BMGX1Ip4HKgpwQBUgzzpE3O2QcfIuach7Gr67KpV5w31lrIUQhGkjw8n/yk0VriAoVMMFNOJEfCKOJlO3ERCWWCcc6E4PTzD/qhMLqwLkK48DSAELxQXgEIQGaE5Jxv/2d/+8OkP/7r32QELkVGIDERAhlSDB4gX/ihMeccQ4YE8cLyszHGDME5GzB+uL+zOW5e3hbL5ZxShAgkC6mE4ta4rjdWj845ylWMMQQfY4opWmszJGu1844zjkCn0VqTCtUIIUKwnOO5f5bKFyULTnGmkoqqzFNvY4xXm+317na/Px4Oz5SHDI5xQikwgs7ree6tMwDgfUREQnPKetIHPTsETlmTgWHKhMJl5Zk1Cz45nZQqQ3BC5ATnYT5MelJKxRhSdpwrKWnOeRg6rbWUknEyzyMhYKyZp8g2EjB7b6TirSxPx8kHTVwKkU7TEFLuh3OKZBj6C4M4pbTb7Rgjj08fCQHEbzmXjJacK0YLgrJQTV20FCettdEekVdlxRm1VlunvX8UvJCi9jROc/AhCEELqZzXhBRlsfRGOedyPnOBt7c3z8/TNIdFG3jh9+f3fX+sm6uiWBBmlSrvPj0BJOdhfD6F4DabTXcejr2ZzIEy4EwyVlBKY4wUR87yPJhhsJA4Rp5DFgJn3VFKlVKcK0blhfcTY2yaZaEW3gVKeUHbuq7HqSeEECjG6RSz5pxRyjmTQghCIWXb9c/GjlJKpSRkHnyaptGEB0ZqwCvON1VxDVn5MAvBzDzf3t4WSl2oFeg9pzwhR8QMkXOWc/RhmufBuul0fr59USwWi5e3Xw5DP+pPx1M/z6Nz4Wb766Jk03x6CJ/qui4Unk/HfoghBKlwf3xnjEPqcpq0dUIwrqaiXsQYp/lECFEqZ3TtotQWV8sdpCrYpqxvJTsicc/7j/1wvr6+1nriXBbV0jnTNFtC+fHwcbvdbjYbQoAQtE57b73ndcudzcfjaRhGVXCgyccUUwohW+v17BftuiyU1jaEMM9TDGyz2TRNdTyNSsl5noUQ2+21knWpVoIvplEP2qTsp7kzdlgsbi5BTjEjEKCYrJs/3d1VlRJCHk/PHz9+rCvFBVVKpqiRuBR9BiUk+SkkbE18epi2m68Ez8bvpVBDr6Mn//J/8r+gQL5+/+//8M3/W5RxuaqMMUZHSikiDSFypq53r5CE4+mZoGDzPGo9hOivdzfn7mjMKIsUjcdcGe09BUS8oIKMMSQBoUzZWWe0GRkt2mbzxZtfM1I9Pe37fmCMFaoBCI/Pb800rzfLaU7eu5SCUsp5MNoxJsqq+GEmztqLiDRhYorlaAESQNJa5zQCgFKKceLjIcQkReF8BgjP+zvIvK5bbY4AhCAbhxlJnvphvdperddvP/SlVIwxQs7TfC6b0vkhevvy+hdNvdFzWK02+8Od864oCkJI4aoYUk54CfK+ubnhTKaUQggx5EJVk9chuhBihlhWYnf1Zc7+HE+0Sta4YTyF4Iqi2B/3ZVlmiDF6xsBaFzxUVTONvbXDdrsVQgTvmrr13i9XrY/gnJ2HPgZAAs5Z75KUxXK5fP/xd1LRBN3jw4fl4kY10cX9NJ9Yy0LU+8Pd4bBP0UzzKYTkJ8WW1Yf3T2WxWCw2j89vOcOue67rqwzeeSOlpBSfnp4Oh8N2exWzj8ki0BhDziBFzbnktLFGE0zO6KrmPnafHk5l2XRP7/Z7dTo9Xq0Xy3qttV21K2OHGHqMI8Zqt3oxGZ9Z/fLmN1X967/+27u/f/9Qrq521+vbJX/TsGSn56dh37lP33yzWfBXr7/4s9981ZQUE1AATmHKKef8AwESAREwZvzsZY6QMQEiJQQpYKa2hpwoS4rHbM3sY/DJ04g505zhYr/9wzfLGfJnFAPejv+FyZmQhPgT/69/NL6vPhKhF94lCsZpyxn5qi4LxtOgKQQ7+9maqBRHSkNwlPkUDROcUJIixJg2qxdlpcpi4S0Mur/aNM6Yx/vTfJrT6IlLmIFQQAKU4cVaNCNkhAiZYsqY0sWbhHzmiv4gR/mBGQrft4EuUMflCqV095/+Dz9M5/n/9VcppQzw2aQcYs5wwTNyzggppZBiCCHk4FMOITgXfYx+toPH/NifAuCv//Ivd69un/q+n3XdclWWiNRbF4O3Vs9jRIS62TLGOOeMUefNxZskxqhkicBzhnnWjIpmsY7JjdPZmPOsOynb9fIlgeX26vZw/nA4fdhs1l3XTdO0aK8oKcqyzmBiTv1wqMqaMeWcM8ZxzouiYlTN0zOlNKOZzRQSlGqDJE+j6frDlbgqVEUpl6LMiRvt67q1bjx1d+M8e28Rec2LlEhdrlKKOYMxxnubUlo3Vc5+mKah7zmry1IxTrv+nLNXhbDWUgaznhFzUSohaVtUxg4xoPeeUuqcR8S6rq2bhuFMWUYyEuSMVkK0kE0MSMmprmshRAghJQeYQxScUUQKmSEUkHmKyLmoqspayBCMDv3QUVJVUjgb5viIJDARV6sFYkUpYRyLkg2jSzkSQpyLxgbJxetXvyiKwnvvrAdgStY3i+bp+CHlrAo6Tr3gjFKaIU36LgYePC3UmlIMwXq0MVmkPGUaAkGQF+orJTyiZFQgotY6RQRUVdEQaNu2BYCur5wfUnYpAWTCqATIn+7/UKpNUVEgwlqdUxS8DCEQAlwkwqyUcr38Yr8/7I/vOXesoMbOxs6znihlMUaWkQIDTCE4xtg0n52fjDsrJVVBPz38faV25/7ueNwnmKb5mFJqm2Uhl5izYLDd0LJU06RzIrvt63mc09KnrLvhASA5bwiBbjBcpPtHH73Isby5fsMFef/+28iiFMXj4yOBZr263myW7z/Oz/snyqCtbwhU82QEV86ZWQ9MJi7iZn079FNRFIVU59NkbSrkiqJ0/sR5tVysuu50Oh/KSnAu15vN6bQPIXqXN+utkEybCTCk7KqqWq+XwzDs9/urbYskpJScs4knQsGHWdvOu77r/bl7phRf3/7Z4fiY4hCicU4bP8Q0z+bcSNn3hlImFEQwNEnA1I/7TKyQhTad964gP1Ls9axf/sWb/+Qv/9Xd493v/vDffur2hNCqzB/vvj53x8enD9rOyBNkumh2isM4P0zTxGjVNA1AttZDpkpJxpjo+6OxU4zeWuu9bdrdNPfLtvXexwCMibLkWtuUYBxNIRXjLKXkXOAlraqWoHz39o4z2fd9UVTtotaznfVg5n57U8xznyFoPxozImJVNVLU6en8w0wYpykl5xymjJCFKCkRzrlhuK9Lt1xupFIpxRB9WTRts8zgMzhj5kW7a5v102GOCcqyDNE5PXNOGaePj/dKrKzR++G0XGzruvYptM06kyAVO3f74KGqxcPjB6V4US4Oh2ehFEUwxiGMAIRSap0+Ho9CMCEvMcyoZFOtt9ZNzuvzqScUOFPWah+c1tNms4kxCs7bpgnBORdSzN4GRKqETKqtKywK5Y3e7/chhLJoYoxCqIiZc8l5EZMex8Fad1O2VcPgadyf9veP3xaq+flXv7Z2+vq7v14v1oTArHtrfT+ci0I6awDgT//8P6EsJGDO+ceH/eFwUqUkpK/q1lrtvZdSUspDsIRgUch+1otF4310zpRlQ4nU2lqWKtXE6AmFmEyIk1Q8JD+O03p188WXu6ZZERTjOD883mlztm5EtN6G9atXqZttbkxcf/vN/t9/+1Gp1ev19tWmaakjxvqZ9c/68UP3Zrf4F//pX/3y50UMoH0khOYURM5WMJIx5YtMAykBQoAC5oSUXKBk+mO9nUDElHMmFIGgIpJGAZQho0Z7ypDSC86RL+r2lEDg534KEVhkoEAEJAYUM1xaKgg/qed/4H9g/H6LzyllBCyFTNXSu20KenYH4ykl5XKxHbpea5OSCzHFOFMuckJKmZIquDDOnuUyZ0iJjH3sjwmNyAmBkogBKVCWkRHkNCNQIS57thACEDOBnGPOnwEbRikipvQ54gTzj0VI/t6oFQF/Wm0AAOP8Uov4oBEzQE45phRSCjkF53MEH0OI3sboXfQuWB9dhDwmPzoTOfmL/+ifvf7iy/vnJx8DIWQYBilUWdaXc/w8k2keOad93xdFwbm4+DEDkEKVjPIMKfgcgvc+1XVVlGqafE4Y4iyY4KwmWEKihFwEQzhOZyShLHnKOvpYVaV1MTpQSgghCGHBJ8YEYzyGy9NCCSEhuAyeUcUYpBTCxWIJgBAmkZbFMkX0bowxx0QBBKE++8hZXde7Ga0QUttDykkoEUKwVj8fHsapm+exKCpELMtacKlnY93MOb9AW5wJpRSj3KNFkkNwhWqCUwC4bFeQiZn1MHZKUsoTpavgcww0MYjBOG9idBGLFreImIn23s9Gp1TMk+37kTEmeBTCVrVkjDiHzoIxhvGCkRpBcA4Zhpj1PDvGmKpyjkLriSBnlFeVdOHUz4+MquPZFqrpeogxERTB0y+/WF9vb2c7ajuWhbA2MMa0Hp3V2j8HJ1btm5evf9b354fHD4ogpsiyYFSGwDinIaZZh5xziqTruqpKbduWoUgxT6MDQO+SdaO1FhAokUqK4CHn6H0YxiMhTErufd/3c1Vsm3UFaAmtnR+NdppPIQRrbYhzJbAfzXk8CSFyjoSw1XpTFu3hcBpPZyYCEvrw+NEYTbijTAzjoev3JzxQ8jb4XBSqKMvd9jZn0nVPnEsp5aJd55xzjOvl1ZuXf/7u7dsM5tzda22rqlo0rVJqmsfH568NsvXyZrN98+Wbnw/jmdOjYOz69urx8bHrvtPu06Erc85VVVVV1S7qDx/epRy5UNM0xASCF4KXVV1cb8klrFuK9jd/+vOuP0xTfx6dNWG5bIuS3z8YzikiOmeCSwiMERJc0NNMAOuyoAgpZy6QELje3TKejR18sFVVpJi9N1p3zs+UeUJTXddt2yIoggWjLljjnSY0pZyalhozcVHnnEI0weEFI6Qs9PNJCi9FlSHG+GPBQQBSmv/w3b8zxq1Wq6fnwfm57+b//t/9n/rh/PL1y9314nw+L+rX17vXf/3X/z5BYhxWqyYE++03X0spl8slAmeMFsvlVUy19xaAUCKW7QuK9TCcAQil3Fm7XK6/+nLnfRjH8XC8K8ua0lKJJSTpvX/3/u8Px5NUcPkEzpNJCQghjJH9/ml/uOeCAAXvfc7Y1JxR5eyPzaGyrCbKAEBWtdW6rjaE5vw5aDtSllLy1lo9m6pYG+Pn2WQwjJGqasqinSe3WBRFUabMzdyHaOfp5Iwum511Y8peSuG978YBkbfN4vHp/WF/vrraaUt86MMMjZOr1Wqaz1VVBR8BwBhzd/dRCEYpPO8fNuvdPM+MquVivVy2zs+Pjw9v3//+endTFIUPJiXHBQohum7YbjeMiRhSVZZaW2u9lCQmX5WLdlE+3H2ISYfozt2+rmtjp2k6MFrUdV2oUlvHJENGQ3ZP+++QeiHYcrm+2tyOgx3Hybs0DlOTFSmkFIWU1jkDyFerFWWuH46UIgINCVbrK216Y+euf0opCcFSBGMsJbxpGmPnGGMIASDHZCmrcjIxmYzqxe3u7u5jTElK3sjVOPX9cdxtX1RlA5idn7zrZtPFGCmD3fXVMD5xvlTVyzr5bIrvvpu+vRt52f76zevdWi6FU4TqEaxOsZ/lNPz6l1+0HMzZJhJpoXyGFAEJzSGnDAQwY86YY8RMLtyLlDMyhEwwA2RIl3qAZMDP5ucpIxWKZgDjcj+YqpYFExlzzhEhAv5YqD+E/1XEzAB5Bo7IANjlm8BPy40fyg6EzH5ss+QYUpCUUMAcaXQ0OckItE3x6sUbvXDP+wckJuZZ64Fz7gMIoRAEZblpd9mpoZuf74bDo+XwyuGIIhKRKc2IKSZnU0gRlSRAOL0MQoFkQpBxQQleSKA/qH9/MGz+D3w48B/N5DO8kbNPEXJCBCQ5hhCCyynE4JN3HkL0wQebUvTRWW/mZFPO+6nPnP7JP/nLYtV+er5PSKTkRVsf90ZyvmxaQtg8z+Zz/w7aRa1kGWPKGSkVShXLZTPP49PTA+ec0OTjGKIyFqe5t04LViyvd5VqIGPIozH5dH5IIe5ull3/PJtDDOequN7uXj88zsNhKMsyBoaMUQoCIOUQoiu5qmoRBxaMEqKVotRzcO4ZCZRlJbgKPhtjYh5jDKfzgTHmgge0XPC6qpXYUKy9H6f5eO7vOZfr1VXOOcasZ69nV6h2tWrH3p/PfYq0rtu1WBfFxYncVNWibZYpB+/9OMzeJ8GjlBKR1FWbEhxPs/e2qmWIOvgkRSmqqqqXzrlp7mbtkXjOeQjhAsvFkE30OdG6WsbAlJSEJufcrDutp6pcbdZrQoh3cdaDcx4yKcrW+JPRlsiJ04rR2A3Ge5eyQWqEzITYFH0/jSmClBIyHwY7TPVJFLMenHNEZyklIho7Gt2LQmCmXKB1Q4gaMBjjKaV9Z6sKEB3nfJ7HnDMAiQGKsp7mjvGcIUmlwqRDdJ/u7xiHEC1jRAglRB2CcdY4ZxftFSV8mjsfu5giYAQMXKBSJUxAMeechunB+pOUjFFOqOWSFaXw3seYq6pKMV8WtM16SSmdxz0ilmXJGBsHw1nhg61KRZA7kxmpymLVdSdCY0re2oSIKUVCE0D49ruvx+kkBDHWr9cvV8trBPK8vzschxzLslkVqtJ6eHj81PdHzrmU8nw8zVMf/LxZNynloTfTaMwcIpzH+ZlzHrPkXMpU7ta3OeG++6YoZM5YqOrm5hVnqjtPUqpCrs186IczAFzitAghIEghl0IoxkRZ1ACA6ClliC7E6euvf89o8eLFy2E8pZSt9TH5gm+C99ZNSKKPc46Zocie7Q932owp6KLkVbUGSOPUz8No0b56+SK5pK2nRDKyCNFnEggB7+3FdS3FH42/hGzP/fF5/7BeXe12L5T6JeYoBHMpn85PZamaZrlcbCEXz8dT2fLnZ6tUhSRYNyMJUlWEEEo5czZLpVJyUhbLRclZJXg7jZ3xY1m0nPP9817w5mb3s2k0/dkXJeOcIghO23Gctd6P0+Fq23rHmqYhhGit23blvUfk02i0GY3N7ardbDbz7ObZQXYtFz/MJMdorS2VaqoqOS946cNMCJFKUJanqdfaXEjIQhTe5apsXQCtp6fHfS8D5zzG9PbtWySJ01TXZfQxou2nj8kHVapzf8+orKrWOt1155h03ciyop/uviXMr1arDMFaEwPo2ZRlXdd13/cAqayKDx8+TFP34uY2xZQSHg/d/vkEGO8fPlQL0izEYb+PyV+c5KdpkkIJIcZxdi5eGjd93y1XREpZFw0FiDEiwdVqmXOepiG4OE3PdXNVVyvnrdZaKg6ETvN4OD+mUBSqXa9u2mYz9nG13MWk9XyklHPChSq5oKfTwTt7PJxy+gOlOE8hZ1U3Bec8JmmNP3d7IcRyuYAsjXYxRs5pSmG92s1jLyVjHJEEYyxlgMR9uvsuxpCyr+uWUBzO8/X2i5e3Pwsh//4Pf1NWlAsgLDWLOoasZGFJ5Sb68DSdunz31P3xnRXNbrva3a7F9Za7+RAjCyifn5/3n755WSQWXBh71i6okJPxEZiUzPpQUIoEGCIBICkjSTkjYKaUpBQjYIaMiBfLUSTEQaaEZoCYMyKlANHCeT/MznIlCwIZMMJnUgNn/9vvkZFMMTMkIiOD+NmB7yeoBnwvbEnfwx4pAgAQCpRSQmmeNeRYiGK52FapNmGgJDgbS7WFdArREyYgC85KJEmKCoD4ZMdu7M/DsrnarBbLor1qf81I5IwoQQlNWo/nw37cP9lhCtM+Jep8SjHljIwRJrniknwfIZJzvnhuAgAB9PEzBvNjwwXx5l/8+x8+Xx//9W+c9zSlCDmEANERAglijD7lkFOM0QfvZ69jcDHGS8ExBW2C9RBXL3Zf/frXvC7PfWeMqYq6adsQ42qxtNaZ2ebs+rHz1kLGDKQsFWNs6GfnTEqpKIq+G+8fPmnTb7dbqUg4TZMmmThjbM4ZgK+ardb68ektYY7KTXe+95HIIs1m4BwJzcYOWo/zPDPGlu21EIpS5pyd5tPYnwFSUXBCY0qJ0er66suqah6fPjivi5KA54g8BjTaEZwTCTHPnDLEUWttrHh1++v18pX3zvlh1HdcUEpASOZ9FEJyzr1PVVnvT0+SL7lQSHndrpumMnY+9QcKNCIZB5vBC1GGlOuqrKrm8LwHwGnSjPGyLFNufOxPXReCb5stpdxaOwyz1s4HEFzlpIK3FGtV8BhzsGm1vP7ii68Q+PH08O79HyZ9yGCklKvVuirXQ28T7ULUjPFSbbdXL/bHT91wB5RqPUrlkETjNCLSzAAIMgEZrXaMMWdTXaubm/XxeKbpfYiG8WzsWBRFCJbQvFhWZaP0HPrhvD8+LZfLeqEOew0Q22rTNK33LoM3dojRLxabslTa2BCs88MPT6kquE8nqxNAziAyRKrpNGnAVNaskGvnnHFnxghjzPn5dN4DuknvEdSi2RFCtN1b3+XEn+59UROGAhnFnBDzqOfxPFNKOVcpovdOymKeZ6ON95aSkkBJJUOMlMrlciP58vHh+PT8ab2pCVKCDEn0cQjJI0uH00yY12PIQNerHcWKc875gXEieHt1dUVI2O8fIpxSSnWrtO768/l4PL55/dXP3/yT3//929fXP2t+Wfy7v/43333dL5aLnJ1zrlLFPE2Sp3GcxrF3nlVlY50ex/H5ad91Q10rHxhnRd/3gqu23nofQ3BSlItyGWNCpJQy55y1QSerjY44dWfzi6/+oq7b+/tPMceqqkI0OWFKSUoupOgH7V0WokiRJpgJ9YzC9fXOGvP8/OzmLEW72nBGpUdTFEXwpK4WlOFsY9c/ccbmyVACDf2R+fCLn/2Tdxs76eeM5rA/vbj6OWTBOY/27N1+Px+NjoKtsjKQtE/PIcRx7LuuY4xsdyvOpTPh5vqKIetTLhhZIIhKrYfxeDh8l7JRZSVFMY3WaB9DNsY87x8pA7BLVa3Wq50xs3UPGU29KMZ5UrwtS0UYPR56bXXb1sP4PE5HVam6bpWsrIlKlEIIY8w8n3+YyTTZlLgo5PP+bhx7j5MUTfBU8EVwYOJUNUSb4eXNX8SAvT9b1x+796pgIVHrkHOfknfh3DQNYzzGSBULIdBQUpR1tTydTmWJIZysGVQhKJaOaGOez/1+tdpq4wgpBjMp0hACGcK5v9d6kkocT6fHp3d1vctIKKfOaSHl/cO7aT6XlaDA7j6+myfNuUxAGGNtrXLO4zzEmKpqIXhztW6v1kmVeDg+3D38QSoqVYoRLjxNE6ZMPDJOuDuP74St16vr06kLcUx5LhRxxjk/cF4QGmPuUxJ/9Zf/+d39d2/fvrVO14mmFDiXOeeikKfhG6shBfnVz/6MM/nxQ6CcedcBba92b4ZhJpQul82523/7/o+//NVXBVNRdEKa5+dnzmrIAlP8cPyUSF4sFi66YQyCV0W1EJKzwn/7hz9kktp2G5ydzV4KhoTMOmjDfAp3/TCY5aejZ8z9fAu/fF1u6+SGgfD6PJjnpyc9npmLph93r0wrqAuQfSZM5JxiyonQTDIgRgIJATMhkEhGSJhSQryEq1/KAkoypgQix+Atck6RxpgIJYM237x7+9XP30iOFABShkwSQf/TAz9hDEABcIAfTMJ/KDR+igrQ76uQCz7yw5tJFWWMNGsF6pzj7IOPc3f2bcvH/rxZN9ra6NLZnWWh+mmAmDAX0UNVbOviVokVRiF5lrLMOQFJXMlmW+++uPHOGWMOd3fn06k/7p0zGYCmSGNmNnqeMiZgBCkAZkgIgeaQM41cKMFkjDE4j5hv/sWPgSl3/82fhxCi90oJziDEGQP64CP6jCElp+1orc05TdNJKRGidcF5hnfdE2vr3e2L9avXtKqcT+vVdfAwjHOMCjL67Gzy/eEdAFDKgZHhfF4smr6zhFhKiVSwXC4fHu+/e/dpsWiWK+W9tpbVdcsYM7MmmJGiUizmmYlg3ZFE++nuVFZl3e6enu768VCWQkrZ1MXb97/Lia2XL9brtXMxRZKiG8dZCGZcd/fwTSVaTLBZbzPCOE+AXPKF7vVyUw3TlDPUy1pI+bw/UyZCitaNMZBFs8mJUUq1MSFaRCqEWC2vvMveAae15PLF9ZoLNg80Rle2PEXNWTn2/axP3p0yC8FSKbdl2RhjJGsEraLl3oGPnfUHVTDvPWSChFIsZ3/f9Q+49Np1MZCmXeRUxpgDTEhyjqxQdVkUfd/7oLXprRu++e7rxaK+fvGLC0PQu/jp00fOORJXN+ru40mJ3avrL46nR+ccK2O1KE6Hx5xzU69SyMGGlIKmg+Bl1S4xsuCTnXPimhMYpkdnM2c1p4JmN+szgRgtmaNrV623+xBsTJaRVqgFo/L1y19qMwkeYvKLBiY9U1q9uH05nPzz8bu+f8yxbKufvXzxi6udevfxf/j0+MdLeJ5S5TRNiMT4WDWLHMg0DUYHQtVmfW20czqkkALpCVrJBWMMIFESkci6WBdVGqeTnQdEzJ5M57mtFyE6ileYojdnwel6fbXfP9XlEoDEgEK0IRpAsV7tnHP98KwK1pSbmGZtOj0MQiiGahp6yhADL4rKpZiif3G7eHx6GseRoChKYpzNCZumCdGeTs+EbpEQQnC92n35xZ9QrJ2n7XLbLqrF8qZCQrBcNDdd1w3j2M97/W4vZUFolIohG/V4fv/pMXhQhcjEG3+sqgXkCoA45znny8Xa2uBjkEUiaMcOGV79+a/+2R+//bfjeC8VLBtl5y6n9fXNtuuO2kyzxaror9av7+/vu+G8XAvKLWZdyDKn2UwnLvB4MtM0hZh2t6u2WT8/H/bHu7quc2YESEqzGUOMomkaglIKlVLK8KOYdBhOukoZ7DDMiuPz+eMw9FykmPz5fJCSHw7zovWIC9tb70kh1TybnOibn/8qZzL0WgrVd4Z5lwK4QikhWd0oH4Q2VE9eEWqSK0v15ouXiOFp/50xvbWGc8FZiTDHZBgnlJaKF5EUpbrW8xmo9rHvnp66vqLIpFgyht5mzAnxEl3WjGPv+v6HmaQMq9Umec+ZLFSDUTEoOFeCF8fhEJMlCEhwmvqcSYgmQyKEERRKlU21Gsb93d3D9fX1YrF6uH9arzdCyIeHB5/GzWZT12ocsR/OKUXnTFEUOaE1kzZjjBkyppT64eiDVoWggj08fxrHfrVa9eOwfz4LoXbb13W1GsdBm56L2tjp+mabc9SjBsCbm1ecFed+4FwCsL4bQjRKqeD0esliCCllO5tP7z98+cXPrbUpptXyqlD14embom6rWmi617OTsuGseHy6B8iUZZIJw3WzasbZDkP34B4oYdoMd/fv33/8fT+ey/q2Hw6IuN1uYyyccymypm4Eb4wxH54+McaXy+V8NwMAIaSuy2nS2gxtW73YXc+TifO+aWtIIcdhMlqp3NYl5Y0qK+vmaeoISUgDY3I2/fuPx1E/FlVF+Riiody7YBGE4HXJRdN+pe3i9KC5D7vN1eubXSnoZB1S4JDQe3c8T5/u5TAtGGfOozPZi3DZOAEQKBDIKQNCgs9ZLBcqAoHLMT4D/DQZBD9jDjkjYIpBUtadxm+/fffm1e162UpJvi8hImZakv/d5eW9/19iiogEASkAISRB/P+bxfIfeJhiBsKlamvgwQwz8XZyp4OPx+N+saqQaz9Nq3XrY3TB11VjzXnsXFtubnd/3tRXSshCMkpSDBgjxBS1NcYApZRzWRTVl7/8pTN27M7D8TAcn5LWlgHjnCbLOCEEUwoXPiNjQpaSZAIJvYuQMwB58S9/+8Ov+u7/9ssLHZtznnP0/pJmnwiD4P2kh4sdECFEa1Oo6vH5CUi2GJ4ej9Vm+eLLL0RVWTftD07JEgAIclUIgMwYHWf98HBn3bRZb4VQCKyqmqpqjNacFZRQxiRnFWfl7YufrVYLM6MLgzFzURQxEO8tEIvE6ZnRrAESZ+U0z60s16ubut1QStOnxAUlwIbOlcXShdj3PQDhXFhrCcnLVcVFsd9bxlghFt6P3vsQJ+dciFYVXCpyODyHkBbtyjnjgq2qKgR77gYkhXcG0Pl4+v3Xd8aYqiqzZQjCOww+WRM8ITnToqDLst1ugbJ8PD3Pk66qRVm026tXhyM7nz9ut1eMsXN3iNEzJvzkY0AhhMAmgbZGazMhopSSMVaVS84kJdIYC1kopZQqg08+zIC0KBkTzrhJ29M06cf9HxGYUiWhMM8z5zzGeDpd5BJVP3bGdTGF5/37/+a/7c/9Q7OgZtIZQk5UStk0ixzwdD4iIqd1WVTee6s7JcuqLAFoipDQRIgpdoCBEmfTCBkpkaVYOBvKshZCuBCn4QxIm3bx9PyQUpSKnk57bSap1Dh2798HTBwxC6GW7fV//Ff/PEby9Td/q7UmKCCzumrLsnQ2XMzNUko+hJzxkpMXA7y4eZNTOj7vMxWI1OgQ0wAYQ0irRfnqdiv59nR+PBzvEoyn0yfIk+Tt7c1vPj1+IwQrSjnPzlq7XC6bpjHG7DY7baZhCIVopt52XadESRlM05jBE8oYVZQUq9Wqafz5fLzEwgkh9vsnKaquPzOeJz0V0HqXlay/+vLnf//7327Wr5RUIbiy9NanP377+9sXtqzo3/z7/76qFePEOsuELEoyTskZpwqhlPDetc2KcZznMUVyPo1/8Rd/2XVdzunqajf0E2IsK+XCqA0WhaSUn8/HdLJtU+UsgGomfAgGMuOcMspijPf3jynnoqjquu3Gwdvh4eEBiK0a9KFnnFEQ82zmea/1RAjJ0EpZMBadt/1wXK+XQrBpmoQQlKKxg3OOEHa1+moabY7k9sVOf/hR46btzNkyGFVIsVpuL441hORxHHfbsihEzoBIY3SURS440sVut+v7MYF+fj7EGBd8+d3bR1YWbUo5ZWdsfHwyIXgkmTGGQBFIP3QppbpWMQYmrCyBYHbhdEl6a+tCW+t9Elx1XYckTP1AKGx3Gz3b6P3t7ct5CofDoW1azml3HrTWRaG22+0PM1FC2AgI9EIZ0XPkFJaL+upqSymJSc/mFKIfxkPOGEJAjEopzjnnsiiKeS5229tCVUNvENT26jUhZBrSaN49He+fjveEkJubm6Zp7u8fZ+skLQWvjDdlwbhUOeE4jik4pPZwfEaEFy9eKlkeDqemxjdvvri++sXz/s76idB4//h2d70ui/p0GggWbduuFhtj3GbdCKHOp17wZrnYHk97QuLh8Bxjvr7a7g8Hpcrb21fdeeo7G+2i3bz+Z//0yz9+93cE0Ni3gi82q5fjOFKqAS1jLCXpdLmo14L3KQ3D+fxnv/nzGOi7t989Hj/sdjfT/5e2P+uxJknTAzHbzXx3P0vs35J7VnVXN5tUEzOSAOkH6HfMrQBdCNAII2IECBKkW/0I3elOEKCZITkkxUVkb1XdVZWVmd8S69l9t91MFycrq5qkpJFIGQIBD8SJCDMcC/PH3/dZZIcQvry8dsECCKRWIPDl4sp7iBG7vFp7FyPwl+s3BCKnrbGaUJBlQuo5BM8Rq8paqzhPMRVXg98QFtOMAsiPpwMhIM0EAGCetNU2EdVxN1CeUJx23WCdSrOU4nyeYtfb6/WXdfbqca/1fqgwfXu5ul5VIdjAGaFI9uN02LNxuA4Qu2A2L/yTmmljrfYEBMQgxAgCGIADEKIII4QwIAARBAiC8EMw/Q/tjjMKOfMiPYIQkWA8JcT2cvPwVBX55cWCMgTBOS7An22tftxpNMIIAI4AIfBbzcq/h/Hw/34gCAAjAHIEuJA0R8RGELzDwgxzB+YIABhGqUzAhHEOYczXy6tV/WWerL3FDgLAQQBRJBAADAAOkRntvI9nSVSkhGbpIk2KxUINV2N/mrr2OA6FcTQiRjFGGGDogY3RG2cx5iH4HxTzfxs8IUTO/RdCkPNO68kHG0C0zmqjnFfWauect855GwFgabYbjgq5yy8/uXp9BzF69ebNu4/fzXOXJAxA5wHAmEg1UMqlHKQakiTJ89zoQAhYNGtK8Tg+I4sCwowmiajzVFOGMcac+W5oj+0xy685rfP00rju1D1UWS242O/3lGZNwxEGu207TjHNGCWpUQZClIji8uJOSolJzLO67Y6zbEUCnZXj5EJAq+Ur6AlACcZwkpM2s9Kj8yzPkjQVaZoTLCYpCSGc83meBE8xEmUefVDjvAsghOgwzpr6AgCgVbDWE8KqqgEADMMQAkjTdLN5tE5RRvb7/c11ul7dnI4DIxUCiXNunkcAbZotBU+tAWlStt321LYAeoKFtdoYQxnBeMGoSJIEQ+N8RAhhDCnlUPkzcc95M4xHY2WSEgAAxgxBOI6dNaCuF95bAMPl1ZrRVOq2H9o0T8pCzFOXFTBJiVJQ8LSpaudc8BBhQhkXggdQ5RkdpuMMO0zEWZ2GILfeGK8AiJh657QyE2dZUedzOwMM6iaP0TslQwAIsn44ZOQCY5jnqfMZJhFT1LYzUKEqaidBmlQ+2I+Pv1ZKvWwfKSVvX3/atu04Ts45QogQAgCglDImWGsp4ZylzgLnYiry6ythQwzBPT59r4xKUsQ5MXZ+//HXnL5k6UKwNYBVkXnKQoTjoX0/q11eXshZn04nkbA8z8+CZKmG/X5/eXG7Wt7utseqXCUpuX/4fpYnSvFqvWQ0mWdlDUCIxgh9lM4Dzgpv0TyPmPjVusgrHxzTCkIgnKHL5nWa4bbbHI/t7avFNGo5O4Qtz6LZdxkJNnoXJuiij42Po7ETYkFrr7W2MnDOGCecZYtFcn5g3mye234CAKRp0g9D2x7TtETYa+sBdBRRZ2PTpF23/9d/+d/0betsEAmqytoHdjr13tsQizQVVmnKuFQ9T6K2vdRtnlUAZUpZD7TIGEYUIhwBNNZCFHnCrAFNfaH1cwjgt8RqEIIRbFleJpvNLnie582Ph4mzcr3+4uFBQwQXi8U0Sq1VmmYYiSRl1mpMoPfeOW2dtG7GmDYNjcBI1UKsijzxsQugJzECjJHzJgT5sunzPBdCFMVqs9kwxqy1x+M2+rIoBYA+guAdZJRaq8ZxsNaBiLKsKrLEuK2zsKqWdV0rNbbthxj0qXdjR1br1SefvPr5z/8yRPPq9k1d1932r37/BFdqTlLOOReClSVx1rkwaZNQBgVJXZjsZAiz1nqAHMKRQ+xcGIbOWZilxc3NzfPzi9ZysWx8UPvD6di+uNhDCLMso5R6b3e7nZSyKuthmGP0gqfee2siwfQcNqZkwDC7vLwKIcyzWjSXaaLatl/UBkCvzQixSVJGCX9+Oi4XV/kyQQhp5Tcv7XJ9WSwW3pK6XpzaXZYWVZ05Z+ex22zVZvt0ebkexxEASDD3HtTVCkDTD6e2n0Qa8jw/HYc3b94cu/ju/a/ubt9Skgt60SwqtVFVVeV5env7Zrs5EcKvLu/yvOi6riiKqiqenh4BAADapr7Q2kMIyyLzfmxPXdMsYBTzdHJunuUAoA0x3+/34zgvlyvBc4qS6/VFVpA//6v/yrl2GIa+k9JOWZZgzL0lWXKVkvqnX//p0+P257/8x68uP68bLvWpH47zrDFZlDRPk9vhFJ8/bqC2t3eXF01GcNDRwIjVNMqxyxGEwZ+eH5NJLRES1hBvgrcxkhhjiDHAgADyIMIA4Q+IIyIQI0QEQY8jjGeQASEAMYaz55UFgCMAIwTSbR+eYPSfffoGYOC889EjCDHGECEIfyhv6PAPbIg+BnTGIBFEECOI4L8D3vhbRQ4IAgyeIsJFnlYX+hIhMIJ+si/TNJZl7pwbhuni6lVdLafZjKpYVG8pzrv+FAOGERwOMOUJE44xlmaCMy4EAwB47621PjpnLACAMFJcrLPFYh7Haejd9iUYLY0iIDDMBMXeW+10BA4ASAhCCK3++3/+45w//jdf/1Y36yJAIZwJoc56a612VjurtZZKKe89QkgC2w59SPD1Z6/Tpur04GKo5gXGEQAXgbdeGz0jRKz1MXpCUV3X3nsASF1XRjujbYyREIIx5TR3Fo7jpLV2Hlprd4d3EPm8SAVPtXRKtiE6TlZ5ViGEhEjyfIVwkHLqwmBtGMdxubxU0lgbymIxjvNmey8SPM2tUgrh2A29lFOeLeryeug8IZCzJALvnEE4GCunufWxEKzJi0prG0I4S1UBgMvlhZqjdYpgDAAIQWZZVpalkl5KGQIghIAIvdfOBYRAXZddf5zlUNUZJbwoiqYuN5sNgjRNlhAQpbT3/vwIK2dDcMJpCQHnLOeCeG8Ph51zLi9Eki5CCJTQfNl476VW0zQyxmKgGFEQuZbWW8Y4FYx7H33slTKMFPV6lSSp1sp5M8/zSXfGGkJYlvHFMiHUjyPoulOV14RCF50xBhNOCMEYzXJMkkxp571HkI5ynqY5BEAJN66LEVLCKRMx4hikcw4AzxJirFJq7rqOEFZWFSWJc96p4L3v+14pFULAACVJQinlAoWQEMynafzw8RshWLMonY0IsjTNp2kYhgEAwDhJREYIwTAiKhgn1niMxfPThjO2rCupUN1keV6GUXrvy7Is8/U4yEk9hihBTOpq9Sp9O4z7bthOaieV/fCxn0ZVlnXTNN5bY8zl1bJvO0JhCOHh4UHwYrVat93m+vpa6azrW6UURoQQZq21VmotkwwgBIRg9eXlOMgYjLaS0Dib2XuaFDyEeH46VUoJwe7v77WymLLHlzAMA09olpN+6He7TQhAa6mUAQBEBwEMQohcZJThGCNGKE3S77777vrmMsvSiNzpOJxONs/Ti/Vd3/f3D+8YTQVLEMTex/3h+XB60FpfrF8xUo1jv1imRVI4542dnJ8mOQ/TIYcpwk5rHQBkNDE6RDI1y5WxuTEuBkwIw5ggZKxTw9ABi4qiWS6unDO73QbAeKahT3ML0mCd2u12K/N7TqP6MO8e0zQnhDw8fDBWVeVinidMMMawHwbGWAjBeeODUXrM8nqY+mEaJzkXWc4Ye//+Y1XVJAQfgRcJIQRbN2szIhwZp1wwSunN7WfPz6nVEyUpgFFryUlqTXTeUEq4wPM8S9VyiSEyIkmzLIMw7g+b5+cHISBETV1canU87HEiQJEtrJ4PW8t+75gnBFCGnbMIgRgBpkrPo/WjNj1CmLMEQogxCdFE4AC0EUTKsPfOOaV0Ryl+eOx2uw1jTOowP+/P2dBNUyEM8jxXSo3j2LZ9DIQSY8yszZxkIgBoTYAU1fVCa40QxYgyKqZpytOMUNj3vVLzsb03dopAJ4JxznfbU5Gti3xV1WnXdQBhyhNvnNMGhDCPvdaKMth2hxAMoeTUbsepdU8TIQJBCiLP06Qfn3/+iz+z/ki5F5lQTi7Wr9Ii/dV3x7K+OLWGYv/2NdV6Phx2SSLSpOpO6nQcb2/epMUnHz58uLx4BWHcbrchGh80Y5QQIgSfZ/X88jBP+nScri5vKQGn41NV5yKyU9tDApfLZZrmwzBQ2Nxdf95Ur3b7j9aGqshAiBDQIq9Fwod+zJKG0YzhuiwWRzFdrK9ijPv9vh934zhw0Vws196n1qYvT9v2NDZVc329FBm2QQcU4ThjFBmEGAETLPQzRT4vc+Bl9DpEF0E4xyWHc/I8RBBECBCEAAcQIYgg+ghRhBCctSsAnb0WIQDn2kcEwLjD4zOM4ObmBgAPAEYIgLNl998uXTAIIII2YhQBPgtQ/v1Zb/8vMQf4wejCeRggIiQrCRAoMhnQOCEIJxCC0XBSqqgWdbXYbtppNK8ufxZsOsmAEOUssdY65wwGc+cwjvMU09QnKWcMI4w5hhAAa+05Dt4CABFMyyKrKlfVU9+N+50eWmeNCJgRWAiuogohIAJX/8nvoY1/9JXRlnESgHPWugi919abEPw4nCCE1qh5npxzAEEfwjTPLRhJzpd3a1aJTvezVsu6eXy5FwQzJgLwKEbrNIj2XGYfWm+0y/Ny0aydxTpIIUjbHRAigheL+nq/37+8PE9ynyQ8y4rl4uZ0HCms5xG60Erbg8jqah1j7Ic2TdM0zXa7HaX800+u+6E9tU9nHAaAPx8pSg+IUNMNzjmRMCknzhNKRCKKvrM2GucioYBgDDGvqkqp2XtvtJsmGUJgjM3zjBHN89wYY6yjRDDGjidrnYtAG/3MmDhLRTDGIUTjBmcDhHCak1kenJ8QShmHQog0g/vdnvG0ri4AdLMcpNRA2RhHwYury0VdLxAG3ts0FZxzRlPn5yRlBBVSyhg9pZyxqI2SRjlvUl4ylloXnHNZlmdZ6pwfemmcCoECAIwx3gFCkRDCGEkITpLGOtG2u64/OOeSJCuKAsWIMZJSE4IwilorH/QsWxcDgpTRVPBSTaMLKkI9j9sYQZ4tCE6AzzBCCcOj3Dw+fRC0PBvNMSaqsoGQauVChDFGIX5wLMWYMsY5y6ZpGoZhvbxzLs7zRCnCBHBOCUan02m5agBwxk4+OmMchJAQ4qOE+OzJ5gBCAPp5HkCQdfNamykEBwGWs5lIWDVFWWRt2xM8z+p5u/92vXyLYMrwcpJHjJ2UE2U0TcUwdIzRvEi32y2jECHkg/QBY5JPc7fbb7KcKT0ao0JwWVZkgjvnrDNpKgDUxmrnDELBB6PULPURYcto3vVdWawXy6wfNz4YiCzjUGnGORFJ5r3HBCYJf/f+OyFEkTdn40eEQJrmLgRjTJFXwakQaXvqb2/eYMwi8G17yAvx+PICYxo9iy5fNrfj8O2xe7q+4X3f1tX6zZtXf/FX//zUbuumxCQAFPtOMXqsKh+i9mHux12EYZonwuoYoVa2rheEgu3umZABY2xNMMYV+aIsS2u8JRYAYLQu0nD/8I2UOoTQ9+1iWROCEiEm9bQ7vK/K1au7z9uP29+dnywepkOWxhCxcQPjBCKn9MwFneTggyEkUcoppRAORZFV1dI5N08qhMhYmYpqvcCvX78lSUq7bsQkiRGmabrd7iGkCM1neb21HnggeAkiDT4sm7V3AGPsnLNu9kEDHLSetkfDaMZZ6IfDLPth2iUZrvOL26tPEVTW6lO7RRgFIKPHzs7l76XFZlk+EgIJUkrN8wixQoggHGzQBDFpZ4wYptxoiTCCEDpnMcZnbjMlsB320zQRhjzQyoCiKJigzarUEyQIYcTl3IUAQMRlWSNIIUbWBR4AwQwhaq2d51lrnaV1P84I6jRNKcWH48swtPUindWu61pMIEbFPOm72zdNfbV5OZylNBHEJKWJYOPU7Q97SumkhrLKKIVq9oiTZlElKSEUaT1BiJMkIDr//K//eQCmKEUE6uXplIj49nX6i7/+c+fcF1/8Qd9aEPlu9+L87IMhJG9PI4wtgoQxAiNuqhUXuOv3p+OOsujCpFTwhq7ZWuup64bl4pKSJC9SENF+j50zTdOkZTKOY5aXCKvvv/++yq4BNM8v73/1659DBBNRyGkoigrg4IM9HtvkpunHFwz7P//F4enpKU3NpFKIPIASY5yIKk0vx5G0+6FtuyxPLq4XoqCQABcCwIShiDiyBkzzEIFtlhWehjnOBDmOrI8+hABCjCC66DCABNIIIYAARhAQgACdOZ0hnMUpEMIfZCrnbYOijdKNuyMI/uJqTeo8QIBgQD80S86uFf/l+cUx/gMQAQYgIgAjwBCAH+w3/lbOyH8X2BFhhCFihABAgKe0BKm3qY9aK0FoVVLMaF3XIHKjWFNeJyI3hiRigUkeQsizgEkweuZsFYF33neDGWeTcJzlQggKAaCEhBghhC54ZxyEGGNKyqJMU14Uqj3J9mjmIXpLAUIceqtX/8lf/DjJ53/2U601JvFc4HBeaWN9MGc7Fq21tdY746N3wM1Kz1ppZ8ll8smXn1sUNsdD2RTrbFmWpVFajjJNU4z4D0YXNnjv+6l3FuZZQ0my3w3zZLMsu7m9BiCO01HwNE1TxtCpPyl9ioBnWSISXJZlIsrd/gHiSSSE4rLML4dhGIZ2wmCeJ2NsVhYIA6WHEP3T873RFmNOKS6KdHWRhqiUmkHMrPUE53W17Lup6w9ludJOHg6nPM0YTQCIJGMizbv+ECEMMMx6DtYhhBD23ptxHLWRl+vXACCtbZoJ54OUY1UXzsF5HqUyjFEhEpHQeTLffver6+t6tawYpcH7/e5x6PeMpQiHSSrv3eXVcrlOHx7eI4Sa+tJoN0z908tT37evxKs6zaWe9TgbZ52becIAwDF6510IDoEYg5nkdpxwCCgCaBwaxgghoiRxLoDoZzkCgIucGCv7/uSDLoqsrK6Cz/u+VXoUCYUwGmMYJjaECDwl3BgzDAOADkFgVEdJSkWGCEcRMp77OL9s+kVzVZVLNUetHGdpVa60GQ/tobq5XS6XZ8vHaTTe6xAAxjiGQHxwzmIMjTFtK/OsZEzM08nY2fsIoIsxKqUIllp7Y5V1/HB8abt9kgqRpBFY54I2/STnPC/TpOrbkYsEcigYNrbfPT9aP5ZlWVU31oChn84x6G33PM7donr9+vaPtpuTCn7R4O++/5tzh30aB+/9YlEnnLVHAxEmhBGOyqrWyg9Thyl6eHxMeMpFQhmK0QJII3CEgLKqlJrHcZRqenq+x4hhjBJRAGjnWXPOQ9S//PWf7Q8brac0403TNHV6OBwQIAgBkvKmbl6eD4Dxplr6YKyTzhmMqA8AwqiUsXp0zs+zyrt6ubhaLtZdvweQAQC+/PIrTheb5xYCVldLAEKW5mqYECLGOAhoXtQQUm18d3oSogjBGyt9MF1/OHVbIYTgDEYQA0SRBcOl9BwthIjblw2lFcaYEAYBNkbHgAlOHUTv7/86eFDXCwQpoYhzOs+zVDPnvGuPCU/ThHXx949HwgXth50x5vr6NhH56dQxTkMwXTdwnlBKvQcIEu9NzhMPkMiKzHo1mvY0Bcvr6ro7WQI8QBHNvTwbDV2tbimlGFMPvNa6P3XWuqurayWNMaapV+/fP7x9+1Zr+W/+8pv94en6+nK1vHIOIARPp9P64jrP6nke1jfXV+s33jJKBcFyHEdMorWaUs6ThLHfO8QxUyZklFMCRAI4XSSpOLtuW+sJRhgBSjkMFUbB+FFKSUCMAXqvrJIe0tW6zrOy72ZC+GpxBWOeJOkEldLjNBprI8a4rqtElF07xcjSpAreQRAhjCG6w/HFeUNpdM4W+YJz2HWHeTolCdJqUEZnaTFNc2fGIm+Wq8V2+zBMHZqTxWLRdZ1SkmJgrfZhFiQbxtbYqUgzCFHwaLlczoz2w1HNA6FIJKQfNm23/ZM/+dNT1yk9rxerZlE8v9zv9o8XF1cf3t/fXH8SPJSzgQg0TZOlhdEwhABR6IYXCGhVF1131HqCMALojdHT3IEguu92Rd7kecoFFSKJ0Z1OJ6XGScWszIq8ftlsrfMIIcyotn03PHtHmNBMZLvdzqi5yKuszOZ+DB5M0yB4lmSgnx6M35a0dn72xhsTIE4Fa6Jn0bPpNHitry6vlqsSYAcQjhHHiCOyvRxUMFgQyMhopNfjzcUiJDhwDOgP2AH+wAONPgAEAEAgIgAijCDGCAKMLv4Qi4IjCDCiACAGEMKgpBxVtGaxWMAsDRBABEJ0IBIAQPxdbNt5BBAhQAD9Pmcj/vu8N/4/jQAoAg4GCAB0EIBMpLhZ0zDen4plcXkrfv19e//wXKYw5Zd5cuOtoERwJnyM1kmICAY0RBajhefaTcDW+xi9B1oZX2cCYgxhjNEjADETZ7xlnCWYiqpiec6rWp6Opj1NShIfbv7Tf/m3pxgRgBEHbWbnjHVSa2WMMsYYq4IHs5xCcJCgyalezzRlq9XV6sureZ6lVFlWYMCsDmrQSZJqGAhOgodaKWt9jHGU8zzPWVp89tnnx0Nvbfjy88+cM9qMmMAkZZiEYTxEqCJQxk3GKsGrhCMMiTNDKmizeFUURXcyU6faaSfl5JxjS1KWFaXk48d3w3wAAQxjzxijCCAcRSL2h+dpPgleXl9daBVgnEFgGM/DtJH64KAdR0UwLOiCEt5PJ2l0BDQCP07tMPTW2vWyccEPkzTGWCc3u1AWK5FaG06E4uvFAgHkfUgzDpGL0Wkzl0XT1EtKKefo9avPdtt2GHoAwKndIoSWy7V3wLlQQYIQ8N5zniRJcpyH79/9MgJf1WmWc61l33ezHJxHwKglXwYYZimdM2eTPeciQhAiVBQVxnh3eOn6U5IkZVGfZSnaTpxTgJhU7ayOlGJpVN+zoTfTJAOwPAEh4uAQwdxqY020RkGICWHBBe88xgmGxGoDgAMRYUhjTARbClYiBJQ5SWURbhJcci6KbMXJctW8NXamOJdqsFb74IxRiciV7ozV4OxaCyChaNGsHu6Hl819UWRpRpyLnBeU4s32iTE2Tajtd1IN2oxlqJM0RwifW/6/dcVFGEPvQgRA6T1htkgLSllTN9vNYXd40Hqq6ixJaYyLVCwZSxA+TXM76f7u9rO2PXrvEQpJQtv2eI7bxIRUVdW2Xd/JMzUHI3p9ffvJ66+Pp+ft/uM0DSE6zhLGGEa0yJcQ4vP/C2KIEBZMoFRcv/1qnufT6XT/8f1yVUMUCOaCV4tyraTPsizGeDqdnCavb74OIfgIQpwwBGlRgogRAVlWGiOHYeQ8ub15k2d1WTbzrACA+92xyC4eHp4Em7yP1hEAQJ41gpVNXSk1/+v/x18g6i8uP3XOVWUj1Zbi6IGaJgOgV0pRkjGSgoCiFxCANBUhAO/w1eUnecGNhmcH2HmQU68wpoInWvt2r7zD69XVq7vP+k6iOBJYZcILIQhBekrao/7m1+9K8DsvZjVBOWiMPcVw7jWJZZEsGCPSqPY0Z80CRM4obRo4TN4YdWx3q9VK8BQ45B2glBZFcTy0xHvfNOu+77M0jzG+fv16mialVATBKkuoKC6rsiyn6Vkb+fHDh1m533z33TB2x+PROae1dSGmWbE/vGN80dRXIBKCsyyn3nvrVJ5WfTfNk+UJwARKNSIc+2H4cSXjOOuEd/24WCzyrHaWEpxOU08pQhgwkQAAvItyDgh7pc04aUpShEAIQMqZZ0UIoe9mJb13StBQZncxQgh2wRMQguDZmX+LEMGYWgerppmG1joJoUtSEkDgmFAyz37WCiYcBT8ZPWDiALRa26ZeYiRSUQghfv7zP0c4WKeuVj8lBBMKOcCzbJVS1prjw3Ndreu6ttbX9eLx4cXo7eXVYuhbxqgPWut5GOa6rvtOLupXTbP6+c9/rqQ3zpRVNk3DenXX9YcYoJRaCHI6dkbH5fLyeDy+bD6sL8pMVLvNQwgOBAujXVR18JO3LERNGScUGKuttTG4b7/7FcY4KUTwse/7thucBa9f3SKGECXOyVP3kCZlvWAhht1hSgXzQR/bUfDkT/7kT6bRcZZjjM/blOMcY+y8JdAwUWZ5YxzQ2gajUfB1lWdZooOBEOIIfUQGBAsj4hRwwhKR17mJmmYJzhgRPBKCz46ZAKIYf8s2gAieiRU/mGigGCGCZzckAEAMEKAfwti8VkHrcrkAABhnsBDK6pRS/wPHAxD8g/dGjP9FCAEB/Le6LPH/J7gBQACAAnyGLxZ5CCJPOQJJfqz27YfT0G6OL1W95LwoxVUhroNfABSNlZCGoqJa2XkCqchdHCHEAGASzzQCp6STszGzLIoszRmEJAR/tt30zlOMrfMORogJr2uapJKnquvm/cffn979P/zJD+RrM49j74MFIGottdbWaWOMNCEC4IPvu67XI6vS15+9/ezrLx+7LSBUZIRhElxgTEQPU16QRUoIklJOk0QIpUV+tvqoy/Vh32ntinx52He7/XNe0HHurT/GQOZpS2g0dvTepiLPs9rOFJPgvc6ybOinjx8/tm27Xq+VhVqPZZlf31zstu3h4XD/+C1LAidFmmRVXXp3brnFp8dnLsirmzuKSx1sU5Xa9hG4We20mUdlqmwFIWRULBbrbhjb03B1u2IMPD09UYopI87PUpl5nqdpEgkry9LFk7JHZU7zPBf9DUHlOfQVoqiVmicFAWnqNWPc2nmz2WkJGEt80EnKnddtt3VeN/XF/vA8z0oIgTE8Ho+YMMrDYrGMMT493c+zIhRwQbQZSrH0wQxDp6xhjGACAYDOGU4XiSjKvBrGbhyU4Oli0Vgfh64TIs1zQaif5qNxE2UxRD2Mo5r9NIC8EMqO2+2mLJqL1ZuuV3meNs2ya3unXZYy71mIAoQMwmi8sdYihMIkQMS5uGyP7TjqftxgjFwIUnpvXZE2MBbHg+z7ExPRGGe15AITgQBy0RuEgnWaUp5kuVLzh4/vgjfaTJd5aa1pD20iiiThEeg0yyHyhIDFsvbeJSkN0Q3dyBlkjBHMhn66vLhjTOy2j6fTYTZTUSQhxsfHF0YTkWBMMeFAiBRj7H0LcHsa//o0PFs/XK2virwZhonT6JwCMBRl5myAELuInl72IYS6TtI8nyZ96ruiyBDItAJauTNHG0ELIQYAzZNGkCDkyjJ3FgGIh2Euy7JrjdY2BPj1118aKw8H13eqzMFmPkBP14vLNMmd/X4e/e3tG0r5t9+9k3KAOFRVNk/GWJemTGsTAiiLOhEZJcl+1x72bVnVEBvO+V/8xV8kyWGxLPfH6XgYs2RFEIaRUAKLoqacICBAMOPsE1EgNGmllbF5nl+sb+p6ETzcbA4gIOskYwgCCCGCgGgJU34ZgS6rwlrdtu35JuidDx5frb4mOBlbimL+yas/yNJSSp0kycVlheJfKt0jgKr6d4WBqrwSq+bUPQDg6uoyFWsppzONn9GyKldDL713eZnOCk9yAnAZAkhToaY5zRII3W7/qJUl5bLy1hGOGKeJyPt2GMaj0gPGuMwXhKbGuKeHA4BY8PR06iJ2bT8hBK5vGgBrY4xSR0JMWbwSvHh5ei6L1eubL1+e30vVQhScmia5TzNv7OgcRJATmNLfM2nv2vurP/hP5ARcNKfjfhzHMr/+7PXfrarm8en7CGeMgY1OhntvYJ5XKUwhTtYXF8fjoeufk5h4jed5IoRIOc2SN3W22x1tmESGncFT5xeLy0WzOnY7loAMNxeX6+9n3XX91VVNcAwsQhhBYCAGbd2kR+M1wGC9ulPSBP+0yC/2W2UDzgRqqsIYR0CqNbm5eaUkV/JEWBQp81OX5MX16m1WlKdju2xeZclie3zZn1plAaSj4GWWX2KorLUvL98RIjFqx/kJEsETLPcyS8vFsvqrv/zFYrFwAUntEcKHw/bycp1mCBMQQnh+vl8sFtbGLF2W+dXL5j6CJBEAwma5aLTW3ivrxnGcKRFccGVHF52UgxBiuc7bdosRIRFjWgQPT6ees4yQ8ubijwH02kwptXV1KYSYp6e2OxTZCkKCsIeCMYiBDA4yH1PjBHbMD5PX892rq6TgFgFAhI0IIhDNHEEUmHsDAmJGQF8TgQUASiduIj3i2BPvogCR+8ARYgCEs042BoDBOVQdRggttlHrmqfRBxM1K1gI2owzIjJbiTj3LiLKGucdisg5hAgwRsO/BS0gAAQgAH901wBntQkA/1+2VAAAFJz5JQECmAAcgnMOA9iURWjH/mn7QHmesgWI3FgUEhqRBgAgRGCARkGEEBLRwgkh/oPD2NnoFBMICARAGul6rR3KU0IZhgDE4AgOEWGGIfbAWwMwppyhyzWpy8uf/p9+nNvun/6p9Voj55DzMo7juekZh6Hz3hPCrPHR6Qjhy2HnMbj57O3brz+x2D8cPkZHE8KNMRRzmrA0E+N0ejr+BmgGITI6EMI++/xL7+O3336T5/msDkmSaTON2xelO6VnBxdFXgU9Hbv3WXIxz8o7WhU3VXH5+u5rGMvn7S+P3QsMwnjUDyZicxi/EeROCGFtfN5sfLCEK0THeZ7r24yRJPrEOyVV6zy+uX6rJXWWjFaHEPaHPYDaheAMTfkFBD3wWMppFPvp5enQPWgzzwNgy1pKiWORFYXWitDs8mIlePqyeUJA5GnZtwp6lPKyKlOEnfdqs3lZ1NcBMZzUebLcvXSJyAktD/sbkRxVAAEAAElEQVQtF5BTYuwAAErFcp4kAaE7HrKysG4clKnKJaOAMpLCNYJku7+Xqk8zgRA4nHaMIZi+lkYehw1jJCG1Vi5Ep43K0jRENExj2+8hVvWirutyHsPMnyDBIcaum62NMaCqWk7TFO1iffPqYgGVnqBkWsMQoTRjIlhVLKbBYZTyygFo5BDybE2JaPuXCOcIvZS0yrKiFABpaxvClBDKautUzsXV1aslwn7SHSQdJN1Z3YM5B0hwnmKM50nd3V5++PCBMeyN3mw+ZLmo8yUjxcvTCSEGQkJw4o2v8maWp3nsYYAEiKIsL9ZXL7vnHswWQIqolFIbOSmqLdufNk15wZMKYdN12whM12/zbIlAlrLa+b11GMIIoHvefG+8JNxb33bdBKMt8xtCcD/sAQSYkuABJxp6Yg2gCP3yV/8cQpiwVX8E/+b4f8mynAnqQ1Ivin7Yt+3pOGCrDWflevna6TSEAJEXHOwP79ZL7324vFgTwpSaOUunuR/meyWjMSZrSR2XXOCxnbUcvNXGv5y6p+WqnuaeC46Ij/E0jg8IEYy40bGuxKm9B0hjXDXV681md3f7xjoFQ7msr5x6ij4pxN3N5d+DWP7lL/6xjy2CgDEghIAw7YaW4OghHHp1dXVT5Kvj8ai1DGgETjiT50nq4DTLU5YuIMwRSDhZZAnoOz2NEwQEY/GHf/Anw3wyOhJcRC/evPo65ewX3/zL7cOv+qmJwC6Xl2VZmvZ3jj4geAzzMnsdUksoPJzeI0Sw44jwPE822w+zbAnF2nFrY0JvFssvTu3+pe+Cn7t+XxQlDElZrsnz82Pbtk21ENwXhDRNM809ANj7EEAcx/5c7cA4eu8nNVVVtX51Mctpv9/e3d113cl7Hz0rq0JJ33X9anmTpqlW1vuYcr5aN+hoTidX5E2Wll3XhYiS3wtv08ZQZ29evXl8+vD4eH95eQthjMBYNys9KN07ZwGAwVMQoTXg9atPQgDtqcWYcJ5imJRF09R4f9hwTimFUvUh6nHqMIlyGiGkCAEAkOBljF5L+PHDM4g4SytKeSJICIFQDINHhHLOIUDDML198xXBqVVtmoJuUIRjytAkpbawWVwcDyep+jRljBNKMQAuz6rgQcVYmhenY2uc7brjIDttxlO3wyS+Xf0PKSWLJrt//LbtNpThb7/9Ngby6tPXIdq+O82TLgv+7vuPRVEihNKUT/MQY7Q2zJOBkGRpYa25vLi7vLx8fn5eLtdSSkqTEAGA9Msv/97hsM8a4r19eXny3jd1ut8fmaAYsdOwPzdB5CQB8BcXF84ZjLFSar2+kLOnGddGCp4RZpR0Wg/TNFDKMYFt2yOiItRV1UQLt9td0UBOk+40WmOSPBVZgggBACCEAIQxAoCxswaAc08kBAKQINBTDyKIAUZAAPRnyqiPAQQAAgAoxugBABECCEMEBMAYg9VxladydJQhliaj7jkKAIY8ImBMd2pJklEMrdUxYoLoPM/nGPfz7rL2f/l7rt//0caPHNLzNUJouWwmvTb+0gGJUcpoIVgeQjizWCH8AeqEeJbIhLOdOvjbulwIIWWJsaptO6lIliVZwggmAMQQztI1hDGLMVprIYRZ9n/48Wc//JP/gQ2WEOKdnIa9nGfO6Sz1PCsIsbVqHEeMcUD+2Hf5svjyD79e3l0Gih43L9Y6nhiplbHKxgTrNISlNYmZQJroGGNZpSHCh8cPxhhjpVSgyZf7/X4YhsWiLMsazxAhNM3DrJWcEYxznhVcEEp5cEGq0Wr18vK02b3c3d1dXb4KHm933ipYXC0o4c7Frhtj9ElK8rSRGFOUYUgACJRS520AYFHnvoDDtPceyNkiBPJC1MU1RgxCWFXLp6cnpWYy4WmaQBTrZRN8eHp6idEzRheL1TjM8zxDgMepjXGwzh0OvXFzUy8BDCEGGLEc47K508rFCMqy+PTTN/v9fp5nY8Dl5aXS4zQNGPNzAjvj1BoQQ0AYXlxcTKP2Hnofx3H2sXURI+yXy/W5J5uwmGYi4tm6ibCIKUAEUY7n2SHMMKhf3b4Zhk5Jn6xzhG3XSiWt0R5BQCBardbWAARpVTVy1svm9XLVPD19fNl+YNxfrq+U1AQUTb0+O8Zxlp26J6lGSlKcp3IkRjLjR8FIvaoYTbWWUo3Oh6DtV19+KWez24xcAG3b43ZX1WIelXeTM9JbjFFCWLZsFtvdiVKulMvzmlLcd/syvyyrjOPc2D74vqorIcQ8jUrNlIRx0AkvMMbBR6/jhw+PTND16kqrGF1QWloLjsdjCAYTWDUk5TePT9/GAJMkM8ZMUaaJIJjZwKSaYrRSeUp58JBgSinFAF9ev+K0ppQ6rya9w8S145HC8u72Uzm7w3HrnGuasqmL/XbIs/ocAHQ87o+HAUB8uX6NMVazCR4Z7a8uq2mauv4wTROjHIBAKB6Gbp4VhJAxEiNMkgxCQxm6v3/3/v33r+4+mc14f//xpz/9AwCA1mcL3XCOW5tlF6Jdr25ijNMkX142V5d379+/R5AlSRbj9vbqJ8O0wxheXFzPg+tO8Xr900WV/c23v3zZ3PPErdaV0/Zw6JVSmMhpkonIhOC73XPXnQghGGPOi6lD1xc/+emXf/R//xf/dQBKCKHNWBVrIYRSk+Cpcw4jXharqmrGeWAMYgwA8sO0+8uf/+bUvazWxf3D9+v1pTHzx4/7YvidXRbAU9s/AoAYE0+Pz0rLPM+rqppmGaIbhoEyBiKaRmtt+Nkf/qSfpwgUZbBvdYjRWdCUdVFUZJ6nJBGYIsrw7ng4tn30oOvk3atbSlnf77SREEUbEOdJURQgEsFL50CWLjgrEwGVUs7GYeiCxa9e3yQpf/fu3aRknjHn3OPT9/Osgyer5tO6XiLwdGwf227/40KqerHZb5V2+/0ugJhl2dAPH+9/c7bkwhhBCOu6uSxfb7dbrby18XQ6te3x9eu7m5ub/aaDgJdFudu/cMEQjtvdw/HYL1YNIdCaiTESYzBGQYAAwELwJGFZzo+nDYJO62me5xD91XpFlE7TNICYZuXV5SdyAsXt6/vNO6VPECsjHcYMoZTzyrrTMBxfNo9JIqxNIArT2CZJynmy2b2EEAIAu9OztpJxCJAJMUBkxvnUDh8eH7+pFwmhuKAwTTNC4WZzOBwOr159cnvz9vHhWRuplNa6Wy6XCOH2NDsXIcQhRG30m7sbRPjtq08QQvtjy3jhPMnyleAVwdJbDxEsywVCIMsKrfU0mxjjsrn78vOfam0f7x+yLMuS4mnzDWfJ9fWlEOL+w/3nn/2krpf7/XYaZ2Ms41AkHEGMMRQikXqOESoTNttTKpZNtjaTJQAC77K6SrMMU+LPnE4AfAgI4AgBhNAB6BCACSN1jqgPzuIIUPDQOoKJj9YHDCAJMEAYA4TgTOsIAJ6rCAhAyKYZUEwCijHYM4F8VRbgOD998xtRVPnr19Yqbc5heBYAQCml+IeoNkyItZ7S35U2/qOgjTPUOKezwjOrk+GyrKW+HuYBxUywpeBFDNg5ByGG0COIzylxP+CP30KQM+D47WdAIIGYOGe899NsnHN5KjhHCOAQQwgBoXMwPcT4f/PjlE6P/9m4fZn7PVUSOEO8A8Arqay1FBEdgo/BoxBgeDluV9frn/7dnxUXi9PYEyiKfNn3g7OD935Wo+4OWbq4vLgTi4bu+3H+HgDkiUWIaK1CCFWdcs6ttWVZrlYLIVjbHRAkIYRhGCCGgidlWV5eXA1jq5Q6Hvbeh7paEUISvkAgMzpoZQVrXt1+mRXp8dhiQnKWOmcen94bOzWLpshXAADvPUNCKeSs9twqMzBKs6rWaSCEcU6XywY43HXDor5wNo7TCcRwsb6DgMxyGMYTp0m5zmOMSpqb68+klJvNd8q2AQxt32ZpvVw0MULvkTXx1J+uFq9ur9/uD9u2Pb7/8A0XMISzIS1kvBinME06Rh+CS7MkTUVnAgBBKUWJQIh4FxAm86RECrx1IGA9ewpBdJTTzBtn8WSdIoQ4F5TSCAqMeCYqjHGe5+M4WgOYIN4bqfrjcU8ZokQQnKZJse0772yR8UQkm+3h22+/DWBmDHMKvQvRYRxyZ9jV5ZWU8un5wzwZhBmnpeBVRqvovXEAEeO9xUkUgHat0W43TZpizFnGKQ5IzkrOppueHjnnaZpI7+U8iwQRrLWcjVHOhdOxv7t7vVw2atbGeBAET5dMR8e9906qUbuRJ8h7++b2C8bR4bAz0azX68fnLYjYSjdLWaQF59HY2RpflDkhpG1biZN5VggRIRgEHEIaPDIuIpo41yFsklRUxUVVoP1+23Wd4HkqzlJ3iDEOUVNi8zIyKGbZ3t1+VlTpu/ffzLO+uuTrC2a1AsEnSVoV9TRNScKTJDkcDlm25ixxziGEIIohuLJcSDk9Pb8nWPzxH/9JDOhXv/oG4+L66m6eR4TQdrvlAiFEtBkIgXVVMyYu1ms594u6isBbY6020YO6rARPCU4SwedJpUl1Th6NASNEgF8YdWjHd7ttCzwr8iUi/ue//pcv23fNIkHEWKuVmjnnScqdpUq6EF0EOkTvfEQogRA2xe2iYBCZ797/WYCtsWqcEKPsHDbSdT1CVPAUIeyc2263wzDd3d0opeax3x+BMicA9alVaYJBUPOk50ll4Xey2AB9O7RdK9+8/lwZwHhxdXOz3T1DQCilRVESQghh86QgUFrbvnsKPgiRYMwEzZyFzrnT6URWlxcUw3GYp3nuO1nmzeXlldS2rpbb3fPxtBUZJ5h5551zUsqySA6HIwDgYn17OnYQokTk4zg6P2HElqvqeNgfD+3l1Xqa291uF1FvdBC82LfbYZ6d09Lo2P8uFUY7M8lhmpUP9vr6ijIGsTz1O6XmZlHlWTkME0/Ear3YbrevXt1mGf94fyAUKD2c2kPG1845qSaEECbkbGPnnGvqtdI9YyxJuBCEcTTNTmtdFRnj6P7h+67dLVfFLAeEPYbw/f17rXVZ5pzy6+vrp8ftPKKffPXfE0cJoR/VSek5Ty6NgX2ni6Iqiurh8T2jKWME4RiRJZTuD8/jMN+9ujHW+uAohD5YRFgITodOCHF/P/3Rz/5Hx9MLRlGGoR80YbPSkxAiS0ujQ5aVUmoAA0S+7Y551nz5xU8uL2+fnh6cBZwnUtph7JyXWksh0iRJpilYg162Lz74eR5j9GmWxhimWWV5XVZ4vz9BQKZJMpoSwhaLxTAMSpq+G5Mk37z8BkC2WJbWmlkOlFJCqHXjOTAvVnmeL7uue/P6wsggRH13+wVw6falw4ESDHmakIRHBEOMGIAAYggBYowACiGGEByMlDGcZxA6ayYMQLAuKBURwCBGCCNBMGBAMAAxBBAAghEgHAlEMEKAgNSal1ybSY7HOiU8hnA47P71L7T3169fezm2xmX10lqtZl00K/tb+XiI/yBGANEP5uT/UQodv5d6H39EDBBC53QickYqEACBDcMLjFIfIsIYQgzB74JOIIQQAe/8DyAD/O4ziMAGQAjmSeK8U2rW2hgbs1TkGUQQnY1GYAQ/lnDOo766xoRsrTtuO6wtAcR5QwgOgA7TJLX0CDjgu74rry5fffXp5aevejVuu/b64vWrV6/uPzwSvo5AsX4zjm1RVJQBF1oXD2W1BABorRFCTdOEEACIkGAtAcJRaynlpI0RImcMaa0pExgKa+3hcJjmHgAAYTRWDtO+qpqry08YI223mWWHEGUs+fjxAUK8Wq2890KIqqopXVR1RgD1QYFgAOJ1ee2c64fHY7tdrW/PusoY45la7lxIRMZIFcMz53zRLCmuQ2QYcymlczJBNEl5cCDhdZlebDbvGEPQCAcURrQsqmE0giewpAHQ4NHLywZAzwUJ0R5PB86EMS7N+Ol0QAhfX911XXtqd1LKrjuUBU2SzPpw2J84z9KkCB4hZO9uPj+dDtMkjXbBY4xDktBZzs9PbZ6njGcABWcBiA4AaG2A8OFXvzlq7SK02pgI5whmgEaEau998Epbc14450nwIIAWM1ckJUTWqAHhCDmYp25UjiepMfMoTwFaQhhPWFlnVVpfXifv3oOX7QeRIDXP3nshuCBpU60JKhJeReBmOQnBLi8v1VSkaUoIijGhVFMunHPfvvuWcR4jtC4YO00zDSEwKppmmWfF7vgo1bA5ngB0dVEwns3jmHPQnvoznDpbny0Wi48fPxh37IYhSbK6KSnFSZIYHbTWDpxCNHmeeO+Ph+OiKlbNWs6+649FWQTgjFGbl93ru5/o3El9RJDP84wgt27Upg/eTMNc1aVW0zDOmx2dJpdn9TzPv/rlb6pyibG31s5ywohhxBNRCy44MwgSAEOIZrO998GFED777Kunp6dT99I0jbXae3hxcREj3Gx2AIAIrTIaQ9A0S4zxer0QvHzZ7kMwSSowxs7F4BFGiWAsRKeVD9SBCKXUD/fPGHPv4G534CyJgRIKjR0AXF5f3OW1ftj+UwDrTz65BKh82dwPw8AI51TM80wov75+Zd0UomUcE8w5y5pmSUmOEZ3HbjceGUOMpZQIRvO2PYQQlFLWac6JMWae9s7Cy+sbQsgwHgEML9sWIVRWYr1eeTc9PW4Fzz7/4hPsHn48YbwVENBXd9cAICFEliUP9y9pllxfX97f38cItbbex1O7a5o6ROm8mWfTnqaqapqm+vjxPWN9XS+IVWZQ8vLycpqUEOLNJ2/HYcrLKkI6SRkRQAgMwxAD4iIXSVZV1W63L8u6ruuuHZIkbRaVc0+TnBjFXXdq2y4vcpHgp5c9JI6RBEKFidnuvxc8YywNISya1e9W4g1lGaNsnr2LYRxHkRBChUjQJ598AgHe73+13W4en95DCPfHx+/edYyxNBUf779jjK0XxIf51HYRmGEYCEFFUSWiTkS+3b4oZRhjIVqlh+1ua61dLOp+PByPD8ZOp246nQ6Ukbqul6tmu922/SkE4B3Yb+Wb259eLtYvm814svv9Ps1EXS+cEfM8ZnlKBG77YTxtP/nk9eH4wgXeHo593wuej3NLCGGM9ZNSysYggo+CZK9evXl82I/jaK0d9az0XFWVlLJpmrJoTsfueJiKvMqz6tTuIaKnY9dUN5999sWH90/v3n0QCQIR7PfbZpHf33/IsrSu6+Ohp5QLIfphBwAghGJMz7wwCFEIcLP9SEkilXx4dOv1pfNynLphbNO0WK+zEMLptL+7e/Orb/68708R2LquCebGxqEfE1HV1aU1AcNcK2cMWF29Co4O7cgg66cxL0rICIDwdyGm4fzYH4EPEcTgvHcRQwQYDZZ6wAMi3kegLIgBYUAJRjBAGh2IMZ7VJQEAAAKICCIIAjB1xW3fOnniUaWAUqm/+/O/tIfx8z/5Y0hZN83ZcgkA6LphsVh5H7Pkf3veWtMkMcZCMO8jRr/rgPyHw47fHz8EpwWU53WajF0fE76iJPcOAgAhpgj8Tt8LYMQQxPADAPl35wMR9CFEF89m2CFQF+IwaOt8nueUQIKZdfpHQzMAgHP/eUBRNIvC+GGaTn0fjAfRCJFoayOMNGWnrlVhfv3Vm5svf+Kj27YnQHCEdBjlp2+rt5/kUu+NUQjyMrvhgrXtSaqWC4BRjhAK54Q4gANAzjngAqWi64/T1BVFUZa1c84YKYSghMeIp3Ee+pExluUpXyZyVs6ZSGOa5BB5AF1RMaPt0/P3hLGqyvKCvby8IITSNOGcGmMB1CFqhGIIYbG4SET+7r1yfuIstyYAQDDG3sNTuz8/YE2jRohYFaS0kXklJ8Lizc0NhHF/fFTSBKfeffdeiMQar5xktKyqtbNBK8hZSik32jHGULS7/eHicpmm4tNPPyWEYcQIsc5NWpnF4mK9WjPGMIHWzVJOIGLBM+SCnMeqTIqiOuxPGKMY4zwrZ0OWFUJk09T7CCGkZXazWNTWGmNn7w3CKMsyY6wHp2/f/arIF5cXtzGSfpDjPDMmMIbOa2eN2TwFjxNeMA68i8Zv15fXwSKlIIh0HI/WKgBDXiX7w30ERptOqoGyGhH7sv3w5/f/KE0aStK6vIxwhtgnnDpvhGgEWwqxRJB104kAjyCTs8SkCoDNyqX5JUvMrCee40jAfvuIMRU82x8eZ9kRipy309RrMypz5EmgDmDMEQZt24LoD8cXCD0mKGrgeeScWqcogzoG74wQzTkvECHovInR8ySmRbnbbayNb159VZevQEiuLisPDtvdt9a3N9dvAMx321Ybc3F1rWZojFGmC3EKcKAUx9AAV8Kom7qYJ+N9jMAbO2sjMS0QgMN4OJ5eFs3VsrlhND13QJyfT7s+BJNmAgCICRIiJfis9vS//vWvlXJXl7cIkXGYr6+vpemLvLbWcpYPvazLhHPx/PQAaeec2u1nBBlneZk3QiTH48GGyTkXQ8yyIkmKslj0fT8MHRMxQdLYgbPyT3/2P+Eke//8X233v35986dFWXf9wKhYNKIqlyGEjdsA6LxzRgdCIQBQa01JhjF8ev5wuX795tXXRsOf//znf//v/926Kf7xP/2Hs9pXVX1xuTgeD2km5nnWWjGe3N5e7/ZPSg+YwK4fUpEpBTABBHmMIcLQGGN/r6XiDLm8uCM07g/PVVV03fblef+Tn/x0GKZzntfpdAjRzvKEiDl1D1bzi/VdMKrKl0nC00wAaE/tC/EOQ0gY40rZpMryPN+8bCGCh8NhmibOKSEiBM9oxnkaY/Qx+BgIpae2ZyKhnBFKAYreIYKT9jQSwlywj8/3LugkZUM/hxgCUMoqnrBju5Ozv4HVjyvBmDiv8jw3BgMfZjuWZU4Z0joa7ULw3nvnTN1k1lprlfdGa18U2Xp9MU2TDwqAoPQcgumHo7X25vqTslxxQQEAaZoSwqxxk5kBtPUi+fD+NyGa1bqJIB2GrmmaGCNDnBIePOraKcsyKSXjCBP3b37x3262+0ltY4wQUEaTi+XtdvfS9Vviog+OCpYXqfX5y+ahPfXr9eWszMPz09XVlYtx7lVTX2RpPU0y5XeHnYQofPPtv1muE2kmxpJmkR8PXZ5n2ipEUIiwXjTe+5ft5uuvvnofPxz27fHYAgCaetkssqfnD59/fde2hxB80zQY44uLC2OclNIHHTxgjGVZBiIihHRddzid2rYvijiOc4xhszUJF9ZJ63TwiLPk+eWREEIp2myfnJdCkN3BlcUKQKoNuL6+aJrL3/zmXd1c9q0Uojx1I/aeOE4QhRDzLI+IegAgBOjs+/CDpZYLIfgYnA8BwIhQACxyEWH0CHtAkAvQRwQ1ZAxhB6ILAUUA/PkOHgGKAEQHA6oojF2nts/MqSYX7vHw9O277v3z13/6dwCjs7XFeqkDaNtTlleY8uH3imeUckKQ9xEheM5hAb8tUfxHRBvn34YRhQhkaVkWIBUVRon1FmPsvfcAoDOwgAEjgBBACApG/y3A8WPJxDjnQogQEkJjjN77EIBS3nuZpUwkhNP/3Y8TiPE/D947FyjlzcWlmsZh7Kajz1A/Ki2d9tCMepJhrq+Wn/70a0OIlCoYJAhNWGKMmeRIifjum79JkoTRlCcFw6y3E4Z5kaeng2aMZVkRYxxnFSPgPCOECJ46ZxEKTdNkaXM4HIZ+xCRMLmRZRikXIj97UCIE5Ky8t1INs+y9t1rrPM8tl6dTRwmVc2f0qOQkREopjSEggF10PjgMoVbDMB4IQT46keTWekooBNhaG6PHOCIUun6fCrJoVkrN1oD1otLqOPTdRVIdTkfvgHfh9uqS07pt2yRJ7CRurr9mjPV9DyE0xnhnYoQoIpFigDLGxTAMSZJZGwIGhAqlTwCQaRqMMQAAxggArK5rb513GESM4PmoDNpIzvmpu/dxFGkiBIzRIURASAmCN29vkyTb77fWWgAM5THNSRjcqRsBDAAGpXSWNnlK5slQ4tOMxhg9gSGELC0ET60bu244to/O2Dxbl8XyZObD8Zjm8OpqTTkxRvXDYZInzjkhaJrbaZQ69Kvyyig4zJP3x1P7kuf561efAwC7SQ7zNgRYFIUQ9W63jcB/8dUfjuPYdV29uLRObb/fMw+EoFzgaZo45xEY6yaAifN6fxit7ylDEUQQXFGUQoi+O3DBEgpDQN6eS2OIEDKNbYias5IJkWeLYegQ8pjEWZ7aU3fJ1hFgKXWeLm+u38o57o+bLE/OTclUNAgki9XV2FuIsv2uWyxuRJo+Pb/zoSfUCpHW5U13clVaLZb1L3/1V4SBYTqFaK9uKuc7HAuEAICeUsy5MMb0QwfOkCha63SSVEoZStnpdJByXl9cH/anJMkYx7vDlpKkKCofQwjh4uKqawepvFbhdOqOxy5Eo+cZIeSDxwRjjBHClHKE6NhPaZqCCM7kOUKIVEOICiI06ydjpyxZL+q7466fep6w6/3xXpn9qT0ghDASMQwY4zQtyrL4eP+9Nags62nqurYFkRltq6pQ8uTCqWqWWRHef/x1fsz3hy1APeMkM+k8zxH4EAKEgFA0jG3b7dNMGKOyPEmTfOyH33zz3c31Is9qwTOEiEjSH8+ZLE9wU7//8I2UE2VAm/mzL+7G6fDw6O7ubqa511Yyjt588kaq6XAYv/j0T66v3jw/bb1z3/3mu2E+JCmZ55E01dIY+Te/+KX3/ub69ceP76UaIYRFlouEpVlWN6ub6xRBrvQUgu+7KQYMADkde0qpBNqY/TTKi9VbgpmUWqSJUqPWhhBig18sVtYqxpHWVvAser1aZuCh+3ElglORUB80RBEAKASLMQAQrfWbzZ7RtGmaCPQ4jkmSEELqmmVpUZa1nA2Mg/eeEIQxNFYxjgPQ43QCAGz274fpWJeVnJVzwVqbFQljJAqMSUIwVtoET66vb53y4zgTnGTpIgKQZxXGjLMkzfB33/5iVkO9SKrm9TDMwyCzVFOKMaYRTD5oRsWxawliMIplU16sbp43W8GrjNcAgCzFRdEsmstE6Jv1V7/69c/X9adZkn7z7Z/f3F0X6fK4c0VVOWe6ruU89QGcyY9pml+s3s5jfNk8eRcvLy/7vru9fVU3hbXWB/vq1WtK2ek4rNdXIViEcMJrY4w1QCufJIxSOsvxeNqvV3fOG0p9WeYIkYQn86Q2L4eqKrSRZVmGDMzzPI5jkjAAgOBlkS+MMQgmSsbTqbNWixQlNE/yun3eL/KKEq4Hy5PMAUghiQFChCAE0QcAA4Qxemeisz6Y6AMEAVEPISACIgwBhAQjD4Cz0BtvphgRxAQQDBHEGEeIEAwIAgQCiB4epv37D4nVCYP60D1++Lj/8Pzq8hpnee98kiSzsS+7tiwWSZZvDsfXF//H87562f9PGUMAgHnWaSrA77ty/IchjL998QN7FCHiY0iSrKmJdySEQAg5d14ghBRDQhDBkBBMUED4Bwjy+4TWcyid955g4CP0ETvvfQgoQoxwhJk1qve6SH9H3bD2vwAxIoxB9B4AwmCzvmhPO2Wkn7iHIULQTZ0M0+Jmtbi62I4nDQKjtE5LCNDFovER7g/P7dCfTgfniosLDrFx3hFCGCq1DJRSIdg55JkxhhAOHiXih2Rma+04zjEwhCilidIdQQmIxDmVCBED0soxRtM03+2f8owBqCGCBAsELcYuL4SzlmAilXTOGoN+8EO0jnGsjfM+zlLJ+1+Ux3yauxCsSJsky52NzjttVJpxxoibAqGeILFavMqyDBMoEggQ2WyfCeV3t59abYUQEFjrey7oRXoHMTM+nJ0Wg/OEkCzLSUTWWQRFe5JGg+BckiQAxL7vnXOUQh9Mtz+di0/TNAEAUp4jmEAEEwGt8c4NMfoY/aHdIwS8VdIMcnYIMgihD1aMSKrEOg2gjnDWxu/249DLWY6c8xjdqd0jKPI8L8vKuOHUDQghiqgQIi8EJeTx5d3T08tq2Zzx9DAeD+2eCprmqXXIhXEYT/3QEsxWyytng3O2qrMsfdVUN/Ok2/Z5czhK1zZ8jXCepLn2z1K1zocc0BAShFDdlEoej4fd8dCngqZFygiWc2sNWC1vslQyKmIEUkoL3O3tbd/3XTeEGLtjFyJyLsIIk5Q7Mxnox06ultdFvtof+mnqeYYQBkJkwCHvYlFUmMR5GqfRcJZDiA+HrqkvVovb9+8/9N0sEvbwNGMm0zRPkzIVdQxov99nWRYDm6YpyzIIuLfEe4sRBBFZpdU0ffrZ26LIunEXY0zTgrMcQng6SJFmTDBMSdt3MVCEwGq9MMoWeZzlYE2UsybE7/YvjDMX0hh6jGieF0mSAwAggNbaokw3L/ssrSGgcgree4QDZUFaRDDNipxzrpXvxkM3HqZpEkJgjM7JCIfDDgLsvV4si91+o80LxkAw9s33/6xrj8Z2jHFE+ufNRmsteMYoQtCURV0UBYS4qS+0SfM01cphpBhjhOCXl5e6TH7z7l8FZ4uitm46tmSxEkLkCDFjLMZsHGRVlcWqppT303GUQ1UkRVEFj2IEi+XF5fV1kSd9N7mAtA0s/O7BbLWun5Ve1K+K9G6W46q+TgSZx6emqSCKCIG3n9wBAKSUY29hzKOF7759RxivqnK7g5QkWZpV5YqUxSJJ6W6/wRgmSXI67mOAWZHHGBljjLPggTFOKWXstFiW3pFEwLpagkiVUjGAfhogxKvFK8bYPKsIAyHE2KmdusurhZ6sMb4slozAGPDVZfLVV1+8e/6//bgS5xwC5LDfUZrlWUMIcd4InqYJdBYgGLI8n2ZNKackwZhOY88IioFZ4wRvrNufLfb6ocsLBgBQujfGSNNzztNUKOkJZpT4JOEvm/tX1183TbXdPYNIMRLBYEbTpqq1HTkvYoTTaIx11oxpmucFu3tzG2OcJzl28mqFtJy1VBSTl+OLEFld1wiSw/7U1FdpUiPI1w1ZrhbD0BGCOMt3272zkJLkX/35/znPy9vb2+eXab26a8olxvg0t3lovPeXV+uH+6ehN6fjtGgugwfBE8YSzpJzbMFut/v0s9fb7W4ch7u7m64/PT/tri5fQUARJBgHQlNrBgigNcGYYbms6roKwd5efxqjPxxfnNcYw64bGM1++pOfHdvnw+GQJIl38fb2NYT4cNxAwKtytVrcDsNwe6MhwM659UW9P77LcBKpLIqCcj5uewoSyhnCBCAcI4QRAQS99wBBBKGLUXvnfXDeBwjs2SgUY4QgQBARBq2D0TtrfYwBYURJTDgECCKA0FlH7mEMAPjtr9/Ztk1B5GX23Xfff/vNN3dXr6/Wr4/znFytcSJ2+0NVNU29ur9/qlbLH/dV09SjNN7oNE1D+K0M9odb+3+cIscPzl2/rUw45xgVRcFOx9l7xzn33kcAIIoQknNMF8IBoQjhmcQOzx8/TCZGAACnMMZzFD1wHlgLnAUhABcAo+nl+r/8/QnEGHXABIMIojE6YTzNRJKlEcIIyTDO7Xislulnn34SORmtDhhHYK33EAI1jiEAG/yoJaTk00//qO/2SssYe6u8d2C5XCOEpDyGQA+HXTdON9d3lLLd9pQk2dDPx+MJIpMkcZ5V8AhBgjH+/LOvnDMvL89ZlivptFZajxE4zikmwdgpeIoxiwE5O3POBcEQwmCdyBmIOGEJjr5IuYNKmQlBIIQbp11EHRfcG+Wc8sEgTBZFvd3qvh/P76aen96+/gkEwjngiY/ARGA4pz6AcZAwot188EETChEiXSe7eVMV5SjnPEk//fwTI3Xb9t5HkVYAoHmSdZUcj/umyZfLan/YtK2MMQrBnDPWes45QohSjqOoyioiKISWcjJGM8aMlRTn1s3GSEKRsoN3EaKYJHx7mjBinCfGz0q3ADpronMxTQWlOASLMTau6/pZ6mPXbwkrqioTlCmlvv/+W0ZTa+JqtaiKBWeJMabtDs0qu03XXddbB6wbQghNvfQOxkDyPBGCDWMbbI5ANgzHbtwleUzz5aJcCF51w9RPnXY7TuihBWV6sVovTu22H3YY87pmSvbWTNEqGDzFJAZSFkutrLUGAlqW5SdvPvsX/+pfGO0JIXc3n7x9++n9/f3L5mOaAKXHvneLeu1c8A6+uvvs17/+68Pj9ub1apiPq+YSgSBnFyNwjtTFmywptNvkaQMAcRZdXKzrWrX9y6ReoHEEJ85CZ6FWo7VWKTUMk9RPdb1IkowgZ1wIAUzDKURbVOW/+tf/6NQ+X1xdcp4wmjmNnQ2rVSlVO82ds4ERQomQqn953gLPAIxZWmMc0xTsdhvrtm/evCl403U9ANBaa6231hrtCCHHVu533d2tMFrFGA+HXQTmD3/2damqfjgAYLSRs5qdDQAAnhBGstPpmOfFZ59+ef9hL9U0TkOSlRgllEoIgVT9u+m/5tznxZLA5aT6aT6tViuCE2eA1urkD11/KvIlweI0neR8StL0+lpQisdpSFK2XK5PpxOGeXRZnont/l6antIbggmj6fVVff/wIUYEIZazXl43k2zHcawqGiPCiMcY0yTfvGwo5UWePT2+0Kfnr3571GCMnaF6Yl998ScY0/3x/th+RKAuK9r3nbEjgFZKZTS4uvwkTYpoQt+Py/WF924Ypsvr1fpiNfQj2e02mMC72zeE4O3uCYCQJInSuzS5QZAc932M3Wp5kSS0qVcIEQT9qd29en13lSy//+4DhHTRrDeb58fn+5vrNwjzWZ4wMRGY6/Xt5fL1g/ouEiylPDP6rZO/+MUvQi9/79QUWgkMxaK6/PTTL4d+fn5+9ABabSA0AKKum40DnKZ5ttTKcRalnA5HmySJlBJGNM+zsa4pX335xR/I2f7m278xcc7zdVmWGIsQJ2eDc5EonIlrH+ahTwRbcD5Z6xHInaYRGG2y4INxnQ9KKyulvr56vViugzeC88Nuev3my5/90d/78P7eBd8P46md/uCrrynCk9psNt/99Ou/f7V6O4zy1L4Uuug7WVXF8Xjo+vb1J2+fn3brZiV4+vy064ZufVET5rXSCCClxzzPKWGnU7taXVTl8uPHD5+8/QxTAHHMKzrI58PjLquyp833u8NznmVCiM3Ge4dWq1U/nPaHl7LKQwzWjUmSOW8ZI09PT1JNV1eXUk4RhDRN205N0xQ9/OlPPtluD12/R5CPg/7s06/SNB1nxnhCqHAWHo7bMw+fUki56bph6EIs9B27kWO0GhKSa2OalHtnnVcICYBwhBFiFADwIYQAYMROexQZIwQG76DFPAEkOhg0Yg6T6ECExkrvtUl0CKwUvENsViF3UZQ0ksPh8S/+Gr8MKcmJqH756/fb3cPN6ury5vJxPOCvP6uubn754bFYLETWfP/uY9nUF/n//rynOvW/ktZZZUQiKMXOeoj/7f7FDzzN/1DggX5AC8FwSmJEzjrOmXUwxogRYdgzRhgjFAMAA4YQooAAjPDfFs6c5+Z9BCDCsykYBhyDyCMAwFggtf/917v4D2LQMBgEEg5wwDg6jzlZXt58++7xpO2Hw9PdZ83qzZUGBBN6tbyOSD89vWCCHh7fI4owogjylBcQkiThXYfV7Akl/XSiFPczMtoznJofwj5YdzpFiNIs8bFX1hR1AhGNwAfgAoAAoaurt9FFo6blIoVAumCMVRBZTAInXI6Ts3HRXHhjr29urapfXl6Wi0qrwCIcphFhL6VEFAQS7ZA3RapNx2iSiIUxipKAMQSezZNeLZcQxWE8zXL46VdfHw/dqd1r2zoPtZZSGUzO7wrFMELgAfQiocYQyrBSijFS5I3W9tO7LwlBu92REBQRLKpl0ywe7w8/+8nfccH2/b+EAG33neCr2+vPH55/ofzczb1R9Prq1hiTF3TzPOzbjnEYo8/LnKD6dDpBQKsVvv84WIOdQaloGGPGuOChM44I6O3sraJIqFkygjgPKVm/ufuDl5eHSclF8ebx+ZuX3YdPP/1cWVRkK6eNUTbPamOM8yZJBERoGGVRNJeXpVSdlLM0yjod/ZznRV0tjXHORuec9xRB7kJ76i2mxnmDIOOcdsNYlvKTN3f224PvpTMRI6yMHjYHbbs8qxEyyo0e9qdtSwirysYY1/cnkbAYfVEV1sbN7vEf/pM9giQiOCtzcZVYJ62buGBZ3uT53TQcCIHzbFLBISA+zlmKclYDx9xcLJcXgqjHh8Mf/cH/eL1e/5N/9n8NKAtxopgAAIPjRbZoTyOMTrZjs8iW9RpE+t3DB4RwnjU3128IqY/towtdP7TT1BXl9aE9aaN4WZ7alosyT5bBRyMNRYQQjDzksBDloqoqrbUyM8I+Ruji8PmnX788H9p2vLi4EMKyaAAQRuG6upymUcmQprnRA6UYk3g4dovFwlqDMBIUaWuN9vv9HDwdJ0VTY53WEh6O3cVVxTLk5EQIz9P1w/2Tdt3h+VtrEAQIQIsxrhfJhw/vvINFfmVdlP7BKLdeXS/KtVbh7ou333//vQfWBz9KediNy8VVs6ieX96LhEKArOKffb62SiBgCXXGztSJaQZZvrhYvxrH3gcFUMwyQSkNHrVt241HY6eiFF13LPKFVCZG1/YPMKSLZSXlljD/+adfAPDfnk+b+4+7/jVMkyYvkXPG2EGqLkSltScEjZNjTGSidmoWNL9av5om1faz81opVZUrivKUl3u1J4wl2ozWjV2/Z4wIkXsPGS0JFhiTvm+vrtcIu34YrYlFUTMO84J/85tfYERDQHmer9dLbWaMIOVBSTXLfhiP06Sb+kZJizE8HrtzauvhcMrzgrOsqn7H4eCs/PrLP5gm7WwUvNjO3Wp1JRi1jx/6vs2LZLWsNruDYARByhhDiEk5MMoQxJQkq2W1278kSdI0SwDQ6XQihBbp8ubqZ5vN5mH39Pbt6zTjHz5+h7AlzMJYUZJgxB+femsSsigAJHme2+NHhJmbUYwsSdiiuYwxTtOUpmScegiB1vLDh+8OxwPCkXK/XCYvL091vg6BXl18lqVN3eQfH75Revx4/90XX3zV9/049n/8xz9DhDjnrm+W33/3PsZo3exna3t1eXFDcIjIQYinaaKULxaLsmh2u/3pdHr3/psI7DT3/XBIUyEEneZ+sazVZA+HU1mWSZLsD9uuaynDzpmX7TNGVAiBEIoReh8p4ZQIObuub2P0QvDggXH248fHzcuOizRLqxCg93a73SijnAuUCKPdMOysVcaqLEsAQEqpPM/LKicUMQbN7EOIACApJYIECwEACD/UEOD52rkQo4/AgzM5EmAAAoQBRBgxiJh4giELwQYJnDJ2nmbCPiAukKIQ0mWF5OH4mz/7efvrzWeBJV82v9g8fvv+b76si5vF+qQm8eauubh8//CQltViuX5+3FDBF8v6x02llALBZWlCEdbackbPXNT/P/FGwQ9OGwgAEIGPMUIQIUQYI0oixgj+QFmNEQYIEPi9Bs+/06P5t6/Pg3GQ/pYMCwB42f3PpHSCcUKssxpjGmJAMIKIeJJgRk+T/ewP/s7bz5cOKW1sRFA6JVVvrWasNJYiJDjL00xsNs+E4Pv7OU3Tm+vb+4fvOKdSyhDQ9dVdsMA5Q2OklFOezLM8uxT7eBjGYKwCkaSJiBgtqwUm4bTfAmic0xBCyvNmUVkrndfRokQIgKizMEub86NqXa2junt9+SoEsN192J2+GYa9NEPVVJ+9eXs8dEYXdzfrj/ffJAlHUEBwmTXcGuh9GKaRMUZZ1vWHvCjy/C2IuOs6ABwXKMaIMZWzztJK8IQyKNVo7BwiEoIvl5fvP7yDgIhkCUC0brYOWOO994fjk7NwVhe7w76qBWXow28+/NHf+fuCp+WcT3KCgH729tOL9eXT8+P9/b11Mk3y4HMIE2fxKPuu36Y5Pu3LhC+v1k2McZz6LMtigCEgALUPmhAo1WSMSesFpfhl81Q32fXV6wDQ6XSoqyWAbwhX3iHG4SxbjrOyrCCEggPBnVZBcEwpJoQkSbLbPbfdrlzk4zhiFAAAp/YwTyrLCgiw1jOljFEOQLROeu8ZZ5Qy79zHh785HPaYgPXq2nufZSWI6GUjGSlBJEa7LCumaSAEn8s5wSNG8ZmLoZQ5nU6MJRfrGym1lA5lZLc73d8/WqsxxkVGX736ZBpvvn//y/V6ZVz7V7/8DcZkUX9aVW+M+2DMuD0ch7H1nmwOf/3ug5/nMSuZhzbP8zwrQwjTKK+v77qeocgoSZv6YvOy4yxdLBZpmpZl2bZKaxmhraqqKDIEOaMwTRaL8rLNJ2vdNPgkSdIk0UaF4EBkZVGMcjLGWOuGYUxEhjHlUHTtHDxsmiZN08VizRiNEWgVrfExxouLCwDgNE15ngEQtK4JFmVZTaOEAIKIPvvsi+Vy/e2330zTnEQSERUJquuUUxEdR0gnCZVqJBSM826Up+XiyvkDpznC+Fe/+lWWFp9+/vk8a6WmEHFZ5Jxnm/1hUa7btp3UdH190Q/t+w+/aeoLH2elESbh1L4QQup68fFdG1zy+ubzxSLd7V8QElUejBv2u6NIWAhOSXP2xsTYLJeL/emJczr0EwCQUUewIFRwnmT8auyPx1NX143ufseH82HCVDdL/Od/9Q9jBJQh447GdUZdIyxWi9tpHparBSXp/vDsvV0vvvjs05923UnO43p9uVhUhABCCHHOWauX6/TUT1LDEECWrBf17Wb7MMtutVoAEDbbJyW94CYEuDs+3N3dPD23AMRElJxTLhhCYJwP+6Oz1mJCq3KxbG7Wq9WHD+/aYQdgqJvyzPDI8xwAkOXFjytJeIVp0Tvb992HDx9ARJwly2XTdZ3WpszrLC1SPvvgIKTWWADwanUlVf/ysqvrmhDmHaCUYcT2u+Pz80YkBEFW5evnx916cSNYhkCsitoYmSQpQmi7e4yBfPrJT+Z5brsdgqQsS86QDxShynvPWeJcGIdBzuM8O2fDF198mWbNt7/5TiQ8AgWgRthzzC+Wr4JzIZjr9d3Tw3vGY1NnWtuuP4zjWNWZtTool6fp+w+/VkZhDMsq2e6ORZEBELigaVbvdruz5rBrh3lSRZEzxvbHR+dUmvEsS0J0IToIKMbYmOlc1J3nuaqq5aoKwSkltVa3t6s8y7tuAAAkSYYQmGdlTUiTzAcHYYSQvnnzCkGyhccsLRHCjBFC4ThO4zxhRL744idj7//iL/6sboqmaQ7HHWN20aystW3fRoswyLwnBDOOeQwQCfZv3Sbhb20qYIgogvC7byEYEYwAIuwgRiggKiwNmjjpAXA+NdJaXJc5xeTwvPnmz/7N4a8/ZjpbfP7prz4+/vL+13/3D396S+DDfiP+8PPL//RPNsd9Wi3SRfP9+/tMZFfXV+lvo9o27f88RMcpPcMLQoj3ASIEAADxt2LU3zp3wf/gEscPI6Kzg0iMEUMPMKYUEYYIBghFDMM5IeaHvwv//Tjjxy//XcCB0f/6x+tu/F/Ms9Gzx5EkKTbeUooRAiFG5z1hFBFcXl6sb5pikVkwIimlmkIM2ri6XqwvXpf51fPTcblcT/MRwi2ADkRGGX58fjieDkXJCSFpkvXdXJelcwYAQClO09RaZ609nU7W95xHY1zC89d3bz58+NC1B0IdRJwyCBG01hsrgTExRsY5xKBrByqA8+pwHI8nmPLUWntV/uxy/SmIYJ7H3QkwhhxAaZoBqJ2X2kzGlCGERbUkOLEaeWcWzdL72A2nPM9nab33dV1myfr5eUcphQhCZJXSPrCqXL5988WHj98dT6cQJSbg1A4AIOsMpRAA+N33v56m6dWr2xjjfr+9vX21Wt0dj+2H+191XeuiPrY0K9KhfzmarbMKBlDldZE3u91hGLoQ3GJRI8ggRM567y2lKM14CCqGkIgsTXMppXewLFbOuZfnTQSGEIIgjT4UWb1sFtrIh/uDVoDQnNHEGHc8tta7LKlDQBENcnaEZ4KXMUaEEEU+BEAQ3h93CDFjDIT4s8++JASqaQYQIciUmREOmERGiTWRMRZDbLv9NLeMsSwtAQgeTIfT4+nUXV7ceJcYY9I0WquUdMvFBaFwf3j5bdXNK2UFn/Os6rruTDyUanI2XF7cVHXhnGN0URTV6XSCAN3c3AiRGu37bm7bgZE6S1eb7XsA3Ns3fziPfvNyGOfJx7GqhRApElyZ/cvu8Prui6KqD8dnqaSzbZ7iGOKr129jjCiSvht/+TffWOshxqdThzFVSm22L3nBCAMPDxvOeZo0VuOqWArSVNlNXS8wwG27JykRBdd6JjSf53mcxr7vKaVXlzeUJg/3z4QgGE2el0pPz8/PeZ5X5cXT42aex/8na//RY9u2pQdi08/lzbbhzolj7rnuvZc+k5lJV0ySgqgSqqFGAQUIUgkQIHXVUUMlFH+BGuqrJ7XUKAiQIMigBJaUZJLJdO96c1yccNsu76ZXI869772kAWhGLwKIvWLtWDHmt8f4zOnZqm6OwzAMvciz+Tj11poozCEkUZg5S6dpyLJZ2/Yej72QWZumaco9gIg6QkCQ7+N8dyzybAEAskYEfImhT3EwSe0HpO36uuqfXn58dnr51VffTJNK07humvUyzdI5RrTv+7at2+6wO2yeP3t2ur4cekOwt1o+GkfRtXWagL5TH3/4688ef/DqzRdCuOfPLimPvvr6L9M0uXh0OgzNm7ev+r6DEOXZnPtsjhb7/abvh+fPPoKATaPpOyGlfP4bzw5HprVmDDft3Y89J4oDOg83+3fjKNI0h9idPVpsdj2jkdYaAhT6tG46CGyc+MNUbvbvPJ8NQx9nnDFY91sAtAEjmURdlFsvmENAtDYs8Dnnx2Jv3BCELM/ndV0v5mlZlmISh+MNQNoPKKW470ZnSeDHVVX1fT+MrTYdgDqOZozMw9BHyFo3MkaDgColimOVJMnFxUVZ1MbIH+9EG1ceDm1XCdlWTZvGq7Lqo4h4Pl0uZ77Phr5hHE+TWa0WztLb27sfOrI1Rtze3vb96Hle24xKmSRJlss5RO5+93UYG2OMVG1Zjca405PnEMLX1z+fRJvHp/N5tj/clfW7IPD3lRWy01pjjBkNzs8fXV9fE+KzGe77CXkEONZ3U9MMmKAwokXVt7X8yW9/OkuffPZXf/b0yaOxVzfXGz8EFmqEkJaqaZokSaqq8Xj89MmLV2/+1PMZhE6I/vT0FLy3jbJG2cALZ7PZ/kCOx2MYBFEUDcNwerI4HHZ5mnGPbrf3VjvO8ND1WZZdXFzUdT1NA0QGQjiOg9LC93maJoxxIQRCBACEMe66TkqZJAkAVEnNKPJ4MI4iDGOP+8YYpSSENs3CNE+kcF07CAHOzs7iJOi6BiPqeyFCBEKLELLWOqudRQ45Y7RxzglCKUHQ/rWT+8dTEwPo3HsVCwQIOGA0dAhC5EFugHFAOm2NdABP/l5UWRo2Xfsv/tmfffNn36xp+jf+8Pf/b3/xJ28/+6v/0d/9WynQb2+uog8vnvzh735x926Zr7HHb+93fhBls8X9vvrx6tZajzHOuVZSWeNhYp37IaUFQQDBfywG6a/UA4IBCADKMIcEM0oIxPBHcAMQhAgh8J5E8qs//G8eukAIf4y9BQBY918BQBAAYjLTpBkjGFMAkAPGaOcg0lZynzx6fmpsVw8V89wox2ma0jThPDgeCz/oA08rJbUW0zQQSjGFwLJpmorigCkaxzHP5udnT/e7ZhgaAC0mQDu9P9xbCxAC/TAFEazr1hpEAr8sOqNREPrdsA9DaoDVTiurfcw8nxtjx3EcxmPVdRGIKNOjGCjlxCcQq0r8+e1xMILX/ZUjFSZjSP08XfT9JHXtUFN3ejabeTwex25f3DKaLhZLCB1CyPf9ujl4NDjs640afC+8uLh4+epLIZs8n0MUZOmMc2qtgdAGvocw7LouDEKjweFQn509np2fXl9ft22vjeAeymeRHGmezd9dvwpCgsnDeI8ciis1UmkGpcdHF08JYZv7e21kGPl5elbXtZCTdUJq7XHOWdR1KEpQ129VUVoDJjlNIlZajHIvJnv5+Gkcp/v93hpXVfU0TVGYCmWqqgIAhKGPEBDDOKqBYN8ZRJBPUAxdgCBUYpRSe55XVRXGcJbHQtrAjzmL2+6IMZ3N1sYoYxzn3DnHuR9HPqW8qTsIbRj6BPvT6ADA1jHO/fVqtZidVuU4Taosj0VRQMDXqws/YOM4FuV9nHLOvSjiBDNrAaWEUgqRA9BOcDoc9uM4xnHssYBSGkWRdYpSGoahNcPt7R1mxvNn221rHD05fYJxPMk9xEOaLIpqIihP/FQpjZGk7AiRJoQEQdB1dTN1EFAp3GbDmqZtu84PfKU0dFZraa3VJmpaDYBNs+hQXCOIs3SexHPoJme863fbRb5+fP787u5OipIz1E21kN1qNRuGpm5KhMDHH38ahPFXX748WT8KQ357ewugE6JXWijFq7J2Fo/j2DRN13WEYM65lBojGoZhXdcQoKpsrbVxnCKE7m7va9p2wzTLsvV6OU5dcdy3lUoCRz3GGHn2/JIx9k/+u/8XRDKfJcMwEMrKskKIfPLRb0DAX758PQwDgKAoCmOAczBN074flydLafthrOerFxSmN9fbMFhEQVruG2gWp6vHPuOYvGra45tr++rqm8UyU6CTqsVUT6Ntm0lKPQ4KOJxleZ7Px1E4w87Pnl29e9V148X5kjFxf9c/fvwkTfKivPf90IHpl4/pMMwV8K3tgiACAChlJjEQFDZtcXp66pzDGG53neeRYeqMURbcAOJj5ial627YH7aEEKMdGUXJOO66CVifUzKfr4FDd3dvtCtP10+OhybP1icnJ23zV8DTxo6ERpvNZhyFtcDzvDRNu75FCM1ms2EqrdPaCAT7cYJ1e1u394QQxri1oCxLjGnXdUKIafwFh0PKYRhLCzplS2Bh1VsM4P7grLWMoq7dK2sghJShu7ubNFlCCKSU1up8FmkttQZRFDkLx3FkjAUh00Y2RTeKA0KIcx+RxDqJEDVWAYfC0HdApnn28tV319dXUYoA1A5Iz/MIRcWxelCZjuNIqFNqenT+UZ7n3377fVHW52ePMHFBBNU1SONzn89ef/+Kc5rl0dXbuyReLpbp9eZrSgjGdLVYa2OybL5cnNVVH0dp25V1XYZRkCanfT+WZcmYhyDV2rRt13djmuQPrcRaC1zveV7XdeOIEWQQoSCIk3i+229ev3nJOY9iT4jROYoJFNJaa3e7Dec+YxxjWNcVIURrxT08ji0hLIpSjGlZ1nVdZ1mm9Xs3cQcMxqjpWiVh173NkrUD5sHJIwgCpcw0tZTw5WxJSdRWwliorZXKcBYDhK21P9puWmvsL1ljQQidswhg69yPmgwrNSaYegQT6oylnkVykqOqdf3B0yffvyq+/Pyrf/FP/+rJ+snf+od/9PnXP/9ie/M/+S/+c3x7c3t3Fz07//Qf/L3boY+iLJovtpuN0uB0tlLGfHj6v394nG72/yvP8wC0SinOmbNuUtrjxNkHUuZDRO0vjMn/Y5YF1hmEEKcUEYwxAAAgDCAE0P2AHODDdd+Dnn8VZ/yrhNZfRhvgPedEByG10EkxTSL0AzqKiRBiLEIU9VOPuXW0cXYUSvfT2Pe9M4CCPPVzkGGl5JurrzjnRd1a4AC0EDCEadc1WTaTaiirXZqgYZicc4TCpu/HsQ/DuOuG+WzBPSZVT0meJl7XjlJAhnEU5kq3EPBx7BljlHJjnLGKUowxKYs6jtNsvlBKcZ9NUhgtttt75ICf7j7/5i1BSRT6UQK7XkxCHvbF86c/G4bOGDP0wnmTMRYTyzgc+vL27jXB3sOjl8S5R4O+k74P1yfzLEv2h7jpJqVHxj0A3LfffzaMLfcQIdg5l6XzRxdPy7KxGX96+RNKeF1NAAptYd+L7fa2b7G1ChPjABxHNZ+d9p2wihg3QKAZoYvZglDsB8RYPk71drvvuqHvWz8g80VMCBFaY8S6obi9u+YeSeJcKnd79xYiF0R4Pp87oLuuM8ZwD0+iH6cxCHzOot3+Tptem5Exhikc6oESkCbLMMiSaK21ncYWew5APYnOOp3PksNhqxX0/ERJTTBbLtbGAIIpZwAhYIxW0oqpx0h6PrGAAcCgC5Bjjx5dtt1uf/SsnR7aXRiGlFkIAQTu7v7a933Oue8HwDkptbOYhVDKabHM2rZVSoWhTykuiqLrGwDXkvjjOFpnpqmr6l1Z7SkJCYWMc065lC1CYJoGBJog8AAy29sWIEpJkEarrhuMq+M47vqm7XuMgeczxgnAEiBdlFspJSZOmymKQ4R84JDv+3Xdaq2Wq9xa27XD5eVTZ/FhXyRJ7nt+W7UXFxdKqdvb+zzPk4y+fP0OY3U4bNIsOcMnw9Adj/u66bbb28ViYR2aRK/N2HYVYwQh2DRDlqyzLGvb9kHjyhi7vb0/Pz8/Hoo0i8uiNcZpZeaL2TAMSZIZ7XySIYTuNm+6pvdY+vj8U4pBUe4ghN98881qtVitVh999KGU03ffvQzDqK4r3w8eP3qy2d7d3984oDyPT0I44xVlUxxrCKFzuu9bP/SXq/l3X727vHy2Wlxu75vV8vwPf//vHortl1/9HGPUdRXzKMT2WO7Vd5YRfn5+Evinfd+VVcmoP5vnGGMpTN9NHzz/Sd93jOyqslmvJ0yckF3X17c3L8vjzsFhX2zOzI8TamCNk1JSih8SEjzPGx5sPKe+qMxqeaq1FWJcrU93+1rpCbP+WCngyDB0cRK2bR1HsyeXHxDnzMX5o7ruFcKMMYzYMLYQGeRQURQ+X6XJsjh2jAbatFJN1tC2brIsC4M0iecQmLo6IKg540IQDANGKHBCSl0Uh3HoKPMJ4XmWnp/jYRjfvXvn+374S9DJOqlMZ52gDDqn+6FaL5bjVDsHnTbDMMzmWTcMYnKUKAw9qw3BwFntrFZy4NznjAJHHhIfpmmcptEBk6Xrrut8P3TOWCcIMVfXX0OArSOLxfPF7HLozK//2m+X9b0xWivo+eT05LTrummUZVkEAcfEQaSnaToW+zBiYbIy2pyenVT1DkHys5/8DgSUB96zs9U4NV1Xh1GeJBk5cGvANMrLJ4/2+621uuuasmzCMASusxZ5PLy53jkHhkGghHger6pSa825xxgbx9EakOVZU4+LxaJpquPxOI4jQgRCHEfpYpGXZekc9jxurQmCQGlR1/Visej7Xso2SSAhkFCHiZZ66nqplQUAD8MQR5nVLgz9OA6nSVurHVDO6cNxt91v0mQ+n60Yx3UzWquiKEIISWkgwFpb4DCCBCMLMAIOYwwwIRhRCAFCCELofjgvfzlhxD1YiUKIMEQIQQgooAAh55y2FmLkhX7giLBDpw7/8nPw2Z9f/8t/8Se/95sf/61/+He+vvv+u/vv/rN/8PfLoX67e/1rv/HJJ3/4N766u8lOTpZJujsWAOLT9bJtOoB/kcGGCNbWIAAtAEg5QiAmRBkAzQMMejBNfy8J+Y9ZEDhrAQAQOYwQxghCYIyGzr2Pr/2VoDj7g8v5v1s584+t1Q9YjnNsgRqEIj5TDlBMAADD1B2q215uGCgpxZPohRwC37PKKCmSOI+z/HDYTqJGhCNApTScRZT6EDrGVnEcHw4bE7mun6JAGaMstkKIaZqCIKCUAgCMtYRRZ0kSR9NoojB59vTZ3d3dzatX2cxzUGkFKMWUcCXGqj5QEkZhaAEmyINEhX7cNQZhAACYRtluN3l6crKeO+eadrCGcs4RttvdPYbJ4/OnXX+8uv7G83EYJGKk1k1tVy0XJ4h6+93NbDajyJtdnN/cf73Z2qt3insoDP2qqjw/dUB1fWmMIYZZa41xUuiqqne7/Xx2YrSryiMAMAyjuhmMcQAAQOuhqVMv1YoA652tPy1xbY0T9h0AYBzHpi279hZTEoRkkvb69puPP/xNZ8/7vqeYGN1Zp5LMu72FGIaMEmsIo8wabPVECOp0XZfbWX7ueUyIoWtLxth8kRPMurbtx/0k2kkKTIzns8BLwyAj2OfcV7Lu+irNAu5FN7eFtdrzZhjj4tiHfhBE4c3tG2X6PD3JZ2nf91IKzvk4jkVRBAGVk5p6TYkf+FE+z05Wp9aIhqRl2wLbWut8P/F8cnp6aq2t6511qdZyHEdu2cn6YpomAO3hsBdyCMMwz+fW2sPhQCl/eDDapg3DEGHHPQoQ7voagSnPl1JwyGCS8rotJ6F8P3SWT4NbLS+CyBg71N3V8XgE0PleoDWAyPTDQCn1PA8Tl80iJeXYVBYYxhgaXZIkbdsMw8CYF8cJJqysDo8fPY9C/82bKyXNMNbWjZjKQ3GlFclnwbNnjydZGmMABJigruuox588OXn16tWxuCMUjlM9ThWhwPNo21mEAWOMYJykgdbk5surjz95bq3+5pvvX3zwyXq93u12gee9a65efPCJEKIqjr4fykkg6HlBYEy/328hxEl04nlRGFGLZF1qjKBRzmmyvSuNsbPk3DmXpsAaUFWVMZpx1A/CGOLxMPDmAFqCwTi2X3/z8ziOJykgJEFI6mZXVceyGD768Ne6cb8/vktSWjfhT376W5Syotz2fc2oTyknxCwWc8ahkG0Q0iiK6qrpuolgtrk/OGeePn3x7vrb719+GQQ+42gYmp4d8lloLL3b3jwENT9U1Wxu7jac8812k6a5sdwBNYoSYsc8c33z2llycXHWT/2+2K3WGQSgqYdZvk5iHkdRn+jz0w+eXv6MzPNHzrK62kAIOWdNU9d1oxX89Ce/8+b1uyiKlO6r+rBczt9dV31rz88jxgil2Do9jHW7a4/FllCnDHcWUepbQ6vqQCkNgoSz+OFTdNN0WZb7XnQs9gAA635xJ1oLrWkYJuvkAkJ4dfNWCMmphwGSDnhewFnY1MM0TT/97d9mJL29veuHxgEwiUkI4flc6YlgXxvZtKIoduOoAj9+/vxnSon7zTvrpFTGOMs9r6qqLHn8wdPf6LoJwAYRBKx3erJomqJqylFMykgDZDeWEOCharWWdTUsFrnSvdSSEF5W9quvv7i8vLy6/i70zp4/+ejtmy8x1YiaIIJVfT8OQmt9erbu+7YfGlkW43T1s5/+FoG+Mdbzgr5vx0E757Jsbozc7Tfj+EAuIW3bW6uDwK+r1lrXtjXGOAgCa+2Dh4+QPQKGU8wIAFZbLZUYlTJxEGOMtdYAgH6oh9FpIyjFbVdjRAnxCOYQukmMy/nS971xHIMgcM5N0zBNk7Hy9HSFMQZorOrDar2oqqIoD/PZ0vPCthmnUWkPYOQ494Wz1gCEsRBSUxx43Dln7UMq2ftD1DkHAHpYxGAMIYSEYIgRgJZiqqFTVgNoMXJewIWGoOneHdRn//Lz7768+/3f/73/2X/5n91dff/yzcu/+4/+iB+nf/Hllz/9vU+f/f7vbSfpL0/ifFG3VS9lFkRyFKHvix+4Irv6v0IESikZYxjjUUzUUsbwOEoG3IPfzgPScAAi6MC/ec7x70wshRZCiIDFEEAE3ke2QQiAgxDDX7JC/7e/+L9lvGHtfw0ggA5rrcHD+4nJZAScDMbQAnCsyt32Td2/kmaTh7FSwjlorSUEaAClHi1Ixm4SQiRJVjXlapUxiuezUwTp7eZmuVxncQYBYcwbpzbNs0CpN6+/Y9QPl7HneZy5uun9gCdJajS6326klLM5LJv9sdrOFhnEUilsIe5aAZENfQ6A1UpwFjnEpVCEMQSJVtY5mKcZcB0Dj5I4qetyGKY8Wzz7yaf7crfd3moF4jizrq+b/W5/O5slD35KaTKLwixNs5u7d13fEgojz0Zhalw7CqOkQ5hPYvB9zj1yON4GQcAYi8Kk6/q+74axurkdGCP9uP2Lv3oHAbt4dKa1QAit1+tpmg6HQ5JEWlsI0OPHLwIe7PURAKulUkYhhKweCTMQua7v9/stIXh9sgz91fX19f325TgWSRIkSRRHizAMCXV9P8xnp87CujlMU2uttRYT7CNIGHWeFyil6qpNs5gQ7PsUEgaAhRDGUeqx96e+VlPb1lV9cDBmjEk5RbG/299y7hdln6Xrk+XpsbiTrYFIKyXHcWybPk2RlBIAC6BVEsThKgyyaZq6vvzq6z+fpkkr6/OMMe55oOur/UEQAsMYB7EGRjKOcpJzzrM0L+x+nNooZhCQOMoggFqJMEh8LyKESCnCMPU8pvTknGGMCSGUFEoJj+XT2AKoGE58BoeutbYPvNzzCAS0a2tEJKE4DLIoim5u38xWSwuBHPTQS9+HAPR939fdIU1zz2dNU/d9r7WLwuz0ZNVWfZQjrQznYduMi/kJgPr27vXN3fZsffb9259jFAR++uZaCjnwwPcDJke5Xp0Ibfa7yuPxasXHsZum3ljVd2Pfc0o5o75SyuNe37dRFD1//nSaBinlarWMouDbb789PT09FvdCDoxDhOnV1d0Ju0AIRWFEKNKG9J1OEh9TOIoGs3AYVZzSYazvttfGqFFunXNRFBljhHCU8rarxqnu+jJJMow8CLyLiydVvcNICVlBpJerhZQo8OY+i7u+zmchwuDdzde7/ZUDpuvLKJj3fVs2NeHkdHaSp8vicBBd/803f8E5xVgzxqaxddbEYRAEiVTm7PREqq5pS4gF9xIxAqWM0gPGwTiI9eo8VL+IPEPIjEP/+NEnzgBKGSagH4Y8SyAGGFGlxsV8hSjZ3d5J1W12dczzeb5YLU8Oh11x3DtrnNVffPY5SeOLm9tXfd/ns9C44XBspXAeT5pKExx0fSVVxzkfp95odLJ6niRknNDhcLDGnZ6eY2KimI6iQZhaR41G2PMIYUmSJvHysGu7ae/7ftt269VZHKX90I7jYPQvUmGklMAhThOPzQM/3gfHze328tFT3ws97qIo0lpT0i4WUdf1Y98T7BldK6PEpBxww9BYQ6MQGaOFHCcxUspXq6VWtm1b56A1KI5mi8WqLGtnvQ8/fKa1ffnyZZoj7qEw8qdpqptD28rXr9+2XRPHwfn5Wd/3k+gppY8fnW6215OstVWMevvvbk5OT6wTx3rr8+zu/ubV2zfrZSalLKudgdMsO5/P54yTm9s3GDtthvliOYmWOE9MrqrbNI3jiM/n87ou9oe7MPIfHA/jOI3juOs654AxhjFWVSXnPAyD5WqGMT4eyr7vk8jr+x6hNM8jraUQQikThXE9tMaYxWLhB/Rw3DZtEYae52OjrZB9kIWnJ+fFsanrqijUbrd7cvni4ZNrludS18xHd3c3jLFl/nHXVcaY2SzDGEuhfT90dgQOGe0YpoMZjAaEeELbB99fCLRzDiCIEHmwG33YszwMOTBGCEOMMSTQWqitNgBB/GC5gSDCUouyKf9/f7y7vd39J//wt//H//nfuXr9+d3r7R/90T9knv7Tu7/82/+Dv/frn7y43x8qYZaPHh/7FgMbBAHGhAIshHi6/t89PEsPkIty5qxTSmHKpNajkIxQJaWj7sHx/WGd4YB7mMH8uwGLf1M5B6CDyEHnEIAIIgAAwg/SlfeMlh9mPw9XhL/6079IZvnXog3n/jdKTxhxhBCAFADgLNDKGiebrg8CDwB0fXP1+u3naT74kQnjvOuagOJhao/VgXPuc1L3lZg05x6ltG+PJZ7m82VdNdMkHXBlUYc8tYaMg07SbL/f933LWegH3FotJr1anxu7d84CR8axg9BZJ3b76+32viiKp88umq4tj+OHH37iNNofbp1zhOBpmLRyfgwJdUI2sqyNG8ZB+B7yfJzPHoUhvr6+klIAxyhJpmE7TdqBcizut4WoyibNgiiKrBuYryhZBEHctv2rV6+ShCk9QhRe37y2YCrKdjm/IIR0x2Y+n0s5OaCHXns8pNSTouXcWyxmTXuM00CqLs39cZBKD31fj9MAUSCEOlt/NIkuT1MlYV3XFGGIm2GsMcZd1xKGx8kAhIauo5ydnK7kyL/4/BtrvyHUDGKDsOV83jXG87xh6qUajZVB4Pf9INUAkJQCf/D80/PTF7vdVqiKMU8pgzF5CAQxxkDklBSTUNwjRg2MQ2NN2w1CjYSapi2tcQgRCN04DRC5LEuqqvqLv/yLfiosUIfjfdNWCPIHthDGmHHUttWzxz/L0rUU7uXha4B6AEUUZbaHGEZS9pQBbQSlNAy9ftw13X3oncdRDiQQQu33Rwd0VVWY2CxaEhwURfGQfVOUO0LI2fmJFoBSAoAdRiNkByGklHZdB4IaYU1w4PO11noY3sQJ1WoMo5VRXhIy7rvdbsfJPIk9iL7bbDaL+WlA8TRNnseb9iDVmM8SRtk0TQ+7YCMhgnQcFcGcUur74Tdff+8x/pOffvztd59J1TLP3WzfpMksDkMEVT9UAFrC6DhNHPNpktyP78o9QpB5FEI8iaHv2ySecRZZa7uu8zzvZJ1t7vd930vV180hy5Mkya+vr2ezxTiO/dAtl3nTVkoa5+zVuzc/+8nvYMyrent2di6lAsgCqIQVAfQn6YzUnp9MeMKIEEIopcPQA2CZx8eh4ZynXtQNxyydYRgvZpdnpwupujdvv+bcPv/g0jnEWaCVq4765OycEiNEQQgRchzGWog+DP1vvvt52/cXl3lR7Yaho4gGIa7Kvq9Gz/MIjbbbHefB+dkTj0fDNF7fvOr6ej7PgwgqZRhji9ljqKcwDIuiJow9mIg8lNEuTPP9rro4f04pq+sqDMP7zbswDiAkWTpHiGy3W89jZHAAKqnGi/PHUg7jVDHPQWwBGjBl5Ks3/wQ7ls+zaRBB4AU+jiNmHS7LgnEEITTGWUMJCvNsFYSekvV+2wyjXC7ny+X8u++/rZomjuM8vVACtY0k2Pd4HIVZ1wvGwxCZB5XUbn+PMez6MgzifvgFdMqz05HwuilevfncDzElfhTzfBEPDZACOmDFVFjQQTs/HLbOwThNqG/6ahRKej5V2mFsIR3quvZ4fH76oio7a+ju+B2EWKoeQgARmkRt7MgY4Sy7uvreoVIZtL3ZaiMJIWJSHk3CMOU8QZZ7MCd+iJau6W6/e/nzIAiApYEXWaejGFfNfduWCPq9uHn5+rPl7Dyd5ff3t01bBgFzQHEPV1WBEdXGEeIlcbjfX3t0nM9ndX0khIdhWJbF7e215zNrIATs7PSUc971lVS10IMDMgufb3fFxaOP9/tyHKcg8AkFlNt26Cnj8+XZ/lBYhwSYABMTFga60/NnRiAM4SReKd1F4SnFedm8nqZpGIa7+9dKj1JNjMTMR8oeh2lKkwXzfA/xze6qbsqPPn4yz+afffbZ2dnFOIpx6OJ0NptniJChnZyDw6QNpNSLAMCYW2UkRdxCgBCE7xkhAACAMTTGEAQgdBgA5CA0DgBHEWJM1pIyGlMt+NhiSq+36r/549tis/sf/oNf+5/+F3+0vXt3f3/78W9+Gvve9vbq93/3d88fXVy3U2XcfL2EThslrYM+IwhBDZ3+AbxeH//XDkGr3TQOzjlKqYXKGIMQcthRiAih75c/zjgIDCQOAPR+OoJ+yfITAOcsdOiHQLUHeOAAMMCRv65qeU9hgQACa6F1CCGEwMNKx8Efsc0vA4v3wbC/XP/qzOOvUTe0kZSEzgAlAOTAAt0Loy2dVMsYVcq8u/n5oO7PLlHTlf0wvtv8OcZUSbNeriHgRVUKoe8334fh6eV8vbnfz2dnhKCiOAAojJ4Q9PbD62Z4o7XD0HOODX0L7XiyepYvZnf3N86iw74eB0G5vt/dVm09n60gwdJKCEcSiKLddF1H8Wq/bX7t13/SjUU7lggBB/E4dJqIOMqnSXieF/gRIUQ7OfQa0WmaEilgGOeb45uvX/0JxDqOQ6EAQsRZTEkU+FEcp9bacRy7rsPEFOWW+4CxJAwyoR3iTgyg6lrMj1mc+2EqNRC60VpSHkvV7g/jsTgul0tK+eXjD9q2HhpweroOAzOMpbZ9EFIl7Tw/m2VPJlHPF9Ht3fVhu2NUMcaUlK1WLPCUEgQQJZ0UXuBncRwKJrrxjlDAyYKP58YOddskUbBeLoeRbza3jOL7zVvKcBSFGKc+A+NUv3zzZ6enJ7ZRm/s2SfKTxUXV32tlEYgpCFiginILFQgTwMA5ZqptWwRpFPFp6iAFvs8piSDwIMDAMj8IEQXtNHbDPonSwMvGwWg9tP1R6cloBB1HMJxEVzcHbStGuO/PpnGiDA7iyFmUJsu+73f7a4C6fqiHXuax19Qd54Hvc+tU140Q4CiYU0qPxbbrujhK1+u1NVApl0aP7puruj7ms4jRiNGAcy4GKYWGyBiNA+YTZBEBjKTOYkKtMyoKgySd7/dbhFwvbw6vGoAgZw4DgnDu6FTXd36IuRcrQSBAzioIgqeXl+Mo2rYlDFZD5Wkj5GCtJQy/fvt93R2M1WGUhR73eA5MwAOuTT+MjbW2Kuunzz7suvFud1wuZrN58tlnP1+v10ppYoOQc4f1KAbKbBR6fV1gYLIgb3uH0hkA8O7u/uz0cRTETdXO83MAkDXWWuX5jHEbRPju9q6q6vXyyXr5zIHp3c1XoyjG7mg1Pb34QMqJEi/LTtq2B85S4rSeEj+Buo2CBCGWf3DWj0LqMZujq9fbSQqM7Hp1Pg1YjODs7KTvm9kyJQzcba8RcVKOYRiHyUxpj2E6ii33xqGbhlaz1IsXsVICQG2MgIhU9VaoVqrh7t6enJyXx6EfmucfPNpsr5qq7jv55PFPrMJVZdtxK2HJCItnvxCTtt3BLeYQekrpxfx8Gu3t3WGWnWWzfBjLtt9FYB4FdF+UcRL63qlTSgrnnI4TP0nDplJiskHoCEQaOkII8TyklHLAGCu0NZyGq9VyGIaiKH0vdEAPUzlMpm6OQRBwL5/lK2sIdJ4cwerJmXNuGBuE8TT146C+2rw+Obl8dHFxu/kWY68oG+csYwQj2nXdief9eCfMgxBJOU7OIU4z34udM3XVi8GkyUIboaw2xjjYEsLu7raX/Fnft7vdLk4CKax18vR0JeRY1cXzZ6uH9e0wNoQhZx3Bnud549DX1dFZxHl4PB53+43nQ2NcWVaMUY0dhFDqsh9cHM2mAdzd3cVx6rFsPxTOME4T6CQjTKgpCDwwAAQnCteL/FkWP9FShaHvB+R4HCFCVVVhjC8uLr788sv9/vjixQtOEzlVzjRpdhFGnlJyHOHxeJzNFtbaKMhgCD3PH8ehKAqMed9PSbrcbo+L+XngLY+HK+f0k6dnWgnGWBwmi+Vsu7+7uX13dnZKEegnO/Qqz9ac86ZvD8fWWdy1EwAgy/19KRnz4miupB17gQk3xiyWWd+1wygQ5E07RFHUt9ajc4YXu+2GM2aMcc4FQQCMrY6VktoYi5EjhEJDjTHGmIdkBPRwwKL3dpnQuYf4NoQAdO4hJRUTCCF8EGYIQwICoCgBQB1OPv9++//4ky+2Zf2f/vf/5j/67/2ulMNue/vxRx+cn590VXH++CRNYqmUdjZNU4TQg590GEfGGGW0tfbT8/de5uPDA64f8gKgtebhQx4EEFr3QBqwEABrIYAAQOTAX1sD/cp04ZfRxl/75r+2/nUjivdX+A8u5/4xAEAp45zDDCmrR6kmYZWEhMBR7F/efj0Mu+UqIwROExHSVYVSaljOF0GQFEVR19t+qpLU5759++5rZ+GjR5fjOJV1RSl21q5XOeHu7v56vlzP59nQds6ZuqoI3m7225OTc+BQVd1gAsZxNBZ71KeIS2WstUEUUkSbpiGI/ezXPlHSFce+LhX3A+vGri/bru4nDACwlhmNAXQIISF7IUdYB11bPn3yoe+F3MPWCUItREBOkHkBIsj33gehCTEGQaCs64eOMXZ5eVlXg3N6Nk/KarQG+n5kDYKArZbLY7GTUjzkjAshINRBEDxQeJxz0zRBJCHSNzfvjJVhxIUQBEOl+9dvP3/27PJ+c/Xzz/5iNV8ISXf7mlKMqWWch1HAWVjX/WCnpj0YO4T+2uOpdVIISQlHzgzDNI4DIcRZCCFWSjxkNuV51nVdmsUQ0N1uRxBywEAIGSaUMo/lJCBFeUDIGiB9n3tegAxV1jjnOPO5R9u25jxkjEAIxaTDMA6CoDi2nudls7TtDhBpxoJRSOMcIlAq2HYTcCjLgknUbT9eX7+1ToMe4AYKMZ5fnCgJxqFxDj57/kjZw939dRQmCOi21hcXFwihu/t3SeprIz2fLRYzRlIAQNu2Uk3b7b0DIAiCL7/6LM+iPM+q6mCdyvMcOBxk+c31rYXCWL0/lgBYxhjARBnPKdi109XbOz8KtRYA6jAIrcGMBpOolTRRaKwDcCRSqCDgSnXDNAV+LFV7d/+m78Xy/Z94Oh5ckkTWTW17YJb5XkzpLE1TBCF0njWYMQakAY4NfTefnSAEjFXzeRpGfLO5Z4wx5jtrsoylaVh15dt3b54/f66VtnJ88uS5kdgCHWC22W21srPZojgUs9l8lp1HUfjm7bfz2bKs9kbDoXPlUZ2dn19dXfl+sFqnCIO6LiGELz74dL89+r7HaDCNlpIgz7OiOEg0HLZyubw4P31sDN5sdmnMDBg3u/J+9y2EJAzXzvmD2B2rvR9rj0d1UTedxBiWZZUmyyxdNm2FAJYSxtGpg5OUknGGMC3rahy7gM+T2CeEtPXB53me5/f3W483/TQyjwoltXVF2ZyfPX32/IM//7Mvp+ngObLZHc4uLjllP7agYZg453EcB4E/DB2ELk3jJPWrqiyrDaGIMeyA4Zw1w5BnnhfGdzfbLJt5gbfZ7BhJF/Os62sShenYWk7zeZpvt/dGjZRbjK2c+uKwM8ZRhAPPG/u6Krbj1DxwoLN06flZ2whGE4aa6tD7wSyOPAdE27aU8jCijLHd/rZta8YYZ77ns77vAIBt268s+aU7qUcfEeKtVxeL+QmEuCyPVdlmST6bp8fjHkA7StUVZZ4tlquZsarrujiOwyBknAAA2rYfhnY+WwZBcDwepqlnHMbxGkHWtj2CxPcSKVop3CxbrFbLzfa6H4pxUnGcQggRJFJq4Dw5BvtOce6vzrJx7PpxXCxWH69+er+5pWRyzoaeXx7LMFqeLFex/+zp4w822+vv777oh3J/uAPAEUL6XovJYMQ5C3/7tz7I0vl+fwyDxSi2V+9ehRGPo/z29o6zCCMPQRcEQd0cdodd2x3ixLf2waBXchaenTznND9ZXWI2Mg6bdmI0Xq1Ob++vy2p3frFqu+Kwa5aLMy0BQ/7YtVK3CEFKAp/PrXaH/QYCzFmwmJ86S5aLM6Ga65uXw9j240Sop63BiH744qdG45vbt3XhjoebIAiVkBjTh+RWoy3nPgQAOAwhxpgaDYCDhDwoMawFBjrwcMwDABAAGliEEHQOQgDRew6pBcY65wCjVgAtass/36r/yz/77v7Q//4f/s3/9O//zOpme3v7+PwkyfJxapiPKOEIE2EEIRQhPArpAPS9wFngLBBCPiRpPVTX9c45hCBC6CG9HUKIEaIUUwQJJgghZx+Qhn3wB4UWOATAg3blB8zhgPsVZPGAJOAvYZN/AygAADj0AzEVoIeX/fczGfvVZco/BgAABxACEFvp1CCUslhZV/eVmA6328/K9rs0xf3YMBoyxq5vDkqpIAgo5WVZPqyivRBPU9+0R2AshPDl658jRJaLkyhKrq9uhJAQQojMNDQ987p2ogQtl+tRyGlwKkcAWud06FOlkdbk6eMP97tikZ+enK66rjoc99B183zV943RxFkS+LmDA6XIW0Ljuq4VwCGMqDGWUgaQMcakaTr1JvDj05PzsiwBAJeXl8PQHY67WfYoTVNCcFkdx7GXQlkDtbZRlDinxsn13aiUYIwci01R7hBCvhfm2SIKMwSpkoBSWrc1dDqKEgjcbLbEGB+LfdvWWstJNNudGachz/PAZ21XQ6AANMN0/Muf3yIEuAcdEEr33IN93/p+qCZhtdCyH8VIGTMaAMN8L5Ntr6SGAPme1w+j0cCLvbZth2HQ2izmq1m+aJpmHFQUZpzCoigRgHVdr1arTz5aXb/b7Ha7OF1KMQAAFqu8rNQwWAiYEjj0ycXFk8PhIOWUZTNKcd/3YRi0dkAIK6X6oRVCTGoBIQq8nPNAytGBsW0bpbQQztjRD/qi+aZt+7bvEORFUeXZfLmaQ8CskVka9kP16vW3bVfGUbqYnyPQQBdQEgg5WGsgMkIMUqr9fm91xxjxPK9pms1mc3Z6ASFIM59zwj1sS22dLYsKQe/Fs0d9q3fVyzCMJ6WNAZR6mFKhpOd5o5Sz5VzpsWnrojxk+eKjF7/BSPr66rNRitkMzhdLAE1Rblpb9+NOjFKrPgzyXkvg8O3N277vT05OulZOopWmaPsC9t7F2fMwjKuq+OD5k64VZdl0Xef5lGB/lodPnz7/5vu/iqKoKA517TCGaZpS4q8uVrc3L/fF0Tp1dnaRpvm7t9dxlEVRVBx6CFHXj2Kcoigpj+XhcPjwww+lFN+/fPfo8Wp/vLm+/T6J8yAIfuM3P0EISHkHoGm72hgTBJG19uuvvz4//VAI4Xk+ox6E2BqMoP/xh59gID77+ZdisJ98/BsnJwQQdXV7szm+naY7hs4XFx+Gfng4bjCVXV+WxSAFmERzcjr/9NOfvnl9UxSNNfjFi483m13Xl37gE6TLsSzLmnEkxHC+/gRjvN3sEYiePrlcLOaHfSXkGCdcCLHb7QDAHk+GXrx8+RpCePn4w1dvv3RAjOL46s3h2Q9diLOgHtU8J33fUqp2+20YsWOxPxwOZ+f5KKZxarVWx3LvnAHGduMQRVkc5ZMslbSnqxVGvDjWBNhYTXL97JMPLj/9k/aPi+o6CCAPYG/6aTRxnHIWOEuUdMvl2rrk27dX80V4dvK0bURVTJjwJ5fPkjQweg7xsN2/1lo5AJIkdnBo+zIIQimnLMuC0BPiIdjCYTH9UqfGEBDPCxj1AQBd0yZRHEeBc+7u7gZA6yw57vuTk9OPP/rUGrA77AEgQcBevPiwqgoAiDYhZz5jbByUc2A+n1OGrTVFuWMsCIIAAJSlq76ThHjffPONEEIIEYTsyZPHNzd3vh8Ah5SwzngnJxeLZbbdvSsO+ydPngPHqmPTFP1ivfJ9Xysrx4CjoCiqPOKbze7zLz6HUKRZxmiQxwtCWJpkUk37fRGGcRRFr9+8dBYqZSilTdMwGiDIx0ElcXKyegQA2u/32tKqaepuB3ECAGDMp5RrB41xjIaU+hBLQpCzxGq+39er5TlCaBxbYPlqtX5QxldVwThEWDLmW5M8Ok2VGAxRWXJqDTZG1XXFGGm7Zuil7/sQUEL4Yr6yBh6PR0b486cf9n1PEfG9kFLOuT/0wmd8PltRyodR96PSEjuAIIIEY4qZtVZbgw0AADyMOh7OVwygAxa+z2jVzgHtrAPAWoD0AH3WaP+fvtz/t9/sDpb9xu/93t/83Y+V6bToMUJRGBPCpkkShh0w/TRijBHGWmtttOd5EOO26wAAwzD8rZ/8Hx8eon/x9X+pjQEAUM4pJoQQAhFGiGJEMCEQPYSpGGetBT94YzzIZB+cuNyvYI4ftTY/zige8AQE4FcxxI/cC/feJ/0BcPx12/L/ULTx8NZhaAAUBo4CjUKOoppkMY5b7k2+kQhBBwI5TpMYIISETdz3jJ2s0J7nYYwXyw9vb2+3x+1yNptEd31zlWXZLF8IITjzq7qHePJ4QCn1uUegL4Ro+xYj7/mzF1LASdTaTMdy6/HIi2IxjGoSnFKn3dAOcpw86lml312/ZjTyvcQPaD/Yuq4x0WEwS6MYQZ/7obWu7xvKIKcJhjzwAQT0/n7TNLU2E6H57e2953lCiP1+73m8KAtCCMY0CEIxKRjgu7tNnITWYGsQxtgBM45iuZxPkxRypNiPQh5F0TBtm3ZP0Xy1OmmbwRgTRZHneWXZR1FAmNLKPLl8Sinv+trjQdd1ZVl6npfneZrmTVMZowinFEJlnNMh9zlAYz8UwJgkWQGTXJx95JAsSmCM8z2KENIKYxQEfqyUklIjSBaLNUKwrrthGKMopgw6Z2bzDAIc+v6DEaJzDkLDODEduLs9GCt8L+Es1HJSSh0Ou6I8KKUIQavVKgiCum6EEEpNQeidX6zqqm2742w2m6apH4WD0yjrZqjns5PV6dnN7auyOTjo9sc6iU5O108eP8JS2PX6DCOK4L1SyhnclCOl0Ww20xKHXj6K4XDcdn1h3LDZFtbaKEogoAjh8/NHx+P+4fexTiMExnH0OLh6d+2cwRg3bTvLTwghGBMAwDS4i5NfPz/74HA4XN+/boctWTCfYWt1Xdec80ePH2NMJ9Efj+WDevbt1WvfC+u6xsRSojDGQoyLxWrsx9VykWer3fbwoJ2JoqhubwijebYkOFytzqQcDsf7LI3HURRFhTEOwkXbtp4XfPfd9w4qiFzXV4wSKyxGPElS4IgXBM2+cc68+PDFfr9t6o4S7+27d06D3XFbVjvGmNHyq68+/+CDDwAw37/6K+eckA3C5vmzDynFw1B/8dU/x8gLgmiaJqEgY4xgHviJNSCKvaa2lHDPCx6Wg9Mkq7IrDq+FnDiLfZ/vDtuX776wpB7lUSoTZzHz4kmYm7tDGPMoPoVhWpX3H3/8gVRjXfUnJyfFsUviOaPBOLa+F1BCprFGkHMfrlbzuimlFKvV+ngoPc8jhDRNxT2MidVmlFJRyghmlHiz2SLPc2eb+7t9li2Y57hPCPtFo1utTlCe3N3dRVHKWQihbZoqTrzTk3PnxsDzKQvLskjibLmaH/eDEnq9PPN4PE6t1bSupqGvGA1Ils73tzd13WprIYRhGHJuxrFG0KeMchaJyTCGAj81jradGjrjeymmvjETYwwTA5zgHmma1uhOqh4R6izyPA9AwxhLkmC3Hbqu6/teCh1HNAxDdPwVRxFGkVbGucEBKaTkXsqYhxA67O+cgxixX/vpH3AWOh1gDKypsnQO0Xu1nrNkNp9bA6SUfT8Gng8AtAbs91shdOhgj/FqtSKY391tFvNTpRTnnNA8TUPGfISwNSDLZkLs4zBdLWeUeG/fqjBaP3/yN15+e31183mappz5CHqH/f6nn/w+wv5XX319e/89wtaC/uMPnyNEulZlyUmWzoPYL6tjUeySNOz7VqkpCIJhHBgPHdaE8O1m/8Hzj58/+fDVm3f3d/c//fg/UbZ6+YZCwIa2urx8WlcDMN5sjsepJRRN01S3u9k8oiQ6WT61UGw35XL5OI7D+80N464fyro5IBB6gdd1Yrdrn1z8ZD47/f7ll2nGy6r3fDJOzXZ/FQRB3wnfjzjNxNicnT5mzHv5/avb65uTk7MoiK6vr7I49/1YCu2sksISrIdhIET7fi6VcA5Cg62FEGKAnDMG/HA8P0w4/rrxKHTgvfcXAQBZaH3i3hXjZ4X9/96JHQyffXz24tHM6fG2Pa6y2E9mvbAaKISpNtYhhDEBEBrjIMQ+o1bbfhqNcQ+88R+v9TBuwRgjDBHBCCHggHPOOACNMcAQQB64HghYhBAFliD44xoFvvfn+OFLCB9u50HS6n5gYTz4m/1bst8cAOBXcuL+Q9HGL8ikGCpnBqmUYZMwm+3dIK7TzFDWM2dDP1ZKqQE8RO0QavoJJsE8CmNjXNM0CIGyoF03LmdPnl6eOzgR7BGKjLF9J+bzVd8riCXFKIoi38vk1GPsDvvq9373bz+++Ojrr78zxkBki+MxCrVRXX081nX3+uUbCGEYcaWn2SxjFIeRRzAax8ICGkas6UzbyJ/+9Negi/b7PSWedWIS3WL5OPRnx0PDfYsQbpoOAIAQmKbJWpDEuTH6cDgEoR+EHgTI92POIkEVcNjjMbAUQZMkXCkRRenpGk+iZYxMotPCUsKdM01bL5ZZ5D2azxZde3s8HhFCnuf5vg+gAwBZCxBizkFnkXOYMY8xzzkzn60oCQ9T5wceZ7TvewR5EERJPFNKyTFYLKIky4+HbhLDvnxTNwWhdhi11nqWn5gYKKml6qWcMMaHw2GaJgDAbDYbx7GqKggIcCjLs6I8vHr7CiPmo1CYSkx6mqQQ8uRkjbCbxt7jFGPYD/U4dg4Yz4+lGq21xsrDcev7vgMRhEbpXhld1aapBx5wiCcHpOfj9cmCEv7mrRCqpijgLIMukMKdnCyapqvrgjGfcVDXw2J+GkfpJAZC4L7dS6kmWVtHg5BDhIpyJJgFftI1armYBX7c0GYapedzxhjjpK7l/lDXdbk+WTLGlFKMI2MUQpCSyGo+y089ljbVfRKtl+tF1x+3h9ssy0/PLtq2pgw4oF6+/gvGWNsOq+V5Es+qqoBYWiCcIwj68/laSzifreIo69ppvbooiiIK07LqOA89L5VSch4OQ3d7/7LpbzebRGu129+9ePGCeS6M+MnJuiiKYzWEYcA5YxQjRIxVw9AHnpemuVRT01RlUTdNN5vNMMZSTeM4FuV2fTJ/9OjRZrMrS+sH5PtXXwRh7CyjOP3440/eXr2qyyOhhFJq7NR203w+D4Lg+rpdzM9ffPDJZrNXahRipJQFyBv6piiKJEkpgxh5YUDOzh5VVae1zZL82NSBFwdekuXBIO6UUicnqyAICPb7YYqjJEuXd/fXh325XM21GRBOXr/9epJVnJwMwxRH2fPnL47HrZSTNci4ZpIUUym1KKuN0hNEUmnnNFytTgjhtzf3D927qoqyqoWs0/lJ33shX+fzAIC/eOg/xoAwiNu27ftmvV5bJ6e6i6LksK93h9uTk4XRiBACsa+VY9R/fH6KYeosZDSOQrVeXfTdqPRAlB4mWb999wUhsqjecV9XTb/d3/7so78fJ75zTuoqyROM8fVNJRVM07zvh+urNwgR7SSw9ljsyuZAGWyahjAa+0mWrDkPp2lq6r5paoSdkKMUmnOutbbWGvuLGCoptDUUQKfNpLRZztdpkh/2dVU1CJEkzbpuymcrOdpvv305m6UAgCSJ6qZ4+/Z1FAeUsLouMcZ5nlsLECTTOFonkzzs7w8QOqXGd+9eB0ECkfJ8/MHyxZs3LwHQSqlvv/2WEt4MHWcR93KI6Oef/yVjzPM9IeSb66921SFJwjiOOOfaIGOBcdYoQSlJc9K0ZZwwbYRT5uz0sRxgeZwIZ84+CEFJ13VJkgAAwjBcLs4YY69fv/7JT34mhPqzv/zTcVB5Ps9m/pdffS2EYMzLZ48eP3p6C/di0vv9ncfy12++NUZgzPpOPXv6QRym3199ZbSLwsxZMI3GOdC2/dD180Virc2y2dRVnD2I7gLgkO8lAIiqPgjZrVaLWb72vVQKZQEZJnk4FJ7P0yRu2mKzuUvTbDY7DcNwv987i/M8RZj14wSBkpIYhxDizhGMwXupJ4EOYfSDqdcvjk3r3iejQeiAdRBBCLW1WtntpD7bTn+yh3u+XKzSNELN2O4cmgXBbSXnPo8p0pOiGBAMgUWYWACgMRoCQDCzzlglEQAYwL//W//nh6v9/M3/EqP3BeADfRVYCIFzwNqH2HcLDPwhLJ68p5gABKC17/mbED4MMH7JogsAB99zSh14Hyj/y6yOX1a4vKeWQvzXINe/N9r4V17fKG37UTdD37THuntjzWYaHXTG6ikLl1LKpukgskkcGBMAsGI0jsI5hqBvqzDhdb3hHouiVGtAKF0uT4wx1gBKglk2931d1fs4mkMLhkb2zeSQzbLcGPvq9be7/Q0mWk4CWVof26KotVaM+sv1Smt9LDZv3n7/4sULwmhEUgCA1kKpyRg/DJI49BlJlUTz2WoY66IsMKa+F1qLMOZCtABoAAChaJz0brdhlA/D5Pk4jBjGAGN3d3c7n50FPmQ0cA5++OInt3fXTVdlYViWHSNQSx9DGIXUWNVWfVW1hCCPpXlOsui06yYIMEKgbTtjpbXKOmA05Izf3Nw4505OFhR6GEOljO8H46gcgxj5gR/MFxFEx0JVozhGOvHoiaQpo3wcuu3u6n77vTEqihLusbY7OuM+/ei3x8F89dVnYUJn8wxC2LaNtXY2S8PQb1ohG5OmCQCwquqiKAByXkgMEGW9vb05nJ8+u7h4DqErjlulDPKQEIJzGoSetRpCc3t7BQDIstl8nqbpHDh0ff3WD9hiNa+r1vMJQpPWE0XUEVcVu7bpu6Y6PVudL3/KWWQN7ofm7v76wWGIEk/pCQLWd6NWcJp6B4wxJgxD4qmyqKVCCIHl4sxZmCYLn9vq2Axdzz1KMcOQAAvlpJI47nt7cnLBGLJOE4Latm7aEkDte4mzcLN7+fbdlxDiJ08+MM72fa+UiKMUAFCWpQUjRHKcjph4wEFKYODzsrCBFxZlR5GfhLNxqhgLtAYQ4q5ri2O9Xq8BAIQChKIoSA/DoehKqagxcjZb+EE0Tg2iNkpZUe3afmAVqbvSOn1/f48xfrAndM7WzdFZFKXB0E+U8q5pZuksTlMpFfeCw3FLPRQnAaeIQLCc58di63mEeXro1PrkySR6SjGEbrO5/+jj53XdhmEIobvf3DLGV8uzzWZflQ0PlJRyGiXn4zjVoyjOk0UQYmV77UQz3N5tXyGEHJLj1CQpB44iYLrubuinxWKtpGnrg1LaUvrV158Dh9fr86Y9tF0BkW6axvf9tqspjubz5TRNb9++pQylaUqYevX6C4SI5wVCNkIIAEDgh9tdAVzx+PGlVBP32DA2tzff//qv/c5s9uH9/f3JyZm1uu+qX+pGeBynx48fv33zToix7/s4jquyGQdxsj6FUHddl6Rh3UnnbBKfCCGMaqWwEKskSWezGXDVZluQqmpOT5dpMue+zmZ0FP3QNUEQDlM/qVqqsSyP3VhRwm7ububzfJZFWvaVFoQwKSXG2PNDzqnSQ9uqk/WZz3OMaVXvu7HrRY/kmMQZYyyKEAQYYxyyEILyx/uo6oOb51EUDoPsui7xx7tue9i1hLDHl2faate2nk/EVIUR2u6vZotMW1c3hziOCYH9UAgxLhaLuhmcs54fSDW0VbNYLdbrE63sg2XNOLaM8+Uq3W87rW2a5dYJo10Sh0GA5/O5z0/2hxvtZMihtvJYbRw6WmLieKWUrJpSK2Sd+Pybf6m1pBRjPEHouMf2+601KM8csFQZgFDc9U2WZQDYvh99L5rNVnEIrXWU+L7vV1Vxv7kN/GgUPe703eZf7o9fUQaM0cDg67fXHo+K9khp+pOf/PT+/l4bL8nWzjmE7fev/ko6kyTZsbyp67osS4whJXQxezKMjZJs+fgROc+7vmm7GkAFAOecd32nFXh0/sHF2XMISNN0dbPXxnR9EwWBMaYu2+Xi9KPna6OBUEBJAACDCBHKMKZKGSWV1J3HQ4SdtRoighF0zhFCDPjRS+sH1y/rnHMAYuectQ5AByAwxghhhmn6q72+097gc6WIwKixwCowGdeq6SRJsTBSTlmEGcHWWADgpASBCDgHrNNOAowoIUpr7v2C0IQRRAgC4Kw1mHBr3QMdz0IIjHk4+JE2DkEIMIbQkvfLHwegM+YXu6CHzYp1zhkIsQXOOmCBBe9FrQD/Utjsv4IM0L8rvPi31y+PNwAAUtu2F3XX7MvrY/kGkdr3ZN/0lJPl8kwIZbSMYyjkrqp9a/Bino+DlVIDq4QY203ZNmOWLnu239x/J9W0XM59P5TSAWcgJFK1ZXmMQp9Cf5YvEOSH6p575M3bbwjB6SzCmOE6XczPtDL9uuchquve44HWOs7Cx08fn52djKOY5EhJkGczjKgQIvBxnufH437op0ePno4jkQIGQVQUdVG8oYSvFuumaRC2CEHnTNM069UZQoRgLwyxlEPTVlpLYwQABiHQd6LjHWM0SYOmLRBCBPvOqMvLj9p+V9VbRtPl/AIARAiTY9mY4XgswjAmhDBG6kYghBjH4zg+f3YphPr226/v7q+MVRBgSvnY68XSD8Nwu931fccCUzeFtcb3mRcE56cXh31RVNdlc+XHLghjLWAczYydjGuUFFKOTdMZNxCaPZB5jFGU4X6oD8d7AG0ar+Mobbvh9u6dMfL0bKGsFHqyemIMewG0rt/ebwAAebYwGhIGpJwCP+Ievr17Z52Jo0TKCQAU+DGCjJJDHAVpkg/9xLl3rK6mUUVhhiDf7TbTNCVJtl4+yeNV38lZPucUXd3cTKKGgPLEi6PMWlBXhVANxlAI4Xvxs2cfvH33sobSY2EUhVkeleXxeCyHXkbeMk7CotifnJxyzq6vrymlhNDLxx8eDvviuKGMEOIN/Xg87sWkeeCXTTkOVRRFp6fnVb29endrjDOOdeP0MMaATu72d0kUx9FikWcAgM32GiFyevLi4vTjfmgm0Vl4bLo6S9nusAUQzVeZF6LD4UCZZzUmhEs1Vc2W8DTw8yT+MI6S2/tXaZoei/1+d0SQtZxyTpJ05ntxWVbQocViVtd1U5fr9VoIYYxJgxBCL0szay3GuB/a3XEHIayqiiLCObcWTGqK43iYjha4qn13uxkhdBDDp88u97vS9zIlnTHK8zyMqFRTXVd+4AkpZrOl76XjVDugGXdtd7y6utrtbz786PnN/Recc879aZjOz1ZSTh5f1VXXd8BotpHtyenM2MG4oR+nKFhSEllrT09Px6nSZnRALmdP20YRzqpjfyhu0iQKQlrXtQW6aYssy9J0ud0ex0Hn2SKJ58bw/X4vpWQMS9UF4SyKPYjs3e1Bae1huDu8y0X9Y/+ZZbOB0mEYHDDffvvto0eXBLN+aBeLBcBdWW0JZVW907b3g3y7uyGIYphS4q/nGUTu+vptVVVhxAh0XhwlWtuyLCGEUpi2kfPFyg/w/eZ2nBoHDGXpycm660trtQMyjCJrXNuWy8W6bkeIGffTdqufP/kbP/30t/eH26ubz5U9DrItqzKPF33fOweDIGybNoz8JEn64RcxdJNojOVJuvQ8Dzg6DHKeL/MPHo/jBAHYbq+7rnvz9jtnRws0QEPbS0LIfJE654xVEClCnVT9/WZ3+fh54HuTIE+ePqaUBX4qpVRKDWODIMYY3t/fTgNljBPCmrYNw1BKGYaxlFKKfT/ukgwANNTHDkLHOLZO7fe7+Ww1SoEgg9T4HN5v7mZBhEEiRFNVFQQ2CKLt7no1P8lmad0cpRx2+2q/3//hH/wdJR1w1DhwONyWZVGW5e3d26dPL4UcEVZS1a/efBaEPsYYo6Sph9DPfvbid63+/FjtxGScs8aoJMkJRe/evaEMRl5KmLnfXxOI5ovAKBj6M2fpKEYx2ZvrQ5qmEFqEDTKacX+1Prm5kQCAOFwVBzFNzSTaKA4QJW1bG6OsRb4XLhdnJ4uLcZRl21VV4XkBY8xaxzyezYKm6ZREhBBjndaaUvqwdLDOOEgAAAYA/HA42h9XD+/NzgEAAANj0ThObdvv6dm2HzR0jKNOTmo0ITAZI9Zo4DpNAApcOw5idKkfWwM4g0IISojP+EM0zoMi5rc++D88PD+fvflfGGMghAQiAIAz1hhjwYPlhvsFGwMABAlABkPkHEEAIocQdAQ9kDbgj2QM4BwADiBgrDPOOucsBBhADJGF/0Z2hoM/LGb+fetfS934pQvQw+GmHIpWbJrxpc+niMdaSchR17Z1XUM0CX3ExM1mL5oKFNV1np5xCl6/vp6EZMz75KNPtCLl+AozpacewMz3fYzcNJq26Q+HDSaw67r1PF3OV1LKLE/64dB1TRjHSYbFZMIgOTt9qpRpqjJaMHy3mUa1mM2Wq6xtq7ZtAcRSSkawRXw2PzeBLOuNEFNZbXa7LWUojU+fPP6o66tpbByYtBuNWeV5Pk7t8bgRspvNsuVy2XXTfHZye/eubcdx7B8/fgwAsU4OY829ZBKDMUqpqetqzoO+H//g9/9oGmDbdnUpzk7OP33x29+9ej0NxyRbCyGiMJvNZm3b5vmcUNgPldby/Pz8fnNHKQ0jBiAqq75r+/OzS87A3f11FCyzLO2m3bFohOziOPXJoixLhL7f7t5tjt8NY/3o4inBHiSuqbt+LLhvpJJvr75v2yGfeZTS43EfRREmUIhRGwGRQRgghFfrU+t269XpZNq6rwGwCKEkycIwrurtKAoHtdV0HNRy8RgiZYw8HDdCWoJpHCVt25Zl7XnB0MswCBbzU4TV4XDsum6alDPaaufRiFDsrEyTGAG/Pgo7vVUSEQreXb/SVnEWcpZFwQoQ2bSVHyLGtdLSx8xotbk/7HcdhuFqcck9st/fCiGVFs7ZJEnyWVrX1e3tve/zaRJ9P/z6r/9m4KdV+ZbgYLmYGaO0clJKiFDT7vth+ODJJ2myGHt1KAtjtXVylq+dhRBZ4KTPyenpCXKelvxkcYaIeHv1PUHJ0MEXzz+9uv5mu73XSGy3B4JZkuRt01AGXr/5mnt0nj/OknkQBJTCNPMwBlrh9fzjq+uvD/vy7NGibo5xHBPsWWu0sUAgBJnWNk+zsqz3+63vh3VzEAIvl0s5DdZaIURVVV4YHMsiCKJZmvVdpaQxBmptP/740+vrKy1CitFmszs/P2WMjYOeZ49jH9fNASFdVUUUhcaYpqmsExY4CGieLVfLs8Px7m573O+31lrfT54//xmEDhEPAOgsjsOVnPTl+YtXb+4oWP3Bb/1els3/n//v/8ZnaTf0fdcEMVqswrYC8/n8WNwbYzglWZZBwxbZ/PnTnyIMrBm0baaxBlZZ61brJQTI8xlwMArTxfy8KjvmRfkC/Omf/Rkian2ykEaESXR1c4WhzrPFN9+8SZJkvboE4E8f2o/SWkq3P9wVRZFni8V8tdsdtALW6bFvIbLcw/04OSh2+/s4XAYed5ogBKyTcpy6Xmgjur4jToOi3McJn8SAEHBI5Is4zQIHe62tUeH52WWepHJyF+fPt9ut5zOtNUZ0lifr1SWjpVLj2Bd5nv76r79om/t3t1+03YEyEPKEL4Ll4rQsj5z7GJMsWzDKKaEe/4Us1hnK6UxMdhhabdthGJfrM4wNRLIbh7o5MMaNUVKjYZQWYQjh4bCbzWZJkrVND6ALgrDrOiXN0AvowvXqo6FXyKqyLKybKKVKOkbJbLF2CNq+8DxU1VuMMffjrqnKatu0WyNpEOKm6ilDjFPOubOkqY1zRKrp7OSsaYau0dqhkEc+jQmB070N+MVisSjKDeVWGEnM1NRHz8f1fhsE4Sxff/XlK0qR1O1ixZqmyWdB5nwAgJJmsVhM03R79/bk5NwLoizL89xYC642L8exHcVhf/CMHYv6XZyyvqSMZHnOx1HKTkd09hDQrLS4unodJ2HAs2SZSqGHYQjD4FjcSdUpU3peMA360dlHdVu9fvt5kgZxHFsLlBg54eMoKSZB6I1DsdnaupqQzwlBWluEECHMo54XBv0gtdHdKAHgmHDltDYTwYwCTxkH3s803vePh4gyCLVz4AFvSAN27bAdreJzCpwlxhpmDeqLRpgJBVyOA4w8gJCRRiiYR3FIrB1lSmEpes8hqoEywCJnkHXQWfKLlRykFDintAKYYIyBlhhChKCxRmirlAIOUYyVUhhrjOiDgAVjJy0gGEPorHMEvI97AQABBJzDAFjpcDVijY2DjkGScQCB8AEBEFoHgEMIAQjwQ2Dbe1nLv++M41fQhv3fAgecAcZAxICFrh+7V1dF2VwZcNcUr4mVqZeFQaTUoR7qm81L53SapghxrdB3L18tZnNraNNWxqpkxhMQUhI8evRkuzkqM2vEfrW4XOWfBEF0U33tnBhGCg2AxqQJCyL38u1nUtjLJ+c3t5OKJMFh3yCMGSTmdvt2muTJ+qKteqMMY4BS1HeiqUVZ1ZTiJA2kLKVRxgXD6Lab3WbbIzrmeTCO05PLpGmK/dv9av7Bb/7OP7q7/X5XXs0XyXw+64fq8vJyv9/f3Nzks+T67pUF/TAdZ/n5Jy9+7eWrbykKKE6LpiXUWdBTqtKUSaHTlFfV3TRJDNgsT7rx7qvvPj/sW4CE0gA4vpgvKAk7YOpqYJzn2aKu67v7t7e3t3kS53kupZqni8BLfT+01lvMPQtcvuS773dSDavlIzlSDUZC4bF+24x3w9hm2YwQWtUHn6cAOz8Ih94oabthm8+WGPl92/k8wJAQREc5WAs8P4DQIcjubzcOGARdX4+U+pTiOI/Plk/vN9dj33os8j1e182kulFtQhZqI41xyGGtPZ8vnj759P7+vm8P1bHNo8vnl6f/9E/+79vDqxcvXiAIm1ExxhFRq+UZsJ4UIE1TCN3QVQSz+exUCnB98ybN4zjxrq5e+gGjOMYwxwYAVzfjXkrZ9XuM+Xq9dq5/97byAsf4lKXzx2e/I5QMQiLUQBhgPoph1PeT78WbzX2erXw/hMBV9UYKm6xCpRR23nwRUQ9V3VYONvTCi/UlcNhfxPvd3W6/iaOIYMD8SCtYlf0785p7hGDunLRwX7bf3d5/by0YxUCwd/noJwTFatxABynlWo9KiYvHyzcvr4Cl56tfG8dRusmBqu7fnJ6t2rr32enl48c3N1dDX1ycnFfNOPQ9RZ4WQVOOnCVSjkMvfC91QB7qdxApDWejlvWu4swn2KOUJOl8e7gnhM2z1e31wZnw8RPvcNhNUlT1dpomQljbHawFHz/7/brZM+YhhLW1WktINGCAujOp3HcvvyVE399vCQ6z5OLy8QdN3XV9M8seKzUBaA1w0lo/Tgi9beuKUHt9fR0Fi+X80c39ayFt7q2qQnHuvX33OaVECQJdsF7NKOUIm+3xy1evv5FqePz4cRSd3tztszg/Ho+U4r/6i2/jOE3nft3eX12/O7u4WMwyij/wPDaJwRjTj3Xbtqfrk93u3XIZxnGkb/sfm1LbFXbh5zMPomi9WhyK27vN23wWdQMGjjKyoJhac/CCiBHYdy3FLIld37dv3+7Wq3PfDyBESkkSZ/E0IKWElDqKgzCkVdkghKwFi8UiDLI0TbWWQgqtDaXU932tpdaWUX59fc05lUpUVbla8W+/+6Jre8YxFViIIYpzrXXTtBhTjGFR7LNsfvnk+WZzh/AvGvN6vdphXBwrB3Tb9lGYNG27O9ykaaJtr+CEkFWondQQRMFq+ez+5i5L1wTTtuk9nxntceajKFzMLoeha7sD9+2k+67jQg/cgwhB6yTCXhix71+/Kg/XzuIgzE5On9Z1G4X5obj2AzjKzkDi+0xITSmD0B3KuyBkRgHPj4ap3O2OWsOukw9JS017DMNwPstXq7kF7SQ6pUXfI6UURDKMgjSZv3z15cnpCePk5rZ6yHr2PE8pxTjhmg5j1/d9nucAgKIoPM93zm23W5+GbTs+/+BDn8++/vorRpJhaAI/I4w0baWVq6rq8vJpGPnffPO1tZoQ3LZtHK4uLs6//vpr55zvcyEkwhSjwBpgtFsu59e3b6MocM5KKSFw1ONa6YdfyTm32+0YHRDkUgyPzx8ppaZJ9n1fFrUBME4SSriSQGmJLQQYUIysdeYHKeyDmPQHoiVEACqtIECEsmEYmm6gfpzz+K7soLMZ5a102+OxrVqfwA5YCLTHWbc9Rmb6+PJCtCOR7QfrtNnvQmf9NFNQDqbzQh9TZLX6nU//Tw8Pz5dv/+dGCalVEESU0rosHhIyIUD9OAmhIIQYYOUcQggC/MA3AQ/TF2eMMQRBBBAAAAP4QOEwAFjrlLOdQq0BBjoAgHEgZIC6hxT699wU+KNO9j9sl/IraMP818YoTCAkQGtJoSekffn65lhfG1f3YoOxWJ9mGLiy2lECgiAExlqnfZ5wHliDfC487h2OXRiklPhtU3icSSm/+OILJQ3zTJIkxsKmLTCBCAOtHKUYYprEHkT6dnM7jsr3/avb/n5zc372xFqglBqGQWkBIbQGlNVe6abrW4K9LPOUdMMw+j6j3DDmTVMj5FjV+yicn52vD8d7QtmDXvj27k1ZFkJ2Qm/7KeWBAJXY7e7jxOfcr6teSXCyvrTWWDcUxS7w0lm+fnd1bxVSSDOCl/O0qI+eF5R1pY3yeKS13O3vqnqfJadx4pXNrp9uMTeIDMPUZtEHCAMA9XKZ7w7XZV1FMQ9CT6psvQIYY0pizvBssRjHUUrdtP1isVRKfPfdO4TpLF85ix/k1tY6paxWKM9Wl5eX4zhWZYfgmCY5gBY4aawIw1gpM6oOQjifL4qigJDM8lXdlFpLxoiUUmkxjr1zdrmc5/l8GAal9Js3ryDS3EPDVD47faHN1LXDZjsBQxBCACBKMWdoEu3mboQAKKXOLy6y3P/8i7/ABP3B7//ttpnkhNfzT5USnMTTCBmN53nKOe/6Rim3mM88LwiD5OL8ibHj7c3O92aL7Pz09FEUpv/kn/x/zi8f5bOLzfYOACBk1XeTkhNjntHSOqYx3mxvMGHffPt2v99fPFpP0zR2Mgji3W7nnPF8zhiRamKcxChumg5j7PvhNE0P43Mh9Hw+PzlbXl/f7q7upZwYIwjZaRqAdY8unjmLrZvKqvA84vvhsdgaYymD2mhKvSzjUg2DFFI183DxPL98e/U9RPr65tXVu7cffPBhGAba9ITiP/5n/202i+q6jKIkDINjuRWyj5KkHUbrRs7p0MKzxx8u5+rr7/5kvU4AABaY42H79vpVGDEHne8l3PNns0XXqGmaOPcIihklSos4Jk1TieHRYvaEkez6+jpJZs+fP7+6uuac+zH67vU+CvN8lt7cviIE1pUgOPQZJoRk2axrj4v5WqqREKS1atqjdXo2y4aB3NzcZFkWRVFd10+fr7/68vt//mf/VwDw8+dP6v477fb5grZtSxwYx2k2z4Qc81mCkffo0dnmvuz7nsC4rgaEDQTY8zzfZ8MwzGazqmw++fhnjLF3797leb5czREklLIoipQS2+12Npulaer73Bjl+zwIfOcMIr/oa1Kaph6zPDSmbtseQR74c4qDbtg9fnQOAd3t75yl6+VZ1w1VsbER0go6i5zFzgFCSNM0SRITZRQksO8mYw3qJ6215wVhGBdFyahHGWra43Z7r41kNGDUNxpQEhgzhmHImMEYV3d763RRbpurdjE/OTs7AVAOA2rqIU2zxfzEOrnZXvdDPU69Mdpam+NfTKZns4XKk6IoOMfWWsQYoJT7vJ3qfigcVMrqutv7GHss1EISHGSzfJw6B6SxAiEMIWTMC4Kobftpmna7LcIW2xnnPIpoURweANq337V+FD55+ujV6zcIm+UqE3Ksjs3PfvqbBLsvv/lLztk0TfjBpgqCIGRCdlGwruta62o2O+tb++L5ZRjG3377dVGVq+UFxu727m3bHZQSWTafzRbFUZXVbrnKJtECK7UZu66DyEyid8458JCINjZN6ZwLgjBOEwTJZnM4HI/WaCnlo4vL9Rlv2u004CTJd8ettub6duN7yZMnTzab3ST6Y7ExRjqntVbWGuu0M9VXX31RVscgCPYHgzGNwuTi/HFZVp7nFcUhTgLbdFqbvu/ybKGF5szzPYQQctYgipwzxop0tjZWQwgxxtaCOA6VNZ7nj5N1yBhnjbHIIQAAxPC9qZZzADjtHHLvM9ssNBBja1079FpIz/MswcrZRRoNhYwRGg97XYlVmo99t98dF+vV1a6mavro/PTPv33jGfmTR6dffnEVA/3hLL/d3xJk/JhNbUkIDBj/xfE89ZNUXhDoqe87hRG1wE1yHIWapsk5QCk3ziilOPMhM4RQ5xwA9oFy8SPpAjnrHHIOGOC0cdq5wbhqskdlDQMA2tBYD6GIII9C+F7v636Qq7j/UMTxy4UgcFgpRSjiHjk2xdXN7Wa3n58MZbW3rswygoDo2k7I0ctzj2exn2ptrYEMh4gSL6fAGmMURrRtewgxIWQclRAijlMhq7ruKfM8PtbNpm0rj1OlxXK5FLJt2qYfOkKIscPrt7dCDuenLyCAlGFtpHXCGhuFaRh6d9s3xlrPC8Iw7dpeKRV4xrqxrjSAzthhkmUYcYQNhE4rCJzhgTiW19OouI+q7tXXL++QZZx7fVcyaqIwh4CdLh8vl8vtdnt/eAkcQpgxFI6DVBJwjpIkMkAMt401FAJCsDeKidDBAkeZBQAIofu+N3qntQ4iiAniHsUY1PWBULA/3CGsAGR9DwGks3wZBMnUia4bhnGfJAmh/vlFcjwcZ7P5Yr4qqnshdBIxR1Ec5dM0IAw8ppQe+1Y3bef7obV2GDvPY77vH49lU/fO0ihKPY923eB78cXF46I4TJOgLAhC7nRYN0djZZwGcRxJOfXd5PvxLJ813X4cJz9gdV1bA6Q0eb4QQhRFcXF27nl86Do5DuWhGscxyvJJTX/1xb88HDeLZdx0YxCs/sbv/MGrt99MUwegqqoq8CPK0CRaYyfKuYPwy6+/zvPFbLHaH7ZJul6v1xSkgR9/9vlfLpbz588+ffXq5WJ23vVlVe9neex72FoNAAv9Wdd1m+312fkFgC7NYs65c44Q63le01R1c3x08ZTQ4Fg04zSEcVC3bRQmUsq2bdM0ds4xj0NuX777pmm6fhyVFqvVvDjel1XFKcOYfvjhR99+/+cOCACB0qMQervdpGn24sXzfRH03aiUXK5Wfgg3m9u6OWACGXVK9gAJIZthLI/F3jkTJ2S32108OgsjOo61MRpQgD1mAWjbkRKzmD9N09QaICYTBtnhcKBMOmDC0A9DBqCFyEkp2rZmHn799hXB4d/6m3/05ZdfTqNo2w2EJk8YxeEHz8+BY4yx/a7M0oUx5s//8o+BDU9PLoOQffvdzxm1eZqt8keLk6WSsCiqIIiEinQ7xklwffOybva+H+4PE3CIcy9KknEQ2+12OV8pCaLIX68X82Xwz//0rxwgjGSUUj2Sh3c1TsLACxjzpZq0llprzoP57MQ60feiHca7+5v1epmlM88zSgIlpeeFbduO4yglmqaJcVIUR48HAACEgNbaaDWfz40xVVV4jfqxLVk7EpJk6XLsobMkny1PT6ixYhSl1vaw3yBElouLsQcIxL/1Gx8ci93xWPz0J7/uecH333+PEJrNcs45Qdha57zAD/0AOlsURZ7PuqbTWhs9AnDo+vr29ppSmueLNE05S4xRYfBACbTH4xFC+PTp06o6AvAgzRisAZxF09hSHHEW7Q834zimaWKMadpiPluHYfTjnby9umrQ2vd9COE0Kis1hDifJXf3lTOW0wAAKwYttBAjiiPkeeGx2Gz2uzgJgsBTulXOR5aU5ZGSIIlOAy+5fPz0y6//glGMID4cCoRQGIZKqaHY+jTknNfD7otv/thqGvj56frZ5m67Wj46HnfTNJ1fnE7TdHNzn8/SNF1oSadp6rvpZBkpanwvQZBREolJ+b7vnNsfbgFUu90GY/bowp/N101XHYtKyPH05OLm/jXG+OOPPx6n9ubmbrvfRFEUhcACgzAapk4563mR7wWe5wk5eQhKLYambdttFJr16fJuN2qVYBQh6G23+1EMy/VMa70vNtznzKNaW6WgcZZy4gXMDzkAgHE/Tua+n7fNdLt/k2axMUopHQRh1/VCCMYCrXXfj9bqPEvzPLMGSmmNVXd3N2EYA4c598PAn5QWQgBAEQKEAmWtVM5YABkkBDunHlSxAAALAULIQoCcM85JpSYhfc+L47gTphtkSCNqxc3r16azyzAb+wFMMqRBV3bDqM7m6bffvDVD92y5+PlffIcOm996evnF9TcxRTMf4cpQBrw0sPw9Wv3L/+7vNTfvWBB6Huumvmm7KEkAweMoJiEgxARTp5V2EP1gE/JgC/bwHwTe71AehK4AOGedU9ZJC6R1vUTHwR0sVNBBBycLOAaEYK4to+iHyYZ1DjjnIPqFkd2/a/31eDYAMMbWQe2A0MP15vX2eB2mzNodhK3HQOgHD3pLzkIj3DDVkR9hxAjyPJ4455zVx8OeeXASY9/38/l8mialdJpF09RLKadJUuZxD0k5EQo45wCYQ7FVetJGhFEEkZNyYh5/8uySsdAYY5yc5CjU1HWN0hoRTCklGHucajMYO0FopZQASso83/d3+zsABWqUnGAYheOg2qaVVjRtFXjz+WKhbImA4ihw1iEEhBAED5whynBZ7ZXux6nxA54Es1m+pEv/5evPGcdNexS6d84Mg4rS0DrVHnfzGaYU7bft6XJGJ1xWmyjMCSFKD0OvKlRSMtxvbpWauuE4mydV206TPFk9HoYJAo/x8MOLZ23bxok/imESbVke0/QhSMisVktKvcN+P/SGMfbB8xez/ORw2CFkOFNNU8Zx7CwUk9FSJ9H64uKy78a27cdx3G4Pjy6eGg2Ox8pZrJXRytVlAaD2Q6aUPB53lASM+YxygoP57FSpaRgbpcynn/7ssG+6tgdkcE4TCun/n7T/6LFtW9MzseGnd8uvcNsfc881eZPJJJOoLBLVKTUEdaS2/oAANSWoGhQESG39CQFqqSVAKjVUVJGAmEzDvO64ffbe4VcsO70bXo04994UWSiUma1oBdaINeIb7/zG9z7vj+057LuRUZBgL8/zfmjffXbV9fXhcPji3av7h6f7hw9BSLXpm650/eXuUBZFgRDyvbgfqmHkGYweN9uqKhaLBYSwafIfPv1dUW5evX338fp3+8MxTp2BH8/OL2ezcyHGDx+/TuLFarE85S11gQXKdQmhsTEAQpymmeN4CBILx7zYl1WOEArjQGtlrY2ihDLQdQ2ARohhGJuyzYeeTyaTsTNhGC6mKyWE4AojlJ+6utRV1VDKfC9u2z4IkjDIAj/K0vlunzsMZ9lEa/Hh43cAGEJolmVJkgzDkCRRVZ9Op1MQeE3XlFW+nF+laVrVx8fH+yiNGPOFcpM4kz6RqofY3Nx/u9lss2l8d7dP4mUQUTekboj7oQIAGIAARlXbyXJTd/vXL7/qh6JtW2jon/zJf2KMOZ42qhyL8tg01bvP3nz33QOlxALd9s3l2eJUPN7eV7NJ7Ae0KGrO87uHkqCgyDuHoaoqhrHloq3bQ1nv/OCqbcsknflh8Jz9SQh5uKvfvPr5cpX+7uu/+/rb3zHGPvvsZ9unPWQCAooRlHIYB2ENMKZrm7zv5F/8038eutnmca8NRoQksc/laDS4vb2dZEvPCzebR4QN5zxN4zg+K8s8TWJrree5Ug0YQ9/3CA7ruj6dTtPp1PkHHI6WHzALojidz14PvcbEjrx62j5i4oxcWghev/kcAPDx40dC6DBYQh0L0Keba4IZc4iFdn/crdYLwkX/ePc4m81c5iAAHMclBN/dPWVZZq2ByEZRMJmmCCHXdXzfjcL05ubTc71WyhBCZvMzz6UNrqeTqGkGhEgU+Rjj5eKqbcTT5lBUhR/EAAqMaVN3QgiE/shs1EpGUeT7fte3s9kMM9x1XVWeoAUBizCiaZoSQu7vn+Jwcnm1ur37eKz2URJghLUCDoshAMJwbfQ0mfc1DL21S84J/joIgofHa0aDFy9edF2Hid2fDqeucD10e3uNEPnis18kSfI3f/M3GNKXrz+XAgKoyjJXyhDiAONfnf+c8+H9D98FoWeBGHj19benIIgen+4NRE3TrNfrs9V65NXDw50xuum6vq1dNzie6vPzMwih59MgiNqurspGK4sRRZC0bQsAmE6nXddVzWANXS5XBMFuX0MIEYazWWp033WtVO27tz/hAzubXgKg3n/8204cV6sVxpBzCSyaz5ee511f32CMi/I0m021lkVRzWdnUsqHh01THyfTVAiOMZbCtpovl+d5fvQ8DCxOUwdCqI3Y7ncEkdl05fi+4qPWcr9/CvxwCAcvCKI4Pp0abbSyxBigDDYWEGKgNQShZw46hABCBCEwxmhr+74HAEZR5LquUgpD5CL8dNj2nfEJOJuGnQKyaiJIIXW2VR0itv/0MFbVOktvP2zt6fAm9n73dz8EtvpsOUOyN3ZcL2NNzT/7Lw7PO6f6cJfOM9dxypsbgYDjOKYtO2MRQgFzMaFCGykUQsRxHcoIIQjh55QTYC34/aAofB4r1cZoAIVBvbHC4lrC02gOGggAIbTcQpcA14AAAEwA+j244w+UsP/xRNFntSGUJJgigoqqu3/8IW8f/Kj1fDD2XRwFbWuVxBD4nhvAH7knWkpusA390A/YOI7PaEgLDACGENT3bVVVWTZFWG+3DxCZKEwBgG1bYYxd19VaC11bqB0XQ4EJwcMwaA2zZOU5k9Vi3jTN6dQjgKfZDAFrjJZ8dFkGoFVK7Pa3CCHXw1IDz038wFVKIGwhMtr0hDHHQV0nVut5O26HEQah47gUSmfsuZLS92kcp8aYJEk415un65G3Sg9VffJ8dzpZ9nxgSiGsmQdOxw0AYHWxFEIoJfquJQRxMbRtq21PmNK9QAjEUao1KItGScoJhxAGgS+V9cIMIcA5iKOJ7wfWg1oYY5WUHADTD0PXt/1QO45TlsUwDEYjh4W3t7dlWTtM/Pk//icQ4v3udH5+MYx11zVRFGttjbGB7/ssQNDjPR2HHkIEkV0uZ13XfPPtbzkXk0kmZC8F8AL/Gd/e9TUfJfRI4AYQgFPxIGQH0ECoDUL2/oevx0HNZvPN48GPPc6Hrm4QwBCiJJmvVldRNqnqou8bACTGcLmcC9nV1WhhbyGzQPi+SylFEM1mtO/7UVTGildv3jJGdodqvozHsbm7r7JoRj2Q0Tgvdhdnb1wPP25ulqu4aZqq/IAQ6Ps+S1Hb1cYoP2AAyn5oMCaO4yBIkzhu2xZRNJ1Oq7JRSiMCIQRKieVyGQRB0x4dlzJGsmxZlKfb+8c4Tu7uP725/KXruvd3W2MhQe58Pn/z+oub6weHxa7LsnTRNo+eG796+VlZlr/+9W+TdH55ub65/eGHD9/kxfGXv/wlgsT3w7Ks67ouyzLLsuVyaaEp6yrwo7dv3x6OT2VZuh7DGAsxEu4WRaE4Wa0XT08bMaLXr9+OvAmjYOi01kRpC4E7dJXvB0bTwI/ats1ml9C6QUg/3fx2Mk0dks5nZ5uHE4KEj2IcR6nMYV+sVmdNU7ZduVyc110+SW0/HpIoEkLsjzen4jqILkJ/zhyvrovZbNqP4HB4cl2ynM3D0O/6HDtYc9W1TRiGRlnqiIEfP93cH8s7x4fTaXI8PVioCApevfm867r98ebxcXN1+VZrgxCxlgMAbm5upNQY03GQzFXGGMnNZDI9Ho6MuZ999llZHW9uPmpNl8tl27bHY44x6vshivyqPkkpkiS1APpBmMQpyP9oJg19fyuG777/TeBnwOKu69I05SNYLi6UUlKYh4cHo+HV5SvG2Dfffg3gMAxDkiQIAWutEML1WFnmRI8jMPrF5aXWum1bz3Ol5FHsYWIRZI7jpGnCGBt5bzQCACAEIDKn08FxvCROX7x4VVXF8Xj0nKBrOUGED3zo+jhOZlkGTa+1mU5W/VA4rrOYr+ryB61Q17V/WAnCOIwCYGFZlo6DF+mCILjZPKRRqiRkNFgvrijFXQU9Rsuy2m43buD5vu85cd+L2fRVftqdDqfVYhYEQVfXYUyG/kQpxRhTwqJFdLa+vL6+Hob+4vxFNz7lp5rS6N3bn//pL/78/bffbTa3Vy9Wx0N1fnbFTna3v/fcMA7CKJwF3qxu3vd9g4mtGtoOVRJP/Uh4IY/ogkvlUp9Rf7t7jIJ4fXHOOdeGj+Poe7EUtuwLSvHpdCjL/E9+/hdFUXAxUEr7vud8VMqMo2DMjaIoi5O8OPV9SwjJ830Ypkq4BGMphrHHQE2+eP2X2/090B8g2NVVTwhBkFgLAYB8VEaDKI3ieH198yGKovV6fdifIKQEO1rzSRhJKfteXl18/py9NJ8vu26Io3A2WyilHh5vq6ryXJ+5FEKrjQwDL0kCACCAUptxf6g5Bz0XShEDAggjTAiEEACDwfMFy48RrMYYqbXW2mrjhyF1Ha0154NUQAnDoE5c+NM3Z/tGPOV9tAxGiQ7tkLp4bLouP71eX5TH0/5h88XFRS/Hp231k1V4/XHv56dLhvCh57IEIAMA/N//d654PCJE27JsxeBPUwYiqwgghDIHYSs0RwY6FGGMANLajEARazUhBALMiPNMBZPGUoAsRgBAaeFgUavBYMDjCB47fbRYAM0QABCGUAfMTAmkBmgMoLXoR4DH/0Cu6H+gNp7dNIgAqVVRtqd8p3TnucqgRpueMQcCmsZrz/Pz/DCO/XQyD4LoWG/KNkdIuK6bF0NVVa5HotgdBC+LCiHUdK3DvOlsttlshBKr5RQjjzGPMdL3PUYuRmDkjRs41gDOR6WwNpIyOp3MgaW7/Z0UdhgGh/m+50opx3HUWkPgAiiVVtqqMIwxcSCXQRAOY1nXre8lEGprAaWorA5CaqWoVjCKEt93+r6RUosRUAAJoc9pyQAgzlsAVRSzzdOTtZYQpLW8vfsIIaSO3B5PSoKuH93Io8yp207IMQ4jDBEkmDo4L+/e//Bt2x+m07k1TGkeJ9nIped5rku7HigDu66zmmqF2mZcLpc96KxRm6fbMIyAhhhj1/HLok7TSRhGH374dDjkSpkkidJ4neel4wwY4/1+fzhumQOzbNK01WF/Cv15HK6rQq7Wi4uLi//63/w/vMC8fPm6qhrXCTCm1kBHOVVVUcdIpZRWRgPP8zBE1irKTFk/1O1xtZ5aKH/1639nND47O3valY7HoiAARkNordEAQUhsJ7pu1ymlCEUAANf1x4EfjpssXYQwlpIj5HqOz3saBpmf+B+rH4IA8FE8PN4qpcqy9HyCMAg9zyIbBlnfs/l8gSCBkARh0g86yyZDrzCmzDkfhq4ovo4ij3NVVrlWFgCoJEjTxGHu9f4WAJBmgeO4XoC7ri3KA8Z4vV5zzrkYKMVC8H5orLXnq3UQhNDYn//si81mqzVbLOabp7sw9K1VFsj5/BxhIKTlQgOIu6E75vuqyaN4Wtf14+PjfD5fLGfnZ5fWorvbhyR04iBGiCCEfD/Mi6LvxOeff/5MfA+CwPenlNJu5AiSvuuSMBh5dX5+LrlzOlYGVghrP4r6hhsrIcIeTWJvWpZlGriBa+VoJ0lQV6cg9ChBWvT/1b/6f2pFXry4WC6Wvh+UZfm0fQhDdzZdcy4eHh4++/y1VENVl0mS3D7c1137+RdXDp1oBQnBrssgsjc3d0qJNJm+vLrEjOb5B6HVfL6wWA1D37f9bJ5J1ebliTF3sZiFYXh3d+e6ru/7QvJ+6B439+PYDcPAmON5ThjEv/vdbxiKfvKTrw75rh8qz/O5tFVRuq4XxUHXV9c3BWPU8537+0dKkzAMCSFVVbguq6pmfziena1cP55Sj3NeVjXPyz8UKNeZ+64nBD+cbhzHURLG8WujwqHvEYJJkjw8PGDsSDVuttfDmBur5vNlFEWnU04ppZTG0QRjSKxUb168nE2mbdsPwzCOQ1kdqUsIgQCYcRytyRjztLZc82HsEMophZ5PPdeBEA7DUBQVQhRBzHm9Wq37vhuGsarKumoxdtbrF8bKHz4UZ+uLq4s3VSnC0B233/yDlTiEEMaY5zl1kw/32vdQEHpe4BpNfSc1xnTdmGSsrkvdq/OzVwCjtunS1A+iVGvuuG6Wrj57+5XneXKET5vvhVCQwLLsVutl3/fff/89Y27gh+Mo2o4bAN6++fL1q3cOC5RSF5cLbXqExsO+2G6PZ2dvLi5e1FXftu1vf/Mr5uK3b768vnm/2x0c5kEI27Z99eoN17ApB2MA0LCr+ul07ntBXjZddyzK4uryNQAwDOJ+qKuq9DyvLAYlYRTMpBJaDXxUw1DGcUywG3jedrvNi1Mcx3EUSKmhNev1umk6Ibuu6yJfFvXD3eO3cUqZmgNosiwbx/F0OuWnchh4mk4ppTc3d03dM+ZorTEBAKgg8iTHXV+VRU9p8vlnf3I6nZQyTXtgDhnH8RmDKLiczWaUsHEctdXjOCAECYVN01AG+2HMyyLwM2CEAdgAZDUFFjNKEIZaYwQBQOgZw6GM1lppbULfZ8wRI5dSEgyV4lrpSZrEXJ+GEfswIk7ZiEpqS5Esh7EfP/v85VB10pqLt2/akedlubo4244D4GRCUwtMvmv/D/86e942zfXeJv6uGyQSyWrqR2I4HqjnBpOp5txIbgHChADGLLBKAgAVxhQbZQEl2DVWWUuMhgAYg6AB0AIkDeylLbjtFPhhEE+D6pALoI0pkhQpaYw0GlOpATAAGgMQxAQ/A8b+x6gN8A/AHgbAsjk97e817GdLxgXLcwWlbfomCmdJMmPM7fteSul5HoSIj0YpE0bM9XDb9ABypSVzXKkZRnQ2mwMAwjCezWZ5Xq3XF8tl0NbQ9cI4cbqutxZ5njMIrRV3nSBLY84H0Q7tWHuOi5HbtXvfy9IoDoKk71ugsEs8AI2xElhAiT9LJ8wheX4AQCvdSSmtIQ5NhRBCdHwc6qpNktT3fWMhxFKqvqoqRiOCvEkWOSzo+56PuipbKXWaxZgo3w+Jg4LQgRgxF0EIhWoOxy0lfpikQkuMkbGcjy0f2ySeY0ta0WPbStVoMwgh4jCL4xDAPopmcZQW5VEIOYwDY/7y5aosOoJJ0/R1WfkBcz0HYVvVLbDI9WjXDUEQeG4ohMLIubi4qOoTIex4PMZxGEZB29bGqGHQcRxbq87OV6dT4ZGz87PXD4+3D0+/czzgB94w1lw0lIGukQh6lxevIWDbw918PhVyOJ1OaRxpOx6Pe4yxtvrq8mXb1V0rL87eIYS1VswhwmjOOTbAd1xtpAa6Gpum77AmAKD16iII0t3uIISeTFMIpeHGGhSEqe8lbSOsoV03aK2tIWmSNU2DIMmyTGsNLNbKtsNhtbxczF4QwjZPt47naOszhzxt78MgDcPQh+HT9kboE5dxUwtM9GJ+5rAQIeZ7kTVmPl8yRgbRllUDIUxS31jWde2x3BuNurHDGCFg+r53Xffq8qLI6/l0tTvcPGzukzjrBjiMeTccHh4/BkGEsCulqusSYwCROhwftO3W50mceKv1/NONKyUPQq8oCkrdKIrqah8EwXoxPxb5drcLw/Crr37WjUPd5FEUKSWHXrDEj10HAEAszvMTdSwwR2ijn/3sZ9989zC2jeMQwiiCzFroTdIwTOtqQIh4ntc0LYSI0QACEoWTwEsoyfuO90M5m6faiKLIXZdxMeRF13YVxpoQ9rQ5GeNYwCjzPv/sl57r3HzapMkcWJWlSVXuGfV+9tM/jaPp5v6OehBjfCr3fuQoYUcxAgPrtnKdcJpdJfHM993DcaMtK+ve8dpvvv0VY4xSNJuvymoPAV2vpxixru5fvb3E2BbFCTPY9oIS/+IiEmKM46huSt93g8ARkq3Xayk5ISljQCkzny/3h401cBi4gS2E0Fo0W5xHPQPgb57rkpTCYctpFg9jl+enMPAgQADoi/NXj5ubvDgSimazpKwO337395jKt69/4fth1/XW4LP1yziOHx4emqYiYeCdrZa3n677fkQUGasssp7vGC2kQF3TMeprraWSQkgpq7Kon7YPWZZdXrzoWlGWtdbW88IkdiDEAFhjVJrFdV0DAD2PUkotQMvFOYLu+/fX+alxHOcfhmgGgQcJ2mweyjKnDGWTZd3uJtmkrmtGIwtNXh4IxUIVmNjz9ZXR+O5x8+b1Tyy0j5t7TITnxq7rjoPp2sZzo8Pu8c3bl5vtAUBTFIfn8UDGGMawzhuC4jgEcRIV5Xa/24SRAywxhjhM1FV5df4iS9f7x67va217YAfJZwgiijNC0IsXr/K8dB0/jdbXm+/HkY+DWi0vuOiZh58hbpjqIHCFEJPJtK6Lvu/WZ0ut5W5bhKEfRU5dt4y5cRzv91vHcSBglLByrCilaZJ0XT2O/Pw8IUy+eHExjN3hePf4+LXQR4RANrNFGXI+TLLZ4XAYen62Tgjhi8WiaSoIYZJk1kDOBYRWqrGqBy1BVTaXF2/P1p//9tfvF4sFJW7b9jMvklIZYxBClFIAbTcORd0gyFbzBaXUWsv5oBQvm5q5DnMAxIRYPI6gH7iwEEEAIKXQYgwhQQBA8/sHAMAIHYbBWAghVEo5LqWe347SkePSpT4kxagoJnDQA9JT6oWTSXuqO9UtLldaod3mMVkuWiNrobxkihGAijcDBeDHOSZVDb2QkUOpj8e8ELJHvhOdr8vjwSBEfJ9FkUawGwcNIKKEMQahQb93qQAAjDHWGgKRheg5NV4Y2wldj6rhdqvUUWpFgWOJgYgiwBChAGhjjQHKKmgUxM9JuchYgP9HjI3+ob0BAHh8fHw6PAhVxBniymozUuw01WigevHixdjDjx8/Emr8wB3FUBRbLvU4cog0Y1gpnaSBtQYAMwyj54VpOunaYbc9tc2IIAt8tts/uGTVd6Lr6qpqAo9aw/u+Hkc1myLPjYQcmYNdDyMiu3YEUCJkgyDw3GC/O2oNkjRWShholDIOC5eLl5wP992tgcPApbVeHE0cGrsMa9Mf842UUmvtun7bKsnVqBoLRBAEQFPHhYywPM/X6/PpZAEB5aL79rtfBZGHqXM4bMJAL+cvpZH1aZzMZ3w0bdchjIUctZFaS87lZ68X42D604hgsJifWTjByD/s67rLXc/Opmsh1NPTk5Bt21Wr5fnr1+/yY5fneT80zHUAsACYh8fHNJ1++cXP7u4/Oo5zOBxdZ1ytzsIwPOXbsjr8/D/9T06nQ1Hm19c/SMV//vOfd13Xtq2QPQDw6elwufzFen5ZlgXn3WThQmiHoUPYjLwWEixm8yhM8mM/SiGlHIYRI2c2WxxPu6I8pmk8m74xSqVRiu0Q+bPdbrdcnUGkj7vrwPOGcTBqdD068Gpf7MPYa5oxDLLjaVdVXRgkEIy73W46zSCyrkcJQUoppURvhDbj1YtF23BGfd/DeX5M0uDs7Oz+/vFpv5stnKI8EhxJMQy8zcvHLIuF4JSSZxqpktwCmWSIj43rpn6AhBCBTxCkNzd3TVV/8eW72Wzy6eaaUkMISpKEi1ZpcTodKWXWGmMApfjFixdlXimpoYFi4HcP3zuu2w1HsSm04f3QDcPA/AskERedBXI2T7QepNJ+SLbbRyWJNr2UvB9a12Oc874f+35QvJnNJ4fjDiCitLi5ufmzP/vzth+stVLKYRik1HEIIcGKCz50797+7ObudwMv4gh+vPm7w+k2jjNgnb4rPTcwGmezZZbO8+NJK9F2J0i5kmi+OJMc5ccRZvHF+Str7aeb31zf/i4IorzcQWR//osv7x8+GdtZ2PNBXJ5/TilVYKi72lj/dEK+l7x48ebh/qmum64b/+wf/QUlXttwBN3T8RgmCeKW84ERh2HKe8NF7Tr+88xAmkyvr6+1snWTN+0p8VdRlFrEhrGGyNGKB4GzecyNAePY397e+pHv+u717e27zz8TbdsPdZyE/VgAqIvi1PdiPlsCSJqmgRCnaVpVjev4L168gtDmDT87OyuLQihdFNU/qFGd1jqNXr59eflv/+pfAzPc3V8bK+jWGfrRcZwkCfu+7Yf6sy+uuKwwopwLjBxK8GGfSwH4aMJgSogX3Tzd9EPlur4xbhDEvh8K2RoNyvwEAFkuJpvNxig9dB3CIErCbBJRQl2PaW2FUAiZqirKsrPWTudTRE3X9w5N17M3YsQ/vL+ezlLGSF5sTvl+uVxbq7Ns9g9e7pymqfrxRBnwvch3EAapEdajaRhECEHHJXWTe54/mcb7/REhNEmDvi0QBsftw3q+8Bw/TtPDYVe3O9fD1GdCIy+YW9NTBsrqSCixQBmLsih2fTmOAmogBuk7vu/7dd06Ttj0XRinkODH7b3re4YowWWQpAPfVDX1nNmbz97d3f72mN8tZss816ftXmvZpV7PmR8uILJc5kYWStCXL17zUWtly7LUEnpk8ertZ0+7TduVnj8tSgmBGcfe8wI+6mHc9J1HsP/q5RcYO/Xp2sUhQcnQqdPhWumROXYYa6nbq8tXbSNGXlxevvS8gJLhxdUXlHiX714/PDz0Y3l+sfzw4cNzqHTXdYwGUkprYZoFs/miqDbYgfs8BwAsFitGsFV87LnrexDCfmjK6uD77mIydxhxXW/z9NT3vbGq6xotmUOZHi2yCAPRKdwNaa+dzGDp6MB1fYSNkUJxpQzGxEFMaUMR1s/0UUSssQioiFgRuNgCTxmNEcQYOpABMFfqqRmjhETuqh+EEuP8zYwbnHOZwEq77gnjoq3+zf/tx+mN/9X/1Hlvk9fz5Xe7AxDNxeUswNgie9weO2UnyxkW45C31nERYQBQYn0lB+o60NMISmCskhoCijBGEgikISVQGVGPXNISur8ZypsSGhISSNhoZg44d0Cse2w9aS0YpRqaaRpQlxprMARYW4D+e1ys/MP2hlb/BQDGItyM8nFzfNx8x7w+SgbmgLyspdBdX2JiPDrZbjd1XQ+8DkjgOKnREkGtVR3FLiHwcXMfBF4YrZqm6/oKoIF57u5wM/TSYZ6x48h7pSSX3PWqYZRxsPadBSFE2wogG4QJF0bwJgoXxhhjFIZI6zyNX428rvqnot3NVktKLoa2laKVNrcGcT5uHm8RQpE/kcrTUsTuOgymgZ8qPewOn3wnAQmihPW86vp6ki1EKUJfdm2Rxksu3MfHLbLIaJznx+3xkTlYI7M6f911hyLHGJKqPkCIfW9qjAK2k/bhmBcOySbZcrWcD2OjrRWmW64uJ9kqaufDMCg9INZOvKxt2+3hu4maE6cbzUM29z0vaCpTlnVRPZ6fX+Z5QQhR2nheyGhYlb1SbVXmr64+T5Pl09N94LOnbTmM+5ubrz0vhBbOsrO8OjrM6/v+VOa+A6tmD3FXtJ/+6jebqtm+fDt3/czoivNR8tYPPT8g2uq6GeJ4Gfk31pD59Mr3j91YDUMThROPLbXohrFJlq/n52+bpnl5QbNJst1ULoyhHRGBiEwm08X2/f93koaUeJP1T/uhhghy2YU40NZQ5qXZgmJyPJRjDwkxSZJtt5vZPG3q/nTKX74MV+vZKX/abp+e/ZBJGjAScTHsT98ihClhq/mllBJAARVt8iG5yKxjmJNCmB37A8Ijw4uqLiDYdH2rpF6sV4fj4/3DdZLOPDfuh+Lj9e+apgm8ZRBEYYKwTspqFwRo5NVmd42orqrGdd3IjQDk1tp+0F3fUgam2QqbNIl8KbyiroZWz+ZxWRVDq3xnQhlQur+8Wkth27aHEGvTSV3N19HN43dtM7x+9Rkh6Wwy/fTpG8+jCMGqKpMkxVhAjCaTycePH7PJLI3mDE29aBon4el0Wk5fWqCq+paiGcas70bOh083Xy9Xk/1hqxVBQElOh86EGd0cniCEbVeOvCqLfjINXc92w3E6WWmFrHYm2bosy93uMUnaFy/fdi3aPR4vr5yXV0tkXxmtttttFPtBGA58+OHTt13Xna2vluFZ0wwemfgBs9ZUVVW37fny80mcFuXx4fHr+wfbNp0c0PnkF9VwSONlHEdP+w/WamCINuL7D393KtS7V19w2w6qe7V+VdelNUOdPx72ZRij7eEwjKPRM4dOfvLFxe3tJ0s0NM+ARjDNJq7rtm1rjPGdoilPvKusInAo/1CmhFLadJ/u/t3D9jcdP2CFIYSLxVLrOkljAEzX50JVro+aCqTJ267rgoBlWTLyvizzqukIo2V1IkoaJQGCLPAjSvxhENaa4ymfTjOhdJam3dC3fYcQWp2dWWsuzz9/fLy/ub2+vXkkFACgR9Eao4dWLxaLyWTy4cNHwc0knkRhFq/WDa+apkozT2mJMVS6jyJP6z+mxSothRzC0G+azg9cz3NOp91iOVPSSCUIIX3fIUggRDfXd1Jqz/PGcQTAPG7uoih69+qfrRYviro5HP+9VshawBxYlHvHnYRBgInpBzYOwpg+ioL8tHc4GMdxuVzH1KurxgLpB14YxEW574e6KCrPDearN0HInp46a21TD4yyzz97vVzMv/l6tNorihFDAQCI4zhOQoyczeMBAHB2vqjrAtrwfP12u90CKMMwztJUyPF4PCrhJFGw3zZtMzguEWIMQs9xnGGslTJJFAtutZJffPYnzHM/fvy42X28urpCht4/fEqylBA08FFbQ4l/f7drEiWEAsAcjpvt/mPbVleXbyhxgiAYx5ESJ/CjOI6rqlFKJEnWNA2ElFG3Vy0hSKlxvXw5DMPxuNdS+KGHEIj7NE1TzwsOh9MwPGgDADBhFDRNFUVR27bzZA0Aqk+5tQ4Apm3bvlerWYYghBZpJaRWz70EBIl9toFY8CPH8/dft+NAowGUBkKDEHYYjlwsFfUcLTTsuW0G0A9QajBq1HBYOjONqRhGx03/sGeK9dWUoq/LExy9y9mqY95+mys7RGk0X4TbH3Zu6sSzlA/dAFsaBBBoGoQIQQgQgBBAbIyRylhjAUU+xQhArmSpxNOgHoTZFarTrpVj6NDQtRlzQgYCjTwGpNZKjj79ESBmrZVKU0L/h6sNCLU1Ax+K6tQO2zBUBg7ajELYcRw451Jx6mDidUV7enx69NxgKIu82vp+gDGdzuJTfuBCez7FBHZ9o7SAEHt+eH/36LrefL6UQg9jyxzKGHWNJ0Y9iS/P1q/GqT0c9mUlAvd1nDicy9APFotVVVWbzYPjOJ9/9tOiaAygTVMZgzD0Pc96Phu4woBqC4QQZVlqrbMsoZSOvA8Cz9gRIjF05f7wOF+kq7NlXbVPm3vPjR3HcV0XICsFaNs28GcvXlxyLuM03u+3nPOuE9RhbVtrheJ4kqRTwdVzk8wAAyEiKBMCAuhfrD83Sl1ff5SCMJLWda0VhoBorYUYATBaS8Zw09faRFGUAMgRYkaDstoJVfZDdTw669WVlNYYM5+5wzA8bR+GoX718s35+TkERCl1POZpMkUI5MXx3Atd1wnDyAvx7d0nrSU0ehxl2/Xv3r2bTWZff/11nNA0C8u6GYa9lDyKQkK11qJq63HsJ9k5gNxxk2wS17eH3eGopaQk/MlPvqpP+vsP/+5O/JCl1fnZK6WcsXOzcE3o8mn/LWZ9Ek+qqhJcI4Sz5WoxvTged3mx77rBdXjgx4IXfTdSzJqm97344vwijmMhBLDGWiBVVzc5oZnrOpPJRErNaLhcLgFUd3dFHEdBEFLiEcJubm4IIT/78j8VkkvDx7EfRJkkSeQ7hBCl2zAMlR66roEQSykDP12vXjRdDaFtutEYMMkWRhOr9SRatw13HMdxyOZp9+ykjZPQWtvz3lhpFNbS/fzdnx6Od5xzC1TTNFKYMIwJIUpKPpowDAkKtQSDAY7jIAgpQXEUp9mL29tPD/c/zOfzy/PXRd4GQWKtFVwyRuqmoNThXE6yeRzHv/7132NiMsSKchuGHiH08vw1tL5Ugzbt7nB3vgru7x+/+skv2rZt2oJQI6VM4ozL3BqubbvfNYEfOT4f+rysqun0inP+29+8f/HiDefjhw/fx3EspQ3D0Bg18uFv/vqvXr569+btK8dxfvOb3zFXh2F4duVsn56YO3ncNB8+fHj18s352VVRVFq3hJD16ryuaz4af5W9uLqczSbD2OV5H4bhbBa6jp8kWTOcMUKq5r5uTpTSF+dvj4cq8py63iLodu2olGnbtmm66WRJiTPJyHwZHk+PfdfPL6dRMMtPpeN4iECllBCKMbbb7ZRSP//5z/u+P+Y7S+DFxZW11iR/BIJbg8eRV2XOucyyBBMLLEyShJFIG/Xp+rtx7CiDCNIo8pbL9eF0czw8cdFRSi3gTTvyUfp+RPp+DKP47Pzt9mkvhPI8r+vaKEwgxFmWUULfv/8eQvRsW+Vc3t09TKeTC6UgUtoIY4XjIoQRxU6chHd3d0rJIIibtoIESjU4Dp1MzyAemw42bY6J4bw/t38kRXqeowOvaQcIbRSF49hboKxVZXWaTdd9P/wYgWaR6/oIiXHsF4sFFwNC6Je//IXv4q+//dvHp4MfOpPJRKp+Pjs/Hipt+qLkQoxFUc1mC2ttXhz7oRlGG4ah1rLve2ONBWQYunEcuyYfxzGKo9VymRdbqS2mVCjle0nTdG13PH677Vr+L/7Ff/709BRF4XyVfffdN5vNZrlYx0lQ5OXj49Nseo5hvNsW08lyf7zXWoeB13cSY3x58ZYQ8On6e89NIBZC1K6mRdEYY65eXGmBOZdxlGLkdY3abkqLtTY8Lw5d1/zkq3+klBxH3ve9sVxIoY3w/RAAkBcHY/l8PudcjuMY+BFCiDFXCMGYH/iwG3IppeDW9xzXdYexe3y8d1yWpcvN4z2hwHFD12GUkL7lZ8uXddVS4swvV1Kr0+k4n88IQVEUWEPTaN6PHOYngmxZnbhkcRKMSlOpgAVaDghB6rgYY2ih1ubHLxhBAC0CPzYApBUAWASBiy0FVhMkDTAapT5QACuLBkkHLjVAo8Et1990oqi6kYq//9/8CNn9n/yvXwhKfn2spdCLdM58/1g1trepH4d4XuwrhKnvuraxFgrmYS+ACBiMDEQaIU2QwRA8p6doCxXU0ALRDadebLi+FuSHit8cZe9SqkUK5TKma58sPBQC4lDYtdKjJI29Z4g6xtj895ng+IdqQ6r/LcLAAtT3fHd8eth9V3Wb2cQ1dhh4bwZlDPR9Fwyci6Fq9oy6jkPmi6wqO6MRpZRzWbcdwoYxai0Zx5FzzhgTXN3f7V0ncl2mlNBGCjm6XrZcrE7HQvARAHR/f0sp9UOCydT3wzCi290mL5qiqBBCEGIlUd9pKaXgklLHWqj02PVKUCr0iBBGyC6WWRylu92ecy6EStO066swjIvqoevr+TzzfK8sOgicwE88NwYAMeYIJSAgw8CbpplkM4xRnh+Gsc2mk6oqtNZ3d3cei1dnF1GY5HlurVVgwBYoCTD0AtejJCQQc6MQIggyzvk4CIzG1fK8aaqq6evm4LjE85yrF+u7m30czrLkqmsHCDHC0sKeEKKNJIRIYRCkBHuMGq3LIIgo8T58eM+YFydhVeWOG04nHsaYUgwBOJx2Ug2c98PYCSGm2ezy6soYWJa577uE6vuHT66fSA1HAaZuVLeV1gJjOurq6ThgKurmBAAixF0tXmglIKCLxQIpzhw4W3qC559uWgTin3x+db76/Ieb9zf3CqjuVDwgbH0vRtAJnHOgcdcMSTibT1hdd1oaYGDXtoGfMuoqZfb7fdM0CKEkScIwpI6sqqp7qBEky+USQbbhu48fbhZrP04CJVXXdZQYhHgQhHGUMhoei3J/eHRdEkZBlk6toV07zmYB5/3DJldKPE8FYugZjTnnhElMFRCY0UBBxfl4d7vrhwpCS1nquUkUZhboZ1dX3tSu6/pOdnb5OaNE9LfGGEulF04CnyTZvK7Lqu4DP14tz8dB9WPHOT8cDkEQZFmWF4dTvqnqIopm8/nF8Xgaub64nG82G4QdTJjrunzUwSRSynDO33329uOnbyEy/dACAKyFELDATz1/LmQtldBav379Mkk9qTrXpcfj4e3bz+uqH7q27o+Oe5kEFwhSpQuHua8u14gSgr3zs9e7/SPGmFCQTRJK/KLc13WutPQDZ+hbwXXXDleXr3anb0dev738rGkqC1Tfj88J6vmhrZuGEcr5UJeN1mC9eDGbLa5v3x/z3TAKxw26nsdx+uLV67IsN093i9k0TVOHxnE0WS1f+Q43mg8cz6bnnHMA6ru7uyRJrq5e3t3c9n0fhA7FqecABII0WUj55LhEKG6MOTs7G4aBUlqcjt9//+1kmsZJUJe1EgpC7Ln+H4pVFGTp1Tt9roviRCjI85wx9/r601df/pOm3D5t76bT6Wx6HvhRP7TX1x8tLorqYIE2GrRt6/u+47i+75DFYrHfb7dPp64bGWOc87KsptOJ0EIZgIDNZlmSZJvNpqxrY4ySP0CyaLrGdX1CCDDMasi5ms3Tfuy04cwBStUDV7cPX7+6/EyIkkmvPO6MHuMocB06DKMYzR9WYoFp2qrtaghxUZwQolLyqi6EHNdny4f7reu64zj2vUmShBBUVjnClvPx8vI8z/PH+pFS7+e/fHl9e73dbS8uz6rqdMqPbggJJIw5Uur16gpj/PU3v1rMz6Xmfd/uDkfXZcxx227gowqCBCHiOJ4xpunLwyHPy2a9unrx8nWdV1I+DWNdlq3vu47j9H0XpX6xLz0vwAh9uv4QR+nVixebxyc+mumUHg+5kH3blU3TQAtevvi87zQjuG4Kx3HW5+u7+49t23qRm0yysujKsuxq/tm7n2IMfvvtv/c83/EBV/aU7/u+fvnyJbDo48dPAACEoNCH5eLy7ubm9cuvPv/sZ8ASiHTXNQBKIRQhzHXd2Wy2fTo0dS+lfo7ljCIvDBIIcVVVXIzL1QQA4HhuHPsYwd1uBzRk2Otrbi1IkjSKkn7szs7OTqfDw+PD+fl6Pj1TSkEIwygADsO7BhFAXEcCNCqNjMUWAoIhhFpro5QBP6amAfNMA7MWYgAAsgAiRCkAGEBjAQDSAK21r7WG0CBgPKQMtYj2GjejARRuhpKFwd//fsP85Z+9M9KUfSqHkSix3T2JocxcppFq8z3qq8V8NhYDyEs/dYMs4kQzgAyzGEBIsEXYPNNFEQQQAYugwT0X23b8NNrvGvOxwYcBIaF8xy4ZvPLhyjETilxErAWtFhBRaIFR2kKLMUYIGWsg+DHX/r+7+AAQWgDbYdzujsdqb2CdzgyGvVGDMRIA6HkeQqgfIB/lav3ZOI4IjxaEjkejMKHUuf500w+b6XSKkAshJBhoBTWCgpuL9U9evHhRlqf7x/dc1kL01towiLVCEDCtUNsVFoxh5GLkU5ptNtu2q12XKq0458PAPdesVufWmnEcp9PFMAx932vNB25ns+nxeJJSaqvqtjIaYEz7sYM1CoNgGNr9YcNFn00mStmqEBihdLJqmx4CaTTSEgd+Nkl9jLxTfqiq4vr205/+6Z9iTG9vb6MoyPNTGoWMJNunYhhEGPpREFCGgMWdPBDMKISPT5+sNYRqN0D9MPi+73leFEX90GCMx3FI0qnrsdOhdZi3XK60tqdDG4bA9dgp166TOMz7dP2D0dB1orYNVsuzq4u459vj8TTJZk9PO8fxpvNF0zTj0EtRzaZrpYWU2vdD13WOx2MURfPpBXPAp083abKcTqdN98TF4Ppx6J0tpv5kMinzb5QGEBlrVBC4XddtHh7+4p9eZml8ffPBaEmI/u3v/lbwinm9Abhpe4+trbHvP/7t+49/O8gR0lM6oXWzT5NpGMYERYGftk3NucyyjFLndKwVM5hACG3TlGEYI0iNEVXdE4KKcizLYhSFUioMYsdx3r9/P5vNXI+0neKi7btBSRRFsecFGGHG4qZu2u63T9tbQq0fZ36Ii/oaUoe4siyMNtz3ojD0rUHjIAMPF3mLiJfnO4Sl64QAINfDWRo2lXEc1/M8wQ0ETHCBCTDGuq771U//7O7uLkkmzyGgq9VF37fTyVnbtl3LLawwhtNpVpbF8bjXCkapU9WVH9DZIuj6Y9M9pWl6ebXw/FlRFEXV/eTLnxmDDCCL1XlZH6JgcXGWMMZOp9N+38wmc2QTn12k89XhsG+a6tvvfse5mE4nw9hQ4jOHFEV+c3Pd9dVqtYiTSEq5XK60PkBos+Ts1dUvHh/2dQMjh0Zh+s2Hv7o4excGiee2A9+t13PBZXHKx74fRwGJpYSFQZyezXe7wzSbaa3LKn+8qx2aQggh0GkymU7nL67eff/+t5QBQkFdtw4LLcP5qQlCl3NJKRYCEuwOw/Dp06fd7smN+ShOtg0Ynl2sv7q6+PwR3v/93//Vq7dfAIubppnPM9/3hRD7/R5jEkXR0OuzsyvfXRwPVZYOs9msKPf397eTyezZsMo5X5+feS7b77cWiOksZYwJoYz94zHNmEeYv9s/CTn6QQSATdNUcFMUxcPmGmF5dXUOjMdHI4Wu6tN2f/v61Wfz2dn9/b0x1vM8z/MpwwQhoLXd7/LJZGKMwoSuV+fjOGLEIBRaa8rwMDYIgfXZou/HPD/t9ndawclkAgAqihJjHIYJhFjKVoqBMcTNECX+KLcPe9F0RVELAHQQOlmWNfUQhRN1OP1hJUqNwwCLvGKeF2cTya1SRnAFNL69vut6YQxoh75v6tVqccr3p9Meoknft0mS7HaH89nbxXJ2Kk8IgTgJympnjDGAY5JYLRmL0mSKIOvagaDgZ1/9o+8//nocR0qdOIrbtseIXVxcUMK04tvdpqlbiKjDfIIlAOh4LIt9MZ1NCSJRAMRQ/v2v/qodmmNzczZ7Gfhh21VGAyFHKTmlVEq9P9xai4tDk03iMAwXiyUE5GnzxEfp+c58ntZ1vt9vozRxmE+J3zR7AJCy8mHzASGkbG/wiNhAIEwznzm27ertdj+ZTDCxVX0k2L27fVyvXmOMf/vb37quG0Ux57wfhiiKnjfQMPCuG4AlzxE2UvCW94GfIGTHsZ/NZtbCPM8nk4kQfX7Ku66fJsvzsxdlWbdt6ziOEAJYxPkohEiShFKqtRzHTijTd5UyXho7HCaDGjvuGQEghaFPHUoRAFJKq4EB6sdDFcJn/KiFGkJIwO8Bn9BCgiwExFpgga+IBtZAZKy1FioEoNbCCH/US8f7P/8v/6vn3fJ/+a//5wQgPqrVqI1mCCHxKoUGEmXLUyn70adTbtQ4DAwSaD01QKS1byyBiCpEAMDUUCwxBZgSQLCPfW1wKch9j97X4/uCn1qiBPVVtwqCNyG98PAEGx8BBOwwDlCLpi5x106yiDDMOUeEEkz+uzhV/oN4NguA0Kos67zYj6qirmEueHbFYYyDICHUqapKSj2drHx3XuYPlIZ8lFLJfqhd6zLXMmfiOqHgJgziYDKpqsZomySTND7fbhopdRTOQCcRMpjA7XZ7vvjz9Tx2XTcvH0/FPcaIYMI5H3mlzUgZhRq4nssY4VwfDluAkDGEEh961Fpb1sUwjqjCI+/qujbGIEguL68AUABYTGAcpbd3HyAyfug1TXu2enuxnt3dPgEzei5xXFJWI0au67hpOpHC7PYPRXV6/dmLvD7lp2o+nxujHEYcFmXpvCz6+WwCgBFy9DxnNlvNYNI0HaUsz/NnXnHf9/3ACUVCjNfXH6V6vu5MPM/TSgOdLuYx5/x4PAo5DiMUfDpJL7J0pUzzzbd/L6XQRriuz5g3DupwOE4mE4RQGPqLxeq56SulXFy8sIAIPpytz/uhu7+/nqSLLJ0S7OWnPcHOi6vXSvPudm8N1No4joeRezrWgtskzY6nrdZ6tTo/7U/L5dn52cXpVFDCADF1cxCqHEURBIHS1AJgAA2CiDJQNdt2KDzfwRhDgAU3CDqO4yhTKzGuF0uHOqfTKQ7DNA33h0bLnrqeNr2yACECIFAa9OM48k4pizELw9DznZG3CEs/IP4IhrFq2vHnP/tHCNLdbtt1XZpOwyjan96Pchv7ntDy9uHj/lBOsiWCbJ58uVpf3j38UJbHyWSmFaHU+ekXP/90/2G7/xBGbL0+G4dhf7g1QeC46fn8bRBEh8PucNx0fZ9mkTGqa0VV7Qhlvu/1vJR8vL354d3bLybp5c31X52fn0dp1HW1hWPTFgih2XRFKQ3DmBBUVdXD5iPGcOTM84JnD47vh0Koph4gwNbCMIiRDou8Hfmu66ury5cQuIF7AdQKmtRho3Q5l/Us8SGQENoknmyebpMkyybJ/f0tISSO4+3TvirGIAkBjOWAj4eHrq2NNK3hN4/fajMW5QlYT0kTx1lT999+88Nn737O3DBM4jgOvv766zCQ3JVcyIfHRwD12zef7fZPx+MxCLzLyxeTyXySzU6nkzFGSKG1pNR59+4dH/Xt7S03B6PBen059KLrOsdxMba+7zq+CjycH0+TyWwc1MPDXVUXZ+uL1Xrxq7/7W0xMFM8oA03bWwsoYUYjrQ1Gju8xpU67/WYyDe8frseh0yq+v79lzAUAjGNvgYQYOohZbca++w+G0saB33799XQ6vbp8/bS95VzEUWoC2NQVc8BsnnZ9VZdFHM2Yg5M01Or1L3/+l8agupRxNCXUKiX6viV5cZhMJuvVRVWXNzef3r17Q6nz4cMnxsg0mbVdURc5QjAOQ4ptW+fWUD72QRB7nmeMoQxw3lRNVZYszWLXMWHknA5d2+UIocOxH3p5frG2VnPOu26wFkCAQz/6w0qaphZxsFhdSsW11taidDIlAHeKF6f+888/3+U7DWQUzPPikBd7x8VlmQdBlGUZQo028njcl03l+h4EZBgGSujFet7LvG/avhsppVVVCKHiJOyH9nTae17AGDMGAks9zwv8cBh41bQQMddLtMLGmPX67M3rzw+HQxxHTd1ffPHF0DZd1wMoLRwhMpwPrutLqQFArkO1lv3QTScrRO3N9WOaLC4urlzXZYRqrc/OzqxpLeBCdj98+M513S+//Oru9uGbb3+Iw6ipO8+hdZsziqmLq+aBEGIM+fTpBwv0JFvMZrP5fPnh4zeEQjFGL69WUuqqKvaHnVLiy5+8I4zrVj/zDPI8V8owxgI/c11Pm7HIWwDAbv/keU4QBHEUGWOUNG3baq2runv16s3V+avDIdfWIgQvLi7quuZiUEr6vj/yFmMMgKnrsueibWuIRMCWAMKiGLUoJcHMd2KPIoSM0VYbaMAze/RHJNbvNQcAAEAEADDGGGABhhhjiBCAEFMCjIEQUAAAgAIghgABcMLMl/+LvwTgR8Fxnulx7ICL4ehBiIUGwvc0AFJYGrmu6ztMdWVNjPEJ01xYAyl1BARGUk0QFQhqPUJFiCYORYxExH9o2q939e9afcthXgpR92wECyrfOM5LDy4pCPBzqoAFSpihV0MntQKBA5FD8LN8Ms908/8WAth/TN2wADbNULeFNAWmvedAPio5SqCRsqCua0LpOA7WQAjoD9//Tojx5asLLqQQbddKa13GZODNGWN11SllGSUYORjj6WQmOS+KIsuyLAq16etWCK6tNsYYbcThtD8VD11/QiS0QJXVTsjO9dw0C4uikJJrCyiFxgoEnCAIdtuTNhwixUXveG4zdFqMjLEoTBzHnU7nj4+PSo+Om9V1q5QySEGLIMR9L4AZGGPamCyLlB5OuXYcF1hS1/U4jtTBUeZV9REiOp3P+oZ7Dk7TeL6YMocQCrIsadrqcbPjIkiiMIrnWnq+77eNAEARQpSEglsAZRjQ07GczWbGkjD0+qGW0iThqq6OTXtkjC0WU6l4P9RG+kYXx/y2HxpjFILOcjm31mye7qSURVE0dff8AtZ11XK5rKrTfr9fr53JZLLdbuumCP3kzZs3jDllUT//H202D8bqqqqatsqmZ8B2+93WGO0wa01PkHYZK477JJ5JYT98+IAxRthqrRbL7Jg/pfFajJiS8OKMEeJEwczzgts767lx3wnRoSwKmqZhFAneHY5HxcMkiQG2iCILdNPX7VgAKIh0KaWMepQ6EGFgEQDacQghUErJxaAN93x2yreHk5BKuK47m0201u3QajNwWfcDQgjEcShVNvKuqtqyahn1CWEEu5Sh42lvDYyiZByFNUrp8dPdt19/812cJkGAjqet1SZJpg6hfOScc86ltZAxQpgPkQQA9p1IJ4kUdV5sCQ74MBqogijRFnmeEwTe8Xi4f7iezZMgCBAip1Pu9hFGrlGo79rAy5I0GnrFe8pNCQCwVldVpSQAAE4ms+3uXguLEVut1mfnP7/+dE+w88/+4p9++/WNCEZCkLHC82icePvdaRjHuq6Yh6QWUpnV+hIhUFbNbDEHlgLQI0Crpiuqx+ksggho3bXy+8v1nxCEw4RtdhV2fMrYYnm2WC1uPl27nh8E4Wy+gojVTQsRWK8WRfWham4AHCcT5nm+NYogiiF72j4yBygtAbCu6xpj9odNXm4s4lLK1XqhdF83h1VwRhmByBz3Q4nLU364WH8ep/T+8b3g+u2rrx4f74QcVrPZ3d1NGPlVVU2yWS/aKEqDICyKEwBovoiFHIpyayx/++4VBPjxcfvy5cs4Tr///tvN08P5+ZkYxnHgXhgYJTD/46hlEPqMQYRIfqq0Ikk8f3raUcoAsEEQDKM+nQqKQ8eFWkuHea9fXXWt0Nqen71UemjaHGPMOScAKiFGxtjQj4SQrusOhwfPDS8vz6s6F4WQamAO6gcjtuNzAtZ6fbZYrLSyp/wwDC3E0vMYABGCzPPo2HW+N/F8pBWGkBDSBX5UVnnbthDis7N1UdT/MMbb94PJZK6tVUpZa6um9RxfGzjPzjBiYTDZnrYD7xeTdOS9MdJxA4wdRllVVY7jC7UfhO6GYX3xEyXo48MxiRZDZ7nGUTizVnddJ1SzWM2Op/rf/+pfKzvaQXYdnmTLIIiapnnabowxh9Ppq69+qpRSylil67p+erwVQkRxlKZnStDXL7/UQP/qd3919uJCKp2f8uXS89xoPp/3Q3U47uq6/ezd54dTqRUWIzwd+t0uV3Jcr8+mk2VV8Lap5/PZfL4UQnz6eNP23cXFZVWVxpgoTRQf66aYR1PHTTe7bRrOPO0MQ6uUoKFTV40QIk7CwEv6vjdG9UPDHD1bJGV12O/3r178dBzHZwg9QmiSzT03Gnrhu5nvja6Hi+Iwjq3rugixxXxhrKrr2nX8LLWTbFl13W+++W0Yhi5Fv/3tb6y12XQqhLBWWwubpuu7rmosgDhNQghYO8Ku59bqpmtp4FvkAgC0lBBZoI0Fz0ZTYK21xlgALfyx1wEIfr7E1eC55QERAMiCRvQWAggBghoDaBEzFpJ/8bMlAACA/yv43wMAPvv+V8iIUStIsHE8a4HgxrgQYKyNUZYZY+SowyzwXJdAxIcRQ0IIk1ICCJFDDXqOYgMG/AjvOpjuu33719vuWocnSUQu/KoNuXj30vkiNBeuTihwKbHQGi2NFaqtTc8d1wVcagRIElpojVXQkv+W+5T/mCgKoVYKHQ6HU7EVeh94MpukfQcrYaPpxFi92T1AYQCEFoCirgDkjgf6oRp5C4B1XIoQEGJEYECQAADquh4HQQjDGNZ1KVXv+o7rkr7vrMGeGwPjrJevlRruHj92fQ6g9jxHCGGsgETstg8AIIgssMgY0Lad4ziYYi76SbyAyBKEmQtaqSGSYuDIwjTJfD8aenk8VEYjx3Hy/DjN/OXZrG53wzC4blDX5f5QTSYTYEzX11V9EGKASAFLNZfaKEwRgCYvDxA508kZTdyq2Gsxxgm92/zw8HgtZOP7PqFa8KZFUgpgjIHAQKilGsIopcQJQp8ylSQRsDjLppiAYWiapgv8EBMgVUcoUEpXVU2YdByqjVU9r6o8iiJK3NBfIkS2u5u8vPMD5nme74U3N3fjOPqB+/3732ECKfP6vj4cDlrrX/7i53Vdf//9+/Ozy7ar2q6Yz+d+4EjJkyRmDhyGATFLsPFC11jedjWjmFGvroYgdHzf3R8e1+tzxkhZcmON53lK2tBfhUHWdDvN2qZpoHW1UYx5DmN+QB1fSjUS5CjFleiNgqbkGGOESF3XhABtBkI1wgQTAqCsmx4jQqkHLIIQ+iEuy6ZuuLXa910AjTEaY9g0RXaxOJ1OEFqIFGVa6np3qAlBDosIdvtxCH2fUddlXhjGXNRScQANgqDrWiGU0hwjOl25jJBhqCHglDqit8LK5WpyKvOiqJI0UKbTth67PvBnWZZRNt7df3rz+kuHeQiSy6uX95ubaWYQlkW5b7o2CDxKHKVIli6NrHyfGA2Xy6XU8XZ3E4RelgR1Javj8erq6qF84oi9e/vV02YrhtEqg7GazSdxHLZN37XjJIF//bf/SmsLHaYU7/oSQti2o5SSUizlYC211s6mM2vg4+MjIcT3Q8/1H576tj1RjKSSgxg576QZomSilERs2Gx/WK4mZdGslldvXn/+7bdfH/Nd09OqKfkok8SFDHR1+bgveX8axxEiEEcJ552SGgL3/v52tb6qmm3bFfPZ0veDu4fbp+0dItJ3AuPou9tPTVNlWRaGJD/l1ggIiNbj2fri4uJFHM2K8oAJgkie8t0XX741xpxOx5cv3n799W+HYVivFlJYqYanpydKcRA6AMph6BjDnHdKgbatjdLH47GqqsV81badFjhJFpNJ8rR9lOqPo5ZVdcyu3qyWF8fDiVHgugxC23UdFx0WGOMgTSJKaV7sgEVJkh1Pm8PxKU0Wq9UKa4cLRi1l1Cd5fozC2cPDQ1VVy+WyrstxHP/yP/nPNg/3p0Me+pGFtG6OwGopRmugRapppTF6HKW1FmMipJQYuB5+8+btfrs71IPjeJzrd5/9VCp8f//N/f3GdSkAKI5jhIEQQ900f1gJpQRBYiGczRZKj8tlPLRinq6/fPPzX/36N//lf/n/iqaM+VRp0XW1NnzklhKHjzLwU2stRlRKgYn54cPvsnQZJY4GhQYSw3joBkSUkL1uR4Caj5++YxROZpPnzqTrupxr13XD0N9uN37k7Q47MaoXV6/Gvu/7lmDjeuz2/v1q+tk0vPjmm4/749NsulDSWsu++PKFw8KPH+7SND0cPm13d2fri91+u9+fLs5frZevr69v+0792Z/94rvvvvV9b726/N3vflOVrZIaQqiNieP4uQ3w+vVrIQQgJk2mTdNjjKJwiihJp6k6cQMBQGi7PzqeJ62EqhZyvLw8e9yUQ9mH4aqu+jicAwDKshyGYbFYSCn3+73vcQgo59poUJal6zkYYyV1XbVV2RvLAz9SqoeYbffHh4cH5jrpJH28+QgAOltfaK2klNZqSikhRGkehiHEBAIuR60Vl8IihLSWhBCXMgihUQo+S0mjESbWWm2MfX6Xh/A5/3208hkHDgBAFmllLADaWM0wAIBAY4HSxiptmn/8j/+DY/v953/y+re/RTSUGkLGjTEYgZAxpZSUnLpUKEm8BGI0cK6tCSah1lZKyXwGpDYUWGSAfc5PIdYgi8hTVT52fKfA0eCyluOhjod2TtCbxLtKyJRZjwCErdJKip6LlrdtV1SLKIBGQ0uAMYMYPc//b7lR+Q8YX7+XHaPRdBg6LlpujnYY/BYWeW+UzjLf81k3VkJ2ymiCXccPK8MBMF3TI4Qwxtg6LvFxGHApRt4b82MjiTEiFS/2J4uPBE4wopxz6lCXpm2tIXChBZQ4UZScTieHhMz1PYaEahz3iWAXIdA2I8FOkqSu61RVxTXnonMcJqRQehRiGNXAvAB0SGugJCTYa5tOax3FIaHgeNq6HvBDh1LctyqOw5S4bdsyTHe7x6rZ+75TFJXDWBB4nk8ApLtTiTBYLpdlVaXhhFEqDaqa/TDwMHUI1a4HgwBzPoyCM+ZpK+qWQ8TbYQdw57spJpALXlY5H8F2u53Pp3XdDr2KI9/YwVjOHGKVjwks69Mp35+t3kDACLW+FybxMksu8lO52z/4oXEdZ7FYjIM6Pz9HCBwOG6VH16MAI8fN+r6fTrPtbjMOIggCpdQwVmHkasP7oaaUCNk7LrXAlEUbJ2FdtyPv5vOp54anYx94Yd8X+/bp4uIiit3b230cpdv9redjCwpt5udnr27u693xXkmdpjMu2zCeSiXb4XSz+Zil8yRaDANRw2iMIIQdj4coStI0nkyj7V4I2RGKpeQSSGNgGEQIMcGVUnr3+IFRZzZbQAjzPI+iCEJmrA7DcLvdzqaXcex/vL71A4qQttY0jVgsVkmSgaKcTqdFUfV9DwCyRiqlKKWu68ZJ8MyY15YzFkOLlBKuZ1yXITIRQiPELGgh0oRAPvb70y0AwHOTMHQ22/dBgOuyItns8uLV3/77fx2EnlR1WR2UltRxHSfUGnhu+uLyCznet/I9wd7T7uaUbxAZNXApSsuS90PbDy2luOva/X4rJB/GFiGUTbzrmx8goI7jSal3+3uhBsfBX3//veeGZ6tXWpHtU55mIULQDygiVHBRFvVyeU6Iq7Xe7XZRGGuthazm85WWF1VVOV4IjRd77zjfWSAwoRDqt28/q6v26ek9QCZOPGstddnhVLhBWDZHL0COC4FYhxl63NxOs8haOw4cYwOQqZvCWuO6rOu6plYQoGwSatsWhxpATSmcTCPGkNIDJhYhSB2gJfDclMDs/bcbgKGxw/3ma0LQOI7bp73RMM8La+FsNrPWllU+DhIANJ3NhWwdlxBlrdVSiXGQZ2fr0+k0Cqm13m63y7PlVz/9pw+Pt7c3G6H5mffHyLPdYXMV/LSu6zyv5/P5MDQQGSGUkGPsTl0nbNqi7ysIbZZOpAAQ98vZSkt9//CRMTYMvVLqzZu3JPAzhPVm9z6OUgBMXbeXl+vb+28+fPdNGMaeE3Z97zAPYdDUnbbA8Yyx5FS0YRw4ruVD35c8cBYzLz4+HcqqHpW2zMbp3MExkhACpvlAPBp5k1myPp1OBGIl/4g2twYGQVKWZZiF293R9RE0QEpa9fJpv5vOQj9SmAoliTHQc1PJ7cXq3Wp5fnd/a7RpO4lJ4LrB/f1NHE2Yx9qmZcydZHQYZdu2u93m/GLddZ2SMI4mCKG6OS3nEYC66xrXCY55M5mdd93j4+Z3yqp0irL4YhzHxSopinuIDCD9zfa3eX5EhCMjPRsZoZt63LaFsVyoBmG+Wk/jOJbCYOC5ZLqefTG09OLiIi8e2q5/2h4eN9eQ4IfHWz8Ip9OZBeaHD1/7vhfG4Xb3cHP98M//8i/KeteeDlGYrhfniCTffPfXfsiSOCiK4quf/GLzdKNtd7P97tWL18cil8L4fnA67aezjCv5uL/j45BNYiFHj8VGkbvr7evXXzqWnOrd2fmCy1FrO4q27Y/CdGlwNvJaG8Ug42Mf+ChN5sWx8r21H+CyOaVpKFXnuVGaTvI8nyQvJtP0+vrDwEeLiUHtcjqjhaSN8oHWio/S+C61RikJMHKtEQAApZSFAGNsALDWIoShND+ewhBYZJWVABoLtFEYWgQRJAgYa5QZwX/TI1TDlTWIYj4+H71CSgghJQhq4yKGXGytjYjz+34DUpYaYxTVBkpMmNEUak8Igx3EVcs5AZApbPKiF3en2c3mCvHP3s5fBCbFo+tii5TSkmBmNeQnrvImGbmz21IXaT/uFSSeDwzQEP04mgIABBYC+GM+HED/8PNr+y+flYmBYdke8/LegHI2TRBxHjb3Upo4xp0seOsKa/0gGfpWjsM8yXriWiQx0BpK5jivrt7uty2BBAcHJdDQiThav3j1aru/PWy2VbMLgsDQ6uH05DAvIFNs4iicQGhvnm4dCoLQM0gW42NIwrbAQJrUf7lczh8fHyCEANuyrBFkECLfy4riRCiUkhd5g6gzncyBAYC1BEGrNSGEEaohuTr7oiiag/prMyJMI8+NBtgqPThUleXt+frKwo56wA1dDVCazq3Vfd+7QQWM8nACRtclvhyl4zEvTNvmAKAkFLghKZum6XgSz8HzXxWrYTxJXeTVrbYzgpnnLa/Sl47v/fVf/9XF1eW+eDietgQD11fHoh5G8mrx0mpdN0etUNerXnaLbNX1htDYAPDx7tdKqdX5WVV2XVczElVjIaUcxSmv7qMwcVjmUlZWe8ejx+IT5zyOYw3s3dOtGOnl1Urp/lTcGquAYZKTn371s2P1eNjfUEf2bdEP2PcSzoezs2mqktJ7evv2bLPZQDgaALIp22w/+n7KnM037/9V3/M4nBMKlFJSWsCRR6DvMqsnWo7F6frLz/8JIz+7e/im64ssIcRpuSgeNx5B2euLf3TKt8LKNJ1gjE+ngwU9JqbtD4hoyvwsuajKJgngfBo2TS25qFUHCD3WD6feasybjlOYEJQwLy+qvGkH34v3u5w5CCLxtNukTuJ60XKyPJ4q6oRhBB43N0KPULM0w46jIYQW6LJ/INgZRExxGviIUNOe6qHn02zmOk7b5NPkDRetFEAIYYHBBGpli7y/vPjMgGa7/xQGSRa/kJyKQe63d43Mz87WdXMk1GaTaVWffrj9t1mW+VGEiPf65avHzf3943eOS6yBGLP7zeMw8CybGznMJlEYsB9+uG0rwGs7S6Jpln66uU8mXpTGQg5FMfCxjaPp23dX28fN0/b29asrI/uu6ftxsBoSHBwPG85HbQljTPT1MLZdx8/Xr6uibqr3CIF+aFer+fbpOJ/PA8dT4jaNHYz6rq+TeCoD2XX9dLawBg1jiyyMvfTq4vPHw2HkUPRj1R0opQS7FrpNIwGtDOih4wrtEwgftt9V5WhEPJ37iC5HkeZDW6sNUD3F2CPeMr2YzWbQukIIydWblz9pmnoynR3RHmAhpdY2MxZzDkcOjJGB7wspqnpvrXZdlxLmubPV5PV2vyub7f3mt8vFVeyv/1C4MKS73UErAq2/mJ/n+WnkNWNKyxAjCqDivA9CzxjFHHQstxSFxhgDOoB401aUur7vI8IIIUgpIcQIIez6xnXdpmnu7m+SMH73+Rf7/V5bnMSzzXaDiffy8sU49kNvjqd2+fblYX+/fSpeXrwNvUlRSAukMEZK2ZdN1+Rdd0KGMs/13TkhmIuBMuSFLvPn6qH+4/sfokrqqqyF6PuBW9P1g16vbdXcz5cuc7yRt5435WTEBFpr42gS+HFVVVqZvDglcfr6zau82Ep5xrm0hitlPJchhJqmOR4P8/ny4vzq9u769eu34zgSxEIfWUP6vkcIfPz0YX1+4fv+dlsBi61Bu+3p8T6/fHUx8o5Q345NWeaTbL1az6t6P4yDEIKSkIuSuWy1Pqvq3BhQ1/16GQDrAAPzYvP3v/lXiNDNhzuIRRC6Tbfv+tPFxeXli6sir9uuQghRx9MWNHW7ezq+ffsOIdK1fJItHebx0TTDvdJCSadpGgSd+4cPzCFGImgczpUYegBsEHpS8rrJpdZl1V6cXXZ1m6VLoEk1jD//2Z+8ufrJ3/z7fyVNxxU95ccomTDGeK7WZ5dGeQiBp+2j56kwJNZAKeV8Pp/P1w+PH7tBP24eXCfIsgwh4jgOc+2Hj9+6LvODuOPCCYJR4N32lCRB4AKCLX7WDUBra60dtRKUUkyg0lZrrYE1xgClCEDg96OkPybFQ2OtVVpCCyDCAEMDTf7n//y/UXA8/PKfLf/dvzbGQAQAANZarTWEEIHnKDNs7PDj7wcYIQSARghAZBHzgVBIA4yAhAMgALsMjTZH4n3ZbBumN81kczwfiknIz+fT1ToLI4YwsNZaqcZBirY3smNWGjkIjoGRiECAEXiGKWJgLYAQGGsQABbY52YP+ofUDfsvfxTZ1kIIh4ErDQFjQo+MaOooobq+J1XdBkEMEbGIdP2olTqcjmV1mi5ShJxBgHHkm8dtlq5cGl4/3mkF/cB3XNMN+SnfKS2Wi3NjTFnt5ouJEKLvOwTg6uqF0abvauB6WTTpW9dCTShVvM4iP4xmXpDsT7+eTLIkDIjjCG44l4w5TauLomI+W6zXSZLlp3KxnHU1ktI0XZfE7ij4ZDKr20ZbhTG1xhgNhmGw1g5jlxcDIfjxrnn5+pd1U7z/+M1snjHqDR3Ceu4Cn9hfe1Fn4HGUNKRzYPHQqabLEbYImXEctULQekqPCCGtYVFWxgKLKB+NjeDN7Q/LlSkPTZrGBthTeVR6dBzCxfDDh2+Z5weemyRhfjoRRl68ePHp9pOU0vcwMPx02GmtxrF3HO/q3OmbPkjn/dDUzaHry7I6uo7vOB7GsG0ra602RBuOsKmfXfRh8uLqVRh6372/v737MJ/PsmymhDmeHovy5DhO0zaUMErp4biNE485eleUcRwfDsXpVFBKkiQ5njqCAgAIH6XFHaUME9u0FUZkvV63ZZGmaRQv2k5qNWDqKaMO22tMiTYois78wH3/4UMQuOvzdT9UGGPHgVmW1HVtrMQYDEOXZqEynlZ4v99KKRmxh32hlFnML1yYfvp4M4jW933GXJcxjwVSSAdFhNCzs4uH+03btmgASokozIChhLrDqBAhWuvyWAuuPS9yfG/gIgqzYRj2u5Iyb7t9mvJRShlHaV0Jh0yTCAouyjI3xmTp4vWbl7c3j6M43T0MbXdyHG85jzTQn24+Gdv7YVL3le+SfXG7L27OX0y7vtjttn7AAFRC6Ivz1+PIEaEPD3dmARyHKaVmUZafyqqqlQTL5dlisf7h/XdtL/p6+NlP/9z30o83f2MhunvYGY2yLDNK9X3vOM4ky1zH01oKMVJKHh8fKaVxHO/3+8/effn3//7XaTq5uLwkBG63266rDBon09nt/U2WzZI4u729zSbxdr+r+5vhcQcBi6PZ6TAIwRi9Em00dN+M3ei63nabT7Ozn375j9pGhsElKxsAVNc1cTRv6o5rdfZuzWh5e38CyGqpJplnjNrtH6whWZxMZ+nx1E2mrG63D48/dF1xNjs/X706O7vq+7YoiigOed/n+TibzYQcIYRaqxcvrhzHubvbh2HAHKuNyat7YEmaJYRQwY1Dg/n0rK6Gb9//3fps9Wd/+s+fnnaH093L39euMJjHs6u+F3XVbzaP80WGBwGgDAOijMQYeJ6nlY2iNPAz1+l5f6oq6TgOwWwwQklAMR4GTiCyTw+Pnuc2bSUFQJCdn79GGCghDqejH0QWgs3m3lr06s2XQy+q3ALrfPXll2Pf7Z7qxeQcWOz7vmj4+cW6aPZFvUNkBBhutvs4iGfO69X5C23h3f3H7z78tijLd29/uj579Ycq3Dbt9cePjDEEHUYBIbgfdpvtD4xRCO0pH+JoikDoukhKKaWQUp5Op77jGGNKaZZlbdvyUU+yeVnWjhMwiqTU3373zTAMWZakSfzhwzVCCAIGgQmclSBHCAFjbBxrAMX5elHXRd+1DguWk2UYhlyOkGjDLSZhGNqh59vd/WIxQ9gUReE68vwsBYiPfLAg8jwvjrK66uI4hYBgCIQzvP/h3xmLozAN3IDLMggJ8zwu2s3TjbYUAlLXrdbacRxM0bu3nydJqqTN0gUCcLlcn/a5UI9KqbpWq1UELOy70zjgNJn8xT/9Fw8Pdwoqzyfj2FqgozCRbcsYQQjF0SxLF08PpySezWazX3/3d9v8wQ9Q0Z4kHB2ftrWMo2XgrpRSWmtG/TTJtNZKca1VmsWH40M/lH5A86LFGAOogiCSMrzffE8JUVoyx48j5+FpP0qSRcRC4+ABAmC0p6Wxz+xvrYC11iJtjVLGQAQhNNpCCEYtwB81hwXQAmAAMBBZaCxA2GIIMMz+3f+n+Cf/4j8WHKt/+//W2iKEAcDWmuerBATQs9wAwAAonhsoCCFjEUIIWAABAAJggCGCkGlgx9B3rbZtKXfl+Fi2h6Nl2zrbXE/t4eVF+naNwxhjYoxRjDBjgOKDHDrDO9cIgDSmEFBgMQIIWggQQhoaaP9DqwqG/8c//GzMvwT292oDAK2B6/rz5UXZb3aH95Cc/EB4gVFc+YGfZUnbi6HnxPGCAEnFlemMCSHEZdGEYWotsNYejk/7Xe55XhDAx6eDuBVV063X61cvP3t4eECwrKoaIcQo86h3PB4ZDb768isxiO12bzSYrOZStcx1TnXJuTcOfBzUOMphGLXWSimlFUbO5cWrX3/992aQWpVRmLke+9WvfkUgCvzk6vKN7/vPkVoIAQBMls6enjZZ6mFMxqFNk4mUT3f3t8v0F29e/eT65gNjH8p6Rwjx0MVf/OX/rK77h4cHo7kXSq1F0+0RCLJ0gbCWqpdq6PvRdYIoCoQY+n548+ozRLCUavN0TXEGAQtDvN3dvl7/+fr8ohqK3f4eE+N5DoTQQJBGYdfy27trznkcB1orYwy06Jvv/k5LzGhACP388y/bts3zkzbSGvfu/hMXNUDCcannBp7nAWDrpqQUu35MCGrbrusbY0yaBWW145IV5c5Y6XpMSq41rOqj6zragMuLV6fT6VTkaZwRpotqowHXRm+3tTbcZczASqo+DNMgyOqqhwwwCoaxRggkaWytbnmrSsi89NXrn51Oh7w43D3djoPAGPtR8rgtzlbRn/3pf3Y8PT0+PvoBpThMkmS/33ExRJFXN0XTVhOWakkJ9ixAjGHfxVprgijFKZd26FWWTanrLyZrz42a+uQwcco76MLNZlPVJ4wpgiRLE+aQSbr+4cP3vTBxHHVdgzHO0nkQerPJ9NPNx7IuoygmxPfc8MWL6JQf+vGkFMfIDcNISukGyA9Y3/dl0TbVvev4dX3kvHedyHVdbcZ+tBCDLJlAjLjs/SDYnbZuqJXiRVEQijiXEMLJZEYI8T1TFCcxDEqPWkulJMaYUepmE+omZVX8cP39YjU5nXJp0XzxUowUEAYAaNoBIzoMHELoMX8YayPVoNqtEP3QPrMly6oKwtAL3O3u4Hrhn/3jf/bwcPPx04eRd2kajxy7bpCmFmOgjXBc8jwf+/LiT7bb/Wy2wIhxLn/y5U/3+33bNlCHr19eXV9/rKvhy3ev2hYl6dlvv/5Wo2IYuq5Vvu/PJrPZbOYHTClTFWK+nGRprLVMIh8hJLWMU7rdPex3+eXV6pif9vubNM6m2RIo2tTj/f3DYrHohtxxEQDgeNperC8QBrPZrGnqpgF+4GjDlR7rurLaTdMIQsQ5V0r17YCRQ7A3mUyW09fz6dndTdn3f7yIuLz4nM2urq8/QWhdj1ggbm8/YgIpVXXTOI7LqI8xVcrutkfBreN4CGPHceq66TuxXi/CIC7LkvR9M5kmV1dXBDtdK4deMMam02ndVacyXy5YN/aIkvl0KbjcbvexN3/58s1ivvr46f00nTguoAwTatyALJZZ3mx2uw2mYn02Yw5CFLVd8bil1gJpRseHuhK7w8nuwOXvV8JcOJsn8/l6uTjr+353uEEIEczSNBFiNAY4Lm3bWoOhbTvGSNf1RhNKGQAgiqI0TW9ubiACw8BdJ4ijTEp9OhaUUsehURT1/djUw5s3b56enqy1F8tJCWrJe89XdXMIQgKRyIttHIe+P4uT5cPTvTZ9XujZ9FxpnMTMYbxpmro5nfJdGAYXF1f73Wkcu4uLF8djzpg7n6/TdCaEOB43nsNG3r9583LgY5KkSZLc38uiOCHGun7c77YX5y9WywsEHcYoxKjrujwvGPO0kI7jAEjyU8OoD6DGGHtujCCzUFogq6pN4rnopRYaQiy5jMKsruvdtnQcL8sirdDZYv1wv+sb/voXb3/3zd/tjztCdZTNOO+6ut/v94vZi3dvXhWn1rC2H9ooiiildZMbYwg1dXNou3K3f1B6YIyladj3rZTy6elpf7o5P79URj5u9ohgbfA0XQyj1lJZI6xGRkEJmIVAa62BIhBxqY0xEGKMsTFAaw0AUOa5K6Gf2xsQAogshJASjSwEGFuAMIDPGI//+BFaIIQgQhY8N28BAgRACyB4do0brX70jWAEIYT6R3OX0w8wTgcEDRit6UPqNb293w7Xd83YWXu/nxxP0+EuitvPXr+4mkWAKGO5UhRjjCyyRiE9Ijsyy52IBpkLXCys5lI6BFsEjXnWORABaKBBFmD4f/r/Uxu/f54/HiVgOs241d1Tp0wEFIeQE4T91GmarmlLA6jWFmFcdjXCyvcZ52OaTl0nRpC2bd/3twThKJyEoW+BYA4aBhn5QRhkVrO65IE/gXhECAZOKjkq6varn7yjlFXypGRvbAOQc7/5pKX64t0XDgyFkK9fvWva+rkQO47rOBAj1nfDJF0aq8uiqsq2boqu6968eLdanisF7u82q9WZtXaz2YRhXNUDgk7XjdZAQhwpdVmWQgjqdh+v//b69jrOSNebURRl3X334d/s90ep64DGViMIBMIaWj2MXRzN27YClrZ1gQHGsSs0Z9QfeXM6tWm8fPPyl/vjbORVPAmSFABoivp0OD4pOwKLhsGk6SwMvLLook7f5gABAABJREFUz9YXUuqqbPq+ycutFwSe5/zw/lez6XkUpQgySuk49nVdv337WRQsy48bbVtjdJIkgkMA4DB2rutSSrWyUolxHJ99s0L0LR+k9pmD5/O574WC2yydMOZZq/f7KssSpew4jsmLKD8d+r6NMpo3lTEwCFkvDroppTGERlq6ECgIoYFKKUGp0zbdbndyPKx0s9k+rtfr+8dbrgcy4DiOz85fNXXrR74f+nl5PJ322oxdN1L6/2Prv2Kufdf8MOjuT2+rr7d/7d93ndne4zKxgxwCGIRCICKIA+AAiBASygkEKVhWpCCRKAKRGAuEnMiCSMiUAyCObZh4JvbYnpld/v3r7/eW9a7+9HJ3Dr49+z92eI7XwXNr3bqe67p+Dd/e30spzs5OuBQA4tl8OfBOSei7AQKsbRvNmOcSpQxzcb6t4jiaL6ZG+qF7BTQz0ihTEgSMkev7m2yUTMYLYGlTd3U1+IGijjeejXeb++12/emnn1oNlDJ3D9frzf18thRCBXFijBGG+7EThMu26aPYRVhRx/h+yHvTVuRk+UhLbxgGYNrTk3OjKSFkNPaub54bo6yFGFFIcN2Ux+MOE6uUDsPIGN33feBHUZjc3t4ihIIgmExmUsqHh81yuQy8sDzW2Wj8bn1dVrnvu5CFCvSXT5c3m2/Wt3k4IS5zTs5Ps3Rye32/3ewWyymLWZ4fHccZhq6u2yAIv/eDH37z7deb/W48yV4+v/kv/vP/NcL8L7563vXldJb4UVg1vGk1QDRKU9d1D3lxv1rPZrNPP/rtSfYg5JDn+zB0236/Pbyu6+rTp38xDACCd9lo1PNOyO0XL/5x3eyzOHVdNwiiMMhG2cQC/cUXXzRt/sGzT09O51w0b6+fX1yeeG6MkYIQU+T6vr95uO276snl4ySauSz73kc/2ezKqmqqZuf5KEmD7XYbB1lRF+9nuaqqsmx0cnLy+vWrw7HS2lydfTydjqu6LKttGLooApzvIQ4pIXVdd+270ShZol9/pUFVlsWrl2WZ+wHp+rysuLEqCTMIB0IZpY412HHctm27rpstFg6eHPLj0BuC/TBEQvCH+maz3xFr7XQ6reuaEtHU3HH8dzdvkySum6NSuudV11euR7ThD+uj70dlk7serprddneHiVFKBiHZ7G8ebnZFe8dFf3F5YqwcZaMwSMSgedcOvDIWcyWsHpTSRlqffSeL5bwNo+Vmc2+05VxqpXwnmYzPGWNDvzs9ma4ebqumksIgDJQyfBgY8zGmnPdKy6pqXNeHEFZVNcpijClCZDafvL3eTybzuq45l2dnF1XVCKGWy2WaplXjN23XNmXblYyx1cON4yJgnfdm1R7z624Iw1j0AAG3a9ogjBBCD+sbQuFonA5DB4BmNLIGp2lCCdtut0kal+WBOVaoUkrw6OqTsj7m5YpQJSVXEjskeHx5enlmj8cjxiwIiBDDZr1u224yGu/3W9GLDz/41HeD1WrlMjYIlSajxfx8u936gW808MYJxfTm9q3WMkujojxG0AHWbeteS5uOSBymAKAkSRCotvtbA+psTF0nvb25H0+SOMrKos4SSRDFyG26+35otem7ngOoCQVtd7y7f+04jucTx00hwG1XWwtDDIPQPXHnWgsEkJCNQ1yK2W73jmAvDGdiEAZga5lRQkOkrDEaGCAAABZhSogxqu+5EAohBCAyxrzfr1hrEEKEvhfMKgwwsAYBZKz5r/725wD8w/filF8/we/+xwYCAA2EClkEAMSQQGjfh63a99DGr7Wp2liIIfyVdw2hkAPRa+1C4Gkij/bFQ/3714df7g3uhsnq7mx7d0bzq4vJ+aOzNJl1jsHEGquGYUAWaSmsFkBzALkXpDRwOdAtHzQkCGmrjcUEQggBtBbMEdsZ+Sff3MI/KcwC0AJjOMHOOBsJdYkxLup3yOQA9hBwwcu22WPqxtEoG08//+JOyOZkOqbMBZb4fmQNRNAqxSFBk2wh1bDe7pIkzlKXMQ8DctjmYTBCRCKsurpeXlxVpfQYCIIw37dVwRfzy/F8/u3bb4pj/8Mf/CAMEhf678XPiiuCkLWWt0oIQVKhtYr8DGPs0Nha67nhp598z2M+AGj98CCEOjldlmXZ930UJQ4LHeYjhBzfsRY2de+50YcfjAk2b979YrvfjUfTKJhRRHDUv7j+u/1QL5ePKPHzogPIYEziaOI5MymlGFrGsskonoznk8nsvQHz3d3LPJeL2ZNnTz/Z7fI4DIe2mcxnRXH8+S++rerD4nTadU2cZA4LKXRmZxdZlm12277nUcyiKErTGBj19OkHRuM8zxn17+7u+r4lhCglhmEghLSNELJ3nUgp2/dm4N18dsIY3Ww2UgnPCzEGfuC2bQ2RtIB6ngcBs4ZRQsNgUpVN0+60Ui9fvIXIhmEspeoH4fkxBIIPfZKMgdVKWaqxw0KgA9dJsmxUN8euK13XgxbVVeu67snp/HDI82ILqexVEUURAAhjstsfHIapo+63z4euYYz5fsgoxSiCoB6PY8bc/aEgBA29QcgLQ7/v1I++/xMAwJu33wAgOK9//st/0HGNqTruDxgAZk0cTB5fnN7ef63NA0DtdJYFoZckEbDOw2pnrV5vN17gAqhaXgUh8wN62BVG27fXz5MkwVS3nXB875gfpeqSJEAADLypV6VSajQaCWEAIIvF6cXZh6P07I/+6I8eXXmug/a78j19dbu7C8JgPlsqCe7v18CiJBnVdckHvVgsqqoKw0RKfjgcur5xXSY4ads9pTiM/KqoECBpMtvv8qrZIUQ8N/rqy5ee54zHap+/yRaJUJIrdTjyoed9N8TxaDo5MVpyzgmBSg8Igbbv67p3mJ/neVEUQRBZC3/x81/OZosovuj6QikDAbOGAIu++PzbNE3ns+Xx0JyfPX578/Pf+73fu7i4iOO0L2Xf91qyyehiMpndrr4Kw1BqaUBft/lq/fzxB8vNzfrs7AoBTCnN83J/eBhEk2ZBNkqtQXe3myJvyrx36XSSJVEQ9WB4rwOPvOxs9pigSAxMSbpYLA7Hh9XmzWw+k7KnlPqhVxyLoiko7WezRZE3X3/1ynW989MPrTW+GzMaUsKBxQjS5WL24sWrh9UNQ1H4JIaE981xkO2vS1bXl36wqBphrO568b6Gd10nRe96wXg0llJaa/f7zW6/6WX58ePfdJhSSnVdJYSomxwTM576hHnum3fX1trzs0vikp4P/dDWfVF3h+lkOYgeIdv19TD0EBKIDETD3/y//g3XdaMw/PTTj/qhvn73euBNGk2T1JOS9X0vtfCc1HdH+X5LGdZKY0JCJyI09fB0nFxNt+pPluO2q5U22909ACiOvMlkaiTiGogBdp04HA6EgtFo7vtu1zdKGkYDQgjGYVkd1+s1hJAQMpsthmFYr9dxHFurOe/z/MC5PD09N8YIIXzfdRyKiEDIplm83d0iAH0/pJT2Pa/KLgjIw7pIkhQaD5l0HC+tcba7V+vV7ZNnJxiCfhC8H9o2D4MoHZ9QihiFr19/K7j6+KNnt3fdw/ouCNlotGybQWtord3uVrd3D6E/n43OR/HsfHH6D372D4FFxigphee4i/np0DcAgMgPAADL5ckwDHc319Ia4sK6KRFCBDtp7HtuoLX2XEypO5lMlNLA4sl4tji5sNa+evv1dr354MknwGKpGi5U0x7iNDRaJVEUR6O2q8vmXpgOEvn2+ttwNPRD03VNHIdBSOu67gfhuARCC7RxXU8po5RO05hS6nnp27cPAIC2rxAFFoiBc5cFoyyr2l5qYDXABAFDFYAGYK2thhoAAIyVUkqh+74HAHmeZyz81YpDawCNNRYoiDFWilOELSbAWIx+9XH+l8FfAQD8h+Avr/76vx8nAZUeJhhAYI2mBkCEADbvBS/GGGshMNb+yrYc/7Htx6+kqp2HBtUTa2feiAD8zUP3h6+2f7jJjxLP1qtn5f1p/ebRVfLBx1dO5CmGjTG/SpG1WmmlVK8Ul4p7AYUhExT2XAzIwQ7UwCqjCYEQwnP0KzPgKaIx+MsV+CsAAGH+9fdCHfDH4TIAAtEL16MeQWeLZRSEb96avIa9Lpqmc9wJJV3fczlIh3i+HxGJgHG0pOv8MJktKKV9W2IChexc12WGeaxG0CMMjcdjrU3bto5Ls2xUHHdKYgh8SmQtKiml7zv5Hv30B3/hmzcvVLv65/7Zf3E8cl+/+jqdj5bL5fX1te8lWmsLoFC9GPRkNIXQcs6brkXGAKvmk1Mu6s16NxrB0WgSRVFT10PPJ5OJ5wUucwbe9X3v0hhCLCXHITKWr1bvKHXm06uri4/bRnR9DcBgQB/FzPVBcTxCZPwgFgPgPQtYOvQrreE0mfq+H/gxBHjopdIyDNMkCX0vfO+WMZ1lSTzZbSvmmigOTs9mXPRyMKcnF3XeWmCFEFVVUUrfc4Y8z5NSK2XicIqgc9i+9cdJEAQYQ4zx4ZAzzJMoRUi0bS25CnwfApSlidKAEIoQDvwkioOmLfggMaaO41DikSDwnMRaZA12mIdxrzUPw8hoq4wScqgr7rvj8Wgx8NpjBUWBkF0cXDg00pgSFCCEPA/XjRa/MjiJrQHvByqEUJZlchAudSHE77EAa5TroYGXXDRGqTCaQwiLovvB979/eXm53a2GofW90BijtZ6MZ0VRvq+Ed3crAADEpOPi9PyRkHq1ehMEEZQOI+jp4wsIzTHPWrF2XCo7tdutKQ6BdbIsMVZCTDgfNt0xcD0AzN39jRi4NRBjFIRuXReO4xfFAWMYRklR7n0XEgo8dzyfnYVhuFnfA2y6Pv/yq89H2QOXJRi0NLIdcur2q9W967lxnFZVU5WNtdp1HUocYEkSJWKQBOPQj/b73ljlOW4SR3UjwzBuu3KUZl2rMfJdJ0wTQnyIkdN36vHlHCLzsLpjjPqe1tJSl3btoPr67PQRJd5xv1+t7s6fnDbtoembumsZSdYPu2yUbjYPddV++MH33717e3d//8MffabNsNvfI4SyOFvOlkVRfPLBD9q23ay2F6eXXd3d775hgcauGlQ5nS4CP/vZz355cnaxL18eqxvXg011ZJ6bF/kHH3wQJr6duRjDKIzaph0GPp2OpcYA8areHw84DGOp0s1me7J8BCxhhDppLJWNglBKDYzvuGkSJqvN6vJ8MZlmjv+o50XTtB9++OGXX36ttanKfjqNR9li6DZFvo3CURyN1uuVMStE+rppu67z/YkYaFeTJLz8zR/+6fvVGw0lhE5TfpelcvX4XC4m96trpUlRNrPZlFJSFPliNr9/eLAGRVFigRRyQFgr3RVFCRGKoyQMQ6mSw3HddkcAFXEcNz+WcRK2bQshurtbzWYTJXmSJIvFYr/dCyEIIRBC0Q1lJwYp4sRjlI7HmRaKDzoMEoRAFI7qigMAwyBFGGy3+922cLxYSSi1MkqNsoXnpgFiTy4+CuX21yeJwkmlUBB4m83KAk3JgmBodOU6vtJi/VAMvfaAAwDoug4h4rrEGmitVUopqZfLWZ6Xvh8ul8vXr18qJYyVu90GImuMOT8/n8/nP//5z13XJQRZIO9X111fRrFHiZvEk1E6CcL4YfUcGNd14t3+PksXiTdajp49e/TR7e39Pb+JghlGzm53SFKfMVKWA2XR4bieztK3795sdg/Pnn5yOG42mw0h5PTkrO902xXaKqMRH7TnuX5ow4g9rN9xUXbNse+AtVZZZYwKgsD32PMXX338waeMsRcvXhAK0yzklVfVx74tkniipUmicdfkQtaY6Nl83rXvCXR6d7jXUGKKpC6CONruX1tDT5enhKAkiYPQZ9YbJdmgpLUWIbPdvZuMEkQb5hDUK2MFgIZzSSl9n+q03+8Px6MFMk1TTez+sEEIua5LUDSeJOvdXT8Ub2/fxtHoyaOz47EAmCgLEMYAImm40kgbqpSF0CJElBKcv/dzswQzreWvBLEQQGyNsdZqJbVWQBsuMXUxVUj9d/6Fu19fj3/z3zBv6b9J2lgyrBxkCEMEAQQsAAACC4C1wGhgjHlPoIDovQXIH2tDLLAQAAB6haDSAUEGgLte/qcv333+5sAHcFIXZ+u3H4jNOBWnT8eTy7lwbU4q1DvASoAhxkBb+Z7jog1QDHIChBSttFwjRjwFEEZASfuBm4F/8onBX95opa2xAAJrMYQAwvfv6bqRVgIA42LK4kifP6Vb+vrdtwjGLsOMOda0RqL1/d7BUZaMrDBcKIycNB1x0W63G8LMfDZuuyqO0kdXH1RVA5B1XW9/eDjmm7PTR0q26/XaYSElbhh4m4ftw+odAODkbLHev1s/3JycTNLYPR4e5FC3dVU4jPc89BPBzXx+Mp8tlVIQiLu7uyjM6mpwaBBFfpFvETZxFD159NhoqJTRUrmOgxFlxFEAz2fjm5sba+ijx0+qqnz77hvHdU/nVwB6CPvnpx/f3d0KMSDo+nSaZuMwcI6Hm67lLp1dnDwBACOEhCYI+9koAgAcjlvOpTZqOh1TMho42Gw2GO8dF9bN/vz8she8OO6n85P5YrZerxgNGCZ8aAgh19c3rh8SRpXuWo4j3+u6oW+HIcBJ4o6yeRxHjkOlxBBix2EYWoyJQ7NK9QOvGSNaw5E76Ya2KArP86IoVFporY3RCEHPGTmON/TSGDj0HELYDbnjmdiERsOL88vNZrM/coeFvjv23QkfjO9ZbXrOJUY+81LieJzL1fatUyMtG8elWksh+CCbotxD7X36yY9PTx5/9eU3VWEDz0uiUErZtIUSWgxDFMZSaoiddDx1PLndrrjo3717MxqnSglCWJpMOBdpmsaRX9brh81LhBVrmRIsCR5FqSsHGzheL2U/rG8ffrF6uFvvVifnI+qq67tt0zQOTQkO0zThgruOC4x2WSjE8LC+47yfz0bGGErZbnsYTzJgLe/rs9OrqquAJV3LtUJ+TBmjRZH3ff/ey8tYx4JhMgu+/PqXi5NkEIfVeucHqe+FYjBVlSstKMVFuXl4uLu8fJxl/sNqTQh7z/ClNMSICG7GowUmpm0qayGw2GFhHE2l2BERYYCNLBdns7v7dy4Jz5aXlHoQoH7oWGg9N1wuzvf74zAMF5dn3cB7LhBCVVWdLhbPHn/ouuT1i+fjdBz5wa45Qsvvbt46DmaEGA3OzudpEmfZ+LDP34vPCSFFcRx689GH3y/L3BgudVfW3PXV7eqbMAx3x+3yZI6Zs16vRqMJIW5TaAjxMIjzs7QqV57nXl6dv72uy7pBkADgjUZTLvdVnTdN09TCAu44DmMMIoIgwcjv2uH+7qEfWtdRxCFd2273hyDwmqYvy4oQ8uMf/tmiqHbbwvfD+RyW1aEfKtdl2gxdX2qjXY+laSqEmIwXH37wGTaorusgYYQwCMivS9nN9e3DkBPiPX3y7MWLr40xlEFVd67HALBd100mMwhZmoysVYy501n86vXbvICz2SKO0jw/Dr0iFpHD4XB+fm6BLqtcClNVVZpG88VUGzMMHADgef5mu6KQMua4rptO0tDz80OBAew64XlhEPkQzcvcKm2iIKyqgvMOUxRFgdR6lM4P+f5Q5FlCgPHFgIxgYpDs17uaWpNFKmUPoPF9GgRB0/Snl6d13SCsJ9NxEESuH7fN/uFhPZ9PtbaC6yQZa62zLIMQYowdx9lsNsMwTGcTz6NFCbFhSovtdn08Hn8liQC6KHLJRTZKOJdBkGTp3FpgNPbc+OnTH++P91KqNMqQmj46+x5D3smUPexuhD50XQMhDMPQWhtFkbEKItD1h/uHF47j5cW278TZ2cXhsDseq2HoxuNxP5jRaNr3XOl9O2ykLI1pbm62zKV8kLPZDEL45s2b6+vrySReLGZS8tv9O4f4o3F8dXUxvKt7flyejttavCe19H1b1hvHDw7b3TCoi6tH+8NG6daPWdMfk4xazQmEDnO1GbpKO45blk1INHMCAEDTNBCZnhffPv956MdFoSHEYRi4rlsUxeXlpdZ6t9s1TZMkiZS8bVslASEmCLyXL5+fzj/w3ASjjeN7T58+1Qq+ePECgWB5MTdGI2AR0EIrqYyWhEtgLKSUGq2VUoQQSqnWeuAdIQQhhBCCAFhgtVJKSWOVhYYYgIz+V/6b61/f8v/1/7bbvGxYFFPHw1orIeVgkccoouC9q5i11lqlldXGWogQgtBAgC0AxuBf/QYCay22zEOEQnNXH3/2UP2918/zrZn4k8vX11f9fgYOyeMofDqTiaNCKGgdqUAoY5VCBGqtleDIGExJqwcoOQCgVaLvDbHYi7TnOQhYAP7phuP96gVCqIFFAGoAMAC/8iQBAKH3RlsaaThNR37sciOqfDseOUbvlNCuH7hOmKWj3X7le+F4HBBCyqYoyr3rMYSVlBySoe3q+TQbeh1EvusiIXqAhkGUD6uN47rL+ZIxdqjK2WykjVRK3t5/nRd7N2Dp2NsfX+SHYxh4FMPtep1EmevED9Ve9sZIuN+UTbfxPK+rWwzw0ydPHN95+Yor3UErqrwIg8ylLPR9z/Mc5jVNp6Thg4yjbD5fOiyQMqfEm05GEHSrVUONV+QNwsKAbjQaVXnXN47r0MCPoEmwXQTOVVFft/waQnAsHpRpCWZSGoIZRNpYLjitq74sa99nyrQE2+3uNojSvo14p4+HOvBTivDtuxttBoLZ+eX41Zu3q4fd6cW55zlS6sCN5pNzMcCHu81yOQ88D1gdBp5WUCk7mcZVyR0WR6GYLyZBSLeboxBqOht9/vnnWTrGGO8PBUTQ89yyyk8WHywXp0VRHY9HAAfHpUKVnPcIwqZpDodD3/eLxTLwM4pTQrK6+SaMUds3Zb2tyiYOp2HkrR7eGcCVNsYMURBBSIpy37TFbJ7pzrEWNpUNvbP5KGKuGrqjsWK5GJdlLQaZRIuyrI2iGDn5cZdE4THfctFCGGdZai1Yr1eeFyKAVw83SvFkBAGgfWvi8GQ++fBY3Z2ePL25fu4whNz2xau/b4D2IwigbrvKWul5DsY4SZK6LjFVgeeXeUEpJciZThYDb6MkXCym797eCjEURaGkmc/OtNaam8CJigIEQYCQXW2e933vO4lW4OriYy19RFrPZ5Px6WG/tkgEQTAZL303aJqKINL2R6X709Pxu+u7pj7u9zdhEENEAACU0rpqs2zaNE1TD9nIT9MRHwQEHgR0PJo7jrfbo9vbd0nqD/wAwLBczPJjM59N4jBpyjuEYFvJ/faY58e6yS3yd2XVdYcnT88goAQ5EOA8L68uL8M4uL29zbLx1aPzYeiiOPC1q6Qp8l1bN9aQPK9/+8/9eYzA4biZTUduBMLIlcqt67JpqmEQxpgwDBl1ht66LEtPpkW1QwgiCNq2B1plWfZ+euy64pe//HlV79KR53kuI+l6vQJIP/vg0WbVnJ6edkO+3u7P0/Moiqp8KPLqw4+euT7YHzkX7SBhGIauf+W67N31W9fxT04XGPn73W0cx5Jqa7XjkKrezxaXXeNUZe+6LmNs4G1d1oT4q/Xr9eobrjoaTQ2wLf+uFFd1N/r4KQCgKvvpdHl79+rm9uUHHz5Wur+4PBHclmXJOZfSaA2swe9uXuRFHkVp29ZNU9VV5zpREAcEamwMxASLvnNcdHU5moxToOB2e/T9Lgj8PC8Cln7y8Y+0IqI3x3Jb8xpA3srjZPmka/s0OJEScfHcaPLJx5/e3YP8dudRxyJLIG6GTV0PjMDD/i67uvQz9MXr/89sy5/98Ul8nz3URT/U2uhwPIrdSy23d/fX+8PBc+NJtghGkCCwXgvqeB3vhkE9uvrAcyNr9dvrl0a6DguEGCCgRjmi9wM38n2uVWXBIGTVt4aRZDJZfPX1z5KM/eCz/wKm4vmLXw5CuIx6bsR1G2fhOJ7lh9vFhO42n2fREy7OIMzyqmyrrhc5dvdeYBzPCM3vVg9Zlk1m3rE4drKJ00CBChH38vyk2OXb/YPvh203IAyqZu0Fxm2ZUma7uzXGXF1d3dzcZemIEccI/L0Pf3rMVy51aOCu1isI4WLqdf3dl9/uWn70qAOUPxunTVPfPXwNkXF8jxCwPd6fnJz1Q6E1j0J/NAr0pqgO9WKxAAAJ3uR8mE5OiqLUypZaBxh7XkCQySJP6SEdecCCodeeT3zqtG2ptdhs1kmSpFmAsNRGaCsN4NkkAZbUVT2dzr0A9T1MoytpDkoPeaW//9GPujbvBBxFVMi2bUpsfdlaiBkyWmqBoFXKSGUsMFL12kgIgTYGQM0cwrDzHlpBwCBkgEVWcan+CeoDyMsJZMeiaYjH/AghQQn2Q2wQwNpaa5QxXEqtNYaWIIwwJlRLTYSAFBoKFIJQQSqBG3EMAtl74Jff3v2//+635uh+jH3x6vmnJo9w4Zyx5McfBBfPem9sCJh0UtDKWgciKpVVWgIorCmsKUMvFhBZiCwjEEEu265RkJP/8uX3/7PdBgBgSdmtaTHE0CAIIXyfH2OBAQYABDR5zzihFkTA+8mT3/hq9SrPH6wJXH9JsByN0iAIHBrytkAGWw3rIm+6HaM6CDIEHIwDralUmDqu4zjGcMa8NF7wXvhuHIWjober1ToIgq4fIAJS8qbvTs8vhOB938axX6iDtVbawUCogT05P6Gus91uvUYf21UUjk7Olvd3W1+R+eRUqi4LvGNROJHb8nqf5/PZuVRY1mIy9SGxytTQQse328M3HU+KskHYUMruVqv1bvXJJyGAuRTCJZmDUHKa1F39cL9K4slf+HO/bZTz+Re/aPo7P1RSagTgcb9jLoMQJskoCuKmaQCIp9P5YrZcb+6W85Oi3FTVGrPWCV1C0G57PR6nhALqWd1DrlCI4Gx6FrgnWTaiDG02D6vN9oc/uJyORlJxbRsL8Hx6YTS6vXuLsJYCUIqDgAlFHAdDgCmlVXVsuo3WtVKsrRkjjlR136pZ9sx34oe7Q1FUo1HaNhUESqt+6Cto4NnyURAECFV1fecgdnpxunr4duCFI9LQmdvMoRQLvd/simO1C90kdIJW5xhGlDpXF5dN01RV4cVosz7O4u/9+NMf3t2/ebv6GtKgqjpaa0L9+cIv660ywkXOq1f3ZVk+uvznKYOj0UhLctyapmkcDxMmXN+p6wpiFLCp1a4Z9IcffM+A7nB8Y+xQD9uqt3706Me/+ZPNeieELHnpOFkUPqMUV02TjdFosszzUitESWi0ms7GXV9s98pzUgyyNLHHYzlJTi4uT1cP19vt7uz0cZYubu+/6roeAKgEYtSXkhM85OX96fzRw6ZCJPvoow+ub2xdO77jU+Qi5AI4NG3dD8BxYiXds/MnVVVNToOu6oS2opFa2lEy6psBW7dodqcnMymE4+BW9YM4fP3tHxVFaQ12HO/k5ORwfIAQhqFblfskBfvjqyh1tAK79X694aPJuBr8su08x0nii+O+4VyOT9xdcVPlzdMnHx7KbSuOEWTUiadJxmVllQXWoU7WNuu23U2y2d27l1VeJVm0L2+SYJJF44fbh8uzc2V106whYHE4W2+vXQ8ejitMnChKCCGrh9uyPCTOBIHFer1u5QOmFJLUcQJje2gWnLeESSFQvhfz+Ykxqq7r5fyJknK7W2826yhM98fNfHaRRpd3D58TQozRTVUF/jQM3DAkgld7hTFDmJi63Y0nYXdsx6OTLHr69Rd/qyzaTz/9/snpeddXebXzAyzA3cWTz4zlQjZt2wLwXZzKbDqm0/Tdu7d52aZZVDeH2XwSJ6EbjKqyh9DphtZYSVzoah8CtyjEbLYwVhyLW2NAz5skDSHoyPJk8vLlK0qdLJ0xBytpgHUo9bVeNY3K4jj0fAQZ570c4NnZ1bNnT//o5/9plR8wRMWhcr3MGFlVJbQgCt3Vw621MPAnvuNi60gpJeg9z5cSKaWErOPI46Luev5dSYZGCDXKZlEcdF23Kb6u6t3uuMKYMvdss7+P/KQsS4zbKAKcN4L3Vnf5sd5sb+PEG4/iN9fPmfM+3n08GgdVdZSqBZYfjwfHcaaT08X8XAg1GZ2V1XF3eDuIspc5c1E75DebnDIcBO7f+/21UfqDJ0+n0+VxV/zO7/3NR4+fHY9Fpa4hEfvDxvMd358cD2UUJoQg0TvHop/NJ24AGYJdV+R5/sMf/akvX/1uUVRVrRyHaSMxRlGUeG5Q13sECYB6NE66tmPKocShTMcZMHDY7bdcttPJPC/WXV/U5Z66zijL2rblg8YYPzw8zObjJMmO+TpO/Ko+brfbxfzUcaZK9NB6EPNu4H3HISRRmB3yI7CES0msadrCGNV1reOSKM5c14WAhWEIgCmKnPPB832tZVnm01kWBEHb2mEYrFW+70MAtJYIQoeFSgpMVVUdj4fi/OSHv/HZP7Nab988fI6wEb2CiEBMvJBKhTWEVmmljDYGAGOsMMZorQAABCMAtRDGQIsQdhzHKMAFB9Zao/4n/73vUMP/3b9dwAHd53lnkeMGvOsdFyMErLVyGBhGRltjjAWWIEQQAQBorUVnwsSxzA5CWcwYZkhqqtqWtD6Nrq+rv/O3v9zv9EUY4rfffKS61GnieRA/HbmLsYyZcSC0sNfAIg30AICwAEjV66GHGjDqU6CF6CQfNGLUCzwnxA5EBFfgr8T/JMX1/bPZ73BBIMUWE4uRxBBioqElFhCIAAAIwPdiWmQRhHA5ObNS7HZtr7Xj6O1+Z/f3Q99Ok6WxUCvNaECAi5EOw6g8NlKtJuMTC4rVw1u6h1Hsa924riOE9byQ94I57uXledv2NzdVkkSUOifLiyDwNtsH1wmydLbdHh3mpslovd697348z4uiQGlhrWWMbTYPCAPHRa+vn1sjpBZt11lmzs+ubt6tr69fJcnYcehq1QBomq50DOn7lnNZN/0wqMlk1POWiz5OwuPxWJX9dn0YjUaEugARzwvatgsDvdttEfSTJEYkpY4kCDT1cH4+zasDhFAIUYjW95KmPR6BcCibTDLKsNI9QmCz2l5cfKCUSZPRw8OqqY/Lkzmweujb3Yb7XvLDH36yWR8uLs94D2bjp+XRDP5+uXzSNI2U4ouv/6htK63QRx9+L4gwH+B+f4zCcVkd8mLjed4wKM/HaTJ2ndAYYLS1FvpekKXjY7F6WL/zA1p01AkgQMxqzbn0HFzVRy5qLluleVlvX73W291KQWWMWS4uxTtYVSVzWN+3QrbWDeM4zIuNlML3fYh03eSu5/RdZzRpu+Lu4c2bm28hlY5DAFBd183mk6Ypm7ojFFVVLYRYLE6b9gghePP61mOzP/dn/vP39/erzYs4jI3t+6GAEGolGIk++/73Nuu7L7/88vLqhGA8GZ9KKUfZXCn19vo1AOaz7/35Q75qq9dBSJKYDF2xr7TDwrc3vzQapukoLzZldWy6um7y9fphPruYz2dB4G02a2BJmkyiKOqHsq6bMAyjKDoeNURaCamN2GzvHeIe88M+315dXVBK03QURXHX9NrgLMuapux6hQnthzqKkiiK7lffzMcnXSujIA6ySHGDMaLETUCy2Ww8z0MQE2zW67WUwvMd381OTmcDb3b7NaWYi4GLdru7r+qO9yKJM993gtAlFHZ9XdfldDFOYo8P5XiSOC6+u76JogSgPs93lKLb2+vT+SPfJV1zzPPyZPHkww+fffH5wfdDRp2Xr198/PGnr26+6HiRBKPD4WAt3G6OJxcno9Fovy3HkxTh09FoVJY5ArAqypOTk7IsLy8vdeNdnn9QNeWxLKDFl+ef9E292rwQ5EgoePPm5XwxxQTUjS2K0nV9pfsyPxCCZ7MZY07TVGFQUeytN6skSYwxFuj3hKS26zjnfqIR0R9++IO2PXn95oXk5HQxf/XqTeAns+np0AvfD5umOR7qprGXV2fvteh5vhdCzOB3poXWmjdvX0Jox+Nx05aeFyyXMylElZdxNMKICV53bX316GwIktFoWpVdWe1XD7cQAtd1l8sFgKaqCiLFsJjNGQ21Nu//uenlqTX4z/x0+otf/Oz+fhWHSRD6x30upbEWuk40Hc3OT+dldWyaxmOuUaIfat8PGSN8aFwnOVs8dX2/qjcIm55bjCGEbhTRor6RmhCqpe6/G2KPh8WPPgjDaDyaWmvzYhvGgYGDsirKmBHNsS6apma+evvmJori+excyHb18JAXm4tHnx6Odz0vHC8aeIWQQVgWxTHO4u09/OjZn0UI1XWx3W3uV2/DMMhG0Vcvf1cIEceR44UGdQa0rjuL4xMt30ITExbutkU/VE7U3B/+oCiPEMJRMnL8k/FoNhqNOO8tUhZWuwOYjBfZ2D0cV+/u30bu5NuXX376IXufHMuoizHu+gZjjCBBiCqlHEbX663RWEl7eTHFAHPOlW63h/1kMnF9j1IqrSaERFHEld7vjsA6WeonSWLBhTGqa7nruhBaY6TjYs93jYZ2gBTHlxejruv4YAhmvhdqDfqOE0IwsX3faa2yLPEDut2t27YP/JgQoo1ou4oQ4jikafp+4EHH+n7wA7esSV23xgCCMUIk8KO2K6bjCwtBnh8QMEMvvnn1szw/BEkEoFbK4DAYOCUureoBQYUFFrIzRiFsjTUW2PewFoLQcVxMoJLmPdzwHmQAGP6r/+3vSNH/+3+vh6XsDrkDaCu17Ie+7bEDiWMg0YhA9F6WAuAfh89iCIA2xmOJ5L3BAiAyKMw5Z0ARM3jL8d2O//W/+bvX1+3T+UW2uXsKD8/8gWUgfLKIP7wCJ8suIBRrR7PeMmqNURJbo4Hhoh94TyFCLOK9MBZaiCGi2LpIYgjhJ8/+5v/f9QYAQHCJCEDGamqsxgori6AGMEBYY0wQRu9j3wBACAIAp1FE4TMEcFGviTMIte/bgzFd3Ubf/+GPq6qpmnI2PUdYUUQYMwAfd8dX1LlgXrfdrgGeJklWV43neVVZdq2cTb33sSmz2UwI4XtOFEW73ZZR11j18LBl1JPC3t3dcS4o8d68eQUhhtDWdWOMun+4wQRFgd/1A4QoDkJEAcCmKI7LxelkmhLSAKsgJFIJrZWx/GH94Dp+FKUEu21bdF3XD7XjkMNhT7Abj+M4gZQ4YZDUzVEZPZsv2665Xb158viTJAstTupmjxFJ0zFjlCBMHUZx6LAYWCcI++NxvZwvEWblsRBcuU78ycenfcelHhBCRmlCmO/7HvMYdZuOp+mkLMumrfa7Qivykz/9z7x9vbq+/+LDDy632+3+eOs4zmR6bg3iogPQVHVNSOA4npLo44++LyX/5puvHcd5L46DgHHOD4dDmtjxR2POeZIk7fAwDqZNrctjF0fjwPUQK7SRzTAAKBEDHS/rtk1HqYWA92K7yefTK8+pinrr+uzkdBaw8WKxKKt8GDohhNZ6GDrOOz8cL5YXBomXb35Rd8VnP3gmTHussBLqfYcNIQ78EGOqlAr8SKqhKtu+4+MkmcRn1jjGyjJfa7Tqh7bv+8hPw5lft+vrmxfzZZxlY877vu8P+8MkHRzmGaOS1HecQAqAke+5rrXy+vraaPTs2UcG4sO+7nvv7OwiSZLrm+vDcUepUEo17fFh02HEKAmBRS9evKDMJkkyGo0ghBBpYCWAyvU8reDt/Ysgyihzv33+xcnJiTF4sz6M0kkUxYfDQ9MWo3FcN/lqtf7s0+9T4jjY5Vxi5EghalUbjYEi8XQqTC+EcByvqbvAT1zXTVKfULjdHISs3928oRTPF9PtZtP1pdJp14r5dPaDH/zgxYsXdV1v9w+BR4cBrx/edW0qBx643vvZZrHM1uu3kg/jLOmaSgiOMWKUMIqsEe9uXg9DV5UVQ958Pu94e8y3kPWEoqpsfT+QUlppl4tTKezhsHGpv96vhRRR5Bx3+zAMP/no42O+/fjZD7NR8rBZe26EMWWM1UopCYv6JonHz549K6sDwgpiiRDy3UwBOZ/PHMdBCLVtV9W5tRZaFEV+21YY48lk2vd9UZRBEERh6kf4oT/e3j4s5qfAOkNfVeUhCEiSnBkD6qpf3283u+3J8kqbHhivKPddV3d9kyajYfjOh2PgDQCEEKqUIoT6XgwstcZk43HTNPf3L5iDHRcXRQEB7TseBgmAqqwCY3mahuNJxgdpjCHDIJ49/SyOpsbY1/5ra02Wju/uVpPp/JMPf/Dw8OB5PoRYIfDBsyfv3t3XxWp5MnYcn0BXi56SMAyDqmo8JxSmRQhijNN0XNc1H1plj1VT+I4ThmMLOGWy5/l2l38WzH59kiDyW2C6rm2b/vLyMknO7h+e++FYqrYsa0r8vuGT2XQQe2MMpQ5GrK47StwsG282G81pkrraDJiobti3/b7vubDtcvnxfHZ+f7dizLNQEWr7vgUWn8w+GwZhjGrbARGwmEeUZBhkw/BN4IVdX2w3Zd83j5/Od8V1lKGzk2dtOxhF66rnw45SByEiFRplnrJmt+k8b35+MoJWV93+l9/8PYwjKZAgOo49hwmEASWuNRgj52R52Xe6qtqhl5v1gUDkuJRg1xoch1MIhrYdCAqsVkqo8Ti1hljDfC8GACXx6D0ZwgKx2a6YQwgh9/e3BHvT6dRxvK5tCXFHmdc0Td8Pjx49eXd9r7Wp6zyOUmMMwsBaYA10HEdKYY3WmkOgtDKC92kcQRhLIfquHWXxKM0cypJwJAWiITs/e/zixSvXiaq6VYKen10FIbu7+2VeHM7RTyCmDGXMiSlhlCFMjbaoOjZFuRt4ZYA2RkELCHatBYQgAMAwDHyQECLHcSjDHgsANn/yOy2r2hYVU9pFtM3zruHA9dzYlcoMXLiAKGAwxhhB8CuJisCQIIQ472hIhDZADT6hQsvBingcrdb83/lr/+Hdg/zR6cdnzT6t3s39anQewkUCn87BydL4icKAGIkM7jEGRkMrrVZS8l4MgzaKuhZ5q2BECEGMGYQtQBqB/8Yfdxv/2SXHl3KoZPCetoIBhgC8199gALQFAED8q4y7907v7/d9Ngt9u3xEqNOKHYBSuzWwQANRVvvNZmuNOb940tT5fr+xgAAE27Y9HHaM0TiOlTJDrz03W87PCDp4DmeM3Vy/Za5HKLxfrR9fPSqKvCiO8/lcaZDn+XK55Jy33XE2OzMGHo5rSh2MYduVAFhtrU8dDXXd7wmiylR937dDnaajvu/3+1xws1yeQICbpjk5XVQtpJS2bX88VD/8wbPzs6vrd68RBlJxa3UYhhfnV4FXKaUAUojgkDlltcMEBCHZ7N5u1nvPc7q+RlAZq7oeUupg4BLChOyM7phDRqMRZejh/mYYhvl83nPZd7wo93GcCiHmkzkmYGgHrY2bep7Hdrtd1zWe593cPVcC392/vX+4Z9S/uX3BZekHOBtd8EECLIty9/KFOOyLzz77oeejbjgoHQkpjTGu6zsuklK2bUspzrJkGPq7+xsMwzSZVc2mriQj6XyWuY7fD+0ge6Wt4ziUMa0FjljbSD9wEQh6yKu6oNTBBGJIMAZQYYTQbnekxBfQCKE4r9M0lVK7LF2t9+PUPv7gvGmit9evVttbz3MC1yuKwnXdyXg2DIPRhjGfYK+qj5Q6P/rxD5Rw/tEv/u7p6eXV1cU/+P23Eh5dj2WjmEBS1Yem6S4u557nS9EDKBGCwCIEiet6aRoDKK+vPxdCxcGIQlfIbpSAxXIcJ8FmPV7OZ+dnT4deHIud6ySLufvxxx8+PGz6qhCyNRo/fXSuJPQCVNarzaay1hCKKEFKG2M5oWGWJYftLs0cA4DatLd3rx0WXF58IAfbd4PnBgCAsjq8DxkhhFgDXTdk1OODFVxOJpmSUEl8enHZvWoAAF1fUgdjDJHxXJYV5R5C+/kXvzw7OzHGrO7XjuMhhJqmCoMZJs719Q2ltOubbJSEYUgphWg09IKG4yiIIbSciuPhUJaH6eSp60Ny4RrlQEMF11k6IYR98cs/vDhfxnHisODZ049/53d/p2vFNIqs1WmaUuIOg3h4eMiyFGjTt60ldD49lXIwxpyfR77nTyZpXZTG9v1wbPs9pkCbfnt4cX//zg8cAx0+mMuLi7YRfdf2nY78JYapHxpkgVa66VuttbWay2qcjTybRCpo29YPHAgwIYQQdnnxpO0khtoaIsRACBiPozhlQgzA4I8++vDzX35NGf4Lf/7PX99cr1Z3fScgUl3Xe17gOK7jeN8NTrInNLFAcWGiKFJKKWXPzx7f3a7vV++SJHRcBIA9HA5aIYz8HgPXY4zRsi4QTg+HgzWwawdyvnwser2pt5R4vuNz0axXd22d317r5XI5zeBkMh2EWq3WYZgul6ZttuvN7W6P03gMLK3KYT47j4ImCIKytQAqSknXl+vNu6a/A6QgJA4jxofaGLk7ro6H/dnyo+b+u/A2LkQUB03dYQJevPymG2ptm3js1E2/ust/40e/HVBjFMCgX0yvgIVVLs5Ozk/nYTcctrvbpikW8aKqC8fFxkBKaRgGiFKDHn7/D16WufjJT35CWXI4JILDyD/76Y/+Ui/6u/uXt6svuHiwVPBhP5m4DE+aekjCJooZxklb49A7ESp/d/PWGnRx/pRSW+RVlk2Wk4Xvh5vdq2EQk8Xy/b9+++7NZBqHgY/BPA6BMcr34r7vOe9HWUKJx3lOKOaiohSdPrvouq6uK0xjh9IkyW5ubixgvpe4jkupU1uCoHNx9eRhdbAWEuzm+WE0mjDGhmEIPG5sz4e+rlvfA1pLhICRWBpACHaYjzHtOz4Mg+f5DvPeT0JlMTDGICQIoSD0+naglFpAhRAQ2jAMtdb7fUMIOB73Wus4GimJ+9ZmycRzJicLe3t7I1SZTQjC9erhaAz5/me/NZS+Mpg5kbUepq5FkLgMQGRg3ioxaK6UVtoQiDCyECKjpBJKa+ky1w9jhJCQnTbqf/Qvfidc+vf+3U7niigFpWqrXHeNoqivuqJsNNYWawg8iC0EAAMEgQXWWoAsMgBCEpiqbxFzHIhkdQh8X4bxm7L76//uf7S9LX589WTZ3Y2bu48vXesF/DRll6dyPIHUZ4ZiZSgQEEJNqZQaGaVF13RdZ7ShgaaBJn7tTxAkBkNjoQb2f/Dk3/+THcbfaloG8X8ucP9hywlG0lDtQQIwBYgAiAFAABAAoQUWGgQQAMBYgAGA1lprrLXGcIy9OAgGMZHH3sAu8E+0Lo2uXr3+ilLmeWzoBs+NF3PveDys1yshGE7iWbag4CCEDp2x7yX5Xof+jBE+DF3blbiv/DAII4awkqqdL8bGCELQaJR6nsMYkaoCUAkpMLHGDlaDIGRaS22BAb22yvGMUn1RlgCAyTSlOMzzQkqZZRPXdZu6E0IZjcJgXFcDgo7jgO32SAhR0hqhIDbL5SnnvKoLpdXyZPn8xeeOi7quQQjO5tOyPN7e3DPmecE0jsO6vdltiuXiIksXBLO6yW/uX6VZlJFH5yfn682tUiKKPT9gFtmuGwbexiD0HWYMA8AoDLNkNJ0s71Yvi+Pm08+elWW+2x3SZLZafQmAPr988tXXv7BwOD057/uua7njUteJiOfG4aKuS6VrbYv19vVkfOZ6TClTbHaO47hO5AdOLw5NU0kpEZOH/ZHi+LDrP/3kIwTx/eo6iIiWrpJ9lqYW6N32neOI9zlqSZgC21hbFfmt68dx4ldNQRCt63q/y9NkOp2cdX2xr46BnyzPF4eDrapjliQ9b+5Wt4fjfpRmju8yTPb7bZrFnudoDayBBLtRlGLka8OjyOeir8rC8Se9qCizGHuB71OGJVfQQgit5zvr9b2RYjKZXJxPsySCiOzzo0V44N14RLUmRg1x6DMWl6WLDL5/t0bEi6Px6n6PEBJCdl2XjfzbuzdaQUoRIlhwWzcHPgBC9cPDw6ef/EhJkx/3zAEAAEqpUkZKiQkqyj2XarZI1w/bNJv7vlsLjjBVWjmOJ5TQWiRJ4ro+H9TF+ZP8WCvez08W1kIp5HJxutse2qY3oO35PggCRpPzk48x8njXhNFolM3bZmAOTdMJpZRRz/OCq4vfePHy2027m83HhFIpdF02FLOmEY8ffQQAXt2v/cD13Lhp88l4CS3lHR9lS6M8Y0xx5CeL5NnVZ33fDsOglOFKCW08Lwr11Cp4d7dKk8l0EiRJorUE0ACLPTeC2r28OK2bvCjyYRgYoW/fvn3vOAcAqKpCA51mHiLdILc+nIne8dzksBUfffDju9Xrw+EwObs8O/no29d/WBXFaJQagwCwo3EKgEXYNuWAMAgCDyFQVXmaJnGc7ff75eKTkyUIInS/emNM53kewU4rBs6Lt9evINIAyjdvXh4Oh8ePH1dVpbUsisoYmOfl92bf7QUAVEV5fPb0wzjO9rtj33ESMQgwY2yxmAvZWGsIoePRdDY9vb/fjEcJpUApDQE2GigjGHWbpiF12wGrppNF0zQWGTdwD4cdcVgcZWXRHI9lEI1cNyjL+uc///nZ2ZkGGiFACLp8dDEaif2+kML4Ydbz+uFhO57Ex8Nd27Zcde9uv1qcRJPRSKja9WJr6dvbje/Ef+anf/7uP/6Hvz6IUcoYgwkkBAWB1/VFGAZ9UwZBeHLiiaEtqyoOo8AbB95ICNE2ilKPYBcBT3CIEAEAU+Irxfu+NcYQ7FHiFcVRSjWZJhYMSqFhGCj1srG73r3J88PD+npfrMdTlwtT1/VkrH/wvT/31Vd/4HpOp81v/sZPd9ui4wUXIIumnPOusQAqqbiUYpKdxOFcDLwCx8Dx94c1RGY8HhPIutqeLpPRaNI0jTacYc+NvMBN+KAJIXVdtl0BAArjU2Xeq3qr1Fu2Q0uotUALWbsOZowFfsil2R9qTByMMXMZQFAoudsfHl0+dV339u7V0NtRNrfWNk2XJMmELY/H436/Z4zFUXQ45JQyjPHJ4mK3W/uep6lLCJWSVdXe9xxgoTHAWhgEkev6u91BKRPHKXNs0zQYY9f162pw3Xg8Hrdte3f/uUF9msZKq+32oCS/PP/kYvHpvcz7ATA2kRpZ4gJgpAHDoDRhyAkADbRWAFprtbWWYmS1RAhgQjzXoRiWTVWWh//Fv/KdL8u//Vfl0InYcQ1uj4eD5dQjRFpY5tXgUUUzx6cOksSBxkKCAEIIIYwQMEBbY6XpAHIwwH3bMKO9JH5+vfmr/6f/W/PG/nM//CwoV7S9Pjv33DPXP73sMevHM+340ACMrKsxApojYZWWSgOt+n6oBReYUc8nfiyxF0NXW2Ok/Zc//Ov/FHryt9f/QzFwiMnvFFpZhAyAGAKOLEYKQG0ssJpAhBFACAFtCLIUImyhBZa8h4asoYQqowii81EGrCgbwLXT9ZQShZCcjsdN01d5MZ2fTicTwdXF6fetBZPJJAyDqjCBh6Jg1DY8CSfMp/1QGiuUJhBZh2EUB8d8hxCSyvYd9zyvLMv3vpl10wyD8jwvTZOyLB2XXlycHY/79XodhEwJbrUZZ6MKdZzzJInEQJqmybLRcjk7Hiou+iDw6roGCFLiV9V+Mplw3q9WuePQMPSNsRBARFB+3BqNut7XRnChCSEY48M+RxhMpqnjOGkaRGHiF43RIEmSKEw8zyurQxQGWg1xNGbMRQjFSYgx4nywylxdXUGoq6qZz0553783HbYGD4NsmsparY3oh6br6/PzS6OthfzFm3+8PxzSZOo4/jC082Xc1qZrYDQajSfJze3Loihc12/bPk3U1dXVzbs7x/FGoxGwlA8tBCjwEyWtVfjx5Z/CGG+367bSTXs4Hqv54kkSZG1XYIQxpvOp3R3uOK9OFk88Fik9HPcb13WDIOh7KYRwPUIpTuLJZHzq++7qQcdxKqXxvaQAJQJmu121bcCYO58tsjTiolFKpXEGre3bIYoi1/UF10bpvucIGc65sXIQhzfXn3cdj9MIkrHWUnAJLWSMMerm+cFaTRmyQCk1RJG3PzZd1yGEMKIY+ZTYtn+tTDGdTiGSCIaz8QdVv6IUuR5aLBZFCXffvu65BMBg4BtlhFDj8dSowXV8349PZo8d4iErwyBBGA5DA6zsW6P6fhgEZrbtO2vg+fk5sPj58+cXZ4+TZPzy1doaMpuc392/q+t65x8QopPReYv1AFXb9pRShJC1VkpFXdzzgbhKmAYoN06Tw75WRje1clhogUiSYDTOrt+++/bbV59+8r2+523bTqfZdrtt2sqCwHN8j3kgQBBircBsNlNGHou9NnA8WTQVaLthsz5kyel4PHv65OOiKKpm+OTDz96+fWshjuNEKQExuLp8NJ2NXr/5uihKz42VUgCA+XR2df6B0WB1fzgej4fj2nVZ37eUQT9wADCHQz4awQ8++Ig6gYXNyzd/VFXNo8vP5qNsPJ6XRWM1CdzMxKRvB61E13Vd1/zwh5+1XXV3dyO4chyHDybPq8ViCqA6HHYAAEyYEIPDgkN+1w37qquNGbJsPJ9ebLcH0fsnJwmXGkDddbXjuFEcSDFgiJQGGOIsGUVRxF9+NwROJpN722qt+77nnI/HY2vtt99+m6bp8bjXZkiSxPPC6fisLOv1eh36Y0wwJV6Wsq4VjDHkIEIIyYvtZLxIs6CqD0IOAfOybIwgIQQLIfwwFEL0PfcCV8phEG1d9ZDQQ5Hf3r7DyCUO3he7vu8xeW81Teq2wcT4Dk3TURJNISB1s49Pwt02973wbPHkm2+uYfsdOIQQevPmDYTw+9/7YdN0njNazka3q9fVsWI0sAYRhOvmaM3U9XAUB227u1+9ffzoqeczQtBHH/3YQlhVVdOUUvGyrEOfaaMcOvVHFiKz3txn2chxST8cn7/+B1nwerW6EVppbR9d/EWp7P3qTvW0b7vQH1OQUCjDIO4CyWXvOpnoVOBmWnNtGwg052XT7h2HaaF4K1vMp6MTTJHR8vb2lhByLB64aIqiFIJ7njcaTdva9J1xyBwhcH46zYv99dvb/X6/mM4AYsVRlOWQJIkyWknkuUngxz2KG1HUdZ3EaZrFDw+3XV9pLfuB36/eOQ5x3WA0msZxnOd5URzLsk1iJ/Tj1umUUloahzKXuVprgt0wTFyXUepgRIUcAFRCDEEwErJFCGCM+050nfC9KI6y/WGDMVNact4DqLioiuoeWJqkzCDrB57VHsPhdreq6+bNm7dcUc6Zh4yEVHGtCKyE6AahjLLUIU5ojDGSQNm9JzQhaK3VXdeXZamVrbv23/nX/F9fhv/NX2fYYmgNL3LZddpaCJQaRF4Pg7CjJBwhogysmwE62KEWMEgABMAYYK21yhhlNTFDWzTxeEbi9P/xD/7o7/y//t6w7/6l3/xT/PDGt8XZh2N/7HVpaIMQOp4knqMBJEIjZAET1kqjyMB7CxQXvVQaUeTHKMgMDSxgEklj7X/36d/4k63Gf/Dqv2WMWbc1w4wgjCyAwEBrEACBdREGAACrFQAAYcAwwRilsc8wcjBhAFEIKYAEAgiRBUgZ7SCAIBjHKaHg0OCm1y61xHRl0QGj4jjmXb8dBqXUs6efRWHy8LA+7CtKfK3F8XjAmFhgdpt7aTsh27I8RFGEUNi2rbXWcRyt7Gg0AgAWRe26PkZUa00IcZ2AMc/aum2G47HI8zoM4zgJyjIH1jo0dhjqO7HfF6fLxwDqotg1bU6wE/gJhAQC6HtZEsV9VyOoueQffvAoy0a3tzdDq4Qczs6mwyB6Oazu3ySxa4y2FsVh2nVd4LtGyTgKA8+9efd2NsmWM19qIGSrdC+lOD25qqrK992+b6HVjNFh6Aihw6CqsvfcUZlvR9mS+/3Amyjwi7y2VoVhKFV8f7eaz5eBNwu8Cef9fp9T1z07uSDY1QIgQBDAURBenZ81TbXbli6dnyyeMQdud3dN1ZycRN/75Ieb7Q3UcDJe9EOjBA9GlKEg36vf/vFPpbGy/fr19c+jxD1ffBixs0EKwY9N08VRNp2cNN1hv9/f362ePVlMJpPDLvG8iNFE6SGOUd1u+aBdNzDG7HaHqqp836+q+u5uNZ0sHO9is3lAGC4WSwTgwOu66gCijx49quoiz3OlTNd1WoG+773AI8QBFndtrwR1UpdSKgR3mFeUbRD4lJDi2HjjwKMOQsB3wr5v97u7JBkDiKIokKpvWyUUyEZBmIQ3ty9bXi0XV0Ec+l7Gd4djvn909Wy73dRN/uzpJ5vtQxzHcRjVTSBlX5XHOE4D35tNLpCNi3yNEEniRdNURmlGk7Ozizgaf/3NL6eL6Xq7krIfenVz8+50+RQC3DTdfH56OGKjFcVhHDHOlRDd8ZCVRZtlE6XF4XCYTk7G00nXquvVP1pv30YJG2cnvhfe3l1vt6tBlKPw2dMnJ3WzI0zvdg/G6t/6rd86PbnSUs5mIy6aMPX6AT16dFHm9dB2GtiH9S2CxPW9ssw9nxpI7h5WHo2XJ5O+E9DisswhhEoLzvkonSdR24nGGN3xQqrK8cKB154XQEiiKNDa7jZbzuXF2fz58zfLkwkmZrvvIQaTWZSXR4SsNtJ14u3+ne+PCE0sGN68eeMSl9HIcxJrrdTV1z97cXl5nmVpXRfbw4uPP73623/rq5//8u8nSTKbj4deW0MwZFmqhdBh5AKo27Y1QrCYhZG72x+retd3VRBErRbho4Qx7wGvmjofj8dlWWajxGHeV199fX5+eXnxaLu7z0v3vUEUQN/5cHAuZxcLjOm7d+8wouPxWCl1cXFR1UWchHWt0jQzmr59e7tYLH784x/utlXKRlk26fsGIw2gqevaD1wSxW4/lK/efMUH6ThO27aBnzU1VyKvmm4ymWZZstltg8CzgLZdMV+cF/luu93ePdzxQX/88We+5wvVKz2cnZ8fjwVj7PJqcbO6/uGPf9pUHEGZ1w8//8U/ns8uZrN5GIxdmrV/IuTK8/0sS10nvL9fS2Hr8oCIjIORFh4wwXLyAVngLz//2cmz2W6/qptS6rqtVVFFSgk/oIdDARHjXEFIEKRl0ZyffugH46beHfMNwjoKR23DKY6yxcSAdnN/Tx1zNp/f3edC6PzYdi3nola8icNpmavpZPnqxYuiPqajBAscZyoKXc4xH0wSX/iOf9g3fbXRZo8JpNDHMI28YH+4D4IgTRyLrFYtZQYijBAaekWx//3v/biuum++/ZIid5TEUvYYZJdnV03TIOgEp5O82GotlvNzAkPfHe0fbnvTYkzfvH394+z7A2/7vrFWMccdeM0FDIIAArx+OPhe+OhqWtVHLRSEcDGdR1FUlHmRl03TXF099ryo67rjMX/y+Jkx8P7+HhGEMZZCU8qCwCvLsmn4fHYWBNHtzUPXN9PpiPPGcfzxOHn16k1Z7T766LOumvfiHoCWUUVdSJiCBm7XbXYypcgxCBuAyr5FgTsYJQmUXGPHcYIYWqAslIJL3hGgm64xRndDq7WllEH4T8SdBUGgOe+axkoNIKAOq3e5UYjSQCBUVA1YbbXi0yigIUIIuQhBCJVSyiiLIERIauJDMBvHe83/n3/nd/7uf/LziXD+0o9/clK+VKGIzmYkom46duJs3dYGtJEXO9BaxAVCWGMNoIYmlEZb2QshjIV+SMMIMFcCbDQQQv33P/4//8l3/mtf/UtSWYMdZSFXvzIjQxYiiBCwDRPEIgQgAhZB6yIMCKaEcGAswgghC6zWViHLIEYAQAMoxlYDYK1DcUYTCc2gdPFQLU8Xku+0HIIg6LrBWAORubu59by8qTs/cBFl3AoAFABKyMoC4TIotZJqMNaXUnLOoyjigwzD0HHczWbHqGsNNgCcnz1p21YpFfjJ1WW83a67VoZB4lDSliUEbDxKtSIIOudnT7ho6ybv+5Yx5HnOMAjHRZS4d3eryJssZpOm3rRdgaD1HFzme6t0FCRc0DzPheRhGAZR4Hlu01ZVwbNsnCYTbTgXfdt064fNbLYQAxNcMgdq2202e6mA1ex0+cxYWRaHzebhk0+f7XY6P9ZpMndw6CYTz5mMR4s3b5/XTa2NaIbGcclsthh4i1AwHp2IAT+s9uPx6Huf/ik+aD/Ex3xdV1USL0RrrRU6LgA01qCLsw+jcHz97oXiIQRKCosIsAZxIYAlwOIwSJaLC94zyY8v3n7DB7PevmIu9wKH9yI/thpIIUQ2yozG797dSiWXy2WZl98+/zIMPYeFLkt5T5TCHS8UbOM0FaI3RnVdwxhJUh8AMAxdXR0Qta6HkzjgQye4Mrrt+3Zx8ogxZ+gFY8x13b7vHccbBt7zo2md0J+N06vAm3BZaCOEHIxFAIB+aGmYjMZpVVXGGM/z+hYwJ3Jda61tmsr3fQhBkkZc1Pf3B4Kdq8sPIbQQwtv7FwiSMMggYId9VeS940SnyydxeJYfy6rcKYWkQp6bGGMopfmxASbyvWG/P2DoD73N0iXDDNpwdVf67vTy/JP5/PzVm68Oh63vxRBijKnSOghCm00tUGVRn59fRlHwxZe/rKr24uJRkkR1U5Rlvl6v03RxPHSQdFHCPM9TyloLd/t7i6qWXz86/eliPt/tb98+/3I0TpMkW6/XGLmCWwNU3RefXj7r+uLt9UtsCKXObD7fbrfCdJb3UrfRaFKWJRc89EJMtLFSDKUUNgzJeJz6AVvfHxkLvDCo2+2bt2/CGCMsDsedVnSUTfI8XywWfuD2/dC2w35XVs0DF83AS0QTiCwmpqqPjkOO5Z4QQp2gbXPXQ5NJenX+GEF8c3OzOEkh4pNZkKT+ZrOVagCI3a3WzNXK1Kv1EWHQNXAyunh08eEvvvhPtLJKKaWU67K27Q+HHcEMQrxcnkkuDvtyNFr+4hc/d30bhAgbWpb1bDzDGCulfD8EFq1W67bfZaPQ94Kbm5uLPyGL1cpSStu2NcZ89tmHjuM8f/58Gox9b1bViFHUt0McJgQph7I0DetKMMaMBqvV5vHjR13XPDw8ZKOI+OxRknrH/GHg+cCbi/PHghvXZR0vyio/P79omkZL5buelLptuOuSui0n0+nTZ49/8fPP8zLHxMXIo4C5LkNjAMCwediaTruAUg8f6zzxLzzaQEuBTC7PP+p7fui/YwhSEnhewhjTZlgspwC72krXTWZTbCR9evbp7e0712YuncuhdL0kDkIE8qbNGUNFcbQ2Xy7Ox6MkP5YUJj/9jb84GS8Et9gQYGDb7ZkDucq9KE0moxfPC8dNE4/1A4/8JIncujyOEl8pNPQ8idD3Pvv0cMi3x4eLi3NrMDSetQpo7DJKMdFGVk3PXHc8HuVHQrXAFPV8D1CtzeB7MaVB0xZKqTSZzWbLuho26zxIPSFEnt/GEV7OR13f9L2cjE7rJieESM37usbE9oJ//fXPfvM3fmu3e153WzdkWnMI25evvwSWMBrEUZoXh77vry4upZSvX68vzp9MJ6f7wzYMppiY29tbz/Mg9gDsEHGJo/b5ccF8jLGSoKoaCK0F0mgQ+JPADd7dvXu/lkzSSTad5cd6UMYPmdBNOxTjWQwxQZAy4u5Wa+QnEKCmEpHHyrxP4o8RGgWOr0yiEJIWCCC143YCKEgBtBgpa62BzGAPu1ZpIYaW9xWUEkDtEzaogRj7v/yfBb++Cf+H//tEKiXMe7ABa2u4HJDBjgFU664apCvJBJVcUKKZTBEBaFCUYaU4gtZDRA1dFob1YF7e1X/7d3/xh//4i59cnf+lH1+S4/PhtPLTWAZQRqxnRqkSuh6wROqh9wLXMiKQhgIhBLVugUS8R4Boxxc04oLwobWo+5/+qb/9T8Eo/9Yv/4VBKsdCCKTWGiBLKbHGSCkd6niezyxACAEDIMQMYQwssBZjCDUACCigDYQGWmsRMBoBSCHSECAEIIDIEgjQ1BunLLkFUduX+2M5DEUx7KdZyAAEGnF72G3fLCbLdmjaRo1HJ+PspK56SBrgsJYf+9ZOx5dXV4/3+z2wdOgFoeBw3HQdT+NTY4w2jVD54ajE0GIM95s2jjLPcRAC6Tht275Y32KiILRGBaP00Xw+f/7i693hzenpiZBDFCYEKYyCIIgYO2w2G99LRsnVw8PfT1L/PY2p4ysEPvrBD36w3d19+dXPEXGYqwXvyrJ9WN84Lrq4PLu72wUeFcIGsymlaJAV131bqcl03HWNMWYQhwgyIIPicMQYcy7rujEGAMilPmgpm3r4+ut7oyE0MAnSru6GoYNoAgG5vDxHkPT93vFqY1gWfvC2+FYoY4wGqO/UKgongsO71U6Z49BbA+eIuj0vMAGh4xXVBkKICCXAdwP37uEuCUdhMAVmGE3o3fpnvu9//NlF24yHQQjbhGE8mp68fG27voJIdkMLYeD57FB+UTW70XAZRamGm6apEPSybLrby3W1SpJss1d9Lxh1paTWagP4ZtdHUXR2cfnLL/6wqg8fPfug7bjrx++zNwE0QeA4Du37Ns9z3w8YC8uu7fGROrKo177vtXUjhHRc9d6I7KOPPnIcIGTFqK/U4GLvyeNHr998y0XFHFs3+yTJXBZgy4uisZAw5nddzZh2XcI5ny3mCOC3b26SJCGEDB0v86MxgoseQmuMwgRGYVrV/OJsbJRTVs2zZ09/+cvPl7MPUvdqMl5iYg67n2HHzY9Nnh8T/xzZpKqLKEwdj4GeHA4FgLyq8/cR3w5Lk/A0iyKr7O3tLaX0yeNPXr54q4R1qBMHZx6b1nU9Hp8Ci3k/LE/O+kYqxfO8HAbpuDhMjIVFEHnHY5MkXhYuz5cf7lfX766/0rYL/UkWX2kDmUs9wsqijsKRAz2oco/aon7e9ZGWLBstqIPKOh+GoR1KCuPhOMRxnI6zuTF1U3RdTxlO4gxYfHX1dLfd+15YN/n17S8Qa/bFtqzXnk9gxcfpVddxl44taLQ1Q6OSCFycLbqmf3L2w9l0Vhb1s2cfeT66fvdylC4Df5TEAGMkhWqOUnGkJfjg6bPV/UYK4tLQWI7BCMAiTaO6tg+rg+dmnu/xnkIMuraVUobR5JMP//Qf/NEfdN327Hz+cL+OElyUu/e+L9nI1bZDmmIUAqABQAAoC75zRRpPRrXWWtmnjz8NnPlxt838cbU/TsYnXWGm6QmEoG6rk7P0/uH1zb12mbfftYLzZ48/ybJRico/+9NnEEJirXWYJ4W1higlPc+HUGTp9PrmOJ9PjdHH4hgEgesya6XjGoxCh6ZStWXRQgiL4ug6nlJmlGZKi/V6TR2ELM7GMwhIUR6TdBRG9Ob2NaWMEbbZPhDMrPkOs6eYtE2zbprz80vHpZdnl1w0Sg8IG4rRq3efHw+HMIN1uxuNozAMv/129/jxs65rOOfnZ0/btk2TaZJkXSsYc09PT4deDUMfBN50/vTrb+q26bNsxKVqqvbp4yf1sZ5Ms3c3r6OpI6V2mOd53vEoXNclhNRN1fU1xhBAZawcjaNhaPqhHYbWD1gQuFpLCCGhIAzDIPSapiyrtiz7NE2HgZdlE4YRQggAeHt7e3F+tV6v82IlVWOVTdO4rHIhBmvN/f3de49U4jiM4X5QrsuE6wy8Oxx3lGEEWTbJXNet64ZgN54GQogozBaTK2s1H8QomwZBcHd/c9g9uC4bTccAgGEYrq+vIYQAoOlkPh6PlbJ5XozHk6qqhBiUMowRYFHf2sXsEWVwtbpzHOe43wZRcnI6f/7tH3qeSxndbQ+BJ9N0lEZp13VKSc8NsB8R4ARxEsYLC4K+hxIwaa20YABQWaDewxsQKMikFBoi4jlgEAAYhBBhTPFOyp54NI68f+1/TH99Df7q/yVRSr3PmzcIA4QkoZJSgfpai0EYgwgfhrpu3RhGcVx1wGN4qCuAZRS7AEGtlevS16X58uXd7/3+56Br/+v/7I++t/BQuwGZXlxctEoMFjDmaUSKqkfAxPEI4vfvYDBQEECrLZdSSimpJwDhyOmUHbQ0CP/rv/U7f7LV+F/9/L9EICLIEAsRkNgAh0KIobXaWO0QQhGGygxGudTBGCMDDLBSWwAMktpFGFmIAUQQA2AhggAgAKw2BkKEAMAWAGghgIwgiPByMWsaVwvRICcJqevDpn44llujBEKk7zmwlBBycX7lsHi/ey2GLs3CY7XVCoZB6nuxw3qCXQt6IaxSRmuNiXIIaVrDuU5i0lQdJrBrSwBMFGfGmKqqqvrguEAquT/sQo8tl6chS5tKhmGIiZV9t93VjPmgV02bh5FDrBfG5OWre8dxOJdaS6VUXQkSl+vN9Xb3EASO57G+b+fzZRj57bB52Fx/8/wXGOM4DinFjosD5HV907SD1pDkLAwy3w8xcnebhnd7QgmAdLVaaa0uLx5vt9u61nVdWwtns0XT1KPRqO2armtGoxhDyRhT0t7frTyfxWlS5sd/9Ed/FyAdJiFzKJdWKC75EWNKiQet07Xd/erd0CvGsDbIcb0odt++e4Mhvbp6bIxpu5oxVrXVbp8/efzhdH76+s3z7WHDGNNAe2GwPD1ruhYhw7kEUDmOp7W0VkdRBI17enoBLHr5+hfMwY8fnY2yyd3967wopbAiAnGcjMfZzbs7xhillBGmlLl+86bIK0xwVTZaA4ewri8H3lEKB97uD5swjJcn02EQ2oA4TiDAbdtJYQckXSeKI9fatm/V1eUjx3EOhx1GzAIthB5fRsd8Y4Ho+gYSFMcxY4wPkjpOHGV+mFFK7u6vlbSYMKX4y+evzs8vPvnkk8MhV0pVVYGh0VY5NEuSmPN+u7u/Pj4k6ZgxtDnuT08uq6rAiFJKnz19BgC7W7/OsuTN3TdNV1xcXFRV1fXN+fl5GIYAgLrZA6iU4pRCiFjft03jZVkWuHi32+RVsVjOyvK4PJlOpikE9H5T7vYPQRA4DqXUc92zqi6EUI7jxHFalR3BYVWIk7PZk8tnf/APv9nvq+Xi3Jj+9fU3xg5B4DBKtZbbTdkPLWMkSSaUenGUFkXOhYr9D41Rju/EcfLm9bXWmlDUtm2c1JvDDuLH1HEXsycY3f/8l7//8SdPmv5hv61G9Tw/FK7HkiQpyoPnBhEi1MmstUogCMjV5YXnOQ/rmyRqq6oeeDcMRc/bsqriOOZcQbgJoxMEKUKkqncDr8MwMZq4Ln306FHTVBi5EDhJnJ6eXH711Ve+E3LJikORZfEOFtPR+PHjZ5v17n775nA4MBp879OneXH47LOn7+7629uX1jBo4yz1DoddVR9OlheUsqapMSaMObv9Ok0nnvjOFakocjpdSsln82lXt1JKrXXXdXBiIYTGmNEo64b2fcLi2dnZYj6/vbmnFKdZ6Hms77HWYjQakfliQRkGkI3GS2PU9c27LMvuHt4gZKI0k6oHwPq+s9vtq6pezM/SeJ6lzcP6OgySOE6HoaubY5qm2oj9ca+tCp3IGNo03WQcTScuwBZj4PsxHwRiqO87rRsvcH99EkRQHMdRFFlr27Z2CEAQKqWk5GFIB5kTdxCi74ehbfuyOkgp66pN07HgR0aDaD5hjH3xxZd8kONJdntzzxjr+74q+ePwfDSa1HV+OBziaJKEkTXoow9+o+2PjPrWmqqqHMfR2oRBpnRfVRUEdDRKsaObpj4cDmmaQWik4k1bdT1EGEyn09X9+ng8+u4YE4CJdT3atkIIQQhzWEQpllLu9htCyDHfjifxq1evCLVA466Hw9BlWVo3JUQ2SWII4Xa/d1wsZEcYDYIgz/O2bU9PTz03AMCIXjLsSg0o8qI0K8s8S+fjSVYUx9Vq1XVD6LnJ46v71fVutwvDECGEMfF9H2Pctm2eV54bZOkYQug6wWg01lp1fcW5mo9mbuBud3dhkGIMmqZGCAZxlCZhGIYYUwTxbpc/uXqCMQZg6LsG+QliQacYJCEHAbAhB3oAWAIgLVQASAsMgBYYYK1BVkMIMAFWc200gJYQJRVjTGuulMJSAPBdwyGEQOBXnhoQI0GwdKjyPOG1Q6WFlUZL2fS77UE5hkQOIgFU9enI8+O4030nQafx9nD4//7hq74ZLk9mP368PA8VFXsUEuZmq7rwggRST0DScyM0cBxkocEMAWC0GjRCCCEFkEFAU9K4icFMIYcrqyz6y3/mn+g2/o/P/ytcCoph6DOXOQyzpqqttcZYAAAkGAMEjDZCM9/X1oheQAscyihG0hojJFKGUk0ppgQzBDVGGAEMIAPQWgggsBZgYBGwCEAGMXWwT6fQsKoeW9RX5bqsOwlMQMMoijCmFmBg1XpzZw1pu9qSAeGAUuo43nZ7YDSg1PHcUAMtuPJcjzFSVA91XWoF03QcBMH9XecTCqAaeD12JtbQ7WE/Hc+1iTeblRPQLMk2D3evqm8pMRDAvmnbOu/7No5GSnSCqzQdUeZ+/e0/2u3Xk/FUadnzoqqai/NHEOL71RsAbRT7fuhVZbPdrrMsG49PhZAQhKen5wTDm5u3EECHOq6Dhg6eLM6sBev1ejIOEcLWdl7ApBrKbUEI+eTjH9XVYKznuO7hkE+n8yAIurYH0BbFsR/qrq993/iBI4TCyHH9UJlKoYFb6TsugNIYaAzABLd9a6xijDEapKPUGrnP7wkhg+ilNbYzSRoZjYSUD+t129YAGNdjbde+ev0tZTAv1phmiLBDnrtO9OrNF13PtRGEUEq9JGb9UA+8ZIx6ZJrEY0KQNJd5vru9fbfd7CGE8/H5aDRqmkYMkiCspIzDRGvtOZQ63s3drm+G6XI0ms4ZcttmuLu/iaJASLPZPGitlTJ8EHGc9r3C2KGEKamfPf1ktVphTM/PLp9/+znBEUZos95WdTmdzAhmzHMfdjcD74wRXV9nceIy5jm+zzCEFPtsMjspisIa7PoOxhBBKgXEGL+Psjo/P+2a6ub2bVUdP/nkn+GcS344WTw95pumq1cP94LLsvLvVw+jyVRZvj68a5rO84kwLXEtpLqXddMWrutev715dPk4CIJjvk2zyBiBsGUYp2kCrL25fffR00sArdKiaRqCWRCQ6+u3juMi7DksRFgLIdq2j+MUWJTEY6VFVVVXl88O+V3PD8cdd0kLACAMK8M///zzujlePj7b79caAD+KfTJ2XT9JgslkcvvujjFnMT9/d/NqNjnPy1VerBG2vpcw5vdDhYkyWp6fnw9DfX3zh52Ytm0LcdcPlVT9wDutFISIUe+Tjz+7u7s/Hos0GQkvHnqNICvLEiGCycx1orLiUTgpi4NUgwUCY5sk0fFQ7w93vu8z5nZd0fTrojhenn/87MmPv/zyd/f7/Wy2OG7ryBudnz2uytpjznwxpiz7w5/93mq1GmVjTODt7buiKKp6NwzidPk0iuI/+IN/fHE1cz1cNZg5juAQIUgoDIlHqds2vZDNKDvFGDPqEezs96urP654Ush+aLNsVNe5lpB6uCh7zw20NScni4F3t7fvuBySKCpqizFumx5C6LqOEMMwdHlRtm0rhCBKqaIoojAbjdPDYbNer6LI3+0fkjhCGAihJpNRFEWr1YrzwffdotwhbBAGfd9LKQE0xsqur9u2V2o4vzr3PK8oqrYREDA/jNq2FFwiSKXsFTVaGwhhEse/rt1d20IwXi4Xt3fvBO+TWbrZ75USmKJhaCww1EXE8dM43G++bds+SrLt9hCGieM4EMIoTO5Xt+PxGGO83eyFEONJFkZuVfR93wuugyCJoiTLxgjhsm5W4u7u/i1Eg+dTRBEfhMOCKAwgEofDERMYhN6h3EkpCEEIWQtM37dt20ynU4zx8VC0bUepE0eoKI4Ia4h0msZDrzDC1oKqaijFURQxxg6HnBDCqDsMQxKmnHeEQsqwMcpxqJQ8DOOTk5P71TvHdVzX85IIWJI8zhBCXdsqJd7LqW0rHeI4xHGp27SVsYOQA6VY8UEChzLGmEuYmyRJWVaMMcHVbDbCiPp+2Fb1KBm1bVvzVgrdtDVjzAJZtYU0TtM0SRJSBgGwxhirtOsRQhiFbhxlfa2sQVXfCwkhcKTC0pBuwIT5dWkB1hZiYa0ByABoAITQQmOg0cYqZC22WhrV82HgEiJXE9t0ylOOQRYa/m/8q9+BKf/WXxNqgO9XPhBaiAEg2DAKPB9ELqglVJYoCLjs8k67CIceFkAn8QD4/QB6CG/2x3cPu2PenHriz/3m1QeLhFipjJVBIlWjVKOoi4OYa3goumHgjDHfxZgopLiFEAJkANWQCkA4JIrQzg0BYgaR//lP/qN/Ckb5G6/+ktacQo4AMlIZ6BjoEiiUVshCShiEVkoONCIYD23DmEspgRYYYLj6/7H350G3dflZGLbmtfa8z/hO973vvfe739CDulsttcRkShGRi7hsVwiFCRhIsDHYCYFyUkXsEBIF28RVGShsx5SJKy4wQzk2Tqg4GFAsLAGSkNRq9fD1N97xnc589rzXvPLHJVQjCScpVwwV9/PX2nuvvc/a5+w661m//fs9j8MAegwkQhZYC6AN3lMCEKQAOQhBCC64ADFAIIRA/k7yB/Q+cETmxTQRadVtj9XW2nI2PZ0K7L1tupoQeHY+X6/vtbaMC5FmygzWW8JwP4xd1yVpBJH31hPCkziTql1vX9X1MU0WF+dPtDZRFHmvu67pO2UdyrNZEhcETptmFYt5miWH/dGYHcaQ8sBYrnQTiYQQZJ32HqRZ5oNGCPbjLi8owjBYt9vfGmPO2BmlSGmIEK3r2gZPKe+6nhAmeOLsOJtmebaI43i1OlAagscEFecnl1dXj29uXjfNpwGopmvq+ki5//a3v7VYLMri5KOPPpmVV7/+K//Ytz7+8OSkS5Kk73tMUF0f+6EWgmMMN5v1ZJr1Q7U8P0MIPntxTzjO8hkExlofoCY8xDEdemctETzmnPV91XVDnk0ns9PmdtP1MgCXJjmlJAAXJ0LErB8ajC/ihFzfvJ/nuQ/Ge2tMgFiLxB6b52qkaZoKFoE3YibOIwAZpVcPHwkRPXv2sbINIezi7LEcfZ7NprPy9vYWhCjPJvd3u3Gw6WUhR311+WC93Z0szi8vL2lE2rZdVfs8nxIcURL3Q+Msubi4zLJis973nW6q8Xu/9BlC2Ne+9tXq0MUi7zvVVfbJ1ffe3b9s+zWj+bQUGDFKI0oiiEhRLur6SBnJs2IcnBp7TmNjJULUOHx3d6eNJhR0XfP06VMI+P39qqm7OI5vr68BcEKQw9ESQt4oXVbVnuAoy0jf94SQFy8/AcDHSQSCXu2erVar05MZ47DpawhwHMdNN0zy2ZNH7zgbnj+7BYGkSbHd9QAaxsj9/V0I4PLyrO9Vns2KyVxKiSBR0hojjfYeQEoTAMe+b8dRYcTjOOFcvHz1cXGcnZ+fH44s4pO+a58/f57laZJGt7f3Dx8+DNe9d9B6uizOgidvnLnKMn/26ach+NevX8zmBRf0dv0NiHVA/fPn7btv/drPPP3en/zZ/3S3vw4Ov/vuU+8OEnfj0ECIPvfZLxrjgWNZFJ+fPiUXYr2+f/lixViUikDjslID9Dov07vu2WpTSX0EgSRRVhQFAnC3rU5P54xGH374wXyyKGdnu8NGiBhgFwAoyiki+NmLj733nEez6anRnpJkt6uc9UVRrNevEPIPH1ze3L5ilIxDAwDQalxMZ6fzOM/S+7vn+93rLPOz2QKavJiWBIvdbjOMajqdvtHdcV6VZfnRh59AiCCgSsq/+6cXvOeUdH2jlJmVJ103YoxdAFpZqTqCQdvVwzg+efJEJGnfdd6C6XTWtu3xeLTWAoBAINZ6+K3Xf+nm+m65PI0ivtneZbmo6vXhuMnSZFIu+04uFifW2urYSKkn5XwyK3e7nVQjxhAhVNfH5XIJoH/54jWi6I0T4PHQXj14FEe5twFhkKRks702xgieYSSKosAfvnr8L/+ZN3fy6p/94XpZChEpM8qxi0UKIWQiMsZoo5I0CQEE77Mk3qw2SkkAEEAAQJilqYh41w3euzzLIMJ11RuruaAiws76vh+kHJbLuTHSBw8AwUAIIXbHlZQd55TTpO/te+9+TyKSl68+DiBwwSCAVV3lRQ5RIARKqZy1/dBPykmcpLe3t0UxcdYbawlCiATnNITYWBtHmfcgBEMwOVQHRlnb9kUxyZJCKUUwoJQ6Z5UaCcVaa2tdlhbdKJv6WJYpRMR7GIlkPpnWTfPyxUeUofOzC6ms4OlicfLpp89G2SxPl/vDdpTjfHKCIbHWARis0SKJRRQppShm1fHIeWS95VwQRKyxSRJXVWWc1UZNpoU1pmkOXAhK0ChHjLDzLo5iiFHbbb2GkSg4ixhnTdu4AIz2Is4RjqwXbR8gy7VFCFOEqQsBIBggChCG4J0zxrngjTXWGKOtMdppbb1zSqm261Hf/5E//hMA/sjffZT/j//SPYQBUgIRIgQiDEEIRko9jG6Q46GuDn1X22ZAbWCScVAkyTw7mYhyMgeU13LcHY9SjaeT4nwxf3fuKJBe1QEFHCX1oGU/ZLGAkAYPulFZaxHGjKA0EVwwGhDChGIeINWISsAUZL/lZ//5P/1Df96H8M/85k++k2r8+f/LYxwsIYhihGAAAHjvgoeEMAwABAgjghH1NljjIcSUUAvQmxVhCAFjjBEBAASEGMAIYYQBxoAgRN+U+kFAIcAQMYQIghQAGiACAUPkvX9jjQsQUk7tD/tBdjyOgNlao4wbKAWUwaraUUaiSFCaO2+6rkEQOQcgRH3biIgpPRIsuIiGoZK6ZhRTksei5BFFwByOGzXK+eLEO+w94iIigEnVA+gxBm3bIogJQwRjwtLddpVmTBuljQYeMCY453k+b7uNNgojoVS/3b2KYpFnC2sQQSQAyLkoykld18MoGWOQyHHUFEcI0SiOmrpiDFNKhg5pZSMRQxSkqgBUyoxtW49yyPNkeXICPNYaLaYPrMFDP3Cuur5Pkigvsr5vu64OwWMCgSd5Ee32Wx8oY6yuD5cPn5b5xScff914hYlH2HPO5WiCJ2k6gUj1fW+0gwhNyknXdQhBAAECvOu66WyWpund7Wsf7MPLq/2u6vuqnJwMrUqz0vsAsUbQuDByOrXGBoCtsdpKrdsootars+XbWTp79fJF3a4BCFcPP0tJEkXx4bgZhjGKIkqIUvLu7lZELElS2VcB4LMHl33fNX0dCd4PMorjaTbXWjNGtNEQAC5E1wxS6ixPIpFwzruu3WzXIUAl7Re+54sJK7/10dcAUNNFMspWSkkQdyFEkRCCN3XlA0ijhBChpPUWDmPdduNbT9/Ni+zu/vVhv/HBxFE8mSy3u30IYDFbNnVtjJxM8xCcMaQopm3bHw87xvH8ZF5Vdd/2ELsoFt47JaXSOooEDCCO+eu7/enp2dAqY0wk0scP32q7vm9HSFySiG44Oifret+0bZoky+UJ8UkUR+V0Mo7j8ViP47hcniCIb1f3zo2YGKVGxoQQInjgbSCMTsqpNUGqwVljgdJ6xBgW2Uma5lVT1/W26w7G6MXyIUGZEDSE4Ixuu+Mw1HHC87xomjpABSHAUNzdjE+uvvfi4vwXvvHXtdtGAufZIkmmMIg4zpxzmGDG4H6/kaM5P31krF2v75tqO51NCSEAB+tgGqcQh7rZdF1VFEUIkCB0dna1Xu2rYyUESxIRgN1sNpxPizIJwXRdLZXO8zIROQDAaDmOuigmjMXjIEPwCMH9fh/HqO/6d99753Dcdl0r1ZAkkfdgPjvr+uF4PEymuZQDQdGkfOA0k34Dka2rIyYMwDAOdQhhOjtVSg/dWBRlnuf6w+dX/87fiew++6P/7epxOY49gJQggRGX/RhCKIpcGwmg8U554AhmozZZWoBAJ9PieDyOYx8CLPIZgrTvFXz/+v+6Wm0ikSAMQnCY+JvbF11fTYqc0ggEOp8tV6tVkiSz2dJoF2WwOjZ13TrnynL6xi2379th6I7HY9M3zoU8L7/4uS/HInM2rFarJMPGdsaYOJrEYtp1Hf/0+jN/9O9J9f8u/usA+NP4793+EQBA+FV/5R/MaH5F/MDPfOcW/Dd+9O+2/+Ea53fxXXwX38V/Vbj+Y7/166RZLudtN1ASny4fYMQJRL1q+7aC0M1m2fF4XK3Xl5ePjfNytGkWKzUihLTyi8XpYnb5wQcfo+NhxygMXguOI8E2q3WeltNiyXk09DKJsyTJIMRRlDy4eBjH6X5XLxYnk3LOaOIsODt9IEfVdUOapkmSpFE6m80eXjyo6+PxuG272ijVVrWRpq36YGCeFNW+jVbt//tb/C7+/wu/lG0AAMKP/cM1i/+9bAMAEP7Aj/6dxj9U4/wuvovv4rv4rxDResiTfBxHJSWEcL3aytHuj93QSxGnIYTrmzuEUJ6XgkeJSKKYem+0GZ3XANqqqqy1y8UpghB474axpZQYox8+fHh+9iDPpkmSAACFiI2xWmspVdu23/zm+/d3u922xijKsykl0be+9e2vfe1rzrn62KRpDiFcTGfOmbap15v7ptrNZrPlcjmOo1aW0ojReFLOxT/5I6vf+Y/+g/4Ov4t/8IA/8xv/f3HZ3/nTv5Q6/JfBd9nGd/FdfBf/tcXz3/QD2x98ihGx1gMAMMZFMfnkk0/HUTEmxlEyJtq2NcZgjOu61toC6Opmv93ee6+n08l2u/n000+zLIM/9jP/bpZlh93+4dWDqqr6vv/MZ94dhmGzW1PBy7L85JOPYi6++KUv/PzP/fTd9c3J6aM4Ti/Or5SyaZre3V3vD+vNZvWZz3xmMpl8+vwTRHE/tNMipwS1bfvlz32FR9lP/M2/AZFFwCaiEPz0C1/49Z8+/6nd+1+fWzVqOZudJkm5qbbHaueRj0UqsNCDztP04vLy69/4KmG0zLjVlomkabo4SXa7A+FkMimD1a1sCKHGIggijpJZOdmu7xzujVHL5dwY8+zTTx8+vIrjdLPeMC6EEIv5chzHvuv7sV9t1peXD3bHHUEozVKrNAD+TbbXdFKO2rZNn6T5cnZSpJPrm1tnLSW06RqC6NXV1aiHfqw32/vlctGP4yA7BJCx3lo3KXOC0Xa7Rji88+Qrr1+92B62Dx9eDn1fN/Wjq0cXFxfPP33OBGu7VsSRs6ap6mkxIYR4H4ZRMiqyLE2S9H6zwghzzq0fldSyGzAlQnCCaFPXT99+eqx6ow2hBCForMIIQgSVVJhza/Wb/F/gAhexd2YYByqYELHV+nDYMIoBDE8eP90fjt1xnM3OlA59d5wuC2nCroEAlppnASAXYAgIQAIh9NY6533AGkgDLHDeSeutsRB44BAADBI9SDoq2zb/zL/6l/++j/N35HP8Evyv/8DKgKCkHvqxadu6HgZlnAcAQJ7lEOMk4ZMiLTicFbTMmff9T/yR/9N3XuE3/W9/F8YMQeygRZgAgD3iAccexRJgpcOx9zyOojT9Z7/2e/9+w/hTX/i3A4SUMx88hwA5TZVCRhPgKGeAEGO91pZiIjADHgAH5DhESTKdTL13bVOrXpZlkcSZtDpgKtIYcNr30gZAOA8OQISiSFhjEaIAhuA9RDARPGGcIIRB4BhijAgIyAMSIMYQBhBCMMHbECyAAcIQoNXGSOm08cGhAGKMI4YhdL1uatUoK60ZKYFpzrXqjZWUUOcdZ8IFeDwcCA6MUYwBgPCw36dFHlyAMCBIJpOZYOn9/R1EXkTMQ0CwCB5BiIexpQRBFKRURtdJMqEkSZMSIuacuV9dE4Jc0HmahxAIofvtJmA3mebOm6GX3lljDWXUuxA85DSaz+bbfZPl8fGw02bMi5xSMvQyz4u+XxutpdTeoTgqiuIEQZ4mZdMeIPKUoKY9aisJQpRRpdRuf3t+9iSOyjTNVqubpqkghoJHIPDpZK6VreuGC+a99kgD4BnjWTIxxkk1yrFVUp+dXlkDm3FLEPReMY6DB33fT6Y5AEANLi8LKaWSKorirh/LfKK16fUhBB+CeWPITAn31lPCAIJj3xdF6T2iJCMYK926MCpFsqyklCmtXl9/GsX86dPHt7d3WoWTk1nXdxhRDAVCGEArZZfGU2MNY4wQeqxqwbkQQilNCFRKN3WbpQXjjHM6ShmCD8BTwkDAcSSO1YExhgkNHsxmJ4fDThspBDkcNphQEAglkTZDGheYUCkHhAOCEBM69EMSZc5LADREkLNYSRPFiZSSMsE40Xqs68o6n2cFADgSqXWdM8w7yCN0c33z4OKtLCtvb1/a0CZxIXgSx1nf1+PYdN2xLHPnAsHMeSdENIyDkgYiyCiz3u93uzSLTk9Pu65vm5px7L2NxLkxUo41jzgIkBC+3myePHrcD1XfqzTJT05OX73+VKomQGVdR0kUnBtll+eFdwB4GmdTSmPdw7eefLbru9c37wc8QoSU7KSqEGZZMqckKfKp1mqzu1Z6XMynGKYYkWEInEzfevSZT55/gOnAhBtk7R3gNPYeHXdVns0eX70nB9eNVYDd/vBam5EzPp2dNnXDGRvtEIskL8rXr26SNPPaEkoeXDyoj3JzeD0OTVbM4oTJ8RA8EXSmvdEKPXn8zqtXn0q9Y5HebO+ms4ls+XIxByB0bUUoTLI39mRcxGy/21vrEMacMcZZU1cQoSyLhl6FACljccT7fizyibW+bWtrTVGWcRQfD5U35uQL72zIOCjGGI4T5h2yBlPKhSBdfzzsNvPZ6ThqCD3Euu9bRiNGUxFDY7vt7jaJJ3l6/vLVWgiWFxH8D3/8Tyzni5cvX2ZporXuui6K+JvcnP3xEEWR1vrhg4uyzN//1jf0KKOkyPPyc5/9wm53ePHixeGwe/e9p69evXj33Xcxxj/zsz+trZlMi9lk0ndN3/eLk4cOhE+efbiYT/brO05FWZ4SmjbHPi/Q6Vnx7NmzOJlcPXrr2FUfffwtSIkeVBEXv+4Hfz1B6Ob+5oOP3k/zZJbHlFIXUN+PRTn13iujIQxSDftqN1vM60a2R/29X/jKFz/3+b/2V//yob4jFE3L4vz8tKoqzvkwyOvr2y9/7/c7Y4Z+/PznP2+M+emf/dvWmrfefvq3f/HnrDaTSTF0TcTFdDqdTxcYYxf8cV8RzIpimkbpfnfECL399tt313dtP3z5y9///Pmnr26exZm4uDivqnpz2Mph/MpXfuDnf+4XijJ78ODik08/AN79qu/7kb/21/5a3dVPnj62Vr969eqdd96ZlKUdzWIxe339EkKIEGSYMMbn09kHH30MAjLGfOlLX0IIbbdbqYYQQlImGOPtevvFL37xsK/UOB4OB4IZ5wnnHGMMgMcYhhCkGpRSSZY5r41RSZJh8MZThvhg91UvGHcuRBx3fd337XJx/vjxk/c/+KoPIokLhIB1Sjrs8Ym0RUPzN57sARAPUAjwjaodwkQ56YJ1wVvtrHbBGueVkNL3eljXqLcEQA31H/tf/IX/r9jGfzEe/cafzcuMxyzm6KQQZQIi5vZ/6N/95T1//V/6o9YFzOcBkkG5trfKYURTgIXzoPNSe6eM9gj+6a/9vl9hgP/Gj75p/M9+7PsQwX3fk+CS4LmRvm+wc0kUx3Gs9GCsgxA7DWIeRVQIIoxUEruHDy4jyvbb3aGqIWWLs/O0KHpvjPWjsTRKKBMhBA9BcAbTiDIGoHfOMQQFYRkTcSQotBFlHFMOAAoAgQAD8N5TDF2A2gfjvfEOIcQZpQB4a5ELQRlgDRcYCVoP1a7eb1evHl6dldPo2fNvVfV2Mk18cFJKzrm1djGb7g9brWXTNX3fXj66ojCu6zoE+NaTdzDir1684oIQCqxzIWCCo+AhoSBJxeGwo5TuDytKqRBxJGKpfZYVXdcfD3Wa8ViIoZePn1ztdpumrzEJUg/eeh8cxpAxRgi7v9tMi/lycTJq07aVNoPWMs0SCFCSZAAgb8fVakUIYYwX+YySeL9rzk4v71YvOMdxwn3QEHqttVLKe2+tRTAqi5MkSa5vnkcRj+OU0chajzG2xp+dnf/iL/7ikyePtZebzaoocmsDRjQAVx22nHMQ6KOH7zoAq3rj7Wid4pxaq0fZ9UNNccqYSJIsiVOljFKmblvOI8FI3dVdf0TIp2kax/E4qmDDKBuM4TvvvHdzvQ6elWXZtNsAdN1vCY4n5ekoTVN3WZZFUWJNsL5Tuvfe58mEkjgEaGxv7EBxSQiJIq6UOh6PZTmllFprnTOU8hBCmmZ933d9r43K8zQ4z3kUAnDOMsY45/tdtVicFEXx4sULhABEXqqOcz6bnkBA9vt9npdxnGotle7HcciyHCOaisluf88F2mxXGFGMcZ7nATilmHUaAGusDCHEcQwAZFT0Q0tQFkVRVuD1+l7wiTV+t1/xyOfZVCvX972ImPfOSD2fL+VonXOMiRCcssrY0Vplnea0LIpst1+fnJwopRjjbdsopR4+eNcYs1qtnAPvvvMZpcePP/zmYlkYrzHG96vbhw8f+GAOxzUXEBOAXGStDt4qpYLHs/lF3cginyMAFrNHL168aMdNFBOjwaMnjz/+5JvjOF5dPR7HcbmcH47b4/EoR3NycnG+eHdUB6narusEL96Yp/R92+trzuOuHuM4hR4Jnj59/PmuUc9u3l+eZs62TXMAgWbpjHMxjqO0bQgwTfIQEAqAMWGtRQgJmuzr6/1+G6fT5clUy7przeXZZ++3nx52fZrPGMflhB+O66YeHz967/nLb5ZZzjlXsj9WW0SQ4AlALIpp27bGuMePH19fXyOETk9PX716kWZcK8eYKMvSObff1WWxyNKpNuNuv/Lep0m5mJwiyNM0lWq8W7+WqkXYCRF5R/NsmqT8k08+3K52v+ZX/xAhbBzb7f5mHNvLy8dDbwRPN7tXjIe6HS7Onj44fXu1Xe0PK/JjP/mTjLGYi+Vy+eTR483tzbgaL607Huv1bgshJITU3TiMvRqHk8ViaNv7/fHr3/54Pl9uNpvDYdcZCSH46jffV0ptdkfGSK/seldBADDG64+fAew2u40HKCKLIp3e3tzf3b9fzs9liANHu1b6dlspMKru5e3aeKdHPS/Vo81ut9589OlHHrjUOu0spfz+bjUMkgmeZ6WyRmtpnHXOPL/ZjMouZ+ff/OiD69XNIPuPnr8+Pz9XvkU8UcrC0Wlt77bHx01ntXv58uXi7CFjbH/orHfrn/2FfdeP47g+NOM4Pn3rsdz3x87WdR1HTI7q4vQCdP1qu2OE13X9/OblZ9/9wpd/4Ff/9R//CeO0VKYdpTTAGr/at13bn91X95t2tWvqzrat2WxXjHy7k7ruhuevb12wvTIfPHtRFIUf1CDHZt8qOWRJOlvM9/vj7f1WStnVXd/3V1ePN5tNCO7s/KRpqm4YOeeI8Y+fvdJSRiIhPLu/vy9iF8dx37dKqWI6YYxKKQEAo6qKIgkBbbe7mMdCCCnlKFvvwGS6nBbT7ebeOy4YHWX//PlzkdFRWQ0Ggdk4DB7GHjjnzagUpgxDHKDzwDsAPQKBIIsccB744CHSBFjvqQVUObRv9Grj7ldGATQ/yc+Xv3wuBwD8o38Q/rU/EX7FQ//FePlXfuCX7/wdf+hX6ppdYkAGV1oPGmhqP/a9Cs4xYinCnltr9NB1o1Z/9wz9JwD7g7/0Mn/sR776pvH7/uJbgNHAImAsaFu1PVR2c5anGIRBWwcRj1M59OvjvR1N7weB0HKxSCIesWXAbBzks7vVEOzpg0vBhZJSKeVBoJzzSNjggDf+DRAK3ngPpHURxdrjhGMLIQUQB4AggBhjbwkimEBsYbDWOSOdlRhMCCOEAEqlVAZCDlkWLyCIBU6O+816tVfWx1GBMQTelWU69jpLUoTIOBjG+KScOxCGQWYRQwiMozwe9wTHi5NFHPG7+9dSqSQpIISYoskkxySEELTWZTkVggxjW7c1JFSZwHkync6dH97UUh72VV23yiqp+vlydtzvvPez+RQhRDCdzWYxT1arldJDmsZ5GjlHttv9bDYHDhhjMOZZOl8sZowx54KSmnE4qurRo4d3dzfjONbNHkJ/fn6ulLLWp2kOAYMw1PW+6xohphgRrTwmAeMwjv3Hn34jzYnSLSQ0jtNxHI3x0+n0cDhSitM0HkelbT2OHAQieNoPRmsLgCeECCEIJghCwaNxNJxFLmCEWx+k00nEIqUGTMIgB4gh5ZSn3ByHEELTd1VbpclEJMyEpO1UmnFKIudU09RcxEKIpukYjRiPvPfB+a7rl4sCIbK/W4dgpxMihCAEhxAWi0WSJE3TaG0wDBhAQiljNMB4u99WbcUiMs3mGCMAvHUhieNx1BDixfxsvX0JgBciNUZRwpumGXoZAnz33fe6Vu73WwB8AFbKgTGSpoXxtum7FIliMg8e1s1xtV0BaDlcZHlqrdTWJ0ms5DCO43y2NNop1zXt9ma155waqxBk82XUD80oq1H2/djG2fKwrQlIppPTkdtxHOfz+eFwUObgnKub3TA23/v5x3Es6mpTH7dCxGpwiUgjmjIO6qZbLE4nxSkAqDls8zwfZbdcnDmvnZGH/c1iMUPAQicYjR1AFGPMoFY143xSTPp2OwxDEqP3v/3zImKf++yT169vyslpRGeLyROZ7a313oPr62uEQ1EUQ7+hFE8m8+F+D/Egzep+/en3fe+vYzRr2r3W+vLy0XIOh2EY2u5Y333zg9oa0OuD37DJNAXQW6vWm9vTkwdRJBKCb65vrdKf/ezn7+/WUvZKSucchNs4I8ZKiEzX1au71xjFD0694PF0hsex40XRD+042AcXby9mj168/lrdHE5Pz+M4HkYOMYyiSFlnrY3jeLVaHQ4HhBDG+I3VX1XtoyjZbtfOmcvLx0qCzbots0dd27S15gJpLTEJfddudxvvfRxny/nkUN1LOY5Dq4axOtCx77/4he+To3FOj7J3NmRZAQAoikIbinA0yMo6tVpf9/2bGiJGRu/lKHma7ZqG7bb1qPpR3X39m0kUdcPgnOOcj87IfqAE9eqWCV4U5QfPPuE3N1lWBEKeX9+IiGFEh2EgjGLEnAfDoL1z3vsiTtu2DRJuX3W/9su/9jf/E7/1p3/mp/4ff/2vOOZf322vV3fWGojwdt8gihGJZd9JFQ7t+BM/9bNVVUURRwTVm+Nqs02S5HioISahV/tmtNYGD6TRaZpiLDAJiNBjXa3Wd1prC+lgQnfo99XzqqqWy+VsNlMe//w3PrDWvnz56m5bJ3mmlKKMGWOUw5TnTVNNp6ef+/wPfO1rX/v2Bx9MJpPVumKMUdGTTgHvZzM+Ovfy9Q2gyaFXX//og8lkstlvnTOMrReLEy5KMIS/9H//cUbokydPru8Oq9V9kkTvf/QJ5QxSUfejB44yUfeDRxh08rW7zkSMHDxsD7e367TIIWXBAQ/QoWpevnx9fn46jn3f93JQd3crCGEcp31/X+STulMQYkh5O0qPcNPLfXXcdwOl1DpHCPHO1N1YlOl+22DcJ0lSN8fZrBAxfP+Dr8+ni8m08Ngfml3fySwvdTAExxCoyvbH45HxSaBcWmkS7j0IAAXoAMIBIIgxxsg6hwICPigYtAfeeWoN1wZ2LW3vsV2NAAKe+ZT96L//P/nR3/m/+84p/Df8Cz8UF/S3/Wsx4cQDZ621LiAIo4hnaZQl/F//7Z/+f05Bfkf40V9x/0/+8O/+s/CXHvqn/+2HajxS4OEQCCEJ5cHY33T+r/0H/9M//Hc5BwDgX/wP/v3f+xX1p37nzXee++/85mdvGr/3zyxTHhEb1DCuf/ZbxSR/6623RJK2x6ruh2xaios0Zuyw21+/eLFYLB9ePkIEusE4Y8pJAZ0duzYgDIUAIGhr3OAxxsFhDwEEGGLsAFTWWReUR8z50RhBCMdIYMooIgAoZxmEHGJGIMHCOSf1KEetsQ+UU05EzJ0LxjoMUR5nCEBjDFZIQIaICmFwxlsIJ8WZlPL2+hjxWRRx7WQaw4sH50q22khjkDbKmMAYG+ToQ4gEnxT5blc555ztndeUYKWUNgYiZoyCECIEqurAqBE83R8aivDp6el+v+ece+ghhIzGQsSEkKEf0zTfbHYAoPPl5X53QAhMZ2XfNyGgJImWy2XXSgghCLAsJsY477U1ru/7yWSWpjlGzFmc59lsury5vR4HwFkJg8GIcxaPo9LaCCG8B96jJC7jOF6tbw6HKoqZ1rJpax6llHArfUQJ8oQijpkgTHCAXl6/zNMLCF3X1tZqIQRCJI6irus7vcnSOedcK32/3vVDk+XcWClHE8cMAQtR6LqDto0QglIOAIQQHg4HIQQmoK4r6/Q46MXiYSSS1WpLcJTnmfMDYToAW2QPEaCEIK0txrTve4z4tFzMl6feu91ugzBI0xQTSAhxzmVRyhjrh2G1WlFOGCNZlqRpylmkzTjKWmtdV62S/vTkoXN+f1i/eWyiKIkgU3pcrW4RQsXqjZpcCMFbJwPQw9i8mVSGcRhG8PDhI85ipZTzCJOAHLx4sKjr43pz47zO85QxAqAF0ABkAOzadhWnJwHoUY7aemchEgAi7ULjQUS5YxB5bzfbW2vcdFpCGIxVADgfNOOwH6rNtuWc5kUGANhuDifLguB4s9koZUBAiJiuGrq+IhRQEpX5xevrT7I0H8em78eIl4Jns+lZ2243m5XSozPWkDAMw8WDs+vXd2V+etw3s2kyyH3dbB4+eLuuNsfDncM7EHiZn42dunp03nRb6+r15sPmOJxdTCniabwosovj8aj0TZRCF1Jvg+DRul1X1R4Bj7B7/PhJO6Kbm5sAdF3X02IiIj6qKs0Xx2MLEeCcOmcoAYQw71TX14vFfLNdp2lq3VjVTZzw169uzk7Ol8tHh0OFkXpw+uAb3/7qsdpiAvvhEMWs3jfj2FttoigSceQdYAhLKSmli8WJcy5N074bXzx/5R3Ms4lzYTKZRVG62x6NIsv55XRyobVumipOglTH17ftOI6EkCSJnX0MAJajCiAkSXKyfLDZbCjh2gzOqiwrmEcuIOf1ze2LOCqitCBCHbb3XKBRV3fPPjxZngOASCAIAnho2zLLP3r2HEI4WjsYM5jROee9x4JsDnuCQMbSum8TBCLvJsv582cviYiiKMIIbvbHrCgJi1wIddsXRQEB6vsGINht93HMMEuIy0Vcvny9+uDjZzSOlTto5QD2lLKA4DiOyDoAPCacxUREST2OJgCB2WjUqG0wGpKIxMkbr0ulFKICYxpG6SyMozwEN44qixNO2Wq1glTUvUQIRVzwuFAW3qw2+7p1GHkHsumid6Hd15gQ3QwBwZhx4xxGkezsX//rf8M7cHLysKnrKC4opbf3B4jCycnJ7WovpZwuzj+5vv7q+x+WxXzb9tKFYZRIWgubNLKMxZPpchiG17erLEmTdCKEwIQeqkOUCIQh53gYBk4jo9wsSrM4pRA7BAzwzmrK4wCBDw5jcnJy6gE0LgxKK2vkqKpjF8cxgjp4tNsdvQOUM2u9tbbwHiIEOT/2vQ/gjY4Ww9Gh3eL1duz609NzloiqM6OtXOhXt+vpdPjyl7/0ycs7jPEgXTVUUsEkwdNpBpw9HDcisVEJpXWy75nlLnhCOUAeIBxCgBCHAIGHISDgfLAWOUODYkDyuDYThaKIBT7O0oGRqpO/53/zO6rX+//o3/xPv/SPfwEzApeBcUQoAAAEB5zx3jnCCGc0S6I8i//4X/1KkRYY4zQSFBPkXZnFp/NJGolT8vdwFwDAn4U/+ityjl/ONgAAf+5/8PqX71S/7PQ//lt/5+/+k//7/+6fiL0zEeN/+vd333n0T/2uv2Pf/Lv/ZD55L2/q5me+/iHRajGfAAS9M0KwfdsqrRCnypuXt6+0h5Pp/PE7T7e73ctnz6qum5+dLM4vCOcOAqUkRogxRjAFyFkLLbAEUcaYNlY6L41mlAqMI+q4w4wQyqgFUHvPAOIQcIIFSb23WgattXFWxBzhgLAPzgKI0jRm/Lzv017WPozWd31nj/t68l6MMG+aIcsywrBqRkpp2/RSNoSxUggjDQggANfUlXMuzxOEA8YBQFc31Sj7s7MTxpHsxq7TSZyV5XRUpgsd59TavizLLE76vu/7nlAUPJzPl13fMyb2+z0hxNkeI14UZdcN0+nculEr+8ZMPI7jtum9R5SwOOF93zMm5Khub+8fPnx0dnr5wQcfDkP/xpW3nBRt12it0yRTsqYklqNL4rIs0DDGxpihl0mEY3Hat3fe8seP3t4fVtWx7oZ9JLKrB0/HsR9lf3H+8NhUkUi0Pkopl4sQQPAOOQdDgARHaZIjSHfH523bHI/16clVP5o0i0dZHY/7z771FeNUrwdCYRJNAAEYEUZFWmTbzW6/q6bTOaVURMxozFka8Zm3AHh+fn4qInh79yKEgJCHgEzK+WQyWa/Xu/1mMZ2+89bbVVUhhCAEWmtMoJSDtYwQYox7g7xIlVV1XTPG5vmSUj4M0jrpvTfGIUjyvIzjZLNZW6uHXlKi0zSlDDFGkiQOIWjTZyJ3Loxjr5QkFIXg+74XEZzMhDGu7fZ0QhEGEDEArQvdz3/1bznn8jwXggHoEIJStVlBhmEIdjSuU7pgKKeUY+IjEUnZK6UYpz4oESFgVDdsm+5aSlscGEIIE5vGSYATygCAinFcTgqth/vVLcFM6U46PQw6jpky1eubVg2664eyLJ0DN9ev9rvNbJGPygqOtYJDpzBoIPZXV493+9Vhty8n+d3ddZzkRZk5j/KicF7evno2jt373/6psizjtHt1f39x9sS6PkDpg7pfvU4zZuxIuT0ed4TQIj9Jk3K3Xx2OayaMN+WL59dFUSLIJpOp81pr2Y5NVTWz2SJNY+89IRBCo7QdBp4k0TiO1pkXL55FQmgDrVNlWUAY5Ghm88yEoaoPp8v5ZCaOzQttzdAbjKK+V1qFJ0+edv12e1hBCLmgWlvBxHRaHqp9VVUB4STONuvd8mTOGBt6mSRp1w3OhRCgc+H8/IxSfthXhLD5fAkCatoDhIFSAjHjFFoHjBn7QU0X3zN0jbcBY9I1/TtvlXIYMQR1v03islceoTDo+u7+VRzHUUpXmz3EcjITVb1dbe5m0zMhdNsMxHtvvbfDwBjRo67a5s0bOGO1UgpAbL1TSgFBPfCY0lGpzW5rrGWCBwgAgt7BOM1AgMMoGaexiI0x/Ti44BORaBF1SnLOY8H/6s/8pb/4Y3+WsJDPcj94ynGcFYSgfmghhM456ANiJMtSSjgPACHUdC3hTIiYpDlhBHmvrYU+YIw5jwhhjOK2Geu6QQgmEZUIwkDStHQMQgj1qAep4jj2IHT9mBcFZlQPSgdHPNTWRZQFQpxzVnrnrXMmi1NngzEGeMCZ4FE+DF1Vd1zQuh36vjfGMCo8hLP5EgSilCqnM9JxrazSlhBtvNPOQgijKNLWWBesCwgDRJn1IRGMUxaw0aOMoygXcc6Tw2HPOZ/N57EtHERvFhxa29OzOSHka7/4TUzgkydPeJJPp2EYhvn85Pbmvjo2xaTEmFqrHAi76ggh1M4Z5yAiBBPlXD8MccIGJY1H20Pb9DoAMDRqGEw38HJajErsj2CUPUJYauM16IZxUAdOKMBpO4S9OjrEHKEsEpGPReQx4wgEALzzJkAaQAgwgGApsJzoGCqOZCRGmiRez7UvOzxR3up+32/v2lebX/sj71gc8nk2X06SSWwBUNrv6y4ARynmQkQJi1IRp5FgPEYUBBAREUccI78o80TQoas/vfktAAYhCApaDv12u+2M/Pd+OYn4Lw1ZH7MsM8bKZvxt/zoypv2P/kjxS/r8e//CAAD47/1beVHE/avr1W6/mJTQmGff/NZW6YcPL7Msq8f+UN05AJded8E0VZtkaTGfegQ363tA6GS+iOIEAwghtM4EBxFyHgIVjAoGYwq8lxBSbyVGg8EEYQJRUsQkQIFRDFEIgHjHAMAQUkoACtZqOWpKCSEIoOCDgyEQQvJ8EkVJ3R7G2hI4Lcvpzfq+LBKe4mZYEw20UVEcbTavvQfz+ZRS2vdjFkdCkMNB90MXJ1zpKitSzvnhCN1RW+8wolEUY0Sl1Pv98Q0r7YcWY5wlJQCg73tMIMb49PQ0SRIRJdevn3MWp2k6DPLk5IRSut/sJ5PJOELvQBwVkUiVUoQwhIhWpmmqyWTiHNxt94vFyXJx+vLlKwgxQD0iaFT7Z883zjmE0LHup7O5t8Q5e3F+1fXVZntHGeqHFuzgg9PPn55cHCr46uX1ZJo5V6VJPpnMsiRv2zoEp5RyznsPrNWEoVFVTVPlSR5FvCxnnMXH46FpmyhO3ugJ1m0/my1EhF68rObz5eOHn3n++pOhC9Mou3p4DgCo65pgpmTvPTo7vWSM1c0RIURJvJhfOC+l1GkWUYq1VhhFznngcdu21vq6bgG0GPqurw5HWh1bD4MQb3J9/H7fJUmWpRPnvPJ6f9w9ePDg9PR0fCWNcVDZ4BUJXCqVZhHB8XRyRnDUtjUmQQjhrJrOSgCANr337k1RIaFoHAcA4HQ6tdZ0fWNNyLJCm3p/2EVRdDgcJpMJxkBphRBommoyKeM4FkLs9tu6qX0wCAE4whACxDZJEsEThjJCmAc9wVRKSIkQcRSCdt5a3Q3jMc2Jtu1m9zyOU20NdZFzBhg0dhujQSRiqXSSxEoppZssnQ8KBmCN7ZU0aVKMo0cYGONk2KYl1L7qxgOLwKFqgecu6LIst9ttWU4opX9XKbsbW0aTu7s7JtzJ2TxNUzkG45pe3lOcJkk2DEOA7bG+QcgzmlKcT6fztq2lHK3ZeQestdWxf+vpAxA4oynBnFAkZS9Vyzk/HA4Y0bKYD2MXR0leRHrU1sD9vi6KwjlX5CUhJI7j65vXapSLxWy1viGEjoOEzPRjNQzi0aMH9/evxqo9XV4JlrXdHjgwnSzb7oAQiuN0mi/2uwojppTdbvdJkhTTCUYMQuSdt8Z3Xf/06bvWgLu7ex9U8DB46h2KokRJu9vfXl+/4pGdzXPnJcNJzFOnMww0pXR+km+2tXHaOMRFFFGhjLRBKtP0u5azOI4jAI2IEIDWeXl+cfrq5ScYIwiYoPGjy6s8m79S10QIBgOAnLdVTSkVlBBCbAiMMRAQQNB7MJvN0ihWehzk4IKLoogxNJ1OQ3Bv4niz2cz6sN9svXVRFA1D56wGKLRjrZ1P4sI537R7B3vIe1pmCo8BOGt8GIHxpusbDABjPOa5DsYY244SBUQpxRhzzp0zWus3KiIIeAAARvRNUpgJKkDAqADBSaMxw0aboTcsAnGcIgSUsuM4AuC1lhB4EVEEPAWIYEIQSaJ4VKaVbWABYwphMMYAEBhjEELrnDGqbVsfbAh4u93EcUIJ11pjArRUWRbDgLqmL4p8pw5JFDs3AoCTiMGYtW3rHZjNZpvNBhJaFJkcOquN8T7CFASVUyYCqnZ7pZRIEo9RWw2Q4NOzi7apJuXMBb/f1x4Qrc1qe8yKlJN4ddziKzadTKIoyrKsbdtsOhmtruu26zofAMQI+KCUci5kcWnMKKWMWBQCbNv+jRa10SGKc2fxt9//tG56AACmLABMI6Ct2u7GKIom5VKPrmoGg5xBRya50DI2iUhiwROESPAQYmihM9gC5NLgEuwEMtBLojMrSD/GCmRAQ9I1E9vSodL2KERCy2l8VkST2ELfNKprzaEZuYCzCc8ikSYi4SJCnCNGEUQEYwQghJxzRJEyqpe91YNzbi4ms3KhlT12XTV0v+Wn/9x/+Kv/6e+kAumf+3O/7y/GgNBjVWFG/8Jv++DvRyx+eXjjDf7Cv/Sv/JN/+H841K1gbD6dcZz81n9lcMB4EP7jP1J+Z88//fvfeB2d/N7/VfPNl9fozi9mi3S5cBDX42BBSJZTG8DLze3f+vpXReBf/NL3nJycjOMwjJKKxDtHILLBvzGPCwgSRgMExjngYMKiEAKEUGM8AoggpIhSTFo9EoTjSEzi2BEqPIQAvFn+Csq8g97oYJ0HEBECIAwuIEgBApDSxTyeTpd1s13vVp3C13cbzizGphl6rfWD/Orq6vFhX1lrtZac8yji+8NOqh7j4CzAGHuPAECcJwQ3lETOBc4yIVjX37TdIc5SSkTfjcvliVIjDGGxWFhrm6ZRSt3d3UmtMALvvfv5zWaTzCfW+OvXr2flxDtAcS5VZ2zIssQYlySZUqquaxqR1eYAAORxRCmru3pf7d5+++3dQRqrIUJaj5Tyumq0tk/f+exudaQU932/2+2apskLHsXIhf5u/RFAajKNrEPj2C2Xcx4n+90haDcMjQemWW8hoQHoUbcAjZPJYwB8FifjaNq27mDnnJkvilE6j8Jmd+i71TvvvGeN18piAn7uGz/jvc0nMedUa13XtRzUxfnlqHTwKI4zQpCxymiHIdjsj5j1EJA4Tru+knKklEaCe4+8VyISXdci7JKUAOBv71527TidL7e7I0LAe1fXTZZOGOOcBYg0UmR3OMRxTDEjGI6DisqUETEMTVMPBEcIRN6hYeijBPb9GEUJxqhta6laiIJzzjmPEFLSgkAgoFpLOYQ8Lx9dvXV380r1r7wOKIC2PrRtb63FGM7mDwlFt/ersswQRYC4qlrP5pk3UZJko6wJFgiKKEqtNVK2WjWz2QyApKp2SocoigI2x2o7m02999Zq5weIQj8oTABCyENwcfkoTWavvvV1wlw5SeIs3u7XEFAA+diNcZw+fvQOo7dt2zAOu6FKklhKT3BU5HOrsfcQghAC3h/qpmkRgmWZn50/6OVojCEcF9OCEusduLk5PH70XggjImo6PcWIybENnmkFJ+Wpd6jI5wCAu/trznmeIecNRnQ2PTkeeoi6+YwBSJ0LSiljLBMkAJDnBSHUOxBC6Lqha8eH5+/GYvbs9TeEiHicGGP2+z2ldDqdEoJwq0dpo1i0Qx1FfD4/DcFFUVQ1x1EdKIOMFWmOq8NGK1sWs3EcESLT6TIWSdvWlHLOufd+6MYkzcaxV0prbTfrHaViHFRWMDlqrU0cx1W9A8CnhRBJMBoJIapaxnEqR993kjFmtPvbP/fjlAGEAACEEHy7fb3d3RAafLAhkChKuq4dxm4xP4MQDoO29h4AYE0o07nq1eZ+bxVCAMM/8G/+9/umxYjGUSSlJJg1XSulhARmWUEIub9f53k+KwtnrFQDY3gYRkJICBAj6lx4Y7iltInj2BpNELBWAwxccAAAHKwcAyUxJwgjba2GLOXxTJqNtoEy0fftKIc0jYFH0GGEQN/3SZJZa99oQgsh3iRgD0MXgGOMGWMghHLUWVYAZjGK9WiNVHFCnTd9Z05PLrU9WuNDgAAApVTwlnMq5QhDUFJPy1kUZUobIeKqaaz1Ibg0i0MIEIIoirz3WpskSUIISkkIA0Ko67qimChtZrOZ7Lq2HcpijgDO8xQT+PLF6yhKWBScc29+ljfjRIhoqRyizmqGIMcwZQwYnQsBrafGj0aXy3mnRio4wEREiZYqhJCmKcTk9v5eal3V9exkzjmPARVCcMHiNG3aanly8vz58zefqK3R2kKCESZdN3TDQAgjkBAKKMVN1XqHTk5OQnCH405EOI7TtukoIxCG2WJ6c7dhNEIEbncbQlmalHE00UFIKNZVe5SBEMIilmRpnpVZVnAWQwghRjI4Bx2BIYcmZyNjlfa70Ja9woc+OEzD2JJDIzbN+HLTysaLCZ4/oCczFcFN06xWTX00wMCijM/PywcXk8Usz0QcU8EIJzRwzhHBAIVIsIRjFLQ14/b+WggxDgP2IKJkvV/d7lcGull2VXfjz/1T/9zZn/o/HJW5rxteFMVydr3dWW8op0meEcqCAxhTwWMGbbvd9Xfr/+R/7n5FzvEb/ke/yzszdj1nZD6d8WTJUIB2GPvG2JEnKY6i//Mfmf6KZOX7/zs/czk/oZxBApMyjbN09HZUepSSW5JlmbdusVh87nu+ECXpvu66fsRpRAiBGCECA4LOe48hZSwKJLxhHBABAAgknDLBOHVBaY0JLNJ0miQpxTkhKWYIOBgC9A4FELw3AQRIISEMAgBAcCC8saeFJgAt7XgYdy9evB9CO53SvjsKEQdPjA5KtyKi1koIIWPx2PVZlgVgQkjn82XX9VEknFebzf3p6dl6vXUqEOaMq7gAHgJGsupgppMzADxBKM/TYRjatlXGRVE0SEUQfFPxdHHx4Hg8eu/7pp1Op/Pp5Wp9C6CGyEIYfHB5VoQQ1rt9HMcIIUrp4XCYTIquaxljwzA+fHh5fX3ddV1ZlsbY2fSkbfs0wc6ivrVJyil3bbcLwTVNk6cPEAJRxBmn6/U6zwrCxc313SSP8zzZHVdpmo3KUYrrbitimPGHTVu9qSPAiPR9TyhE2AOE+l6pEVw+eKK1VWrshwaR4IOxVivdB+zPT04RJEM3TKdzCOhud8zSCeNI67Hv+/fe/dJm1ax3nzIqKKWQ+H6o3pSVgYAmxbTrRq1skYtRHurm2DYyEsXl1ZMXL57NZtMoivp+eHT1FEF+ODRNu764uNhsNtvtdrk8nc9OXrx4VZZTziKl+6reJdHs8sHbnPP71YuXr9+fzsrzswer1Wq3X1GGJpNisz4IkeR5CgFVygohlFIhBBAIRhwDRLkHcOQCtW2rlGKMSTW8+/YPG2Nev34xmUXdsKnbu93hdZLSiDw6Oztbb26GsZtPL08Wb1X19vb+g8lkNinn1oLd9oCw55yqcQQBpWkKUfDeaDNII9u2z7OSMUGJmBQPMEoZI6vNM4SNtVaOPk9jwRMI+KQ8rauuH5oAh6E/QIwghMYY58LV1ZWz3lo7jqOIJygEbQYIA4CBENINA8RIS5UkqfcOeA1ClKdnq/sXDu5YHFGcHw/j1cO3syxbrV9L1WIM227Xtu10Os+S5cPLt1+8eAHQ2A8HzqkcPWepEHEIrpeNMTJJkjdl85TSrj/44LQKjx9+MUvOPnnxU28miyiK7u/vI0ZPz076vq3bT0Eo82zSqa3zOhNzCLEQtml66633NnjUdyZNC0KIUhJTkYri7PSRUfb19QseIWN1N3aXF+9st2uEgRDijehnmhRSWsKGspwdD+10Wg5jvdvfaTMul8tJ9lSb8XDcnJycrG7v2q46OZ0cjztKxTC0RTEBgb5JcG/abdNtzy6uhs5REidptD+sCA1lWT5/9sqG6vTkDDgvVW/NmESx9yh4RIgGi3xmrUUQQcIghGUcW8YsDHmSOReKOOWYckwAhAkvlZGdaUUcIYQ459WxDs5zFhlOPArajjQWwDkcUMTEbDI1atyFGmFkvRutpYJMp6mUNYKEIuesFkIYYwRP5DgC4gFkSZI4rzBBlMLgkffeuQCRJRS5gLX1lAmEEEYUIWDHcGzWiBImuLKOEz4vhVe19cAY92bW184KIRwMDmJnesQQjalHBrEgzWiM4ZwjDGNBx17OJjPOokN1zJM8QGj9SAgSjAkhOOEEEWMNsoCwJI5I38lpuTgeOkIRpRRhS2FKCLBOa2WnkymGBAUQInAcahpz6Kzqe0Dx2fJkaJthGM4W+SKdB4ACDMq7NE8IpfvqGIJ7+s67RV7KYUwz0RwP3vskSbz3CIEsiZUeIHSr1eso5vvdsUwzAqCVdpKVhFLkguo6O7anp5dZnjjn5nkphHjvvfc+/fRT4NT0ZGqtjTkjhAgWj4M7z65m05Oj3Z6dPNjtNhhCiIyU1gOopfEuHOoj45FzAUFmNJjMaAiBxBY4JABKIxvFLSDdoJV1aRuYBMxynGGUAosLCUUWLaKLgR8prYRwsfDDOB7qftfAECeRn0/E6XwyKyZZFKVCcEEJwggGRCAAgGISnHcGEkxko+Wg2qYBXlsj+75lPLLKK20PdkswffRv/S/X+w9ZmYNxW8m76sioDNPp6dhaefRxMTEEOgA6Ms7RftzvgZO/9p9b/cqRj/t1N1bT+YwBerzbOrtzXqW5eOfdRx5lFgQXwG/8Qx8fR4VJ9FN//Ol3nvvz//Gv+nkAAAA//LtejDYebteOyrpbZ7MIa+6JWS4eYJGOGg5mXG+Pt3d3XJCn773LeLJra+udiCPbmyyFSh4C4B4xD31WMGlbj2IUwLrtPHACx219kM4VXDRcJAkrIKYQcExYAAgAoiQMFkIMiAIAQIIhgN4FiAiCNEJ8KWI9CYf6tZFdkpb7/bW1GgWEKOp7nmcL59w49lEaWQ+tEWlGtrt7jOH+cMc5R4iu19s4SkNkvHfITZUavfeBIcYYZWHogMgS59l6e2eMPj09gyFazmbewOcv3n/46CyNaX10GGHKgPXNsalmixPnnA+2rWrGoLPYWjMvrry3cRwfj/uETQkQeczruk6TBYKRMRaisFrf/Opf9Y80TT+OY1FOh3EEJERJVh/3GCWb/evZPBME3949Pz2bApRm6ZTg+HBYJxlwYBwlE/QsFcuTWVJ3+6YekEd93xPMExEpKSFy3tl8enrYN4EeJ5NpKEScCGU6bRVAgTJczvOuaw9HeTjU8Pxhni8gkkm22K4/nUwKCJg1VkpjjLm+fllXA0HTMp8YO+6OK8oogkGZAAF0IdTtPgAn995ay2jcj/XV4+XF8klfj8dmk2Z/p/QsBLXb3w6qKmU26o5FyPj+UK8gBkmaXyyv3v/wFyHA2h7vNl8HAEBAoyjlLOmHtm52CKFpeXayeFBmtqoqKzHlNi/o/f392elDEIg2w/5wHUeAgsuIXWhdE+xFNus7vZw9gIAaMwghmnqI4znO46GDWRRNirPVat3143J55lzYbO6jKD1bfGExexTF5IOPvhaxGCGwnJ/2nW6b0YEhOEsohp5DjRazmRDMWosxX63vFrOHs+nDuuo3u9c+KMYBAMgH1/fbzfZmOl2KGO62e6X76eTxgwcP2rbZ7XYvX9w+vHyUZ+XrV986O40uzh/WbdM0R0AMgMYFbwaPnGWYDcZ6QIoy6obXDlXeQj86GFmCXECqHbTUg1JjFDNnyWfe+zIEVCu32+2k1PPZWSJOX1y///Dhg2Fs2351fn6e+tl6tUuiIo1D2zYIIYpLwbNkWSyXJx988K00nSdJNIy9UTLP80TwumoW83kiLpIkihPRdZ13wHmz329wxOdzc3t77RwUIi5yxBjTple6LXgSx/Ebw7yLy9O62Vgv0wxbJ09PLpUM+8M2igPjqJwk6/XO2nA4HJRSVW2NkmmUi8lSa7k7vK6bozEKAEcFL+lJ2w3zxdWx2lKeE5r3nTJG5uU0C+Gwb1N2cfKQPXv+Yd/tACKRyLbrtizmw+COazebnVC8l1L3IwAAcA4JZGRxfvrGbvjm5kZwcfXo4d3dHYRQSZWm6TvvPG2axjsTCdZ17bHaR4Kfny2eP39OcH754MwYU9ftIimtUQxlsu988Keni3HouIDTouz7dpCKcr48OSeM9f0QLHZSYowRwl3XU0C6qi6yPI5jY0xdDwhCRlHMedu2EGIAAo2ZlAohrLXFGAAAhBBt2+ZxhksqtdLG8yRiUeSNVkoHCKSUcZxiTHPGAnrjRIoNCs65tu8RJFY77wHnIk4Ewq6uj48eXmFMpVRRxDFlVdMQBNqmixdL4IhgsRo1hgwGkkYRRWroBqVGHywjsRfCOO2cCRAQgiDET5488dZhgO9v70owmc8mWg5sCRZFprsOjlKkeRylWppRq7SclJHo5GgtPDlZPL56IEdzOG4vHpwYI719E6+mUo2EAKkGzqnSrh2aspwulpPlZNF1w7F+cXp6GsXp/f2aMXGxuJxmSVmW3nvGWJ6ngqA8ZjXHkySRckhnEwhxc2wWk/TX/Oof2u0OX/9gW7dHO3STxWJQ/nisN91xdVS7Xp+en4k4JVQY6wZd1bKdlDPmCMWYx5jHIU5wCMwqZCQYJAMQMQ6TKCQZxCkDhsHBtR33kFKHQ6fAvokHOQdeAb04P1nMy9k0mxRJEkeMIIIgAD4AHAL0wGMPKUQwOGuskiNBCGKijAQAUEqdN2nMAQxKjSgCnAQcJJEgh7rdrREXk+W0jLq9HoZ69HgxjGpf9YuT08qTw2aLjK539z/02//x//zP/yffyRg+90OPEHmWl+XNi48ITrJ0au0RYT8tlw/Po+vb66api3JytYzaj+6V8b/q9+wZpT/5J7/8S1jLj/+ZxwCAL/0TP/3y9jrL85cfjb/hv/mPzefzR289Qpj+/Dd+Rin1zjvvPH4y19YcDnfDSjEhkiw9vl4FZ8uzCwdGqTrMYoBBvdEYBsCT8VD33iGE5NhM09w7djg0URTt6v1iOsmimAGAvU8IFoQFr4w8xjQLPgQPIMIIQwCAD8AHwih5cPEYQLPaf2Ssp7jgFEEPCcdCJEmcGTsai63VbVt7h4syaZpmGIaiyJwLy+VyHBQhBCKmlKKUQUAwxiF4Cy1CEGKFsItixhjmPA7BD0NdlhNKufbjarsy92rodZ5NyulJ3zc55wE4bYZRth65blTDocuTFAPyzjvvVFXVNjIvsjgqQwjeMcRs3/eU0jSL+p5vNpu+0845SkkAJgSQJcJovj8cI5ECR0ffTGazKC6VND6MbV9jaL33abYMwGvTDtIBUlonKcNaj0KgSKQUE+dJ33ZZli2Xy3Ewx7oOWqV5Mg4qiYQQc+f1brfZr7oo5gkrk7McBbS+u8WY3Q9j0xzyDILwd+o4mkav1nfTyTJNiqvLy7o91t3WORNF0Xy+bHtZH6uIx4fjLkn42en5zc3NyXyBAby/v3fOAQC3mz0h1HtgjQ/BxQnb7zcQgiim2gwhOMbpbn+z3+7qZs84jOKo62rORRSRBw8uCEGr9U0Uc4wxJmF/WC0WJwGI/WHNRTmbnDMy0Xo4HO+jmJZlQWFMcdo0lTQbyq0Q7MHlOaNx1x+a9qhNByHs+kYI/ujqiTadd6gspvN5ud8fvcMny5MsnTZNt5xOv/nRL4TgAQZSjsaYsizns9Nt9Vqb3thBKRUnieBJCME5Y7QJHu52u9OTB0mSoAPCiK7XN8vPXyolAcJCxAgSoy0XWZTECKG6rhgn2gxZlr2pGX7v3e+5uX61ISuIobGjs07VSgixXEy9Btev76bzZZokt6+vp7MUI45oIBTvDnsRZ/vtZnc4ziZlnk1hcJHAEFBj7IsXL8/OLq6urpI4s9bersVms0PYCy7atgUAnZ2d1XULgLNO295yLoyV/eBfXzc+qDg6ydKsOg6T8qRu9sboKIoGOUyKfBjrQ3XvvT87fbDZHKKY9kM3DjoW8ygWk3KOMfXeD0PXd59o20rNBQPHauy6Kk7oZDLruiZJRJbmcnTWyck03h/Wr69fpkkOIB7HcTqdhAChh1GUKKUYLV7efptgilGEIF/OL6OYf/LJh1VVydGmaeY9ECKOY7Rerw+7zcXFmRxt3/ezybm1VjvX1N3Z+WUc85fP0MWTt+u6JZxMJydtOzrnJpOMcM6bpqnrejIpTk+XIQTvTVGkQiRvgp+uNQiHLE+yNIZIa8Wms+Lxower+9cQGEEDJ5jAeF8dm6b74he/1LfdZrNWcuiHijTm5MnTL3zhveub+2PdUgLSSNjRKmPLOIUQ112bUp5liTF6Mi04p845jvzd3d3V+ZPpdP76xctHj560bbutaxgAJ1hkaVVVGKFyOacwe/fpu2mW/cTf+EnnXN81CIY0zQelaUBZkocQAgTDICmlyqk4jnsbGGbBwwC9NhIDyKl4Y6I+m5fOSwBN29WcJWrQwHuEaBKlSrlY0KbrtDbevfHkbRFClJIQHEHIOk0pJYSEYILzx6abTsvj/lAfjwgSZ2wRz7BFxCFgzYdf/7bp+8+++xaN4aE5BoTHQfJYsyjyxmKBEpGOY+9cAB4URd52pm8DAFZEvJwUQz+2wxiC01rDEPq+JUQAACCE5+fn1njvwYMHD+u6/sEf/EHuzGazSYp0HPuIkoiiiOH33n4itU6KwgcrBCnT02EY9/vrw+EIZbsskjwiHqC72/vD5njsw2bTBDFJeXQyX+bz6aBNf9xVu4NyNqFlnlNOkbEOYERh5p3uWh2g4CKISIpIItAboo1ijQWHSYIVYL1ho2R1y6xflKkX8fzpoySJijKNI8YppBQRjCGE3lOMMfAGhIARpBgiFwjyy/kCYa9k75yyTlZV5RKPa3u92p4uH3zlS9//6uWLn/u5v52Y5kmJZssCMX2ovsWUWzK4eflB1eqTxeXUQW/YaWJk13771S/IjP1Tv/+Hy1L8qX/1L/83ftPjrh+WU/zw8UOpuixijx9ddZX8xjeen5wufvALp1cL3G6apPQXlwklPMUXv/iL30ROfeXLX3nyh79hR/W5dz73L//z8XfSjl/8v/23AAAVAD/823/ynccPZvO5NnVz7JruVo79/c3ICMIsds7d3N8Pw/Du07cX5bQsskXsKjXmKd8d7pwHXFBGsJMSOSC9CiEkcYSYoxZpq9uuchB1QcU8jkWSR4kEgAeDgxYRNlZRQgFAAIQAoLXeuUAp1toSxoSIOUsns1kkEITYSHeoN86Gqmp8GDG1Ug5SjkKkTd1Z48uyvLy8PBwO3vtxHCGEmEAlTZrmBCPGmLGjMVYbCaBq+931zYthkKenpxjDk5NF19fKyCQTTXdI01TE+MHDS62tNi5AsN1vrBuP1do7HUUcAFB16vJ02g3bT559ZK2lNG/bYwiQUtrLuusb50wcR1laKGWzLFssTozpvbFFlu0P667rkjinlAZvt/XNpDwtyvP13a0PvQ+jdR4ELHiu7ZFyeWz20vaURM7LQR4wtX7QOJ5Za4dhuHx4RQjph/bhxWeHsfPOEwR2h22eZ+MgEaDBIhSixSzHGByrfX1sFouliARCU0aF0UEp1bZtWU4wxozyKKL36+v71S0lJMvLvm/bth16lUQZJnAxm2EMD4ddkRZvFodJhI0xWVZwTsdxCMGKiPbDCKEFBCRJ4pxRWrbHivOY0ZgTyAWiDIbgvffO2TeaPZRSYzREjlJyrHYYUanaqj603ebRwy9wllqBt9v7qt5iWgghyuxsPjvbH+42h9X+cNe1w8WZUPKo3Ng0NYRhPp9L6VarVV7ElCGAfFXX02lhrI9Eqo3f7Y99P/7cN/9WmkU5E8+fP5tOp4OS/WjPzx46ixFkGJsQOgCAMcbo4D2Ko7Jp2iTNXrx44byZzabrzeurq8feg/3+wJiYlAtChFZDWSxERLVy+/2OMogJkLK7evg2Z7lWbjY/3x9uETZxHMsReW09Bgi4OFkmcX9xfoUweP36tRw9RoxxmmVZO+gQ/HxR+mDVoNIog4CBEIbePHnyBAQkpdZaKqXGQV0+eHhze/1GD20YBin74CGEEBM0iSaRSDabbQi2qo//L/NwFULmDBQ86/EolR69wgTcDs/HsU+SBEK82d5aZ0/PFq9eVVkuQnCEgK4/1lWHMY5iAYAdevnW4yUEQkr79Ok749grLWMxv755QfAmjWcIgaZplJKEUCmlcVXTDFEUCZEInkKAg3fWgyjiSVx6R09PLq31+90xiiKp7Dtvf263OzDGp9Op1hpjiICPomgxO12v7yGgWZIsT88/+PCDuhqbupvOLx5dfOaW36w2nwzHjtGYC3KoGhKM3u62SqlUsMlyqbW8efXSe58X0zhL8zxResziKMsTNQ5aDacnkyRJBAGLSQ4AoCQAANIkt1pxlL3z6HEUxX/zb/6ESLDgbru7qw7F4uR8Psudl+u7F+j0YjGdHbarywfvnJ2dWWun0+nN/fXhsCEURRGfTCbuwSmyMmUkwuHxw/Mvf+EzL168cF4VEfcQRVGku+r8/HQ5m49jfz4tXr5+tSzSZuy188Gqer+ihHFCQwiPHz/6+Z//eeeChvCL3/u9TdN1XRPHEWdMSomCn8+m89nEe1s1R4xMCAFCKscqS5I4EvtDg4mHCGs1rrfD1eWjqqrOz8/Hcexr1csRQF8U2XQ6lVLqUctRH7u6LHOmqCDcGcOogAHIQfVtE9Hp2EuvR0aYQ+Nxf5B9X8ynUZpgQhBCfd8ZqxkUxqpPPn6dxFkcJ8fj4bBbtW17enrOKAeet00tdah165xOi6zve54RhMggtdT6F/7zn2Q8evz4LaMDwaJru+3hkE/eClLvjgcxiqpp5/PZMs/v7m7Kspwupi9evNBaf/hxdXNzc3l2Op2Wg5JV3T58sJhOpzf7wdtREebGY9BTYLL2WG3u1vvDYX2/maTlxYMlYzlhSDsAnLSas3hCUYgTGUeKsdZbbRyTLu5QMDgGqk3BmKFeg2FglixO6OI0Op1RSjnnlGKMEUIEQYwQCghDAGEAwFsEECcEgJBEJMsyxhCAeX3c9oODQcecRIusau683mEwuzqL+Q98xnvfy1FprUC3SF1WpJTyr/7Ct5PH59///b/uxfObqtsXRWbGQPqL09P5o8eXfd/+ht+y/PxnHy4WC0LIxcWJDwZjOJsstTIXp6Fpqs+8fULQ8PThQkTRYrFcLk/fuzpP/AAQ/w3/yJc//DCu91WZkY9e/Zqvffsbd7cv/se/Z/H3BDz+/K//8T9vALj/F//E5sXN6zzPrx7Moe2ANGO/CiHMeLgo4kWkbffq0ITz9N0FxwGGfXvNICn5bFGeFEneN+1w91qqYZZd0LHHkSpFtGuaKEkPBzlAEYl8TIs9QFB3pcBnJ1MEa+3gOJgQYJ5NCGEeWwchY3iwldKND2PXj0aTLJtQIjiPmvbQDxUmVkQ0eBTHeZoU3pE0zaOIbzYbKSVnUZqmwzBIOYBAIISUshAAYywAzTnth+p4aBDks+nC2XB/v376VkkpPVTrtquyLIMoDHWz3txwHm22K8FzALx1Q91stBnnZJ6nxWa9FQx+8rza7fbvvP0eJO0wSO8C0oQKijEMAY2jdM5Z6yHAzgWjxq6TIcBxHAlhwZPpZJ7E2d3+9YcffaSkV9JwyihhTbWfz6dNe+iGjXVd2yuECoOGUdaU2YAUobwfmuo4FkVprf/ww48ns0VZTgNwfd8kKdsftNMGevTuW59v23q339A05YyiAic8r+sWWF3OFn03EoKstUk84Zx675umadseY+K9BwAbZWBAwANCWFu1WuuLByfHQ3X9+ubJk0feA06FtWoymXZjDwASQoyylSpgEijn3gMlDSYwEknwEAAAYZByxBjOZjMpByGE9yFJkjhO7+/v8zxXurfWAuAhCsdq65yZz0+dM9vdjXMhTjhhJ3WzPxwO7KKA0G13d9Yrzvm0nBMKV6sNYn42T0fZS9XFcW5t7p2FgIxj37YNws45hzEmBGHMKKWb3QuIJYS+nBanp6few3GwNzc3URT146i0xpiGEEKAbds6F4ziFxcPQ4Ba65gSAF0cJ5Syfhgm07k1BmNyfvrwhXy13h5OT5fOKi7osdq8CTaHAIJHQ685j+M4qtvj8mRWFjlw9O7+pdWmU00U8X6o4zj+7Gff2x82zhrnlIgezGa6aY5xHD19/OjZp9dWwaurx7kcjtX+9vZ6s72XUmrTR1HsbHAQCsGuHl30Xb1a3Z2dnTGOhIjbqkWIplGxcntCAecsToQxJsD+/u5NUYLXWk8mk36ofDDWynKSGmOGoWfUcR598vGnPrgoihDCImLW+DRLnHOU4nffe3t1f2gbnWdZWcxAQFJahNjQ62kxVSMSNCacbXc3cZzNZrP3v/XBZMaSJKnrWilLIccYn5yc7Pf7JJ4mce5ceH39rO3qs7MT5y0h9LBvISCMCjlqiALG9M3bA4xDmsZKOa1t2/ZRFI3SQOSl3n/9479ljCHMGucpZW/yrsjlYn4+nRBCQgiqb6dFkT56NAzdqmqMHvMiDSjIscXQGqkixiNKGIKH3SYWlDFGKRn6vmrq85NlXbWffvj+F7/4vQSB5XRaZowTN5/Ou6Y6Pz1dLPOf/+puNqEX55PDhiUCLcoky4qrqytO/DTjWg+QAkagg/B7PvuZNE2NVKQgqm+X0zIStG1bhOnp6VlGYRRFRZZF0bJar65OZ0VMvvatX/z+z3/h0+cvrm830+l0ns/Wm1XK6XyaYUSLovjcO2/9zb/5Uwg6Av2kSG1EMUpOlzMuMEb00cPp+++/L1iyXt9Oy2JScsGSs8VMunEYhru72igXJUCkZYAj5ibLCCHEgxDFVAjWN60xxhqzmM6EEIvJFELIENkfN5PJZDYpvLYB2bSIkGeCTvtaWDUehvokOXfBYooIQb2WVisYrHcBBFxV7ThqPQ6vr18JIZwFu11lLGsbjRBRivRj7zx1juAiPRyqcZT7/TGKUwhxVdVa6//sP/vxNIoIQe2glQs3N7dCcAjhaleVuZ4uT601t+uNcrYbh7arLx6dzycnPkCrVJZH7529tT9Uk0mVC//+ddX2q/Urc/3iWa9B3XbGOgjhUdUIdGqYTKbZfDHhnIMQCDEl1zGTnLQQGOuI85mDJcQghyQmcM50zPshGXGasNMZPT2jcYwxppQSSjHGAADjbLAOoBBggMFBEGCwwfvgNCGgrfdlWZyezBHQjAelYucU4/TqQbKYTpBvmr6ZzZJ+0MW0LMpJ225X6+soJrPZouQlxfn5yemE8vpYlGUpVXdRxOcXJ/kkr+vjyTSPS/fw/FHbjJzy2WwBIVbSz6anguFh7L70hS9s1ytBmfeeAFhkaREl7ge/3HdSD8fPvfvosK9QwErVk5JdnH3purq6u7vp+uY3fKX6Tubxx//gEoAlAODHvnqBrNfDyHNyfXfbD3Iym4YQ1uvDbrtm4sGjs4fjqOySp/kUBHq5LN66fPLx84+rg9bYLsTolESjojCNfM9CP0eRc8R0x64XGBMCPDIEg2NKuzwvHPK73eH1rQQBCSGyrMDQtUPjwUjF2I+NlKicZAlPD61G2EUxwRgDgBjlnKXeA+dMURRxLO7v7ymllGE56t1uxwXiXPR9ixDpui7NmA+GEIARETz9zHtfUtL2fc9ZWlUVQmSzXb+h7IfjdpTNy9cHgtl0OocwtG29O9xPp1PG4bNnz1Qpnzx5ut3dAewvHz0QKT82+yhKqGDjoMa2AwEhhCDEhGDGUACu6yuO0yeP395uNxBYSkTd9ucPxLHum3oMwHmgOY8Fm7739LOvrj/e7l9XzQsHnFLqdPn4/OzJs2cfV3WFWT3FF129i/i0LEvOxP39PYJsOp19+uzbUvUAGutbAEPXNwhEBPO8iA7HoI1USkEI42jiDDs7u5BmGIALIXjnrq4e39/fGmuzrFBq5FwIIeq6artOCKGVx5hdXZ0dj8e2GdtmODt9IEcXJ0JKleXJyckJ2teYhGO1cs4JwULATERGh0ikImKHwx5BRwgJAXHOAQAECwiM0WPX9VpbxgSEcBgGhKExYT47k1JOyvliOR17eKw2g9xRSheLhTH58dgkCTNwe73e7Ha7yVQQFifZREppQAdN8IEYMxqgZrMZpZPdbuc9CMBGMa2qPcYkScXl5XnXDR9++OHZ+ex4PEIIKaWbzYaxaD47TZLU6LDbr5uum07zLC2LfOYdHnp5+eBxFEWr9R0AFmFKCMqyrGnqyXThvBkHs16vulYaHTiLDofq/GJ+89G1sbqIM0rim7vVch4p445NvVyWEA+cc0ZEXQ2H4z5OF+WMWthXx2vvpnGUyqGzYNSmdTc765RS9uWzFycnJ5Nicn+3n02HVnZZltzdv6rqzdnZKWNgGGs52iSLGSN1XX3y8YeEIGt1VR3KcqoGYLXCcMziclBtkiQ+WBAQRFXd1XFUDHLfD8fLh+8SAW9uXs3ni1G2ozLFdEZwhBF1AT64PO9be7+6dd5zHh2OexDQ8uS875soUdLIKEjrZN0249hPp3MlVX0M52ePT0+uuq7bgR2CqGsHziPORRIzALAQQo/SWgWxbvtN3+N3337rfvXaJ6MN5vb+oyJfTspTZ3AIoeu69XpNGXbOllkex/h+9doYI0SkjXzxch8nrChF1w/eKaUNgiRJ4jRNk2g59HK73ZDPvHWFMT4cDiFArRNCSDybIYSugtlu13VdN209m80Wk2lzrKMoMnZACPVtNynLJIn6vpcIQQQiTiZXl/d3608/eR9B17V1USSL2SmnrO0aRhEw7mw5mU+z4NRbVxdvP3kKPRj79vXL58i7IkuH0Y+q75qqLMsHbz2ZlOX93VrpcRy6OI6fXJyt14hF8bQs+HvvSim91YKiFrppETndfuV7PhslHD86+9w7j7puODm5SkUY6vWj87n3Xivzza/+bWjGy2WJMZ4XAkEBoaNYtVUdCVomp6eLHEHGz09nsyVBWAjx8MHl89sXw+CdThAiejzMl/MPP/zw/OLUozCdxlI7LeVmtdptDxQzDGCelY8fXk6m5cvnz65fvxYMcAYhdDzG41hncQICkHIwwEyWk3SSeKR7OQIArDJSSe9C3zXWWsGLLKZt2/d9Twg7PT1vmmG/63g8dRY4azmPEdT7XVMURde7OAoQUADI+fkD74MyLuFRfTh6ANI0vd9Vh+N+vd4+ffpECKGtulkfpgZIORCCZvNT7VYJQuVsGcWTpmtdQAhSraUamkyQ7/v8Oyy9e/5q9fz1y09fbRHJA8DWGErpHlbL7MvMF3evVvc328VyPlvkaRYx7gW1BAJjWN/RTrIAMAxhinQRwwKCoDxfTlh6TpaXPptSigAAACLvQwguBB9CANBDbyFEgiKGoKAIBa/MiIATER7G5uZu2O5WIkJxzIL3GIe3Hp2BgPb7Q9u10+kppvT84kFWTqZtHpwFUAMLnz5+53T5eBgkI+izj7+vnORS1ZvtrYdjABoBl332MzRC46BPZxNCSBJHXdch4LSsz88vYQhDb+OoSOI3Bgrj9fW9HVWZTx5dTSGEvRykZBhQHpHT0+l6tb19fUMpZUj87PtnFoy/5nN/D+0AAPzI990CAH7uF86KRXI6TbtRGudGNZyfvfP6tYBwNEMTMXy+zCflFAQOvT4e7sZ289ayBBR44DTxnIxmHDLGjDqmYd8r6x3Jk0WWldZapdq9dGtVleUUIdJ3gzEOQ2Q8tWEXbOhVm2YUU6O7o9Vhu0s2Zj2oHhMfRRxCqFUgOKFUtG2b55lSarttpRqklFLKpmnGcZySghDX91WWZdoMUnprzZtyhml5BgHru9F7AoDr+z5N08kkcy44F7IsPxw3WVZqbbXWbXdMs0SZjFGKgpuVJxcXl5PJrKo6BN1ssgwhKCmDNxB6jLEQDGPqLBAihhBqLaUcRtmTNMrKXDsljbRAQeLWu1fb7R5jDCDSpn/08PFQ0+cvb6um7sZmMPvl/PK451m6iETGBc3B5FC3aTzLF9OmHoN3CKFhkLP5tK7GgEA+yat6W3c1gaTI58ETqUbjGmPH6+t9JJKimMYRiwQeB9tLDSEmBO73x6bpIKQnJ6Vz2nrVdR0AkHORZRmlVPZjxFJCiPfeOf/4ydtJHK3XawCAVrppKs5SjASCoa56HgWE0Hq91cZNp4s4mgDPMYopwULEWZq3TdN13WazZYxBiKMo6vt2HMflcrbZroILcZR6hzCKtAKruyOGOYIEYqt0PwyJ0QBBNimLgA4B2CRlUcybethud+M4QugIIf3QKT0Inmy3GwCwlBIiXtfHKKZCiOl0KuXw7PlHWmttuk8/3aVpOptOu66jlBVFdqy2bVsn8TwEwGiEoLAGKmW991mehABubm4uH570Q3Nz+7Isyzf6b11bz+czZ4zCNsujLJqM47ha3QHg6uaYpnGRT+uqh5BhjMsyPT0pnr34VjvWaT4NcNxVayLo9ngctLJOEoiaNhwPdRylJiCp2tOTy35o7FojgL2Fk2l5rLpnLz8p53MBSYA2zhgVQOlhVMY6kGUnm83m/8nWn/Ras6XXetisZ9QRq167/MpTn0xmJpO8vLyUBAGyZNiAuv4lhgD/AMPuqKmeAXf1H65swLYur0gmmcXJk+ecr9h7f7tYddTVrN3YhEBfM1qzsaKxViPWiPcd4xlNWzkLX7/6XBuZJFOMcXXYR9N5mizz4oBc1/cDpWQYJMBCyPbZwjKdxT/8+N0wDGkaB0F8PB4po74XDr1uhmY+n4vRCKEAAFLKOAk9j1ZVVTen3//+t4TJ169fn4q7zeN9kgTGmP2+9b0Y2kx0qGvs6di2ZYeJNwzder2kDG63+8CPOIN1XbddJWSrjXj58pvd9nA6FhD3AGpMoDEGQeawMcYCaCfTNMuysiyN0m0zxHFUlCeEQRJn8SRs26Zujv1QpcnMKEMI4SwaByd6upyvi6IkBAOtxdA3aTpZLtZN0x4OOwDA7GIxTSI1NtLj58vFYrZyoxWjOrs4r+uyFiNjLE0n0KEoiDnnf/zu+3/7b/9dmsY//PDDcjE9Pz9frRbH4/HT/U3oe1IMUoqri+vIixiOrj9/ayG0ykIAj7siSsIkTDjnS291+/Hj5flFEESn02kYhuV8KqXM82MahfP50gJ0PB7jOL66unq8v9/vt199+81ut4mS8GpyfjgczpezU1l9+fY1AJi/uhBiVEZHUbTdHMIw/vWf/7d/+PGflFLOOQcsRnYUjcdNmgZ9u88CPpufLdfX958ePIazNGzrR90WSJu3l6u+H5nnE6heXczm8zQvjpSaduiGERLse17AKXNGKdF++vQeustp6lUxDgJvHMswiZ2RGKlTUWFIzs7OlG7rocqSVKgaeQAjqrUhFFKGxThorQkJfN8XYjieDmkaR1F0PFRJkrZqMA4DRDFHPvAt1H4YSjmKQQqtnIVSKm3Bc5AYEgwh1Fofj8e8OGFMIaR5XhpjtJZV/cQISdPYKBIHk7GX+aH2ZkFxrA/FiVLc1q3HaODH3IvT6BBxOIm81TQaR40xpBFfzKeAz64WmXGiGiqHmR182UGJ1BAQCoCjvlRkHNkoqOeBOFQpbCNkCaEarfzFBIXnxptIzLQbtLbWWgghhghChzDACBIArNEAU4wRxtABLZTAyIaUau36obFW+34CIehb2dSnQbZSSmfAdLKcTxeE+rPpom16RjwMsXFosThbLV5IhQbZIWaF7h+2hTZ91R4sVJ5PHHLOGQLnWYjSNAVOI6z6oTVaGjQwkGo5dm2fpTHGqJaNF0TTWUYBbZu+bfskiaAzy/mkqfuiPAKoGHZa9WJ0nNMkjrk//Z9/5+bzpGuHX31x/Jey4y9+tXk+fH/7ZpRiGDtswdl8HgfR4XRM05gwDDFYL8/zU7PZbeM0QgZrbGpRI8IRI6aXmECtTC8bayyDLGJjzHrhhDbFqEYHkAPSDzghQVPXUg4QO0xxFE9sJYwVRg4IIc4JY56DZJA9AEBr7XsxjzylrBCjsT3n88PhIMQQRj6ELooCCF0QeHGcPpMGfN9njEGAtdZFUYQBH0f13R9+4DyYzydDW0nVaQuVHrN0MZnMbm4+RGHW1O0kmxPiTbJEa2WU9ANurfW9LE1SpxCCdJSKEOp5HkJYKWmtJQQ/d4YpCRAiQRBorZQeMLH9kP/wUwERUq53SgNsNqctosADKAimnPplmZ+OrTGKMEO4iTDnnM9myTgOj5v3UcqSyXWWzn0ej8I5h7UypSxms9nbt59vN4XnZWHEu76HwHR9kyDHKHRg2G63aZoul+soTITQEDiE3eG4HaXkHnZAQWTKMuecKyWfNrfZZHZ2sQAGKWWcM5xSpwiEtG1bhNB8vkzTSdu23AvbtnUWDcNgDaDE74c2TaeIjMPQezxinmKMaWWkGBgNgcNSuNPYeB6K4/iZzQCAA5BI1Tsg87Ioyh3nfhJPlXTz2arvx6I4EVpwzqz2tcQD1OM4IoTqqhdqJNhjDEg1EGopJZ43U7rXegyjAACLEMyLYxJP4iTUWk7SmVSDHBtggVKyHTtK6WI+2W0PzoAsncZRut9uqyJHCDVdDYEXBIHvs77vIXB1tT8cN/P5dDXnlOGPN+89HyMEIHSLxWK3PQQRbtqiaevQi+XYWc/HxFgnb24/vHz5chxHMRrnEMa0H9r1KnO2b5ueeiFj/PHpdnfcvX37BXDo3U9/Wp/NCQJDP86nL3w/vn34qcyHsz+/uH+UVuHJcj4MowM1RKZqT28+/+bx6WPTNJhaKYUxYOgF5yFGbOjl1fXlJFnmp4Yxtnpxdnd3Z4wJwzDwwofuk3Og69r5fB6GJM/b5eJKK7vdbjn3n39na8HtzSfrDADg3bt3y8WFc+5ZazrnwojVdfH4VF1dXWGqi3I7X0Z9XwsxDIMAAAhhPBp6LOM0/sVf/s3p2JSnFgJKCNNaE+ocUIwlShp/Gk2nC6tcEETWSozp3cMfs3SRJJMwvDgVDxSrN6+//PD+Qcj26uqqqnqMQRSFWuvyVK5WZ74Xtm33zMwljBXFUSm1WKyqYkyTmeezzeaha+3FOoHIdX1Nnrd301lmrTFGvXhxDQDYbreH7aPUKg6DJIo5Y3EY/eWf/6UWTuLm0yeb5/luu38e04VhyDnPskxrOQxdmsY+x3HgV3kFDEpj3xijtV6tVhThphpWy0sIgmOxTZIsDlKKy2yaEY6OHwtMfcbY4+PjfL487E9JFM3n80+fPkEI665Pk4nPPAeR1noYRD/Ky+vXk8XyVBaE+FVVjaL3fX81n8WhL4QIZ9kwdIQio93lL7/VFmJsQg8jn/dDSwj1fDoKax2JYr8vGgi9SZaetvu+roNFNvRlcdp6EHtxBCD2SWgNMMYs0mioC+A6RBjFgDECHWUERYHHSGhc09Qn37sUo/A4MKZDRIdBHLDo4f6xKksEKWOk7erA80/FcZQlxiRJEspYHKfOwR51aZqWnd5sHpWWnNPFYkYpnk6z87Prd/cftQJJnCqpCYVJGmICxk6cTidr7SjkbL70o5Ax5pwjhGijJmF2f3//nOv58OGDlNJaG0URxpgE7OF+u33avX71Ij/UwODd+LQ7FUXTRkl46LvFYimtAkMrhtFYdX25ni7Pf/MPv2ua/XwSz5L51eXrQ3ncHPcCAMTDjz/uvdB78ep67Mg0Y1HIAcqakRiHuOeSwAVAY+MUYJguGL+QMBqENqofdWMtQAgxTADG0FkHnAMAQ2yV1EBpQK0B1iqlBSS4rE5xHFtoEUVKiWGoxFDXTWkhnU7PPcqiMMSIylEeHh+Ndo6A1Wq53X16juNv9yWA0iHR2eJ4PGSzjCRIay2cwghj7h3z+7PFuceJtWi/zxmPuTdFmHqIAT9YzOZFeXpeS0PohmHgge8Foem64/EYxRxCB5E1RiDnJlkcBMHQdoMUdVnpE1wuXw2wkgD+3Q/nwDiE0K+/evyXyuPrl/9c1/K3f1gkPgXG8jAuus7zvHYU0kIDkXB2NVuW26eiaxUBwlqEMPT8URiEGPIm2TSikJhRj11PKY4DH4/WTyZa667rIISEIAgpY5gg6PuhL8d+UEJqYxxykGAviRfKylG0fTckMYujyXa7K6udA/L21hqjprNMa9n3/XQ6vby8bNsWOFZVRVmWWZZFYWKM87iPkfB9PJuuJ+n5drsfhjZJI4AGAIyzEgLb1q3Pw9APFtOzMMh227LvO2tt142cBxfry2Ho94dtEAQQaUwsgOKU58fTIYqiySQtij3GFAJiLZZShmGojXRAI2QtGCxEYhTWyUH2YURD33ZDrSRCCFGc1HXNfUMDoPSIEEGdV5blZ29+OY7j/nSfTaLjscuSs6Ef+36IgoBw4pwzxrx790FLrIzVegz8CcIGQng47KfTKRkRRhwC6iwsirKu6+VyHUa+VGS+mo+ifnjYr1Zn08kiz/P7hxsAVdN0Ho/HXhnjMIYMe5PJLPDjn25+N5/PjXa/+c1vAj9CCHmeR6gfeKTrhtX6DCFUNzsAQRyndOId8semqUN/CgDSyhLszWfTw+EwDE0YhlEU7fc7z2OMc+uEUkPXn4axiqJgFC3F2TCIIIgIYbvjnyhdUTRLZ7F1fd18SJKIUl4WdLWaEdY/7v6otdVmjMJJd+rKqlRaFkX+9u3ngR8rCYQYhmGYzRZxHD13wViDkiTFGAk5/OxnP2/bdhjGZ2w0hDDLkh9+eIrjM4SQMWgc1auXF8PYDWNDKbHWXl9f/oe//eD56LmZ8urqRd/Jttkoih4+3S4X69XysuvrrmknWVy0eRzHQy+qqvF4PA4yTcj33393fjaZzRZFXRwOp7otwtSDBBR5qw1Yr8+rvKiG9uri1f393mr253/+N+/ef9htn5I4mU9Xt58+ICyrtg5iL00nx5MfhvEgcowJgriq9pcX87rujYF1NQSeH0dzQsjNxyfOo9nUBkGw3++VUsZJbWTbtpPJ/Ms3v/r0+MnzfEqgc873/bOzM8/z/vT9j2kWvnh5+e6nD0qLMEi7rp9OJ2l88bS5m2Te4bAtTj3nCUZyOlnm1UEKg6B/dfElcNBpysgEWP7h3cfZ7IIxe3n9EpL2p5t/jGKu9Egpf8ZN5ae6a8XF5SWE7tP9jQGF0iEjk6GDavQholohJQ2EdhhaY5Rz8N27H30/wogeD/nFeYaRzyiVUt7d3xvjOOdDrwEAmEBKkXXixcurwKP3jz8ybyQQjMCaq+vXx0OBMX32eU0mk9G0Q25SL3798kqIbhb7nh/smnq+OJOzoe+P9493SfIVtFSNivt8mk454QKLWbZKk7nPs7bZRVGYxp/vdofLy0vPY6f84DH26WETBpPr68+k1E3XTpcLjFHXNz6PKGLzxXS7u8c0ns0T6OLHxxaTKEyAkO0pl0k8XS5Wj49PUsqrq4uyyu9ubqezsKx2iLnZ8jwKJ1rrsiknySoI/H7YGYOyycQ5Nw7Vzc17McggIARR6CDDAfFp29Z9ZdPsdV3Xp9NpGDqLu/vNLop9L2QhZwTTNJnmZVsX9XI+r6tqBIbi0EkbBkwMzTjUWuuXX/zC9/2PHw9pHPajbtoOUKy1oBwOqu06UHU9YtQYsDsdQ5/XQ80YadpiOs38ABWno3Xx0GtncWASpMfVNMrrPInmhOi232ktB+WUybkXLs7Y73//jhI/CEILxXQWSNuWZd2M1ZzOATSUYmuxEANAdreTxhgpXNe0g+gZJ4giIaVzbnM4UMqNMJtDG/oRwuh+PAohEMC+9RDFh7J5KgsALNKeUeyw2wCHLhcpWk4hhMd93rbdqCQNQkaJtnoYm6bvmnrwYn199dLzgsAbjBVJ6sMo48k0NX45CgV9hRMtrIP9OPYOyLId0yi2UjrdUYIgsM5ZhJAbDj5hOMnmwVQ1JSZu6HqWxtNJOg4SGYgt6tsBIOcQXJytp7P1ux/fKy9M4sUoRqEGCM2gxoinlLJsdmkdO5ZNGEVSjcNgINKXFy+GYeirQRsZhqGzNo4SBuK+FznZCy0choMUPkZJnHA0bZqGEI9gUzc5JkRpiRE4lQeM4Si6bJo0TcNoMJnMpDB5nmdeGgTxMEDOA6UUsHq3241jiSmC0CWTzDnwH78/U9J51PuLb27/pfL4tz87PB9+88Nl6M21Aj7x95ub6XR60PXdbXm1/jnAu2bY+BSPbXU8lGmy9Jn/X/7Zf/933/93168u7h/ueiVDHmpIKZ9QEhnVlGWOMV0tL8ZROOcg8jSsLcx7uRmGhlKOCdntH0WiQ58zTMZWqgGMsKcIceIPnQF8IBi2VUkZWS2mbV0RyDySjlqkk6kFDhN2f/94fna1Wl1ohSEe8/xECIkTcnv/xBsMoMqmPqV0FA2lGGHjezGldOwbrUpC46pqoyhi1Nsf8yjmo+ry7SP855CFITiALvTYtC5H4PAwdEaDzz/7FjhalrXV1CgOCeThIKUQQmhlp9NzCExdlGly4WbEmUBbO4wF4wT0WRy9gtDkXR16aVEUi8XC2NXj00epesYk4zFAXV7VPp9N0suy6BCW01kkBgcgTNNp01ZJwqNYdH25P9yv5hddV+dFH0VZEATWgKE3CPhhkDgLz9efna2vjQRNsacwiFMsZNA2NeOgHxtsvCCIoMHKoNnk2uPg3cPvO1G8ffvq8eG4mJ9zj727/Uct7XR2IVUPoOn7HsKkrkTfmziMABgxxuMgEOTOWKU040DI+t2HT4EfAeG1rQ2jWMqxrtCrq7+YTddV1WRp6oDJi23gR5QEXTvMZ2A6i+/vT10rX734mhD+cjV52r4rqxqIeeR5y+llfijtSBaLlbXW95QSiNEgClnb1nESAKNPx61QtcfDcXBqlJ9//uXj431xaIRsur6MQv9wLH/27a+4H0Zx0ctcjiIIgiTiRo3AmNV8AQnYbv443ozrRbpan9/f3yOHHj/dyXEwWmiF3rz8nPvMgv7Tw4csmzrsF9X9xeU8TdP9rqIsTJIQEXj5Ylnk+zDx29EaY15df/HTT+89FF2tp3Zs3/34KU3W2WTRDiaM+NJNq0NRdrcS2CD9kvEwTuZ1c7ROrmaLvLyTsgJOWSPv7n6cTy8oCr/+7N9SQLriP2w393/5V39ZV0NTd3HilcUmiZZdL6zlXjDpBwds54wfB+fDkCtRT6eZlB1BYRSf9bX3ev1n6Kvp/f3t00MZRmkY+cYYTCGmRJvBWmktAgBEUaS19njcVINW0DpIMUWQ+mzmSPjy6ue7Tc08XdUN5vDHmx+MNavlpVClVdoIsF6cCa2q+tQOXTyETd+UQ/Py8q/SLNlvNw9PnyjFcRzdP/40qmqxzPLimMbry4s3UuiqLvqhPJbbVjRh4PuBP3Q9Qxhzop2WeiSUNe3RgeRs/RI4XpYlwTz0LslisbAGCCE8jzVdX1XA83iaJtqqz18GlHKrpVKqrsun7X63Pyl9bYF22iRRZqRLo5BEpCqPCGAMyZeff3M8FIxGWTKZTiZaj03TnZ9FUZicTru26SfTFBNRlRuhUsY8ZqDn0/3uaK0NgxQh1PUNI1lxEp+9+bnV/uGQI8wvLq768fT4sOl7oSTgLObMB84iyLWpqqqD8Bn36VtjPZ8p7WVZvNk++gEGAA1DP51mZTV6PqMsk1KulmdhGD48fmKMWAMJ4YwFnD+bucahMXE2iUKfEOSMG6VinjLGGACdQxDyOOQKSMa8/aH82Tff/PDDO5/xMGDWiSQMAaJZEnEKP94cIHIBC5uqlgY4hJ3TUkpCbDsoDG3sByt+Fcdx3bTSAGJR3vTA4WSGWyk559PVedc1j5uHl69fehD+7o8/LGarwGNPj/d1WRDWEwqklE0NXr1+83e/+cd+qPNiHycZ98ko2jBioxFd2+x2hySeSKmjNNHGDGLo+xEilOeVtZZTD2NcFJUQQgFLEWaMIewP7dgOY91WxunQC9tOhFGS5yUl7HnEF4ZhVQgDUYD9LE0n0/lmv3t6eiqePmHY8kGEcVDX5YuX5wmfq2aAid4qqyEeBmjBIIUblMMYt31HWHAoSk6cT2ydF05r67QxZmx3iR9G7Gp3KKwcJtOs63PuAYYj56wyNfWU0sPhcMCIBv7SWoOQIxR0fS6lpIxgjFUv7u4+xkn46uWbuu4IpqNonTOYAKWlNohQlPKYUmq1OR4PGGPomJRj20rOqYVEKUkI2e93k8Q0bUvZlHvIlBph7Hms7/uzs7PHpwdCEARYjMrogWAehqHWuqoq6AAhpCzL9XodJ+lm86R1TZkX+LHRGEKUxL4QozPqn358C5H5xWc3/4nJ48+/fAAA3Ox+3feDUqqqqiAIGGOrxawonxAi/WiVdEky+a/+4v/2fMtffv1/BQB8+vH/xBkx2onReJ7XVKVUI6XEOSfl6Pu+luNh97jdaQBlN/RSySwNjXEXl2dxND0eD0LJyWQyDL21JkkSY2wYJAgrrS2lVIhhGEbw3IIKHQDI4+zFixd/+v47xjwHDABgMpmc8idr3W633e12cRxTTiBCWmulFCGs61pCuFR91xlnjNJDEC52uz3BIMuytm3zvIQQBUFCIIEQno7tyxdv16uXVVUqPRjr3d7tozA1VjV1pbRxwMznUyHE8VRShhC280nUdfl8sgqDa0r9vCjCYLpYLB6efpRyGMfB48N8MUmqUEktZK+UrKoKI285mWGEoaapHyhinGF60Fk4CUJPqs5aiTFu21bK0TolVcsoMsYNY4UxJhQOQ+esCPwsDCJK9P39p/1he3Z2JmQrepkkAfe9UZaUkH5ojAVB6PWdeNrcUESMcVJR64bDaX95ef709GQM7vpWSIIc4hQe80cInRADY/zVyzfv39/4LCXYUxLWRd51/cX1FYA6iT0HkFR9GCTPGZYkyVbLxc3tuyj0yyq/vHwBADie9s5Zp03APa0AQmgY+t3uSare81hZ5V0r316lnhd0AmkFT209m0CPZ3HE4hn54cfv18tXi8X67vY+jjmjwWb7qSp3jEPuIaWUNQQRUhattehw3J2dLRzQXdsvF2ddN+RlSwi5/7T59uuvkjTaPj4J2fk+PxWlciNQoO3aUfZe4M3mWZ4ft3f3k0maZVnfC0wZpX4YcqUUAHYcB8ZY3/eMJ4vFDCNOGTJGPW22Yz/UTRnHkdLDw8NTFCYQ4rputNZv3nwuBUSQt10+zVJt2Xd/+C5I3Nu3n2vpfnr3+6ZrCAXWqqoqlYTjODBOV/F6f3Ba28/fvuYMWGMAdL7v3d/fi9EmUbrb7Z0RFPe+NwmCYD6fDyo75YGzyGhyPB6UhOXJLhdfagXrun/x6mJXPEk5GquGQQYhxRBWbTsOMo7j4/4jpcT3Q+dc3/dJkpxOJ4wxY3SaLbfbbVEU8cViOl/tj3uA2WJ+Fctxf3pqK9kOdRBQZHmceEVRvX27iBGqymY2ndZ13XWNz3xj659++hgGcZJEjAaRHyvpLI+q/JESH0LXdnldtaPoF4sp9xBwRMiu65qm6bjnp2m6O26c1cZBpSTGKAppU+fr9SWltK5ropWllO92O8Y8z2dKC0KI58XFsZssFsv52Xa7zce8HMtRd4hopfuLy5Wzqu27vukZ9FerhfC85TJarc4hoHE0j6NZEHgfPv7ogASOp8lMjnYcXBSlGAOpGqmLP3z391k2mWSLcdNLaY0GX3zx1WF/ooherq+NMcWxmk3DX33zi59u/nTz/s5hkSZzzkOCfUZ11wrGybdf/eI3v/v/SDUi7IqiQLDFmFLm5cVBKwGAlb2ZzRbAoa6vhBgp8xgjjDEp5fF4yrIMIQQcdc5ZgzHyGGMeD42GaZRQSrSWhDJM7WFfdX0/9qPPs/n0UkmDyPDbP3yntP3f/Ff/TZkfEUJ1c9o83v/iz3693e6O+x0mEGNICSOIUuId8sNieT4MY5qxw+FQnoog8L788rzKm83u9OVXX1Vt80+//b0FECDmNU03iuZwfH5YN6P58f19HIeHvEsi4fnh09Nj1RZpNj0VBweMlPLMXebl4ZDvIIZlV1VdIYTwPM8hXNdVK7p6aKaTedHkBNNjkQNNKKUOAsKo0CLxw0k2kUoo6aSDg9B1O1hr+3FAhElh6uoUhmFRNox7QgirTegHQ98pg5gfnPbHvhM//O77sjpZPYYBb/sKzBcsYkB1bbXvEstI+O7HjWaekoi4DMPe2chBhigTVo696quTaU8x07/69vPitP/uu99LKePEU8PufEnqU5sf919//TUAZneoBz/RRnR9fnY+8zwOobNON02lLFqfLT2PdU0VJR7BzBg3nU4RAsaoqj6UZRuFE+AQxKAoj8PQhmEYhiHGVI6jtdZaZ4zN4gBi6ZwihEhjpRQIwbarxdAkSdZ0R61cFAfjOEppVquVlJYSL8sSKYXWACFwPB4573w/fObUcc4RQghi55y1EBMIAZpNz0cBhmGUQo+jwNDGUeSA/vd/G1trfd//z371/2PyeLV6JpeCf/j+FUJIafH3//gfpBrPL5ciV0br/+av/+//qVL54v/8bvN/kVL6Pp5MJsbI/WHLuS+EbNrKam2t7PpaGZtNYo8n08kSQshomOd5kTfOAUKwNBJhQAjputHjEefh4fiJc+57IcaUc26dkXIctAiSqXOmLE5pGgOAKKVGu9OxAoikqafUqHSXZktCSD/2t7cfsyRFCPV9n6bU9znnVgs5CrTbbRCCGGOtNYS4qXtM2Hp9NjSSUuJAg5EnRieFm0znXV8YDdq2/fDhx6ZpkiTzeJSm6TCIU15jCFiI/IDU1QAAmGQrKZDHrcfSthHOYsb40Fvf94/HPSGsbRrOQwAtAGCazoGj46AiLwkYs8QoCSiOXr/6gmL8w7s/UkqFEH1TpmmMCVZ1hzFSSgnZIsgQgpQxJaEQQxgkQRB0D00ch5S5Y/7gtEMYVVUbhMQg1TTVhKbQeQSxOI211k3TTCezst6FQeoctMZ8++3Pum6w1hLsaSOnE/rdn75v2/Zn3/7Z4XBYLKY+n3dNdXa2un+4cc62bVvoLfW4FIYyHyPqnBNCKaWLogAA+T4dB1uWRVXVRZF7jDyTORbzc0LY8Xjc7U+TaRLFvjHq+vpyEsXb/YdxkBDgJJ5JATweLharXuTEhWm4RCYM2IRAMowDwzQIfM8nhKD9Lj9bv/zqy188Pmw9HvoBsU6NYw8AiqKs78ZBCj+gYUSbNjeuR9gJMUwmEwBQ2wwEuflyaq0ryl2aTKyThAKlBaGTNIspCaqqssZhTIyRUo5BEAkh2uY0m57PZ/PT6fS0v0fYQeTCMJJSxnGipJFSYkzquo7jeLN9ZDRcry7LMm/qTVEektTHFLRtCwHxQzQoU9e5MjqMZmmcIGwhtAg5zv1pMlsspje3PzHq+xGPyCzJJmK0CGDnHEKkbsrP3n7rLL35+B4QSykOgvBwOE5nCUIU2HC9+LrIK2Cr27uPceJRyOIgHIWBFu52e631y5cv27YPQvpcOzeZzJqm0VpzDwsxRuGcs6gsPiAALFBF83T7aUdJoG1BKc2myWz52fffDwCqdHI+nWYVzYtTGUVRHMQOmK7pKGUQupuPd1KNGGOfexgRzv2X1y8fHrYP273HQzn2d2UJIfQ878PHd0mSAACcM3nRUcLatu77Np0mDqiiqIaxRdgGQaB0X9UHYwwAjnSd0Lp7zrmFcSylwpi0bcsI2G3uGfE5987PrqsuqLt925UeQ2PXU+qdLadV1RhjuroLvVhJUBwqzsMX12+twdZqiugwDhao8/Pztu0Oh13gc4AGazXCzvd5lqUIAwhc39ez2UrKoR9q64Tne5T6m6ejUgoTWze7pj1Ags/WF30vn2N4YRg4YB43j3Ec1o00xrZtTwiJwrhtCqMkQCYI/Nu7jxA7ALCSRlnRjyaNsyybfvxwW5bVz779ZVnWHk+11vnhYCEIfG91vuIstE57HhNinGTLp82np6cbBwzBzFoILFdS7vcbMSri89/+4bd1V/q+P/Ryupg8Pt1n0znj3rv3Pw1jk6aJUApjapxljIlRZ9PZenX1d3/3dxT7EEVJ6u1OtbJsELAeNWG8bZpm/Egw7LouigLUdYDysu2Ug9yLt6d8dn6pIHScl6IX9UAYttb+/W9/4wjwIr9XQ5sPymqM8f3TA/PCNI7jNDDGVG2ulVXWAYcwYIgBP+CMUSWGxTpdr5aP95+CIHAOVFUz9rIbRmst97znEo+u67RzYy+NlMBoBE3sE0W9um7KospPe+gUR+abb98s5slPD5sXr9Z3D3fDWLede3gSRetrLcuuEB38+vUvYi4ojSH1TscKELrfbFfThOjT7vE2+HYFQzVLAOXJ/rSfzjIlDgTbyYR13UEqGIXxqDZ13YyDTZKUkjBNJw7IpikciuazmbVyGHoAgDUjIZ62LvT8+eqqqiql1Hb7dHl5PZlM8tPe89mr1y/GfqiqhjFmNAzDMIqSqjo5oAHUbacQZBhjjLHv+4yD7e5BjGY6WVmDIERZNvV4tK/2gZ9oDQ773PN4EmfPyS8hBELIOfd8+ziOylghRBROhlELMQBIw8gDwCJk+7ZGCBJKLy7X4zgKIf6n/8X3fMI5+fUXxb+UEb/++p9HIP/vvz+/vDyfLxfdIJ0l4F+7MMZKKa1109STyZRRz/c9rTojJIKE+3SxWGDqxXEIgGva6ng8TidUa322XkFI2raR0hKPtnULIfnm61/2nej6UxBEQgxKKcaIsUAKraSLken66nDYrlar3e4IrJ+E6Ors9al4OB23CKsXL14gBOu6JoTEQbZcrjjnXfdUlCepxiiKMIZRFGwP2zSZxVEkhIAQz2YLIbv8VF+srpUWKWRl2Q69IBQdDsfD8SkIktVqUTfFMpg9Pm6uLoPNZsNokKYTpVujxd3HR6UUMDknK2to1wyvr8+LIlfCMI61MFXRJmnkcQ5doLXebvbQujCIqnK4vnodB7OyOkBkOMdSIGNtPwx105LQ+D4nDDOGu74WYvR4QAk7HkrP86eT5WK+FMK0zXAqngAAELqrq8uuL7u+DLgHIDocd+fsnHLDOFouzvvWJX786vrrh4cn0R6mM+/qen1z96euq8PI74fa832trJTqlG92+9thGKbzM4TI6bRzQGF3lFJiYor8NJ/PKcOMEY/TodfEgecmcK1b52zTNIyR6tSK0e732yCIVouZ1ppSmk2SUeD9fo+wDSJcVnsIKHD49u7DvfnUj0Xbl8vV3Fl0draqy7brK4jRZLIYet3W5XJxoc1wPD1hTNNkSSlcruZxWB2P+X7/BKBzQBNiTqcjhGg+X7Zty5mPGCjL/PJq3neNscDzeN+pIm8Q8C/PPxvHvXNuGIYkzjzP01oHfiSlFKMNfD/0p2MPMXIAOiWNMa5pGikcJcF+v9vv93EcJYlXFCfG/CjyP93vskkUJ+Efv/uUphMIAYJ4s3mcTRcPWh0OOzm2k2myWEyNoX0/GtN5nFEKJ9O07SVnvlSjUsI5iw1cTlcQ0h9/+hMl3nx5nqRB19VjPyhpgyCaptOuq8OQfLz5CUFvlH3iBYi4+SI+HJ92+32WrA+71hgldTuIHECRZtlYu8ALw9Cv6pPoVRyHBBItpAH6cDhAwM7WF86iuinSbAkhwDBC0A+DjBLbiXIYntKFV5b7n24+TKeLSGYIMgjGOIqXy2WeH7Wy0+lUCNG1bZJE1xeXXddKNU7iFUIQOC1GiZBmjLXt/nC4i8PF1eXVjz/9aTqZ8IAjhBgnRrt+qDCBbVNfXFyFkD4zALVRdV1mWeKc3WwffS+Scmi7uusaAiA/5qfVakEpccYkYUSIp5VNfLY7nKRqpXKEMyUtwf75WeKUPR6PnIfIoVk2lVIKoS4vL30v3e12p2P+ffs9RqyqSsqcNkOcTfqhVMpwD1sLhmHwvCiOUwQ5594wCAiANkLI5uGpGYZhaIrA8xHAL69fVFX39HhHCZhOslOVb7YPcZR9/c1nXddtNo8QubzoAh8ihygNZiliHHPON5vtar7igV+UxySKGaVauVcvXz49PQ1DE4bxOI5SyiTJPn361HXjdDKfTpf54eBRZqQWQhoDqqqdTNKuk+tl4izzvcQBbYy1BjEWnK1fHn93m83nfhjs80Mn+rptoAOh7zMaBUpTH+ZNwTl2GFPuB1ny/vZmu91m6ey4O6UJ/Pk3v/6v/+v/7W9/84832x8m09m///f/E/bYarn+cHtHKEUIWaAvry+UkMuzdRyE73766c2b1z9+/6ePm+308mpT5A6ipm6V1VTjKA4ORW6MxZQ4AIy13ThY4Do5Ukq1FmEQDMOQRqGxdhiEddBjXFuVxIE2w2wavHo9pxiGn5/73B968cNPpyTzH+4LhAjnerFYvHt/q5RW2vZ9H4U+Avqrz94Cp354+ORx+erVbLfbhYFPgP5v/3d/8/bNi//H3/4/y6bOgnE5jQCGYUhn08nt7e2w3yY0ezOJszC0WvWqluY4Cvvzy+nVeeqh5IfvTtXu4+ri/D//d39BKP/DH/6AsbFGXlydt23b1MOLF69n8/XpdIMJhIAhBI/HY5qFWTZBCFAai1H3Q4cR6ztJCFsuFpvdoWt6ITZCDFk668hotKurNorSYSy7phVCQOjatmWILxarw+E0jgP3CMG067o4DtIodMB6ftJUR2tQGMTLxUXbjNYCjydSmDAMEULDMKTpZD6fE0IAQIx61tqu65RSGI+EICFHn2Dn3NBZRFFV7/Oq0FpPsuXlxZtZtvrxw2+tk7N5YqFG1NZdWfdqNk+/u7usyoZS/pdf7/+lmPjP/uIJgCcAwD+9++ZvfvHf/6uC4/Xy//gPP/x3xpi6FtbAMEzSNO07hZAzBuheSWkIUG3bz6aLUnWL2eUwDACgoii6bvA8jxDUtQNGGGPy9PRQ1y3mrhd90zQQ2kFqSkkQxarqnzY3/dD6vt80TZrMoPb6WqxfvGzanCKutTTEFcXR84LFYkUpV1JQApIkkVIaY4QQRirG2PXFZd9LirEYOgjo9fW1VOOHD++eX7/C0BfCJHEmpdzuPlHCOU98L2GM1U0xm83CMLSGGuOMHYIg8HiKnDefLbuuF0I4J5fLRVHkQghnIQTkZ99+WxQNgoaQEAIbhQwT9+HdD0Kos/U14wRicCryMOIEe2Vdu4fbtq21kwxh3/eplkWVV3XuexQjjrFM0hWESFt4Kiul1HPdrnN2NltA5MZxlHJEQAGAJpMUAizEAABomiY/DgEzRXKq6sI6bbU47Ir1Yt0GXGixPT5ixAnmdV1BBDCEX3/9dduru7sbz2cAIDEUxtj3H/7ICM/zI0CwKIo4SrkfVVXu+1wI8eyr5R5t2xpjTClO09Q52JQVoUhrnZ/KKF5Zq5UetRnGUcymK8ZJ37cQjYSq9fnEGIkwfXy6AdY1LfD8OMsi34+lMJShYl9BCLnnRWEWhuFuvyGErdfrpi0hhEEYPs9lMSbGGELwcjUf5LDZPCQ6CYMppbhvegixVCOhYDKND8dOa804bRtRVyJJEsoI9jwL+KnoheROA87ZMLZaQc4SGzoIKCcUIHg85m1bcQ9zziC0VX0MAq+qCkIIZfhw2L169eru5sPPfvaz/X5/OG5ev3l52D05Zxhjh71YLFZFeRrHPkoC54yxTCuIELi8vN7vNw+Pny7PLi8vLupSeJ6nrRjG3iijVI8cmp5lpQNlWc7nmRCy64o0ixm3d5/eV9U99XgQZBSTNGM3n37ngLBQUA73hwek0iRJLtcXdwhhTKUcbz7ev3nz5ml/p5Vdrxach8vl+e3t+64dMIHGtbv9AWEzmSR5VRxP+6sXl0nqu4AHQdBUBXBofXa+3+8fHpuiKAKfx0nIOInj2Pe9KAqkGI0mYcgpw57HmqYaBiGl/PDx/Ww27QeTn5oknkCAi7yKoijwo6qquqaglBJOlDFBEBDOHu/vAdAeZRTjuq6NdtN0SrALPAodJ3E01doiBCFEwGEI+PFQZemcsCBJTF7sTnl5cfXSAuccztJFWZyybB6FaZkXnofTdHI8lFWt27b2ghDgYlRdEIAw5dapgCVBSH/48XeMBb7PrZNKqTRNMMZiNG0zIoS4R5bLuZCDtTpOuFWpMVQInKaJ56Pzi6uyzPf7PePQuvGUb61TAAAHjO+zpu3HEcdRQggZxQCgxBhTzDwWDoPSCiJEx0FhTAnmlHASk6fHrVLq6uoKQiRGA4CTUrZt+/LlyzhOqqqBFmLEOQsgYFK0+aleLS+UUg6a4pRrbZIkMkZR4o9jrW2XTVNCOHTobHmeH06bzQ4hEsdx13X7fcUYuzx/0dT9t1/9vK6aw6m0FnHqA+o+3XwEzgBoGCXGyq9efblYLWU/vHr7hjH2j7/9h4vFvK5rDk3AkexrAtTlxcIyeHd3dzgckmzy4sWLT4/3CAGM8VdffLZ92o1srKqGMhqHQTf0L64uTddQYP7617/+8cd3x+3BWfNvf/2rOA7/8MfvPn3aJFdJPwgtBNBTZ9DZ6myaRh9ubgNPhLG/nL05nYokSWaz2djlCNObT5+iKOra+q//+t/8F//ur/7p7/+XEbRChA7Ciws/CYM0DAhRjw8fPbN7vYr+4utfnvIyjlPKI4K9JYK7jF+uXv3yq88ogmV1qBr18uyqG7Xo+mWgz9erb9/874uyRIQ23SBG+fMvv+Qeub15ZxVYzpY+67Ism08nTVVmacA9IsTQHysAPN9LAs85qAhhEJA0iY1x7jltkWRNVShpJ5OFMWY2XVxeXu92u6EXENG2GQG0PvO0sMY43w8DX3CGKEWYEmOc7wWc+8PQOW2jcEaxXszPz1cvP6lHz/PCKLi/vxOi4pwTQtI4G7rRWksgQwABBKfTWd/Vw9ClaVqW9Si6ySQRgxC6G8aKcu0FlFAnZOcU9Xx2OpVlaRkjcZzOZjMhe88LtLJKKUK8727eGGP+7O3tf6IqfvnZHwH4PzjwP/5rkuN/sPaGMY8QwpkvxmE3HLCjn3/2hhCy2d5JNULonIVPT7vATyaTyW630Ubs9pswiBkjwzAQQjj3tZBCNsb2Yz8a7TzP4553Ou2DYDadzMW4B6hTmmJEtYIh50E4SZNkd3wKQkYbjDDzPer7ftcOUmhKqXPm+V//ORFtDQAAEcy1VgjiYRjKojHGAaitNWHkDUOLMWa+z5hHCcOYXF6+HMbKGtI2FYB2HMzF+UsIMATMGDeUOSORGADFCSUxZ8QY7XPiB54zGDw774xECBHMtO6BQxfnr47HfRqGP//Zn202m7ou81OZTpbS9ikPrLFxms4WM8xtPxhO4Tj2o+i1Ub7vR0ForQl5RFgwDANGmBKOEFJqtE5Yq/Pi2A+etRZj+uwzePXyc99Lbu9v0oSMok1Typk81d8TX80yJmRfVoWQfpoFDzd34zj+6ld/cTxUccI9L32uAPWoiJaRUgpCEIQMGCuEydIZAKgsaoIZD3xKKACQMSaESJJ0GAatpbUg8ENNUBjGQzsGQRhF0el0yrIZwmw2nzw+fRyGPo4zjClC6NuffdnXZduVdVsTQqqygQlGwE1nWV03/VB13UejYZbNtdZJklgntHZGo9l0XTcnAEwY+sMwBEGAUETJaRxHrfX67Lyu2rKpV8tLYGIhBhxSjCwhCGGDid7sbhCIjAKz6arreqt04EdyFF9/8fX9fo+h8DxfCGCMwYgu52eEkKed9niIMfe9MAxjpVRe7DHGvu81TRNFcV3XQRC9ef2Z1hZCPJuulDQY49VqEccxI1dFXooROAcI4QTzZBpjCoZhWC6WZdkoaY+H0lr76vqFkrbv5HQ622w2zEmKKKXsfHVeFnVZlpTSNJloaRGAp9ORewRAHMdh11dBiBmJAj8cBilkHUTQWGkBMIZoOWjNn46PxjjO/K7r4jihlPb9gDGmDI9j73mMEDKZZlVdaHfqhpr7PIwCKbW3ioHGURRnq5dlXnDK0zhK4+Tjhx+5hyZTJoVtuyLwQ4QsY6Trus1mk2UZZLIbVdlYn4ar5SpNZnd395hEaQrKMn/95tXvf//bcRycc0op7tEgCCCEYZJy7pVFDQFer86aNuc8NFoghLJZprXu2t4BG4Y+iaIsDMOqzpUSyrhadUrCobf3ZZ1OOWGY+gCQ0TphjAEWOgcx41JqAABEgBACsbd9qtIshL0OI864fzgcsiyDkCVJLKWkDIchd0BbLRjDhJCuGxBChKJxkIvFoqzyZ1wEIXi5nCllnTN5fhzGJgiRkF0Ue5DHEGAplZAdIcQYVTedH1AM6HQ6F0IpZayxWqrpZG4N9Gl89vqsboogCKyBddFSxCB0LPXrug7DsG27KA583w+CyBgLAOYsBG6Q0vhePJ+tu64LfAuMw4Ay6hGK2IoH3O/66uP7m7zMz5dnlBMe+MlF5jSYpqtVcvnivBmGwUn7Z19/23YlYyz2oq4YXrz4fBiG+TzXynqcL5fztn4c+uryalGW1Z//6tuvv/iy78d/86ufz2fLoii+ev1yngZ/9Ytv//TD92Nzevty5VT77/7NL77u1G9/+/uAsCRL337x+STgp8POGPP26uL1eqWlu/14xyhfnK3Kpmac/+4f/uNn129j7hPpXl++RNhhKX722c8YstOYXl2fSdUVxQnqcTKZIjNaBaDus5BNJuH67OrmxmGIVF989fmFUBqAPi+rvu2+/upq7A9S5X/9y6+DwHvYPCgjgyB4cfVSdkIpE4V+4LGrs5VHEII0DpNJtpzyKI5hEiYIaqXVMJZ9ny8WsyzOZNQwxgAA2WRGeVjmpYdNnMWUU6XU6xdvCUHW6tnUt1b/8ON3GHHKGHAgSTKECAREayuF1qD1OAUAYcwpIV3Xfbq/ZZ43nc6l7H2ft22vjazrum3bKIqcc5fn6zw/Nm29mC+Lonp63F6eX+6P98ZYjGHgxwgxawHnft+3WTaHMamr8Xa8f0Y+NE1ljJKyDwKPEGSt7bshDEPPC3zfv398uLq6qMqTlON8MSUUDOOQZYnH8e5YDcPgkAPAKFEriabpLAxDrbNRdJz7ENAsXQ5jB50l1PO9BAIMHDNa/sP3rzyfIQS+fvHjvzrV+E+uv/z6FQDg9x+Oo2iN0cgBQnjTNHme90MZhBwRFwSeGPuz9RXGOI77UTQIzyCEZVl6XnB2dnk47KWRQUiq3Wa6mAOHgsCvqrLrm/V6bYzxeDCM5XSyisIsCtP8UBIKERZP2xtMLKEgiHwpJaIkSSMH1H6/oZQ9p+sxoowxjImx6OlpnyTB1dWLvh+1stba0+mYF/u3b19HcVTklXbOGomAiuOU0XC72U8n2WQ9P+Xb7GLetjXGoK5z3/cZDTFmRVvGcaKVhQBncVzXNWXw6uzqpw8/IISSMHra3JdFM5snSqk0jZezuR/wqrLWgskkE6PabG/TLLbWDoOOw5QQjDHohxK6kAfc87wg8MXzY8i4aTpBzAo5OOcAAIQQCCEhFABkFIijFEIIkYNOVmV9OByiUGvlGPeMMmnmY0yKooDQ1a04HhrO/dk8k3LUZkwzv21rY/QgysXiCzGCtukJdZwixr2+EwR7YRIBgOq8ZYwFcRylCQAAYz7JZowT4GgSTzEayjKP4sRBPALTVl2azNiE1HUtRmMN6oaiqnOE0OXllZKwqXuEe0pRFk4Z1WnC8jyfZEuMMQTm/v5+GHUQeJxznviMAsY8xkg/wKI4ep6XxNlut0lSTin6+OFeCpzEszReTzIb+lHfidOx7oW8vr6UClRlByGaTVdd1/VDS6mvhEYYcC8Mg0RJEMYhAOC4q/7pd38UQCVxFkZM6bpuTsaoJPal1L4X3d8/JvF0/dWFp4w20lqrtcSYRFEKHGI0YjScTRdSyrbtgyAUSiJIuq59etouZ0vOYoL4bBa2bf3cWG6BzbJpECWHwykOzwAcohADYIv8EPji7csvxWicZzzil3ljDRqGoWma6+vryXxhhSrK03w6P1tf7vc7zhLfiygl46ARcFcXXxbFoageIdaP28dvv/25QKDpT0/vN0mSZVnGA57N0tv7W8YoQqZuTs7CU76VcgzjqzzPLewZ8aNw0tYKA3+2yPpxEL14d/ijGMb5ZIqwa+r87WevmvZ0PB7SNOv7Ogx9iMDt3c319XUcx9Za4CiCJPR9BHndGGBbhFDXNZRZ7uGyzD3P832vrvMwCQh1SZJ0XVfXtZLAGuR5vu+zYeyHfoyTKE0np9MJOE0pHUYhBCBdO0JkgyBUiu43O48nf/Hrv85P1dgiaU5lU0vTGTti4pRU9w93QZhWVT1243w6Gcex7cbp9NXXX72p6v3x9AiQ6cd2vszatn96ejo/P/dZzJkfRv4oGuNM0xYQwtXqfLd70hoAaKu6wBhLKS8urvq+N7qOkkQrC8BAuXrc/BgEgXEWISDEmKZTKfUwDIxhbYyUIgk9KWXbDBBhxljd9PPZvGvV+flLY0Vdtxixsiiqsjk/PzdWTeaTYRgeHh6eqx98PzSGV1UT+1MhjBi1MS6KktXy8u7uLgyyOPY/3d8lSTSq0Wfe1dXVYbd/8+bFspq1fcMZl0IPbugbGdP59fnrzfZOSyO68WJ5Xjes67rFZJqFWVWJs+XFt9/+/O///m+DkC/mAYhcICEAAQAASURBVEEdJrQz9u3rK+cghg5Z9eriwhiD4/B89fO7TzdtlV+uF01TyYhTjJpyN0kvfvHV56e8CuMUQvjXv/jlb3/zD0WZm6HPkiTM/Ndn55TSQ15wgpIs9f78F2Kwv/jqG6xwEsUOaB5APXZX58uzZVZ1OaXh5XouxnGxmOWHfIRqMZ20Tb9azPQ4rOfToRsRQtksjJIpgMrY4csv/tKYoayK68sVMfrV+WoxDX98/+N6PU/DwPGQYB7NaZEff7jZJGG0mC6gpQ6y84tXLujHFkRZiqGzSGigrUOxn04ncdePvTQ3D9tJOmUsCFnQtTUmQIzjcrGyVtdtNQzdKT9qp+fzaeAH42CSaB1wezzthOy0bSyUx+PBWhj7qYU2DMNhbADU0+l0GMkwDM4ZOfQtrTGG2SSz8rnbjzPKjXFBECFHpNSUcKlGhHAchsOolZRpFvd9XxYNgszzojCID4cDJkCpYRgbTOAzkINSHscxpXy/3/u+n8QZhFhK6YBpmto5K9Ww2TzGMW+aahw1YTzLplmWHY/H4+nRQRwEkXMuClNnCSEEQT30Xez700mitZnPl/mpZJx0XaOV/f7jN9z3OOeX0/8AAID/ypDjf/hfTz9/M//9+0fotFRGa8OoB6ELgoAR4Ce8Ktu+H/f7Q5pOxlFKpRBCxmnPZxjhDx8+QAiimN3cv/cDVhSHJMmkQk+bh+fhxH5/JJgj6BmNOIv6RkqpEWr7Iaf8n6eSzjHnzGlfBHHAPUKZa+ouDP/Zco8xCQI/mSbjoJ/xR4f9SWsdhqHnE9YRIUcyDA6YKEzGwSLoGQ2qquEsktIEftay9vHhE/ew56HFYlEUxdnZldZKiE0QeMNoKWLn6+u2/iAF+Hj7iWAviKZVvTcWpFngB2Ro5bsf/xiFGSHEOjmfrefzRXEqS7z3KLFKM+xxwo67gzJ96HmEoPlk2o3DOA4YE4yJHGRddwpUCBLPC621CCDOAwhcUdSz6do5V9d9liVdV8VxCgFGkGAInTZa6+Mxx4gxGiCEh7H2g+FsvSqK0/G0izPfD7yyLDDy0iSUUkfBKk0WTbcVsubMxwAiHEgBxnGAmAFEk9A7nY7KyDSMIKTjoIyBRd6+evWKEt4PrZQyi2dDZ60Fdd37fvjrX/9VmZcAWN/nw+isBVEUI8iF7BAGTS2qqocYTNJ1HKdKCTG2YRAnKRnHPk4Cgulhfwr8LAzjMa+zSaC12B+2hBCtbdd152cvtYIem61X10I2u83T49PDX/7Fv3MIbzabsr2XYhh2zs3PPJb6zOfcj0K6ObyrqsoZMJ3Op+n006eH2WxBKf3h5nsArOfBQZRVfVRKLGZzhJhz8Pr6pRj13d09JXx5tqTEE0I6i+ModQ543GLMOQ+lAFHIqnITpXEQeJ7PpNBiVNPJqi4bDeqq7FarNcVE6KFpmsftxveDty+/yMtPm/07KfvFYuUc3B1PUZA+VXcdlEbaoqjCILi4PJNCl00zS6Zna+9p8/Dh3e1ydWGtrescAmbNYDTCIIkD3rZ92Xy6unyVn0qfc4ThxeVaGUc4RsY9Pt0TgijDAFqMAcCOcTKZzpqmms0mzl0Ow8BIhjAYbfenP/1xMo2CkAdJH0QI4/JYHMdefPXlN6eT5izQVoZJqMxIKUUIxHH8+Pj4zTffPO3602Hz7Vdf1nW73T34PoNUZpm/e3zqB6H1/OLiPC+OXQ8Jsj7HYjCe5yEN+kG8ef250fq73//T2XrmHJZC+b5/OhVffP4lxvRw3GbZhCCE2mEbIi+Oln3sjBJV2Z4vvn3CH9pcOYCiKOn7fuj1ONjzs6s4Ce7ubgxUg2sBQMogwiiEoDjs6iZ/8Xp9LGUveiFbxqzV5eAkxrjr9bOpcz4745xrLTeP1eXV+au316d813UdRhQCRhCuhSQUKyUQtsdim8aBdYpQHCWru9tH7fkvLj5vm6Fq9hiVozt1Y2eAKZpTFEWc+EEY9mOLGTkVn4ZuDIJICc0IBU6NoqYe6/ocYae149zjPGjbFgIcRUE/1OVdmSRZ4Pmbzf2oRoLCi+VlXh/m85eEOtdX2ohuUGXbXV5eLi+vf/vb3yoD5vN5XeZJ6h2OT7PZ4pkEVVaHJAshxIvVRTcqjyfTVdz0RXGzIQEAyB2Kum0kxtyDwuO0KCqCvVFJFrKmqQzRZ5evHAj6TgUhBRj1Q8FZSEkwSLfPTz6njDpOgjhIP//sLUTqxfWbx7v9avE64MlqsX7Y3ObFBmG9ir9+2tzX9fbF5cvp5Gx3uF2uUq3tx4fvJ5PEWXHKD57HGPXTZKqV87xAa3l+7ghChAFnXZqFy+VSSx7w4K9/+Tdfv/nG4xghp2Xf9XWWTJ722+Vi9fnrb8ZRQovHUdDIWyZXzIYqElmWdF3HPS9MYoJZ3H41X3tZsri9+zFO59Tz20YILWyPfT8UYrBaAiutg53WhrBB99l86ZAvpYJIWSAgJRQgbZyDVtr600OBEImjzDkXBqk2cjAdAGZQDUY84PF6/hZa7PtgHKUF0kKZTCOlauOsc7wdlBA9xjgJZ9agNI6t1d3QKSNHYXzf7wcFkQ0j2ve1UkobNJszjOW+fC+Mand7zmkn6jSZdEJbA8M00FpJ2QgrjLAkAN0IeimCIFKWOUQnk2fQeB2FM07Qz3/2b5Q0j083AYuCyCkVE2oIclroabbiPJxlcrO7EcpSgqJoSlkmdaXsUDaF52PfSzmjSrrfv/sF9wNMAFwDAIAD/+O/lBr/6+X7pq4GBPjl5WXXDdIOEBlK+DgYAIwX6mP5Y1F7lPiMMYyZcwYiRynd7h7evn0NAAr8CUbYj7hWQ98fGIcY8bzYQwi1loyHUbQ4nQ7D2Hk+7pW2wBHiI2uUUpz7ztI4mkCMAUDWeut5+uL8i0+fPvpcKDGi6Lrv/CBcSF3cPXyMkliJCCC0WkWL+UQr3PeaswBDZ6RdnV9zHvzd3//PUYyP+W1R30AkIVGUxVKOgZ9enH02iHEUfRDFSTI5HRuDQV4fR3v0QehcJ0YXhOvlLNvtHwkBWkEeIjLaZtyHYex7YTcOpKmCNIj66fE0LBfzNJ0o07Vi74C21nqhuv30vQWUYP9sfVHXNfCdEEMaTruuO50O8/kcIjwMrVLqxcsr0ftBEMxms/cffnIWel64Wr9Uyh7yP84XGeEUAAAhMkANolZoMBbti33ZtDSIjAus9iFU2gwW8KotqBfGbO7a1EoGsKO4UcohCrI4rqsq5CFFXhwuAUJJ7N3cvvN9T2unBOBkupgFP/z4h/PVL9MsOOFtVe8QdgDxUzH0/Xist1prQohSQogDJxw51+a9F7hsFo/jKGRb7w/OGcY8gymjjEFwKmqPR8ZBoUVRH3pZREnWtV0cTd+8/Gq731I8Xl2+3G73xo5DT8tSIBTN5mqz+xhHM4ZJHMw0H601/WCsdWfLz+Nw8fR45Di3sImiTEp5LI4A6LprXr68uj6/OB2r2J/F/qyrZBioU/VgXe/7F5dXn1VV9fH2D3HitT0cZdF0e4Qu1stgv3ucZrOhHzf3t6MUk/kEEmyMMcasly/atm/bthnKVp0IwX6wci7r5MELDCUxREHdFDdP/8CZH4ar2OfOwdk8OZxuLeic6CkHs/nCaIgJH3pRlHsA9eGkX1y/TRJ9PP3oD/skDUTRt0d5tfjZy5cv/+4f/mM8JQa1l9fXSllgPUQkxshaxyyFjiZxWFZ/zMvD1cXnyvCLsxdtV6yX520LiuIQBRbj6fkq2G73nKL5YlFUx/OLl0VRzKLZMAxCKiEM5eGxPAo1QgI4ifJjPptNJRDajX/44z9ixnen/TjqNPGrZosJ5oEdVRdGk8O+6jtmLcAEWifbtmU0IiiQAyIolfKUBBTozimrBQqjucVsPg+UEo+bjTJ2kGqSJX4YjVKT2fScdXC7e1CisU5X3enj/XeIEsaJsdLzmHESYxKG3tBXs3mWn4owSEbRAQAANKPofnr3u/1+H3Jmnf7p3Y9CNr7vB4H/8uX12Lf9ICFEzgGl1DiOs9mMMbbdbufL0Bh5d/dgDYrjRVkdHx8/9UM7DMOz5y6Og8DzxnEkhPl+MIrGAck5jnyvbTsIMATEGoywef6MMaarG0IIQgRC0zSNUeZ5Y4IxLgpircWY5KeK0XCShVLoJEk9HtV16ZxzTjNOptOEUp7n+e3t7V/95X+ZRvOiOQahN53F798XXdeEIV+u5je3H4LDFiHrefzm9t18ks3mmRrhbn/f930URQAuqrbQWl9eL7ebPEsxxmh3OFgrZ/PMOTcMTd0cg8B3lpyO1XQ6BwD0fTuMTVUf8+JoLEbQ/+KLrw7HjTJ+muC2Gd++fjtK1dTHpiott+fXl8dDLkb9xZdvGPOTybSqmrc///px81iWJYS4qoo3b352fvFquyk+e/2WYP/D7Y+8ac/WF97RI4RcXl46YBgjhJCu63zf93jI+TQIor5vOffzPM/Sqe+Fs/Ubxth+vz1bx9aMAColyPpsVVdNHMG+H+M49T0AIY7Xy81mswjwxeVZXZfjOHie5xzEiOZ5qcy4mkyMHZ1z1qC2EYyGnMVvrr85njZKHBgdD8etMcrzWBzHUgdNPaxXszCIP94cjXHr1YXWum5KpSxGHEAtRonRGEdpOo+dc7vdZhgGgj2llEJjmHgeY3VfP6fVZdcJIZQy4yitAWmywhhJKf0oVIOBEFoLnHNaWzEq5yBCSErlecw5SAjzAg6Rbtomz08IMt8PwzAmhGnTex4HDjVN2Q8thJBSHvix0aY3o3Pw/Pz8eeSOEJhlk8f7k3OIcdR2BYI0CH1mtDI1wsZYkSRRU/d1U84or5sy8MNuMNzDTXvKiz3n1Fij9BCgZBzHvpfO0fPza0zpw+Onn7Z/zj0Gsv/iX92tfHZx/bf/9CfC3GazCYJAKRUnPkKoaapxHNIsfnrcBgG8vnpdlhUADgDQtYOxdRRFp1OhlEqTyXOnZV5UCMPJZMKoD9wzhJt1faWl9b0UY2wNCKO47Yb81CQhSdNJVTYIYcZYEEUQw9OpcM4iBNI0tQAp69I4xcgbZWEBKarK9/3PP//65ubGGEMoQZASyoTsqzoXAglVVfUpzZgfIogn1krPx1V9Qgg7BI+n7VdfLk7FaRTtfDpbr9daASn17d1HbUbOed+Nnhd0wzEMYsahEAOAGFk3joIQRgm31nLO+76v6zqMGCFkGEsAjVKiKA9nZyvKcFNv67ozjpyfZXd3dxC5xWLqgPK8oK5bxjxrrZTW8/y2bcWojFNFlfcjk6rGGPfj0I9xVdW+72ttOScAgGGQcRxHkb/ZPiolIHTr9TrwY2uQM0YMzjhFMKeY9n2PXJ/E076tmyqHiOT14cWLq7pupBb709ZZGGcZQ97d3e6Z+EwIdxZUzbGqCkyMtRojqpXBiPd9TTAriqLv+1GocRyns8wYk+fl+WqdZnFTd4yxJEmkHLu+Adj0Q+t5HgTEZ+vlYrbdPkHoEHYOqFEo3+enfD+dLGbzJK+edvt7QsjdJ7nfH+M4PD+7SJKkqgpQKIxd29aEeJNsOYxtGPKuG8p8qHiFUTCKWumeceiAEGLEAkEEMLHvP/zw9Vd/5vt+056Wy+ViMXVwPJ6ejNVxYqp6f//wyDiO47BtW4RIlk2nWbbbbaqyCP1gsVgV7z4ao7uuVXrY3t2fn5+X1akoyulkLtUAIUaQX12/6ntxfGqNxZTI6WSNENntP80XU0IQYxAavNvfa+08b8IIQxBlWbLdbqWqKaWUMqVwEl0n/OxRHpeLM2Pb9+/fIQyEEM3o/+nDHeJNL/UoKky707HN0mXgxwiBpmnms3MIiJRiNj0LRSCl9AI/LzfOucPhkKYrSmlTN4s5dkavFlNjxNPmLs0iz+O7zfZI0Ndff/3bf/rder1GBO12hzD0h6Fr5LBeXRKCnkEYWhlgLHRmMT/bbren0zEIGSH6eNpBtJrOokW2ULq/f/h4f38/nczPLs+VUtPppCwbRKL8tJ1O58fjXiv0+vVr5oOmKGezCaRWCFFVhRCCEKS0Iu8//Mm6YTabi9EFfkSZK4ri3fs/xGnKONAOY8cIwUpZytDptAv8yTAIzn2ELABGyPZsPf/ZZ5/9+OEDQiBgvnNKCBEF4TjKfhyDYEIpbZqOEBJF0TiOp9MBQmhB73kecISzaDY9AwBVzRPCKo6DojhRSikDEELO/ShM87wsmiNGrKqP++IxTedx4pUVimK+2d0++z+UUpEf+L7fdQMAAGOIIXXAOGc4p0EQAADGccyiRRRFSqnqtLWqmEwyn3NnDIB2HLvDcZcmkyDwoijY7R+VdMPYCAkx0bN5qm2r9OgHCWNU6TFJwyQOh7EKQr9pCoyC6WRNCZdqMA44i7J0VhZt145iOBEKoiAjjDBCD8fNKCrrFKHco1OEUBTFeX6IE1/Itm6O80U6jvJsvU79bGcf+05QhpxGv/vHP15crLIwScNAjPrpcet54WJxJqWRYqyr9tsvf6mtbts2DMNulFES3ny6m0wDZdWx3DmLAFHbw2Mv2jgJjTF9L6SUURQ8JyyyLGPM2+32s9nEcqCUWi0v9vsDY34UTsoyH0eFqcvSbBgrHmEErZRyGEQYxmGQdN1gHPZ4NJ2smmZbVUXXtQihMAy7rrcGIETK+lGbbjpZBaEHAAz89OL8ylpU162UWmutTO+APL9YI4ibphkFzdJJ07RdX1OKqReNgwEAE+x1rfB9/uL1K6316XRqmuZ5o2EMCII4jtO6rrUZuyEvKmEtw8Q9QwistdZarQCCmjFW11XbtmfrSwVc349KCe7Rw7Hzvejs7Ewp9fBwV1UNISSJM4tknh/y4iiFztJFGIaTyVQpeTh12gzWgGHsjFEYPTMqsNK676tne6DWsqqq2WymtTDGEAIJAZvtDcEeZRhjCBweRIWwy/MGAmZ0X9flMHbWCT9MEXKUgaYrIObP8UVjbN/XSTzN0pQx0o+Cc84Y3W23n37X/M2fffX/Lzj+/ru72J85Z7WRVX1cLCdh6Od5bozGBNZ1GQRBEmfGWAhwWeWUgSgOT6cTQqht+r7vMaJRFElphl6FEccYS2HjmAdBACGgHni42wW+i4Og7tqhVz6LZy8vGZG77aGum7OzC855XbUQIwSpNlJrOY6jkAJgvB/2SZL6PpfCOufqut7unghFeX5yzmmBslnStqUQIokXn+5/4tyDWBprCYFKQQjJJFu1bTubzR4eHg/HzXq12GzGqqqMMVKa2Wy23bWU+c6ZUbSMo8enx9VqFUVR2+VtpzDGEGLfC1ers6Io2rZ1zjjnmkMxDjrLZtogB1wQBKPoKQutQRjTOJwghDCBbdtWNTRGAYcIZlGYUIb7vocQQ0jKsvE8BiFECK1Wq7qutXbj2Esp5vPlMDYYk8PhMJnM6rqeTNLn/kKEUBolTTeMnXxePzmLCY3DMBRCCSGSeB75Z0a6vDggRCDEURQpTZqmctAU5Z4QkiYXCNu6Lj2fAaA/3b/Li/31i/Ozs/Vuv6nrPorCi4urtsv7AYxjSylP00nX1qcmj+O47/vD4fT27dvFdP3p06eqqSeTiTaDM4JT1vbj02NhLWiaLkmDJA08HhRFIeQAnGraMs+PWZb5IayqHEBFqNnu7ieTSZrMPc/z/VCbcRiafqjL1gUh++Gnx8lkMirx/nZ7pV8hhie+17a1VA1lxEjd9z0hgDJ0yvfH08HzvHfv90EQJGlUlp41qG5OGPmMI6lMXddhMPc97/HpZhwflRwQ0Hl5DOOIBzRkYd02xtSLZdL1ZdNUvhdDZLXWBHsYcQjhbDa7f8Rdq8LAaeUQZNPpoq6Lstqt1nOnbd+6xeza5wmfzZ42923bAmjatvJ4lKZT4KzHg2O17/uGUGg1z5LzOCV5senE0zJdj1Y0XY0Q6EeRJAmllDFvv99ShheLSX5qAQCz6XlZMoilkHVVn3wv25U7ypnnY1lxY0zbtmkaNm2en3brsyVGCAD06dOnoijOzy6UUgzRq4tL42xZltCiMEi6vmbUW8wWbTeM49j34zBuMTHIys32abGcMEKlMOvlUnbDZptDSJaLC48HSTxtu7qq6sfHB8ZdEPlt21IaO2fKMmcDbuuqqk48ZIvlzONBXTdN03k+I7vjn968eTObZ00tF/PV8bS/vHi92e4Px0/WGWOH6Swex6EsS0I4gKapS62E53nQ2rZr4zB1xv3p/fcej5fLNeNgGJKyLAn2lBwCP5NSIkQYYxjRUfTPskMIQVlECPGYhyBVSmitgSOTbGmtCcMIACR7FYQx59xZAoGXJtMsm9bV8PBwe3EOtdan/KDNoJVDCDgHGaacc88LECLjOB6P+yyZIAS11s8IBEyRQzCJMgjhOMqvv/66bRshB4xh37fcS/u2apueEFLVJUSmaY9SCt/nTVs8PO6Xq2y9XrVtfThuRtHGcYwAbNs2TVOhZFe3GI2z6Vk2nXz4eBgHSQhTxkU+Pz+/7DuZxakfpsMwKC0Zjfu+tQY6B1+9enV791FKgTCQSgNrkyRL4qyogNbibv9+u39azKdKDI6hP/v5t21TNHUOoPH9sC7HN6+/rJt8t3/QWloHb27fXV+99kJye/fu7GpWlAWg8rsff/P61Zfvbv+ua+XV9fxiOb+5uR8E8zxeVVXgR4vFqigKQoiUsu9OcRw2TQMhDMPQGNO2lefRP/7p77TWQoyjHILgtdKi73rGmLU2jsMkycZxyMvS9/+ZWKWMfzodlFaUEgDt5dXZbnvAmCxXk9ubR4QQ5wFGlFK02z88Pj4SSLJJ0nYFY4gQ8u6n95Qkb159PYrdfr9fruZBwB422yxLFovl/f0GIkgp1dre3t4KITjnURRZa6uyCMMQANx2fd/33MPGKan6YRg8jzlkMcYIEa0l597zF4QQEkLyPKfUn8/mRXHY75+SJMGI5vmxbVshh2Ho4jg1xgihMSbWAELIYjkTo/x482MY+saIvldaS4QhgIBQgDBACEVRNAxDFAVaS631MHZKB0PRQAgZpwjBUQ8OAmNoUZbOGUQhgQhYQAmBhAmhgCPA2bKsuq7BxCndg1EBhxjznEWMsWEYMG4fnrZa28vLy+JUng55NuX/6oQDQTabzUbRPW0OAFjuzfLiIIRSSoWR3zRNFEYAoOMh59wHDhkzSom1lp4XZJMkmyR93z5tPl1ffgUcRdj0fYsxQAj1feeAQkOgtCOEPI9PLAQQQmtUXpVFUb59/YYQJqT2/dDzgr6TUYQB1G1XI0JCHnWtKIo8Tnyl1HwytRD0fUcIqdo64D7zYmNUFEWe5wFgrVMAwjzfTmcxodwBV1UlY3w+WwVBZM3m093TYqG01s4BYwyAputrjKHvx88Y+8k0GcZ6GFvOGSFsOllqrRnzqqrK83wcRwhdlk3artYWtV0ZBAFnPiGUcz6O3TiO4yilUOuzhFJmrY+QO50OURQaPaZpSggax7HvRmvt2frCGOPx9HQ65MfTdDqNw7PV6qxrh7HPqyrvh1prmabps8+07/s4ji1QzrmqqvJTTQiZz6d1WQkh0+jFOIxd3wMAsixbTC7h5blUw7Gu9/ttHPqex30/xBhLbYdhaNthMkk5D+M4SRL4+Hg/ikap8Xja7vf7JEnCMCzy+oefnnf/LAlDLZU1nBASR2nkRxiVRqPf/eH308k8S6cIAkZRlvK6aifxKjl/3Y8FRqzrur7vZ1NqrVXShAFDCEgl6qaAyDggHOAQ6ekseXi8PR7z6WRhLVBKeT49HgtI4Co5f9qMs3lMGd5tD0V9M5lMMGTcw4xRpy2iOI5jQpBUw/GQh2FojDBG1XXZtu3F+eunx+0ojkrZq8tXj5v3VVWcn73hLDwcH4USAFpllHZis3vsR4UlbbtaiOP5+XVAvMPhNJ1OgpDc3Oxns7lS6vbu3dnZOee8qlpGlbUGIWoNgoAiyKMwraoiiv0oDrJkdjzmX375pRBd3/echXEcSzlaZzFvhOggaZ3z59MrpYwD7WziVfUxLzshbV2q2WzmsxhD9uWbb9/fft929ZRP8uJQVs04aikjYwhFBIDWOk0IA6C/+/TT2dnFdndACI1ioBRqpdZny7pqxXAHHBHDeDycrq9exHHMOHUOVEV9fnZNMD6eDl3XPL9+J0k2Tdc3N3d+1CSTTBnZj8V2O3KWnq3W0MR1syWETPzZMAyN7DCmAIDtdkM9YswQe9E2363WKUJ4d9jOZjNnEaFcSaO1SZPA94C1wBpN/IBBiKuq3m72vs/LqjoVe0yAgwNw6PzsWumhKHZRFEKIuq4ZOhUGKaXU8zyl7DOMq66GKCST6XSzuUeYJMlESslZ6IAJAk4ww8gghJ4j4NZqQsjYKscFcs12+y7woxcvXsbhWdu2GnVdPZyt11KNXdcwShD2xFhj7OkRMuT1ojrsHoUc/IBgBMNwTTEchs4Bq7WrqioMY4TIYrHg1DPGKjlgjK21TltplBF7zrkxputaY5VSAhNgrI792ZtffnVz86Gq8iCkh76MkyCbEmCQMtQ6+OHD+/XZXEoJAEAIQYCdc0VeE4IQBquzK2vw7ni4OgvDMPQ80vTNfr//8stvq7IlmMXh7Gx1XbXD/eNtlpwRgochd8ZK1QGoqvqAEAQAQEAIDsUIfE5GWT08feCUORDsjvvVfN22JYTQWtsPLcLS87IsScoq59z3QtLW7ai7vNxUbRWm9JA/Nk0JkGCerpqnMDpbry+V7tu2RRBTSpfLFcaEEBz4Sdv0xphhEFprTGAQsqIoANTO2fOLxTAMhBYEg0O+0dZCfD5fpN//4ZFz7gfEWrvZ3MfxJAg9rQTCIIvSrs99P1olK4RNP7Rd10jVRzwq8i7LpvPFtCzqYeg4Z8YqB9t0Ojnln7TWYbRomvp4Kn7xsy+Wy/Pt8d46WRQHzCDGrm7yYRDGOCVaQgilFCPgnOm62lplnTbWxsmyqbu6aY0xHiSUcpKQtt0r5RDFQRAw6jW24dxP04lW/ww0jMIEAFJ3dd2XjGNIIIDgabdpmmo2T2UrDDBCCwg8jNzlxStCEed8GLpRVFWzSeIJxhhCjglo25ZRDoDFBGKMAHDW6jSdVnURhmFd11JKzn1lzNg3lFLqYYKZKESSRPP5/HA4cM6VdEkSh0FaVQWEgRsqhGDfl5hgSilGzBpEqQehtRZop4vi5Pv+erkcx5YxBiH4f/32t//5L37xL9XGsZ6ru0/vbz5cv1gboKQcy3wvhGibPsnmzpkoitqmD3z62dvP8jznnDuo8/w0nc445+M4UkrHEVqnPt78iXFCKTbGReFESzh0cDpbSgkJVlKaeBVzj97efMqHvRcEfTPEYTSfz3e7w+F0nE7mQRB4npfEYdXWRV2sllcIkSTFXdfVdbteXeTlk5TDfBru93vP87I061pLeVgUp+Vy2fdj6GOlxvVyLmRft7u27d+++UoK19VdV4uXl2+EEJShw6HXRg0Qck7atjbGJEkmpdEKlEVDiS+EqKq672SazBgjxvzzw4oQUhSV0oJz7vux57VVVU0nK4L9YVDA0bvb+8UsdRwpZZLEf3x8nExSABDnnrPPbgxsjPO8wBgzny+VUkaxSYYghFJKJUHbiOOhHAahncjzPE3jyWTS9+M4jpTiUXRK6ThJnMXGGIyhtVoIkYTply9+9ulwU9W5tfKUP/VDJYdxEBVBVssx12JO51ICpeTbV6/LspYaTiYzCOFue6LMOaCXyznn/FgcIHF+5DOPvfv4hAhhnqet6k5ba8FzXZy1drZYIxK+++mDxxAhjBB2c3Pj+9z3fUayi7M3UTDbHRTFq832kwNaC00gOVue8RDf3d15QaiNMFJSxo55GYZJkkb5qVZWQIKSINtsGwRt2Z7Wi7d965bzV2IgXWPDYCbFUFV1FEXOaKFN1w1ROOGcG605C8L1dBg758x0Gm63+/ls4XsJwY1HrNVcSeQsMRoeDzmlDWPUOogxadq+HTqhVJJMIcCDwPt9FYZVHGUYw6fNJyEXSRoQzJI06rouLx+zLLFWIgTCiCsJtrvG96Pz9VRL03cuCFxeHdq2HYYhil9wHp6tX+12m7atEVbWqf3h7ux8AQ6qadTbz34pRpsXm7quKc6m0wxiNMka3wujKKmK8je/+3shy7OzpbHquz/+YxynYjQAgMV8TbCn6269ih4+nYAFBvY3N+/SdJ2mE1CBPK+7vqIEvn9/m6WzVy+/oMz9/ve/3+12k8mkbbrFYnHX3AtpKDEQQkrxMAxRmFqDIeBvX3+zPd7K3olen60vTvlhFE0YsVFUD5tPi8XiyzdfFV318cPtw+bJ2MFhEwR+EEZNWSAC+66eztaEnEmjo3DKPXwsdlI64Mg4KoJ9HnBytf6s7wDDTGnxtLsNguD7P/3JT8CLs1dto0I/DoJlVRRiaIMg0kqFoRfHfpbOjodyki2ktM4ijwdPT48OSKOEMygIIk74Id9rM6bJRDutlOKcr1arpq2aprq4uLAS3T/cUDZcXS8JYdoILbHPs1NZUEqNMdYASnnb9hioSTLnvhdGXIgBY8wYL0vp8cDzCYI8SeKb2w9dW89mk6ZpuqbNsklRFdIZRmmaRhDCtquVUdDCUbTcw55P7x9u0jTVWgJAoygaet21I0IEQlgUJ4RcLypQOorCqioIhUkaKKUwxgAAznzP8yDEEEKlDEfUOTedTquq60XPfb9pxyAIlqt5Xeeb7R4C3FfjanmeRdmWEExMlmVR7Ilh3O6eoih4nrUY7QjhjAZJPBGqfv/+p8vLS8bYc8Gbhebm/gMFzAIbp9FhX1ASlmWOnPUZl0AEkTdJZ0mc5tVeOwWgddiEfNJ1XX5qLr/5syIfRjF4nmE0TVPP87zAj4qioLQKgggAZLRLkkgIYYwxRpfVKQg8Y5S2Sg25MWa5TtpOPDzeYMQ5p2EYzubR4XBAGAotKPGt04+Pd5PJrKwLQnEQ+dyj2pr7+7s0nYRRxsj0aXO3edqFkQ+AK6vc8xhlhBLvyy9+np+KvDgMY9f1+e7wMUkj7hFCoXVAa4kwAAA7pxwAxqpZNqGUFqfcGOP7PuPkeCyhIc/7NYQAxuSZsIQx8nz+nB1njBFCMH4WK/RQbQByQchG0Q29NMZYpyBxZVnOZ8sgCKyTnudhjCmlURQ5E3Y9ZBxorcSofN8DMDkcW4RIHKUQIufsOCjPC5yzTZsjhIaxwSTKiyMAwPM8IUTf14x5xlitLEag70eEpLU6CHwIMSX/X5b+a9mWJc3Sw1y7h46Ycom9tjgqT2ZVlugCCYAACTOa8RH5FLwGjQYajSCNIIFudHV3dWVlHrHPFktOHdq1Oy9W3c+bsBnh/osxvpEY7bwP3ttxainDr06NeR4QQknCz6dWiCRLGwiwlHKxWCilGMc+2Kfd17Y7z3Jcb68opf/2T3/xLvzXf/uHzy+O0QIYM4zdMLSUxRhhVTWMiv3uyHlCCNHac84hNBjjjGUv5slYRShKkrwsFpfLZZYz51TpOU0F4gZCn2YVCIm3oiqutqvc2fDL7j/nRa1U989/+ieCWYyRMRacSXi6XK6fnp6UUs5oqSZ3dBBFF/D5/Mz+lTU0rNcNxMX5ODkNEaR1wadpOhwOhPk3b95AEI0xWruuG4uicFprI5OkkHJyziVJ4pzRxkLIPrx/114GzjnCcJpkmqY+SESjUmqY5mGUeVpSwqe5JzjBKcuyzNn2cDh888378/mcZdk4jhBCznmIrmmaYRgQJO3Q7vf7PFtzllKBm2aJEMjz9DX49HJpx3EkBCFErAuvqTFaa85FCPFwOMYYnx5f8jx/+/ZtP5ydc1KNWZZlefXw9EIprutqnqeqqqdpKooc4TiOztkYcajrBSb+8eHL6dS9vX33dHzQcsAYRhCMnYyVBKLVtmzbgBAqqoYQOo3nYZhOp4v38WW/hzACAJw3DBHGCGMpY0LJyXmjzWit4oIslm/KKnl+eWzbdru9BgD0fY+gen55HAdlrCqrRduP19c3aZ6/fXNjjBsH+XD/ZOxvELmyYhH4LC1iBF3XQwhZUhd5gzBou8k5X9eLRNTOIqUMF3Qap89ffl0u123bphleLpcRmFlarbVSarPZzvOsNAhRO20wxowzZxElSQw4uMCEMM7sdrs3b276vn39TF4T3kEgq+X1K+JlsVgCAF57xSKrMfHOqX7ogIBKzYQwBCOjRZ4uCWZ5Hh8ePxkrv/3wVxAIKaU2/evJn6ZpBO75+ZGzcrFqjAbfvP/95y+/dheViGyz2dzfP3GKTucdo3lVLvI8f9l94UkoSpGltZJxvXzjzGF/uMcY9+NuGNurq6tx7PuxW6+3xqrjYUoFOR6+SDN9/8O3l8tFSpkkAhN4db1glO2ez1nR/OVf/tNqtf3Dj7//y8//ovTYdocIOISIIrxZ3yg9llVdlHW9qLTp/uZv/sZ7XzW1MnqS6m//5h/+8pe/tP2ZMcYYw5jWi+b+y9N+d/n7v/uHcbqZ5j4VEGK1WtXO219++3er5XVe8PNl//NnGAJCCO33L9r0mLoQNaGN1jpEl+XcOYUx5ZC/uXn/snus62XXvR5W1fl8Xq+uCec8y6u+74pSaNNzTt998+7h+c/jNHDeyNl6B7UKhPH1ervfHbv+ghDdrG/neV6tVs457+3L7lHbLsJ5taij9zFYhKB1MssSzhNjzHK5llLO85ymKYSxbVunnXVKSpfnKYRQSgmjMGaK0b8umJNUHA7t2A93dx+aurm0ozFmv9957/Mcc5Z5h5SMEFgApnnSzoUsK6IHr4DkNCu8dc4FY9z5fFZ6rJqqrPLjy+lVDllVTZqmh8Oh72fOOfCtSDDGkBAihOCJ2O+ORb7cbJrzZffysNtsV865pmmcDZQgpWdGxSu5yDr922+/vf+AhMj7vovAD0NXlOnNzfXLy9Msx6IoQJx//vk/FuXKhxFEg4CBEHCReh/lbDEmNPKuPZYlXa8WCFIlY12UzuuUchrY5dwxJsqmVoNRs4kYLpZ1kZXazITCYZonO8jZpiKPeVxvV1++/kYTlOUli9WyAQAAKW0IkVI8juOiyS/nTs7aGKeUkbOt64RSx5gQPL3avvmXP/8zxiQv0uPx5Xw5NE0FYFBKLZoV9wHG6IP98bvfK2UeHu4RxMv11eXcaa+Xy1Xfjefz+dw+McZmeaGUMsY5K2FMxj4krCjz9Wqd9cNlmuY3b94VRfH580eA2PkyIVxsr4pZnXiSIgYP55fDaV/XK87EOGqpbJJwIhjAwVioXzcLNI1BD8PckOrd2w+Hpyl6Zq0HKITolJ4hACGEKi8gBN5Z5xDGJEkyjOg8K8Zx149fH74s6w0maJYzRBYBL3gOAKaUCJ4b49K0AJFAwJx3RZG17fl8OW63G2dB2455XgteEJxgzLx3WbqghL/SPrigEAaMwfG4r6omERklfJ4MRhRjVJYVIUzO2lkHQHzZPRCcLBdb4EGW8XHq2vZ8fX0NIfbRh2jSNCnL/HxqAQBVVSBEMEUu+BBCknCl1K+//kQIqaq8yJeEkL49CyH+/PnYvgzjMEOIaUp9H7TydbOWUqZJtVw4KWXX9VmWIYSXi/U46L98/Ms49pgARopUsPYitQJlvsYETNPkLKiyXCklZ0tQEj3kPCvyxadPn66urrgISsHuYiHAwYFZWUIgCAEAIKWMIIiEl2U2KQWBe346jHOb5YnWum3PEWkIGAACQS54buy8Px632y0ilhACcbDavn37tus6YzQlEeP46dPHplmWxRpj7H3MsuTp6aUf6ufdCwS4KpaLarVcr8bp8vnhl2kaqnpZV6uhb1/hsM4brZUxBsBgrXp8uocQYmvneXztkcap/9Of/pQmeZ7nhCIuaFEUaVIM47ksc6MUISTN08ul3W63wzCsVss8KySSCCHOOaU0RgAACCEQQrZXa61127YAgDRNF4vVulnvTjvrdNM049QTzIZhlFK27YlQoLX94btvAWSfPv9aVryqC07E169fF7V3XlIGEpK9pnVwQl8PUiGEEMIYQxlKM/rl688Y4wBDP1CMKcYRIifVcDqrPKuTJM0LsVjm4zBzAZWeE8vKok6ShDHmvV+v2eXS7fYPjIq64c7H2zcbiOEs+0mn3lvlZ60UhLAssiRFTVNhTAmmEIVLe8jKIkmSWY7L5bLv24eHp5urD9vN1cvukRBYlMiaSCnebrfWzSVPHp9/q+u6H06r5dVyVcmHwXmp9QQ5XBSLPCsYjYKXFDOl5sPxuZ+OdV3E6L33nNNfP/7lu+9+gMgcD09VuYoRGqtSyvO8tNaZYQ4GjuM0z0YIkWbJ5XLBGN9sr4KBuWjqunl++SwoSxh9fvy6Xr7rp3GYDq+hIULkIapxHDkru/44T/7Dh28gCpShEEKaVEUWpvElz+jT8+eff/nn29sbTOLDw8PV1abK0OPD4frqZrVaHU6fEULW+t/98PtLu7NOVWVxPp6MCct6OU1SMK7s3F76aTR5VocQXoHRp+Pl5WX/jn8oi7X3fvdy0hI3zRuIjI+QEF6VDcbYRVfUVfDm428/5XmaZKn3/vHxsVktlTS746lZbn+8+sPHj7/4YHkipJx5QigHn+9/Loul1Bai8PTyUDQCofD49BmhIOewWm2GsT3s27/6qz8ejvLSdeuyTLPk5eWJIIAxyvP0+engPHl394NzbpomIuLxuAcAUpKEEE6nE/xf/vR/vr75/nQ6aXuBCEWQMsYO588MBRiLq/X3lNKnl49cAMqwnE3bnTAStzfvp1FO8/AaO6m1TlKKMQzOwgidDZOcWUKXq8YZCgAoimIYhqLInDen06muS8FgjPB8PnOWQohjwFmWj+M8yQOIcJ7Ver3ECA7DeH11l4h8f7gA6E7nfZZlINJ3b7+vyvp8PhsrT6eDSBjGAEQv5UQpJYQsVutpGOdZIYSs1QC6AMK5O29X2+VidTichEjHYS6KMkmS3W5Xl8t+GGY5KitX69p5z1gqZxf8rLW2TlOKhUgFT183UNp0t7dv53mGEEo59eOwWb8hmHsLXilyUo4ReM750E83NzfRhqEzSVpNarSxW28ajLhWAEYwTq3SQ4xOJAxBGgPGmGZcXNpdAC7JMwBJ8Mi4EGMEHoeop/FclnWRLMpi4Zx5fvra6w4hghGTUn/zzTd5lT08f9ntn26WH3gSsizdPXdFUV3aF+uUs3DVXGFMXxU2AAAII2ME/KsIdC7LUpspBCvVoM2IcBh7e3V1ZZ2xziU8AYBslhvvwPN+xxirq8VisVJKz5NCiLR9Z+PT0E8hxOViK3g1T1bO4fc//rHIyk9f/qVZsvP5QHCyXt3sdocQnHY7a8jvvv+7uqh/+fxP1iqMRCLqc/dUlgutgpQyTVkErp/GGCMGkVJOCMMQveYQUoq5oNgvszI5nZ8gsc5LHzTGeB4nDLAQqQ1e8HS7vbImKmW6rrNhoJQCgDbr67GXfd8mKdFmIHCVJFld19bq42mHMdbKleUCIdD37WJZhxDGYTZWERpjdIIXMRBKE+eMVD3CDhMwjj1jxFqPEIEAE8KbejlNMoSIMZBSvo5bYoRlmUdgHh5/wygpy4ZCnhepVL3WMoQQAtBOc85jjJzzcRyDB1mWc55oHSECjJGX50fOuRDi9QdZshJCnI/75bIO0T0+3mOMsyxTLsYYt5srNWvrdJnllJK2O0sjk4Q7FxhNh35mTDivKEVNdfe6a9tu17McdrtHYycAwzS42zfXICKMEghY142v4UwQhyRDQgQ5TmW2SET18PDUj5e6qiCMScKHsZ2mabFaAoTW62138eP8BKCTE5DaJClitHh/9zdezcadTu0uQpymQuqznG0MvG4yZ8Fqtb5czu35RSQ8hCB4xmntvOqHS5ZxH9zL826ezXq1fXf7B+dCN/SbbXNsH4ehu7l9bzSUcxdCwBgzRkK009wpNXFB06QIIYzjvF5tpZSU0jQTP//8M8Hsj3/z49f73yhJy/x6GnWIyscZeDCO43c//KiU7tohhCCEmOU4z9O7d+8IIVmWvU4+hBDWeK294GmW5WVZfvr0JU3TxWLx66+/BngmBDJO/hXDagxE0ZiZ0fzN7bcIi19++TMTQcnh7c2HNFkum9U//fM/RuxXy808q+AhAOB0OCAYlquVsopyJgSzRu2eH+ZxWmzXWVo7CyCMaUadNy/PB8HLoijyPAUAvCpFiqKa5zmEwInwwCslV+vaOX2+HI1RMcar67+lCHf9qeuP47inFDaL2rsw9bJpqqZpjAldO5ZlbYzaH57XmzeMMetkiNZaKaVNRVMWywj86fzCGEGQUZI2zXJ/eIxAD2Nblc0wzGlSgUgopbPsEfY3V8vT6TSNqq42y/o6BBCjf3z6wlKfZdnDw0NZlkVRXC6XLM1DCMoNVrP1+srYwVpTlRujfQSGoYpQtz8/IOwIxX039G27Wq3y5GbRbIZh2B0+n9uvlGHBqqq4Kevl/vQrIWRZfzAatP3LcrHGKN+dflbSF0WlzVyVPEaEQRN93jT+cHwexrNIKMaxaZbH45mztK4XZb4+HjqpRg9VnqdD71KxkvpQVuk8z0OvE15HB7abJs3xv/z6H/OsaS8jRJ5xCGGYZ210rOp0tXhX581/+I//luLkze2P1zfrz/f/dGh3wcPV8mboxjRjxk4AhK7r3lzfXV1dzVrN8zyOI0Y8TfNEZP0wr9ZN352enr9mmaiKTCk1TVMEqu9HjDEAIc24MpbzbJ5skjAAoFZeq/A3f/N3j0+f+/G5qkWSVu25E4wQgr11nKcxJt6SIl+cL7vZdFmeVOVy93K8u7tTSpEYC8FTQjqlBEGYEOytSVCFqZknjallLKvLG6MmHGKwpigFBGSUZ0TEZrvVRrWXQ1EmalLVcj2Ncpymuq6rainlBAzyyuZ57o2LLrRt76NjnENKjAsxhggxwjBG76OGiFEW7Hgexxlifup8Xa1EknVdt98fKaUQgzzPMcbTOHf9QcrBWr87PRR5/e23v//l5z+33SXLWQC+G8ZXSAumjPMkgogjRpAnuMIw6/uZc2qtBDAkiej6c91kEATrpBC0bDJCyDi0IGhr1O3Vm/3+Jc/LEEKMsWoWEEIfQ0M5iCRPrqUaELS31zdGB0KSukyNU2PXRWC994Kkq2Zb59sAqHG7YW6VGrdXay89wD4YY8Ik1QgASPNcS9PUtZqkHFWT3hQpjlBZZ8ZxXKw2goFhGK63q+Px6HmplcdoCEgTQiD3fp6KfJ2IqsggI4nAok7qUBoPZ+vp6dID4hGLaV4TQh4fHwOY5jGsV1daW20mrVRebITI5nm0VgnBtJn6fmrqdZlfM8am7IIxytJmmocQgqA8+Hg6nRdlCjG5nA5FWqwXixfzovRIoIKYlnltDfjm/Q99N87j8eqqTlNw2J8ZTbq2jd766LMUpRx1rUrT1MDQXp67y8FbgkA+DN1qtbF+JWdTFouyWGIMpBpeqdubzcZZh3FCMIUI8YQdTy/upP/43fd3mxtj9Mv+U5phxsU4DSLh1oBJTRhTH+yXL1+SJEOQEUIzsZJystYOfQshFAmhVMSIvIWUYm0mBMmi3BrjvO6j19ZxgtPoOYRBCLBYLNruRAihiEESINIgBIZJCAj6kImCME6Jez3Q5Wwvlw5BulisQjQgUmNCInIIoZwNgB6jHIYYbAgk9q0mJHM+JglLM3E4HIzWIZrXQGNngZw9BA7DrCzStjs4rfKU54nousnp6BNtrC/qfJ5nSunV9u7uzbuXw/H026+r1ZWe4fncljXtpgMh1AVQVomzcLvcSik1HYKfnMVFtrlu/gttzz+d/sPxeNgfXqSc3r7bdv0RM/n88inPi7s3Hzin+9OuyCshRN9pwRJvrdJzIgIN9u7d266t//Gf/h9FUaRpOg5TWdbzPFOeWhMY67nL82z5MH3xoR3H4K359lvqtHt+OW6vlofLDsKku5huaN/c3TiHGGcIEqXUzd2baegP+2OWlpQmzhtK8TC2h8Puu+9+PB17IZLnl8f1evWHHz88Pj1NrYSAzaPO8pyi1HvTz62eQ5GVlPC04BDF42mkFFtrj6eXPM+6vs/yN0VeIez7oZVSft59/vu/5yLDh8NZzhrRoK15ePxstFsu1xiTWeoQYZ6SsT9jxKd+dAFACL131mmKxKKuQwhazoLhaTiP08n5OSvLee4R8cpIZacsT3wwf/7lz9+//zcPj58RJFmaKKU3q28QSaQZf/1yBIgKVlNcE9z98uufXk28eZW1Q0spB9p4ZyhFkOCkFBFaFwzlOYTweN4zDhB1kGjE9MtxJDgVvMiLzFptjBIiLbL8afcVIjd0rp/Gq6srAMLXr5+PXz+JBEOq02Qe56Htp6Lh57bN6XVdrZXuD8cnAFz/8slZn2XFqXsUgiUpc944YDwwJobH/cuyvnahffj66ZsP30+KfvqP/0Igqur0bvtXozpZd4yICl707YVSjCE4nXWWb65v8i9fP5Uofd49OeeaVTWN5+OpZYxFR3OxTrdro7QxplytHh4eIjCcJ3K20zRfzkNdL1hulJsg8lIbbMXtzXd11beXlxlN48NPIQTG2N/81f/hty+ffTSiJJEeDocdggnH5TRNxrnz5bDeEADIhw9vP3/5dHOzabvz5XJ5/y4jWM46GCspQ1VV9ZdZDsAb6JHupvHL/SPDPEur6+X7sqh38Xg+n/NC9Odxnqxgy7/78b/98uWrUfLu5naV+344AieLRY5oMHaOUJooM3513D8UGU8zIQQX+diNEwB+mg51eW2NITRcuvtZnRAiichNkINsL+cuRjQP82ZdplwMfT/LcZp8ALOxA/fg0huEYDedL6eX5XJJKOI88RHGGIx2AIQ8vfLeztM+QuVjJ1L/+Nz1fdvUgPMEoXwc5/fvv9s93/fDc5Yln7485yUOsB0lS7MiLxqlTF6khFB0OO6M0RBGhAEm0DoHUQQA5Xl2OLw0dfjmw9vn/ePzwwPj+NTNIYAsh2lCRcL7oaOEa+XzrDba5XkOAPDeCcFDCIfDKU0K772zxhgdYIgwUIadtySi12WbdhoGKIRIkmQcZ4Kz1bKCGMcIX6EIIMI8qwCKSsmmacqy/PTp0/G4Iyx5Dbn1wX7++psNHiG4WNRKy9fWxDnnQqzrBYjIKquUZpRDCGMA2hjvPQR0mmYI8KvpMQLH0yKE8NqDMposF1epYEIIay1lFGPct10IgXOBEJpG+cN330s1/fTz2VpfFM2y2UYHhv0QI2oWy2mavPcAEQ/i4fBICAnBiIQFa1/7HuecDW612iRJcjgeESRZlqtJI0g2V9uHR0UZM0YZ7eWoNpsNhCgEkOdlRBBCAEAAAJxOp8vlVFULSpJE5I4ABEmM2NkYPJL9JIRI0zzN0qf7p7IsU55cb660dJvVRohMyROIrCpT57ycTZrmWttxHIuiaJomSZKu6/qu32y3Ss3jOLxqa3wEAKCqqoxxZVaDII6HbhqNSNisughI8JCzVHDiLJBSY0zmyQzDRBl/ORySFDgfg9YfP/6SJJmLyk4qBHBQz1W1FEnatucQzdf7X9+//3EYJm0mSunpfGmaarFYPT8/IkAEIwRhqx0AgLPsav3WWjPJwz/95WmUU54X1g3jNCSiqMqFc+ZyuUCAo2eJ4ART7/3V1dU0t0opQv41ZuL1teGcA0a1kRCmACM5K4wxY+zN7d3+2BGChRDj1AMAvPcYE4QQQMhHH70HCIgstdYq3RMKKSUIodfgjDwLAKBpmsephRA4b72PSikAAsaQMkwwq8oVACDPa+89FdT3dppGH3QMEACcJhWCPAAQoynLHMCAoJe6laof1RDONgYAAW+a2gM3DB1BiHMOYOjaQVnjnCuKIsaYZSmAy6eXj1kmsoxobQBEMZC+H7RWUmoIMMRMKWXsOM0tgO7jb5/TVBRFESMEAIPAQYwIinGUQ68oSWKElPLVOvXeGuMZY8aYy/mR84TzREm93x2+++6729u7GGOSZNqGfmibpg7RMI7TlGFSc865KH76838UBBOCjDGc86fnhzzPq0WeZdk02lcHYJ7nSpmqKmL0Uo1Zsnn79u39g+n6Y9M0eZ57hwjmeg7e23EeIIpv3ryBCEljr66u+nM3DBfBi0vbTtFcXd10l5PgDIDJWl+VTV3X5/M5eDSNMs/zx6cvSilrHYR4vzuv1xuC2Xa7CMA+Pz8/P+02mw2lOMYAoJWqLdMkxpgkSYzAKSOlzPMMIaSmOUartQowEBH0OA7dpSiKqlpEoPq+vb6+9i5eLi2hMU3TcR6//fY7a3zXDYiAANzTy70xxmiZpRVj7NIejJ2TPOWEIoQARK+HMCHIBztNQ5JwIYpJTkopnKZpmjbNwtiJs5im+TicvcMJf520RYhAlmXOhbY/V1UxTp3WOhG5kj7Lsqa+ojASwrJ8aYyhdHG+vEyjJhSJTAQYXQAAMT3botgoaTBMf/+Hvz2dd6fzCwBxlipJ+ND1lFIXpjzPa3XtDEeQbbciOJ1m1PozJmG13EhlHYJpUvTDqa6Seba3N0ulZwTJx4+fXpOJCGZSAYZ5s1glosCUeGX7cQAAZDgTInt53td1jRDSWqWp0FqumsX98dAPg0gYAPF8PgtKvIPWgOBA3w9XV1cAwOvr689ffv369WuSgRDQYrFCkF9tF8fL8eHhIc1K7/WlPVKKXx3jlCRaBZwQ51SEhAvaXobN+ta5IIyZ54EEkPAFJ6IqF303D70s6+Jy8aPUIhEPD0/ffth20y5Cad305eG3D9/c/fqrDFGv11ez6iCEfewhhMq4q5s3x/OZ8uR594IIgSi+qo6cc/ky1RoOU5BSr5YlY+Lx8TEGOE0yEfnN9RvngrU+SZJZj7vd7nh6Xq+Xy+Xy8fExxsA5L4smTYp5niEIWVEhaEMAMbhhmOq6/PHH3//jP/774/HivU+SYrvdFuldVTZfv359//Yd9PHd3R+knF52T1dX7NK99J1cr+txnMfebjerw2FPkiQ5HPYQRkwgjfj1DEUIeeeqRTlN09eHX4wbiqLY3KzUNLO5sFa3bTuOozHKmNBUDYjodZiMKH4NSaGUEiqurpssySlnXXdxMVhrrFcIUQhhDLFt2zRNGSFa6RgAZ8q5cL39RmvZDh2AwfvASJpnzc3V3aXfXy6n10UvQgAlmBKotSXkFZUzlVUGohynQWvNOGWE5VlBKU9EppSB0Ash7m7fauOG8YIQIYQhSBkTzhnvvbFKpGmSJJTyvh/kbEJAwaPz+ey9Z4xlWQoAmLUKIQbvrdLdeTwfjzF6igjHiaCiu1wY5d98883pnAxDCwCABCs1Pzx8vbndPD8/U4aur6+fHx6NsZRyIVKlZmfB1/1TVTeiEO2l50nm7HT/dA8RBhEgKDbrzBgjZz31Eua0KAqptfPG2n9tnbOsKIuFUnYYJgRZniEQEaV8sVie2+icT5LEGJeleQwgBOBciBHWdY0QHgbcD2OaVfM8W2txT66urpSSUg2viA6MMSZRSWdMECLLc3S5XBAiLBFa2zLf3t7cns+tVkaqGSBW5M3pdKCCT9PMaE4IresGI9a2ffBgtSm7qYDIYAcji7OcWMKJiIIWjAmljNaTDVqqPs2E1vP91091Xc9TCwCAECo5OxOKdAkiDREopcuifr0FQwAAgK59iBCLhGEcQsQhBIxEwlejO2Rpw1mqtc3SnDFyOh+GoQ8hUMIj8NZ659zrGt5a23UXgkXwJEvT77///f39PaH4cDgMo8qyLC9SpWdj3DiOPlhK07IsT+eDUipJkrqunTP7wxSjN8Z4HxAECDKMKcZYa2ndnGWZtSFJWVNX3sdxHEFEdb1UQ1ivt8vl8ueffw69B9CFEKSUjFYAAIwwCLipq93uUUpp7ARR9N5iAqo6pYggDK0xzhlCMAgBIBCCG8f5cNmbvb26ukl4lWU5RNFarZVdLOrFYnE6fYxAJEI457z31niEwGbVCF58/vovSvdZJa6uNovFou/7cZDLxdV2LcZxBAC0lxkAsFisYowY09P5GSOKMS7LOk9SRruu646nl//6v/rvvt5/vrm5SdP0dDoJnlo/SSkh4ElCjR0icATSq9UdpVQNX1frJWOoHc+cJZTSpmm0lg9f76tyqayHkRBCgje7w4lTCKCRRkuttbMizQEMn7/eg0jW6+3v//Dt169f//Ef/+3d3d2HD9+ezu08dw8PD4tiZT087C83NzeMiabeVnnzcP8pxphl2XbzxlrbtTPjxPuotW7qNaGIMVYUpTHuch4oFWlSdOPl3d23fd8nSXI+n4syq8rk0ikAknEcg0d3d28xm6d56Ps+z3NI46nbAxCs031/4YIuV7n3bpwul8spBKC1g5BAgJUaP3x4R3Hd95cYYZLS5+dnqQaMEaHQe2DsHEFVFCljGaWo73sQAQREK2edrqqSEt73T0WRr9fX7ce/gIislcNgrZNSzhgTEHFVXI3jiCALHhgtnQur5YYxIachRmutLooqzauunUgpKEm0PVvndl+OZdlgTMfBJolIkwyh1+Kb5lnjLVks786nHkEaA+tbDQJHmLy5XWACKD0BALiIcgbL5i5Lq66/5AWnWFhrT5fH5Xozz3oazOrt2/V6eTqn59NjVa2dC0+PL8vVwjnXtq3WdhjmVCyllJO0D08fM5G+f/9NWVWfPn05993t7bW15nK5AABCAFlacp7sd11CS8VGY2Sk8bQ/5HmJAFuvbnfP93W9dC6O4ywEu7u7+/NPfwKAMpoU+SJ4kib1lnI56649j7KLwKdJfj6fX7U4y8X6eBiMGQhmzlrC0lmZ1WqjtSbOJjwbB0UAEryYenn/9HkxFjF6Y12aius3Wx363z7/58PhtF4vj+106drVarXYVN7b06E3bjodL3mRxBhPp9PhcFosFm/fvnfOzNOktfZqvtqskyTZ7Z4J4XW1rOuV0U7OZ2McIZQQliTZ589fhRAEUwhhmibqUUmph2GCgDIOu6591aIZPSWCFUXdXvrgfZomh30LQEhTIUQieD7N3Xp1RTBLaF6kefT+sNsBEPK8XNTNm+tveBr64bxevYGR5lnTFAJAo60hIslEkkIEYozORzubEHFZ1YSQYbhgjAmBT0/3i8WCED70U57VQrD9ceeDlWpaNBuCGUKsqTfH427oe2W0QGzWCiFSVyspZVDW6JCllbW6nwKCjCE+TgMh9FWH1bWD0TZGTDBDIDNOew8oJdZakaAQwOnYEoEQQk/Pj8ao5WZZFlkIAWE6DCoEX5Z5jAFRcD4fX3fVr6ACAFDXDZSyJM+ABwFEpczpdAHACyFiDAQL67wQCU/TJEnmeU4SkqbpPM+UI+OllNK5QAgwxiolnfMIoVkqhODdm3cAAOdC0yxDcAihrrtYa9t+p9SMcFRWMQA4T7TWp9PRGE0pVZNcrbZDP2HEq7LCGA/DUFdLCLAxoSgq72MPxtPlVBVV38skSbJM5HneXk6MUin19fW1DX4ce0rpMLR5VvpgIcQxmqvrqzwvv3z5cjyZxaLWxqZp/srtcdbHCLfb62mS3kdju3P7SCkDSPIEYOIjsM659eoKQgghTJOcUn08Hl7XzJeLzvOcUeK9NebAOfYu9uOc8g0EhDOhpJ6VEpmo6/Jl9wBtwJjGGJ+enjjnmKA0FdPcuRcrhBhHFQLKsgwi9vXhK8Je4GS1YnVdt217PJ/HqQ8xy7JsmodZ9lkuXqNE5xksF1vvoNX6+++/3e0f9/uX4LRS2vu4Xq+rWmiFtEHajJTFusk4pX3fO2+SJEtE1veHYXjmnBorfVAIAcYYBMAYNQwDIViqaRzHpmm8xRAQo+PQz4SQsiwv7ZFz7oMdhi4ExxhBCEyTVdIgOI3DTBkihEiplJLWeiFeVTI0RDDPr4GrDGEQrD2fz3mep4lQejbaUcpeOShZnlzao7UaM3y13p7OO+s0wXya9M31m2map1Gulnmalv2wc0FFF8exT7MkRu8BitE672bp82yRJSml2DjtvU1ToTuFGWSMheB2u7NzZrO56vuurhdVVYFInHP9PGQiqesG02TRrJSyVcOY5MpJa+00Dc45a713sMxLBJlIWNd14zgaYxBCEMIkYedz62zcblngwXmDSViuSgjharkhhLyWKT5YAECSCGejxjOAOk/Fy+OYitXQd1VRV00DYDheWmNUkVcgouARwSkhHALKaAZAJDha22KCm+U6OjzNAyW8KODz81MIsSwWSqlh7s7d8eZ2m6Ti89ff5lk/7w6/+93vzt2JMhiiWSxL7+LnL7/mqZjV9ObNTd9P4zhXVfPtt7/b75+yLKub/LC/1HUNQEiTvO/Hh4fHP/z+r72P0+BWTdNddDBoWW9O3ctu32V54kzYbK7Op/ZwOExKXl1d7XYvx+NxmM9lWVCKAQxpxpqmkVLP89z1l9vbW0LY5TzGCDlPozbzPAvGu25o6mVVLR8e7gHARZlZaxFKkyRvmspaL6VECOV5maaZlpBSGqLrukuW8+3mLkY/DjrPaucCoSjPcu8TjKhzAQC0aG4I7qZp0M4SQl5tt/M8e++Xq8ofYz+1SZY5P+/29+M4AgTKihg/ShNBAAihm+tv6mrz9PKLdRFhAiAhVGAiIJqquv7lL3/WRi6WBYQeBng5XpQyQggIKIIwSxc3N1cQG+tm75gzVLBaDm4cJYSoHw79cPBWIkS0lt6nmEApJwBDmorlcnm5XKriqsiTNBOXy6Udur/88ueiKJOcYwJP532aiqJMhl4a7Y0GMUSnZLNIgwdSTkW2IMvKaWCUByGs11tj599+/Xh1c22MEjm92q4/f/7t9uabRbXSKshZDeNFJOxw2N/cbs/n89hPMfrj1E/jWOaltSMVr0YqabWJ8WysfO3MZ2WMCQm/3u2eEITLZQNRWF+tf/3l85///NObu6ux7wihq6tsvalfXtS5f3ZACp4qpcdxhNhRhptF4b3TShVVPslRpFzqWVvdLJvjYfY+ai0RQgSLeR4v5w4AeH19SykzOsQIvQME0yzNp2mazYgJEDzNsxICSgjL0nSapBDJ3d07a/35fA6AvGK+Y4Dv3t3N8/z8/GytrapqnkfnrBDo68NP5zbliYfQpiKR8vzweOI8EYZBQKtqcdhfNsubGMPx/FAXJVHK1PUKITDP8zRNr1b7PGsQAi/POx8UiDFNUwjRYX9CiL57e5OkDBE4jJ1zrqoaI12aZk212B2eJzkjDJRSEGLGkt3xgAGNEPqIF81GW6Wt885bA2KAnCfjOL5qIzbXtyDSlKfeQWcjwSxGN45jkS+FEH3XIuVePwMIYwh+HAfvX7W7DgJlbXI47CgDLGEYY6VU9CrLcsL55XLxQfsAEIDntkWRcM5jdK/T0Vcop3NWaQCiNzqczBmAiAhQegghpKzkPBBCAAiEUK3NNE2UcoyhEOI1gVCIxHkDACAUcEG5ILv9kRB0c/dGSnk6HZum0VqXWQEAOuwvy+Wa0uR15VSW6XKRFnV1OBymeQYZNmYGANRNPk8qeESwOJ/PEWjnnDMWwOS1k3DO5UV6Pp+Wy6UxhjFR1/Vu/7g/PFFKCYxKT9M0GOPWy7WWGiAEoyGIljmx2hFihqEzxjHGFs3KuRicWzbXCMHT6QQhQAhkWQYA6vsRQgxBnmXV5XLwzhZ5RSk1xm2328PL/mX3eH19neUJz5b7w/P9Q8s4DtFlWfUKOZhno5RCiJwvx/X6zWKx8N5Po4Qgqcr8cDis1xUFbJ7kfvfllWjeNE2IzjlXlvksB4yj1ipGTBDlnGdN/enXT//8z//COGiauu2ObXvOi+x4Uj4oZ/H2+q1Is+P5ZOyIc6a13GxWwzC1neICAogicIwjCGPXdUKINE2zLAMgjlOfJHy1WsQIh1mubr/J0vrp6fH9h9v94VlrlZeFlNM0DQAGazyE8NUvhzENAUBAQMTjoKw1GHHvA0I4z0qEyDhOUkqtVQR2nucQAOfcEqu1tjZkKSJEcJ5Q7EY17c89pRzARdv2UsokSRJRblbbC+3maX86XkIAzjltdZZWhBiCaUDIe2+D9cCZWVHyWh1GYxzGuK5rqZWUEtqBcw6gs05jIubJ7F5ORZEZC6ydnbOUloSwALDWuht6HKMxZpTjYlHXdbnb7eq6TtPcOj3L3jqs1AyAe72hjTFd1wEA0kxQiqd5mKY+RMMYGac+Rj8M2jknhBiGAVOepunQud3uGSB9u33vHABBONMP/Tzbj4LnicgJIeN0Pp0uCNJFc+2cg5B6Bykjh+OuKBupBgjYerP65deftJ7XmyXnKWMsEWmSZC+Hl6LI8jyL3hqrGCN1k/XDGRGEUEhS9PMv/xlCPPQToWi1Wrwa+J+fn2OErwwupdQsjfcBQvTqsOUsRZBQyudZCZYOvVo021Qw69T5NCjdO8eq7GqxWMyTmqYxQMA5CyGM45hX/NIeCEFVVcGIIGB5msOYjfNvnHOl7Gq1ybPqLz/9KU0q60drTVFklFIAwGq1GsfxsD8VRZGmxdBLBPpECO9d1w1ZWt5cvz0d5vPlWBQZghNnRVnmLy9PRkHvI4QwBE8ZmtvZGIcxbZolRgkl1ujeh1jk2SuRuR8GgtnLy/Or6ffp+bNSJssS68d+mCfNOcXj1Aua/u53vyuSpXfA6EBwyIoUo1hVwph5kG21zLfX5TiCcbqsVisAguC50Y5gDkG6Wtan0+l5N8/yPM8qIcuqeLNabr98/bWu6Kwu3fBAKScguXvz3fN+3w8XredZamM0xlgIQSm9tGOep8f7Z+t8UZUAhEkO1loWYAjBDXMIIEvrPF1DkFTlEkO/Pz9CiIuikHJEgEyzNRL0fUso0HLebtdyGkUq2pfTPA+r5RUlyfF41srleaq1RgQuFjVnRV2Rvm8Zh11/wsQ9PH4cB/Xu/U0Moe2GcRwJweCipmlqmmV7fiGQlvUbiiihYprg4XyaJwMhai9j0+iqLj99+nh9fb0/PEmpRRrvH34tiyVCxBglEpxl2fF4TBi8ubl5BRUOQ1dV1fFkIIxvbr/Vyvb9GEKY5cxZlqbJOI5CJIwKo5WzcRim15j3osznYzeOU5YVlAprfAwEY8ZoejyeKOVdN2BMMaZSSgjRerVljD09PbxKGl5eXoxVEMYYw2azbLsz53i9WalZbq+Wh/3FeT3PriwbM4csrQkhh8N+nlSxqcl+v8+yDEJorbbWMia01udTG6IJIQCAlDEAwKJgQqSE0M9ffmOMYoqCB8GDtm3HbgbgKK3TTnvvtTaMU0wJYdgFP81TjNHZMAyD1EpJo5Qax1kkGCEMohciESJxFvRd6yucJHwYhiQlzWrJGGOMQGRn3WIHYwx1XWqnx3EqiiJJMq2sSBJrfdd12kjnwXJVhRAs9GlSBQBfdoeu66jgr/yDqe/qcikSEmNouzZLS2PmsinPxyMIQiSsruvnl3sXDCGo70fOuTe4qirCiJZTnudpml4uXZ7nwzR9vv/8mqiuLOecT91Z6jmGWdhECGa8e9XrMca6rst4OQwTZ8lyuQQAxOhTIV657xGC3W5ntKuqynsv9SwEs9ogQNabG++9D3pWI8OYF1l7kcfj0QY7TRMXNIQIAAoBvLy8vHnzpihyKSfvDUQRIuy8KcvmdDoBABKRSSkfHx/v7u7qulaKGePk3EoXFk06dB0I+fff/puffvv/AAgpp8fjMQB4ffPWWf/KZu67UWtb1bkzr3+0LsvS2Meqqowddl+/ZnnS9ccQfC4Ko6n3nlFIKVV67PoLQkjOerV4I+dZsORihr4fEivyrMmzmkGyaFZfvn4EICilqqrarrZt2w1DX9c1AM5a631AGHTdhbNM5LQoaqXHSU15lfOMTNPQzydvYJ4VUvV9f2m7FuHIiKqq5tIfzqfWObdYrBCNCCHvoNKWMgwhdM47FyAk1gSMgrEzwbyu1llWgoh8ME/P94fD89u374extU4Tgimlff+KahBFUSyqjTd2GDo9WwixoDnGcJY9plCIfyXHa+2dC2maZimdpqlrB6MdoSgEMIyttXaxWJ26w2pdKeke7p+llH0/iiQJEUMIP335FGMsy9xY9UpWJcav19ciTY1S/dBKOYOClkUNcwg9hghb57yP1noGaZqUMCBtpA8mz9NpGod+Wi2v+74FAJTVyjtTFBmieJq1dwYC7Jydpvnt3Tvcsv1+b+w8zUNdN7/88tP7D29CNJd2OhwOeV409bJpls9PO63dK5tZ6UlOA6GQizQElyQihGCtHUdtnfIO5EJM06Q1IITNcjqez1VVKtNDEiIM/XBWSt3evG+S+nTaOW8IADja29vb3e6UNznjZLcPECIQiXf40+eP1hqM8fnUGu3u3rzz3k+TNEbfvb19un8QgjFGXjFuwzCdT22M7vpqc7lcrApFmSAEx6kTAq5Wm/PlQjkybpJmmk/9er1MEmKMMcZQwr33NzdvYowx+nmettvru/XdqbtACHNRIuwJgUVenY4X51yapjxNDocDAODt27cRSaVUkvAyL06nTkrdFNWubcdBS2liwH03pEm13dzMsjuf27yghDCtdd8PgmdaBWsCJamcLUIEADTNKgZHCIUQ3t8/IsgxxlVVnU7HeZ7fv3svpd69HGywWSa0Gvc7016mNClFwkHwQz+NowyeJEmqpJ9l57zCBLRdJxLs3Awma51JUsY4FUmTV1RJR3DGSYYgA5GcL7vT6VDWawghQZQQn+fpOPbe2xDtpKWHjgoKCfQO9ePMk2J7fRMDEQnZ7afTeZrlWGSr7eaWkWqZv5kW+tJ/lfAcgUEAUVoeD12WpS8vT0rPNzfb8/lyOl2+fL7P8ypP81SkVvvt5vZ4emGMGm+Ox/3tzVWeZyGEcZQvLy91Cd/d3R4P3SQPlEEQ8X53HsbT3e1tkTcgYVmW/PTznzBEv/vd7x4fn8uyWYp12x1jIBQm11dv27Z92T1iHKO2EcHjoavrkrHkdHrxwW42m8P+Qig7HA7b7VWR1ghgnmBj52nu3r57U2Xi+fnw+PRZ0Nw61F4mnhQxjEVa5UllJci2NUL0eDyXRSQ41fqcpqJZFDFgSrHzikKIIQIBTcM8zyrLMk6x1c5qq2bV1CLPawCCUrNzPk0LSmmep23bViXUWkeKgADGmKenp7qpXi1anPP20mvts7QInjgbYyAQkKZeee8pZdaEvpuVfHxF/guRpmnadmetdVVn/dCSIi2Lxnun5mgtVgpQkoJob29vI0C73SlCNAwDFxR0YZ40sVafTjPnFGMMQFyvm69fHw7H5yRlAHqC0SJdaa3lrGP0WnshhFIztAhjfLl0jKV1U/Z9//Mv/1RVFUuY6lWCCIJYaSkSIefRx6Cd2R2fYoxlVYiEee+NmY3VhAAAgLW+a0/r1e3vvvnDy/mT83pWlgxQzrPW2uWzNr0QKWXIRYwCem3oGU2tmSllANgQwnq9lqq31sYIgwfGgSQR06i7YTp8/pTlCWMsBG+tr6oiSVkA3keXFakLlgk29ZNUwfm5G7pXYADGOMsqZ/3xeKyqYhzHbhxWzaooirIsbXTjPESEORPTPM5qUloiFIzsEUJJnmHjMOJKunFQZVkCEBECIbqizAAA91++7nfjD7/7HoXU2eC0uVw6nrDt1fp82VPB1vU1APl68fbcHiFyEBmpxuA9JnGauzTPm6YBIKZpejqdlVIYYyEShJDWMkT36vu/urpiNNvv913XZWkxjuPrVOnq6ubTb2OMsCxqAJ1So9JDImofJKH4ZfeMMS7LEgLkLASRrZaLaZqVkoQwgumh21FM5nmWUiYpi8Bchi6CIJUdxnOaplpLEDkElGCuVN9e+jRNX6fiPmitPSEZJQATjDHmLDkeOo5BsyjTVCg9QRB9sPM87/d7RJDvXZYnTCSXcxejyRq6Oz513bNUaVnWRVE5Z2JwWvlZmjpf50U6jEcpzYd3f0jT/OHxt8PhEGFIUhojVrq/XLrV8ppgcbW92u+/IkQRFAhyguh2U0IIlFKn02m7WpRF3XVdmrKPn/5FCME53Z+neZ7SVCAsMIkgwtfcO+jbJMmUUhgxzjMIISEoBDDrXmuDEIzRE4JixHW15Dx5fLynDGMMxqlHCBV5ASGeZR88chYiSNM0LYoqLwsIcFEURtn7hy9pmt7e5D4A5800SWPNpT0BECHGZdFwllOSCNZY61nCOOdWyxiBd4BAer291VpDCI6nFx8kY7RYrChJxnGEEGVpMQwXjINScwgky8oAonWyqVdJUsB2RJBwzqe5PZ8PAPqua4VgeZ5qnSNEhEgJ5jGi5WLrnJFyTjPGOCQEMUYgxA9Pv6RpKngKkXfWE8yNMd7HJGk2Za3N8uHhYbUquvl+VhPJUBaws36ae4icsZJiWORFVW7yPP/69UHNvY+IcWSMVtoo7cZxMMasVqskSSCEwzAghIRgmJKvXx6slsbKLEsQ9v1w4pxTkxAUESIpTwc9Oxdub6/HeTwe2tVqVZRit/9KKV0uq9cJU3t+7VmplNJa2zT/il4VKXh8+g3FQGnCGKuqqsSJcYMQyatCaJ5nD3yMYL1ehxCMw99+8+PQX6ZJBmv6yxlYmKUs1fXz04HzBCOilFo0m3meb64/PD39JaQoTQo12TQtvn1/AwDY7/csDfOkX5+x69vz+dQ0ESFCCOiHE0QG4XC5nH779Ku1Xum5bhoAtdYyBLdeL18h7vvDS11eM8Y2m+ssyz5+/HmetQ9zUTFte4AIRLHvpXdgs75drVZfP31WOiLIKBKJKMZxbk+tSNhms2ma5el4mWfpvQcREyKyrMKI2aBARHlWWRPyPNfaYIydc13Xyud+lpeyzOcpYbQKIb7svzgDrZPexe3mjdJdd7kURVUkq6fjPaU8zUSS5NYevYNKRoIARvZ03BFCr7YNhmN7OTsvGWNaxUTQtj0yxm5vb/vW7A9P02jTgp3P57brIBKM5ruXy2aZ3Wze7Pd7rW0qknk2Rb487Hql5azHN7ffSml3LyejZXfp3n24o5QOkzwcd95HSnGe1YwjCESaNIIX43CwEtXVtZI+4azvOhDJ8dAu8m2WLKKLk5GEZnlW3959o0208/n93XdFUcAIt8vb+/svq2W6aLZ//uVe8OR4OCdJlqb5+SxDAG/efBsDlVJBECBgjIqXl5c8XWECIWDTqMap45y+uX0LYHh6/tL37XJxMwyD0SAGwpasqqpLe3x6enhVqZtgCBYMEeDh2E6CpvXtKsaIEeaMIMwwgpzxxWKxf3758fu/2u/3EYTr9d3X+1/lKIVgLtrFYumcv//6uKjrYZjyPGWChgAEF1ma99MwjG2aCgho8ARVdU4orJuibgrGcbOouSAABEx8Xohh7KSa0jTNi5QLOs9jWeZlWTLGlsu1MS7P8+VyAUBMUgYh2G63b968TfKCcOac6/vWBQWRC9F23WmaujQVaSogjNvtNaMcIRIBqqsFZ4l38cvj/S+//MVazTmd53mcJ2O0dUqqdtazi84YQylN01xJs98fjPVSyleze1GWZVm+wnbmeW6a1fb6Oi3Koqq9j5SzNE1eZ/WE4ixLiiIzVud5+vnLJ2OUcYN186XdL5fNhw8fKGGb9fWi2a6Wm8Pp6GOoqqrvxt3hMM9z341SSohA37c+uNfNjvfWWAUQGWdJKSdYSGkoEcvFJkkLAMA4DkrNz8+Pn377RaqeMvDTz//5/v7+ValXN+U8z/f39wCEWU7HQ/fn//zL08NO8NJZyHhmXTxfujxPEQJJyuumjDGuViuM8XK5ZDT95eePfT8kSYYgydKCs0TO+uXlGUK4Xq9fs9mKogAAzPMIUXBeLtfZm7fLiAaA+1E+/E//838/z+PlcvLefv/dD0KkD/dPu92xyOtX1OY0TZ8/fz4ej6+P3HWXrMweXx6N0YSiceyzLGOMQAwgoDGg1Wrz+x//uN3elMUCIbLdXq0W9bKppBqNnRmFq9VqsVjEAI+n3adPHzFBeZ7WdQ5h7Pv+FUKvtb7/+vjpty8IkXEclZZSDoQ77QYfjVR6lm6xuHr77oc0Xbx/940QzFiJEKIkL/OruryuylWSJIxR500/XJSaEULzpBEUGPEYMKNJmtTBExCEs3i1vL7a3r687He7Qz+0bXfK84RS9PXr1xA8hDHNBEIgRq+1foXNPz48WG1AgGVefff2+3dvPhRZDQNt2/6wP53PR21kiM5aFwJCkBdFgxE1xmmtnTM+WOdMCL7IV9bAeTbGhADiq8ckL4Q2EoCAcRynVunZe2utiwFPc+uc8d6JJGvqTV1tm/qmyK6M9dZaqS0AiDGRZcW62UJAIYxVVVinlJ4XiwWlrKnXMcC2bed5JoQghAAAlNLwr6guDQHBmBFCx3EIwUk1fPfdh6oqXlF+TbMsi/q1ti6L5aLZNM0SY9x15647QeQxhlrraW6nuVV6xBhA5J23bdsWRYEi1NqvVlsAwzAfZ7vrxkcdzsYNlIUItDYTZVDKgTJ4d30bY0wzvts/jdOFMvD23Y1IOKW8qgpKaV3X6/U6TfNpkq8NHIJYKVMtmqIoxrHvh1abuR8uSroY0GF/BhH/+ONfN/X6eOhBpLe3t/v9S9dfjqcdJkEk1AcrhPDeWmuTRITovPdKzYwRa3WaUcbh88vD4fCMMQwhTPNAKTXGeO8JIVzQEEJVFYSQT58+tZdJjo6zZLvdJikfx7NUnfPyj3/9d2/vPjDGkiRR0mhtnUUEZR/efshEQhEVNCmSKuV5kVYJe0WW2ddIB85xmjHG6Cx7ABwmfppbkWCIHIDu7u726urKWnc6ndruorV2zu52u7ZtY/Sn00EpBQEeB/X0tBNCbK/WWZZstg3CQZspL4vb23dK+nmMZb7dNt/V+fV6udSqjWHebFcQMMHW1uppHoxUnCWpKLK0JoCfjj2ALC8WjGch4q4fq6YOILhgMQnDeDZ2TpPqavMhSxZSzoTatn9E2K9WVwgmBGdlvo4BMsYQJBAirfzu5RADWTTbzfoWRKpnUyQ1I+Vvvz5jkGkVtPbr9ZaSPAYiZ7vfHU+n4zQP8zwYM0OICUvqxYazwmjIaHb35v0szTzPGBLOE618e5nGwRCUlcU6OFoVm76TEBDOkr6bjofOGoAQ8t6HALQK3UUddv1qcScnkIpGTuG06wnOdi/nRbPOsnLolZwICClGGcEiEalStu/kornqumEa9fPj+ePPX8pieXv7Llqwfzr23cR5xpgIAYzDTEmCoDge+vOh8xpSmHSnqT2OVbZsyhVweBq197EoCufc09PLNE2LxaKqSsbo6wURY3x+fu66C4Tw9Utfr7YQYGOcUk5rO8+KEAYihYARnMyT7boRI8FoHjzJ0ub56aRVxEggSAXPCRYhAOv7p+dPl3a/Pzy+HJ5n2XX9/tff/vlPf/rT61kdY8QYfvz4kVLa1CtS12WM0VnMSJmK9PH+CAGpmwoCQxC92lxTwvt+FCxvqitvSZ7eGHXQ815S+Q9//w/7434cW8Ljgq/VpNTomnL11D1Jb5XUxlsrDaW0yOv9fv/mzfZ8Pp4vJ4whhuTDu+8ulw5BEoH/3feLT59+/Zd/+SgKod0AYMI5gxF5762PScoRiYfDPk0zJSPB5ft33/38879MY5cVubV6HNtl872aLYxQcJbl9HD6ZFwNgqoy8dd/9XvOqZRzP7QioZSwMlt1Z92UpVYSEy9VG6DpBi1EtlotuktflYWSI6wLCENdFvM4jdEBaF2YRmmMN7OUgvM8zdMk7bq2aTKtodKjkr5tW8YEBDhGKARfLOuu6/Im6+a+n4asLABmFLCqqsqyjJh13YUljBE0jj1wCIVIGTfuqViGi/rHMC6yMj+dJhDidrPcbLZfv359dZTAEGwIGACGcXW9/e3Tr7OaIfQBhHGexn4qy8pBDSLMeKn0iDFOUzGOkpMkBANhlFIagxHKkwR0XVcvckKHzWqb8quXx1a7Li+8MzHazMxlN36BxKQZvbn6Y1nWsxwR8SCiNE0jsDGi9+/fW4OGwRMsEPXOhWnUctQMpYSDlNEQDSJkmEelFCFESn05XThPKE6SAkkpI4QAMmdijIhihnjMEjRN8updPc99s6j2+73T6Nv3f0SQXNqTMdJHDaLpu7OcplVdHbqXvu9i5EywYdor3QEYxmF0LpbF4mb1bk7VhXZNca2Z9EHHiIwOvCmN9j7Yrh8555dL5+3sXf/49B8wRt779XoDAT8d+17ti7whqOiHszGOMmzsZK31xFjgvvvur/UcD8eprMvzecyqZhUHa3UELkYQokMYnM4P0yzKahWVPnUnG6bg8O4gAUwI4dsl3KzffPnyqaw4iHbqw2JZff36c/BAJFCq1yVOtljUWU7O7bPWfuyn1fKWopKzdJ7nPOXRKzlHbzWnOADuHGjqb8dZe1dG0LatrOrFNE1df9IqKmWMASG0Ruv2AhijCCFlLgAA7+Qgh3FKt6s8eAERicBiTOd5NnaOwDJM5rFN09yF4bh/xJhS9kap2QeZ5VRp1439rKcYY10tE1EY462xxpgi51VZWy0DAF27B2QUSbZa3lLCd4//wauL4EVec+fcfr+b5t4Yl5eLdp4fnx6G6az8xQdytb077EYCxdCfjXacpSHE0+kQokoLOisNIHuVoBFCAIyjHAF2Ro9pmvTDEH1DSfrtd/+GUvz0ckiS1Bq73/0268v19bW1qVK2rPQw9PsXWdYNE/MrHhtC3Pc9gH5/fFitG6UV52nAaH/5Wq+y6encd1Mo4aCGoigDpNbE4Mw4XZR66vqPH95/ez5PZbFK+KoqiyQpOEvay2CdQSgYNwBlEFIYS8aRUijJSkII54mce9NKpbSSBkCPQETItZcDo+Lt3bfz5ILTw3zqxkOaMWJtUWTOgmk082RhgO/f/LA/Vc5Lqaau6969eaeVARAjIr8+/WOM4fqOJEmitfaWMSJwDHVev9nchYCmUaEIsjKburZpqnkeGU0gjtppluCA5DTJSUqIdVZnx8vTNEmt5fXV1XJx3XWXtj1QBoM31qBEsK5trRvrupZzOk16tay819orJlgI/tS9FEWZcjF2HYBwmgepfllvb+4fvlprEUIZL/pOfveH3wePjA63t7fjOE2TpBS/e3P7P/6//3sGxa679IMVgkGI1ssPw9n9l//mv9Ja+yClDEmS6tD923//P2QJ7vqxPZskXf9v/s3/aRo1xiT7Lp3mgQpeV4upa4ehe3t3a7T7/rs/Sik5p4QC7cM8eYDb/9//+n8hkNw2/+X7m7+pi3uOK4hRiG7S53/373/bXi04ydO0+Pu//m+tU0nCjQna+H/zt8v/5//4f7tcvhxPz3W5/W/+d//Hvu+zlGxW14IVzsJT/0AJmIf27s13Tw/t+7c/VlVl7JzyMs2Sy+UkRGpdrMqGUNT3bTf2q0VJED4fRsELG/Sh/fUSh6E3f/v7//319v1+/zXLMpGUnz7/ZZT/dnu1nieNYFJWyx++/4PRTilVFAXnom0vjLFpmoqsSNP01WSArynGWOk5K8Tz7nNZrwCSAJrD/pJmqOv2lMEQZTsMVFFMWYDsMg1ZzogLKedWL+U0zVNPjocOYxyBl6rDGLpg04xSSp0FGGNnQ8SwrmutzTAMGJMIhwDmNE1jjG17EgnyHmHMgrcQBQS90nME3jtPKWUcW0wZY5Twd3fvMSUhhKbG1tpxnrYAaWWVGjnnxhhtw82bDwE4CEiMcOyHYRjrurbWcpb4SK6urhEighdaRQDA+/fv//LTn6ScmqYCAHz8+JlggTE2imBYn84XbfyrKLLKqyxL5iThnIcQfvj++93LgVL6apQfRhpBiDFqbYTIHu+flLIf3n9vjHM2QEjk7AnG2piiqBGK3nutVZ5WlFJKaVPX4zhqFaIjQXPOfV3XnJPj8UgIKUo+TjYCp2aQ8HTZpEWRA+/TNHtNH+26SwwheNCUlVY+Rl+Vxf60pwTGiKy1+/1+0fxrQX0+X2JAIYRxHJxzi6pGCBljY0RPz/eEwGE8YYyen5/X6/ViuTBGM0K6tpOzcsYvlrXzhlI4yp4LOk1aKdl1FyEE5YRSLNUEQfLj735oz1prdW4HyiCl+M8//eOsJKGhzkuMYpKSCFRVNoyvD8+nVX2VJInxhtNSy97Z8d27dXsZ7+8flsvq1PZFlszzYOwcguunzyIhEbgkSZMkTYRACHKBrKRpQjkXfT9maTHPOoQAIUhT8f79+2EYnJ9jDNfXVy/Pp93u6Ydv/24cJQAg4+n5/Hw8HoNThNY+wN1u9/btW2/9OMxVxTHG1nqGkmW9IEzMs1oum7JMv97vjZ3yPO/9HGMQQviQKgVe3+0Qcdk0lJK2PUdsj+1zXa22t3WlxOu4KHRh0WykGqZpWi4ZRDmjQht57rrD7phkqfemwMV2c3s87bvuslw1nPPz+RRC1Nqdz2fKECFUa1QUefAIU+EdfNl9eX7a5XnpvLPGgJBwbpwFx+P+zZs31vrdbldXq6JIfLSvkF+RJDF6722aJlqrX375qa7LEIBRWiQMIKfMBLGEWLpw1mpumtoHnSR8nqdpVIvFitLi0h5WqyUhhHPqvUcY9H0PEQAgSCm1cUmSAGgJJzFCrY3WtmmaeRhf42oPp0uWF1rLr/cfMfFZziFy4zDlRaaUkmpYVXecJwj4LCu+fPnirXCIWxsXq2aW7el0KssKYyg4/fb9t4/PvyGENpvNJPU09dqwoqh2u+c0UV2/JzSmqSjL8ng8Hg9tkvCyyk/mMM3qy5cRgGCsokwsF5ssrQTnOpeMw//0T/9OJInISNsdp2lera/eXL0jOLtcLgmjSpokSRJRWH2YOrT88a2Zd87px4f9zc1tcHbo5Gtqo+Bpnol56I1UCUtenk8312/StNi9HPIcEkLTpDRGWe2dcYLxYZhAJNZDgPhmfaeUmsZQ5mujXVGJpilfXnYAAIgYQmEYBghCvq6GYVqt1iE4RoH3vmtHjNWrc9B7f3v7Zhh6KeXz0yFN03zbVGXDqD6fP5dN0jQLIaizFqDIOQ3RhmBjdP3UUYa9wV03cM67sbNKf/vdN8fTHiGICVFKjcP8+PhU14vFcktwAgGIERttQwht25ZNSbk4n8/TNJVlWde5VnYYBsYYxZBzzgQ/nU6v4+YYwH53rKorygQmHBNkrJ2lAQAYG5IkDT4uFuXQTy8vOyHEPM9JIoyOSZItF2uK4cPjlxBckmTOhrZtYQQhhGmaKfQx4iTJhl4WRXk6nZ2zjHFCSATi229/N/SnNCkgMrMc6mo1jbIqN0pqjDFANMto34+X8YAgrcple9Hr5e0f/vi7adSvEwJjZ8bR0/NjknBMuNK+H2SeVdZ6ayGhkCER/YVS+h/+6Z8J5mM3V981h8MhLSgjrB8nLvBudzDG7l4OWVaWxcJ5iQmY9UApD8p9+fIbJvF0PkKAOOcAAIyxcd5Yx5mHCBGC5KznWXft+Ld/+/cEpdpIiF6Vv0FqRRjlPGm7Y5ommAAu8KU9cMqWm601ADpzODx7b/f7I/jrcGn3EAOp53FSwzwIIeTsp1HdXL9P00IpFWOEKALohnmChGCMIYqQRG1m5xWEWLsuY0W14MPQPz3d57WwzkDkvPdV2cQYN5vNMAwYYwhhkmQ+BB9k8Omiuvr06yfrSJ41MUaCYa7kpE0XgEQIvoaIylkZZRFCSZJN08QYU0odj0chRJJbjFMQRFFk/fhsrCSEzLNhjGo1TxB748sslUYaZce55yi5e/NuHMdX6VyMcEZzFBGgGAEoqkokHgSYZqIqF967YerrisWgcYqcN1yQGIC28XZ7OwyDVdZDjwHuLy1EvkgzE3Xf95wnWVpRkjKaIoQwSn3YhxA4p4zxosiyLKMzSii7XC5fvnwhkHz/7Qdr7eVyKvLKOu2cXi7raZDFcrndLIdeKmWvr6/7y/lme3t7e7s/PPsgIQzWWpZxkSwwxuPUjuPsLMAAJUlztfmmHw+n06HKF1aZYRiABwACr4FIM4d9dH4e2wgMwqJrT/vdwSFEEF0utlW5IjgxRk3z+ObN+/5yZhwRjl9eXqyTjAlKaTQxxlhV1em0v7QnDGNTLzlPnh73gEpjVNu3dZNTBn3QPpgQbbSIYoIQun1/E4LXWmojIcJR23mevOcQQogigjACjxDFYEFwgolZlk2I2jnFORdLcW7lanWTp8Xh+Nj1JyknCDhGqyRJjfEEIwQTNXqEEMRGqnPZVPazBNCKBLfDhTFCEBtHwxjw3jKOyzIx2o3TOUsL52cQMaV4HOf97rhaIUrZ63g5RDfN3el8sNaMY7darRhHzqtLO3gXnQ2YQggBZRBSqtToIfXen4+n9frq5XTcbK5D8FdXV1aC87nFGMcYKMNPzw+Hw369XjrLkiSxTuckv7q6+vr18ziOy2UjVcjzXMpJ6ZELglC0fhSQMNr0/ajNyDnHSGDokwTMssPwynt/avfeO8yNj76oCpHCh4dnAAIEtMiXnFM5awih1ros88vljBGFkJxPfVEUb96sfvrp5649/fjD3xOcYIzPpwkioaQLIVZ1AVGMwGZZmhfi/uGLNuN6U0MIu65bLW6VNB9/+6VpmqappmmCgDbNUjs5jJ1Uw9eHn46nF+/Nm5sflqvyp5//BEAkxHLBqjpVSgEQGSPOOefjPI8heCnlm7sbvsnPpw4hEkJAKG6urw6H4zjMXLDT8SKnKU3TNE15kkCIEUKQIW3mYRgYo9vNXVmlH3/7i7W2rpYxQjkNjCbr1RUhDAIOYkh5nmf18+43RnhwfZ4WTbPqu0uaJ6fjZZgnznkWMu/9NA9v374f5xdjFULgcu6qagHhpaoLjFGaCe+ilJoxzjjxAcQIx3Ec+zlJxOVyztJms619tN6BYWy3q01RVFb5x+fnIkvqpszSIgSwXLz54bt/kNOYJCmAeJpkKrKXlycEMh9smuQooqv15oRwPxyzLIMotQb1Vgle3t29Ox73MYKmWVotjVR5niklAYDTNE3TVJbLm9uF1vp8PkMMIYq//PpnnjDv/aK+jsAhGBHCSZIoZQCAWtvFYnW5XBhLMMbeO2NMkiRJwl4hXvOkq3KlpPv48VNVFat16YKbpmkcXZbkWZaF6ABw795f//Lxn7xBAMEkSZbLpffudHyBBCo9KjVN8/D99987Gw7ty6K52m6vkmTRhWOMPnhIqWjbQcpxtV2dD2eMeJpgpV4xNGMIEQCYFGmWZVVTf/36VSnlrKc0ESyLMRJCnAsIAaVcjD5JkrJYADC/HPdKnquqiQGc5zbLMu9DJvI0yU6HAwCBMKaN74YhBADmGULY90ORN9+8/f54GJR0eVJCTIZhiMARipyL3se7N9/86U8jTbDS8zhOtzffjL1frVbGGJFwpVzd1EoZrSwlWd9JwatvvvmhbVvOMkxgiGAY+xB8P5z+p//vvZzaGD0hpK4XMeAQYojWWj3radHcHI/7apGmCa/rpTPIe6OcWSwWIbjT6dTUy364aAV+/PbvCQfny9Fau1lfYR4//fQLgJ6nCWdZgHCYJwABAoAQMsmRYFGUGQTYafD27ntGcimV0jNlgDBybg/Wyc9fdrMy3nuIPMYohNBdDpzzH7//6/Opt8EMY0uSuFgsREK70ynLEy5EDNh5I0R6PHRX25u6bkAkITjnXATeOuwDenl52e2erdUUQyE4hBAh3PYvZVGVZX25dMfjMSneCpGPY7/dXocACGZa+aKoAABaWe9ivUp+/elzcM//xT/8N4tl/fHjx+Xq5nw8kM363f3DryGAosqtm7SetVar1fbp4RlC/Cp4RghZa29vb6WcjsczwwSDDIIwjFLaQ5IkiaizJMWQJjQPHr3STs7dsW3bpinXi7XVum+PNvjXkR1CaJYSITCNltFks7nSau77IQS/Xl1jDA6nex+iEAyAkKZl8AhEulxurNWvzjTn3DD2zvmsLJRSXTc0pchScffm7ng8ns47llKjFOccIY9gsEb2/cVqPU1zU1be23/37/6XV6CQEEIp++bmfdcOV9vlh/fffflyP83T7e3tcf8IYaybRiSUMTJOfrPZHPYno0GSIsaJ7/3z82PCEggpiPR2842SEYQZw/xq+4HgPYIJwSJgByJdNJvD8WGWc5YmL88P4yAJEZOVGNLN5kpK+fj4vFotyrJ00WjtuaCEEGvt6XQUPJvnmXOutWacCCEYY4fDIXj4w/d/bRRs5wdCmLX2l58/5kUKIQzOCyEW1crITs9Wz7MJKoTgo6GIU8hiCo0xaZpTijnneeJjjITQ/eHZGKUNS5N8uXx3aXchagitkr13inMGIR2HGUEoqFi/uXt5eUE4IIRm2YsEAw9O+wti82q9GKbe+/iq45smWxYLQtA4ta8xIu1l0CputxGAaE1MyjQEkCSZc74oxDD04zgiHM9nACFkjDmvTueD4CkmUekOYtOfT1gHBH2aphQDa/Xh1AnGX9Mmr69vxmEO0SWcIEReS2cAwOUyhhBvbm699+fzuSxLKS0AwIdyHGdrJSbRODnJ8BqEizAWQkipvR9ykT89/kaoX69uEeR5lhYl2R0/Ysg2m83x9DK6losoBCtKOkzj9npDCNnvd+fLhQtKOWOMjfNgrUlTMQwWApxlHADw+PTl85effvz+j4tmDSLXWv3h9x8e7nezujinKWUhBGt1BDZJRFW9ubSHYWiLomHUYUz7voOAMiqESJQy1iPKk2EeplF6F5+enkPU2+3KOv3w+PX55eH6+jrPk67rH58+IQQRxggDp814mb33ZVkAGKScRjPOs16tNsa4cezPFySlYozleXbc7SnhGGNjDMRYqYknQqnZe4cQtwYIzvpOD72yzjgv87yWkozThTJ4uRw4y6tyOc9zXdQPj3Ge5+Uim4bLfn/crDbaTbMcheBcUC7oKxjt0h4i8MMw1NWi76eyWHKeMCoOx5337rvvvtdaPz09GqMQxlKNSupFvX3lEN5c34Voz5ehLq+r4urpcR8sYVSkgpzOT0Vd+DAPw+Rt9vbuw8+//CWEEKLjOB1bSTGy2iGIVouFkk6IFMJzcN55hVC2WCwSUbxSsZWaQ/AABO+U0t3T48fL5ZTmDaOZtto4zjl/eXlyzmICy7owTp3Px+12i5AbhpZQiDHywTJGnp8fCELzZLMsy7P6fD4Sil55pofjLsaY57k14PrqTgjx/PJ4aU+M4a6fGE3Hqb2oNgSYiKD1PAwDxB6+6soJm5Uxaq6bpVbzPM9lWY5Tf7lcyrI0OmoVvv/ur7TGRjnvzTiY9+/fI0hO551zDhHOOCHen8+qTNl6vSGEeBedm6VShNEkycqimmdlrRtnbd3D7ZtrxkgIDiOSZq9qtnG1LDFqOSfXV3dd1/XPfVnUhCAIYZ7nx+Px3F24wIQgEJF1MXifJnkLRyOd1n6zvsGAMpbOUjLGjLXTNAiRQoCztKqr9aD2McZX2dk8B0ygD24YFCEsBJfnCaFouVx++vjxf/tf/C0lDOD0fLowJvJCNE39P/zf/6/Lzboo0kk+p5mQchpVzLIKRQSiJdjTGJXurq62mBrAMSVccDrJMcboXUQYUsJ9tGlSOIsJTvqhfU0U76dxnudZDkWZLBaL4Gma5K+6CoTAalFfLqfd7nOSiPNpsAbW5dU8a0opxNwHpUzfdodhvGRloZwGKNR1cf/wKU2qq+u1Uurl8DAMkzGKMviXn3768Xf/5TRNAYIYYAwYYBBCyLJmas9v777lnDvnYow+WILx8/PDuT+maQqQjFCduuGPb//IeXJ/f79cNtb60+lAKb27u1ZKUZozJowxMRqlTJ7nwaM0TS/nZ85Fd56UkptN8eun/3Ue5lnJfiD1oiaMpqvlth2s852UOk3yp6fnh/vD+7fvrbWfPn16td4OQ/e3f/u31tq//PkjQuX7d3/19PzZOxI8ennZ//D9ehwnhgVCxKqgZmOs4yQp8kbO5v7+MURtrOzGC6FLyoiU0/F0mucZALJZ3wSvx7EL0VJGGSNKSRDRNEmtdYwQRpcmzenYL5aVNvo1aUxrnYhMawkiXi42MRydc/1w+vmXcZzaNKNpyi96MmbWShk9VHmBgBOCWJ/EGACIm816GEZKaZJkABGjgnfIO/Drx5+VkhjF3cuvfd+WRe4cHgeg1QhjEIwLlniH9odnIQhE0VhZ5qk1/nw+frr/LURbVYVSigtcVZW13nufF1ldrM6XHSNs0RTdeHE+vHl7115GFaeU8/N5v11tN5vF4bjXegIkMJIDAKy1ScqtiZRhoklVF0Y7OWvn4np1LcfZmhhjbJpmf7mnlBf5AgISoj2ferhA6/XWKA1CvLm96rouyRNrdVWWwQM9m7e3dzHGw+kyjuM46Ovra0pp13VKz0nCu7ZNk8a5OM9mnM5CCC5w35+8j4kor9dvtZH9sCektm6ezSUEJ0SaZVdydvNkgLFZllntGBNZXrRtv97cOhu8nxfN5tLu+26EEEPolVJJkkKIXnfteV6EEFarFQCg7zvvQYzAuwhAXK+21mlng3M+yZzzzriOEUwYGYaBU7pYLFxAVVWN4xQ8SNNUz3oep+AQZchHZZxmlMfoMeJX27e7l0OaAoQBxnie+6GfMKJ5I46nZxsmzlMIYZpkWms5z4wmRBTjfIhARQAZI5vVtVbeuhECxgixTp7OO2Mnxsjz/eOiWlTlQs5dkiSUACknrSKhSCI4T6PgRAhBCCmLgnJirRqnFmOUiBoCDiGLUR1P+812+enLM0+Cms3huCMEbrdXUg1K4RACo8I75B1+etwJXpZlBQDuuyF4GIJtu7P3fru9RZAej8e6KRhDL89fkoR+ePvOe4thrMvCOUMImpXrukua5kIstNavFpJ5Mj7YJM/a4ey9M1493nc313ecZWlW+sZP00AJGYYBQggJttYiyJIsu7q6mmfVdUOM4Xr7zcvu/nTsKckhoH3fIwwQJEIIAADGMMa4Wm0g8p+//Ha7vVssFuM4KzNBFKE3UfmyLI121umHx0/tpf/hhx/TpHh6enIuIIQeHp4WixVnCcVFOyk5Gy44wE6boShLTNw0n0Ui2vZclU0i6rJYeu+1fNRawxAYh4xHbTvjoLJSz/P//G//X3d3d92L3qzqRNQAIOfFevn2ZffknHuVeF9fX2vV//bpnqVmvV4qPQ7DcP/wUZs5SWk/nLwZkwT6OFYNK+s0EeXp2F7aF+fGV7e81X6ec0rxKzNN6UHpUQgWIwTAUxyDU6IqEBJCCOdc0yzX6+XpfDid9oQiKWXw6He/+12W1v/pP/2nCFxZFff3n+/efijK9PERWWM4SxBCEfh+OOV5TiiUswbYhxCKrIQoeqdEnlOGMWIgommaKeVN3Tw+vGT5oq5rCMPD169dN3CeESwOh/NysUYI4QQaYzD+1yI+BoghFEK8Ql8opXUtvI97czB2bNvjOPZcsCxPGWPj2Cul9nvLaPqH3/9ACD2dzkmSOeeSNOOMHy8HaWRZCQCilDJJihSScZiVMmmaBxM//fb1H/7uJssKjJi1PSEkAuq8CSGURQkhXC62+4+ffdCE4GHotEQRWMaoc54xos3sg267w3JV5llR14v23LIEpem/Xvwvu/s8T50z19fX47TuugtCrNleMZq+vLyE6BCKy+X6ch58CBGgKqsxxlJOhDDgoLVWDoNSirCYZYWcQwyYs2Qc5IRURFAIEaOfRrlcLq2Oi8XKe89Z4oPVWgPoX3Zf0zrs9/vv3//tNCnOkggMQAQGgrB/2X2FKERsjqdDmoqvD88QBqvnCVqlVEQRYH8Zjstl9d37H65W7zFigkIIWAxoGluEkDPgavOWkuSVDjyOPYAxhHh/fx/JiHDp/OC8A9A/PT0mSaqUcpYtFgsXulmbAEHCWXAmWOeiE0IAoNq2S9O074er7W1RFA8PT4zUfWeapk5TBADaH553+ydyOHx1TldFbR1pz93dd++s9b/+8tv9/ddXybrWGmOcJNnHjx9DCJyVtzd3V6uN0h2i68ugnYsY0QjROOvg5KLZUia6vkcUv337/uHLQz/1jMMAHX+9oY2GEH7z/gOEJAbIOdvtn4wxRcaPh0cQzDj8/1n6ryZZmiw9F3PtHjoiVWXVri0/0XowA4DA4bkhjcb/zBvSDKAdnoGe6e5p9YmtSqTO0OHhmhc1+Q8qs8x9+VrrfZ4pSRLgAAgkjlI1e5qly216OD4GYBACICBKmRDMulz70DSdc45RTymsm90kW2XxYvlLwalSylolpVuURVHmjHJlTjZYGBwmEBPgvX/16u3Tbne9Xglh3gOEwbIq2vYyqxEiK9UAeggQVEYCAE+XM0AsyZJmOjZtV1VlFicheEIx4+F5/+nN2zWmL4tO0FqLMWYUGtsZU6RpNspuVq4qNxh1GPEsg7dvN/W5CwGdTjutNReIULY/7W+W6TQN2imMKIlwmqbOOYxRHMcviMAsLTcLXtd1XddSypvlKyFYkS82N6sffvjL5y8foUN90xdZur5ZLZer66UZu54xlic5RnQ/n7puQAhpqW9ubvt+jKKsbVs5d9bposiWy8RosN/vIURFvlDKEBxhPI7D4PW4uF9RBpwfhqmd1ACADcA5R5OsSJK73fM5zeE4jlp3WZZfzmcIaFksjsfzLO2shiSNEUJt22+3t5v19nQ6QYAv55ox5rxBCBKCAXCMESGSvhupoFmWOOcIZiB45/Tz7kuWJ1FM4zQKzimllJRJnGZZrtRMCHUWTv1wc3NjnWQcJkn0gvkqimK5zA6nxlq73d6+HPTeG0IEIzkAwIeZCypI4h3iTMyzSZKcUb5YbJ6fTv1w8MFgL6ZpHseubYeuv0yy3d6kXW+UkVmWlWU5jdo7EEXJ54dPL9QmzoXWprsOSRKVZe6c6/veeQOA79uWclIU1bffvgSJzTg2h+Pjzc3N9XoepxbTKYo2jJM0jYQQ+/1JCBFFMUKQ0cS7kQjx61/+7ny5EMLiajEMw6l+tM5b6wRfrVY3EFCCwDyPaRoPYxvHTCn7gg2d52mxKEMwwzAInqZJBgFTQHGGQvBybrQ2LybYJIkG67quQWhCiNR17b1VEhhr7u9fT2o2xnCRIQReqg2tLEKY0Ohmc4+DMEoInqAiadv69f2rOMrO52acmtXNgvVsVoMQImAnBJ2G3gcbrDtedkVRZmnhPej7Pk1jRmPvw2Kx0FqfLzvn/M3mVfDEWrfbHS+XEwAkjuN2ONf1FULorBU8Pp8P3oMQAgBgHEc1mzjmnKJJdpNs44SO8+Rc4CL61S9++/R4/ssPvy/y6IefP/7bv/v3+/0hikQ3dgAhZYz37q9//fNyWV3bszLzprp1fh7GNoTggynKxAfVtvVyEWNNlTaM8bFrx1YSLsoyHvr+d7/77c8/f8IYNnU99NNms23bYRzqF6WOlIph0XcDwlDr+e27ZfDw+Xn/+Pj4/Pyc5ynnkXOGEIIxPhx2TfPjOMiiTLTWlHLGxPF4Pp+v280Npbxta8bRzXYdPFFKldUyiqIff/wZOOCtFzx3lmml3rz+cLmerLXbm/txUJ4gbudIUIRBliVt295stnGcYksDBN3QEowBCJSSJIkpZdM0aaVZJJRWwzBcr9ciLxeL1e3ten96bNpLP/TWRUVRWGtfysS2GZMk6fvBaGeNT9OMUuRsIBk813XbNmnCsywxVmntGE2yrJhnzbDwAo+DzrJCKQWCs04DCJMkIYSMo/zXI5eTsiwfnxofdHW3WVYVxlgpxTiepoHHrOsvh8OznLtFtbbG53nZDpcXHUkUx+0PdVmW+9N5Guftdns+Hykl3rvTeXe5HvMiQRheL30IPoRwvVzvfvfeWCXnMY45gjCK+TA2EEJC2DTNglXB42Fok7iw1kIUtJN5ERPCmqYJLk7TvO/7JM6YJxCEJInq5oyEMMZ8990vIh4Pw8AYNtZgTKy1SZL8+NNf0zRGlBCCjAU+2ADc7e2b5+fn3eG5LMv1uur7/ma9/v6733EK6rrFIKIYX66nMsum2W0WG++9nrWxCgD/0kRcLlc/f3p6tX2VxdmnT5+KotBaM8ajKKIk3m7vsjF7ev5ijP7Fdx/qugbAe4uMMWmahhC6rvvtb/7uz3/+6/v3UR5XES3fvP5m93zyzL55Iz59+dPj08/Eg27WU1YsV6v7y+Wy352rRfH+w+vDvoYQvnr16uU+S9O0aRqMMYTOg/7x9C/KjAAERpPbbUopBSG40Uopo1fCWe+8tUaliN2/3QLo2+6stVLGSumMCZSItpnW6xs1qUlPwTlOMIQBYzSrmjJOGS7yBRhBmhacMsGz5XJhnYTItG0LoL+5WStlTqfTsT4B4FerVfBem3m1WnZ9uNYnNSlBY4YZJ1RrDTExDsx6AgjGiWjbep7nze1N107P+2dCmTEmTWPGmLXaOxACLIqqri8I0Vmaq20gRBijeZ6CV/M8373aNk0DPcjzwhgjhCjLvK5rhC10jmDmPQweJGkFoB/H8dqcRMSrajnP0ySNsQgTQIWIeNkiCQBQekzTVKm5bduqqiCyL3wtxgQlghIeRUKbSUkQx/lysSVYwBAoEdYabSaKS06F1loOMubx3//u7yNB6voq1YwJP5+uURQB6DllYz85C4xRdS2zLOOCZln2UtrP8+xccIZ4G0VRGvxEiMcYzfO8WlVa2TS6LbIwjZeHp7865+I49mEOIaRJCQmVk3l6PC8XBBMIPV1VG6t1fb6M07hcrC/nIwQAALTdbmfVNk1dlhWE4G8//AVCuFnfKWW893EcW2v6vp3kEEURozFj4f7VGy7ojz/+ZVZTFEUY8bpuCeGMChCQ1rMQAng/ToMbgdZ6s9lYA1DAWiuMg9aSEhGJVEo1DB1CCHh1rfdZWgEHrFLGSs7S9XI5DtPxfBaUdKO8vb1fr24fH5+Umi3Q/xpWmrxTgEbpNMnPww+zmhCCEIZrfagWhRBMSpWm4O7utVPh6fEgGILQe4duNxuE8OPjIwBBTaobhyjiELlx6oRgatazAotq9e7uXk7hpx8+b28Xq0V+2NcEkiTKCRU+QGPMPM+EIIyx9z6EF6ovsFY/Pn9u6iGEUGTZNE2TrRljk5SHo7PWEoSsM5TCUWpKKcYYIYQQ4Yxaa0+nU7FYIlSEAKdRUZJ8ePetlPLx8ZGLYpqmLCnHqW3bnkCklLq5WXVd13VdVeQIIWU0AEBOCgAAgeYcn867cZBJUlBG27Z79+6N0xAEWBaV0nNdn4ax0Vr3fefQ2H+urXNZniVpqpUcxivAXmDGOAbEQYBfMk3ee8bocrGWUj49P/TDFWEr5wlAq5Srm/Pt9n69XjuvjR1BIHm2nKXPk7iqlsa4KOKPT5/qttlutxjjSKA041wgpTuMSRwVfTcLtv705ckHa+0cQLqobv72858oopdLPUjJGOOcs4jNZh7GZhx7H8w0DYtFmWWJUsp7G0X8Wnen04myG+BtHOdRlHTtNE3yJishhO1luBxrpx0AaHZaiIgRdj1fIaRZHmOMjYYQkCQpQjBaq8vlKKWy1t3c3FhrEUIIAa0NhLDvWwAG78D2dkUphTBUJTyfz1rPWVYwJl6ETdZKY+2qePPjD//kLNxs18YYTpL3335nlevaycM54RyW8OvD58vx9P79t/W1H+V1v28wgRxHAGDGRBxluvd1fQkh8CLT2u12T8655XIJPeBcAAjTNFVKeu8Zp3IeCMJSyjwvb7dZ03Ry0nEcMxoFDzabzDn39Ljz3ud5nqSR1nKSQ7s7QQgRtg/Pz4uyypPC2tBfm9tfv81SMHZD28g0TjjnbTNMU4dI8AGEwAhhBLthGAgFzsv3779t29ZYmcTl9uYNCEQraa12FlNB2rYty3IYxvf3S2fhclU5oCDAcczGqU2SbBz7u9t7re2sZsYoFxRAb53igsyqMxYsy++XqzwE++c//y1N8ratOefOgSSJ5nme5LC93TzvvgzD8Lv/7T96H2AAnDJCWJbz3//hv50Oj9vtXZ6KscMcc1rgvhsBgJuymqbZGjnPoaqqYejSeOmcTtJFGEwIUI7TZnW72Wz6oVOzpowM7RDFyau7158/f52kvLm5kXKM0xQAtHu++F8DCy3FCATgnDmfnm9fbZfV8gX8FYADALyUa0a777/79fs333Z9s9s/YpSuyrVzxngnpaRMfHn46Kx2XmMM+74NIcRxSgyK43i/f6aUFmkhx3FRlMfdkRCGkbicayFEtSo+fv7Ti/WMBDis1kU/tM652+1911/O52NeJJvNyhgDYXgpNUIIb9++JYQ+PT0eTj9jTAVPAPRRlIxja0wbxbSqCmvgPE9N0wDsEQR1d5HjZN3sgWWCK+0W1Q1nRX0dbOjUZJI4X6/Xu/2zmockiudoUOZ6c7MwGq5Wq9lINTsE0Ol4GboLRLZpj5QSxqKHh4csKyh9qYL1rCTFNM/KV/e3P/443255zFOEoVTTi/3VWu8dMMYTgq7NRY5jWZbGKM7583739s039/fb8/kax3Hf1oYQSiKC6f2rb7p25DzyDuR5LueeczZNUiuXJylF9PlpHwkGQvDee+8Q9F07C55hCEDAN6syy7L9fpdEibFT13Xr9RrT4A3J8whiEIJTM8zSpbUzAt4Y3bZtnueIknnqQnCUUgjRi77LeyvlKFjV932ergnhQ9s5FzAB3tvNZqP1DAHY7/dlmS2qbJx6xpjyWmsLwowxydKkruv1apFE6al5ttYiiJwz89QtFovD4WSMWi429XVKk1VRFEp91VqP44wxyfO4rS3BiZqv1kll6uDJMCCeIB6lLrAquXl9tzwej+frmRDUXMeiSO/v7//yl3+JOc/yGCPW9yPG+HQ6Mh4YJ95bzqIkiY2xq9XGez8M3c3NTdPUsxpUIzebFaU8eHm9tuPYWwsEjzEiIYT3735pren68zRPcuqEoHESeW+t8kVRSKluN7fHw3kYdde3SUq9ISJmiwpoI63VCId5ahnGagZy7imDUk5t2xJMGWP90Chlx0Ex2mGMnTOT7A6nr+M0hRCytHp19y6EIOcGDtIHK3hCKXk5aj1A1jhCBIuwMeHanOM4naZpHKcX/PlyuTDGQIL7oV6tKh+U1nMIMIpTpcz+8GANfvvuFYDqfD4wlm7T+2E6SCkpRT44pRRjvK5rxthms0EIHA4njPjpdHix9lBaWqsv170QosgqBP3Xh59ebV8BaLWWzrkAnLWgLBcIkbbpRCSKItPOvjBsNuv7aTRdOzVNx1mWFDnBAwA+zxZazwAEQpiajRBJVRUYoru7u7qulTIIka7r4hgEgEKwUcyKMnp19/aPfxz6vi+yZLc7aNtrLSGed/uLMU5OplgmzqNIpB8/fi7LdL1ZWG0IAUKks+rLMh8H1ba99wFBEieCMco5/5d/+X1eci7QJPXhsBesWizTYazlZNabpbVUq1AUS6OdnPTH5ktZZdM0jVPLBUozKucRYdN2p1nqcRxDgN9+/5v9cwsR7+RlsczhDd4sXg9j48HAGJ5l0FYjghISKzVDCE/Xc0ChWlUh+GmarPVavVQDKI7SV69eORcwjkVUzJPyjuZJkifL591XjOKnx3NZ5oyxcex5HOV5Hsfx50+PlMQIgURgSqK72/Xz7nGapq6/xnEqRBJHGQBIKVXXFwABxpgyjxFlTKxWi7ZtrQ3GOIxxmqZ5kSmp5DTkRTorJ+d5lv7f/t2/n+103B/ev32vFWA4irNons5cZMN0McZGUTSOIyGkKLL99RlAc3NzRxEbB/cCoXauBgDIeYpixiPB1KSUgxBiCp0NjPLVZtX3rfdeCNY0jZ7V9u7eGJulVYB8HMen3SnP8++++9Xh+atzLoqi4/GY53lVVZ8/XyGE1umnpyfBaRRxQhBjNOaJN2oa58PznhBW5EsESNNcISBCMBdMCK6ua0p4luVt2yg9O2c5TJfLDUJhHFRYY4jJarWdZBM8Dd4Pw/Ddd98fj+f1eosAb5vBWm+tDlNwQe93xyxPAEDeOz3yKn1lrPKKxXRB4uR82S+3C6OhNQBhsN1u4zhumoZSaq13zgAAf/755+VNjjHkLNpsNsBElEbWAGutNfrp+bPzSpvJmun92/9Q1/Xdqy0EeOiG5to+PP94d7fdXb7+9te/PB6PgpUvSyQhQM7iMs92+weEQ76tmODTNDV1ezg+Q/BMCOm6LqCwWObDMCBAv/nwfQhw6FuEAPRYCA6gfXr8VFUGhohxAgAoy9Jaq5RJkiyEkMZ3jFRVsZVz9+XxZ0wI8laOHWEEIQBRmKZOCHE+n9+8eXc+X7WZrbUvDizvgRDibK5ZlhljCPE/f/6fZZU7sqjbJ87pu3ffkKkdtdScc+/GumsjkSTJqm6boOc4WX//4d8/Pn252EFEKBI5JWmcDEqNsxwgcnIY06R8//rdNM6MJuM0ZDELwfkwOzcrPVGKmYg5zLt2JCjTs4EgKoryfL6IuIjjOI7Stpdy0iJKtIFZupovpr5OL6mTVze0ri9dd41inmVF3Y7GGBYJgEEra5Ezi+blcokQOh7Py+V9HCe7XTuM1nsTizmN4zSp8qR0xnZ1E8cppcxMliIxQ6mUFjwb5LRa5m37tN1uw3lO0gXC5fF4Rgh/9/a3bduq2b99+/r5+WmSrff+fO6892maXfcHxtjNurTWWiMJTbQKcbxC2BJMpJTD0EUxnRWYVXdTbZq2FoKtljdN0w1DE4DXUldV1U9tCNB7ZFzgnFfLjTYzQggEzjhXSnrsPJTzYACA2jg114LH3XCKo7Sbmra7AGg5Z3JWSRp1Y00InOQAMFLKWh9xKhZleT5dlTIxJ1YJOdD7zftpQqOt+6GOE9ZPg3LWAzArN2t1c1c9Hf7ay/J6rjmLqmrR9+P+sZ7VKAQhAjWtpLhKi1hEPIniaR5P14vURBiKCLDjCECAnFz6I442ASGpddf1UsokSZQyAEBG4/PlOASZxC7PS6Xay3VHKDhdHrVti6JgjOXZAgI+a6ntjDWu6+tiWVZV8eXLp9dvXnXtzjkLoY8ZxiHd3twpZa3xBE3zPEHo6mZPmFNaWjchVPFIJEk6z8QapNUMIeQCGdd4TzY3q2mcp0nFWWyMMc4FzCzUs1bGIDW7KOZRTC7nWmlIieCU6mmM49ShJPjBAweYx1AopUc5GzsTZuQw5mIFAl+U7zEOlM91d1XKJCJNo6UoExhOGdsUecphqs1o7GSdpNDvDg9CFKvo9di7KKnubu/PlyPCWcpRANZ5SBkehi4Ey1isZrMstuuSI+yNMfMssSAQue3tqp32VVW9TEWt04g5Z6xSarNeB+ia9jyrYb26gTBzzk3TFDyJo0LP9nJ61LY/Ha83629//e1/OHWH9qKimGBqlstl09RxlrbdgBGIeExJMo6wLO+NnbvxMyb2Zrts6g6jWIiY4OhyuXzzzfvHx8ejlNaNHgDn7TjoRfVKKbVcwEFORskswevlihNaxqvn5tl7P0wNoSjjXAjUzLWUcxRFIFA1n5UBSsu2UymghJCbzTZhmyzlHz/9GYb++DzfrL753//+Pxg3/+Vv/wySxrrh3NTv37/tJcMYB2AYI1030ShBLNrc5RDQuhkCtMPQZnFpJHh18+5an7UaOc1DcOWKYhRrraWcMcaEwtVqdTg4waJUFASQze3ir3/9k7GqKLNE5JzE41DHaeJNCD4sFyvOudbh/bvf7Z6fjVFlnudldrlQ40LXmGGY1otNmubnU+McWtzdIASVUkVRUBpNgyqL4ng8LxYLzrlzcHvzhmLfjjXGmFFxvXZG+zSLy7KcpNrtn1725GYzCMvevPn+n//5DzfZL7//8OZPP/zjZpEgCKggzbX2vk7SNIqitquH0fMolUp9evwZQiznqxznLMsYSiBg5/MZ4OCDtIolAmHk+/GS5jkeqJz8hw/fCpI1/eV4PJ6bA+Oo/nxGnnIWQ0/GdoyotXouMg48JwxqbeMon6QEUOfLfJj6L1++EISC88FSI9Hd5t1mcaPmues6BMbZTE1XU8EAwFLKt2++JYQ56wEAkSgDmD99/qvS8pe/+E1ZlcPoIfQUFN+//91/+x//mRCSJZGazDwHRmNtfADmeDkqY+KoIrQggIxTH4AOwBV5LiX8h7/7vwQINpuNdpYALqUimGECOYPX6znPS4TI7//6j+fTw7s3bzWLY16iPAnAE2G1RwH2Dl8wxVlWpFES8dWprbOYTKOBECGqlarfvLv58unzevm+LGLOYm9IGpdyGmZd7/Yfb18thvGmu3gzoyaZX2fZMJ1DCJzza9MxwQOwAGLvcFXc/eoX0etXQ92cMIbsXfK0+6Grp7JYIZeuFq+1rW2gZracezldGMuGvq6vh/VmUddhs36lZwkQdF652YQQRte/xL+zIv+W/4px8vj4+PjYwL6FyDCB4hQKgTnHchowcAh6CANjYlFt2rbdPR8ow4T69d3t2E94jwWL3Ow3y5so4oMcCSIQYwgAMDo4izjLq2LN6XJ//AlAc74+zapbrUrt5s9fv6TxsspXxiYNQs7ZJKtEFPfdiBChDHAPEfbGqmGsrVMA+BfG88sfwHn0zTffhAB+/PFH7z0MM6V4AuB6vWo5JelaCHa5nOIsRQgzLgY5T2qGhDoQRBwnWWq9U0pVVUUpvX66fv78OcuSRXXDOSc4btthvzu9f/+eEu4D1Nqe52a73kg9BYiu12vbj69fv0uSBGNg3RxFiXMhBKC1AQA8Px+6bsjziRASAnjBpDZNC4L7+vWLdVopFUWR8yaJsySJp9YhEkHsCWUOOmNeQt6Wsfh0OkQiqxbp8+4hiiKM4W73oPTgPfz6QLM0n5WcpqGqqtPpwDjKs1IpBaFQSvKITYMGDhNC5DSUZemhU9p0Xce5UMokcZHlyfl0JhsSgJumgVCY58n+sHvNXhljMCaccyllHCeWWGfm8/k8zzqK4iSLx1EaO/346U/GSus1F9R41zQ1YZQQkmb0cDiEEBDAzbV2zgkhhBCEsPZar1eba1sDA96///Z4PECIgyfXS085wzC9XNrrtUvTNE7o8bgHgbx7966uz9frKYqivofTNFtrIGCUQe+B994Yy6gBAKZJ3nXdOA6z1FkGvPda2xBgXTfAi6JIEfZxCp2X16tbFBsGCxA0JX4Yu9WqIlhLKVerNYT4+fkRIxaCf3o8az1Tiiep4siNoHNOE4oCcM65NE2HsW/bdlncY8TSlDgHDocdhBBAnyQRwhsEiVYjYwR4gBlZVJmz4Xz9GnOR5rGe9Tj1hNA8zer6YmnTdlOapoLzy/G0XCyMVd6Y19/+VkT0x49/Y0xkWdE3nZx7QgjEE0ZumlUAuu2umIRx7Isij5MieHw+n4NjIk6v9fF43L+gQWY1V4vscHjGiC8WhbXeGDfO0niDIPAQDFK2Tb/Z3l2vzYuX5wUYGseibk6cUMZQ27fGKKUn74Dg8mZzvzschnF8dVdNoyKENO1xki0XYhjPh+tn45BzwGhwvfYQG4ITowFGVE46y9M0zawJTdME5AVPOefBw8Vi0XXDPM+c83m2fd9nWYYh9IErPcxK3txsinxVLKrn3VdldQhCTqooilgI53zTNHEiAAZRlChllFKUMmMshLDrmvNxhwi/ubk5np+1gotyMU2TmxutyHa7HSfRNhMm/toedrunxaJslGUEd83548+Pq9XmWp+bpiGEIMhAQGma1Nc2z5Ou6wSPEEIiQlVV7Z6e40SAQKUcKcOMsa4doiiK49gYQynzDrx980EIcdydszI5n8+zNlmWKaXKYnH8+jXPYzXbPM8JMfM8W2sRYQ/PT3LsOaejHJSZQ4BjNy+qDV9kQ39MkkQIsdvtrvURYzRNAwACApFlhdTmdLo0TfPq1avf/fbfaG2MMd3zTmt9d3u/Wb+CgColx6H3wRZZPnZjP/RFUeZpfjzsCIKX/p/+8vFjgAYADABC2Nbdp6Y9Y5wlcYYxrRZZP9SLxco6v1pvhgmO/fPjl8dffP/bzfru6elJmmkYhqJYfvjmwx/++N8xJd7BslwmcTHPc2DwWu/b8YBJ8N7Oo1wutrGIr9cv4zhjbM7XU5JEi2V52B+sHpfVWk5jAHCx2MzSAg+rRa7mQYXwq+/+7ptvvkMAT9MkJ8MIYFT0/dk7kGer42n/+v5D8CDLqlnqOEn6cbxcD5xTa800TWWxOF+OAPg4Ecvl2juAIOEcGmOMMd6jWY9RxNNMgOCb5sIwLctiHFHw1lkSPMmz5TRPXTtVq2XfnRCmScrbttUaRFEGAvUONc0VIfTp06dvPvxaKYUQsc4BDxGGD8+PnPMQAqWMsLjv+5vNurnuORfOmWGUq9VWTubu9nUsqhCcNhJCCKGIIo4In+f5+fmZiwQT++rDzfVyenjqttv1yz1FSeQ8gi/uQQeUUoSgxTJfrRZyHv/5j/uqXDftIYmdlWNRFISwYZrTNJVyet4/LlcVhPoF3Pfp0+fLufnFL3/LSYTQS9QoAA/yPNd6nqWO4uRyOd3dbReL4n/+/r9aq70Hfdfc3aVd1yZRvL1b//xpZJzOUocQijJzzgQEAgJ//vNff/3LX3377ffjOBrtjHXz3GKGCWZkmudVWpbl0j6cBCnKdAtMlyQ7CGA/XYwfopgwIE7HzhgTsdh7XxarcWq11pzz2dtRSmmv1lrOOcbYAaudBsBLjZClcZxSym9ubgRPf/zxp5fG42q5fHh4SJJ0u92c9gcQIMY0BAyCDSFobev6kXN+f3+v9fzyG8RxnOd5CEFrHYt41nMIoe9kDyTnnFJaVaIoCiHitht9gJRE/STbtrbO8CgRIiaUUkqN1UpbTBwIGmFuHdRaCRFn+XKcFCFGaa21fnj66r2HIDBGEAaYwWt7rqqlnOT1sREkoxHu2/p6vRirBI/X63VTN7N9UrNZLMJ6dZMWsTHKexCAM0GFgD8/fEzTfLmslmnVdUM/9G+rVy/ekDiOsyxzzlnrvQeUUmNMCAEBEGxwzocQMKJJkjobiqKY53kce0rp23f3XddoM0g5JnEWZ7dd13TjYK01RuGAojhWqvfeo61PCz4OEgF/vDyu12tKWTd20zQRCylDw9A5JQiigMIkySLGpVRVkctpHglZLtdUsD/9+Y+LRfn9d7/q27ZtW+uCHT0jBUYKM+P92HUhz8vL5dIP7bW+BGC0gcKzF5k7BCh4MM9K8DSJMWMMIRRFPE6EtWa9Xqdp7Cw0OpRlZY33jobgYbB5ypQywKPF8h4j4ayv1ssQwuVyTZLYOffp08cQwDBMd3d3WVrk2dI6bcxsrMI4EAom2YUpvGxdLRarEKDgCQH5NJoAjLW2H+so4nIetJWcJ4x4wNxmeaMVMNriQGbTcy4IIcaqYRoh9FEUVcWia8f68lQt1+v1chh677SZ1Xq1DBb3fb8/DG3bbm6WWs9aK+vNC+KTMeYD4Dy+3RZRzI/7A0KIJdIa3/eSUCDnru3qrhviWKRp4YPRylrrooiV5WIcZAiwG6/zPOd5Po4jRGi1Wbf9gCnxE2CcOuc4p/OsEQ5y7oQQ1npKMcLR5VxfLzUXJUKUUqGdRhSeTrssF2WSTdNk3Pj56c9Z/Koo8u329uNHr/TABZ7niRAWfMjzEmPaj+3pelqtlrfb15Mcrtfjcrm21gcPq3LpvPn06WeMi3bsRQwBgi4EgNH+dDxdLwh7Sunt9n4Y5uDh+dRJ2b8YmIH1wKVykFmWrVarv/71z11Tx7HIsuL21f0862645nmmtY044pzsd89FJQj1AJr9+fNq8SqAOc2Wb979u//Pf/p/i6i8u12fz/skLqoyr+vaY2Q0UPNIafRSz1lrKSNtc6IkQOSds1VeqEkGGzCg3g/GKOcsAMDZcL029/dvkrhiYgoB7g8XBLExLgB0vhwRRdOkEUJyMhDCPCtno4dheMkPQ4JDgG3bI8iSJMOYn0+1tvPz8/NyWTGG+6FJkmS5XHrvIYQQ0+1yHYnkdD6cz+c8L/tudF6FYKydJ9klSToOfdvVQrCiTDnn86wFT+Mos9YqpX7z2192/fXp6adlWQXIMCYxiwiDeRlP0yiVipJFUayjiD89PUVRomeHAq/KtaA8juPT+dg0DY0QRGEYL4cDMsZl6ZISkSaLYRgul1OxSAZ5jWOe5fR0OlVl+d37D3/9y0/n65fvv/vNcn2DMWaMXE6nqixnqU+H53mU1qN395vtshj7Po24nt3337yCEH/98sgYp5RSErXNOUmSJGVNPYxT/7LIYpz3DgiR9H3vguGChKD/9sOf/t2//d8JYZREPhhr8PbmNQTYWYgAYoz44L11l+vROrXf77758Ou8iM1srvVxlqGqiqJMf/zxCWNovDZGXfudUb13JElyray1/u2b9+fzmdGEc+atnie7WCy8DXmenU6nJIoQ9s3lnMXx5XiBIP7uw4eh7VKRCiGul7YsS9P6PFs+Pn26f7WNROS84py/4PbjhPhgOedZKpS3o2r2l5+t9YfPzd9+du/efnd3SxlKGBOEgnEcgw8hwBcJMEJEze6Xv/zN/vAZQHs5N7/45u8JYd77NIptCHHCjseDUX0SR8vlYhiv6/WqH4b/8T/+x2q1+fab7yHEIIRFuYmT6C9/+dPNdmGNWa/XTXvK8uT//n/7f/7X//7/BVDRciGE6Or9+QKMnaZxDh6+ffu267rL9cRjvloth2EIwf3pT39ar9d91xNCFovy6empSiqS5nme41nq4/H48rI/nU5WuRAiOWvCHKG465sky0TCbVBd11BGqBCzGrRW1lsPjLYjsNJaZ62O4/jlFnHeIESyJOU8MrNrrjXGQ1vXi8XSWns+n51z8zwbY7SzaVFyziGuZ9P33SBECgKalQqPj23fJUmi1Nh1XZJkxAMAACEkgsIYK6ponuUwdCGEKEp++PEvELk8T1erVVFU+/0+ipKmnbIiz7LiZS3RWP0iWiRECB5jjNvO59kiSaLDcWeMieMYITQrWRaVs6of2ijiAIQoEsPQURLFcTzIM57muq2bvgOBRPFis3pn1MGCh2SRGaOVlkWZtK19IfEVReEdpsQQQqQcb25uOI+MccfDmXNOCGnbfrOJxnGoyjWldBi6qlzLSSPsQSBVvgSI0JRZ4yEFwzABACjl79+/bbvaWp8WyZenT5REtxiNo4yiqO8b43QVb+7v7iEkXdecrhcI4aj6lIYoJgCHWeuXnNvu8BAAtE5ub96WZQ4AUpOSUu52u+WystYGYP/pD//LB/vq9d1u93Q8xsvlsm165xWh8f3dh9PlcZR7hJ3WjpEyTcrz6QpgWC7XCCHOImNcHCda+cViofXcdR1GNE0KhP5VJ/jSBiOYvYxdOIswsqtqczjsvIMQUuCts/rh68/L5RpA8+XLz2kW53ku5RQQDAhdr9ciTQHwp9NpsVhBGP/08w+bm0oIdjmdu64ry3KzutFa69mhwLTWeVE13WVWM6URE+lqtTidd/0IMOBCcEEZgswpLyffti2AyiMErOv7E6U4SRIp1X6/k9PU9z0hzGk7jiPnHACSxIXW5nrdAQySVHhv4zgOFrRNv1rcCE5fggbj2K83a4RQWfm+76NYTNNk3EBYwCQkVITgx6kvyowx9vDwJYq5c0HNBiFijJFz0/c9F9BabayrFuXD109lWWKMKeGzGrxHs5pCMNPYA2goScsqV2pumtoj8/HTX4qitG42Juu7kVLCGBnGXggGAZnn8evjX17dvQdggxDyPmAMuSAIAWfx7vi0WKwm2To/Z3mitCSYIYSapsGYpEm+2+05Z8vl+gVl2Lad83Mcx4Qgxtg0TYwRTkSRVqlAD193m5u3AOr94cvp/Pz+7SvOo+CxNaFrByFiLohSktFIa/tiDzifmojHv/z+9eefngC0dX3Jq5jHdJQ9j0BF0uPx2QJ3d7fVZr5eau/RenHbDy2jieCxtb6uaxYLGGAap01Te+u0mff7/du37+dRci5ev3632+3kZCnD1umu67wPlEQYcTXbk77GccIFFzwGRDhnrLXX67XI8yJZtG3bdT3nfDbae2+tzbIkK/L6etbWIsKcdt98+M4Z2FyGbHFbFJnSo9aGEm60wxhHIkUUG20xxs6bENw8T0+7r0mSQTwN0zGEIBV5fB4I5iJiSjdjB8uyfHv/dhgGpSQETlB2PhzvX71Xo3V+Pp4f4yh/dfcPhd88PDwA/CSlgXju+1FKeb0233+/qarlOEZGeiF4fb3u9uco4oREEII4o+frKYmLaTQgAAjmaZ6VmU/X4QVVTAi6vXkFHIIBvX39VpsBAl6maz3Bosi8gTyKIg7G9rp+dz+NLhVVma+0tF3XKCX765BlmTcuySNjjGDMxqmHIRFJKEjX6PtXb5xzxsmz1lmSI4TrpsmyBBN3OY9d11CcZGl5OH2dpiFJsjTJT6cTwTjLIowoROF8Psc87sdxu91qqQEAjLEkxdPUPu0ux/Mn65S2EhMotYSA53FBKPry5QEAkGZs6Oe2GaOcTr2JoxRBjAh7KYOCh4NsT+fjepNa6yJOX79+fTkPz7tHwYGxWhv55csnESNKxJfPD7/9zco644PGBAVllLYPj1+cc03T9FJX5erx6efXb14tOO+6wfr+n//wXxmKlsvF6zevCIEIUWchxgzCQIm4u33dD9cfu7mqbtTopnGGAPddX1XV1DTKjRA5TADEwBjDeMZZ6r0SPK6q4qeffzgezu+++S6Oimlyr17dtt01ABN7aq1Ts+ExnUaDsFmucozxclkBGIydjJ0iSAIwch4BQnGUj4O2BkYR54zVzck7QKiY1XT3ajubmRAcB+edU/M8WGWKIiNU1NdztXp1UPtp1AHI8+Vivec88U613Xlzs+qHYRw7TME0dfM8U8YoSeZ51toa40JAEBKCESVcSqm1jpOk79uqWt692l6vVwghCOjbb79r23a32zEmIIRaWc4iZREACGMcR2nbti8R/2EYKAmDnAAiWNuiKLJUGCuv1wuEECEwyS5Joizn/XAKzkvZJ1llL9YYlSRJ056s9VqZ2VjbzZSRNM0RxBhThFCciFnRaZogDNZajBHnHBPknEMY+oCiOH7JXnsQZq24SMtiiZowDANh9N27d3Iy3gFlDeUcaGqcN9YZa50HPkBM2DjNq9V9WSyeng4AgGHonp6eFovVPM8R43GcEkLq+sl7/0IFbtvWuXB392q3241jX5SxDdw5L3gqpWqbUQhhjKmq6nKpjVEQIq1n5ywA8nQ6QIyAdwCFiHNMmNK+KpfeATUb63SAoemuBENjDGexcwECTAgjJFRVZZ06HHe/+sVvDvPhRZV3OBwYI8pOaU6aduz6i3Vqf3pu2osxlkfB2gkTLwQ7XeYsiz+8f6tnOowXCMgL4iLLMqMdBDY4miSEMeFcEOIlSTVgjEOA8zwLIV5SORhTrU0/tNM0ZUlEKTUGCZIBNvX6sj9+zspAGFpEUQiAUDh3Wsp5Ua2CxwGoWfX9IKOYZlmW50kU8a5rmnZ89/495xwCTFkkpeoHLUR8t32d5fnx/ACADyhACCGESZJBz0HwfT8F121XH+7usqfdzy6MWZYdL/v2el0sM+ONDWqeJKdhtbyllL569dpb+Pj0nCRZ0/QAeG0bghhEUGkLAACIEEKdBVnO5nme9bQ7PExq308dwsA5N7uCEBQC8D5ACANwITjv/eVyfvl+MKLehZcq1jk3jFdtVNuhRbWq6/Z8eU4zLucuidJrfbZWDwN8EYdSjCCE06gI6Yex9kHHSSbnrukGyvDXL+13330npZRyIkR4D0BwlGLC5mE6ffriu24IQE0SERqcc2oGSik5D2VZpl58/frRGKe1LopssVgZHYSIAIBaa+/d5VLfvdpoi56eLy/wuoindzcfHp++joN5fDgtqrXRoCpXacyfnh6TuKQ0aupusVga4y6XK8KQs2gcRxKL3fPJWp2XWQggz8rz+ey8gsRxQhBCGOMsi/qpYSxy0DzvfxQiBlYxTguejeMMAfPOIETjmIQAZqmNMRDCKIpCCCEkSplpkiiQ07H9/vvvIaDH4xEgxRgLHhhj4qj87ru3Stnj4UwoEnFUVct2aLMya+szY6Jt2/vte86jy+UiBAcYNk1zvV4Xi28hxD7AFwaDAvp6vWIkAACMRof9+XI9LxZlmsQv47Cu6zD3jEVtd/n69StjKCsT5zUA9ny9eO+dN1rPVVkkIjbGaO+nUeZZ8bLt8fj4VSu5Wi2sNU9PuzTNIYohxPW1+/nnn7OsAgBQXALmk2ipZvf8vI+i6Hq9MibKdN3Xg5Z6vV6kWTHPkzSjEAxRTL1Hgb5+9YGz7McffzR+Jkxo21KKBU8jLjarlZmdnDRj4u2bNxixh6+fAwRUhjSNOeeMxsCEu+0bNQclzX7aXeuDgwNltu9b50wcsWFs27Yex/Hd+zd1Xff1XBTLGdf396+NdgAEKQfrZBovD4fdKHvrpBD5zz//nP/9Sk46hEAwJpgBAAAAEDrvPaPEWcsYWywziJngSTdOGOOI89mMIbjj4SCEuFw7F6w22gbHKLs01yhNEDGc09//8R+zrGCUW+cYY5BwjLgQyctjZpolgN57q7VZrTYEFYQwSrG1GkAoIoSwtk72w/zhw4fLuU+SLI6Sl+FjnqeTbJ+eHhhn/TC8uf9llien024YWqVHjPH+8MU5kFY3D89/3h1+ytLF+3e/rso1gsRY5Z11zqVpHkVplqYndPY+DN2QxHHf95jA+nKJY0GxGMfx2tRJtEjjeFFl0zRNsqv7owHSuv4//5//rzhO/uN//L8mKbcWeheytJrlaI3crO8AkgEoOSnnvdUy4my5jsex//jpb3m2WK02aVIOgxy6YZwPWZZcr6c0TaM0H8YWwDhLUzK003qz9N5iEmDM+vF8vuyFiLeb2+DduX6mNFosNgQh6APFwAd7rk9tWwfgmKDaeOeNoGyWM0JEcJYmmab6ZWwZAgzATFICABAmw9ClaXp7uw4haAWE4MbytguUot3ukUfRrHTf94zxJEnyrGBMYAwB9A8PDxCELC2iKAMBRSLDBMIZFnmwxnvvGSMiotf6YOxMKX7/4e3Tw75puvX6RuveOZdyGkIQVDiEvbcYY2ucczqEwC22TjmrxqmmFDsfXg4gCGHTNEkUrxbrujkhBE+nE+exHFUauTJ9beY9oT5NI6WOw9gcTp8QwlmSQQhhAtMkGcfxJQ1ltTnsT85io502M8bQeVPXl6qq2rYVScwYWawXp+vJWmu8wRjX9WW1WvGYn+tjgRM1TgDAOczL1U2cSCllUeXX+jzPU5JEPOJ9d91uN1LNl8t1u91cLjVjJIQwzqM+6DiOZzOXVX4+Ty/eDWOtDyGKk0t9NkaVZa5UjwBIUn4+nX76+IOzgTOepiljJEmSgPXHz5+qqoDQcY6NkVFEyzTpxuMw9P/8h39cFNWiWIyDhOAlrdpGUWaMssYN/RyJ7O2b7WF/AWAeB6m1jqOMc973HYAeAM8Fz7JsGAYIIQDOWvNyVx1PO2cBJdmiquZZhRDWm8Uka4SSV69eD8OwP54wZotqNWuVl4V31+PpSUo1yutmfbNYVoRg7/00yUgkUsr9/mGxWBDCXz7n68G4qevPGEPMKBydtRZTnGaCUzFN2s7eQ2fc2HWt9lNVFUKIu7s7ANyf//wHOXZRFC0XJcElRnQaVBxl33/zG2Vs3V3GqWcRck5p7aI4VVpGIn91cz/0EiMBgDU65FUVgIMQOu/iNOqafrFYLBYrBMnLa0xrned5XV+Wy+WrV6+u12sAznkVAKOU+mAIwUqpl6lc0zTb7a2UklDEHAPAc858sHleAucxZllWaD31/Wi8Hscxy6PDYbeMFy/7Otf6jBAq89XhcMAYOqc32xVG8SxlkjPKRNefpnGCMMyji+OEUhzHcZKk7bX13k5TWK/X4yiPh+tqtV6tNn/4wx+8t2/evHV+LopinEozS5YujdLn0yk4L2hqjbfW/+IXvzicDw9zF8fxm/ev9CitnYZhUko6516QBne3r4t8s1iZa30CCBbFMuJit9vlSUqY7vtR1aparbd3b67X6zzLcRwQ1T7A0/nwu1//PSHs6ek5TdM0yX2wAAAEyWZTaq2t0/M8Y4xXqxuMcVN3AISx6798efj2w7dt25+aQ5YWAELOImOU1volgSnluHtSTPBEJIsij7mwZuacaq2fn585p9Vq2XVdmqYAgOu1WVT0bnv/5B4xpoi6v/30t9d3b6OECSHK8t04SjX7RZWInE/TACFUWjIWKWXu7u5EzC+Xg7VWCMHpYgw2jas8razBFhNKmDVj8O5yuTivGSNJyqdT13VDnpUi7mfVa63Xq20Sl/v9s7RNnFAK19v7ZZIkp9MRAKuU4YRfT1fd0e+//c3z7nNd10WZAehD8PvjLqvSIinb67BauKrIsixvOn1zu3K+upwOIoooItdTE0UJFwxBxAXijJxOJxfsfPV9N/7iF7/BVGtrmqaORAqg74fehhlho71KIhFnfLe7Zll2s11eLmAYuhAcxlzN1lnIecQofqHV+WADMMPQQ+KV0oJDLvg8T4xTD3hZrIx2/dCKGBEErdNQw6Y9C8GstZxQOcg0zZRSSpm+t2W5lOP+7u6VNVDE4nn3lVOsdIcQk3ISiTCqB1A5P0IMAcDW+vvtHWMCISAEC8AjhNq6ydOiKvKyWBlF60sTXMjSRClZVsXz7ssk2zhhjMZxhBblbQghSbjWGsDwsnsXxen7999QtpSyn2dNaIijHCF0vV6zrJhkSwgkBCmlmqZh5F9hZUnMlLHc8WVZffn4Uxynd3f3GNNIxFJKRMI0jVJOgzfLcnk6Xne7fVEs4iiqm5NHZFadDx5h9/b9arc7/unP/+s//MP/djqfGeNazYKnhFGnrUeeMuo9tMZwFgMIMIaU4nGYtnf3wUNj7Hp1Ow2PSb7Z7/dRElNOlJnlPF5Oh+12Sy6nkxw7yjDnuBsHAFCWVkmcH06fXFCU+KqsEFp2Q2utVmqK47iua6kmhBAiMBaRtyE4oJSKIkIoiuP4xUajtIQQaq0wBsaq2+3qcDiZZi5fbGeT1mbABFIW6nbHOOcxqtuD0RpDggBM4pggWjcXjPHNegOgVbNDkNxst/Os26Yzds6ylNKkaa/WWQhf4HfYe9A2PRcoTngc0XEcQnCxiJyHQiSC0bq5eOcIxrNUMHg1A2dnSjgEPklE0zQvdbH3AUMcx0ldt8Y6CH2aZt4hjChCzCmY8DRg++LsrpZlgDZOk+u5hhCGEKw1UkqMcZIkZXXbd7Jpmru7u7o+Xa5HSrExGkDvvT4cnrSRaRp3/cUYY+wUx/Goui9PP1flEhPfdGfnDQgEgLkCiyznk2w+f3m4vds6P1kngSGEcm1V11+7/lKUgnGECDHGCOodUIPU2kjvowCM0pJSEkVsHKa63TMm0izt+joExxgP0EQpPZ8PZbmMs1S7Rmo1qRlAlWWZ1hoznFf57ukJwPR6PQNKVqu8vlzHqfnmwy8Q6Jq6E8JgTJwDhDDnZNv2nKWcJVlmjudrJBJCOAQ0y4qXK/N43ENIBziM46i1xhh1XSMiFsX8ZVOJAKVNP+thlPNyVY19Ryj94W9fyrJkNDHGrG82Ws9pmj7v9P60d85kZTTbvhlA8MgFnOTpl8cv1aIgAnVTU5XL9e2ya4dZ1VJ3bbdPs4iReJJS6Xlq5bV+evP6uyjKz0P96cufpJbOuTzPn3Y/Xeo6SZI4TbbbO4bv5TQ6Z0jMF2U5jWPbDG/efnc4HAC2UUK1loyJWfda64jH2ozH00MIYByzEJx3uMhuJtkJAbVRMNC8oMMwbDZ3EY/GcfQOcM6NmsZpKMpsuVyezgdrNWXIjBPjOEtL7wGCpO+nNE2d83Vdx3Gs9fyiSMiyrG0lRnwYOq2Hb96/tS5SVmk9q9lGImNk0jN+/Wb9x3/5p8WiBIA3dceogCh4PxuNljfLDk7OuTQVxo5SjoyxakG08uv1uj43ebbI0uLzl49JzI/HM6X8/v4+BPjw8JCm6Xa7PR73XX/117GtL4QiBIMH4PPHT1HEV6sKYzxOzWpdNN3heNwvVmXf98HiNFsFYByY0iIry/Lh4dEDanQQUVwWy0t9Pp/qN/evt9vt6bCzvjEebFav16s7iELfj9ZawuispihCL/SkaZo5ZwCEWY1xHBtjrdNRFEkpjTF9PwAQVusN59HLwJ4uy+Nlnxax1KOaTRyFF/aMmvWXrz+HAJfL5aK4fdrvoIJxGl8vjdHz8fR8u9l4H5SSk5rkzyrLUkppHMcQQqv8i5JjHMe+7yc5aTdXy+XQNpeLqarlL77/1eV6enz6NE71clmm0VLNXlt99+qN0tIaJESeZysEY85529bGuKLInXbTNJRlebv9MAxN3Rz7oU6S+Pb2tmsnEGiR3LTuggWb5xkhkOQpwpZx3NUaQGytkXPLOB7afv3uF5v1q4isnJVN3QFoQgjn8xEzVC2Kx/0hflcURXU9XaFjd7f3g+quTUugNsZoiaOMxXna933X7V+9foMRb5omSsTp/Oy8MtYfDrs4KriA43yxbsrS5YIk53qU2vvgJjWVtDycDwADDCAhZOjGxWKhTeja8WUrmWCGEQUA+GCNd+f6zCOfJKkHCGD0p7/98e///t8QR7z3xiqlR0KDdwAjMY7qWh+0GpT2VbU2VgVPvHV5keTFom3baZTTpBEUlArBC8wwgMpaP03TclV1jUmSYK0XPHbQjMNUFitjnLUWwtB1DaHicqkxJhDQaVK3N69e1IYI+c36VddfQnB5kVprh15tN28ZLfrhWhSZd8A7O03Ty6gxipmam7LKCLoZhgF44ExYla8oxcoaGIIPECFmPQAYGaeVk1DOlPJ5nvq+f/PmXdu2WZyP44gQYIyNsjscdlwgyshqc3PctwAaCL024zh1bjJaK2td3/cBuLZtKImGceCcG6Xnea6qAgDcdYOD87t3r8epZwBFgkyyH4Z5s76hfJJSMorGcSBY3GxX5+t4u733wL2waiCE3333Xd/3RDAaRZHSY9sO2vmyWHgHHx73wA885s4GhIF3RClVFJnRyoEQZykAoG3bPC+TuLheHhgVnPMQ3DDMCCEAwDzP3nuMIRcUYywnPasJIUAIOhx2jDGMIURWznKxXEjdphlH2GW5iHiFIAkB1teWEAIBNsYgBBCCzjlnVQjwcrmkacwYHdoGIDyNs4iJc0Frq5RKkujLl4fbu/VqWWAMiiwZuquUEmOWJMnQ1/MsEUJpmvV9b6xyYXJOz/OUpilCYBi6+/s3WtlxlFmWj4M01kAE87yYZ/32zTdfPj+fT1cCAiYBhjBOPWM8z5bnU00ZzrJ/bZExTibZhQAgDN4bpSTG9Hjc90NdVinGYBwnOXdUCA+1MhNzcFKdUsoBPZtexPR8PaZ5LBJ8uRzLspzNDAL+y1/+GMUiSZIA7PH4TCjSUsVxbDRQSqZpEkWs669xWiolhUgR8UYpBElWxOfLnnOGCYfeWatFhIahLUsYABzHviwSa+0wNpv1nVahvg4IsiRJhmFgjHkImDXKhrpuo4iXi0UIwYMwj4bAebkq5lE75wFAw9gtV0UIAUL+0r14gTx+/Phxs7mpqqqpe0LCenUT8eTx8RFjEEWR93boJ2N1CCGO436oQ3AvtOCyKr331+YpSeO6Ac6wd+/+ru+mZJs4Z8bj/nTaizhiHPeyU7NZLBbWKUJh17cIsTgqurZjjATgjFGz6rMsO56e6uby7u0H2Q/adsb1EGGICQQkSZkyYyfPXb/kFADoiPA4zCLi2sppeDbOecimacjSglPqbeCMACqmaZq1dBbWdR2nad3tcUy8Q6e6XqyqOI7HcQQeNmoy2t5u38VxHAKZjRrOF2U0xlBZL8fu4etzVW4igZ+f9l3fvnl711wPL6oOTGBZluPYY+Lbrp+VWS7ug4dpmjGsrtdrcCgWSRIlbVufTqeXlEpVLdq2z7NKCPHx82O1SDlL06TwDsVxGvHFw9PXx6cvEEJjtTFus77r+0FrSQgBgS/KrZz2h/0XSpeCpwg1jEXOzRDir58e0mS1Wt6cjoe77S0haNIuTXM5qZ9++omzKI5jrbUQsTNTN3TGqvfvvpNSJkLc398PbQNhyLJklMOf//J7ysnt3ep0OaaZePP6Fz/8+C9KDyLCfd8SQhAk3pG+m0zbCEEo5QCQrht80GkaT2aYZrXfn6Yx3N7eZlne9m2SRIyR4MF33/7qcDhACAlBcu45p5eLhBASQp+eH7z3AICqqq7Xy8PDAyFEa7tYLIos5wL/9PNfCcF5XlbVou/7OI7ThPR9TynP81QOM0HQe08QYRE99P12vQUgOODKZQUAOB6PnDPvPeccU0JDXJ9rhtnqZglhyIp0UkMeMhERIYR3eL/f7w/PcRIp3Woz8Tiy1jMqACByMlm6mOf5T//yAxPGB8cFWq2zJImeH576sUnTjfVeWYMZpoLMZhbeDNN8/2aZs9f75/8KqZnkpSzLJElm6cyMtrfLSfZdNxIaNjeL+9tXRlmCo2mad/sHbwOiwBgVRRHmQHXjdnsXPCzKgqEMBDgMwzzrbjzfbopFWcWCgeAmOQRgA3L7w0OW3BCSd+25LJfn8wFBqjQyxuY5MMYM15oQlMSVUlJZvd6sxmFSWmNCdrvd0HabzbbMq7btXdCY8PVqAyEchjFJMu/9bILzcxRFLgwhQCEia+w4Dl8fPn54/asXpkiaxuN0ddaul1XXGKUHLqAy1loNoY8TjgA2RlpvEDbf/eLN4bB7fn5emVVZZt3Y7ffPUZQsX6+vlwZhwllWFgnBIoDuZRHQu0AZGseeUuy8+/777//ylz/udodZmm/e/V2a5OM4OucwitV8iOPUGAMC0tozmlmNBU/6bsIEQgienp6WyyWA+vl5J4TWZoxj0XWT4AnBURylEAalpZSD4PHd/es8WznnxrFnHAFvnTOnyzVNU2NmrXUcx2VRKDVqo5I0YowVRTIMw9PTLoriAKcvDz8InrCI9P0UxwmCbJoUQODVq/vvvv1N3w9JkpVlKefJWtu29c3NjdTDYrHU2sRRqvRIiYiz5bVpsyyz1s9qgoDKuUvznJKYUCjV1A0dxRRhJKVyLhCIvLOzEIwQVMYRIhgEEFkQR2XX9c57rSXnUYRR3RzHccQjSJKEMXJzcxNFkTFOiNh74D1Ikwwjdzk3CPs4FnEsECLaKmscZWj39DVNiiyr4jh+fH5IGJ3lCIDvB1Dlq1n5qlhm+Xbqz/Os0igd+gFwYnRnwUwIrrLXaRIeHh4en35MkgyAsCg2egrZUiBSSDnGUZHE6c8ffxjkkJWZHEfBWNOeOY+iNFmtFz/88EMAM4Y5wZxxfDwetDbL5cK6WSmFcEwp11pVRW7VjDF3zjBBoId6HqNcSDl9/vyZEGKd9cCRhEZR1Pct5zRO476vjZ2aepcmFeNpFHGlB4gsE2ScWmsTFhGt1SxnreVu1263G4SglAMAsiiy1bLaH06RyFfLKC+iw/GxaS7L5Vqq6zAOmECIAnAWIb9a3TKGxqnjnE6yX1TbH3/cxyKWegwhME6EiAT3FBFIAAIWBDeMdRRFehittxxxjHgIQQ+GUrxalX3fxXGclcW5ruM4JRhqba3F1oIsra71uSiy4IxgJbbIykvKk7LItdZyGCMalwWqr0MSLZMcPuy/AOgJjb8+PAmWJimbZKP0mOWps3Ne5rM+ds2p71pEKReA8dcumHEcKANVfiNlXeRV017Hsc+yrGmuWZYO3bXI4iKrnptJDiMn2dDqC+oZXC6373lE9sc2SsQka20IIQKiEEWRc+SlRYlxGMYLxA4icrnWytnLtZ+Ul2MfCUqZdx5ZaylPAaLGGAIdBOxmceNPuG6OZTXO2jJfMVIEN8eRe36W8yzTNMXU1O0FIVLkS2NsEXNj5DTLb3/5HSXx3/72N0YDdkZKGUKghHRtixAihNAoglI3Ta21LYuFnPo4jt2gmKDOuUl3hMIvXz8jSNM4e/PmrbUSILJdpYxANUngfBzHAIDtppykwiCZzSQnF8epsyhNU0yA0mPweLlcAujU7FRgf//b/8c0TY9Pn9cbFYBBUDiLinxzf/fmh5//5AyABGdZ0bQ1RJ7HEECCCSEkhmj6w5/+kRARgGrblnEaiYRSQjgPnnTW+EC1ArOyhCII4TJ/XVXlwT3RJdwfHiEU9nq8u7tru2vb1m9f/3qePOcUYTfJFkJovWOCDlIz7ssyrru2yEqKhZqt1hYAT6mAENZ1gwIAfo7zwhiwWCwOh4M1qqwW0wTHsc+i36R37denP9d1zQjIku3i7pWcu9HZsoowtkIwo8E0Oi5i7xyjyTR1AFiC2Xp704/DMDTKzACbSfqqWmMMj+fD0PebzdJYNY3z+XxijHMWZVlxubTO2uBHY6fb+7Ux5nI5ZVkRQjAWbzabYRjTNJnk4N0FBBxFsdYKIcByr4IfL1OmS228dQbj8PXxB4azD++/fXh4QogkBZumKckq722Z36WxfX5+tkYe9s+UIsKsBxepFfAwEkuM6dPjXlkTZfFpOj78+WuaFnLQd3f3lNLd87GsluPY6/ExyeJJuixJjdLeKz33XNChTZerDGHRdud+qEEMTAh/+/jfMfEOmmQVKWVGDVgkrtcro/Eyr7pGYp9uVveXy4ULjIPhGMQMYkwET5XSSs113SyXK2OV0t2Lr8oZpyRerhZFEX38+JFHbygViIRJjsMwYOIE4lpaPU0qYosilVKuqkpr0/U9pZxyftyP9/cLwmJi2lm1abIskpu//Pj/++7D98fjwSMLIaj7p2KZ/eWHf6qSeyGEnFSSRhjmAJumawnDjdpFIlPWz9f21T0OwAzTkETpOM1ynopyVS1W795/Z4zLsszZ8N27f5NmkfNKK8tZ4r1PMvyP/+U/UQZ8UL08LKpbpYm1LADHOS6y+3/39yuptJRyVt75VgjWtnWa1mWVnS/jb3/1v81KYkSixBt/mPpQVpnSbdceEZFybpN4+Ytv/+Obu28ZY6Ocbld6uVymabrfHe7u7oKn58seYxjFrGkazHCVLAkhmAjn5//5T/+LC5AkCaVUGd31+yRKOKen64UQbjSOxeZ3v/h7EEgAmnGCMTye9kIIghljwmhHodB6NlIxxiCEyntIufahnTqIcQDu+fmp7S53d3dFub2c6+BolkTeWe9mhAMXSJvpdJCEUBAwhgRaNE3z+XoaFuVqtSJxHHsQKBXT3PvJZEXkvMuybJquQvCmacep997nefmy1jdM7b9u1b2MMDhhjC+Xyy9fPsfrLEt5JJJJtmWVNk2DUNDaEgy9C0Z7x6G1YRwnhAjCVOkpr/LgoXHWWvvw+IVz7h3QWo+DEZRoBRhNgONtXRPUl2X50pas61qI+MPb9/OcT6ojBG1uVvM8zWq01nLGhWAEQMZ4kvyrC2aaphcg3XffvO76RqlJKZmmeZYlx1M7qynL2TxP1tpFUToXrAeMJu1VUYSzrJRqQhgsVsvd7pFzkSTZMAzTNAEAhGAIYCFiIVJKGCUJ53zo+xAIZ6maZyFiCCH0kBEGHAKCSimH3jBGKBUAGoi0MmaxSjASjKYRzzCY8wwb7dQ8cR6tV5VzjuJ0HMco4owROU8hwLJYX68tpXy3261vty/DPEJwHEfeewgBhGAa5xfjFOf85uaVMf6wv9zfv1lW+Hg69N1YlEXf91EUScowCIyxaZKL8rbMNlW5DAHlefr8+FCmhVjlFuAAFATo5ubmjI9mVsa4JImMnce2JxQJFkPAh8msFxWAWvCUMdY2fZJkh8OOc97L1gSFTGjbWs1uVvOsZimNmZ21drUqKaUABIicENx5kyTZ8XAxCt3cvB4HraQty8X1eg1YfXn6m9Qyikmc3wQ4T4MssnxWYBgGY1CaJgQbKfU8z1EUZXk+DCPGeL1ed11XFAXBYL/fL1alD9455QPDgVhPoWNyAJTkCBtOI5qGvtMgOCbCMAxxnC6XyygSCAEpFSGEUBQCHseecUwp/+nHT5wllHAIDWMkSUMchDHmJTEeQoAAF0VhVXhZdh7GNgBFKSGEFEV5uZySJC3LXCtn3QwAzbKMc6LkqJUJXk/TbIza3G44jyiJhIiUYgiBOE69g3EcazO3TU8pj+NYa+WcK4tskp2cp7xIlPbW+jiOnUXWmq+Pn7Wel8uKx2vOuTVguSqkHAhBiGA1yzjKrR2nqfHBQ+TneXDeLNLSaWyt5cJSqj9++T1G/M3NO0qpVubh8eeubwkBy83ydH4Ok5VzIwSrFrm1erVaTWOvzBzHomn689Nfd4cfkyTJ83yQk9Hu5uYmBEiYy4vodL6Mk1mv13Esxr53Xi8Wi/1+//Hjx5ez4uefP1ZVpbU16vLq9fJu++351CbRJs+WlIFpvmRZ2rZ1AFopvVxsvAen8w5jYMy0WFR5nu+ejwCg4LFWgLN0vSrTNL9e6sPh5L2PBEuSTEp0Pl2TJCmK3Fj1008/MMa325vLpe66JgQHIZznmTFxc3OTpYUx1hgzDGPf92W5wJhO4+yD7fvee3g6XiDESmpnPCE4BNPUTVXSn37+G6XsuN/nef7u3bvHp6+cs6Y9hRAC0KfzM+ekac9ZLooimzUmGL/EwmOeIkSU7ghhcYw459CTf+W5ATvPQ1mWQ1sD6OKYERow4bvdpR9aiPLvvrvt++Z0PgRgz6fm9jbK8/J6rbumds4YkzoXKHFCRJTSPM/SPCWIDuP1v/2Pz0KIWY+9bO7f3CYJN8YBAOq63m632+3mdDoihDinnPOXDaF37z5IOQ7D9ObNm7rtGdMY0iROlXL9YN99+GYYhr6tZ2lAQBDgNE2Lomyb8elpxyKCEU+ilZ5JEq2kaibZTtOwOzwvFpWDBgTfdPWL0UNZ9fD0w7/9t//ueh3H0eZ5XjcXCIkxtu97o4OafZGutJ69cQCgUQ4AAiGYD9o7QBkmFBmjpJScR84rCL3S4zAMRVF8/PisjRrm2YXw+eEzIiLP1hHh1/qkXKCYuuAQCkRAGiGnVdvVcRQdjqftdktpaoxZrzbW2qZpq2qRFSBA74H/w7/8/vZuyQQHCMZpxCPGGAsQeO+b5qq0ppzuj/uqWgXooyQdpz5AwAR3FrgA+uHyj//lPwegoySGEA79ZK0HAMt5Korser0yxuIoXa9vEUJaWYz5PNk043m6fplIBAe0DhYPhOIIc+uC1nOw6nR+vlwOr9+8ul77rqsPx3a9WewPD5SyLC0oY3leDsOw253yIun7YVFt2mbEmAzDqNT8os6pqgpjJAQjURIb7byDjCZa676bAAxxLEII1/pECa+qwrkg514IxjnVVmltKdUvm1x5WhrtjXar5a3RsJcDZZgQ7ixkTDgb4qhIYt601zTN87yghMcRJIxSirkV8yyttQjyF4m5lKPHs/GYktWHD//Q1d213jlzZTRIqYSYQwiEkBeRyteHT9b6gAwAlhB+rdu6vmAMUQAYQu+AlIpS6h3ABI/jGMexc+58OSAECEUiYkIwiAKlZL1esgh5gwkWRkOEQyyYNfjt6196Ox1PO8b4MMkoiqzVXBARYYKztm0RBtawWQ4AIC4iBAMGYXZaq0CISGM2hBoEZIwBDq5Xt0WxHHqprJJyGmQdx6UxI8EcQBuJZJ6BVoFiGEeVsjqEYI1nNBY8b5tutVolsT4cnwWPGIumUSVxKVgcR6mcR+B9XhTHaTLGRlGstWYEhhCS5IXtYcZxpIRzliJII17GibheG86pczZN83meoigyxszS3b96beZwPJ3jqNDK7p5PHmClQ14VgneYxV1/eXp+hsAro5ZF5Wzox1EbSWjsPSCI3my2XdePU2PdWC0yiEKS8klCbaRxqlzkGDEEqHPm3Zu32kxtd5lnqY11LiDI5nmCyEMIvTdFudGmbfupKNmbN/dqNtbabmjj1H/88tV7G2cMWQOC2W63ONDr1d1s3iCEhmGQcoojjjGe52maJAAAQhjHqVIqy9I0fklEX6IoysqEUnY9d0W2/ebDP1hDB3n+8ad/GYbLuzdvs8y8hAy7vrm9+RDFvOvqF4BYCLDrOhBQCMF4OkxyvXqVZ9XpfDBWN930koZ9CSo7G0IA/dQSQrar+9PpJJIYkxACEpFwFrWNZDRZLcvlcjmOYwiBEqS1ds5HUTLPMwBktVoNQ+e062VPiYi5wACMU29mFZxz2mGICSScxYwSjOkstbHyct0zRqxTzgYAMELUQ48QmOceYa+0jJOb9fJ2Gi1nzDn3gr1P4gSCKImpUgcftA+KUKwne71e3736N/1w1VoCNEEsX0y/10sv0uDgTDiyVq/yYlLRONXPh33Exe32fpb6cj1mWUYprWWLCFhtBEIkeAAhrKoKgk4pNY7jMHQAmmqRWGvq+hJFSVnmUo6fPn2y1vZ9DwDw3o+D3N7ccRbNs9XKDp2L+c23b353uBz2h89R4r13URSNk5qmKRITIYxzDiHA2Ibgrtez8+Z6vb66fwshNCbTuj+fLk3TFUVBKXVWW2uNMff393VdG6PyvATQ+aCHsZlVJyLWtFdCSByl3nuttZSy63oh4svlxBgTggPoiyKr6wulHgIax7ngsZptHOfWTRCi5XLZ9z1CqMiXhCKl5SR7zkkU8b6/UkoZh0PfJkm2JFUUk0m2IUBt3GqR4cA4iwlhCHgpBx1mCDQAZJomAPxyWdV1ezg8VdlmGAeMIcRQTYoLuk22CKGHx5+cM1LKsspDgOMokyTDGK3Xy7q+eu8451W5FCJqmgYAoJTq+qbKq+323fF4zEi+AEk/9iBYxoTsOwc8izhEiApuJjPISVsfAAoQQwIQZfM8IeurqjLGZnHhAkCYpkmhZrda3h1PT9qCOC3yqmKMBYgdCACjcZQEL4p8AQGTY2O0C1A6r0fVZUFgDDx0So55lSul7u7uDpfH3Wn96u7t5VJfuzOmmAl2PB7zrOy6IThIGX7efRU0fn3/VusZIQxgGIY5AEcpZVQ45yiDAahJKqVkCCFO8jjFZj9WVbE7Ts7Zpr0oPWoTde3gvLm7uyEAtnXDBVFqaE9TEseQ+NkM2tpmBDTimAv5Qvqi0ISZU3w47D5++lsU03HqhBDXy+VXv/z1IFvVqCiKCEfII20HgJA2GvRAxOzSngDwaZYabyjnP/ztp7/+9M93d5uvXz7ebFIQ7GpZ/OXPf/j1r/5eCKaddM5gjJw3SRJZaxDG1k3Wmn6YrdWMMWNnSkleRNr2zhlKhQ+264bT6VB3J22GP/55H8ccUe9m1XSXNE2VMcKzuZ0gDFlWzPPcD01ZVrvdrio3RVF5b//lX/54e3fDOZZqQjhcr1cyjiNhQs3m9vbVPM+X+swF9d5DQDiLqqoahj6EYIy9u31jrb2/fzOOo7X6JVv/siB5Ol2SJIMAdl2PMVqusratQ3BKGS4AwbhtRk7Y0M/7Y6P1fL6etFNZHjlnOKVJXBDM0yzRRlFu7aS1kdpMzpkAXJ7nt6/eXa7zPM8YU2NMXqQgoI8//ZSlBYvx1EulJikna3We58aYWWrBImu84JRzjhDSZs7z3DnHGXVeTdPonFZ6rGvVD+00dSwGglVZdBNCwBgqNc6THvvaByXlSCMUQkjTDGOIIbHGbze3L50DSjljUfAQIYQAnuRAiXj75v2spmu909oGaKOYP3590rNJkkJrizC7vS2tXxHqT/uu65skSaZORVEs4ujp6WsAhnLIqOAMEcIIppxH3qNhmKzVUbmIosxZCALJs1gLLiJmrCWYCR4TzILHTgPOI845gN4oQyh0zgQHrHYERY9fn5MsYkwoNfpgGSEEUe3Uark0ipo5UMrTzH/8+CMhZLVejKN52H0upgwRZOZZKjX2TZYnURKfzlfnnHOGYGyUEZRY7cubklNGqLtc+2kaGSNdVxMarterSJDS4zTWt5vXBJPz5eiNJhS+CMkIYdub16fTUekewsBFAhColgszw91uN0uLEBqnvqxy62S1EIRRiPz1OhqlXQGu7TV46CzEjCcxxYjOqn9xoM/zHEcpQmSe5yTJpJxgCCGEPC+t8X03CuEDQNp4YzzF0dgPjHCEsXfQ2ZClhfPcOWeMI9p5D42x3qFh6LwDVVVhEgCgSVysV1ut7dBPaRYxHoXgEUJ5JqIoCR4a42bpg4e749E5l2DoZhNFwtmgla/ydZqmURR13fV03mdZhnCktY6iCGOgjNXWrtdrIdj+eaeUKwtW17V1qu9bIWaMWNM0XFBKRRJXScqVks42WmtrLYDRNE2Cp0IkjHJj+nGqjdFFkQFY1ter4JwRpqXL4up6vYbAAWC/+f7fndvdOHTGBmcsI5QRoSY7DL0QDKC0H65JlnVdB07PcrLM2CzLKWd9769NizFmjBIKArLDNBgVkuWmbtvPnz9/8+4DQKHrusViY6zvp2lLeJZlXx8+a62iKKIMEoIojeZZee+9903TABRhjBfL0nuvxhfBR4AQT9N0vR4ZY1VZfXz+29j1mIZxHBHxZZnPihBCz+eztfb27sZaCwDsupFSYo2P43gcBwD8MDaYAADA3d0WIdR1HSU4TeOX1+2L9fd6PVurnTNtawEAWZa+VCQvVJWXWi3Pc+eCc4FSqpRCGHDOGRNCCODQ/fa1EOJPf/rTr379y//1T/8ljvm7929O14uajVLq5Zh6WVNTSkEYAjBCxIyx4NHd3dY6NYxdnGZGKUp4sAgGlCUFAhD40DbXLF3keTlNg3eGC0wZnGT/5tUHytA0DSF4pXQkEsaYUmqUXQhwnHohxO32nnFijKGUJgkzRkMUGI0wxlrreZ4JwQFAzrnW86xJgBZjaoyTUlJMnJPzPHNOm+Y6jmOapoQQCCFCiFLuvfcexFFKKbXWKmWztJDKbDaLthn7qeMxBzDjLDFWdd0gBJNSamVDgFmWKIXkJP/XP/8fELDj6VlEkHEIkSsXOcQBYKfkOAwdwOF6rbMse//h269fv/z008dZ6s1mY4wZxo5zmiQJhqTrRmNkHMfDWP/5L/U86xcctveWEKK1Rgi9NGzu7+/2hx1CKM/THy5/8d6u18th7JIsPR73y+XyafflH//r/6mVffvu9d9++gPDMYB+uS4enz4/Pn7N8/zN/XtjXN1+kVJHIs+z1TjMWZYlqTBGgUAJwUQEH8I4D5jBOOf/x3/5zwRwKeXd6/uX5vQ4yr7vq6p6uWis06fTibNouVxHUey9395Ucmg/vL21cvj8+PjL735zd7P+5//1n0Y1E0aVUllZIAQeHj8yGjWXZtYXhOELZC/LssulRgglcaqdBwBwFkmpISKEQsr8NPdpsiAUSTlBCCEKPlhng/f24eGpaZpFtcIYiygnhOTZKolTa/ysZiGiF0/k69evvz58mueZAIQQQgE4rWdrNQAe/OuaH1sutpTB6/Wa57mUTV3XWVZ4FzDGSjnGiLVWyoFxaiw0Rr26ey2E2O2eEUIYk2GYhRBRlJyOp+PxpKWGAAeEMYajHA7nQ5KK+/u74KG1HkJ7Pp+917pjzurBfP39n58SkQheGJNNPTOm13rOsmQcx7qu0zTlnAJoMSZaz1prQkhZls65l/9yjDEAIAQIADLGEcxCgMMw4YIqJcepp4RTSoXgabY9nkI7nAUDAZhqsXF+Ph+7okx/+vjHokir9aJuThAFCNEwSEp4HEV1XY99b7SDkKyWG4RI3/chBEph19XszJSa+6GGxDNGxnG4uV15F7ruOkk9zWqaBaXw0py26zfvl98e9k3Ml9vNq8t1v1m/Ppw+I0go5RBC50LXtxiRrmus1cvlcrFYnE41ISyE0LY9ZaDrOi7S86klhHOWOuOl1Gr2SYIow0aHl6GYc4GSeLNeWxN2h6eizNQ8eBuk1MaoeVTRJu2uM2d4GCYAvIgQJr4fjkKItn9WRhRlOcjRB5vkhXfW+wABQShgzICH9XW4WX+4nIfjbi9STBkQEVZ6wCRyHkSRyIvEBQ1erMYI5Vl2Pl9hcM4BpQyCRE464qVWASEhhFiu8t3xgRJRLipnkFZzsME62Q/WWrtcLw7HfVmWcZQBDo/nJmKcUH+9ngEgL0KWcXLWeOectS7PE2Wd9z7LMosghB4hlCeLcZDKh4jlVR6dTv3Hzz9V5db6frFMkyQBABhjKOVW2rK4Gceh61QATilbVYskSQ+HwzTJzc3SaJ/EyW63k1JublZCiK5rKcWXS317e0cQU8ZY4xlNGGN5mR0Pu6KoIApKSULY7e2akfzr4w9KzqPsKSVCcCHELHXdNFkeR1E0DNP+tE8jESBYVMssq67NCUDHGIvjeL3aPnzdBQ/jOK6qVZVVz8dH7wZKMCYQQrioVuMoIcRaawiB87OxUhuMEFhv8ro5RiKjlENACU7ybEVJ/Hw8TNNISRRFgnG02Wy08g9fny/143K5VLObpxA46LoBISqE4Fwobeu6DcFRhqKYW0cJi5dlMUu7XG3lNNd1UxQFoiQVUZJk1gNMw9gOv//977M81mbMi9R7hzGR80gw5yyx1nuH7u7eNN2Q53nf99M03my3Td3t9/v7+zdRFBHqIbLaXU5PD1laxUSY2RYZudZnENCru9dyHtu2KcvCOX/c91VZem+Nbimlh+MTgAYTm6Z5XddRvLLWEopnOT09PSktI5EghIwxbdu+9Epfuq1RFCdJejwe+75PkowxEQJ4ySYsFiWE0DkLQNjv95RShKi3cBgGa/0//MO/+/L1I2dRHIthGJwNQsQfPrwSPD4ez8fjvq47xug8TwAAJUwcZ2o24yin6f/P03/1yJLtWZ7Y1sKka4+Io/Jk3ryiq6tFsYnBAAQHIN/5cfnCRwLkEN0z3eyuqisqxVGhXJm2rffmg2UxHgMID+EWW6z/Wr81egd4LsqstMaq0R625Waz0VohyDbrnZQ5QkhrjXAchh4hEJPtxzHPczcOfd+VZT7OGiqbZdl2VytlAKgQBpv11gc7jgMhaJ7nxX4UBMBIxpiMMcakGDAhxMF0vjb1qhyGASRUyKqua6VmSrF12vfaGANgrKoq+GVX8yFEQogxDgCwqjfzbK7Xdp6nssydnyKYJgXbn58pLoUsm+bqnMsLmVJSs7ndWoj8erOx9oVglldWyoxSzqi49U+3pkMIME4Pxz2lNARQVVVdbRDkL88nQtg49VpPWU64iH07cc6/++4DpWzop4QAlzKvs3nSEEJMBEIo9L4sS4KZ1vrWv2almKbJJytL3DT9bDmmtKq3zhlKcYz2cNgCgITgALr2dqnXlQsjYuH99/fOGJEDmahJCFHa3M6U02pdYxxdnHyyBNGnl9N2uwbQI5xeXh8f7t9lnkqRbXB5f79tmialiKzNK8xkNMYBhPKcJ1Q5GwKYvj0/M8b+9OPvn799/W//+f/9w8f3q5y/Pv98vXzjXFo/rbZHDwyhSUisdFevcu9whspxHBFGjFWcc+XIwsDElqSUikLU6ypGMKseE4JpXeSrqiqu1/Pp7N6++dB1gxS0rrcPD+HXX78s58g//uGPp9Mpz/N5mq31q9Xq7u5O6bFp+tWmttbP80y4yGOMWV724+C951xarRBCnK5S9MHH/f4OY5gSwohiTIZxds6M01BWEqJo7JRlhRBUynyam6Isa5U3TZMX0ru4Xm0Rwadg3717291axoTMy2HodmT18HDnvC6KrK7XjImhH0P0ACAXrRAMI9C1V0Jh0rDtLl+fHotC5HnuPRWShRBeXp6j94RC7xnGtCgEALGqqq+PX6qqwhhboyHAKc3WWgjhdnu3kPm9PzNGGWOCS++9UqkoJUaEUYFJjEldLi8poBQJTIhRQCgYp9Y6BwBobp13MQZXFbUQrCgKNRsMMOdywWVCCDPBovfDeEspzKrjGXlzeK+UHrq+zIrT7Zlzsd4WbdvazvR9G92Y5dv7449qJJzlm9Wb59dfOK4RnFNEIUbnXEyhruvo3OG4zbNinpd+Mnw47LSKMYYsy6pq04I2ywpvXYzgsH9YGsyllGVR35rLPDnvPWOgLHwCqazylIIQgtLMW+t1ZLRwFqyqiiKsnVV6ADjVeam1PV+esxyvVuWtuWy3+0lPTmvKsDHGGB+CYxyvqjWG5cd3P3D86r03dvZhZhwBRELwRVH0fW+dppwIIQCYv3z5st1qzuT+sA/RTN8UY6xtG63tOPXrdUUIsiYxKlOCl/O5yCtMSIxgvV5DmM6npr11z8/PXdflWcFYlpId5iEvM0xgCEmZ2XqIMCur7e2WKEWEsAAcSGiapkIKKRjRBHgsaH734wchWNd1qxoWuQx+mOYbQggTACFknBAGoUVlVSUYjDEpEdOPmLBNWc/KGGPmSRPCGeORxH5otKar1QokMs0dSHi7OXbtFLyXoswzpPSkzQQgbLp2GIY8YyGE6/VCycg5mdWIEaIsM8bmebHdbq/XqzGG5BQhpPVMCAIY0UwgRpVx1qkQjU9RZMVsZoQQA+zp6dtN3GKMUuTWjc5ZrXXnJ0JQUWQxRWMniLzMSIi268bvPr5xzkKYpJTeB4JF8OD923fDMMyqy7KCspRS1Cp4FynlAI39cBsHzVlmTRI855JjkiiRS7NxCI4LkVLiLM+YwZAJJubBHo9vpCiHscOY7nfHp8ezc66qqqqqzucTRAGgSDkOPik9TJNiNMhNvVlvUnBt2yAErtczgHGzrYyZi1LuD9u+G4uqZLx4ffkyz0pIQhnohzaTRVHy19eXVb1dCNCU4tvtYoz/4fv/gEl6PT1Rym+3izFKSKzNJGWeZZn3/nQ6UUqLopqmSYrqcNi/vr7GGOp6vV6vT6cTABBCcnq9lWUZA4IQl2WNEf3X/dUTgrNcQBSdM+M4Ygx3u53xbpinCiTY46Kqbt2FCnFr27peW+vOpysAjXMBIYIhjjEwJhaqxzAMVbmBEKcEsyyfhxmXeQzBe9v2ze6wZ4L7Lsg8n+d56MdpVllOBqM55Qihtu2apoEoZVm23++/ffsGIZymSaRkrdvtNhDiWQ3TNC3VE9OklLIpBYwZxphSTCmd5+EPv//udDpprTnPmttkrQUgzvMshKjq6tZo6xzCKETrvUkpOJeMsUIIwTOttTYmyzKlTFVuXl/Ofd//4z//j812FZPrBwUAuv/uAwDRmMk6bYx2zsuMf1e9f3n9aq26fzgSzP72txOycbvffvv6LDIyjoYLRggSItPKrau1FPnry1Vrm+eVlBKA8Pg0nM4vDw9HzkVZlm3bKTVXVU0p7brrdrtFGMTovAdaz/M813VZlMJ5c7ndsix3zlmHIYzHu41W3jtfFfXQt7fmtF6vt3eHlGDTNOt6o6bxdrtcryGr5OFwuJxetJmsNnV5d9hmgt1W9bYoqmEYtNYICWN7SjFamoOauaoqrXVRlN6HmNLr6RkhCCE0dl6tVn3fciZSCl03CiEoJRAmxkEI6m9/+fN6Va2r+n/7z//lT3/8PZesKMX+ePf0P/6S5WJ/d+z7UVvlg/unf/5vq9VqVW+G/loURVZtvPeMVIf93TzPLy8/f/z4oa6Lvh/VbDillEGjh7a9YQwhhIf9kWBZlSTLCimyLJt//PHH9+++//Of//z4+Jznedd1Xz4//k//0/+s9WyMzvN8GLp//ue/NM2VcUogyFJ0MmfGKCkl59KqgDGRYjXNLaFpmm/X9rrfHXe7w+3aCZFBmKjF3hsAI0RY6d4an4Dt+2lV7xFGCQStNaXcuVDloq6rqipgTGVZIcK4QDIXw633wbroqqKUWWmNIzTr+9uqIgSwGLK6KCST3lshXUi6Xu0ppdrMjDGEoPeeYMA5N9rneUEIsdZAiAWTEEJKKQHQGJOCQwkwyuqighGsq5VyI8aEEI4Q4jzjnDunAUAJQR9mKYgaAwWb+7vvmva02x2uXfv6+rra1HkujVWb7WoYehtmzsssExhR71Pf95TShctJiKCUat1hRkROEUJdOyoTZu0w95MdXdAiI4Qma+O7d++G/tS1LzH6eUq39rGuNpQlGXPMBIRQqQljVGasqkqlJmMUZ1nXDc6ZaR6znKbgx3GUGb811xACZwSCSEm2hDDP52uRr/b7/Wb1oPRkjEopdP11HAchMwCTd26zOQ5tt9uVwUXJqrzMur4RkoyTp5SDRKpy6wyiSNfVtmunZQD/PH0teI0RQAAm4Cmlx8PbOYtKWWOU93PCYBh6xkGWFfOspCyCR6676cnoya3rteBFSmjW0/PrHJPzPq1WwtnovapXggtsjGnbm7V2s9kYM0A4ZLKwylplD/vjfoMn0x/3O+vderdVyoiMPr+8VqsypcQ5YUx4H72PdbkjqI6g8z5SwkMIXsfWtC4TMYasEiAmQbkajRpVUWRC4MfHJ4JAUVWc0/P5rPQEMYAAj1OzOJkAQIyxcZwRYlKWUua5zJQy5/N5v9/UK6nUYO0WI7mUFy6KaIyRcYJJGsd2bK7RJi7uV6uq7W4EIULIOA+UUil5CCml5LxHkGCMhWTG+HmeGOcI0VnPxpnL9SpzT7mw3mDCnPfPry8JJiYkQiATrG3aqqqtc11/y3O53x+m0c6qowzHCG63CyZeZizLNrEsT6cLwVxrXZY1AAlA33bXy/WJETyPDRd4XW0455fLpW37TOTj3AEQhGB5nk3TBDwkmBJMunbiAq9XlVKj0sM0B845wWIaPEbidz/8CCF+fjoJWQSfrtcGosQ4VrqnDHIBtFXWWmv97fbEOX94OEDAtbLjOKbgrrczIoQLmlIKwSqlVqttCLbtrrfust1us2yjJq21RRmXAjvnXl4enTOU0lmNSk1ZzihlzoXL9aXvO8aRtTrPtxKkw2Hz7dGcTzeEUPBgVW9TgtEHrdJmtX99uRDCEUWEEGcjBIwxBgDYrDfGmDwvCSGc874bAQDTNCOcjFFCEgBijD7LhNKTsQoTkqw3RocQAEhFUSxLhzGmqmrvYkqQc+QcXK1r770aR8FYcAYkAFMA0WIYQkoI4qEbKcUBxLa7PL7kZVkSSZv+DBIqswLhMiUXow0pyqz48Pb95y+/zvNY1+XlekIYbDbreZ6d00a7Efec82HsU4R5vnLOAYCLvEIYIEi0NhhjjJGUchz7Jf0hs5LxTAr6+Pg5y0Xf94xj720CLgQAYcJkgTBlCHlGRZ7nhBBCSJZll+sJA/KHP/74868gBCelbJR9//ZDXdS3tm/aK2O0rgut9TSZGOPxw5ERNBvdXGfnBsnXZV1pM949lOM4CyG4IARhDAlM4bA7Ikhv5xtM4T/+u39/vTafP/+6Xe22sHZOpYRiAAihoigQggAkLqixCiFKCCMEQZgYYymFcRynaSAErdfredLT3BclCyFaa+6O77xPMYK6Wpdleblc9rv7j9/97vHx22azE8rEGPOqBBExWsQAKKVmBgTCulhLLrw1CEBOBcZYrqQpnfd+eagQJIwWCHKQLGeybVshWVVVuczzPFdKCSattXeH+yW1gLBT85hl2a+//PTLr/H/+r/8nznnZVW9ef9uti5iWeRV383Huw/ewX4cuKD2fCYEWeuKoi6KAmMGAKZUeJ/atjscDtbqz1/OCCGMWEzAWkhJJjPy/PTVGPvhw4e+HaTM1Wi9SSHEsli/vp7fvfswDN3Xr18ZE3d3d217SylWVfV6ep6m6Xh/p5QCAJC3Dz/cmnM/XLVRnHNn4d3+7araWge894SGcWwxol3XSVk456ZphjBgAqe5ByAWuXDWOG+bdtys74ahdS4cDofr9baqS87k09M3CIKxilBUVWU79EvOgmCcAK6qwhjjXMSYQpjK1ZpAAiE0Std1TgiBuEBo0w79alV3Xbe08E3TVJYlQWCappj4ptg4ZxDC8zxXVTXOE8Z+t67P5ysAKIAQY5xnrZThXAISMIYYo74fsmzZNkaMKaVYmwkkX8sPQWXr6h0E7Np85qw47JELNiXIhAAgEApi0ufzWSnDaBZCVOMUM7mEHp+fX4UQx+MRUdgOUCl1Ot3KeoMZv7Xd7rA1Wn399mm73hJCOOFjKjmzZUFkHk+vPyfU1NUmQVWV74si67qmaS/Whq7tlVIYQ4Xder2e1cA5tW4EMcmMSymFBLdbe7m8hpCEEP3QppS4wMthmVIBIbLGh+hSSjKjAEZvXZ5nT09Ph+1+6Obt5uhd6rrz88sL5xxCWNer5jas6vx4+O5y+mrnsNseb9cO4ZRlchpbzum7d3+HCRiGwTugRv25/4pREJIkTPoBLsP4cdAgdYfDQSkrKPPevnnzDgL8/HwCMGmjfFBGJUJ3Qoi2bSmTs+pThCmlNw/fc0EAQGoaYEplWfedolSeXy8JOecNQgiANE1DP1x5TqZpghAKITAOEJA8W9XVIfr+1p8ul1tWVEKI77777vz6zCjEGE1TT0l2fr2cz9dqlc/D/PL0BDHOJZ/HcRgm67TW0zC3m/VOSGqd1hrMs8aYci7zPI8xKqW8jwDAPM+nuXN+hpCcz+e6fFiv1y/Pp0+ffsGY5nlujAoBYQIEQSgT1mrGM+8NFWRWo/f+9TR//O4H76N3McsLhMgw9D5GgvEwzgvd/OX8wlnmg9c+1VklRFaUHIB4Ol2qcs0YUUrNqWecVHV+uQxFKTgnEKaUAgDxcjk7526368PbdUrBGGVtLIrCGDdNirHOeyuEKEr27fFXyTGhCAD4888/73Y7IQRCoOuvECEMMGHQByVzPk5TjMhZnOfS2Gmam6LkhEnv/TDO0zQdN0eZr7T2Rqs3b94trohpmjGJhKBZDT7CBGNMrq5rjAkmISY9zT1GGYJyVmN07v7+eGlujJFhmJUeMcbWqtfXr9Z4kdMUASKZlPV+W8Rkzpdv1s2IzFW9Yowp7azTtp2kLG63zjssJWWMrNdra20I8OXlIkV12K+XuYl3IMb08cMPedZMo8IYV1XVNF1KkDHCuYwxIkg2m+3j4yOE0NlwHq/GmPv7e+ecsdPC1OecYwKllFWdt21b1RuZZxjRYZhSCmVdxWhlnoXgQrAAIpCgEMJYPM9TCAGiZK1GCOzutl07dZ0BIGGSUCDeWec951yuinEerDc22BgjghghRCCJMRZFMY1qst0j+hyCc15V9d3tdiGE9H1jrSWE/WulAOGcpgQ5596Hd28/GDt3XaOUQchRSqWUzqGua4pilZflNCouaAIgL2SMDkH+9PQtL5jWsw/usD9aawPhiABCSNM0IaTNZmOtH8cxBnC7nSN0RZH5FIfJcJ5fL/3Q2MPD5tdPP63XtZAEooQxbNuGMfZwePv4/FNZbN6//fDzL584K/rxMUEVLWeUMkIAANZa54LgmfeJcQgheXp6HEf13XffQ5ism749ft7v1tW6ut5eGaMYw3nWzjljNMEQQpgSQggt9P2UYF3XYFCL3b6qqqJkl8s5z/N51tEOhSwAtCihQmbdrRVUYkCYlG8eNrdm0FoLIviWn89fZcY5E4xRhKwLI2OslmKaNCU047TMyOn1tttvJMs457vdobkNQxy+//D9I3/++vUrRpRRYZXPeGGtFyKz1kOIGRPj2FdV1ff92+/e2Vl9+fb04Yff53kZEsoKBql49+7jt6+Pj48vm+2+BGhW4x//+Md5HgEMb98dtbLX66koCoyBDwqiKGVu3Xi7XSjDgheZRBkvyqzU4VrXJSFMa40gQQg567U2jCPvfYpQK1vXa8aYMe54uHt9fRFCOG/2+z3n3Dpzd/dACCHO6xANJiknvGkahNg0zWWxtlYLSZGPPllMUZ7xp+dfyrJcV+SXXz8xycq8AiAa7TmXGPMYbQIhy8X51GitMYXn5nOeZzZARlA/TILTdmidCwjnzhLEcNJwnG2eF8FDTgopi64daO689/Nkdrt6s9k4bQAAHoOu60HCCBIfbVnm49TriMtqLTlqu6HIN8ErAEZj5zwTbTPaiAiVyQcqSIz+28tPw9zu99vkc8qYc2oe07uHHw7bQ3/9L1w4Y/sQpLfUsQBo97ev/6tzAWMoBHt4sz+dv01zL5mMHhRiN03KwTkBoJ2VoqiLWilFEFBTh7lrx8F4s93snYYg0EwgPQ67ww5WxeV6QpBIsaKkqCt5vjxDkkBKt2tXFNVmfdDG9+NkPdhlH1NEQSfBgA0nbQZKQApA6zZBhhkuRd123Y/ffc8wm4dx9EbwHCEUvNNmzLLMaFeWK4ysmgcgyhigmv12d0zQPT1/ujserfbjpGWWT0ZPbppeP8UYKUQQMIxEVebJwarI1Hy25jaoNuEgpYQABBczUSgQp2n89vXTdrvtuw6tg0m3aZ7u795DJNru5jzEqMbwsKqraR4Q5jLLtEZFURJKv3z5JkSGA3YuWWsAHoehy8Txh/f/8fXlrNw1pN7G/nye7+7upvHVeZumSfC8rLZ9fzv1XxnHXNC+754e/wUhEp3f7d9ylk1z//Ty62ZTE0IAwON8igEq5aTMKYYgRqsMpVxIOs2tseOku7LMeTE/vX4p8pqzYukxcSHkeQkQjAhvj/fRG+vm4JMxDiMmBJNSFkXx+PiYUkJJVGURojUWMFrO82z8hPFrr+Fkrh6Q++M7Rhjw2BudCaZ6oExXFFUIbLvdW2utg5TFagV//fK3oqjKspRZcbk+Wmv3+33b2hjj7Xouy7KSpVbhx4+/G0ctcwYhj9H74PK87IcGTaQsS865s+H19THGaEzECLVtyzhBTrhgtG2FRJRk283x2jQheesgJdn33x+HtkOYOxeVGneHfZln82y6dsCMumhxRMrqvKisbxMICGbOGhenvCRte/n9j/8OIdR1wEdnnSWEU0ZBMrvt8XC/7tr510//vF5vJ5VAQm/ffn+9tBCnpnuZlXHOUSLKch2TGaerszDLpJotpXi7WQefHA2DahFKSs2MMecgxiRGyJlsbifGBMXM6JEQZr3HGJdl/vLabertMHY+fhGCazsjhDOEMAUmztCyWU93x2NMljIYArDWejcyyjGK1ijnQkWLkz15a1mVteNUrEs9zdYrSuHT02uZ57cbowxZq50zxpgQQlnJ63X2DhyOm6Y9WzfF5GIkhAgIUX/zh2MVk2EsaD2p2Rjj1eiKYkVw6b3ngoxjb61FCErJx9Ftt7vT6dR08zLEpJSX1UZ4M00EYwwRijF6r4VgFGEGGYAwhEAZcS4UeTYN435dKdNBiB8eHoZhjBEwTn766a8y4zDlDw/3VVUMwwASgQD0fSulBHDRuSsItPUGINC21ywXKfi2UxBiSpnR6HTuY4zr9RohgDE+Hu9kxq3V3gOCJaXCuXmex5TS08u1H64AwJR8AgEzfr68ZhnHKAztc16sXMIwS0/PZy5K64DzIAHEM7wi4tZ/RnBeb8Kl+WfeTe/ePzS3nlMx60lmXKlAKbVOKz3nZd5034wx49S/e/vh9fIvxliW67peT2ObV/l6t+76awiWcd53s/dhvd4AkBCkzgU1u+1u3bY3COFuvUGIeG8x5s7Gdf2GUPTm7jCr1gcjcpznq6GfjXF5WfjYKteXa9Y2MwCNFBkE8e547LpG8o3V87YqKRJYcB9DP1zpipUFn+fZ+5Qi2O+PCKGH+/c/f/6XS/taVQWk8OXymOXiu+/ez7PmnE/TQAhZbeoQEmOsvTWU0t1ut6qKvu/Lss5z+fr6ejqdimTv7h6Gfo56qqrV/s7FGAhOdVVhhACIWVZYE0BwaIURAABM1ElEQVSi1piu69++fZtAeH251OVh0h1CrKzWKYayLOu6ShETQlJfgGi//+6P86SnaSIUGdtVq2qxK0VgtdEJuBAChDABXxTFNOlMVofdw90h/ctPf12VG8YE+vXTX5r2pNQwjP2792/3+7Xz8y+//vl0+RzTfL29KDUJUXiHJd++PI02xN3hnhLhvYcQp5Ta9jbPo/deqQlAV1Y8ATOrXqlZa+2DJhR4pxYgGudUcDqOPWVYSplSUGpWaiIU1HWRgFt8sEWZLaG1p9encWqdVxACQpFSajGNGmNCcBDCAFKWi5g8oSDPM+f9MI4i49pMsxqEpLPqEY7OGyFEO/QJeGtn6zQmMEbvveWcE8pX9Xaz3pdFZa2t69o5o/XsnGn7pu27cVLOR8pkiEAb/7sf/1gWGwQFIRQAADAo6qIfx0mrGDBG3Fr77fEz4xBAi0mSkgkutbYQ4DwvGWPjNGlrjLXjOHvvMaOYUYQQZxQhQFCc9WlULxEMmHiMIUIMQYlR5k2IHqCEnA1Sys9fv/RD+3o+WTNwDmOwlOKqKhY44DKVeH19vrbX59PL/rAty7K5tsHF8/UMMayqCgDQ9/00j8rONirC2Mff/YAo0c6KXEQYlTU++bv7HedknieMcVlWZbEui816dfBhUrrz3rZNvxSdPz29FkWFMSYEWNdjqu8eSojV12+/+GCqumya66fPv3RdE4JLKUCUilKs6r3WdgFyh2hCdBDCzWY3qP6f//rn59NrSABiPJv53Ly+XB4hijH6YRgwxllWUCLqeg0B6fsZJFzklXPRuehsYJQzJiilhJCUkjHm27dvRlvnAgDIedJ0szJeWUcFDyC8XJ6zknNW6Mn13fTh/ffH7R0IwBg7jSYmH4I73u33+63Wc9M0nPNhGB4eHoqiCCFM03Q6nYwxZZlTSpTuY3Qxxq4dtHKMZgRLEOVizY4xzvOcUlqwvEt7H4TY2QQBPZ2uCBGM8afPv8ToKcVFkS3I0TzPd7vddrttmmvft9YZ5wxjKEYPgDdmUkppM1OGAAwAhGnuYvIppQQ8ZwRjXBdrTqRzcRrm/e645ClSSt7HBHFdrbmQ0zj/9MuvmJAIwuVyHoZhGAZrQlGsDts/1PnH6IrzadQqgoQwAbfm5edf/unb4y8QxaIopkkFn7bbLeNk6LVWPsvKGOBiXA/BDUOPMa6rFSUCYyKE8N4XRQEhFrxEkIYQnHNKTc6btm2bWwchjDEihPK8QIiEEA6Hw/F4lLnQbkYEMkFDjN3Qtn13OB6rFZ3m9tOnn0MIWZZP03S73TabjZAUE9D1N60nQuA4dpQi5/X1er1er9777XZ9PO6/nL96b42Zslzcmkt3awAAFBOZ8Vzy9+/f5oUchs4YZawyVuWF/Pbty+Pj13Geu36+f3gfE8JEnC5XYx0X2Xa7vzs8WGv7vlNKyYxjDOpVsd3WjCGlJgBASgkAwLlYJmvjON4dH8BvLWRxqXGZ51lKiRCapunl5cUYk1LgnGKMEojWmRBCjPHbtydCmHOBcy4Ea9tmHIcQHOc8xjjPY5ZlGDHOKqNR3wYMq+36ffSZUlMInnHy5s2bHz7+bimCadvW2ZDneQgxRRgjSAHkslKTDR4SLNXsICCMZrvtUcrcaNd342Jxs8YbYwXPOJdDPzHGj4d7jMnQK5DIPCuEiNEWAicFpgRZbRHA3gDBinV1P43WO0RQPk9eikLwwujkHcKIHg8PBEuQKEYiBkwp51xW5ep2u1lrY4xfv3798uULhBBjOE3qfLrO89w2/QLFyfPcGLu0OGEC276BKJRVTil1LqzX67LMv//+Y5YvQzR4PLxjtDy93qZRb7f7ulrvtnf7/V2KmFJ+OByKIscYOmdOpxcIQV7I+/v7PFvV1V7IglFpTVCzy7N1nq0pya2NBHMIyO3WY8QJlkYnzuX1eptGtVpthMiW1ExVrVKClNK7uzsp5VIzTghBC+uWsJDguw8/lOUaQuyc6/tungfGiTbzOI59N75/98OqPsAkrO+a9gUi/7sfP1o3ExqLklYrejweP3z3br/fb7fbxRbNOWdUHO/2jNGXl6eyLL//3Y+b7TF42LXzYleXUh6Px69fvzrnyjJv25vW2hhzd3c3DL02c1UVr6fnprkSHwchBCHUe7jEeDCxTDguyMvpk1K6LNYQkKrcDL097tfOnkEiIaSyrDJBtZ4TCVVZjlqFEJxTxs7D6CFGUsoQAkbg9fQNAZhl2enlEST8p7/799M0huABTAgDQtA4zqezSSl0/eVwXDvnQvAh2hCCsaNLCOFAKcaYdF23OL8YFVrZrmuFRKfXVmbl+/dvlR5j8nmRI0j0PE/DDGHICgEAYJw7b2KI89wn4KMPzqHb7QpCJIRwxmCEKWpAYl0VzjmEAYBeaY0peX5+FIIJnvfdXOQ1o0XbzIKvb9cpJV2UqOluzrluaDebHUJYCBqCJzQM441SCgEGibw8nSmDjMiHuzevp/PLywvC0MXw8PB2miYIEyEkBBOCN8ZJKf/5X/4/Usq8KjnBxgWUSJGt9rsHlGzbN7mAp8tzVZc2gkkpykmVZxBiWUmtZ0ypMcY4m2dVczsXdRmT7Yf+7dsPS+bi4fhwGb513bzgEyatuGRdd4UIVNnWBR9SnNSIO1DVZdvfJjWOqi3LKoIYQYwpJQi0CW07hNgShY53b4t81TQNBBQkrfWs9KzNAJE/3359OQfvQFWul0Jw5xyAsSiKEBwhxFgXk63LA+B46Ptffv2rEExm+On5wjU1TnMu6/U6xmi9m+c5BrjfHxMmSqnftqi8ruvt5XwNIWWyAiB675UeGWUxAcZESjBGEVMwRmVZtt9V3vtx6ooim2DY7XIhqfMAQBVCwBSdr6ePDw/7HTrfrtb6JaUSgxu6frNdzfM8jt00TW3TK6XW67W1pbV2mrq+HwhmjEUpZVUXSikMfVUXUspM1A+HN+v87uX0dDpPWVYsTIhh6JwzWutlK7VO3x0fUkKZrLW6aK1n1VOKMIGEMmMMI9xaW1fbrm+en86IQgDTOPaEAoQ5oRDC6LymWAAQ8oL6MEHk1TwLwayF203ZNDeKaFZv8qy2NjCaUywSc9HHr1+/EszKsr67e6Cc/fTTTyIXf/7bX2GKZV1Yb1gUm83hdh3eP/woCMCwGUbFRXCuj9FbNxjX+xBCyFOSMUAIKQCwbXoE6If332vtIYRaj213e35+fvPmHUJonjUAaLvZ1/X68fFxmmYIMAIsBgcAKooMwGCtizFut7vVqj6dTs75LMuLogIJ7XY7a60L1nvrkiNkCXZiQgpr7ePP//z8ciqLjffeaHc83Fun2+5KuVDWbrZV118hhACCrr8CCOpqO45zStF5w5l8fX3EGDuvb+fLcbed5xmkMIwdnfF2u71cLkxkxihMoJQixiAE7/ueMvT27du2bb9+eWzbcbWqHu7faW2V0hl3r+enceyllM4DAAChKAaAMUUIz7NeQrZZJvM8f35+EkISzKSUXd9M86CUqqs1ZQgFGkLQWhNCdvsthNBYPc3We0c5AwBoPZdlOQwDowIEsBxqAQC73e58fu267scff//y8rxaldapX375Rc1uvz+8ffteKTUMc9/3lPKUwNBP3nvrdFWtiiLL81wpQzDT2hayeHv/fuhHjCKCrCzXztmU0DAOEDDvfYyAEAYSOuwfvHvBiB2P99++fSnLumkaAFbWRMbkdps5H9+8effy/FpWUivLmPA+qNl4Bx/u33Rd53X0Lu73d2qKp9MJI/7w8KbtGEIgJWhtvD9+3G63j09fY7TeB4SQtXa73TLG2rZDEFJKp2mKAUkprVMhpDdv7ppbN0+aUjpPg9ZaZJIzmsByM3HeAZc0IeR0fsqyQor8dBq18t9//6c/6/8xDNP93QdnU9v2ECWE8DjOb968WQKreZ5Zp7nIXl77EPgqr+7u317OtzyHnLNmuDImGc3VNEWK82xtg1XW7bb3zmuMYUphv5POBa1tURTOOSnzlGCWZafTKcZY1/X1es5ygSjWTgNE8ThTktfVrht6hFlW5JSTmLxzhjECQFrQMimBcZwBShDCpukh2JWVfH56znMZo08AxBj/tQ4seBfLUmLEZtVxQSmn354/3x3ffvv2ra7XGOPbrZFSlGWJEdjtNkvQVQj27dvL/d3bx6fPzrmqyp+eHut6JYRAAHprtVJqQRgtiYMspz5oY9QS6Oi6Yb+/Y4xzViZAjHUp4iVuqpUiGGs9Q8BiBCEETBCAIcuyLMuM9rPqOSeMYwRCjL4fms9ffrZW35pmGMeQPCRR5gziMOkuK5mPrh+7rmsAiBAFQoFz2kZ1vrwu9iJCiPd+HEettdZ6GOeskP3Q/PLrz7fbzYWkjFFWQQghAimlsl6FEDCmlMhCrDABRs/zPBNCEAYJREKYMT4GkiIBCTMmljInhJY/e6iqylo/DKrI16v6oJRtm4HRnGDhXHDed317uZ6r9SqvSjUbjChjTAgRY2RUclpJvilkIUjmtH15eYUQ3909XJtmvd5u93cxgsu1u5xv0flc8pjsMDZ5CTwctL2OU+OsAQCkBOZ5jg5ED2CEnAoIoVwsexhER6IjMWBnk9bWOeecEZLmZTbrwTi13daPj1+8tx8/fOj7HsKozfzLLz914+CcY4zt9lvGkVLqdHqxVkOYxnF8fHx88+ZN13UYE++i1vOSvjmdnvrhwjisVyvKxDTbcdKz0j6Gw93udP2m1ARRjMkM4805DSGyBmZiRwmrqpWzoSiqECCEFAKSIp6nQImIyd+al+VLEELOec5JSul4PGayuN1uWs9CYog8AAmAJKUUPPMeqFkjxKQoj4cHKQvO81W9P+zv86yy1mtlCSEhhIVIIYSY59m74D04HB7Wq12erQUvnSHBsf32fZ5tpnF+eHhb13VzvfjgMsEJIQwTxmhVFdrMWk9CssUSuNlsJjX6GAilm90+LypjrbYqwdh1v1UCKaWeX7799OXP1+4UgCeEEkKNMVpray1jDGMMIfztEGZMSqmqKgjTPA8QO2PmJf4dFnVeiHmeh6FTs04pWWulyGOMeV4QQjkXZV2IjBtnLs3ry/lrPzWznmc9Ne0FYQABam4DSBQkVhbry+U6j5NSar3aFkXFOZ+V+fTlW9uPeVEdDndZUSJKhBAQ4RRhDGi1uqtX2wSIc8m5CAEhhECUOCdVXSBEEOSZXA29vl7aPK8ZL6yDjGdCFi5ELgSXjDAYk4cQCpGN4zwMA6VUKxsDXq8O281dSnCZU3DOCWFt2//5r38NKUFETuersd56d2ubSc2zGmP08zzG5JaK8/W6btsWAXE8vN2sjxCIGJFSynvXD7flNem/fjDGlifEOI8IppTebreub7jAVVX88PuPMbi+6wjGQogyywBIWiul5sVIjhDMc1lVxTyPKQVKcZZJxvA4jlJKAMB2uwUghuC0a5v+JaFgvUkA9cMUE56VFWytJgABK4vN+/ffCSG0ViG4FOFqtRqGYfnxlJrWm3q/38cAtLJKKWutEGJx5zDGEghNc2WMQAi/fv2KEMmycp7VOKquGzNZpog+fPg+k5WaXVVuZ9VhkghNZcUT0F3/8vj8N2XOIMZxHJ1zy0mlLMv9dn+7NF03MMop5UVRBQ/apltV6zf3b6WUGOOu6xaMB0SJMcYYWWQYSiljHEJMCJsmpWZbV+vj8Y5SwVn+cP9+VW8RxHW9nntNIMWAoIRghJLJMs8l56t1Vdel1ot5kx+Oa4TTMHRd3xCCyrJ0znddP03TYjfhnK9WK8aIMUYIkeViCdrcPdznZZWXxXa/64fJxySyPMvL4/GIMSYEEQrHsXXOEsI2m12WFQAAbcZpbq63Z0w8Jqlpr5vNhjGm1ARhattbCK6q8xj9L59+Dsmfby8RGmXGa3M53h8iSBiT0+nkvOn71gfNGLndboQQLvP1di/yjBBSliVjjDFWVKULMUFknO2HwTrnQ/jDH/+otDbaPdy/1VqHFO/u7kIIp9NJSokpGSd1vL93HjibunaYtDLe+RAiWCp7hlt3+sd//m/Pp882jMGT58f2//Af/0+//91/zMSxyI6cVSCxtrs9Pz9CCDEmRVFY66dRzfPsfeRCGKOUGj99/qt1Q0zKhBEhpJRu2/b5+bksS6WnW3NhnKSUhODj2L2evo1Tq814Pp/uH45o0Scp5X03rFabRc2DKGWyECIbxzHLhDHTTz//mdAU4hxCYEwwwdu21VrHBDnnzoWq3CHInUuUCM6yGBAERMoyxiiEJITY4BMI6/VaKeWDdc4tol/f95jAelWG4KSkSk0ARMKwzHhKYSmG0Ho2Ri2wDe/D0h2/rBGMiTyXUlJKIaUUAGStt9YGm6QoVquN93HWzuhY5GtKss1qvVnvN5v94uC7NJduHPpxZjTnPEsRn04nQohSM0JoIalTSq31jMosK5b7blEUp9cLxPjdh/eU0r7vlVKrssIAppS4oJTStu2lqOYxOcMycdhtj/Osh2GCABtlrfXfffdDDODXXz8TzI+HOwBQ03Raayl5WWZZmQlBY3TD2HVd1zRNPzTX5unr47eY0tIrGJyfhnFpy9us3t0fv58G7x20xmtrfLCfPv2SUkIIbTab9XblvGma2zB0w9gtwjLGGCWwXq/P5zMlTIpSSm6MEYIdDgcAE2Os78f7+3fT6CiVVbUydtJmYCIQ6rvhBSS6295bEz59+qK1vt6ep/mGiNtsVlmWSZnlWZVnq7cPP3z3/u/uj7+jlIOEY0RFXj/cfyBYIiitgXlWT5OCEN7f3zGOnDdVVXkXjbHOuWWIdnd3t6wLGMOUEkL4fLrGiIKPT0+nJQYcYwwhWOMhxBDiZelZr9fLupllWVFkt9tlGZzN8+y9fnl58S5QklXlPhN7EPP7448+BeMN53jSnTHTNHcphcPhoLXJsmKJDhKCnTeXy6VprsPQeG+dc8tjgzFumuZyORPCBC9CAN7bpn/9+vRXba9ZASGgVblacAJ93y/HDs55lsmX16e+77QZm/YyzZ2QpGmu4zgOw5BnpdaWi2xJ5+eFsNamCIqiKooKIw4SShGniI0xy7wmhAAAWBbfGMM0DVVVGWMgRNvtPobkXMhk4V1ar7YpLU068R//8R+9j1lR/u0vP+939x8//gACMMYppeZ5xhier59CGn0cfFAhhDyvvQfn05VzGQOYRu1dLIpa8GIh+mSyiDHV1bprhyWzcLw7WGeUGoRgjPKFyRZjjBExmhf5psjXBEsIKIJ0njVGNAYgpXx5eSnL8rvvvjfGNU0zTVPXdd57ynCWCSFYTGEY+2ke61W1Wb39T//wv2xWb7yDm/V+mtSifyDEMOJlsS6LteBFWaxBIlW5AQBIKdu+W15ztVo5b4ZhWLgUnPP1elXU1TzP3nuEkFJznmcAgHGcF6s1JtB587d/+e+35sQ4IgQBEL98+dR219P5+dY+3trnpn0NwRVF4SyInn54/4fgGYIyl5vbtTfaARiNnYydYvJLn60xegFwTdN0Or2M44gxXgRtCCFCZJ7nYRgYY2VZxhil5ISwqqyLvPr9j/8GJJLJSilnTEiRNrfZO4xRRvG6b501yTlnrHJ+JjRcb09FXlFECERL/1/XDn03pgReX1/7vnfBxxiXqkUhWVFm43TzYQYgxOQpxVpPPmgf9GJcbZoGISREBgHe748AAMZY340xAJDw1y9PWltjnDFGq3Q8vCNYBJ/KKs9y1nZnAJ11k8yIzEhZsaZ7+vXzP15v3xiHnBOEU4x2Vt2//PTP09RpMxOCMaaEsBCS1jqliDHGGFNKU0oIAUopxtgYFYKL0RujQnRFlVNKlTLzrAmhNlhrrRSVtTGEMM9DltMQZ+u70/nz6+kJofR6egzRUAZ8MDFaAF2WCUrh4bCxTiXgt9t1nueUckhAOzSzGTCPg2qtHuoyu11eGEcQBWOnae5mPT4+f+2Gtm1vS804QogyvNtvAIzOm812ZazSZqaUnk4nmWcIYxf8pGZKKee8LMtlN7chQoCUUhASwTNj1DS3bfeS4OhjP+tXKXkCoWmaruvO59cFXjVOPYRJqQlCmGXZcgsK0a1WNcGyvXV93wPolWkRMdY3Wp2ttcbop6cnzrnS03q9ruvae7/dbpv2ulpXu93mdH6SkhOKXl5eSIoQIZLn+TIrJeQ3iS/BtN1uIYS35qKNHkb67t2bz5+/2qA5JRAmY+3hsAMKISp3x7VWnmCmtJmdRQgHECHDnCPtM608RICzTAVFuQQA5kUVYowxYoyccwvG7nK+3d3dLUc8a61x2hiTQIwxppSWMDRjJEUo84zzlffeGJdCcsbnhaSEp4QlzRYPF4F4WQWklDECwhgChCBwPr9gRLOs5EymBL33zoVF+jN2MsYQQr33jHEpsxgDAOZyua3q9fH45unxZclTGTtOegjBbbffQZjW9ai1dtZC6JjgCaAEIsay61QMhK9Ilte//vy/Oe+s8fOs37378OXrI8Yu47lzIaUEE4wBRoD6acQYxhgutzPnnFORsUJgrLXlnHIBem2AiRHGFB3nzEcXY4wJXm/98ShFVnW9HfqJMFwWFedympRS5nQ6KWV+9/H3Uspvj1/2d5uYimnWnHMf3B//8CdvbHsdq6pSShGCfvrppx9+9/1utzufLvOk7u/fzMJM48w49d5bN1uXIAr1Kh96fdzjzWbnnJMZubX+cn3ZbNbrqjqfDUFFjKlrp0LEbc0RSMv8aLPezrOtymIcTJ6viqLabnbn00vfey89xhQEzxiTUn59fHQ2pYQ451CBosikzJvb6MNiiKljgIASKSWE0Hp1vrxCCDCBy8kVQrgYOBAijLHF2mLtkOcSACCECNHvD7ulIPTjdz+CRPt+Nioap59eHglNzpklELGq6izLvIoQJIwoxnh5Ta3NMAwxgrpeO+fUrDFBUuaz6lNKGLHgQQyIMUZpDMEEoHxC4+AAQOMwD8PQ950QoiiKw+Gu689N00uRaz2dL88AhO1u7bxJCaQEECKMSgCQtia2t5j84bjXWhPCfxtCY17XhbMeAMS51DoV+ZoSvt9vtdbaKM5y61zTt/vd23Zo+2mYzYAxRACvVjvn3OV8a9p+td28nk+cU5hXz99e6rqSohqGZtI9pdJ6N5jn8eXb1+cvxs77w7vddv8behiwBdrYdV2WFcfjsW1p2/SMkxjDOI7GKkpRin4YR+89xvB4fOOcW61WKYW2bYu8XNWHruvLShT5yhgFAQ/eL3ls7aZMFvOsEWJZlnVd9/r6ul7X1toUYQjhcjlZq6WUnz79slqtMBJq9lW56btvRVHc3T1o06eUxYStCSDhtm0JIev17nS6Oq+HYfj48SNnIpN5irDvxpSgLMV2u13yq8/PLzGGANLh/m7xT3jvsyxrmmbx1linAQDDOBPCACSMsZTSOA0ARAB8ngutbUppUY6N8cvpsM5p1+mlcgGiNPVTCPHu7s5oMKtxqQhZb8osy4ZhMDoUeb0YI2SGhn6MKTgXVqsVI/T1/DKO88ePHwnpQ0iECKPd8Xg/jmOeixTh6fWSZ+UwDLIq3z38/evp0brpfHlMKT0+vgjBt5u7261brnEYIUrpPM/zPG+3OyaJd4EQNE8jQqQoi29PX4ZhSGSu65oyqPUEYJznuSgKjLFgtTazD5ZzCRJUegrBrVar6/V6PN7X9Tol6D1ACH369CUEd9i+xZRjyiHBPnnr9dx1KcVMsLZtjTdFUUzTpJQripIynMlinsfbrd1ut4zD3W6ntZ6mabc9dn2zcCDneSaEZlkBIX16+kZZ8sEYo6TM1azHsVd6TiHKrAQApIiKvA4xtm1rmVPWbLcbSrF1MwCgqqppmiBKAAQhibV+tS61mYyZEA4Qhcv1lVKa5zIEyxgZx7Es13lWA+iFRBACiDxEFiMoJLpcRq2Lprkhgp0zxqq2u+zZVmu/Xm/b9iIE2WyrW/M6jq33mjHBCJ6G/v13H5qm+fr16/Kor1YrNWvK2NevXyhlCMWMs9X2MI6VVdb5eZpHa+f7+3vKMITYOHBpv2wPWxsbDFxWpevt2/Fup5uWs2zZf6uyvN1ujApjFBeYYEYp2+1Xs+pCmEJwUpYxUqvR99//8PnLr2WZt98uhJA8z5+fnwnO3r179/LypPQgpSCEICiMMci5cLvdxrHlHCfgFtKRMSZGPwydzCil6Hi3Qzi+vH6OSadgp6mLycqMR5AmpS63mzZ+aSUAAMWYqqpmjBmjxrF1Housxkgwnq83B2XMrekwppTSxdG6hLLUbFKCKUEAozHGWtt3o4+/fX7pP0spCZ5RSqdpDiH9ax9x2u/3FJNffv5Zz1qIDCRMCJNcYojUODltKMIE4egcSuAPP/674+E9SKxtR2st5xTCtIw8l0lKURRaG0q44AVGLISUIqCUhxCcNxClae66/gyp66bml19+6tuhrrZ1UY9N118bjOk0qXm2q9UGY5wXkrDg44Ao6YYpr0qtrZrtcX/sbiNB/M392yIrOZdL/7WzIUHApUjY+6DHcZSyeP/ux932DefSGKXjdBvOLipEEJdMCKGUatte1vjUPvXTzfi5KMu63joL+k6VWY0AllxgDJ9ev319+jzr3gYlRWmUPe4Pm1V9vVwwpoLVf/jxPxRF1rZtWRVN0+x3hywrOM8pkQRRDMlmtWaEc5IX2UqyOhi8Wq3arun7G2MEIbDdbhnNula3bRsjmEZLSV7Xm18//fX/+f/6v397+e/PL9+GsV2t64VpixDS2gieLYajPM+lzNarreCZmg1CqCo3799/wBinFBEC3sfggeCldwAh9vG73wmRgYSyLNN65IJYN2GS6rrEGEKYlFJd172eniHEKQJj1PV69t4mEC/XV8YQISjPZds1Ly9P19t5GFtC4zDe+mlWxoSUAAYAIwBgSkjb6Gxsm0lr51xgjC31Gc4bmdGiEPWqAgA0t3aaFEZ0t9vHGENIVblmVMYIMKYpYsGr3e6OYKq11doIkQmRhZButwajTIoyxqjNnOd5Va1jwJnYiqwiLHM2FkXFmNhsNiF5ygkhYBgaY4dpGry3UvKyLPM8z/Nc8BwkGjyOAavZNc11GFuIWYygrKuY7Jevv4gcr9f1rbvFgDbFLgZIKTufz33fC8EIo//p3/8Dg3xoFQikLNcYY+dnUaBhevn18z9dbp+phO/fvyvLyrsYQ7ImMMrrutSmv94eAbQAxmHsEIqPT58/f/lVSqnNzAVbDI/GzpRChOHtdjPGSCmraoMxAyCFkKQo2mbCSKzqPSG0aZq2bcuyBAA1t7ZtujzPD4dDlmXb7Z4xwZhACFGK1+uaMWKtruv6+flxVj3jSOs5eICA3K7fLMfZL1++WGvzPF/07cfHx48fPyKECGGMibysGMsgxEtMoOt+s6wKmf3hj39SRrvgsyyLMQkhGePzrIxxwacQAiEIIeBdkDJXyngXQgibzSZ4InhZ5Kt51k3TFEV2OK6G8frTr/+7smeRxarm0zQAAITItPIp+aa5OW+yLMvzfL/fV+Vqvz9M07TUr2NMMaZqtozKutoAAA/7+zwvb7e2rlYY4+fn5+vlFoITgl0uJwD93f0hz/MF/GWVAwEYNSEQOIUEQobpD9/9frc9ZLLQWiulsly8e/+mrHKZ8dvtElPougZTQBhUZuQF0WFCKIVgtV6G0QgjCgEmmGGY+uaGQcIwRW+by/nzL7+Offv6+vq3v/1Na1sWNQRY8GzhrU1z/+unn/vhpvXcdW3Xdcsq4X5zVjJr4ps37zabjVaeksyYJSBKrrdXH3RKoSjKFFHXDX03xphWq1WW5QSzeZ6v12tecOdt1zXGTn3fOm8TiBCmrMiVUpTIqtxJWQ7DxDnOKr7dblJKQmR/+uO/B4kTnFfl9rB/U5al1hoAME2TMWZJM4QQ8lxSCqs644I652639vR6W692PobT5TTNw6+f/qXrrwiD5+dHSums52Eap2nwwSIE8ly66CFBzy/f2u56a85fvvxyPj+PU/P88k3pnguS5eJyOXnvp2myITZdb5xHEAZnn58+Kd37YIxV3viMFwCGEE2MnjIcY3x5PoUQj4c3h8Ph1lxjssaOPsyrdQ6An+cRAFAUhXVm6f70wbTd5edf/jqPY5UXDBNBubOJ03zq3eV19N4CGBECv/zyy6IdhBDqai2lXOzwWisI0yIybdY7VNe1EIxxMs19lv0G3auqCkAPUdB60mZMwDmnn18ep2mcVT+MHaKYZ6Lte239rO3T+SwzCkDUel40tBij0hOAgbPMB5ggDf43oXWzPxgXFlHa2aBmM0+aUl7XtVJmEQYhhISQIq+c8wSz3fawWq2W9T2ENE8aIbRoxcfdseuGEMJhf7ffHTnNGOGCcRijlHK/3/d9izEcp5Yy7Ky5npoUcV1tirxa0D0hBEqpUmr5pn3fM8bmWccIpCxlnrsYmr67tS2mNK/y2UweOMbx27f3CCGMacYzTsV2s3nzcF9Xa4x48ND7+PHjR5mRtnv95dP/SCn98U+/L8v67du30zT1TZ+LTE+67/vL5XJ6fhm7nlHBhGRUjLMiNCbgp2kyOgSP+k4N/TRNKgLPJLm21///booxTSmN5urSiJh/8/7+eDy2TZcSDp60bc8YBwBtNpsYfUqBCuqiBQGWWYkQWlxOZb56c//h6esFpEQwggnst7tPv/6KIRE0H/v5hx9+IIQ4570DjGaC1YLXUmyEpAjFYWwhijH5oijLYhM8ut1uRjuESJ4XZVmsN5nIfDt8Xq/LcWpfXx/neVxU5UUH/vDdOwCA91Frq5SF8DcJ9O/+9Perau2Mrcq8LLIUYvQwOPDw8BYkfLncYgBVVUEIfXDe2ywTKbkFjIYxZozUdblaray1KaX379//pntjGELouk4w/vXzl+Cs4KxrL9++/tw2p/v7dZ7n6/Xax2B9YJQjwhDmdb0pihWlHEFirVvqNqy19/f3UoplDwAAEEIopVrr2+22xAoYE4s4saq3PuJh9NZ4xsThcLc82xDCGFMIYRy00T6EhBHlnFPCrUkUF3W9ZpQTwqz1hBAAAOOEc9a0J+smKdlqXfpgrdW3261pby/Pr23bew84K6pyixC21hijpkm9ni8ARB9tBH4ce5/8w8ODMfa//uN/e3l5maZpt9stsxjv7fn1kgK4PzxU5QZGUlXV7rgTEvd9A1HY7VYx+tfX119/+TxN02azkVJqo/qhcX7mAiVgh6FBKPZDk+eyLDPn7GInhxCuVitCweV6WpYqIRgA4Hq99t14OBz6vkeIbTf393fvjQ5dO6xWm/VqG0I6n8+LSAAAUEo9Pj66kCZlIgSr7WbS6tJcCCc+eeumepW13TkvhJS86zqCM5BElmUppfV6fX9/n2XZly9fmqY5HA6c819//dz3/e3WEsy2m30mC5Dw7doKmceUfAivr6/X61UrY41jjI/j2LUDJdzZMAxjCMkaT4X0EfAsz8u6Xm95lkNMCRcpMmcBwXK92v3pT39COLXd2bohpAagAeK5XmVKD97FIq/LYgMhXEARh8MOABBCijEKIf7tv/23h8Mhz/PX11dCiJT54XDnfWybnjHx4f13bdt676tqlcmiqqoQ3Nevn41Rzpnr9fX19IgJTCn9+ukvl9tXba/VCmp7q1Yc4XS5nHa7Q0rQu7iYkGOMwzC8vr4Ow3A+v0IEYgrKzjaYyYzlulisMEKIPM9ThOM49f2AEDZGQQSWyu7NZlNV1WpdKaXev3/PGFuEk0XDllIeDgdth0m1yozjPAAEtTXWhaKqtpt7RsvN+i4EMI0aYyZlEQMp8lWMiVA0DF2Wiefn1xiQ4JX3EQA0z/M0zcvDZowz2nFOt9u10hOEQAgGQHx+fsxzCWHq+76uN9v9HQR0mlRd1ykFYycAo5rN50/fQOJ5tinyLQQCIbK80U+PL5xzxtjyJZTi3X4zTeNSkbpardbrTduOXddprX/59LOUIsuy2+2yXq/7vocQLUi0ZYohi/x2a6x1eS4RAiEa6xTCCcC4P6wZI13XheCNMcusHyH09u37YZiWDZdxUuS8rGSM4XS6zLNGCGSZ0Hre7/cIESnLoTd9Z9b13ZuH77p2mmdzer31nfrrXz7NUxBCMMb6vj+dTovnIcukUjNCgFC82Ccejm8yVh0P321W77igz8+P4zi23Y0xtt1utbJSyrpaG2MoxXVdLwf6eZ4ppcg7U5X52LbJWa9NIXJJZJ3VlORqDsEjAFDb3iDxTEZA5qLI1+v1cXt3t3tXyFWZ1SCg/tpcL0HwAwDC2DjOk3caghC8dWraVHmZSYxAAl6b4dY+bvYcIr/eVIQiIcRqtXLOxeiFIEOvCFh9fPt/3BU/0pT/4fd/VxYb77kPMEHUdLe8FKvN2roIIHl6fr3Or4hjgKVyYdZTVYuxbymgVVkmH6y1kJFIYqu60RleFC/nJ236EGeInPd+nq3WdugnEzUgGBFqnB/nUWTUOI0pEqTkFBGstbqmEGiSpahzJjJSOGW0mmL0jInj8d04e+viYf2wXx2dhk5RrwUjq+BhSilCiwjMi2KaNSYMMyqLrJ9uzy8vMhfVumAZSSBILjfre0HqaOS6fvPxhx9I5n/69r8P+pEyzEid0QJ5VOWFtRpAv1zjAACPn1+ShRmpGaj0hDirj8fj+++PkQYusiLbv93+/mH1EWh6rO+ThZfuBGhSRv/6+VO1KnwaL+2vk/2ibBdBQIxhIimtQCLazO3tNaUcIzn0k1IaJyFwkbNMEKRtaIfWRiUKPJvp+fQy6sF4dXf3uzcP35fFRs0OI7GuH949/F1VfJdn/Li/swpMvV9VG4pJiu7x25fT6zdjRyEhZqgdmhjgfvd2Xb0RohoGc3//EcIcpJLSShtPGP7du//0b//0n5zxCbiYtFLDrPWkp4QSwOh0OnEmyrIkFCdgAVQ2aBd9jODWXK7Xx0ldEpyNaz8//ePkvnTzT+P8TBE97r8Pjg29hsl51+n5tK2rN4c//s//8H8T5M08seUITyldlLB1tb/bv9+v36XIpMylpNZoKQQnsuAlCjhFWNelsaN1E0SgKIoyy52ZhCTXa6NmXxSrw+EoBGMMG6Nn1ez2NYTJOSd4sV4dKJEIsaBylJj3nmDZNp2xPaFJ8ByQ2I3D569Pp0tjnBvm4dqeu2GIyVybb93wBKGqqzIXVUbqdX4kPEIUnQuXy0nbZlQvp9dfbs3z/s1a2SHBIHNOKc14VoqKQlkVH//0p//onA3RCCG8wfvVWxgESJJgWWbr4+5+ngJIfLe9P5+v53OTIqCUbjYbSunj42OWZQiRPKsoxZSl1TpDkKyq49s3H6XMMWBWm75vMWLeZnrKCn7PcGVsKKsVpgASf7o+7e82q02NKQFJEsyX2V8I4f7uIYRAGWouLxRDlMD5fF2tVj4mwugwDy+3p8P9DiFCIIMJMUK17SDTKdhxHDebg1LgfB7zYpUXRUzu8fnnSV0Ox22e587atm1TShACQnOCRQiBCxKTO52fMaOYcUJpirAqCmeMj2EYfF18+Lvf/V92mw8IFPPkn56ejO6LDEtOQQApGmsUQdRbOPVmHrW3wVmNEnU6nJ5f2uuNAJaz6s3hPXBQsizPJaHgfL2Mo02JvzxfH789t92t67pxMt9//FNRHjOx9hY3tzFh0XTD7XYTQhirpaTaTZ8evxivZEEpAxBbCGy9ysuy3G63Or5ANieUjMer9VsIy0zW06RuzYsJ46i7CINN/unlabPdUibuj2/evn0fo7fW7jeHsVNGe0JIuV5b7xFmWV5JWazX26qqCCEBIp7V2qdfPn2hguZVThjLitX+ePjw8TuM8dPT82azp0C+P/6+Fvdldecj0Vqv1mVRCOdMjOBy7hEuZV4C6BECf/nL32JACCHrxnlsCIRzrzHiAKDdbgcAOp2up8srxEhm1WZ7dB6sVrsYQJbl4zSo2RbZluDcOSckubs7ECIYr9fbo7XmdjlRTH/3/Y/X81nPI4wQgOjiPOgOCzypkXNutfr2+vXryxfthmqdd0PLpWBcxEgkLwmq5xE5g6zVbfd6vb2cXh+HoWccvX93H6MvsxIkrhX4u3/zD7qzBa/mWduY2lFtt2//8OM/3O9+z9B2t/5dLnc8kxCz7fb7u8MPIVrnTN8P0cM8W79/9zujQ9d1Mbpks/vd797f/wEFyQgvCwbRoM0zoehyfa6qVZm9G/sEkaPMQ5iGi/rDd394c7zLMy4kSym4pGWJjNYE448fPpZlKXOx2W25KO/vf/jdD38UvBS8Pu7eHbcfnE7Qwr///b+Zx8EaBZLdbGrOGQb43/zh3+EklB5CMFkutps7CDIEZUruf/3P/w8EIQQAGeesjyGExWvmXGCM53m+WKxTgosHByQUY2JUnM/XaZwJplqZ4/G4Wm02m81+vy+KCmPaNj2CXIqqLDZlWXofvXMxxqWI7/Xl/E//9E8hpHmeEfotPbuEwa7Xa9c19So/HLaD6i7NRWu9oEUul4u1GmE4TZMxalFECSFaW5AQACAXv9mkx3H88u3LOI55nkuZM0Kfn58ZodHZ6/U3d/FysnbOaa3vjg8PDw91sc54EXzkTFDCAADe+59++qltWylzQmhKqSiK19dXY4zW9nw9iUxACBhHAbhZDTKj49x33XWzWfmgCUG35jJNo8z4wt29XF6cVxCm1boyRi2OsLLKIYRFUUFAg4fBJ+ectXq7eWC08A4Y4xACjGOIHGEegIgxXtoXp/G3GdDhcHj79n3wsK43ICGM6Nu374Zh+Mtf/oYw2B0PjJNb28QEAUDjOEuRL7/gcrOc53kce63nmLy1tizzdVUvjpl+aNv25mL4l5/++/n2lIDNMrlarcZJGQ0YLdvbxagZBH96eZqGDgE/tI1g1OiwZLpWq02WFSHA/f5+vdojzBJARZVjBv72018uzQuXzDj9+vqMEFgCF1ob5xzn3Dnz6dOXlJbdVwIAFgu69/7x+dvp9OK97ft2HMeiKOqyXK02Uz8IysqyPB6P1+sVY3y73R4fHzEBCYTPn38Nzhvt2rZFKBEKOZPDMMWQnHPTNPzu+++Od9tx6mRGnNeMkTzPuv76evqCiZ/V1XsNQEwp5VlZlavVaoUQXBK21mpjFUKAECIky6tSCFbXtVIKgCglb9tb2zWMkXkeCUGEoJQCQkgpdbu137495XlRVzvOs93umGerGLDWfr06lMVqu93Wdb1UEpZlmRKcpsk5F0I6Hu8Xleu3qbkQ2+3We5Ai9g5Mo5lGTbAsqp0UlTGu70cIUZ6X3vt5nrXWXdcJLN89fCewSBbe796s8k2RVeti3favzy+fX16/zKozduIC//zLX73Xh91qv91gjPe74+9++ANnJWer92//VBa1Uqbv+1tzKcpMCFFVVVFUy/+71nqxXb+8vLy8vEAIi6LkXC49hW/fvlmtCsrAu/d358vLt8dP3lut5+fnxyXZD+HCzvGcc0LxNE3e+8PhUFX1wqW93W5a6/V6izE+n69FXmplPn36ghBQetRm2mzruq5fHl+mabLOPD5+zTJBCOKcJhAXQMjD/Vvv/bquiqIwxqzXawAAhDCBEEJYtB8I4TxPi/t4uaFuNivGSD/1KYWY7MvLUwKxruulZrau1/v90Wg7TfPimV3qZpYLpZQ5wCBC77xuuwtlANFwbV9ezl+ds957jCiIqKo2jGb1ekUo+q//9b+cb68yoyn54HSW87ISfd/AmBghSqklBGutrarqcDikFIRgRSkYIyk5Y2alO6W7hzd3SzLIO0cI0WZGFAkhlgkXY0xrbZSW/zrURpAEF4qshAm2bYsxFIxiALvblCKtq908uWm07999DxKbRkMIgTBtNpuiKL58+fzy+iQk45w6ZwhBEML9fmetpRTLjBOKIITH47EsS2utc66qVuv1duhHpTRjzLu4WL+ttd47CEEIsetGTLPd9n5V78dBDf2UZZkxBiEAQHx9fV5qvdu2pZQQzKfJrNd7a0KWVc1tyLKKYO6Ddc6MYx+CZ4xijDnnUkrMqLXaWk0o6vv+drudz+em66QoN+tdXa+3mz3nvG1bCGGI3jnrjH54eFg2u/V6TQghlOaidjplstps9qdLszs8EMzbpg8OjYPabu68iV07BBe+e/ddSsl7zxhzzn3+/Jlzybnsu1mKoixX+90RQvjt2xelprqurfEIUSYyLiXE1PhgjV/m4Fq54FNZrhmVlHDvgzVxKTQFKD0+f1s8rVVRrtfrQmaccADS7drGAOpqE1x6eX6dpgEh8HJ5ut1O/dBYb32yCQQXtLITF/R8Pjnnslx4b3nGf/rpbz641Wqz2x0QZM4mCNiq3iMoMlmR86WtquJ4f396eXXebTbbaVIsIogRBAQiSDCLMGLEEcKIp6Wz8dvXx2lS+/1+GKayqDjnz4+3zbZadCGlFGQkQoAxRhha6yHAEKE6z70PmHFn0+l0IoQyxkjFKOVSeucMxphx8vXxE2c5xmB/2M7zlCAqi9XrySwLDQAIITTNPWciy4RzLrqgJ6O1QWhw1lLBrNWEUp9S8JEQtoS7QggQgW5oRcYTjMZZ6ANIaHfYt23nTdxuN13XLYl/7+N6XVBKL+cb45QxaVKIMb5797brmzAYLihCCFPUDd2sFMF4HLuY7P/48397+/Y9IfDhzV4I8dMv/7JkalIKw9jneQ6BSdfUtBfOMWN0Vt16tYMQ19V2nmeE2Ol0Kqtit72fpmkcJusMTDEm1/UXCCHnNcaYEeocnOcxxogxDSFsj0c9awTJ+XomBImcXi+Nc65pNIwYBlpkq3dv3lCB+6kVUnZDn5LHODDGIEwIA4wRIZAxao2tKmaNM8oumEsA4jB39UpoPcaA1pvauWSMWa2P6fxFKaX0wDldr9cQ4qGf6roOzr/5/gfOpDVOqaFpfpt/YyQIRpQRH8zl9pUxURQFAHBJIy8Ur8Vn13XNosTu98cQ3GL68d5XVd33/TjdjB0TcJkUGGPvo3fBG7+ARpZCaqXUrKZxHI0xaxSiTV03/Nt/83fTPDy9fIEouWhigLvtnWAUVHxs9V9++h95Lp0fEbTGTktB6Dj2IQSMU9udXRiLvBJSEsLGfsAYIwyKsvj29DiOA2Ms2zCCSQjJed2NHWGUEDKMHWMMQD9NHQCRcTpOHaGQC7lA8zDGeVYxmhFOrbUQMJggxQhDvt/eDcNQlvk4vy7NLAiRGCMlnHNex3XbDNtVtVqtfvn1bymlf/Onf9u2oxRZiMwYQwnjXO52dwiR55evdbXjxAjKQjTWKgAABHgli6+fvv7Df/iHUtTP314pEJLl8zQhAhkz19tt1N3Dh+9vt1sIochlAj4ll+WZ9/52a4PL86xab+qvXz8hRO/uHvrhDCC63c5VuVXKgES8d1W1SSlY4wFASs2bbSEz1jXeOWeNU8o07TlErY2/NbTtTiG4LJfrsPr65dvlcpEZAyD6YBACGEMAgHOh64Y8lwSL/bH++vVrjH63Wp1Op5TAer1NKX388OZ6PQtGlO4wxjKjlMpM5hDFlNLtdvn++9/F5GfVUkqLIptVb60lCAYaIIR5nndd3zQtoTBF5EOECGVZRinV8zwNPaUUerWqKhu81hqicL69CCqk5EvlsuTcGPPLLxcpss1mZ5QFIBKCEI4+eO8dAIBzbm2LMEgoTHqkgiulnB99mAjfMia8gxjJXKydbRJw09wClDinAIbnl68AIM55HmUCjhBUFEXTqCWIMQxDWa4ZI003xuQRABACijHC0HuvrbtcXx8e3qSIAYiPj49FkccYbLC3rl2ATiEEhBDnwlibUiqzUimVZznBPISQZyKlMAxj8EzwMsuq87mRWXW3fzeN+nq9ViuBEGJMSMmX2yPn3DnbNk2KMCWIMZ4njdeb2+10vb4mHKO3Wmsf7BIFq4pqu949Pj6/ebvTWlNK3759GwMYhsE5hxLeH9/sd/ffvj22t9l78O7toarq+f97izFSSruuizECEGPyCQTO8jxbW2ut8YxyRmXbDJRygGNMVumpLAgXQqnJhaCtl5LfmhZhXMjs5flGCM0yOYwtJ/zNm3dN00yTYlS8jq9lkUUfvLf90N5lWVkUcTDex5RQWVZvDu9ezs/fvn5ZrUsIuNHegplz8Pf/7h8GNXTDxZ9PjMm+Hx8fv06TohRfridKaVXWry/n/SpbrVa7/frb1xNjGYRqGLuVqQ6H3ctLdC48/PjGOdePQ4zeRxhjsC5Qls2zYVxCApeHdpwcAAAjosarMaZaV8upESO4qtZSyhj96Iz34HoZhl7t99sI0vV25lTMdlSXUet5XdeIAJ/0l8dfEELee0KB9z4GUFXly/Npnmf1W0ufxZgV+fp4eHu7XSEKKM8Ka713IESQl+XheI8RVUqlgKJPMGHBskwUGFKUqGRVimToZynL4OHz0xkApLW9Xm7GDtfrqw+mKLIsE0uQN5MFhBAhJGXuXQwhZbLYb3aMcghRlmUQ4OUYsThjhRAQgrLKEPbOT+M4hBBCCMPQLfda7z0AEcLU9+0w9pigFJBRPrhotRn6fpxHTBHLudbmer0uhIPv3n23WFO9twHEfhp8iqvtKkH4cj59fXq8Ns3U61WxKYv10pExz3PTNEKwxc/hXEIQz/PMOc/zHCM+G3u+3kY1I4QYYz6EWStl9GZbxqS5gL9++pdvz58RjoSgui6X3ZRSuvgJtps9xhQkbIw6n1/HcdxudxiTZTK9wPznebTWEoSrqqrrejlxLxZXCCHGmBBGKV8uu58+/RJjiMlzTgGMT0+Pxk7rdbVYgFNKfd9e26ao6qpe9/1YFJWUOaUcY0woYozGZPvhlmVZXkijtJ7Vfr/d7Tbe+0nNSk1932ttMcb//Z/+ezc2m80qpcSZXK83maz2u/s3Dx/Wq21VrQDAEKXPX35FBEIM2r7BFDlnOKc+koRwP/UeGJ4jSP1sRpbRsi4QgUVVOh8IpbvDXltj3LycF50LXdctNToL/G6cGutmracsE1IImEBV1MGDGHzfdVLKGONSd5RSEkJggCDEGa9A4ikShCiCJMaYEowBFsUqxrjbbWbVvJ6/CAkh8IJxRrjVtq7KTBLnBowdpQii5Jwbul5ra51OyRs7EwwySQXHIXhj1dKTl2USIXg47ClF3rui+K14hRDy6dMnhIBSakEspATevn0/9LP3QWujlPYuYkSXMa1z7tPnX56evmVZ9u7du9VqxblYLvFqMpJnnAqYAEE4ON933dgPnFHJmeSMc76sBTGCaTQQ0LJYpQTV7ABAGFEA0Gq1Qgg0bQsAwkRQJu7v34zzcD6/ajcBEpYuvTwrl7NRkZWZyL31ata32+18fm7a0+12Pl+ep1FJKRcoatNeQ3Ra66qqVvVmtVoRwtbr9X5/0NqEkChheVap2cYI9vvt588/T3NDmP/05S+ruuAMPz1+1vNUV1WRy/12RwnabtcIAa3nuq4/fvwYI+i6YUGobbfbBUbkvZdSZjyvixWjcql7TMgB7LuhOZ/PhDAMEaeMUXq9vMxTN08TxYRiQpGIPlFKb83l06dfpnnoum5d1avVCiGEIUoRIEQgxAiB/X672WxCdF3XKaXyIvvw4R0hcJqbFFwmWHSeMTb045KW+vjdj4zL0+U6zkMEseluEKN6vUoAZkVOKJV5lpcZABHA6KLbHnYQJYRQjKgsdhAwELC11tipqKtFfhiGIcsyreeu6zabFUYgEzzLsgVDqbUex37p5sWIpgS01s4556zW0zB0Ws+3882bWOUryXiM/nx+1Vqt1+uFJLSswN57weRht+/bwepgDZAsJxSl5EFMGNOyLKtyRTDjTOZZ+eXpq3Nunufn52dr7Tj2Cx31fH69XE4IgaUVq6qq2+223tRVVV7bmw2OMqzUlFJaeH1WWzWboqh26w1FNPkUrMu4yKWsy3JVFbLIYozeB84l54ISPky9ceru7q5prgDERXoEIN7fH5Walr1mOYt8+/Ytz/O6rrMsC04LRhGKmCSEgFLTvxJdx/uHh7IslVK73a4sy6ZrIYQQksfHp7raqNl6n94+vLPGd113vV77vn9+fgUAZFIuGJ5yVWOM99vt0jlwOBy6oZ/ULDIxDANCQGud53mZZwn4y/V0/7CfpmlZvgpZvHt4e3f39nrutIoES2sCAEAINgwdAEDKfJ7Ur19+/umnvzw9f3Fep+SdM8tIYVVvBC8FLx8fHzHGnJVVuUeIZIWs11XbN/3YpZTapkcICyGLLMvzfLPer9e7PFtZ6/WstBoQitbNbXc2dhzV0M9tP7XD3CGCqlVZ1/Vut8sL+fXrZy5otS5u7bXpbgBBQnmWlzIrAEQhArLe7Z1WSqkFzPz582fGRV3X06Qp5Zgk7xMACAKMECVYUgIZLYJXlHqMsZBkGLqU0npT+KB80EqHBcJb1/Wq3lxu5xQjpTSEZLQDCDIqOA+5lIJnxpjFWE4IWWykUkoEqfMzRGmeR0opxIRwulB6UgrGmIXX/q/v06qQ2d3+bhg67fRsxggjAqifhphAAsBPrixlCiEsyRaIrHWcI4SQseo3q7y2khSTmqw2zljCcAjudHpxzmV5rnUECTImEIr//Od/PBwOCJEYCMZ4nNoirzHjY9czkSk9IQJ99AG4lMDtdirL8nI5b7dbKUvnDEiQUo6xvz/eN82tH1oQuphw37ePj9/2+8P0pV/GWMN4meYxBk9FLqUMIQWPKOHKzDGFEECMgBBCCFvS+cHrp+cvAKCyqLMsg0QmWHTDrSwqCIiUfJ7s+XoaZ5FSsNavsoLRlEAMwYXoMf4tnTRNUy5zSgSBwczKGONjEEJwvvfe++AwJdaNmMiE7cvLZb3eS8nLou6H9vHxpcirutpJKYdWpeR8NLeu9cGvsupyfdmkjXEwJt0P16yghMIQgjUuhOxyafp+4FxiTAFA4zi27aItsbZtIUyUYgih9/719ZVSijH0ISEM5nkOAWzWByGEOZ0W9ujteh2GYZwmIUQI9IcfPnbN4B0ojuvm1g3DTEmOkEleQwSXVmtr/d2ucDGM4xCTp5RjTCkRanZSyroufZgITQk5kDDDwtmU5zJE47y5XDtKRFUV3nttRghYSgkhSBkOJmo9AwAAiH3fp4hW9b7rhvV6+9e//svf//3faz1/+fLl7Zv3jAmtG5BaIbIYIwAQouS9vd1O3tsY7aKQN7dO6WnRfhCCglMEye12fT1pSnFVlYuKDkCkjMTkQYq324UQ5r2nlIYQOaWcpRAcRIEQ5FxICe7ut6+Xk/Vos9vNWlmgjZ8Dtj6pWfXr9VorizEv8k1MHkHqPfAeEMQhS3mJ1dx8+vLIBCE4u91u2lhtTCaLruskXy2l8EVRZLKw1lMiDvs7CJJSLoR0f//m29NXzvmbtw9d101TX9dFjBETOAwdY2JV7yCESg8xOmtTWZYAAKUshPDh4WEYui9fPq3Xa8aY1vM42ug8jHBUoxAyulDlldKt91apibOcQBR9wASv12uEUNPcOOdVVZZl6b2v6zUhrG1bhDBGmEBUb1bDMFFKGBNlWSs1WW8gijHCLMu8d4fDwcwKMzpb7b2vNyWBQlR7AJBW1ge7zLnmeX59fW2aZqmLO19OeS6llMMwCC4ZLoaxTREwxq0JmSxCdADEWSmjo7OEE0Gh9D6mlCBBjGcJYsEyyVMuC6M0ALAo8qHrQwiMUq1miBGEyHvvnEGQMiEQSDF5jLANNsYEAMiyrGuH7z++T95X1ep6e4kAZLnkjGH8W2aYELo4VQkhgYU3bz+o2QTgTD+MU5/leVmW0UHv1DRHyqDSw8vLk8wE4WBxTzdNBxNY4kXLTcnZqJT6h3/3nyDEX79+5fx0OBwgSv3YeW+rquCcCxbLrKaUMwbL/W6cGoDRPOtb13ImIUKY0UJKNfnr9ZISghAEYL9++3maG0LYZrNZwGgPDw8JhHEc8lzemsvxcM8YabuRceqDQQHutsdhvAjx/+vpTJbjyM0gjLWAQq1N9iJS4wmF7JgI3+yL3v8t7PBowrKGZFNsdteOffEBHj9C1QH48WfmlxwA4JyRICqlKKUAxnEeqrZkjGm5Hu76edmut4sxMnh0Oj1o7Y0JXbOTasaYClEJIQ53R2sigYiVdUEGXOAY/SbHYbjWTem9dSGdTnsIybYt7z9uCcYQbdsJ50Df90oprTdWshA8xriqmFLm46k6Hj78/u3b6cPPzivvY1GQbVve3t4I4TGCt8szYywAe51+1KVo27aqe4wxxWXX7Z6evmMCx3H48uXL+XwOPnX3jXMOACAED9FZpyEsnXY+KBgLiqiPoKoaY1dCyMPDw9PLU13XZcW2bVFm5VxQjudpKeu+qiqtpfceQrhtsmm6eRl4SZxXu3IHAfTejqPe5KzNiipeppTyXZwv/hSicy74xBgjuDDGaa0xLigpQSJV1V6vt+E2t22HECK4qKrKWgtR9MHEGKZp9MH+0diJS869d865/L7HEEGIy7IiuFiWBUKcBbnMWYMQAkQxgbfpchvetJF12zRNZUPOO1QAgJh8iC5npbz3MUafImOs5BymBGJS62atpYzQgkgpt227XgejndY269Z56bKuq/f+4eHU9y2AAYF4fnqepklruW0LL1nbNRhDhMBut8u5XIxhjP79/Z0S9nh66OqurttlWS6Xi5ImRliJZpqWYRiklAAmWpBxGoL3wfvD4ZDJVOM4zvO8LBvnZSWauq4hTAB6Y7cfby+5CUkrk6KHIAIYIYTOBSmVs8kqG6JPKf2PzwZxlopyRwahoCjIsk7jdDNGZTwACMAqbYyp67quq/f3t7fLK+eFMSZbIiDMXnQshGjbtiiKcZznYcxw36pq+r6PEDiX7u6Op+NjCKHg5D9Pv3799z9WNSppx2Fp2zuM2DytzoV5Xq0JCQSEAUKgKIgxivPi8fHBOZuC8daAGKKzat2CNQVGWq5ayxiDMeZwOJxOJ2MMJqiuRa75AAB03S4bs19fX6y1d/udtbqqqoydxZjKRUYX52GMzscYMMZCiJKLEIL3kRd9isWnj5937a7rOs659ZFgjhDoui54uOv3SimlpKh4NjZZE1hRAYDycoXzkmAOIyaI7nY7xilEyXtnrUQJrNsUoo8phBAgBAkCqdUw3XIjQx4NISBdu//TT38+7H+CgPz9b1/WRXkfC5rXb75pOmMVIXn+hhBCiNIwXp3XPjhRca3l9Xp1NoCEMghSa3m9XRAGQnDGirZtC8q1Nll8idEjDGLyxukIQsGpc25dVwhxXuOlBCktpmnSztoUEMH9/v77+fdff/sn4olVAMAAEIgp1W3nbKzr7rD/oLU3Unnj27Zv2zoBw0XC1He94CV1ziFEpDQYU2eDsfrH2/P75bLMc1PXz78//zi//fKXv7Z1DwLWWocQ/k/Yi9F3fROTd95AmHa7Xf4QreXXr/+Sag3ej8MVQdjWzTov422w2kAAur7NJC4heIweY7jf3aOEGGOMMeNdAOk2jTHG+/t7xqm1LsfvnTMphezrUkpr5aqqvru7Ox4PJaPZI1WW1TjM3sVdfy/KluKCkiKEpNR2fn12we1Px0zOVkp579uuxpCs86aVcs5lF0juhREVD8ExVt7t7o1x67qmlOZlmufZWhdCstapTVPKMWJ5CyWlFIz/obxkoQEVlCOE7+8PQtTLOOVCL601xdBbndPa+YcQgjgvnHPBx5QggoUQNeciZ52ul0vJ28+Pv6RIxuuCMS4rUZTCGMMYwxhzXjaiYoQWhBilzuczwcWyqGVejXcQISHqSrS5mGa4vQMYlF5LUYRgRFXk/EXf958+fa7rrqDl8fDw4fRRMPHzx0/XaZCbbpueEoYQyj3bOd5cMkEJwxiv67qu67ZtyzJlB9uyLPn0NtpZ4/u+pwWe5+E2XVJyEIEEIgAAY5oPgfyqBDB671Pw1/c3COLdrqMYxeC8dfM0UMqKokAISbVN0yT1himiRZFSen560UoRUmhto0+c85RgVVVSypKLijfzvEmpOauPh8fj8dS1903TqU3LTWutX15ezj/O355+W9QYgknAPT19n5ex69qyZKIh83K1bgMgtG1b1SUm8Pz6DEDMyFpj1TyPr6+vtRB1XTtvsrcDIVKW1bIsWsu6KUM0bScePx77tsrjGkHYKOuM1VIf7o8QhMO+l6tEgDR1TXAxjmOeI9dtK8uyYARizJnY7/eEkLfXF6U2SjFCaFtVQai3xjvTti1jLJv/KKUvLy8hJEqZNub19RWipLW0VouKpRQAjMYqpeU4DRAmhNJ/AbAdD+Sarn9RAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/.ipynb_checkpoints/evaluation_on_coco-checkpoint.py b/ViTPose/easy_ViTPose/.ipynb_checkpoints/evaluation_on_coco-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..7bb2e0a722ecab7967dd931321d19164fcea9b3f --- /dev/null +++ b/ViTPose/easy_ViTPose/.ipynb_checkpoints/evaluation_on_coco-checkpoint.py @@ -0,0 +1,92 @@ +# Reference: https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb + +import cv2 +from easy_ViTPose.inference import VitInference +from pathlib import Path +import os +from tqdm.auto import tqdm + +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval +from statistics import mean +import json +import argparse + +def parse_arguments(): + + parser = argparse.ArgumentParser(description='Argument Parser for infer') + parser.add_argument('--model_path', type=str, + help='Path to the ViT Pose model') + parser.add_argument('--model-name', type=str, choices=['s', 'b', 'l', 'h'], + help='[s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H]') + parser.add_argument('--yolo_path', type=str, + help='Path to the YOLOv8 model') + parser.add_argument('--img_folder_path', type=str, + help='Path to the folder containing images') + parser.add_argument('--annFile', type=str, + help='Path to the COCO annotations file') + return parser.parse_args() + + +def evaluation_on_coco(model_path, model_name, yolo_path, img_folder_path, annFile): + # get image IDs of images in val set + # Opening JSON file + f = open(annFile) + gt_annotations = json.load(f) + f.close() + + image_ids = set() + for ann in gt_annotations['images']: + image_ids.add(ann['id']) + + + model = VitInference(model_path, yolo_path, model_name = model_name, yolo_size=640, is_video=False, device=None) + results_list = [] + + for image_id in tqdm(image_ids): + # run inference here + img_path = os.path.join(img_folder_path, str(image_id).zfill(12) + '.jpg') + img = cv2.imread(img_path) + + + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + frame_keypoints = model.inference(img) + for key in frame_keypoints: + results_element = {} + results_element['image_id'] = image_id + results_element['category_id'] = 1 + results_element['score'] = model._scores_bbox[key] + results_element['bbox'] = [] + keypoints = [] + for k in frame_keypoints[key]: + keypoints.append(float(round(k[1], 0))) + keypoints.append(float(round(k[0], 0))) + keypoints.append(0) + results_element['keypoints'] = keypoints + results_list.append(results_element) + + + # Define the file path where you want to save the JSON file + file_path = "results.json" + # Save the list of dictionaries to a JSON file + with open(file_path, "w") as json_file: + json.dump(results_list, json_file, indent=4) + + + #initialize COCO ground truth api + annType = 'keypoints' + cocoGt=COCO(annFile) + #initialize COCO detections api + resFile="results.json" + cocoDt=cocoGt.loadRes(resFile) + # running evaluation + cocoEval = COCOeval(cocoGt,cocoDt,annType) + cocoEval.params.imgIds = [int(i) for i in image_ids] + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + + +if __name__ == '__main__': + args = parse_arguments() + evaluation_on_coco(args.model_path, args.model_name, args.yolo_path, args.img_folder_path, args.annFile) \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py b/ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..7edfb072fc1f7543ab629a1d9684c59fa9c36fac --- /dev/null +++ b/ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py @@ -0,0 +1,188 @@ +import argparse +import json +import os +import time + +from PIL import Image +import cv2 +import numpy as np +import torch +import tqdm + +from easy_ViTPose.vit_utils.inference import NumpyEncoder, VideoReader +from easy_ViTPose.inference import VitInference +from easy_ViTPose.vit_utils.visualization import joints_dict + +try: + import onnxruntime # noqa: F401 + has_onnx = True +except ModuleNotFoundError: + has_onnx = False + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument('--input', type=str, required=True, + help='path to image / video or webcam ID (=cv2)') + parser.add_argument('--output-path', type=str, default='', + help='output path, if the path provided is a directory ' + 'output files are "input_name +_result{extension}".') + parser.add_argument('--model', type=str, required=True, + help='checkpoint path of the model') + parser.add_argument('--yolo', type=str, required=False, default=None, + help='checkpoint path of the yolo model') + parser.add_argument('--dataset', type=str, required=False, default=None, + help='Name of the dataset. If None it"s extracted from the file name. \ + ["coco", "coco_25", "wholebody", "mpii", "ap10k", "apt36k", "aic"]') + parser.add_argument('--det-class', type=str, required=False, default=None, + help='["human", "cat", "dog", "horse", "sheep", \ + "cow", "elephant", "bear", "zebra", "giraffe", "animals"]') + parser.add_argument('--model-name', type=str, required=False, choices=['s', 'b', 'l', 'h'], + help='[s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H]') + parser.add_argument('--yolo-size', type=int, required=False, default=320, + help='YOLOv8 image size during inference') + parser.add_argument('--conf-threshold', type=float, required=False, default=0.5, + help='Minimum confidence for keypoints to be drawn. [0, 1] range') + parser.add_argument('--rotate', type=int, choices=[0, 90, 180, 270], + required=False, default=0, + help='Rotate the image of [90, 180, 270] degress counterclockwise') + parser.add_argument('--yolo-step', type=int, + required=False, default=1, + help='The tracker can be used to predict the bboxes instead of yolo for performance, ' + 'this flag specifies how often yolo is applied (e.g. 1 applies yolo every frame). ' + 'This does not have any effect when is_video is False') + parser.add_argument('--single-pose', default=False, action='store_true', + help='Do not use SORT tracker because single pose is expected in the video') + parser.add_argument('--show', default=False, action='store_true', + help='preview result during inference') + parser.add_argument('--show-yolo', default=False, action='store_true', + help='draw yolo results') + parser.add_argument('--show-raw-yolo', default=False, action='store_true', + help='draw yolo result before that SORT is applied for tracking' + ' (only valid during video inference)') + parser.add_argument('--save-img', default=False, action='store_true', + help='save image results') + parser.add_argument('--save-json', default=False, action='store_true', + help='save json results') + args = parser.parse_args() + + use_mps = hasattr(torch.backends, 'mps') and torch.backends.mps.is_available() + use_cuda = torch.cuda.is_available() + + # Load Yolo + yolo = args.yolo + if yolo is None: + yolo = 'easy_ViTPose/' + ('yolov8s' + ('.onnx' if has_onnx and not (use_mps or use_cuda) else '.pt')) + input_path = args.input + + # Load the image / video reader + try: # Check if is webcam + int(input_path) + is_video = True + except ValueError: + assert os.path.isfile(input_path), 'The input file does not exist' + is_video = input_path[input_path.rfind('.') + 1:].lower() in ['mp4', 'mov'] + + ext = '.mp4' if is_video else '.png' + assert not (args.save_img or args.save_json) or args.output_path, \ + 'Specify an output path if using save-img or save-json flags' + output_path = args.output_path + if output_path: + if os.path.isdir(output_path): + og_ext = input_path[input_path.rfind('.'):] + save_name_img = os.path.basename(input_path).replace(og_ext, f"_result{ext}") + save_name_json = os.path.basename(input_path).replace(og_ext, "_result.json") + output_path_img = os.path.join(output_path, save_name_img) + output_path_json = os.path.join(output_path, save_name_json) + else: + output_path_img = output_path + f'{ext}' + output_path_json = output_path + '.json' + + wait = 0 + total_frames = 1 + if is_video: + reader = VideoReader(input_path, args.rotate) + cap = cv2.VideoCapture(input_path) # type: ignore + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + cap.release() + wait = 15 + if args.save_img: + cap = cv2.VideoCapture(input_path) # type: ignore + fps = cap.get(cv2.CAP_PROP_FPS) + ret, frame = cap.read() + cap.release() + assert ret + assert fps > 0 + output_size = frame.shape[:2][::-1] + + # Check if we have X264 otherwise use default MJPG + try: + temp_video = cv2.VideoWriter('/tmp/checkcodec.mp4', + cv2.VideoWriter_fourcc(*'h264'), 30, (32, 32)) + opened = temp_video.isOpened() + except Exception: + opened = False + codec = 'h264' if opened else 'MJPG' + out_writer = cv2.VideoWriter(output_path_img, + cv2.VideoWriter_fourcc(*codec), # More efficient codec + fps, output_size) # type: ignore + else: + reader = [np.array(Image.open(input_path).rotate(args.rotate))] # type: ignore + + # Initialize model + model = VitInference(args.model, yolo, args.model_name, + args.det_class, args.dataset, + args.yolo_size, is_video=is_video, + single_pose=args.single_pose, + yolo_step=args.yolo_step) # type: ignore + print(f">>> Model loaded: {args.model}") + + print(f'>>> Running inference on {input_path}') + keypoints = [] + fps = [] + tot_time = 0. + for (ith, img) in tqdm.tqdm(enumerate(reader), total=total_frames): + t0 = time.time() + + # Run inference + frame_keypoints = model.inference(img) + keypoints.append(frame_keypoints) + + delta = time.time() - t0 + tot_time += delta + fps.append(delta) + + # Draw the poses and save the output img + if args.show or args.save_img: + # Draw result and transform to BGR + img = model.draw(args.show_yolo, args.show_raw_yolo, args.conf_threshold)[..., ::-1] + + if args.save_img: + # TODO: If exists add (1), (2), ... + if is_video: + out_writer.write(img) + else: + print('>>> Saving output image') + cv2.imwrite(output_path_img, img) + + if args.show: + cv2.imshow('preview', img) + cv2.waitKey(wait) + + if is_video: + tot_poses = sum(len(k) for k in keypoints) + print(f'>>> Mean inference FPS: {1 / np.mean(fps):.2f}') + print(f'>>> Total poses predicted: {tot_poses} mean per frame: ' + f'{(tot_poses / (ith + 1)):.2f}') + print(f'>>> Mean FPS per pose: {(tot_poses / tot_time):.2f}') + + if args.save_json: + print('>>> Saving output json') + with open(output_path_json, 'w') as f: + out = {'keypoints': keypoints, + 'skeleton': joints_dict()[model.dataset]['keypoints']} + json.dump(out, f, cls=NumpyEncoder) + + if is_video and args.save_img: + out_writer.release() + cv2.destroyAllWindows() diff --git a/ViTPose/easy_ViTPose/.ipynb_checkpoints/requirements_gpu-checkpoint.txt b/ViTPose/easy_ViTPose/.ipynb_checkpoints/requirements_gpu-checkpoint.txt new file mode 100644 index 0000000000000000000000000000000000000000..fa47af223c3eaeb1abe01177ed6c6912001eb425 --- /dev/null +++ b/ViTPose/easy_ViTPose/.ipynb_checkpoints/requirements_gpu-checkpoint.txt @@ -0,0 +1,3 @@ +onnxruntime-gpu>=1.13.0 +tensorrt>=8.5.1.7 +torch-tensorrt>=1.4.0 \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/Dockerfile b/ViTPose/easy_ViTPose/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..c7454a2c7f6d4da54671961792d80cefa978bdf7 --- /dev/null +++ b/ViTPose/easy_ViTPose/Dockerfile @@ -0,0 +1,11 @@ +FROM nvcr.io/nvidia/pytorch:24.07-py3 +COPY . /easy_ViTPose +WORKDIR /easy_ViTPose/ +ENV DEBIAN_FRONTEND=noninteractive + +RUN pip uninstall -y $(pip list --format=freeze | grep opencv) && \ + rm -rf /usr/local/lib/python3.10/dist-packages/cv2/ +RUN pip install -e . && pip install -r requirements.txt && pip install -r requirements_gpu.txt + +# OpenCV dependency +RUN apt-get update && apt-get install -y libgl1 diff --git a/ViTPose/easy_ViTPose/LICENSE b/ViTPose/easy_ViTPose/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..29f81d812f3e768fa89638d1f72920dbfd1413a8 --- /dev/null +++ b/ViTPose/easy_ViTPose/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/ViTPose/easy_ViTPose/README.md b/ViTPose/easy_ViTPose/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0aa9c2b96eacf4eee861c8ecaeee61556ae5f0c6 --- /dev/null +++ b/ViTPose/easy_ViTPose/README.md @@ -0,0 +1,275 @@ +# easy_ViTPose +

+ easy_ViTPose +

+ +## Accurate 2d human and animal pose estimation + + + Open In Colab + + +### Easy to use SOTA `ViTPose` [Y. Xu et al., 2022] models for fast inference. +We provide all the VitPose original models, converted for inference, with single dataset format output. + +In addition to that we also provide a Coco-25 model, trained on the original coco dataset + feet https://cmu-perceptual-computing-lab.github.io/foot_keypoint_dataset/ +Finetuning is not currently supported, you can check de43d54cad87404cf0ad4a7b5da6bacf4240248b and previous commits for a working state of `train.py` + +> [!WARNING] +> Ultralytics `yolov8` has issue with wrong bounding boxes when using `mps`, upgrade to latest version! (Works correctly on 8.2.48) + +## Results +![resimg](https://github.com/JunkyByte/easy_ViTPose/assets/24314647/51c0777f-b268-448a-af02-9a3537f288d8) + +https://github.com/JunkyByte/easy_ViTPose/assets/24314647/e9a82c17-6e99-4111-8cc8-5257910cb87e + +https://github.com/JunkyByte/easy_ViTPose/assets/24314647/63af44b1-7245-4703-8906-3f034a43f9e3 + +(Credits dance: https://www.youtube.com/watch?v=p-rSdt0aFuw ) +(Credits zebras: https://www.youtube.com/watch?v=y-vELRYS8Yk ) + +## Features +- Image / Video / Webcam support +- Video support using SORT algorithm to track bboxes between frames +- Torch / ONNX / Tensorrt inference +- Runs the original VitPose checkpoints from [ViTAE-Transformer/ViTPose](https://github.com/ViTAE-Transformer/ViTPose) +- 4 ViTPose architectures with different sizes and performances (s: small, b: base, l: large, h: huge) +- Multi skeleton and dataset: (AIC / MPII / COCO / COCO + FEET / COCO WHOLEBODY / APT36k / AP10k) +- Human / Animal pose estimation +- cpu / gpu / metal support +- show and save images / videos and output to json + +We run YOLOv8 for detection, it does not provide complete animal detection. You can finetune a custom yolo model to detect the animal you are interested in, +if you do please open an issue, we might want to integrate other models for detection. + +### Benchmark: +You can expect realtime >30 fps with modern nvidia gpus and apple silicon (using metal!). + +### Skeleton reference +There are multiple skeletons for different dataset. Check the definition here [visualization.py](https://github.com/JunkyByte/easy_ViTPose/blob/main/easy_ViTPose/vit_utils/visualization.py). + +## Installation and Usage +> [!IMPORTANT] +> Install `torch>2.0 with cuda / mps support` by yourself. +> also check `requirements_gpu.txt`. + +```bash +git clone git@github.com:JunkyByte/easy_ViTPose.git +cd easy_ViTPose/ +pip install -e . +pip install -r requirements.txt +``` + +### Download models +- Download the models from [Huggingface](https://huggingface.co/JunkyByte/easy_ViTPose) +We provide torch models for every dataset and architecture. +If you want to run onnx / tensorrt inference download the appropriate torch ckpt and use `export.py` to convert it. +You can use `ultralytics` `yolo export` command to export yolo to onnx and tensorrt as well. + +#### Export to onnx and tensorrt +```bash +$ python export.py --help +usage: export.py [-h] --model-ckpt MODEL_CKPT --model-name {s,b,l,h} [--output OUTPUT] [--dataset DATASET] + +optional arguments: + -h, --help show this help message and exit + --model-ckpt MODEL_CKPT + The torch model that shall be used for conversion + --model-name {s,b,l,h} + [s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H] + --output OUTPUT File (without extension) or dir path for checkpoint output + --dataset DATASET Name of the dataset. If None it"s extracted from the file name. ["coco", "coco_25", + "wholebody", "mpii", "ap10k", "apt36k", "aic"] +``` + +### Run inference +To run inference from command line you can use the `inference.py` script as follows: +```bash +$ python inference.py --help +usage: inference.py [-h] [--input INPUT] [--output-path OUTPUT_PATH] --model MODEL [--yolo YOLO] [--dataset DATASET] + [--det-class DET_CLASS] [--model-name {s,b,l,h}] [--yolo-size YOLO_SIZE] + [--conf-threshold CONF_THRESHOLD] [--rotate {0,90,180,270}] [--yolo-step YOLO_STEP] + [--single-pose] [--show] [--show-yolo] [--show-raw-yolo] [--save-img] [--save-json] + +optional arguments: + -h, --help show this help message and exit + --input INPUT path to image / video or webcam ID (=cv2) + --output-path OUTPUT_PATH + output path, if the path provided is a directory output files are "input_name + +_result{extension}". + --model MODEL checkpoint path of the model + --yolo YOLO checkpoint path of the yolo model + --dataset DATASET Name of the dataset. If None it"s extracted from the file name. ["coco", "coco_25", + "wholebody", "mpii", "ap10k", "apt36k", "aic"] + --det-class DET_CLASS + ["human", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", + "animals"] + --model-name {s,b,l,h} + [s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H] + --yolo-size YOLO_SIZE + YOLOv8 image size during inference + --conf-threshold CONF_THRESHOLD + Minimum confidence for keypoints to be drawn. [0, 1] range + --rotate {0,90,180,270} + Rotate the image of [90, 180, 270] degress counterclockwise + --yolo-step YOLO_STEP + The tracker can be used to predict the bboxes instead of yolo for performance, this flag + specifies how often yolo is applied (e.g. 1 applies yolo every frame). This does not have any + effect when is_video is False + --single-pose Do not use SORT tracker because single pose is expected in the video + --show preview result during inference + --show-yolo draw yolo results + --show-raw-yolo draw yolo result before that SORT is applied for tracking (only valid during video inference) + --save-img save image results + --save-json save json results +``` + +You can run inference from code as follows: +```python +import cv2 +from easy_ViTPose import VitInference + +# Image to run inference RGB format +img = cv2.imread('./examples/img1.jpg') +img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + +# set is_video=True to enable tracking in video inference +# be sure to use VitInference.reset() function to reset the tracker after each video +# There are a few flags that allows to customize VitInference, be sure to check the class definition +model_path = './ckpts/vitpose-s-coco_25.pth' +yolo_path = './yolov8s.pth' + +# If you want to use MPS (on new macbooks) use the torch checkpoints for both ViTPose and Yolo +# If device is None will try to use cuda -> mps -> cpu (otherwise specify 'cpu', 'mps' or 'cuda') +# dataset and det_class parameters can be inferred from the ckpt name, but you can specify them. +model = VitInference(model_path, yolo_path, model_name='s', yolo_size=320, is_video=False, device=None) + +# Infer keypoints, output is a dict where keys are person ids and values are keypoints (np.ndarray (25, 3): (y, x, score)) +# If is_video=True the IDs will be consistent among the ordered video frames. +keypoints = model.inference(img) + +# call model.reset() after each video + +img = model.draw(show_yolo=True) # Returns RGB image with drawings +cv2.imshow('image', cv2.cvtColor(img, cv2.COLOR_RGB2BGR)); cv2.waitKey(0) +``` +> [!NOTE] +> If the input file is a video [SORT](https://github.com/abewley/sort) is used to track people IDs and output consistent identifications. + +### OUTPUT json format +The output format of the json files: + +``` +{ + "keypoints": + [ # The list of frames, len(json['keypoints']) == len(video) + { # For each frame a dict + "0": [ # keys are id to track people and value the keypoints + [121.19, 458.15, 0.99], # Each keypoint is (y, x, score) + [110.02, 469.43, 0.98], + [110.86, 445.04, 0.99], + ], + "1": [ + ... + ], + }, + { + "0": [ + [122.19, 458.15, 0.91], + [105.02, 469.43, 0.95], + [122.86, 445.04, 0.99], + ], + "1": [ + ... + ] + } + ], + "skeleton": + { # Skeleton reference, key the idx, value the name + "0": "nose", + "1": "left_eye", + "2": "right_eye", + "3": "left_ear", + "4": "right_ear", + "5": "neck", + ... + } +} +``` + +## Finetuning +Finetuning is possible but not officially supported right now. If you would like to finetune and need help open an issue. +You can check `train.py`, `datasets/COCO.py` and `config.yaml` for details. + +--- + +## Evaluation on COCO dataset +1. Download COCO dataset images and labels + - 2017 Val images [5K/1GB]: http://images.cocodataset.org/zips/val2017.zip
+ The extracted directory looks like this: + ``` + val2017/ + ├── 000000000139.jpg + ├── 000000000285.jpg + ├── 000000000632.jpg + └── ... + ``` + - 2017 Train/Val annotations [241MB]: http://images.cocodataset.org/annotations/annotations_trainval2017.zip
+ The extracted directory looks like this: + ``` + annotations/ + ├── person_keypoints_val2017.json + ├── person_keypoints_train2017.json + └── ... + ``` + +2. Run the following command: + + ```bash + + $ python evaluation_on_coco.py + + Command line arguments: + --model_path: Path to the pretrained ViT Pose model + + --yolo_path: Path to the YOLOv8 model + + --img_folder_path: Path to the directory containing COCO val images (/val2017 extracted in step 1). + + --annFile: Path to json file for COCO keypoints for val set (annotations/person_keypoints_val2017.json extracted in step 1) + ``` + +--- + + +## Docker +The system may be built in a container using Docker. This is intended to demonstrate container-wise inference, adapt it to your own needs by changing models and skeletons: + +`docker build . -t easy_vitpose` + +The image is based on NVIDIA's PyTorch image, which is 20GB large. +If you have a compatible GPU set up with [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html), +ViTPose will run with hardware acceleration. + +To test an example, create a folder called `cats` with a picture of a cat as `image.jpg`. +Run `./models/download.sh` to fetch the large yolov8 and ap10k ViTPose models. Then run inference using the following command (replace with the correct `cats` and `models` paths): + +`docker run --gpus all --rm -it --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 -v ./models:/models -v ~/cats:/cats easy_vitpose python inference.py --det-class cat --input /cats/image.jpg --output-path /cats --save-img --model /models/vitpose-l-ap10k.onnx --yolo /models/yolov8l.pt` + +The result image may be viewed in your `cats` folder. + +## TODO: +- refactor finetuning (currently not available) +- benchmark and check bottlenecks of inference pipeline +- parallel batched inference +- other minor fixes +- yolo version for animal pose, check https://github.com/JunkyByte/easy_ViTPose/pull/18 +- solve cuda exceptions on script exit when using tensorrt (no idea how) +- add infos about inferred informations during inference, better output of inference status (device etc) +- check if is possible to make colab work without runtime restart + +Feel free to open issues, pull requests and contribute on these TODOs. + +## Reference +Thanks to the VitPose authors and their official implementation [ViTAE-Transformer/ViTPose](https://github.com/ViTAE-Transformer/ViTPose). +The SORT code is taken from [abewley/sort](https://github.com/abewley/sort) diff --git a/ViTPose/easy_ViTPose/colab_demo.ipynb b/ViTPose/easy_ViTPose/colab_demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..9f20c6fa82688cbfbf03c2e7d99f4eeb0c8cbb07 --- /dev/null +++ b/ViTPose/easy_ViTPose/colab_demo.ipynb @@ -0,0 +1,997 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "b0761f32610c4765a82cfc8f901356d9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8e20ffed38024ab5bfa8361f28852e00", + "IPY_MODEL_9954b2e0034a4106b9c00c89ac237a3d", + "IPY_MODEL_473dfcf611e54451a7de2f0950af81d3" + ], + "layout": "IPY_MODEL_3c60a788ecc6475884b62055bc167d0c" + } + }, + "8e20ffed38024ab5bfa8361f28852e00": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56b99433062f47b19081f8185b2f5f39", + "placeholder": "​", + "style": "IPY_MODEL_e81b426b15744848a783320254ecce8b", + "value": "Downloading (…)pose-b-wholebody.pth: 100%" + } + }, + "9954b2e0034a4106b9c00c89ac237a3d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e1b06389ec174ee088dba83724828e43", + "max": 360153207, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_43ba777eb879488b8f2ee4b98484f3b1", + "value": 360153207 + } + }, + "473dfcf611e54451a7de2f0950af81d3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_818cd9a4336c481688d42ea88292b181", + "placeholder": "​", + "style": "IPY_MODEL_65ecee0429774fcaad1f4ace595ec518", + "value": " 360M/360M [00:09<00:00, 36.8MB/s]" + } + }, + "3c60a788ecc6475884b62055bc167d0c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56b99433062f47b19081f8185b2f5f39": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e81b426b15744848a783320254ecce8b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e1b06389ec174ee088dba83724828e43": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43ba777eb879488b8f2ee4b98484f3b1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "818cd9a4336c481688d42ea88292b181": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65ecee0429774fcaad1f4ace595ec518": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# easy_ViTPose demo\n", + "Be sure to enable GPU runtime" + ], + "metadata": { + "id": "m7kiw4g_5L9d" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "FL7NZhO6vsFQ", + "outputId": "6d4ba0a0-3a83-48bc-e9f0-a75688ff85f7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'easy_ViTPose'...\n", + "remote: Enumerating objects: 815, done.\u001b[K\n", + "remote: Counting objects: 100% (231/231), done.\u001b[K\n", + "remote: Compressing objects: 100% (121/121), done.\u001b[K\n", + "remote: Total 815 (delta 176), reused 134 (delta 110), pack-reused 584\u001b[K\n", + "Receiving objects: 100% (815/815), 8.98 MiB | 14.97 MiB/s, done.\n", + "Resolving deltas: 100% (483/483), done.\n", + "Requirement already satisfied: certifi==2023.7.22 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 1)) (2023.7.22)\n", + "Requirement already satisfied: charset-normalizer==3.2.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 2)) (3.2.0)\n", + "Collecting coloredlogs==15.0.1 (from -r requirements.txt (line 3))\n", + " Downloading coloredlogs-15.0.1-py2.py3-none-any.whl (46 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting contourpy==1.1.1 (from -r requirements.txt (line 4))\n", + " Downloading contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (301 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m301.7/301.7 kB\u001b[0m \u001b[31m7.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: cycler==0.11.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 5)) (0.11.0)\n", + "Collecting ffmpeg==1.4 (from -r requirements.txt (line 6))\n", + " Downloading ffmpeg-1.4.tar.gz (5.1 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting filelock==3.12.4 (from -r requirements.txt (line 7))\n", + " Downloading filelock-3.12.4-py3-none-any.whl (11 kB)\n", + "Collecting filterpy==1.4.5 (from -r requirements.txt (line 8))\n", + " Downloading filterpy-1.4.5.zip (177 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m178.0/178.0 kB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: flatbuffers==23.5.26 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 9)) (23.5.26)\n", + "Requirement already satisfied: fonttools==4.42.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 10)) (4.42.1)\n", + "Collecting humanfriendly==10.0 (from -r requirements.txt (line 11))\n", + " Downloading humanfriendly-10.0-py2.py3-none-any.whl (86 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna==3.4 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 12)) (3.4)\n", + "Requirement already satisfied: imageio==2.31.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 13)) (2.31.3)\n", + "Collecting importlib-resources==6.1.0 (from -r requirements.txt (line 14))\n", + " Downloading importlib_resources-6.1.0-py3-none-any.whl (33 kB)\n", + "Requirement already satisfied: Jinja2==3.1.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 15)) (3.1.2)\n", + "Requirement already satisfied: kiwisolver==1.4.5 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 16)) (1.4.5)\n", + "Requirement already satisfied: lazy_loader==0.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 17)) (0.3)\n", + "Requirement already satisfied: MarkupSafe==2.1.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 18)) (2.1.3)\n", + "Collecting matplotlib==3.8.0 (from -r requirements.txt (line 19))\n", + " Downloading matplotlib-3.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (11.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.6/11.6 MB\u001b[0m \u001b[31m42.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath==1.3.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 20)) (1.3.0)\n", + "Requirement already satisfied: networkx==3.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 21)) (3.1)\n", + "Collecting numpy==1.26.0 (from -r requirements.txt (line 22))\n", + " Downloading numpy-1.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m53.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting onnx==1.14.1 (from -r requirements.txt (line 23))\n", + " Downloading onnx-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.6/14.6 MB\u001b[0m \u001b[31m37.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting onnxruntime==1.16.0 (from -r requirements.txt (line 24))\n", + " Downloading onnxruntime-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.2/6.2 MB\u001b[0m \u001b[31m83.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: opencv-python==4.8.0.76 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 25)) (4.8.0.76)\n", + "Requirement already satisfied: packaging==23.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 26)) (23.1)\n", + "Collecting pandas==2.1.1 (from -r requirements.txt (line 27))\n", + " Downloading pandas-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.3/12.3 MB\u001b[0m \u001b[31m23.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting Pillow==10.0.1 (from -r requirements.txt (line 28))\n", + " Downloading Pillow-10.0.1-cp310-cp310-manylinux_2_28_x86_64.whl (3.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m86.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting protobuf==4.24.3 (from -r requirements.txt (line 29))\n", + " Downloading protobuf-4.24.3-cp37-abi3-manylinux2014_x86_64.whl (311 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m311.6/311.6 kB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: psutil==5.9.5 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 30)) (5.9.5)\n", + "Requirement already satisfied: py-cpuinfo==9.0.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 31)) (9.0.0)\n", + "Requirement already satisfied: pyparsing==3.1.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 32)) (3.1.1)\n", + "Requirement already satisfied: python-dateutil==2.8.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 33)) (2.8.2)\n", + "Requirement already satisfied: pytz==2023.3.post1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 34)) (2023.3.post1)\n", + "Requirement already satisfied: PyWavelets==1.4.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 35)) (1.4.1)\n", + "Requirement already satisfied: PyYAML==6.0.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 36)) (6.0.1)\n", + "Requirement already satisfied: requests==2.31.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 37)) (2.31.0)\n", + "Collecting scikit-image==0.21.0 (from -r requirements.txt (line 38))\n", + " Downloading scikit_image-0.21.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m103.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy==1.11.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 39)) (1.11.2)\n", + "Requirement already satisfied: seaborn==0.12.2 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 40)) (0.12.2)\n", + "Requirement already satisfied: six==1.16.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 41)) (1.16.0)\n", + "Requirement already satisfied: sympy==1.12 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 42)) (1.12)\n", + "Collecting tifffile==2023.9.18 (from -r requirements.txt (line 43))\n", + " Downloading tifffile-2023.9.18-py3-none-any.whl (222 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m222.1/222.1 kB\u001b[0m \u001b[31m27.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tqdm==4.66.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 44)) (4.66.1)\n", + "Collecting typing_extensions==4.8.0 (from -r requirements.txt (line 45))\n", + " Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", + "Collecting tzdata==2023.3 (from -r requirements.txt (line 46))\n", + " Downloading tzdata-2023.3-py2.py3-none-any.whl (341 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m341.8/341.8 kB\u001b[0m \u001b[31m39.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ultralytics==8.0.184 (from -r requirements.txt (line 47))\n", + " Downloading ultralytics-8.0.184-py3-none-any.whl (618 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m618.0/618.0 kB\u001b[0m \u001b[31m49.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting urllib3==2.0.5 (from -r requirements.txt (line 48))\n", + " Downloading urllib3-2.0.5-py3-none-any.whl (123 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m123.8/123.8 kB\u001b[0m \u001b[31m16.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting zipp==3.17.0 (from -r requirements.txt (line 49))\n", + " Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", + "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.10/dist-packages (from ultralytics==8.0.184->-r requirements.txt (line 47)) (2.0.1+cu118)\n", + "Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from ultralytics==8.0.184->-r requirements.txt (line 47)) (0.15.2+cu118)\n", + "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (2.0.0)\n", + "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (3.27.4.1)\n", + "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.8.0->ultralytics==8.0.184->-r requirements.txt (line 47)) (16.0.6)\n", + "Building wheels for collected packages: ffmpeg, filterpy\n", + " Building wheel for ffmpeg (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ffmpeg: filename=ffmpeg-1.4-py3-none-any.whl size=6082 sha256=63fd12aaeb6b7d5e017e908717004872b0a428f7a3569bb4eaa2f8b5590554be\n", + " Stored in directory: /root/.cache/pip/wheels/8e/7a/69/cd6aeb83b126a7f04cbe7c9d929028dc52a6e7d525ff56003a\n", + " Building wheel for filterpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for filterpy: filename=filterpy-1.4.5-py3-none-any.whl size=110459 sha256=dfa6f7c452d0b1fa6c545b911843b9b7b0bfed0aa3ba4d95fcbc000a336f1ed9\n", + " Stored in directory: /root/.cache/pip/wheels/0f/0c/ea/218f266af4ad626897562199fbbcba521b8497303200186102\n", + "Successfully built ffmpeg filterpy\n", + "Installing collected packages: ffmpeg, zipp, urllib3, tzdata, typing_extensions, protobuf, Pillow, numpy, importlib-resources, humanfriendly, filelock, tifffile, pandas, onnx, contourpy, coloredlogs, scikit-image, onnxruntime, matplotlib, filterpy, ultralytics\n", + " Attempting uninstall: zipp\n", + " Found existing installation: zipp 3.16.2\n", + " Uninstalling zipp-3.16.2:\n", + " Successfully uninstalled zipp-3.16.2\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 2.0.4\n", + " Uninstalling urllib3-2.0.4:\n", + " Successfully uninstalled urllib3-2.0.4\n", + " Attempting uninstall: typing_extensions\n", + " Found existing installation: typing_extensions 4.5.0\n", + " Uninstalling typing_extensions-4.5.0:\n", + " Successfully uninstalled typing_extensions-4.5.0\n", + " Attempting uninstall: protobuf\n", + " Found existing installation: protobuf 3.20.3\n", + " Uninstalling protobuf-3.20.3:\n", + " Successfully uninstalled protobuf-3.20.3\n", + " Attempting uninstall: Pillow\n", + " Found existing installation: Pillow 9.4.0\n", + " Uninstalling Pillow-9.4.0:\n", + " Successfully uninstalled Pillow-9.4.0\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.23.5\n", + " Uninstalling numpy-1.23.5:\n", + " Successfully uninstalled numpy-1.23.5\n", + " Attempting uninstall: importlib-resources\n", + " Found existing installation: importlib-resources 6.0.1\n", + " Uninstalling importlib-resources-6.0.1:\n", + " Successfully uninstalled importlib-resources-6.0.1\n", + " Attempting uninstall: filelock\n", + " Found existing installation: filelock 3.12.2\n", + " Uninstalling filelock-3.12.2:\n", + " Successfully uninstalled filelock-3.12.2\n", + " Attempting uninstall: tifffile\n", + " Found existing installation: tifffile 2023.8.30\n", + " Uninstalling tifffile-2023.8.30:\n", + " Successfully uninstalled tifffile-2023.8.30\n", + " Attempting uninstall: pandas\n", + " Found existing installation: pandas 1.5.3\n", + " Uninstalling pandas-1.5.3:\n", + " Successfully uninstalled pandas-1.5.3\n", + " Attempting uninstall: contourpy\n", + " Found existing installation: contourpy 1.1.0\n", + " Uninstalling contourpy-1.1.0:\n", + " Successfully uninstalled contourpy-1.1.0\n", + " Attempting uninstall: scikit-image\n", + " Found existing installation: scikit-image 0.19.3\n", + " Uninstalling scikit-image-0.19.3:\n", + " Successfully uninstalled scikit-image-0.19.3\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.7.1\n", + " Uninstalling matplotlib-3.7.1:\n", + " Successfully uninstalled matplotlib-3.7.1\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "cupy-cuda11x 11.0.0 requires numpy<1.26,>=1.20, but you have numpy 1.26.0 which is incompatible.\n", + "google-colab 1.0.0 requires pandas==1.5.3, but you have pandas 2.1.1 which is incompatible.\n", + "numba 0.56.4 requires numpy<1.24,>=1.18, but you have numpy 1.26.0 which is incompatible.\n", + "tensorflow 2.13.0 requires numpy<=1.24.3,>=1.22, but you have numpy 1.26.0 which is incompatible.\n", + "tensorflow 2.13.0 requires typing-extensions<4.6.0,>=3.6.6, but you have typing-extensions 4.8.0 which is incompatible.\n", + "tensorflow-metadata 1.14.0 requires protobuf<4.21,>=3.20.3, but you have protobuf 4.24.3 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed Pillow-10.0.1 coloredlogs-15.0.1 contourpy-1.1.1 ffmpeg-1.4 filelock-3.12.4 filterpy-1.4.5 humanfriendly-10.0 importlib-resources-6.1.0 matplotlib-3.8.0 numpy-1.26.0 onnx-1.14.1 onnxruntime-1.16.0 pandas-2.1.1 protobuf-4.24.3 scikit-image-0.21.0 tifffile-2023.9.18 typing_extensions-4.8.0 tzdata-2023.3 ultralytics-8.0.184 urllib3-2.0.5 zipp-3.17.0\n", + "Obtaining file:///content/easy_ViTPose\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Installing collected packages: easy-ViTPose\n", + " Running setup.py develop for easy-ViTPose\n", + "Successfully installed easy-ViTPose-1.0\n", + "Collecting huggingface_hub\n", + " Downloading huggingface_hub-0.17.2-py3-none-any.whl (294 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m294.9/294.9 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (3.12.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (2023.6.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (2.31.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (4.66.1)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (6.0.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (4.8.0)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub) (23.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (2.0.5)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub) (2023.7.22)\n", + "Installing collected packages: huggingface_hub\n", + "Successfully installed huggingface_hub-0.17.2\n" + ] + } + ], + "source": [ + "!git clone https://github.com/JunkyByte/easy_ViTPose.git\n", + "!cd easy_ViTPose/ && pip install -r requirements.txt && pip install -e .\n", + "!pip install huggingface_hub" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Restart the runtime (runtime -> restart runtime) to update installed packages versions" + ], + "metadata": { + "id": "YzHXdqtHGTab" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Download the models" + ], + "metadata": { + "id": "JxMDvPYF57pH" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Choose model and run this cell\n", + "\n", + "MODEL_SIZE = 'b' #@param ['s', 'b', 'l', 'h']\n", + "YOLO_SIZE = 's' #@param ['s', 'n']\n", + "DATASET = 'wholebody' #@param ['coco_25', 'coco', 'wholebody', 'mpii', 'aic', 'ap10k', 'apt36k']\n", + "ext = '.pth'\n", + "ext_yolo = '.pt'" + ], + "metadata": { + "cellView": "form", + "id": "0NyCRDB46ric" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "from huggingface_hub import hf_hub_download\n", + "MODEL_TYPE = \"torch\"\n", + "YOLO_TYPE = \"torch\"\n", + "REPO_ID = 'JunkyByte/easy_ViTPose'\n", + "FILENAME = os.path.join(MODEL_TYPE, f'{DATASET}/vitpose-' + MODEL_SIZE + f'-{DATASET}') + ext\n", + "FILENAME_YOLO = 'yolov8/yolov8' + YOLO_SIZE + ext_yolo\n", + "\n", + "print(f'Downloading model {REPO_ID}/{FILENAME}')\n", + "model_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME)\n", + "yolo_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME_YOLO)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "b0761f32610c4765a82cfc8f901356d9", + "8e20ffed38024ab5bfa8361f28852e00", + "9954b2e0034a4106b9c00c89ac237a3d", + "473dfcf611e54451a7de2f0950af81d3", + "3c60a788ecc6475884b62055bc167d0c", + "56b99433062f47b19081f8185b2f5f39", + "e81b426b15744848a783320254ecce8b", + "e1b06389ec174ee088dba83724828e43", + "43ba777eb879488b8f2ee4b98484f3b1", + "818cd9a4336c481688d42ea88292b181", + "65ecee0429774fcaad1f4ace595ec518" + ] + }, + "id": "DIophLL45ls7", + "outputId": "496ed38e-724b-4698-9daa-5613e1b51914" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading model JunkyByte/easy_ViTPose/torch/wholebody/vitpose-b-wholebody.pth\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Downloading (…)pose-b-wholebody.pth: 0%| | 0.00/360M [00:00" + ], + "image/png": "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\n", + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAMgBLADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD1+iiitDAKKKKAClyaSigYuT60uabS0CuOpwNMFANKw0x9LTM0uaB3Q4UtNpc0DFzS02igB1LTKXNFkFx2TRmm5ozRYLjtxozTaTNFguPzRk02iiyC47dRmkzRRYTH5FJkU2iiw7js0bqbRRYLi5NFJRTAXNLmm0UrAPopuTQDRYB1FNzQDSsA6ik3UtABRRmigAoooyKACiiigApaSigBe1GaSigBaMiikoAXNLTaKAHUU2lzQAtFJmjNAC0UmaM0ALRSZozQAtFJmkoAXNGaSigBc0ZpKKAFpKKMigAppOaXNJTSAKKKBTAKMGnAUoFK4CBaUClpaQDcUuKOtKBQOwlLS4pcUrhYbikqTFIRRcLDKQinkU3FMRGRSVJikK0XCwyilIpKYhaSiigApaSloAKKKKY7ABTqbSipBDqKKM0ALSYpaKAE6UYpaKAEIpmDT8UYoAbg0hBp5FGKLgM5owafijFFwAZ4paKKAA0lLSUAKBRwKO1KBQAYzTgKUCnYpNlJCbaNop4BNOAqbjsRYFO2mn4pcUXHYZto20/FFA7DdtJtqSilcLEe2jbT6KYWGbfakIqTFGKLisQ7RRtNSbaTFFxWGbTRtp+DRii4WI9tLt96dRzRcLDNvvRtp9FFwsR4pCKkxSYp3CxGRSYNSEUhFO4rEdFPIphBouKwUlOpMUxCUUtJQAUUUUAVKKdtNNxVEWCilC07aKVx2YyipMUYouOwzFFOxS4ouKwyinYpcUXCw2lpcUAUwsIM06lxRikNCUtFFAwooooAKKKKACiiigAooooAWiiimAUUUUAFFFFABS0lFAC0UlFAC0UUUAFFFFABS5NJRQAuaM0lFAri5opKKQXFBpcim0tAJjqKaDTs0hhRSdaWgAooooAKKKKACiiigAooooAKKQmkyaLAOopuTRTsA7IpM0lJRYVxd1GaSigLi5NGaSloC4UlFFAC0lFLQAlKDSUtAJjqUGmUZpWGSUtMzS5oAXoacKZmloHcfTs1GCaXNKwJj80UwMKXJosVcU00ijNBNBLEpMUdaWmIaRTStPpG6UAMpKU0lMTCiiigBc0ZpKKAuLQDSUtAXFzS7qbmiiyHdD80ZpgNOzSC46ikGKWgAoopaAEooooAKKTNGaAFoppYUZoAdQKQUo60AOHWnAU0VIKTZSQYpwHrSDGafUsoKWiikAUUUZoGLRSUZoC4tFJRRYLhmijNJmgLi0ZpNw9aQsKBDqSm7qMmmA6m03FLQAuRSEiikoHdC0lLR+NAXCjrRxSZxQJhikpc0UCExTCKfSHFNA0MIFJg06iqJGUHFPwKTFK4WG4owaXFJzTCxDikxT8UUCsNxRinUUBYbilpaMUANxRinUuKAGYoxT8H0owaAG4oxTgKXHNADcUYp3el4oAZikxT8UYFADcUYp2BS4oCxHilxTuKXIoAZikxUlGKLgR4oxT9oowKLhYZS4p9FF2FhmKKkpKd2FiOlp+KTAouFhtFLtoINFxWOZ8e3M9r4Pu5beaSGQNGA8bFSPnHcV43/bmrf9BS9/8AAh/8a9g+Iv8AyJV5/vx/+hiq19/wifhDw3pGoz6Hb3V1cWyLGAgO8lQzMS2fXqQTyB06fT5TiIUcMl7PnlKTS26JdyJK73PKP7c1f/oKXv8A4EP/AI0f25q//QUvf/Ah/wDGvSDp/hz4iaJd3Gk2K6Zq9ou4xooAYckDC4BB6ZxkH2643w78HWmuC51TU1eWztSUFuitmVsZ7c8ccDqT+fr/AF7DRpTnUhyuO6sr67W73I5HeyOQ/tzV/wDoKXv/AIEP/jR/bmr/APQUvf8AwIf/ABr2K1j0vW7s6XeeAriys3yEuWtQmMdMlQCv4E1yGj+FbTT/AIsDRbqJLu0TdIiy4bK7Cy7h0PbIPB9Kzp5jQkp89Oziua2juvVDcH3OM/tzV/8AoKXv/gQ/+NH9uav/ANBS9/8AAh/8a9O1zW/B3g2/l0u18NwXkwO6beAQhIyF3MGPTsOBR4X0bRk8KS+JV0FNTu5ZXZbSEFxEN2AgVs9OucE8+lJ5hTVJVZUWk7KO2t/y+Ycjva55j/bmr/8AQUvf/Ah/8aP7c1f/AKCl7/4EP/jXpbX/AIQ8Qw3VlrGhx6BcxxM0UsiCM9OxAGSP7pBzXP8AgTwrpuowX2t61KG0ywyCgyBIQMkk8HAGOOpyPodVjKKpynVpcrjbSyd77Wa0YuV3smcp/bmr/wDQUvf/AAIf/Gj+3NX/AOgpe/8AgQ/+NekWfirwVr9+ukXHhuG1t52EcU+xFOc/Lkrgrn2J/KuduPCMOjfEmw0Wci5s5po2XzPl3Rseh9+COOuPwp08XTbcKtLkkleztql2f6A49mcz/bmr/wDQUvf/AAIf/Gj+3NX/AOgpe/8AgQ/+Ner+I9R8GeC9ReGPw/b3V9PiSSIINsYPT72QufRR/Suf8d6RpN34X03xTpFkloLlgs0aEAcg9hxkFSOPWs6GOpVZQ5qLjGeibtv/AFsNwa6nEf25q/8A0FL3/wACH/xo/tzV/wDoKXv/AIEP/jVCivW9jT/lX3Gdz0/wrpZXw7J4k8UaxqUdiGHkxLdOPMGcZODk5PAAx0J6VrWp8NeMlmtNE1LVbDUEjLRhrmQbvcgsQRkjOMGsnx+v2H4e+GLGPcImVXbIxyEB59/mNcl4Ene38b6S6Zy04Q49GBB/Q188sO8RRqYtSaa5uVLay7rre2ptezUSne6hr2n3s1ndajfRzwuUdTcNwR+NMh1fWrieOGPU75pJGCKPtD8knA71tfEq2S28d3+zOJNkhyMclRmsLQb1NN1/T72RVaOC4R2DDIwDzXsUuSph41VBXavt1sZvR2PUntNF8GWluPE+s6le6jMm4wxXMhUc9VAI47ZY84OB2rP8RaUl14cfxH4V16/a0iJ8+CS6k+UcfdzyCM9D1ByPdfiP4W1PWtVh1vSIjf2k0CrmAhiMdCB3BBzke9bHhTw1eaF8PtZi1SAebcxyyfZy2cKEwAcHqcdvavnVUp06MMT7S821eOlt9Vy9LGtrtxtocj4E0zUvFF5cS3utajDp9ooaV0uGBYnoMk4HQkn/ABzXTQ+IPA+oXo0uK41SJpW8pLn7TMFz0BBLnv6jHrXldhrepaXbXVtZXksEN0uyZUP3h/T6iug+H/hOXxFrUdxKhGnWjh5nPRyOQg9SeM+g/CvTxuDiuevWnyxS0UdPv7tvYiMtkkO8ZW2s+FdeazXWNQkt3USQSNOwJU9jz1BGP14zXskBLQRsTklQSfwrxb4h+IovEPid3tsG1tV8iN8ffwTlvpknHt9a9otz/o0X+4P5V42bxn9WoOorSad/wLi1d2JaM0lFeAVqLmkoooGFFFFArBRRRQMKKKKACiiigAooooAKKKKVhWClpKKLBYWjNJRTGLmlDU2ilYVyTdRuFR0tFh3H5FGc0zNGaLBck/GjIqPJoyaVguSUZqPNGadguh5OKaTmkpKAuLSUUUCCiiigApaSigAooooAKKKKAClpKKAFBp4NR0UBckzS1Hk0bjSsO5JSFqYWJpKLBcXNFJS0xXCikooC44GnioqUNigaZMKeGqEHNOBqWhpk1Lk1Dupd1KxVyXcaNxqLdRupWDmRLuNG6od1G6iwXRNuo3God1G40WC5NuNG41Duo3GnYLkufekz71Huo3UWC5JkUZqPNGaLCuP3UbqjzRn3p2C5Juo3VHn3pN1FhXJd1JuqIsKNwosFyXdSbqjyKN1FguSbqN1R7veiiwXJN1G6mZFGaLBcfupM03dRmiwXHZopuT60ZFFguOozTOKOKLBccTSE0nFGaYXGUUZ9aKBBRxigYozg0AGKPwpc8ZpaAG0ZpcCjFACiiiigBuaNxo20YpajQUUUlGoxcmjcaSijULIXcaUA80g5p9AhAKMClooAMUlLRQAmKXFFLkUAJijBpQaWgBuM0YxTqKAG4op1J0ouFhDSUvFGBTEcn8R/+RJvP9+P/wBDFZ3jbw9qWseC/Dr6bAbo2tuvmJHyxDIuCB36fXmqPxavLiOLTrNJCtvLveRAPvFcY/LJrqb2HxI3hzw8/h66it5EtFEwm6MCiY4IPIwa+gw3Ph8PQqppXlJ67bW1+4jRtowPAGjXXhDTtT1/W1+xoYdkcUzbScHPI7EnAA6/1l+G+rz3/hrVdNs7mG31RZHmt953feGc4OcgHg/X883W/CvjnxCVGpajayxrysQkKoD67QuM8nnrWdafDjxTYXKXNpd20E6fdkjnZWH4ha7J/V68JyrVo88mnpsrbLXfzEm1ay0Og027+J19qos5/wDRIw2JLiW2j2KPUHHzfh/9eqHh8XUfxlMd3qiajMBKr3EfAPyH5cdBj0HAIrSurH4k3dobd9YtEVhgtEwRz/wIICPwrA074f8AizSb+O+sby0huYzlXWUn8wVwR7GlTnQcKilOnHmi0lFd+rdr/IHfTc5rxkxbxnrBYkn7XIOfrXUeGNK8Uad4VXXPDmpCfzZCJNPRNwAHBODxu4HAGcY5NVrn4a+Jry5kubi5tJZpGLO7zMSxPf7taOjeEvHGgMf7N1K2hRjlo/NLIT6lSuM8da7a+Lw8sPGlCrC6tdPVO3QlJ3u0dVok2reKNKv7TxhosVvbLHlJnj2HODkgNnBA53DGK57wN5Ot+Cdb8MQ3UYuSztAWYgupxhsdcZAzj1/OTVdF+IesW5t7vVrXyWBDJE/lhgeoO1Rke1Ydp8OPFNhcpc2l3bQTp92SOdlYfiFrgpxw/s5p1YxbaaSvZNevfqW277FPQ/h/4hn8QQQXOnzWsMUoaaZ+FCg87SD8x9MV0fibVYNR+LmiQ28iSJaTRRMyNkb9+SPTjpVy6sfiTd2ht31e0RWGC0TBHP8AwIICPwrm7f4a+J7S6jube5tI542DpIszAg+v3a6FiKdabq4irC6TSSbtru3cm1lZIqfFD/kfb3/ci/8AQBW3rP8AyRDRv+vgf+hSVU1H4feLNXvpL2/u7Se4k+87Sn9AFwB7CpJfA/jKbSItKl1C2axhYukJmOAf++f07Vft8N7KhD2sf3bTevZW0Czu3bc86ortv+FW+IP+ell/39P/AMTSf8Ku1/8A56WX/f1v/ia9P+1MH/z8RHJLsdFLYv42+FmnppzCbUNMYI8R4Y4GCOf9nBHrj1rP+H/gvVYPEkWp6pZyWdpZhpC0427mxgYB9M5z04puleCfGWhzmbTdQt7ZmxuCTHDY6ZBXB6nrWlqmkfEPWLY291q1r5LAqyRP5YYHqDtUZHtXiyrRjGdClWhySb1d7q+6XT0NPNrU5HVYp/G3j67XSv332iUiJ2+VQijG4+gwM+vtnis7xB4Z1DwzqSWWoeUC6hkljYsjD1HGePpmulsfh74p0y9ivLK6tYbiI5R1lOR/47+lS6r4H8X63em71K9tbicgLuaQgADsAFwB9K74Y+hTnGEKsfZpW87/AJENXW2pcfR/HHg+K2XQ76bUbKWMNiGPzERjyQFOcDnORjPtWvqF5qmifDbUJfEd67apqRMccTEEoCMbQBwOMk49fWqOl6R8QtHthb2mrWvkqAFSV/MCgdANynA9qzdV8E+MtcnE2pahb3LLnaHmOFz1wAuB0HSvO5qVSovbVKdk7tpe87bJ6W9S9lomYPg7wZeeK77+KHT4j+/uMf8Ajq+rfy6nsD2XjBtaWwXw14Z0K/g0qEbJJY4GBm9QDjO31PVvp1h0Pw7498PwPbabf2SQu24xs28A+oyvFbK2vxPb/mI6aPqi/wDxFVicX7TEqp7SDjH4U29+703/ACCKsrWZ49f6Zf6XKsV/Zz2rsNyrNGVJHqM19C288P2aL96n3B/EPSuC13wV458RPE2qX9jL5QIRRJtVc9TgL196xm+E3iRf4rI/SU//ABNVjZYbH04e1rRjJX21Wv3CScXoj1rz4f8AnrH/AN9Cjz4f+esf/fQryE/C3xAvV7Mf9tT/APE0n/Cr9f8A+ell/wB/T/8AE1539mYL/oJX3f8ABK5pdj1/z4f+eqf99Cjz4f8Anqn/AH0K8g/4Vfr/APz0sv8Av6f/AImj/hV+v/8APSy/7+n/AOJo/szBf9BK+7/gi5pdj1/z4f8Anqn/AH0KTz4f+eqf99CvIf8AhV+v/wDPSy/7+n/4mj/hV+v/APPSy/7+n/4mj+zMF/0Er7v+CHNLsevefD/z1T/voUefD/z1T/voV5B/wq/X/wDnpZf9/T/8TS/8Kv1//npZf9/T/wDE0f2Zgv8AoJX3f8EOaXY9e8+H/nqn/fQo8+H/AJ6p/wB9CvIf+FXa/wD89LL/AL+n/wCJpP8AhV+v/wDPSy/7+n/4mj+zMF/0Er7v+CHNLsev+fD/AM9U/wC+hR58P/PVP++hXkH/AAq/X/8AnpZf9/T/APE0f8Kv1/8A56WX/f0//E0f2Zgv+glfd/wQ5pdj1/z4f+eqf99Cjz4f+eqf99CvIP8AhV+v/wDPSy/7+n/4mj/hV+v/APPSy/7+n/4mj+zMF/0Er7v+CHNLsewfaIf+eqf99CnghgCCCD3FeKX3w71rT7Ce8me0MUCGR9shJwBnjiuj+FN7cSRX9k8pa3h2PGhH3SxOcfXAqMRlVKGHlXo1VNR30/4I1LWzR6RRRRXjFXCiiigVwpc0lFA7i5ozSUUBcXNFJRQFxaKSloC6CiiigYUUlFAhaKSigLsXNGaSigLi0UlLQFwooooAKKKKBhRRRQKwUUUUDCiiigQUUUUDCiiigWgUUUUrBYWkooosFhaNxpKKLDHbjRvNNoosK47caN5ptFFguO3mjcabRRYNR240bzTaKLBcdvNG402iiwXHbzRuptFFguLuNG40lFFg1F3UZpKKLBcXJoyaSiiwC5opKKYwpaSigBaMmkooAXNG6kopWFqLuo3UlFFh3F3UbqSiiyC4u6jNJRRZALmjJpuaKYXFpabS1IBS0maKAFo6CkpaADNGaKKAHZoptGaAHZopoOKXNAC4ppFOooAbtNGDTqKVh3YzBFL+dOoosFxu40butLgUuBRYLibhShhSYFGBRYLi5paTAoosIWgGjNFFh3CjJoo7UwuGTRmjPtRgelKwXDrS0maKYjy34u/8fOk/7kv81ruvCrE+EtJyScWsfU+wrhfi7/x86T/uS/zWu68KD/ik9J/69Y/5V7uL/wCRVQ9X+bIXxs2MmlFIMUteDc0FoxRRTATmjFLRkUAJ0oFFHFAhaMUUUAJQRS0UANxRinUmKAExSYp1FADMClxTqKAshuKfDHvkx2HWm1dtU2xZPUnNJsaVyVUVRhRisnXbm6t7SBbNws0txHECcDgnnkg4474NbFYniFbr7PYta2j3MqXcb+WjBeMHkk9APWhFo5U69qE1vaz2s08bS28dzIZZwwUNMI9oXYAfxxXoLelcbf6TqttZIiWljdBjHHttYvKe3USK2Bkneoxk9D3rsmo9BtIjYAggjIqlJH5bEdu1XTVaY9D700yGiHFFPGDQRTuTYjopdtGKLi1EooophcKKKKBiUtFFABSUtFAGP4p/5FTVf+vWT/0E1w/wl/4+dV/3I/5tXc+Kf+RU1X/r1k/9BNcN8Jf+PnVf9yP+bV7mE/5Fdf1X5ozfxI9PopaK8M0EopaSgTCiiigQUUUUAFFFFABRRS0AFJS+tJQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUtJRQNC0UlFANDqSjNFAhaKSjrQAtFFFABSUtFAXEpaKM0CuJRS0UBcSilozQO4lLRRQF2JRS0UBcSiiigYUUUtAXQlFLSUBcKKWigLiUUvSkoFcKWm0pNAC0lGaM0BdhRRmigdwoopKAuLRRRQMKKKKACiiigApKWkoAKKKKACiiipAKWkpaACiiigAooooAWkoooAWikooAUGlyM02loAdmim5NBPNADqKTNLQAUUhOKOeaAFooooAKKKKACiiigAooooAKKKKAClpKKAPLvi4f9I0n/cl/mtd34U/5FLSf+vWP+VcH8XP+PnSv9yX+a13fhT/AJFLSf8Ar1j/AJCvdxf/ACKqHq/zZC+NmzikxRk0ZrwixaU0lFKwCc0YpaKYBRRmkzQAtFIDQDQAuaWkooAWikooAWijNFABRRRQAKuWA9TWgvCge1U4uZPwqtruv6Z4b0uXUdUult7aMcseST2AA5JPYCkWjWqKWeKBN0siRr6uQB+teA6p8TfHXji6az8FaVPZ2RVmW52qJJFBwTvf5F57A5964bVfAHju7uZX1JmupURXLy3yvuY7coCW+8uTnPHynBPGeSpjcNTnyTqJPtdXCpKNKKlUfKvPQ+rP7d0ottGp2RPp9oTP86tCaORNyOGHqpyPzFfD2p+HtW0hit9YSwgMF3lcoSRnAYZU8eh9a1PDw8ZWYF5ocmo20fLCVJDHG/OCAWwrHPbk8H0NdNJ+1sqet+2pLq0lBVHJcve6t959mNVWc/Ka8Z8MfGDVbG9j0rxZaLK7bMXdptJXIH30B7c5x6cA8V6JY+OvD+q3gsrW9/0iR/LjEkTIJDgEEEjj05wSR7jPa8Biox5pUpJejNacJVoc9NXXdam6jZ71JUEeRIVNT1ymTExSU6igQwikxT8UGi4WGYpKfSYp3FYbRS4NJRcYUUUUXAyPFP8AyKmq/wDXrJ/6Ca4b4S/8fOq/7kf82rufFP8AyKmq/wDXrJ/6Ca4b4S/8fOq/7kf82r3cJ/yK6/qvzRm/iR6hRS0YrwzQSilwaMGlcBKSnYopgJikpaKACiiigAxRRRQKwUUUUA0JRS0UBZiUUtFAWEopaKAEopaKAEopcUYoCwlFFFAWCiiigAoxRS0AJRS0UBYKKKKAshaKSigVhaM0lFAWCjNJRQAUUUUAFFFFABRRRQAU6m0vagTFo4pKUUDCiiigQUUUUDCiiigBDSUtJzQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUDCiiigQUUUUAFFFFSUFFFLQAlLRRQAUUUtACUUUtACUUtJQAUtJRQAtFJSgZoAKUetGBS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHlvxc/4+dK/3Jf5rXdeFP+RT0n/r1j/lXC/Fz/j50r/cl/mtd14U/wCRT0n/AK9Y/wCVe7i/+RVQ9X+bIXxs2KKKK8IsKUUlFAC5ozSUtABRSUUALQKSigBaWkozQAtFJmgGgBaKTNGaAFoopDQBQ1rX7Dw1pkmpajL5cCELnBJLHoox3NeAeKb/AF/xXrx1LXdPlt9LjzHZ20ynah4OSCOWIPU/QZ2nHoPivxImreIv+EaMTxmxvYZmJJBkCEMDnBGMnOO4B5HUWb23s76E292qSJnOCcYI9x0NeDmeavDVY04xunv3+QLM6eV4yjPEQvHd7Xt5J2/Ex/DPiLT9DEKfZ5pd1usaRW6bnUAA46gYwOfp9a1vPn1TBWApIw8yRXkUYJ7ZJAPWuI8J39lfXbS2zjmIgIZMlOR8pGOvHXjofw7O2BM647V5ebZXTwWIlKF+ZJO79O2nU5uN81w7x8cIqPNFpO/M9b9rO1lt6rtvm+MbBrHRpYb6FjHMdiFeVYgg9ccdM4OCcGq0s0F34XtXtWYRWwRJEY/cIUDBOBnGQMjjmuu12CDXdBt7CELeSpMoYQknymXKkMQcKQcqd3v0I44vV7SHRvC0tpLi3keZWVbgYeQkgDbnHPB6DoDx3r0OFc45J2mvfV9O9uxU+FcE8uw8KUpqcqsb3s0lO0W2klolaz77u23BalFKPEBmtYnuCy5LNjbnHYjjpxz+tatnKfIVZY/KlJOUJz+tRRgmRcdc0t+7RK0scTysi52oCST2HANfqGCzl5nRca0VHl638vM/S8LlNPIaHNCo5JdHby7LfT7uh3HgfxQNDv7qDUJZBp8kSGPCbtku7BI6nG0knj+HjJOK9V07U7PVrQXNjcLNEWK7lyCD3yDgg/X1B7185aXeJd6fHNuPzFvvHnhj7mvWvhnd26aRcRNcfNJdELGQNo+VeQcdT069hj38TMMPClT9vP3W2t/PoeRneDwjw39oQlZzadrq2vTbc76iiivMPkgooooATFGKWigBMUmKdSEUANxS4pcUuKAMXxUP+KT1b/r1k/8AQTXC/CMf6Tqv+5F/Nq7zxX/yKWrf9esn/oJrhPhF/wAfOq/7kX82r3cJ/wAiqv6r80Q/jR6jilApaK8IsTFGKM0UAGKMUUZoHYMUYpR1paBDNtG2n0lFx2GbaTFSUmBRcViOipNtN207isNopcUYouGolLil20uKLgkNxRtp4FGKVxjcUmKfijFFwGEUYp+KMUXCyGUlSYpuKdxWG0U7bRtouFhtFO20baLhYbS4p232pcUXHYaFp22lpeaVwsN2ikK0+g8UXHYiwaSpeDSFadxWI6Kdto2UXFYZilp+yjZRcLDKKk2Umyi4WGUUpUiii4WEooopisLRSUUBYWikpaBWCikpaAsFFFFAWExRS0UDG0U7tSYoFcSilxRigdxKKWjFACUUtFACUUtFACUUtFA0JRS0UBYSilooASjFLRQAlLSUoqRhS0lFABRRS0AJS0lFAC0Uc0UAFFHSgH2oAMUdKUjPejvzQAgGadScClzQAUUUUAFFFFABRRRmgAopMijNAC03k0A+tHfigBc80tN4pQOaAFooooAKKKKAPLfi5/x86V/uS/zWu68Kf8inpP8A16x/yrhfi5/x86V/uS/zWu68Kf8AIp6T/wBesf8AKvdxf/Iqoer/ADZC+NmxRRRXhFhRRRQAUUUUAFFFFABRRRQAUUUUA3YKKSlzQK6ClpMiloHdBRRRQB534q06O08ZJqJAT7daiMEkDdIh5GO52gH6A/hWEbkZCNj6VzHii5u/ih49/svSmkufDukLvneBsxyuASWzxlmx5a4LcBmXgmuxlu7aHHmTxruwQCw5B7/Ss62Rxq1E3J8zV7Jbdv8AhrHw/FdKSrwrrXmVv/Abf5mDf6NA0ReODBYlsRttBYnJJ98k1lt4bWS3aK9BkScKWj3EjAGF59cHg9u1btzq0SmTYqsFJGQc5ptqZJ3SefcJGXK5HAH5cV4M70ptX1T/ACP1GWKpYPK1iakbxjBabvZaf5v5l3wFax+FdAudOhVpWa7eUs8gOMqmMgAYIAHHOcZyN2BlfE21t/EbaN5yGNrd5TjzPlZTsG3GM8kDnIxjGDuyq+JdR1C1hmh04S+YsBIEaZbceARn3x07+p4rgbe4urqzt5rueed2U7ZJ2LEjcRwSemcivost4JxNXHf2pLEJSbe13LVNd1bT/hj5/h/FzzbEub92lvy6P06Lrr+B0yabDbQDaqDAxhF4Aqk8sZk2rgE9qht72SHT2TPyhjt56VRFxvuAxPf1rz8Xh3g8TOg5X5XufX4qNlYr3Go2ouZFaYBwTnqenvXo3w/a2QWcAvrf7VeyefDEs6lyg7hSeo2tnjtg9MDyG+029jvpVNvO++Q7W2E785PbjOOa9Au9D1Lw14D8I+Lwkn2nSbgy3EIKRubeWTKrvHO05xtIY/v2zgAivv8AiDLYV8qoYb2truPq7K69NUj5rF4+eNpKg2uVNPTd226nvdFMhmiuYI54JUlhlUPHIjBldSMggjggjvTq+QIFopM0tABRSZooAWikPSjNAC0UmaM0AZHiv/kUtW/69ZP/AEE1wnwi/wCPnVf9yL+bV3Xis/8AFJ6t/wBesn/oJrhfhF/x86r/ALkX82r3cJ/yKq/qvzRD+NHqdFJmjNeEWGKXFJmjNABRS0UAAIpabijmlYY6im80ZNFgHUmKMijIpgJS0hNA60CAiilooAbS9KOlLQAUUUmaADpS0lAFAC0hpaKACiiigAopM0UDsLRRilxSuFhKKdiimFhMUtFFIAooooAMUmDS0UwEwaXFLTsUrgkM20bafRSuOwzGKTFPIptO4mhtIRT6SmIjK0lSYpMCi4WI6KeU9KbTEJRRRQAUUUUAFFFFABRRRQAUtJRTCyCiiikAUUUtACUUoBNLtoAbRSlSKKAsJS0lLQAlFLSUALSUtJQAUUUUAJS0UUhi0lFFAC0UlFABS0lFAC0CkpaAD1oB5oooADijPrRiigAzRmikoAXNGTSUUALmkyRRRQAuTRmkooC4tFJRQAtFJS0AAFLgUoooAKKKKACiiigDy34uf8fOlf7kv81ruvCn/Ip6T/16x/yrhfi5/wAfOlf7kv8ANa7rwp/yKek/9esf8q93F/8AIqoer/NkL42bFFFFeEWFFFFABRRRQAUUUUAFFFFABSGlooBq42lpcUlBLVgFLRRigEGa4L4seMn8KeGBBaHGo6jvhhYMymJMfPICP4huUDkcsDzgiu1vbyDT7G4vbqTy7e3iaWV8E7UUZJwOTwO1eQeB7Sf4gfEW98cXyZ0uzlMVjFIQSHUDYNh3Y2q284I+dgR3x14WnG7qz+GP4vogZ2/w38HJ4N8MJBIM6jdbZrtiFyr4H7sEZyq8jqeSxGM4rjfGEK6b4jvjM4SNnEgd/lGGAPc+pxn2/CvYc814x8cYSLnT5VOd0Y8zjpgtjnt979RXdk9dyx65/t6ff/w1jmxmDWKpcjdra/195l2F5aXcyrDcRSkE5RWBPBxnHp712b3EWkabJezorsEGQ8e7bnsB0zkjr6ema8c0mxmsr+C6eRU2HkKNxwQQfTnn/Pf1R/K8QeGpLWO7t4r4Mghhkl8vzum3GepPICnvjOOK+c46yyWExsKsZN0ptczttrt92vz1PYhgMRLC0MHK8afMlJ6X5W9Xrtb/AINtLFRPGNpNcvJcRXDMzZUhV5z3xnjmsrVdfnuUYsp2E/LFnC56jJ79OuKoHQ9QjuCjwjKEZKyqw6Z4IOD17VWmPmptj+Yg816/ClTCp8kXHfur9/6Z71Xw/wAijetSjKUtHfmb/q//AA1jAv8AVb5JvLlS3VdnCxr8vXr65q7o1rc6lcIlrAZXZM7QeAB6nsKpapbebMGMirtG3AGTnJzn9K7zwPpM9gwvJ/KEU9uBHlyXAyCPbBAB9eB05ru4nllc6tKNGyqN+816dejb/wCH3Pl84xcsooVXfRaQTe7+++g8adetOIVtJ3lOcKkZYnHXGOtepT6B/afgZtBvSA81l5DNKiyeU+3g4GAdhwR/ujnPNVNFtpnv4ZlRxEMnzAOCMEdT19K6qscfmEq/KrJW1Pl+G4ynRlXmmm9PJrR3OB+EepTzeEpNGvzt1HRbmSynRpxI4AOVz6KMlB1H7vg9h31eYXRi8GfGm3uAjxab4mg8l9rgJ9qDDnYoySTsGT3mY56ivT648Ulz+0W0tf8AP8T6VAaM0UlcwC0UlFAC0lFFABRRmkzQF0ZPir/kU9W/69ZP/QTXCfCP/j51X/ci/m1d14qP/FJ6t/16yf8AoJrhfhH/AMfOq/7kX82r3cJ/yKq/qvzRm/iR6lRSZFLmvCNAoozRmgLoKKKKAFzRmkooAXNGaSigBc0cUlFAC4paSkoAdSZopKAFzRmkooAWjrRSUALS02lzQAtFJmgUALRiiigBKUUmKORQMdS03NLmgBaKSlpAFFGaKACiiigAooooAWnZplGaBpj80maTNJmlYdxSaSjNJmmS2LSelFFMLhRRRQISkK040lAEZpKeRTaYmhKKKKACilpKAClpKKAClpKKAClopwFADcUoFOx0oxSGkA70tFFAAajIqSkIoAjpaCKSmIKKKKACiiloASiiigBKXNJmikMWikooBMWikozQFxaKKKAuFLSUUALmikpaACgnNJRQAUUUtACUUtJQDYUUUlAri0UUU7BYKKKKYwpRSUoFSJXFyaWm8Uo64oC4tFFFAwooooA8t+Ln/HzpX+5L/Na7rwp/yKek/wDXrH/KuF+Ln/HzpX+5L/Na7rwp/wAinpP/AF6x/wAq93F/8iqh6v8ANkL42bFFFFeEWFFFFABRRRQAUUUUAFFFFABS0UUAFGKKKAaAUUmeaxPFHirTvCuj3N9e3EIljjJit2kw8z4+VBgEjJ4zjjqeBVRi5S5Yq4rpHA/FnXZ9YvrL4f6ON97fyxtdOCGVEzlVYAFhjAkY8YVQeQxx6PoWiWfhzRLXSdPVxbWyFV3tuYkkkkn1JJPGBzwAOK8H8C+NrLQ9R1PxHrrXWoa3qC7VYfKETOSCc45IXAC4UKMHkgU/GnxT1bxHYPbQhbG0L8xwk7nHozdx7dK768OVKjHZbvu/60JTPatW+I3hjSGeKTUlnnRtpitxvOfr90fXNcz8Q1F3q+D9z7PHtI5GCMhgR15NfPT3LEhie36V774RuV8f/D6DymU63o4Fu6k8zRgfLn6jp7rXmYqHuWhuduDmoVE5HAqn+lGBshlPzYHSr6RWxaMXMfmQrwQWxUuo6XKkwnjQieEkMrjG4ehHYisX+0nnnFvJbNCwBJ3N39B68c134jOo4/DOOLS5lstfv9fmfeYCeGqx9nW+KTstzd1DVIJV2rK0cJBB+dsnPrzzVO00691O7+x6VbyzXDLvC7gvy4zkk4AHI5PXI9qteHlQ37k8ssZK8dORzn/PWu+8OahZ6deyyXs8NvG0e0TSvtAORxknAz7+g/H4PGY+eCbVCOqX5+hlmOGq4aElTqNpa2/pnK6T4Bnhu5z4jsfl8tDBsm+ViRls7TnK8D064yMGurg0ueSQW9pbgqo+VUwAqj+Q7Va8ZeJNOs9FaW1vrOa/GwwRCTfuDYOSFOcFeQeB05555zw38RYbPVBLrMSW9jcMYIpkBIibII39zwOoxiuTK1jcwqKpNWi9Hutuy8/zPy7OMnr4+tz1pfu1trtor6Puen6NZyWOlxQy8SclhuyASen/AOqr9U9P1bT9WgafTr63u4lbBaGQOAfQ46GrlfcQpqnFRWyOujSjRpxpx2St9xwvxZ0RtT8Fzahaq66lpLC9tpomCOgUjfhjyAFy2AQSUXrjFdL4b1yDxL4csdYthtS6iDFMk7HHDLkgZwwIzjnGa0poYrmCSCeJJYZFKSRuoZXUjBBB4II7V5t8MLj+wtY8QeBp2m36fctcWfmyby1s2MdBtXqjEcZMp4GDXZH95Qa6x1+T3/GxpfU9MzRSUVyhdiUZpKKAuwpaTNGaBC0maM0UWCxkeKj/AMUpqv8A16yf+gmuF+En/Hzqv+5H/Nq7nxT/AMipqv8A16yf+gmuG+Ev/Hzqv+5H/Nq97Cf8iqv6r80S/iR6hS0lLXhFhmjNFJQAuaKSloAM0ZpKKAFzSg0lFKwDs0ZptFFguLmlptGaLAmOopM0ZoHcWijNFABRRRQAUUUUAFKKSigBc0uabRQA6ikzRmgBaTFGaM0ALzSZNGaM0AHNLk0ZooHcXNGaSilYLi0uabRRYLjs0ZpvNFFgHU0miiiwXCiiimIKKKKACiikzQAtFFJmgAxSEUuaQmgGNxSU+jj0ouJIZRS4oxTASloFOAoAbg+lGD6U8YxQTSuFhAKWkzikLUAmOzS0wNTtwoHcWik3CjdQFxaTNNLUm40BcUmm0tJTEFFFFABRRS0AJRRS0AMoooosMWikoosAtFJmjNFhWFopKKLDFzS0lFFhai0UlFILi5opKKLBqLRSUU7BqLRSUUJDCiilpgFFFFABRRRSbE2LThTaAaQJ2HUUmaKB3FopM0ZoC6FoozSZoC6PLvi5/wAfGlf7kv8ANa7rwp/yKek/9esf8q4X4uHNxpX+5L/Na7nwqf8Aik9K/wCvWP8AlXu4v/kVUPV/myE/fZs0ZFJzSV4RVx1JmkzRQF2OzRTadmgEwoozRQO4UUUUALRnFOWGRui49zxWN4z+3WXg7U7zTrlobu3hMqsgBOF5I5B6inFXdgempbvdUsNN2fbr22td33fOlVM/TJFcLrXxg0fS757e2tpb2NOGnjkCIT7ZByPevCb7WLi+upLi7neeZvvPKxYnHqTWZPdGQY9BXZGhBfFqZOTex6F4g+LOv6pLIttcGxtWOFjgODj3fqa89vb2W/n3TSO4HJZmJJ/OoJJMpjNQ7sDiuynajT9pbV6L/P5AkSS3BK4zgA8bajDs0RB6GoWBLGlHAGa4ZSbNEkMBPQ9q674c+MW8G+LIL1yxsZh5N2g7xk9QPUHkVyLjByKQ+tYyV9DRM+ytb8M2XiCFb22lRJ3UMkycpKpGQTjrkdCK8s17wpd2LNHfWeFPCvjcjfRun581c+BvjsXVoPCmoy/v4VLWLOfvIOTH9R1HtXs7osilWAKkcgjIP1Brhq4eM9dmdtHGTpLleqPmE6NHbXRmQSRSKMJIjEMOMcEe3FVLm6uLhvKnuJJlXGA7EjIGM49fevoPU/BGg6gXLWIhkYctbuYz+Q4/SsGD4X+Hracu0V1Nz0lnO39AK5Pqc3K7dzsePpuPVHkNlZXF5MlvbQvLM5wscaZY/l2qH4iW7aFHpWiu6tOkbXdxs5AdztUA98Kle/mDS/DulzzxwwWdpAheUxoFG0DJyep/GvlfxVr8viXxLeapIColf92n9xBwq/gBXpYXDql773PPxGJ9r7qWg7w94k1Xw/fvNpt/NaPKArmM/ewcjI6EfWvTtJ+POo26qmrafb3eMfvIj5Tn6jkZrxaL/WA+lPZvnOK7FZ7o42j648N/EHw/4mjjFreCG5fpbXJCSE+3ZvwrmfHjReEfH3h/xmI3jtJ2aw1NkcKrKV+RmCjc5A3N3/1SDg4r52jlKouGI2nIxW7c+MNYv9BbRr6+kurPKlFnw5jYdCrMCVPUcHoSO9a0IxjUT6PR+jIufXWaQGvHPDXxs0+LRrG01SyvGuYIVilnWUSGUqAN53c5OMn616P4d8W6L4phaTS7wSSKMyQONsiD1Knt7jiuWrRnTk1JbDTubhPNJRS1mMSiiigAoopaAMfxT/yKmq/9esn/AKCa4b4Sf8fOq/7kf82rufFP/Iqar/16yf8AoJrhvhL/AMfOq/7kf82r3cJ/yKq/qvzRD+JHqFFFFeEWFFFFABRRRQAUUUUAFFFFABRRRTAKKKKACiilpAJSikooAdmlptFKwJjqKbmjNAXHUU3NGTRYLjqKbk0ZoHcdRSZoyKAuLRSZFG4UALRSZpNxoC46ijNFABS0lFAC5NGaTNFAXQuaM0lFAC5ozSUUALmjIpKKAFJozSUZoC6FpKbmjNArjqTNJmkosFxc0lFLTAM0uabS5pAOzSZopDQF7hml3e9NoosAu6jNJRTAWkoooAKKWkoAKWkpaAEooooAKKKKACiiigAooooAKKKKAGUUlHegLjs0ZpKKAuLRSUUBcWgUlLQFwozRRQFxaKSii4XFopKWmMKKKKBXCiiigLhRRRQMWikpaACiiilYVgoooosgsFFFFFkFhc0A0lFFgsLmjIpKKLBY8w+Lf/HxpX+5L/Na7jwqf+KT0r/r1j/lXD/Fv/j40r/cl/mtdx4V/wCRT0r/AK9Y/wCVe7i/+RVQ9X+bIXxM2M0lFFeEWFKDSUUALRRRSFYWlpKsQwb8M3T0oKSGRQPLz0HrVyOJYxwOfU08YAxTS1ItKw7FVtRtVvdNubVuk0LRn/gSkf1qbPvSF+ntQu4z4dnBgnkhb76MVI9wcVX3cnnvWz4ythY+Ndath0jvZlHH+2TXZ6VpWnppNuBa28nmQrvfy8+ZnDZ5GcZ5wfb0r2sJhZYqTSdkjzcdjI4SKcle55n170FfftWp4ltYLTXriKDYifK2xcjYSASP68cc/hWVz7VWJoVpVHGMdForHRSqKpTU11VxGXg1HzipqaVB6muZ4Wst4s1TRGwBFIo9af5ZpQnrWbw9X+V/cx3RJY3lxpmoQXtpM0NzA4kjkXqrA5Br678A+MrXxt4bjvEKx3seEu4R/A+Oo/2T1FfIRQY+ldD4J8XXngzxBFqNuGkgPyXEAOBKncfUdQexrCdCb2TKTPr94Xzxj86ge0kJJI/M0zRPEGmeItLi1DS7yO4gfg4OShwCVYfwsARke9Y/j/xhbeDvDc165El0+Y7aIHG9yOM+w6msVF35bDbVrnkHxv8AFbC4XwzazAhMSXmw/wAXVUP06mvFsVZvbue/vZbq4kaWaZy8juclmJySahVc8npW77dhLQEGBmgAk5oY7jx0p+NoApolibiBilDUmOhpccVSYmSq5ABq3purXel3yXVjcSQTocrJGxBB9jVAdSp70PHJBIEljeNsBsMMHBGQfoQQR7Gums+aEZ99H6r/AIBNtT6v+HHi1/GHhZbq42/breQw3G0YBYDIbHbIP511teJ/s+3Jxr9vnjMEmP8AvsV7bXmNWbRbVgpKKKBBRRRQBkeKf+RU1X/r1k/9BNcN8Jf+PnVf9yP+bV3Pin/kVNV/69ZP/QTXDfCX/j51X/cj/m1e7hP+RVX9V+aIfxI9QooorwiwopaSgAooooAWkoooAKKKKACiilpgJRRRQAUUUUAFFFFAwooopCCiiimAUtJRSAKKKKYBRRRSAKKKKACiiigBaMmkooAXNFJRQAuaM0lFAC5ozRSUALmjNJRQA7NG6m0UWC4pNFJRQAUUUtACUUtJQAUUUUALSUtJQAtJRS0AJRRS0AJS0lFABRS0lAC0lFLQAlFLiigApKXBoxQAUUYpcUriExRilooC4mKMUtFACYoxS0UARUCiimACiiigAooooAKWiigAooooAKKKKACiiigBaSlpKYC0UUUDQUUUUDCiiloAKSlooAKKKKACiiigAooooAKKUCjFJsVzy74tf8fGlf7kv81rufCv/Ip6V/16x/yrh/i3/wAfGlf7kv8ANa7nwqP+KT0r/r1j/lXu4v8A5FVD1f5shfEzWopcUV4RYlFFLii4wApyKWOFGTU0Vsz8ngfrVpI1jHyj8alsaRBFb4O5+o6CrJPTFNY80wt1FBSVhxaml6iaT3qvPdw21vLPPKkUMal3kdgqqoGSST0AFAy0ZBXM+LfHWh+D7TzNTud07bdlpCVadwSRuCkj5eG5OBxjOcA8N4j+K17qGoPoPgOyfUb8MUkuxHvjQcLuTnBAZh87fIMfxA5qx4W+E8FrcnWPFtz/AG3q7bgwmczQgYCqTvGXYKOrcDPAyoNdkcPGmueu7dl1f+RN77HgnibVJNZ8S3+qzWv2WS9lM4hOTsVvmXk4z8pBzgZzmktfE+q2tsbeG6yiJtjDIGK89sj8Oc8H6VsfFT/kp2uf9dx/6AtcfHzMfpXdRxU3WjGHuxfRen4mNSjTqK00n6iXN3PeXD3FxI0kshyzHvUYel8ukKEV5Tcm7s1SilZBvp6yYqPbSYpxlKOqHZFhZscGniZSPuiqmTRzV+3n3Ycpc3qxwKY0mCKrZNLmr+tVn9t/excqNLTJbH+0Yv7TS4ezJxILZwjgeoLKR74xz0qO+ltReTfYRILXcfK85gz7c8ZIAGe/SqXfpQBzVLGV0rczDlRMsjMMkDFBkAO0KDUZJoHHNWsZW6u/3MVkSh1Ck4ANIGV+q4pm7Jp68Zqliqj3s/kv8hWQ8BcdKQsuOhoJGKjZs0fWX/LH7kCR6B8JorWXxRcO/wA08dqzRAxghcsoLZ6g4OOByGPI7958RobeXwNqDXA/1ex42CBir7wBjJGM5wT2BPXofCLO5ntLpJ7WeWCZM7ZInKsOMHBHPTirup63qmqxIl/qFzcRqRhJJCVBUbQcdM479Tk56mrUXUpSqJJW6fd/mfPYzJalfMYYtTslbTrp29T1j9n4j7Xr+OnlQ8/8CavdVORXhX7Pn3vEJ/2IP5tXuUbc49q8t7s+kY+ilNJQQFFFLQBj+Kf+RU1X/r1k/wDQTXDfCX/j51X/AHI/5tXc+Kf+RU1X/r1k/wDQTXDfCX/j51X/AHI/5tXu4T/kVV/VfmiH8SPUKKKK8IsKKKKAClpKKACiiloASiiigBaSiigAooooAKKKKACiiigAooooAKKKXFACUUuKMUXASilxRRcBKKXFFACUtGKMUAJRS0YoASiiloASilwaMUAJRS4NFACUUuKMUAJS0YpKAClpKWgBKKKKAFpKKKAClpKKAClpKKACiiloASilooAKMUUUgDFFLSGgQlLSUuDTGJSgUYpcUhBRRRigBRSfhRijFABmlzSUUALSUUlAC0najNBoAM0ZpKWmMjooooELSUtAoAKKKKACiiigAooooAKKKKACiiigApaSlpgFFFFA0FFLRQMKKKKACiilpXQroSilxRii6C4lLiilouFxMUYpcUYpBZiUuDS4ooCx5b8XP+PjSv8Acl/mtdz4VB/4RPSv+vWP+VcN8XP+PnSv9yX+a13XhT/kU9J/69Y/5V7uL/5FVD1f5shL3ma+DRilpVBYgKMmvCLsIB6CrcFuB8zjnsPSnRQLEMnlvWpS1K5aVhS1NY00nNN3UFAzcVAz4IpLqeK2t5pp5UihiUu8jsFVFAySSeAAO9eRaz8VtR8Qao2h/D/Tvt9w0RY3sq7VUbTkqr4AwSuGc4J42nIJ2o0J1X7uy3fRCbSOz8VeOdF8I23mancbpjjZaQkNM4JIyFJHy8Hk4HGOuBXmcVr4v+K1xHNqbvo3hsMP9HjLK1xGTvBAP+sPCDecKOqgnIrc8MfC2C0vjqniu5/trVm3BhMxmhAwFUneMuQo6twM8DKg13KuQ0h/ukY+ldHtaeH0pay79vT/ADFZvcp+HdC0nwtp62mlWqRgKFkkIHmTEZ5dsfMck+wzgADit6OdHB2nB7g1zt5KyyOobAJzWjp8bzRBjk+9cUpOT5pO7KPmn4q5HxO13Ix++U/mi1xsJzKfpXffGS0a1+JF+xH+vhhlH4oAf1Fefwf62uzDTtiIeqIa0Y8nnpjjmnYyKiJ/eN9aPMNZP3W0FiTaMmkKCkD0bjRow1E2e1Jt5p26kzQ0gE20bacW96TOaVkGoYpT1/rSCgkUWQCUtJRQB6Npvwr1bXvA+ma1osK3lxczzLNH5qr5aqcL1IHUNn/gNV734dDQIt3iLxJpOnS97WJmuZ/psQY/M4rk7LX9X0+zltLLVLy2tpTl4oZmRWPTJANUGdmJLHJPU0JPqxtmlqQ0dAI9Ne9mIPM1yqRhh7RjOPxasomjNJTbFYli4BPoKEOUYenNIvEJ9zSRHEuPUV6MHyyp031T/wDJv6Qu7PePgDZmLRdavSMCa5iiU+u1ST/6FXsCN8xb3AFcV8MtOGk/D/TIhgSXCNdvj1kOR/47trswMCNO5O415TVm7lMtmkpewpalkMbRS4owKLhcyPFX/Iqar/16yf8AoJrhfhL/AMfOq/7kf82ruvFQ/wCKU1X/AK9ZP/QTXC/CQf6Tqv8AuR/zavcwn/Iqr+q/NEN+8j1GjFFLXhXLEwaKOaKLiDBopaKLgNpaKKLhcSlooouFwpKXFGKdwuJRS4oxRcYlLijFFK4rhijFLSc0AGKMUtFAXExS0UUAFFFFACUtFFACUtFLQNIKSlooBoSjmlooCwlFLS0BYTFGKWigdkJilxRRQFkGKTFLRQAmKSnUEUCaGUtGKMUCExRilooATFGKXFLQA2jFLS0ANxRinUlAXEAoxzTsUlACelHNOooATFGKKMigBaKTIpNwoAXFLTS4phlHrQBLRUXm+9HmUASUuRUJkppl96AJtwo3iqhn96T7R7igC7uFLxVJZ896nSTNAE1NxSg5FLQA2jtTqSgBKSnUmDQMZiiiimFgooooCwUUUUDCilxRRYVhKKWiiwWEopaKYgooooHZBRRS0BZCUtFFK4XQUUUoFJsLiYpQBQBS4oFZhSYpaKAEpaKKADFLSZozQO6FoozRQMWikozQB5d8Xf8Aj50n/cl/mtd14U/5FLSf+vWP+QrhPi5/x86V/uS/zWu68KH/AIpPSf8Ar1j/AJV7uL/5FVD1f5shfGzZALMFUc1ehjWNeDk9zTIIxEuW+8etSHB5UjNeCzZIUnINRk0hYL3waiuLmG2hknnmSKGNC8kkjBVRQMkkngADvQMlJrkvGvxB0bwVak3kvm6g8Rkt7KPO+TnAycEIue59GwCRiuH134q6p4j1FtB+Hdo91clRIdQZQAqjlsJIAAPujc/ckAZKmtLwf8K7DQboavrVx/a2tmUTieTdsikxkkZPztuJO9ueFICkc9qw8aS5sRp/d6v17L8Sb32Odj0Lxb8W501DxBO+keG9wuLO0jClnUnHHQ52gne4/iyq7WIHqOk6LpfhvTlsNHs0tbYMX2KSSWPUliSSegyT0AHQCrzT4PWql1dLGhyayrYiVRcq0itktv8AgjSsNu5hFKhJ4IrNe5VZ7g542E1S1fVUFuku7hWYH34BrOtrLV9btZGskRUfajSyttUDGTjqT+Fc4FuCY6lcRpFyTgflW7/a4BNlparKycSXBOI48f7Xc1yfizQ9R8OfD6/vdOvTJf24WSUhQFaMHDrg84wc/wDAa8et/idew6fNbyabayTshWKYu+ImIxuCElcjtQ47ME7jfivqcWp+OLxobn7SIES3MoOVZlHzY9gTgVxMRw6qPxokYkDJ5zk0kXDg100WlXg+l1+YugsvHHuaaEJGcU6XiTHanjGBilVi1Ukn3Yr6Ee3AopzE00AmlYBKXijHtS4pgN604ClAp3QUWBsaeppPwpTnmkJoEJRxzRSUhinik4ooBoGFAoNC8sB6mmld2QEkhwij8SKfY2txf6jb2lqhkuJ5FjjUEDcTxjnio5DmX6V3Pwl0STVPGkV0V/cWKGZ27ZIwo/XP/Aa3xc+WveP2Xb7hR2PZfhRqI1XwLYGSbzJLTdbS/Lt27D8i9BnEZTn+ua7mLLM8x9OK8x+GEg07W/FXhgRpbQ2t8Z7eFyRIY2JX+I5KhViwf9rqcivUWG2ED1NZ4qKVaVtnr9+olsTocqPpTsVFEflxUo6VzMGrhijFFFILIx/FQ/4pPVv+vWT/ANBNcL8JBm51X/cj/m1d34q/5FPVv+vWT/0E1wnwj/4+dV/3Iv5tXu4T/kVV/VfmiGveR6lRS0leEWFFFFABRRRQAmKMUtFAWQmKKWkoE7BSUtFAhKKKWgBKWkpaACikooAWiiigApKKWgBKWikoAWiiigBKdSUUDTsLRS0cUDuhKWkzmjNAroWijNJuHrQO6FpCwHemO+BUDy44oFcsbxTtwql52KUTUBcu5FFVhKKcJRQFyekJqLzRQZBQDZLRUQkFKJPegRJTdwppeo2kAoAm3CgsKredTDN70AWS/vSh6pGYf3qRZxn71AGgGFLkVUWb1p4kB70AWM0ZFQ7/AHo3+9AE9NZ8VCZsVBJOB3oAsGUUhlrLmvkXPzVUl1NAM7qBXNwzj1qNrhR3rnm1ZQPvVXfWRg/MKVwudIbtfWomvVz1rkpNaxkF6py64oGd9Q6kVuws2dub9QOtPW+U9xXApr6ycbqni1gZ5ap9tF7MpJ9TtnvVA61A2oJz81cpLqwAyWqhLrPo1J1UgszqptUVSeeKg/thfUfnXGXGqk5+aqR1JyfvVm8QlsNQuemWmpqx5ataC5VgMGvLrPVmGAWrrNL1HdtBatoVVITTR2aSdKl3Vkw3QOOauxycA1qItA0tRqwpxagB1FM389aXdQAzFGKWii47iYpaKKLhcKKWkouFwooooAKKKWncLiUUtFFwuFFFLikISilxRigBKXFLS4oCzEApaKKCkgooooASiloxQKzEooxRigLMSilxRQKzEpaKSgBaSiigDy/4uf8AHxpX+5L/ADWvQPBsZbwrpLHoLWPH1wK8/wDi5/x86V/uS/zWvQ/CLD/hDtI3Yx9kj/lXu4z/AJFVD1f5sUPjZtMXXlpgo+oqlqGuabpUXmX2p20C7WYCRxlgOu0Dlj7D1qziPOVhBPrXjfxaiuR4otppQPJe1VYmVCAMM2VznBIJzxjhhx3Pn5Zg44vEKlJ2R6ODw6r1VBux2niv4n+GvDunNI19b392yEwWtrL5hkIwOWGQg56nsDgEjFedponiv4rTRaj4hnfSfDW8T2ltGFLMpOOBwc7QTvcfxZVdrEC18L9I0XVNenuNRjtZrywVJrWORj5ikkgyKobBAIHJU4JUggjn16aOGbdtL56dcj+tdOLhDL6zo0tZL7T8+y/UzxVBUqzpp3SMrR9K0rw3py6fpFolrbBi+xSSWY9SWJJJ6DJPQAdAKnkuODz0qpdO9mH85SYx0kTkY9/pWNc6vHG0ZaQYc7Cc8HPQivKbcnd7mBp3OoJGpwa5zUNWlml8qBHllPRIwWJPToK1LPw7fajiW9kNrAeQBzIwPt0XPvXUadpdrpUBitI9oJyzE5Zj6se9IG7HPaL4XEtrHNrMIkkzvW3JyEJ7nHU+3SupVEjVURQqqMBQMAAdgBT6KSM22yte2kd/Y3FlOMxXETROD/dZSD/OvizVLGbS9VurGdcS20zROP8AaVsH+VfbmMivmr446B/ZvjX+0IkIh1GMTZxxvHyv+eFP/Aq1guZNDTseWMxZqfGPmH1pCuKevysM881VJWmrlN6aDnz5hOKZ70+QkPTN1b4nStO/d/mSthadjaKj3elG4+tYXQ7DzRwPXpTM0ZzTTsFhd1Lnpmmd6UfWi41YUnNHSiikITrQRilIFGaYCUlFFIYU+IZkHtUZqSPhHb8Aa3wqXtk3stfu1E9ieztJr+6WC3jLyucKo7mvpP4feGofDWhx242tcyEPO4/ib/4kdBXj3w5t4E1FrqYFpFAWJB3YnGPxr6A0dWWMbjlz19MmuacnJ6jOSXytH+P8Kxo8jazpmJCzgCNlzyBjkYgAx6sTntXpjN5khHZR+teZfFkR6fN4V8RTSOY9N1Nd8KICzAkOSCSOR5OMd93UYr09I/Lh98V0V/ehCflb7v8AgWEh8fGPpUuaiPG2pK5GDFzRmiikRdmR4qI/4RPVv+vWT/0E1wvwjP8ApOq/7kX82ruvFX/Ip6t/16yf+gmuF+En/Hzqv+5H/Nq93Cf8iqv6r80S/iR6lmikorwi0xaKM0UDCiijNAXDNIaKKBXuFJTsUYoCzEooooEFJS0UAFJS0lAC0UUUAFFFFABRilpu6gBaXFN3igMKAHU0kU1mqNpQKAJt1G4VU87mpFlBoAsA5oqNWqQUALTCcU+omoARpMVEZ6ZK1ULi52A4NAXLslwB1NUp71VzWTPqOMgtWPeanwfmqHNLcdmzek1VRn5hSR6opP3q4WTU3Mp+binjUXUcNXO8TG9ilBnoSaihH3hUq6gp7156usuOpqxFrIxy2KpYiHcHBnei+X1pReoT1FcQNW5B3VIuqEkYaq9vDuHIzt1ulPepRcL61yEWpN3JqxHqWDyapVYvqHIzppLhQOtVJL9B3FY8uohl69qzJrx8nBpuokHK2dG2pKTjNQyah6GuWe7cPkZNTLOzDOazdeOw+RmzJqZH8VEOp5/irDkZiOtRo7K3U1m8Sk7D9mdfDqAbvVyO7U965KKZhzmrSXxHVqtV0yXBo6gXI9aX7Qtc6t5uHWh79o+N1ae0QkjcmulA61lXWpKoODWVcamQDk1z99qvXms5V0h8tzR1HWTEGO6sQ6+7Zyaybu6aUnk4qmOfWuWeJb2GoG7JrTnoxqnNqcp6MaodKYTWDryfUtQL3252HzGonnZj1qrvA70m8E1k5yZSSRMJXU5BNS/bZAB81Vs0HGKFJoGkyf8AtGQdTkVC9/noarSdDVMnFPnZNjQ+0knrSiXJFUUY8VZQUczDYuw3BVutdBpmqGJlyeK5dcjtViF2Ugg9K1hVcWDjc9S0/UAwBzxW7b3qnABrzbStQKqFJro7W+GR81ejTqqSMmmjtFmBHWnNOo6tWFFqCBeTUM+qKCea3TRDZvm4XsakScetcdLraqfv1Zt9XEgBzRdBdnZUu00uaM0yrCbaMCiilcYuBSbR60UYouLQNtG2l2+1HNFwsJto20vNHNFwshMClwKAD6U7bRcLDdoFHFO2UbaLjsN4pc0u2l2+9Fx2GZpc0/aKMCmFmM5pM1JtpNtIVhuRRkU7aaTBouAYoxRg0Y9qLgGKMUYPpRii4BijAoxRg0XAMCjAoxRg0XAMUYowaMc0XA8t+Ln/AB8aT/uS/wA1rtfDEssXhTSdiqc2seC+cDgelcV8Xf8Aj40n/cl/mtd14UAPhHSgef8ARY/5V72M/wCRVQ9X+bIj8bNPzNRb/lrZqP8Arkx/m1NcLJC8F1epMrqVeIRZVgeCCozkUudjeW3I7Z709pViUGW4SFOwHGf618/sbo4Px54Cm1W4j8SeG3ltPEloQyykKiXIAxtbdgbscAngj5W4wVs+AfiJa+NdN2FUt9WgXNxaoucjgeYmTjYSfqpOD2J7DfA3zCJpPRpPlH4ZyT+VeW+P/AF+mp/8Jl4NSW21a3YzTwwIV8093QHq5GdykYcZ4ySG7qM41o+yquz6Pt5Py/Il6ao9HvIJJ4is+1YyOkh3E/nx+QrO0TQ9Ltt6mATTJIXQ3ADFAem0EDAGag8HeLNO8a6P9usy32hMC6tSQDbsf7zdWBwcN39iCBruojmV0YySKeFiU7fpxxXPOEoNxkrNAaWKWo4JVmjDL+IyMqfQ471JUEhRRRQAmK86+NGgf2v4Ie9RMzaa4mGOuw8OP/QT/wABr0aorq2ivLSa2nXfDOhjkHqrDB/Q1UJcrTBo+IZRg496NoIzWp4k0ibRNfvdMmHz2szRk+oB4P4jmspW2mtZLUE9BZfvD6VF1qeQcg0xkHUGujGr9/L1CL0Izx9aSnqD3oKcZWuWzKuNFAp21qMU0hXG4p2PegClximkFwx09KQinY60mRj3oegCE8UmaDSUN3AKQ0tNNS3YpIM1Oo/dKO5NQV2vgDQbXWfEEsmow+dpunWkt7cx7ivmKi8LkcjLFa6MO+WnUn5W+9ky3Oi8C6ZLZKl7cIoJGUBIAVSPvH3Ney6NcRtbkpkkY5xx+FeG+EXyIrfJWFHyRyeSc4HsK9x0mFYoEIdXBHGw8f8A66429dSuhnfEnTDq3w91OJUiMtvF9qVpR9zyzuYqcHDFQwH1x0JrY8F6gmreB9Eu1uJLhpLWNZZXyWaRRtfJPJO5W579ea0Z7S2v7C4tLoebBcxtFLGCRuVhgjI5HB7Vw3wamuY/DV7o9/IoudKv5YDbhlLQrwcHHUF/Mwec4ODxXUvew7X8rv8Af/wxPU9GI+ZQPWpsVGozKPrUrjDGuYGFFFFSQzH8Vf8AIqar/wBesn/oJrhfhJ/x86r/ALkf82ru/FX/ACKerf8AXrJ/6Ca4X4Sf8fOq/wC5H/Nq93Cf8iqv6r80Q/iR6jRRRXhFhSim0tAJ2FopKKBti4oxRRQMKKOKKACkozRQJsKKKKBCUuKWigBMUtFNLCgB1JkCmlwBUTSUASM4qNpAKrvOBnJqlPehc80rgaPm0qyGsAaou/Gatx3gYZzRdAajScHmqFxdLFnmmNdD1rF1S7wpwfxobQy6upAyYzWnbzq4BzXnaaiRcEbuM10dhqXyjJqFNNhZnXo4qVXFY9veBh1q6kwPeruIu7qY/wB2o1k96GfIpjKd05VSa5m+unGRXR3Zyp+lcpqP3zUTlZXBK7MO8vH8w81nvI8ufers0W9qRbUeleXUqtm8YpGV5LZJoEbFsVrfZcnpThaAEcVzM1VjNW3JPQ1YjtDmtFYMfhU6RD0qWxmetpjtUqwN1q/spwQCi49CBAwABqQrxTwFp4AIpqbQ0kVzuqJ9xNW2UUwqD2qvaN9QaRXWLnpU4jxTlUVIKEyHYiMeRTTGOtWTioXI9KGwSIixAqpLcmM1NNJisq7mGDQpA0Wl1RlNK+p7h96udlnOetRec5HWmqr2JaRs3GohsjNZE86setVnlOTUBY5zScmybFgEtRtINMjapgcjFTcEhj5qu7dankPBxVSQ5oKSGGU+tOVyTUPOeRUqLQgaLCN61IQSKYgOKmAoYitKvFUH61qSAEVTkTBoRL3IEFW4c1AOM1IjcelUwSLgxSg4qBZOetO3+9TYpF6G5MR4rVh1XYOT0rng2cUbiO9aQm4g43OnHiAjjP41HJrZK/frmy2e9MZjiuhV5bEOmaF1qbsw5q3Y648eFNc9u5pQ5B61m6rTvcORH0zQKMYor2DIWlxTaXNAC4pRim5pcigeg+jApuaM+9ADuKOKZmjIoAfRTN1LuoC47mkOaTdS7hRYAopcg0cUrAJRS0ZosAtFJmkzTAdRTM0Z4oC4+imZoyaAuPoxTc0u6gLi4oo60UAFHNA607IpANoxSHGaWmB5X8Xv+PjSf9yX+a13fhQf8UlpP/XrH/6CK4T4v/8AHzpP+5L/ADWu88J/8ilpP/XrH/6CK93F/wDIqoer/Nma+NmpLF5sZHQ9j6GqkX7uQ7lAccE96v1DPDv+ZfvAfn7V4LRsnYNyAZ3cnsELMfypGJ43gKO3m/MfwQVDHKVODkc1ZTaeRwT370kM8n+IXhu88M6iPHfhaGRLuNydSt9q+XPGeWdkBBxkDdj1D/KVLV1vhTxfpvjbRftltI6zJhbmz4HkMexx94HBwx6+xBA7A/KMkgD1NePeJfC178O9dk8beErJH04oV1DT2UfLGSCzR8ZVMgHj7hGeUyF9CnOOIh7OfxLZ9/J/oQ9NT0u2mW3m2BSI3PQJwD68VpmuX0rWdN8V6LFqdjeSz2z8MjusZRx1RlHIYZ/kRkEGt6xuBNCFJXzFGCEJPA6devvXJKLi7PcCzRRiioEFL1pKKYHz78d9EW28S2epxLgX0BEn++mB+qla8fcY7V9T/Frw22veDXngGbnT2NyoxksgGHUe+OR/u18tSqVY5roTvFCWjHfeUD1FN5HFLztUe1IGB4J5rpxf8V/L8kC2GspOeRimfMvTNSlR1zSFgBjrXK0VcZuyAPSjdntigkelGPehOwB6UE000maLhYdnrSGkoouFgooopDENJS0lS9xofEMyCvffgh4fhvPCXiG5dtsl+TY7wMlECZJ/N8/8BrwWEYYn0FfUvwY08WPw1s5f47uaW4b8W2j9Froqvkw8V3bf3af5k9WeU6FZto3iaXQr8GO7gcoCAcFh3+h6g17FpRCj29hXIfEWzWH4iWlyOGuLaMggfxKSMH6gV1elSHy1JGDgZrke5Sd0dNEybRgk+5rzbwr/AMSD4zeJdHb5LfVIhextPw8r53ERngFcyTdAT8nXg16JE2QMmvOfGTDSfi74N1kES/at1h5X3dmSV355z/r84x/D1546sL73NT7p/etf0Ja6nq8QzIMCpJPvD6U2F4xna2445PYU1G8wNJjq3H0rmG0PI4pMU6jAqSbIxvFQ/wCKT1b/AK9ZP/QTXC/CT/j51X/cj/m1d54rH/FJ6t/16yf+gmuE+EQ/0nVf9yL+bV7uE/5FVf1X5ozfxI9QwaMGnYorwi7DcGinUUBYZRT6KAsJiloooHYbg0uDS0UCsJijFLQSBQFhMUmRTGeoWmAoBosbhRmqnnined70CsWHbFV2kqJ58d6oXF6Ezk0rgXnuAO9VJr0KOtYtzqyg8Gsq61UYPzc1EppbjSbNq81MIMg1iXOrK2fmrAv9WznBrHkviTkE1zTxC2RSgdI2qBZfvVsWeoCRR81eeG6ctWvY3rKF+bis417PU05Dtmu2I6k1k6jcZjPPaoI77cp5qhe3OVIBqp11bQFAy2uzHcde9btjqK4HNctPHlie9CyvF3rljibMp0z0K31VQRhq2LbUQ2MmvM7G4diCTXT2NwcDmu2GITMXBo72C4DAc1K8mBWDZ3eQMmr5n+XrW/OrAkF1KSDXOXoMhNa1xOMECsuU5NctarpYuMepniDnmn+UBVgjFNNcDZraxDs5o2c0/IpN4qGwDZSZA700yYqu8vNQ2Fy2HBoLriqPne9MafHepuO5e3ilEo9ayzdkUi3fNFxpmtvB70hb3qik9SebnrTTHe5YElPVzVZWFSCT2pqQrE+6o5GPrTPMNML0XKRVuCayrhSSRWtJzmqUqct3p3KdjFlhIbNMYEAirsq8kYqqw60JGT0Kb9TUDHBqeXkmoHHaqsZ3HI2BUokHTNQDFNLdaEilqWHfI61ARk0gJIpy80yrDNnNSRigrUqAVLJHKacWOKYetFK47CM3FVpW5NSyNiqznNUiWMyM04Pio8Gl2ntV2Bbkpk6etPVicVDsIOamjjyAaTNEieMZqXZT4IuOlWRbnpilYtIolTzxUe3rWp9kJ7U37GT2pq4mjIdcc1ET61rPZnniqbWbbvunrRa+5nY+ljTaKK945gooooAKKKKACiiigAooooAKKKBQAtFFFABRk0UUAGaM0UUAGTRRRQAUUUUAFGaKKAF60Z9aSjsaAHA04GmCloAfRimAmnbqB3FopMikJoA8t+L/APx86T/uS/zWu68KE/8ACJaT/wBesf8AIVwnxdP+kaT/ALkv81ruvCn/ACKWk/8AXrH/ACFe9i/+RVQ9X+bM18bNrNLTKK8E0uQ3EBk+ZPvDt61VjuChw3r9K0Qar3VqJhuU7ZPXsfY0mikx8cgbkFE/2vvH9elPUpuyGeR/UDc35ngfhWSk7wyGJm8pwekiAj8D0q+k0nAa5Kk+oAH4YoTGeMeItI1j4U+KJ/FGgQG48P3Un+l2ZGEi3H7h2jCrk/I4Hy52nOfn9V0y/i1zS7HWbF4/s08Yljw3Iz1UgMRuByCM8EEVqy29vdW8lvcSi5ilUpJHKNyspGCNvQgjtXkt9Yah8GtafUtNil1DwfeOPtNq3zPZucAMCenYAnrwrc7WPoKSxUVF/GtvPy9e3chqx65FKJVGeH7inms3Tbm01Wwg1XTbtbiCeMyJKn3Svp6jByCDyCCDzWgjqw4P1HpXFJNOzBodRRRUiEKq6MjruVgQw9QeCK+PfFeitoniLUdMZ1YW9w8cbAg7lzlTx3x196+pPG1zqFn4K1a40wst3HAWVk+8q5G5h7hdxFfJGpM7y7ixJJzk9zXRSXutsTetit/AM8dqawBHFK2ZY89+tRqxNdWK+KL7pfkCQBiMCkPNPdciowStcjdilqIc0cinBhxxQ7BmYgAZPQdB9KQxtHakJoouAtFFIelMBaTNGaSk3YdhaKTNKOtJO7AsQjC/U19e/D63+yfDzQYTwfsasfqxJ/rXyGgOEUda+09Gt/seg6dbY/1NpEn5IBXRjdHCHZL8df1IWzZ598UbcLqml3e3cDGUI9CrZBz+NXNGljlhSUk+4kG3bWj8QLJpbK0vVmEflSGNsjIIbofwIrE02AQ7GmkWaTqFxxXI+jLjsdfFIqoDkEEcYrhPjJZTX3gM3EZUR2d1HNJuJyVOY+PfMg/DNdzaRCWNHf5UwP8AIqp4otv7W8J6rplvbJcST2sixo4GDJtOzrwCGwQexANbYefs6sZdmJq6NXTdQh1XSbK6s1dYLuBJwHADBWUMAcE84Nam0RxAehFcB8H9UN98O7BN8k72rSW8hYnKkMSq5PUBGTGOAOO2K7+TPlHI5PaprU/Z1JQ7ML3QtNpVIIpKxZLMjxV/yKerf9esn/oJrhPhH/x86r/uRfzau78Vf8inq3/XrJ/6Ca4T4Rj/AEnVf9yL+bV72E/5FVf1X5oh/Gj1KjNBpjGvBLFLCm7xUDyiq0lyFPJoAv7/AHpQ9Zv2tPUU9blT3pXQGkDS5qokwI61IJadwLGaTJqLzBSNJxQA5pMVE0vvUMsoXnNZ1xerGDk0mwL0lwBnJrPudQRQeayLvVOvOK53UNZIBAas5VEhpX2OpXV1LEbqmGqp615iNYkWYndxV+LVXPO6svrCZXId1LqYweawtS1XaD81Yz6uSp5Oaxb2/aU/eqZ10loCh3Lk+rP5pwxNU5tReSs1pcnrURc1wzqts0UbFiSVpDyaZ+NQbjUiHNZ8zZSRMi5NX4MgCq0SZxWlbQ5Apc5SVyaMPjg0548jmrEcIp7RjHNTKVzRR6mW8A9KqvDzzWrLGecCqzx+orFuxVkyC1G1unFb1m4wOayVjwfSrtuxFbU520MZQ1OhgnCgZNWfthxwaxI5uBUqynNbe3a0RPIaZuCajLiqgkPrS78is5VG9ykiV3FQvKM01396qSP15rJyBomaf3pjT8VSeQ1E0retZuY0i6Z85xUTyiqZmNMM2c0lK4mi0ZhnvTHl61ChJpWzmmrsRFK5B60yOU5p7xk881FsI7VVhl5Z+BVmN896ys4qaOfb1NDYXsaquaeH96oC6HrQbsYouguX3kwOtRCYHvWfLdHnmoVuST14ppgmaTyDnFVZpQBnPWqsl31warS3PHXmqQNkkknWqcsvGKY9wKhaXNWkZtjWJwajOSaeTxTOOtMkaRio3NTMQKgJyaaRSFB9qep9KhDY7VMvPapa1NE7koPFSRketQE4NSIQKlsbSJcHNGOKNx600uam5DQx0FRGPJNWF5609Y93QVcWTYqrAT2qQQD0rSitsgZFS/ZhitVsCMnyCT0zVmC3YkcVfS1Bq3BbYIyKGjRPUht7UEj5eRV+Oz9RVy3t1UdOtXFh6GkU2Zv2QAUn2U9hWv5PFR+UMUmiWzIa0HpUbWC+lbLIM1GyrRck9Vooor3jmCiiigAooooAKKKKACiiigAooooAKKKKAFopKKAFpKKKAFpKKKAFopKKAFooooAKKKKADJpc0lFADgaKaKXNAC0UmaWgDy34u/8AHxpP+5L/ADWu68Kf8ilpP/XrH/IVwvxd/wCPjSf9yX+a13XhT/kUtJ/69Y/5Cvexf/Iqoer/ADZC+NmxRRRXglhQDRRQBHNAky8jnsaqxq9s21Qw77YyMH8DxV4Gh40lXawyP1B9RSaKTIv7RW2iBlhcMxwg2DJP4Zpb3S7TW9MnsdRtY7m1ul2SxydCP5gg4II5BAI5rPeK8h1B5ZWEtsFAQj7y+uR/UVqW1wWGAwP86Iyad0UeKW0Gp/BXxasN1PNceC9SlI81o9/lNjgsB91xgZI++oJAJXC+0q0Vxbw3NvJHLHIgaJ4mDIykZyCOCCO9S6jplhrOl3GnajapPaXC7JIn6EfzBBwQRyCARyK8TsL7WfAeqX/hbQb5tVs47ndbJJF5jRD77IAp+ob3DEBSTXRicTTlT9rUdpLfz8/XudWAy+tjajp0baK7u7JI9ka4jiXdM6xDcFy7hQSegBPc+lYWteMdP0oMkDrdXIB+WNwVX6kfyFeVeMrjxTrNxBcaxay20K4WGJImWJSy57k5Y98nPbg5rQsvBbQQETagWkYDO2Pgeo689uePpXh4nN8NSinzb7dfyJxNKjgZL63NK/bW9vS5du/HmsT7it0IVbjakSkYPbBBrwnUkP2iaJsZR2H4Z4r2vR47F1uFiKTSW1w0EjFD8rr1AyP1FYlzc/D2W/L3UULzFHR5I4pNnp0Xgk7iQwB6ZyMCvQypYrF1pU6cG7K70en/AA/Q8LHZ/Q9vLD0KMpcnWKvf/gefU8eBxH/ummsAfmH413niLwhbXE/2nw5hLd4w3kyvn5v9hucg+5698dOC3YORXt42lOlyc6tp+X9I6MJi6eJhzU/ue69Qyf8A61Ifm6UpweRTQDzXA9TqQmMUZNBGaQg1L0KQtJzSU6kAUlFFO4BTaWkpNggp6jJA9aZUsIy49q1w8Oeoo92Jl20j87UIYwMlnVQPqcV9r7SmE/ugL+XFfGfhiE3firSoRn97eQr+bivs5jmRj/tGli6nPVcu5K2Oe8XRLLp0CujSRmQ7ggyc44rn9L1C1s4/st55kkI+5vgYPH7ZxyK76SNJYyrorKeoIyK84u1uYtfv1Sa7t0FwwXBLRgZ4wuRgYrC+hSOhhvtKUhUe7k9FELn+QrH+JGoMnw61L7BFLGH8tJJDujKoXUHHHOc7SOOGPPY6djBdTRBn1G8kOeilYx+QFaIsJHikinuGeCRSkkcxDqykYIIPUEVvhayo14VWrqLTt6MGrqx81+ELi6tfGWiy2Z/0j7bEqr5hjD5YAqWAJAIJB4PBPB6V9ZSSHacwj/vr/wCtXj1nYWnhv4/W1vbW9u8WpaeXhVIVjW1YK2SoAwSRCwyMf6w/j682T1xXsZ/mEMbUpzhG3u/n/kRCNkyOKVm3BojHjpyCD9KeTUDvtc1GZ8Gvn2U0UvFLf8Upqv8A16yf+gmuE+Exxc6r/uR/zaux8UTg+GNTXPW2f+RrhvhhKIrjUs90j/m1e5hH/wAJNf1X5oiXxo9XMlQSS4qk18o/iqrNfrg814PMWS3N6Is81h3ep9fmqvqN5nJzXLX1+VJw1YVKqiCTZ0J1Y5+/Vq21fP8AFXA/bH3E7jUyaiytkNWCxOpXIemRamMD5qtx6gp/irziDVjjlqurrJUdTWyrp7k8rPQ1vAe9I94AOtcTba0H/i5q4dTyOtaKqnsNI2bq/wAA4NcvqOrlC3NF1qOQea5bU7suxwaxqVrbFqNye51gH+Ksme8aUk5qhLI+eajV2zz61xudzRKxOXyetWY52UEVUQZOasKmB71DdirD3uGzVdyTTyvNMIGKhyuHKRmkqTb6inrESOlQ2FiEAmpY15FP8ojtS7CuKVxpFqAcjitm1HTjpWXaJnBIrZt1IUcVN7GiRbVaeY8iljHc1OoqWyik0FQNb+1apjHpUbRD0pMDJMBFPVT0q3IlMRKaZLQ1OMVMDijbTsHFFxWFDmpA3rUPen59KLjshWNV5AealOTUcuMUmFik4OTzUTAAE1K/rULmsmhpFZy3SmgNipD1p4HHNEUKaHwrxUuzJpsVTjFdEVoYsTy+KieMA1OXwPeq00wx1ptDTKk/GfWqbzkHGaknmHODWdI+azaYM0EuBjk0Ncgd6yfNx3pfNz3ppCuXnuD60zz2NU95JqxCpNCQdSTzDUUjtjk1ZEWe1RSxHFWtAsUi5oL9aJEOTTAKsVrjw59TQWHNRHI96jZsdKpEuJI7GmqctUe8mp4U3EVSQJWJFjyOlP2EAYqzHHxj1pzQ/LUSKTKWDnmnrxUpiORxSiOotcu6Isnk4pMknNStHQsRqWgSuNXJq7AtQxw5PStGCA8cU0yZKxPCnFWhFkdKdDDx0q2IsDpW6ZKRVSEDtVuOICk2gGpYyOKTdykTxKBUyviq/mY70jSe9RzDbLocEdajZhzVRZsd6cZfei9ybhJJg1A8wFMnlwCc1ly3RGQTUNhc9zwcUmDT8UV9Fc57DCDRg0+j8aLhYZg0YNPoouFhmDRg0+ii6CwzBowafRRdBYZijFPoougsMo5p+FowM09AsMop+BRgUBYZRT8A0bfegVhlFP2j1o2igLDKWnYHpRtFAWG0U/A9KMD0oCwyin4HpRgelA7DKKfik20CsNpcGnYHpRj2oHYaKU07AowKAseVfFz/AI+NJ/3Jf5rXd+FP+RS0n/r1j/kK4b4vf8fGk/7kv81ru/Cn/IpaT/16x/8AoIr3sX/yKqHq/wA2Zr42a1FLilwK8E0sNopcUYoEJRRijmgBageEqd0QB9VP9KmxS0NDTZXm1S2srKa9u5hDa26F5XfooHWvNPBuvL4i8earrD25thdxlbZWcAlF2DlccsQueDxgjB7d34h8NWPiWySzv5LgWvmiSSKGTy/NIHyhiOcA88d6858ReDL3wvaPdaduv7BfvZwJYV9Wxwy+4xjvXm5phpYnDSox69T0cDVUHJc1uZW/r7jovijfx6f8PtRkaeSKVjGsBim8pzJvUjacHOMFiByQp5HUcHD8WdDa0Ek1rfJMNoaJUVuSDnB3AEAjHODyOOuKF3o8PiSwAu5nEqjEcxbcY+AB+GABj0H0rz57TUdC1k23ni2uF+7IHwkg6jnoVJA68euMHGWQ8OZfWwToV25VIty/l0aSt1utO1zjzTLlUlFz1j3R1P8AbWp3msztoXiF5pb25LC2mjysanceC+eFX+6Ow46Cop/BF/bQiZpoJFUZlVGIIGecZHPHPbvx67XgrQLm/uItSuILaxNkz27xx267pyV5bOAF6rgjOfm6A8+iabb6fb6i8d+0EubaSRIZVOHwyqevy9XUYPUsMA449ivnGY5HL2mCgnS93m0i27aJXVm1Z6PdGeExWQqtOhUdqy6JSV7K+7vqlfd+h5lFPJbxxosh2qqgLtyAB0H5V5xqtlLY30kchU7jvVlUKCCeuB0+lfQ+rQWmsRlJbG2hOFCvBEEcbeB83fgYweMduBjwzxc4j12WzIb/AEb92S8e0sc5z64Ixj9OuTEM9r5pU/erlSu7dvmtzrjmuQZlhpPAQ9nWja6tbmXfTdL5NadDnOQaesg7ihl+lRkYrd3T0OTcmEijvTS6k1GAO9G2k22Fh+5cdKZmkwaMUrsdhQaWkopgFJRRUsAqeLhWb24NQCpxxAPc12YLSTn2Tf6fqTI674X2pvPiPoERGQLoSH6KC2f0r6zBNfNvwHsRceOpLsji0s5Gz6FsIP5tX0gWNcdR+8U0LmuY8QQXcGqR3VvEGhnUCQg8h146e4/9BrpCxrI18k6YWxwjqWA/uk4P86hMSVirAsoUGW98tD2wAa0oBDwRIZD69axrC3QEsIgxz1PP863YTwB8oqrlHnvxYnk0fUPCPiUSSJbadqBSdYmIldX2sQvQEFY3BBIzuA6E16gzcVwXxc05dR+G+oN5DzzWjR3EXlg5QhgGbA7BGfOeAMntmui8L6k2r+ENJ1CS4S4mntImmkTGDJtG/pwCGyCOxBFdU/ew8Jdm1+v+ZPUtXk3lRF/Q/wA6xpdTwfvVpav/AMgu6I6qm78jmvN7vUmVjhq8+vPktcaVzd1/UxJod7Hu+9Cw/SuO8I3wsZLsk43Kvf61X1DVHlhkjzwwxWTbyMhbb3r18JW/4RcTJdGvzREo/vEj0R9aB6Nmqsus8HmuThncdSam81mr5V4ls35DQvNVdgRurFlnLvyakmQ1WZa551W2CVhrS4pUl3HFROBTo0wRSUh2LaMwq2h3Y9aqouKsxiqU7DsTI7RkEVaF66pUO3I/ConFV7VrYfLcbcXTyVRYFic1aYVGItxqHNsaXYovAGOAKZ9nbPStbyMUv2YGpUmjRRMkIytU6oTV37MBUiwADpQ3cEjOMRpnlc81rGDI4FM+yE44qUwZnCE7sY4q/HakqMCrkNkOPlq/HAFGKGwSMVrVumKclkSckVtiD2p4twO1F0NozYbYqeavxIRipktwD0qRY8VLZSBBxU8YpiqOlTIKENodt4psi4FPB5pjnNArFSQZpqr7VMy5NIENAmNC5PSl2gVJsNNYUWEV24NLmmueaQGiwmxxao3PFOzmmuvFS0NFOQ9agbNWWQmoWjOeRRYtMrnqaeMcU8RnNP8ALBIFNIUlcRTinNKAKc0WFyKpzMfStVZGLi0JNPjPNU5Lrg81HcynFZcs5BOO1G5DZammznmqhkzVczEnrQGpWFuS9TUirUcY3EYq3HGx4p2Q7DEiJNX4ID6U6G39qvxwEDkUJDsRLEMUySMYNXCmOtVpsY607A2ZksWc1VdAD0q9KwB61Vcg8U7XEmisQKhbnoKsMp54pqwtTSKb6FdVO6tG0izzUa2xz0rStIgvNWiCeKDoalaHgjFTpgYpWIxUTKRntCAeQKBGOwqdyM0KARioQyuYwTSmL2qwFAqUKpFSyo2IIo88YrQij4HBqGIANVuJxnFOIpalqKPipWGBSI4wKHcYq7kEDvjvTEnUd6gupMAgGsw3LAnmpbFc23mGM5qNpz61mpdcAk04zg9DUNjbLiXOG61M03HJrJEo3c0rXGRgGhMhstT3BwRWTPJyeeafLMapyEsaGxJn0lgUuBRRX0WpImKXAopc07gGAKQgUUUrgAAo20uaM0wsJgUu0UUUBYTbRilooCyE20m2nUUBZCbTRtpaKAshuKMGnUUXCw3FLg0tL0oCw3aaXaaWii4WQm00baWii6CyE20bTS0UXCyE2n1o2mnUUXQWQ3aaNpp1FFwshu00badRRcLI8p+Lwxc6T/uS/wA1ru/Can/hEtJ/69Y/5Vwvxg/4+dJ/3Jf5rXeeE/8AkUdJ/wCvWP8AlXvYv/kU0PV/mzKK99mvtoKkU6ivBua2G80nNPoouKwzmkz7U/A9KMD0ouFhuaM+1OwPSjA9KLhYQUhweMU7A9KMe1FwscZrPw30jUWeaxaXTZ2OSbfmNifWM8D/AIDivOPFPwy8TyW0i/Y4dRjjBaKS1cB0P+62Cfpzn8q97rmfHfiqPwf4Yn1D5XumPlWsZ/ikI4J9gOTShSSqKcNJLqjojiZxjyy1j2PHdOvrrR7GO2trqUQxLhRId+Onr9OnbnHWp7yPXfEMi31ppt99nRCSyIdrkEJ8mOozuOPfPY44a38SzPLFb3giVGIBl6Hoeo9zjn6/h9LeG7m1vPDOmTWUiyW5tkVCsgkxgAEFhwSCCDwOQeBRnnFNXJZwq4akpJ6O9/nt1PczDD5LiFSxmHox54t9Entf3lbXun3v1PDF1q68NpI7pIY7YFGtXYoAc4xjB2nPtXl99dyX9/cXkyqJJ5WlYKMAFjk49ua9A+LGqJd+PtUtraYvBH5aS7ZFZTIqKCBgDGOhUk/Mp+g89KfSvSxGIpY+nSx8KfJKpFXXnu/Xffd9TwMX9XniXWpw5ZNJPz1b/XfcjDkU8YNNZPSm9K5LtbmejHlM9qT8KA5Ao8w4xTuhWYAjvS5UcYphbNJQ2ug7DjikpKKhsLBRRRQncYtSzcbV9BTIxlwPenvhpT7cV20vdw8n3aX6/wCRD3PbPgDbhItcvCOSYYQf++ia9la4x3ry34OQra+B3mA5uLuRifUKAo/lXdyXQ9a8arWtNo2ULmoboetVrqdJYZIieGUj86ynuz2qu9yT1as/bhyFyycySENuzn7oPAregGAPlxXMQTOZB85EecYTjPfk10dmRtGP8a7Iy5ldEtW0H6xp/wDa+hahpvm+V9rtpIPM2btm9SucZGcZ6ZriPgvqH234dRQeUU+xXMtvu3Z35Ikz04/1mMc9M969EU8d68y8Cyy6X8TvGugXUjO08/8AaMQViYkVm3HrjDESxg4H8J54Ge2j71CcO1n+j/Mh7nf36CTT7pcdYHH/AI6a8UvmfGa9yulH2eTvlGH6GvF7yAk14+PdkmaU1e5zshOTS24y5qzc25VWOOgqKyTe7e1engHfIcV6x/OJM1arEvwR5AyKn247URYX8qlym33r5O50kEijFU5UzmrjEVAxU5pklLYc81IiGpWAoGB0p6kEiVZj4xmqgdRS+eR3oHc0N2Ka2McmqYmJFBmOKCrkrY65pUbJ44xUAcsMVNErZ4oKT6F1OQe9CgDNLGpxUgjPpRYq/QiKZPSrCRAryKFX5uasxikMjWFfSpfJ9qnRM9qnCCgCvFB7VMIRUqrT9tFhoYsa4pCnPSpwBikxk0rDaIwuBTMVK/Gah3UWEhwHNOBqMtTA5oKuWs00jNRqxqZOaBNiCMU7ZUgWlIxTSEQMKrv3qzIQM1WPOaBNldlJNJsqcrTSOadhJXIguKftyKXFSheKVi0iqYc1E8OOav7Ka0WabAz/AC/agR8irwiAHIqNlAqbjKrrwao3CegrSbniq0yHHSquJmBdp6VjTIcmukuI854rOltB1ppmLRjCM1IkVXxZ9eKsQ2g9KbY1Er21uSela1taEn7tOgt1XFaEIC9DUcyBpLcdFZgAGnmMAduKm3hVqnNcAZ5qrpCfkMnYBeOtZ8rVJLPn/GqUsgJIpOXUzbsQy85qmQxJxVl296Yi5qkxJiwx7gMirkdtnGBRboOK1IYwRnitEUiottx07U9Iwv1rQMa46VUYYY072HYaSVFMaXPemyPVKSUkkCoeoMmaYChJwe9U2emq+D1oSJuaYkz3pwlNUFlxjmn+bx1pNDuXhPjvT0uiDjNZLTnmmG4xzmlYGzpo7sFetOa6HrXNxXhxjPNWBcEjrQ3Ylst3M/B5+tZ7tk06SQsDVVs5rNsL3JxMRxmnrISKqjvTwxx1qQaJmk96Qzcdah3E5qM9etGvQhk5kBNAXPeo1FTKRQtdxI+kKKM0V9KAUUUtACUUUUAFFFFIBc0UlLTAKKKM0XAKKOKM0AFFGaM0AFFGaCaAFFFJQOlAC0UUUAFFFFABRRRQAUtJRSAWikpc0AFFFFAHlXxg/wCPnSf9yX+a13nhP/kUdJ/69Y/5Vwfxg/4+dJ/3Jf5rXeeE/wDkUdJ/69Y/5V9Bi/8AkU0PV/mzOPxs2aKKK+fNAooooAKKKKYBRRRSAKKKKYC14p8dvtFxe6RbqI/JjhkkBdurlgPujngDrXsOoX9tpenzXt3II4IkLMe/HYepPYV83eMtdOva1JdF1bk5x/DnBCe+0cfXdXTh43lcibscO2kXU3zeZGfwIpRpF9CkqRzBVlXZIquVDrkNg+oyoOPUD0rdhwIzSuxArqdJPcy52cm9hPaHdKgAPGQQaqMHQ/OrD6iui1QM9vn+6wJ/l/Wo5oknjTjhhuFa1KV6MEujf6FqeupgBge9IRmrk9gUc/MfrVV4pIuo49a4JRkt0WmnsRkUlLupcis35FjaKXikxQAcUUUUrgFFFFAEsGN5Y9AM5pobLZpycQO3c8U1PvjtzXZUfLRpx9X97t+hKWrPprwvappfhTS7NP4LZC3+8w3MfzNaDsRWfockraBprTptlNrFuU9jtFW2JJr5ipL32dkVoNdzUBc5qZlqFkOazvqVyotWruX2qcZH8q6LTnYgKTzXLRkKVJ6AiumsE8rcSGUDoHr0sJPmjZ9DCrGzubSEH6CvMtSH9jfH/SLqMC1ttYsjDcTS8pPIAwCgtwGykAwuD93+9z6VC4K5VfoTn+Veb/GUPpieFvE7sJW0zUxi2HAkBxJ97t/qcdD97259fBa1OT+ZNfh/mYS2PSbn5vMGchUIJ98dBXk00Oc16vKhihk3NmQqeOy8da8xkFeLmT91G9FbmDf2+21lOOimsnTQS0mPQV0Op4+wz/7hrntOYqZMe1enl/8AyIcV6x/OJFXStEvFyvApPMGKY7Z71A8qjjNfKo1uPllxVZpcmopJCe9RGTH1qlqTcteYaQyGqpm98U3zqtK47MtGbgc03zRnrVLzOeKerUWCzL6SEfSpBLntVVGJHFPHHNSwasXI+3NaVuikAEVlI4NaVpJnvSRSZpxoKlZBjNRQngVaGDTZotSBY8npUqDDVKq4pdnNSyrDkxVgCoUGKmFNCsOAFPFMFSDFIaQYpMU8UhFBRBJk1CRVlxUZWnYgrtQOtSMtG2k0A5RU8YqNRUy8CgCRSKY7AUhbAqJ2yMUXBkbtk0zHNLTlXJoJ6iYpNtS7aa2M1RSQzaKcBmk5pw4FIsdgCg4xTC2KYZaGyWOfAFV3PBoklHrULS1Aroa9RNhgc09myBg03FCZS1KcsQJ4qF7cHtxWgyD86ryOORVEPTcqCEKeRTgq+lPaUetVnmUd6TZDkWNw4p4nx3rMe67ZqFrqouQ5GrJecYzVCa7GTyapSXJOeaqSTGmrshyLz3GeKgMmTVITEnqacJDVcvclu5aLDFCtVNpTSpNmtEgRs27461qQyqFxXNx3GO9aEE9aGiNjzwc4JxVaVxkmmIxIyKZJnnNJ3K6EMrVTdualkbrVR5eT60kiWOdqFYZxioDJnvQr9OaLiLQwaU8DrVcPz9Kk3E07gI3/AOuq0hI65qyRmo5FyKNBNXIUcjvVuOXoKqhD6U4GoYrFtn4poeq5agPjpUWGkWdwzTgRiqwfNPEnBFHKNqxITx1phfHNR78dKillx3qlG5DRZE57mnLNmswz4709ZwB1p8grH1EJKkVs1mpMGPBq1HJXvJ3FYt0VEHGKcGFMCSimbqXNADqKTNFAC0lLRQAlFLSUAFFFFIAooopgLRmkopALmgUlLQAtFJRmgBaKTNLmgAopM0tMAooopAFFFFMAooopAeV/F/8A4+dJ/wByX+a13nhP/kUdJ/69Y/8A0EVwfxf/AOPnSf8Acl/mtd54T/5FHSf+vWP/ANBFe/jP+RTQ9X+bM4/GzYooorwDQKKKKADNLSUUALRSUUALSE4FFcP8VdVfTPBrRxSNHLdzLBlDg7OS4+hAwauEeZ2BuyOQ+JnjiDVNukadIJLWJ90so5EjDgAf7I9e9eVkANtyScksT3YnJNDuzNknqaaj7pXOOrHH0r0oQUFZHO227svIAI8Cq8zHuad5hA61BI4JB4rVEpFXUBizkPrj+YpkPMMY/wBgfyp1626ykA9v5023bMMeD/CK2f8ABXr+gyRkGOR1PNVpbZT9PSre73/Ck9cisWkwuY8tmjZIGKqSWzr05Fb7RjPSoZIc8CsZ0IstTaMAgjqKStd7dX4I+lVWtBmT/ZwPxNc06DWxopplKintC69VNMrBprcvRiUUUoGSAOpoSvogJX4hRfXmvePCPgbRtJ060vGt1ub2SFJDNMA4UsucKvQYz1614PMQZAOwHSvoT4f6uNX8H2jE/vbUfZX99oG0/iu2jOHJSai9FZfcrF0LX1Oj9cmmlfentSDmvn7nVYbionFWO1QSGi5VrEJ610enStPCjP3/AKcVzRbk81v6O2+32g8rxj8a68FK07GVZe7c6SIx8MWyAOQOAPrXKfE7TJde+HurhI4F+zRfaommGSBGdzEcHaxQMB9ccAmuqij80hTwo6+5qe8sYtSsLiwuU8y2uI2ilTJG5GGCMjkcE9K9mlPkmp9mcjOS8OaxHe/DXTtS895T9gSJ5XyWeUDY5JPJO7dz361y0mam+DjyXfgq90bUpdklheS27W0m1JIFYA4ZTyPnMnXuCO2Al3D5E8kO4HY7Lkd8HGa4c6puFRpbJs3w70MXVP8Ajzn5/gNc1aHG/n0rptV4s5v+uZrmrJd2/wBsV3Zd/wAiHFesfziTVX76JK8hqBjmpnQ5PFQOPWvlUjRqxE+P61XL+tSuDioSpxWiEkRseOtN3HHWnMMmlCE1orFjEJzUyE5oEYBqTZik2Jj1NP8AMx3qHpSE4qGhbltZav2spBFZERYkVpW6kYoaGldm3bzHua0In3Vk265AzWnbjkUmbJF5ASRUgWmxkVYXFSOxGBinqBSGhaNgTHgc04DApoIzT+tFxDhSMaM+1NY8GncBrdKacdulL1FGKLiaI8ZPSg4FSbDUb8UhCrTtx6ZqINzTs0AKzUwtmnEZprAUWBiAE1MiVGoqwo4FMSGlcCoW61aI4qF19qCkRUhOKVqhkcY4NS2DYO4ANU5JsZGaJZsA1Sd93ek2Ztk/nZ71G8mTwaiFSLGx5os2RdkkeTyam+XGaRU2gU7imomiloQzPxWZLLgZFXrogA4rBuZjk4PeqasRKVyRroZIFVZJyT1qo8pzTGk4qbXM27kzynpUPm1ESTSDNNRESs+e9V3brTjnFN2+oqkkiHuMHBzT80mB6UEVTAaxwOtR5I5FPccVA8mOKuKuNsnikOetalq/IrEjky1aVrKOM1VhxZv27ZqSRR+FVbeQHirTNkU2jVMz5wAMYrLmbBrVuCKzJ1BzUNA1cg8yhJeetNCHPWjbhh0osibE4Yk9KsIx9arop5qwiHipZVkTAErmkMee1SoOAKGAApktFVlx2quz4+tW5cYNVcDrioaBK5EWOafnikZRSjFDLSsKud1SMQBUecYNLu9aEKTEZsCqFxMQetWZX6isy5bMnXPrW0FcxeoLLk9amVyeBVeKMk1djh9qqVkTbsfQUF4d3JrWhulOOa5ITFX61dgvMYya6qVXuaSidUJuBzTxNXPLqGMc1Yj1AEda3VRE2ZuCUU8S1kpeKRyaet2nrVqaYWNYSZp4cVmJcg9GqdZ/eqTQrFzcKXIqr5opRKPWi6FYs5FLVcSCnB807hYmopoYU6gAooooAKKKKACiiigAooooAWkpaSgBaKSlpAGaM0YooAM0E0UlADqKbS0AeWfF/wD4+dJ/3Jf5rXeeE/8AkUdJ/wCvWP8A9BFcF8X/APj50n/cl/mtd34TP/FJaT/16x/+givfxn/Ipoer/NmcfjZtUUlGa8A0FopM0ZoAWikzzRmgBaKSigBa8a+Nd8X1LS9PB4ihaVh7s2B+i17JmvnT4j35v/HmpHdlIHEC/RFA/nurpwyvK5E3ZHHuDyfb1pIkwue1SyY3MW+4MfietM8wMeOBXcjIR2yDVdjgggVLIw6DvUR607hZHU+DvA8njU3sYvks4rZV3N5XmMWbOMDI4+U859OPS341+HP/AAhlhDe22ofarWS4MQSSPa6ZBZeQcNwCCfl5xxzxL4A8dW3g+K+j1CK6mtZgsiCAg7HGc/KSByCMnP8ACOvaz8RfiHp3ivRk0nSReLD9o3yzN+7WVVyFAXJJUkhvmxjaOM9PmqlXOv7XVOKf1a66K1ra62ve97K/podEVS9l5nnJkA6/nRvU9DVNoJBwJWwOgNM/fRnOVb2r632UX8M1+Rz2NHcDxkU1sDiqXmzKQWiJPtTxeJwGVs9/aj2FTor+gEpQN26Gqrbgr47uf0qYTxk4DjHvxUkKJIu7g/MelZSpyXxKwXKBiYjnPNNMQ7qK2GRRtx60GBJByOfWs3BMd7GG1uvYU37OFcHPStdrA54NVZoDG0aH+I1dChF1Y3X9LUOZlF7dmYtuHNep/CC78o6lp0kgDFVmSP1wSGIPtla4FbYcZq1o+qSaJ4gtdQiyREw3KP4kPDL+IrhxeH9rCT6s0pVLSVz6EY9aaGIpkU0dxDHNC+6KRFZG9VIyDTs9a+W20Z6Ypbiq8zCnsxAqrI2TSbGNLc1t6DLtaQgAlcEAnt3/ACxWFtqSKTyZUb0YH8jV0KnJNMmauj0u2kMgG3aeM57VZYuBjcS5HAHH4mq1iuI1xz71eHA68/Svei76nCzxnwwo0P4teNtIlbzhOo1F5j8u0HDlNvOf9fjOf4enPE9xKJ7iRxnDOSAeuCaXxpajSfjF4f1LzYoLfV7SWxkEQIaaUKVXzAB8wJkhAJz90ZwFBqgknrWedNyjTn3S+9afobYZasg1Vf8AQZyP7h/lXP6Sobzs+g/rW9qLg2FwP9g/yrB0lsGbnHA/rXTl/wDyIcV6x/OI6q/2iBYnUAVQlFaE54PSs6T6/SvlUazKrDrxSACnkZpCtWnYixEY+c4qVUFBNKH6c0+YBfLHpTyox0pFYHOTT+CMUXuBAU3UogJOKtRwnNXIbXJ6Ur2KUblOC1x2NaMNv0FXIrTjpVpYMAcUmzRKxFBHtGTVyLiowgFP3YGaTZbLsb1MsgrPWXvQbkDvU3IbL5kHrUZl4qmJ8jrTGnOOtJsVy+JqmWYEVkLMfWrcUoIoTuNGiHzSMc8VXSTipA2TVXAkXIp6imKakWmh2DFRSKKnJqIim/ILEGMGpVXim4ANSrilcEhNoprJipcU1qBNIiXAqdSKqu2KYJj3pXFY0hioZSMVXFyB3qOS4B6UXBtIbK4GeaoSz46mnTTcHmsqefmpbIciaebPFQK+eKrNISaWN+aEZ3NOEBuvWryIMdKpWjL361fDDFaxQNjWAxULtgZqWRgM1m3VwASM1drCuQ3c3BxWJN8xJq5NLnPNUZnFS0JspuCOKb25pXb2qEyEcVKV9iR5oFRB81KBVNWEAoPFOA4pGGakVhlNLAUpzVaViOlaJXZOwssp9aqs3NEjnB5qOIFpBW8Y2VxJ3LEKknpV+BWBGKjhgJxgdq1YbbgA0r3ZokLAWXvVxXYjvQlrgdOanW2OKbLRTlGRzVGVeSMVsSQYHIqhLDjNZTdikZxQ0LGS3NW/JpywipUrisNij4FTBQKAgUYpDmi41ckBwKa747VGWIqCSQ89aEFhZJBz6VVeU02R8E88VXL7jVWuCTLKtuFPFRxDvVlI244rNopjcGmMcZxVhoyBVaXgVSRmypO4x1qlt3SGpZ25pIFzIMVvHRXM2mXLeEDGOeKtpGAaS3jOOlXFTFYt3KtY9MkBzmow5B61PJgioggpXa2OhxuO81vWp0uGFQhAcUMtWpslwsWxeECm/wBoEHrVI96hYEmrVZolwNmHUiD96tCLUs45rkmLR4xUkdy/HJrZYjTUhwZ2qXynuKmW6U965OC6Y45q2l0R3NWq6HyM6VZwT1qdJa5pb1hV2C9B71rGsmS4NG+soqQSe9ZUdyp71Osw9a2UkyGjRD0oYGqay1Iso9aq6FYs5oqEOPWnB6YEnejtTN9G6gB4ozTNxpd2aYC0CkooAdmjNNzS0AOB9aM02jNADsj1opuaM0NAOopu6jNKwHl3xf8A+PnSf9yX+a13fhP/AJFLSf8Ar1j/AJVwfxdObjSf9yX+a13XhRv+KS0n/r1j/lXv4v8A5FND1f5szj8bNqimbqXNeAaDqKbuAo3CgB9FM3CjI9aAH0U3NGaAFLrGC7HhRuP0HJr5R1C7N7qV1dO4HnSvIT/vMT/WvpfxNefYPCurXWcGO0kIPuVwP1NfKd1cOgKxRFjjGfSu3CqybM6nYknl3soB6DpSK4AwDzVQF2kwvBAGSeKsKoXvzXSjMXqaD1pccUmKYCT820v+6f5VWs+bdQff+dWZ/wDj3l4/hP8AKq1pnyE59f510L+A/X9GCHv96o2HFSyJ/FUD7xnFc7Q07Cq27rSEbWI/hpincQfwqXbuFArNkLIhyCg/DihbeJkVjlcjsaftI4pQcQpn+7Wka9SO0mFmAgkCgpcNx0B6U8G9QZ3Rye3+cVC8pJAHrUomMY+YmrWIk/iSfyEXNMM13qtpZzRBBNKqllcLhSecE8ZxnHrXo8vhPRZUA+x7XG7bIrtuGRjrnn2ByPzNeYW94EuI5A2yWJw8b4ztIOQea6T/AITjWbmKaKCC0WRCymVVY8HgEAnqME85HTjjnws4w2PxM4zwcuVJa2bW/X9D2srxODowmsTG7flc5rzgZmhkaMbSQWVww/Ajg/hUEgXzce/WmrppXGeDUhgOcZr1km1qeM7LY9X+HWr/AGzRn092zLZkbPeNun5Hiu0LV4t4N1BtM8R2jE4jkbyX9Nrcfodpr2nGOMe1fL5lR9lWutmeph588CKQ1XbrU8hAJxUDGvPbNrCYqOQ4BxTxUUpOOKVwZ6Xo9wk9lFKvO5AfzFao3EcJXimteN9a0TSLOy0hViI3efdGLzCqg/KBngE56muYudR1HWY45r3VL6ck4KtO20Hv8oIFexHFwjBX3M6WDnWba2O8+MTRXEuh/Ypli1uwuxdQz43CGPvxyrEsiEAj+A9M88419Hc3MzxKwjMjMoIwQCeP0NZFtZySDZBCcAZPb+dXI7OWCQrKCobhWByCa7cXWwdfBRjzrnWyur6vXT+u59DLKcLRwPtotup6+fYkvpCbKYZ/gNY2nttMn0Fad8skcEquMHafpj1rItM/Pj0Fa4BNZDik+8fzifL1f48SxPIOearDLfSpmhdj0qWKA46V8ojezZWWM0GE9c1ppagjkU5rXrxTuPkMN0IPNQ5Fas1qeeKqNbHNC1M2rEMfJq7BESaWG19q0obbim9BpXZHDb8jFadrb8g0RW23GavRJjFI0Wg9YxjpSNFU4FNegVyttx2pHGan25pGUYpMdyhIWFVi7FutX5UyDVMwndms3uSxUbtSPk8ipFj+tP8ALzSArKWzVmN24qNo8dqniQ00MtxE8VYBqBABUoyatDJ0NShqrA4FO38UxljOaaSBTQaRj15ouNIaxNKr471AX7U3zPek2VYvB801zx1qBZBUm4UXJZXmbGaz5LjBNXLg5BrEu2KgjNJomTJnvsHrzUZvsg1kSzEZNRfaSO9FjncjUlu+vNU3lJNVjNk9aQy/ShkNsmL4I96VZR1zVRnY47Uhk7dqSEbFvdAY5q+t2Ao9a5hLjHerkV0CM5raDY0zXlusisq5mJzStcAg1RuJT61rYe5DJcHkVXkm96imf5j61WeTGe9HLcRM8o71EZFJqszsadGMtk1XIkJltBzVlE6VBGOlXo155rCbARUAFMZaskcCk259KyuwKRQmoJIeelaZjAPFQtFnmtFJoloyjbk/4VPbWnzc1dWIZq3FCBg1pzt6CS1JLW2G0cVpRWwwOKbbqABx1q/GAMdqFI1SuCW42jNSeT0qVSDgVOEGBVcxagUXts9jVC4thzW4RjoKrzx7utZTlctQOfaDmka3PStNogH59aTywWHFZphyGf8AZyO1MeEgVreUCSKbJbjHSrTDksYrREA8VTmQit2W1OOBVR7UselUmVy6GBJGxPeiK2LHkVtGw56VYt9PGRxVc5NmULexZsVopYkAfKa17azVQOKui146UXuDVzmJbUqCcVmTwnpiuxnsxg8Vk3NrycChO24lC5yL2hL9DV63s8AYHatT7F8+cVYjtcCm5aFqmUEgKjkU48DitBrcgHiqU0ZHtzWaZM4WPR2NNzzTieKaBmnc0aHJmnE0ijA5oY8UxMifHNMCg0rHmnDilcViN4s44qLZg1cHIqLYM1QNBCDVoZxUcScirG2mhEJcinpcEGmSL1qA5FWm0JpM1EviB1qzHqBHU1hbjSiVhW0a1tzOULHVRXwPercdyD3rkorkjHNXI7zHQ1tGuRyHTrOPWpBN71z0d8R3FTLfccmto1UyXFo3hLSiWshLwHHNTLde9Wp3FY0xIKeHrOS4U1OsnHWrTQrF3dRuqr5ppDKfWi6FYs76NwqoZfejzfei6Cxc3UuaqLKfWnCWi4WLOaWoBJ709XzVXAl5pOaAaWgDy34uf8fGlf7kv81rufCp/wCKT0r/AK9Y/wCVcN8XP+PjSf8Acl/mtdt4Wb/ilNK/69Y/5V72L/5FND1f5szj8bNrNGahLimmXivANCUvjvTDKKrSTAA5NVmugDUuSQ7GkJRTw4rKS6BPJqwswPekpJhYv76TfVQS00z020BzvxNvPs/gHUVzzM0cQ/FwT+gr50lkPlSKDjIOT3r2j4v3hHh2xt8/626LH6Kh/q1eKsN2a9HDL93cwqbkSNIWISPEQOAccmphx2pDJOp6KRTkYtyR/kV0IkUij04pwxzSmkBFOP8ARpSf7h/lVa1/49Y/x/masXB/0eT/AHD/ACrOW4YWyRIACM8+vNdCdqD9f0YF8nNMaMMvBqhFdOSQ3FPlvfIUY5JrncluyrdBXzG30p6MTVMXxnbDKB6YqQSEA1CmnqhtNFiRtikn0OKryTZYLngVFJP8vPrT7eCOXLGQkmk5rZBbqTxKGYMxwF5qOe6TOB2qZ7SZ1w7pDCO5OM0ttBYtKUDmQjq2DinzXCyKHmOeVBqe3uZrdy8ak+takkNtHbSGMAMFOD+FR2M9ulqiFR5nOfzrqhG1GXm0S2XrW7W4XE8RVsdcdaV4U7Yx/KqksxbG0YprTuF54rPYi2paiXF5CF+/5i4x/vCvfHU7mz6mvG/AWjya14gSd1P2WzZZZW7Fhyi/iefotezMa+bzerGVRRXQ9TCRtG76lSRTVZhzV2QrjrVKVgK8fodTGFsVBK4ApJJMd6pTzhRkmpuTJor3irMrKwyGBB+hrI0y0MMhi3DD859CKuz3G7OKzILg21/tY8MSUPt6VcbnVgKqU3F9Tp4IFt9+OA2OTVW/1SxhntrSS6jWe4J8pc9cEqeeg+YFee4I6iui8KNFeatavIMldxAK5BYA4+nrn1ArqfF8Frc+DNajvRm3+xSs5EYkK7VJDBSQCwIBHI5A5HWvIr4qlh8wpwnFvmts9r6dnfvbrtod2Jx0qUPZRSPMLpv+JdOkkYYBCVPdTjrWVpEBmabg4AGT6ZzWdo/ipdUsJbW8IW9EZAPQSjHUe/qPxHtf0iV0uNkR/eO6DHquefy6/hX6dTw9Shk+KpVVZpx/NHhV3CriKcoPRpmwLLnoKmSzxV8RipAoxXw90bpFJLbHanNb47VbyKQjNK4OxlS22e1VhZDdnFbZRTTREAaEzNpMpQ2eOoq2sAGOKnRAO1ShRTuJIhWP2qUDFOxSk0rjsG7ioyQaa7nNR7/elzE2JxSEU1cmnine40iN0BFQ+SKtEUBKTHYhEVBj4qyqigqKQWKflZ7VKiVJtzQABTGlccq4607FKKCfzppjaGMTmkDc0jHJzQPrTKSJw3HFI2TSKaVqCuUqzfL0NVjIQaszc1SfrUMGrFmKfNTeZxWcGYHipBKR3oTJaLErjbWLekVelmBHJ5rLunzmqRjPYzJ25NUzLgmpp261SJ5NNK5zsnEpoD81CDmlyO9DQiZpABUbScVEzGomY5qlAViQynmnR3BXoar5pgODWiVgRoeeTjmmPJmqpkx3qFrnqK0SuNMdM5zxVfGTgc0pbzD3qzDFkinexY1LckdKmEIABq3DH7VKYBWUpsl2KqLgdKlDYp+wLUbYrNu4h4k60eYc1XL80hfmhIC4JBTWcVWEg9ajab3qlEhlxWGRV6Jx+lYqznNXIpjwQapRKSNuGQA1cR+Bg1iwyEnrWhHIeKzaa0N4I0FfpUyzg8ZrPDH1NOVjnpWd2a6GkHyM0rDINQQkkVY5xVWuFypLFnpUaocirpUGo/Lwam2pSGLH61J5WRzTgOanCkgcdq0SJbKUkXoKj+yg9q0PLOelL5VNk3M77IPSrcFqo5xVlYc4zViNAKkG7iR25A6VKYsCplxxTiRtqkCRnTISCKz5bUHtWw6A1XkQUXNImKbbGacIgO1XnjFV5Exx60mzTRFZ1UDiqFzEDnitJ04qB4iQcCpvcynqdcWpy4qKnqauwDsjmmSPTj04qFgTTVxOwmTTlJpu01IimgQ7tTT1qUg1GRg00IliqeqqnHepd/HWqTEEneoCufpTmkBPWgcmi4WGhOaDHxUyJ3pSlNCZVCnNPDEEVLsAppXHWi4kHmHinpOfWqztikVqpSaE0maKXJ71YjuW9fzrLSrMbVvCoZtGrFcnIq0lzx1rGV+lTCcjvW6mS0a/2k4pjXYHcVltcHHWommzxVKQrGmbwZ60C8X1rILkmlDNVJisb6XQI61ILkcc1hRyuuOTU6zOKpNhY21nX1qdJCaxYZTJ+Bq/HNjFaJ3EaIkp3mCqXmikMwFFwseffFht1xpf+5J/Na7Pwy+PCul/9eyfyrhfig++fTPZZP5rXX+HJ9vhnTRnpbJ/KvoMW/8AhJoer/NmUfjZutJ61C82B1quZST1qNm3V862apEdxckCs2W4dmPNX5Id4qtJaMvOKxbLSIY7hgQc1bS8YVT8vHNLQmFjUS6LDINK0+OTWejlR1oZyTjNTKVilG5578WrsyTaXBngJI5+pIFeZZ4P0r0r4pW/7nTr0jgM0JPpkZH8mrzfZXr4OadJWOWqmpEyRttDDnjNHllfmxTYC8cfqgzn2xT/ADgwBC4yOldRmNHalbhfakBOajuZUVVGeT2oAinP7txxyMCssHEee4q4xZunNVVXNufrW8daMvVfqNIhfLfMOtMbDrz2p+cGmsQGBHpzXCy0ViCpyKn+0L5YAU7u9RN0NR4J4rnbcXoaWutRWdmPJqWGGST7rAfjU9rYmQgt0rUSziAx5YP1FaQpOWrJcktEUYtNdyDNLwPxqwWWCPyoIG9yamaxj6pujP8AsEimFb2H7sokHow/wrdQ5ehDdyF7p2gZGUqSKsw20U8CGNvnAGR71VubiWRAksIRs53Dv7VPCLedv9HnMbDnaRg1181qMfNv9CWg3mBtrdqlkjeYEjlMZH9akYq/7qcgns2MH8aksC9tP5Tcxsflb0PY1hK9tBJK+p7N4O0n+xPC1nbsuLh186f13tzg/QbRWtLJio7K8W90u1uh/wAtYlY49SOf1qtcy89a+LrOTqNy3ueunaKSEmmwTzVGa6AzzUc8xxWXPMeayYnKxYnu+DWbNebgeahmlbpmqrhm6VNjOU2yRpiT1py2LahiBVJY8gjquO9MhiJboa1IIHAO1ipIIyODzVxdgpu0kyLTNduLO4+wCaIOjDMq5+X34r0S4UXlube6/wBIhIAKTfODgg8g9eQD+FeEa9Y33h7XrW8kuNyTsSD0bA9R688V6XZ32q6vp8EkGoi1CSLvdIRIZFA5A3DjORzg9K580y+VXknCSVurv+ibOPiOpzUFX5+WMHre+t7WtZM8h1u3XSPEd6thIqww3UkcRRidu0/dO7ngHBzweeSOa7PwpctcMl3PE8B2FQSMBiR1X1FRXHhY6BO0st4b2a6cuJZFIfdzuPU5J3DJzzVrRoVuNVgieNZEfcGVjgY2n9e/+Ffp2HTxmQznOV/dd+75db67N26+p04WjSlgf7Rp1LwSb235U77uOt11sdYJlYdacZBWFp8zJbqm4MFJAYZ5GfetFZHbvX5xUSUmkd9aDpVJU30bX3F1XqTdVNT71KDjr2qGZXZIxApBIM81XkkqEy4pXFc0g/FAkzWYJz61NFKc0XKSL+8fWkL5zUYbIpGOBQ7g0QTSHJwaiWTnrTZjlqYh561m7hZGlE24VMKrQN8tWAa0RLYvGaetQk80qE5qgW5YFB5pganE0FpDTxUbZpxNRyE4oZaQ9WOOaRpKg3mk3UBYmL7hzSAjtUZbIpFbBpXKSLak49KUt71CD3pwYE00wb6DZBntVZ0q3THUEUm0S2Zz/KaiLc81akXg1WKc1KZLZFI+c1QuCTn6VoMhyaqTRnmrTuc9Qw5+uKq4NaVxEBmqZSqTsYtXIQDmnYNP2c80pA6U7jSsQMKYwNTsOahI561SZTVxCue9MK8U8nAppNUmzJkD59OKh8kk1aelRMmtVKyBIiihx1q9BHz0pEjxViJcfnWcpjLMaAVIVwKYrgUPID0rFyuK5FK2PyqqT1NSyHNQtjGKaQyFmOTTCTipChxSrESea0TQJFbJzUTkj2rR+z8dKglgPHFaJoHG5VVufWrkLHFQpbkHvVqKI5qtGCVi9bkkita3QmqNnAeOK2LaM55FZTSNoCBPUVIsRJqz5Xt+NSiMY5rOyNH5EMS4xVpOlMKYNSIMCm0JXDYKTZ6U4HNPxjGO9Q2aWGJFyKnCYIpqg8Cp0XNNMTQwJzTinFShe9DJgUyGiHGDUsYyaQLz1qRFxSBIlUe1I1LnApjtTuOxEx5pj4xSsajPvS3KTsMZBVd4x3q3xTCoNAnJspmIGoZIwO1X2XioHXihWIk2bOynImTVnyeakjiwa0si2Q+TwBinfZ/arqoDipRGCMYqkhPQy2gFIISO1aRiXHameWO1NomxT8o46VE8VaQjFQyRZqbFWM4qRTGY9KtyKBwagMZJoaEQhSc09FORUixYxUgQChITFWnHpSYpegqkJsaaicgdqe7HvUDt1oYiJ6auQeaVmNNU5qWBYQ1IDjvUKnFOZqabQmrk4lHrS+b+VUWc0zzjWyqdyLM0PNoDe9UFnOanWXiqVWwJMtqTUygEc1UQnHWpkY+taRqobiXY0BHNTCHpVaKUrirkcoYda1VRPYXKSQxADirCqaahFTBhiqUxcoxiQOtVZJu2anmk+XAqi4JNN1AULnD/ABDffNp/+6//ALLXV+H3P9gaeMf8sE7+1cl4/H72w/3X/wDZa6vQF/4kFhn/AJ4J/KvocZP/AIR8O/N/mzCMf3ska4NPUe9RdBTo5Bnmvm3NGyiywF49qSQqeDSNJUTOpHWs3URai2VZ0UHI71TZiDVi4lGapFwTWcq1ti1AsBsinKCeagjcdKsIRisZVbmsYLcyvEuirrug3VhwJHTdCx/hkXlT+fB9q8JgZhI0E6FZo2Kup6gg4IP0r6OABrx74paL/ZetQ6xbpiK9yJMdBKvU/iOf++q7suxPLPkezMMRSuuZHMXLRRWqxA/vHbJx1xnNNReOaxzd3FvLuZA47GrlvqqzYV12mvejNPQ4HGxexg1RudzSD2qf7Qi5LNgetZz3DM5bt/SqbJLKkdDVWIE2rem6m/aV/ipYZlSNlYE55ranL9zP5fqUV37moByTmrDlXyF61XPANckrFoYxwakto98ntUTGr1gp27tm7nscGsFrKw3ojTijCjAOKnXcOwI/Ko45I+hfafSQYNWArdRz9Oa7UYvcZuXvlfqKTG7lSD9Keccg/rTDEpORwfUcVaBlO8BE0G4D73+FOa1gfkgf1oKv/aUYGJCq8+3XrVwxA9UK1tWS5YJ9v1FexVUvENrgyx9s9R9DVhAAvyt8nYHqKArRnjkelQXEykMqcOO1c7skNas9n8HymbwhYk5yvmLn6Oas3Ocnmp9Ggit/DWmpBjy/ssZHuSoJP4k1FcDJNfF4iXNVk/M9WKskjJnHWqUkG4H1rWeHJpFtz3rAGjCltGx0psdmxJ4rektKI7bBORSZHKZ0NkVwSK04oCq5HB7cd6sLDjHFTLHxRexpFW1PNviDZ332W2vLl4DGs4XEe7dlh1OR7VueBNWE2nTWThybdgQ2QQA3QD8j+tSfEOAHwdctj/VyRv8A+PY/rVPR7nS/DWl2aXL7ZbuETvcBNwY8fLxk8A8cY5PNdzo18VhuShByn0S1fnZddBVMDhsxbpY1+5o3rbXpqaOvy3HmxzSIohHyKFfODyc4wOo/lVa307Vr2G5l0m/jtJIo8NvjB3g9t2CVwATx3x9QX+sWWquthZTCZwxaR1X5UVeM5PXJIxtz+Vdc00GkabZwOIopbmBZEWIjJBX7xA5HTrjqMZNe3l1bF4PAcuOp235Yyjuldv3WrtddfU686x2HpZfTyTK6Sm20mk7qEVJO8m7766303fnwmkXctws0dwiR3EEhjkRD0x/kj8K6GAcCqMFmIprmTdkzTtKflC4z0GB7Ac9zk961bdPavAxtSjUrynRjaL6K9lpra+tr3t5GFraXuSJGacyHBqdVwKR1461x3DlM11PNQMCOavSrVdkJJ4qWilGxSDNzVqFiagZCpxipoR7UIbRoRHIp7j5TUcIOKmI4qibGdKhJpiqemKuPHk80wRgGixL0JIcgCrOTioUHFSjpVWJYnXmhTzQw9KQUWGmSg807cD71EBijNCRfMOJqNs07ntUbFieKLFqRGeSaTmn7aeI89ql3LTGAmlAORUyx0bcUIGIAcdKUKBT1+6KSmQ2HSmE5pTzSDFQ9xXIZFA+tQhAasv35poX8qEtSWyu8XGcVRlTjFaxUYwapzRkAmr2MZK5h3CZz7VnSDk4rYuIzmqEsPcU9zOxR70metStEc9KaYz6VSGVnOKrtJge9XWhJ7VXltyc1pHzHcqvKTwMUiyEnHNOMDFqesDCtbpCcb6goJ7VZjj4BFLFDxzmrCx4FQ2HKMAwKQPjinMpz04pmw56Vk2mS42JdxxT1BIzSRxZxV+K2yBUrcSRRaLNRmBvSthrQ4BxSi146VaGkY4gPpVlLUkDirwtKvw2owBimmOxj/ZMdqY1mT2FdD9kBFMe1ABq0wW5z4ssdulSw2RLDitlLQMRkVaitVB6U3I0jBPcq21kFWr0cIWrMcIAqQR1k2zVQRDs9KVE9eamK0gWpuU4kZTmkYdhUo6UhU5p3I5dRiIKkbAxSxqB0oZCah6miQgJPSpkJHFQhcVMlCHYsL0oYUqc0rfSquQ0RAU5aMYpM0XGSEio2NI7VGT1p3IY1jzTCRT8UxhighuwAk+1NJwaM4FRs1JgncUsKrTcCns1VbiUCpvYpq52+BRkVEZAAKZ5pya6Btl1GGPwqQSA8VmiYiplmFNMW5aLYGPSmbxmoGl4xUDSHNDYti+JBxTWIPNUhMfWl84nvSuO4+UA1GqD0o3E96cpORRcTHKmaGT3p49cUhbOBiqCxGRxTGBqxtFRstDFZlVxzUDD61cI7YqNkHNS2KxRYUwHBqxKMVTZwDmlcGiwr08nNVkbJqyjKe9JMq2gjLkVA64q0xGOKpXDkU7isNPy1IktZ8k2Mc05Jx1zSbGkagm96mS66Vivcgd6al2epNClYLHSx3CnvVmO5FcxFeflWhDcZwc1SqgkdNFOCBzU4kHrWDHOMcGpftR9a0VULI1JJVx1qHeDWcblmPWpY5M0OqCicl8QP9dYf7r/+y11egMBoFhx/ywT+Vcl49OZLD/df+ldToTf8U/Yc/wDLBf5V9Pj52yPDPzl+bOenG9eSNUv2zUe8+tMZ/Q1E0vWvlHVudihYsGcgYPSoXuQO9VmlyKryOfWoc2wslsPmnLGoQ2TioWk55NIsgBqHJsLF1SeOanSXBwapCTilE2DQmyloaiv71h+MtHGveFbyyVQZwnmwf768gfiNwrQjmBFShz1FVCbhJSXQGuZWPm2NVmt0jPBbKnPqOlVTEysVHBBIP1FdT410k6H4kuhEuIJ2F1COwVj8wH0PFZE0aC8c8c7WH4jNfV0JqpFSXU8qouV2ZQAYg5z+NRkEcir0kZG4+vSqhHNbtMzIjGsnQYPemsxRge38qnKZ5WoWBKVvD+BP5fqG7IpMq24U123AEfjQDwVPWo84NcTdi0hprZ04IsKb+M5we3NY/U1v2gKwjK7o8c8ciikryuE9i0Y88FRj16ik8kDlcr9DQmVUGJt0eOn+FSriQZX8u9daMnuMDS9yGHvQSp6oRT9pz0wR60h4q0SZwQPezbSQoXqD9KdIJVHFy340tqcyTuPus3B/P/GnyBcc1riV71uyX5AZst1MCVEhYevSkt5XWYM5J9c1LJhjgLgU0J/+oda4pXRpF9j3XwTcG48HWeWz5ZeMH/ZDcD8M1pTKc1R8I6XJo/haztJt3nFTLID/AAs3O38On1rTcc18jiGnVk0elFWSuV/LBFKI+alC81IEFY2GyAxj0pBGPSpylMxzRYQBOgxTgoFOUDFOpNDuc543h83wZqvtCG/Jga8w8Pz6YmpQtrFpNd2skZTYkrAo3BBABHoRjI657V614niMvhfVk9bST9Fz/SvErNmP2Vh1DjH5V6uBlONNuEnF902mvRrVHNXjze6+p7NbWOjeFw09jov2iRY9jS3J3qflzuIJPfkgAZ7dqrLqk/iXWJ7+7WMyRxrHGEXAReenfrk8+v4VrakudFuSO8BP/jtYPhJd0l2PZf616WFpqvlmJxtZuVWNo80pNuzcb7t2vtpbTTYqm40OWjTja+ret3pbV328rGqtvzzViKPFWGi9qFXHtXy9jpTsCrxSOvBqTimse1S0aJopvHk0wxcGrJAo20JDuZ0kXPSiOPBq46E03ZxRYdxIxU5HFMRcVOFyOlAWK7JzmmslWCtMK0EtIYtSKKbtHUVIo4qkZtWBl46VHtxUrZxUZNWkRcYW5xRmmnNKKTZSFoA5o5oANIadh4UGnhcUypA/FKxaYEgDNMJJ6UrtzyKjLGiw3JEo6UHvTAWx1oyaLMlyHHpTcU8DIpQKLENkJFAFOc4NNBzSasSncGFQSqCKsnmmMKQNXMqW34qq1rzn3rYK800xKTTSsNRuY32IE/dpv2LkjGK3jAPSozAO1WgcDBew4Paq0tn6A10bRgVXaEE1V7BydjnPseDnFJ9mwcba3JLdQelQ/ZhnpRzAoGalv7VYFscDjmr6W+O1TrDnHFS2aqGhjmz5FJ9jAboa2xb89KabYkjjipbIcUZ0NoQRxWlDajNWobfAHHFWVjC9BQmRyFR7bgcU0QcYxWjsHpSeWKq4cpRW2AIOKsRwgCpwnNPVaEyWhgjFMeNfSrOBjoKjaqTJtqQrGvpUiIPSnAYpRxQ2axZMi0pA6YqNSRTt1S2bJoRhmoy2Kc7YFQsaVyrji9AaoskmlB5qWx2LEY5qXrUCGplpILIaRzTl6044ppOKpMbJ0bpzTs1AjUpai5jJkp5qIsaTzDTSaEzO4O1IDmo2PPWlU1VwuPzUTtTs+tRPyaLkMCSaiZhTi1RtyeKTZaRG5OKo3AJJNXnB6VTmUmobNLaHWCYGjeKyo7oHvVlJwcc1qpGdy2XPWlDmod4NJvo5iki0JMimFiajSTNSA5FF7lWGFsd6YZgKJeFzWXcXWxjTuS1Y2EnBqwsg4rm478E1fhvFYdaLsErmx5gxwaUP0rPWcN/FTvOPrRzmiiaG7A61FJLxVY3A2nmqkt2BnmjmJehc+0DOKR519axmvMt1pj3wxjP60NkaF64nBzg1myT4P3qrTXvymqH2o85qGyWzaS44+9VuKfI61zqzc9alS7ZT7VSYrm+bgA8niqF1drgiqL3hYcGqM8+4jJptlp9i01yT1NKJu2TWWZffipElPrU3BuxoNIeeajWQ+tQq5xzSls44pNjTL0T56mtCCYjABBFYgk2jkVNDdYIFJPUpo6GO4x3p5uRwM1hfbSOM003uTjNUmZt2djoI7nLcGr8MtctFec9a1YLweuaVzWKMvxw26Sx5/hf+ldJoswGh2Qz0hX+Vcj4sn86S1Oegb+lbWm3AXSrRc9Il/lX1eYP/AIQML6y/ORzUv95mdAZx61C8oPes/wC0dPmpqzkt1r5O52WuXw2aZJnFLEQakKZ6U7g0UGBoVc1M8eOaaqnNKxI3JFJk5p8g4qKmBYiYjvVyM8VRjNW4zkUmVFanHfE/TUu/DQvh/rbR159UYgEfntNeWiQSNG3cwJ+YyK9v8V2pvPCmqwjqbdmH1X5v6V4SqlTBzx5fT8c19DlM26bT6HBjI2lcsyngflVFhiQirsuSq59aqzD96PevZexwojOV+npUGMjFWW4HSqxHy1pFfuJ/L9RorSDBzTGOefWppF4qA+lefPQ1TuKgzIv1FdJAjeQCp5Fc7AMzoPeuoQMsYKgHA5HrV4dbsmbGBGBLxcZPzKehqRdkp3KSHHX1p6kHBXOD1z1B9DQ0QJyDhh0NdaMhOf4hkeopkjBULbsgDJqRWYcNwfX1qvdvtt5CwxlSK0grySEyrZAi3Oe7Einv1pLfKWyA+maGPtVV3epJ+YWICDnhRXS+BdD/ALW8RwmVA1vbYmlz04Pyr+J/Sue4zk17N4E0hNM8NQzkfvrwCZz6KfuL+A5/4FXk5jW9lSdt2dOHhzO50L5yeajIqdxxUD8Zr5W532EHWn8YqIE5qUVSE0ITUeRmpCPQ0zac0mCTHL0p1CqPSnbTSuh2ZQ1aPztIvk/vW8o/8cNeB2DEpB/10Ar6GuIt9vKv95GH5givnWyO1UGekgr0sB8Ekc9Vao97vGB8Oyn1tc/mgrE8HD97d/7q/wBa2Lo48MP/ANei/wDoArF8IHEt39F/rXsYDTIsX/iX5xJn/GidZxUTDFOL5FMJzXyh0ibuaaTzRij8KTLTDrQRQKUikkN3GEZpu2pttNCc07AnYaBjtUgzTggpwWhIrmIipppQ1YIpNlFiWyuV9qcBTytGKaRLYwioGQ1ZIpu2qRDZXK0gSp9ntShaTGmRBPanhKmVOakWPPShIGyuU9qZtIq4UqMoPSqsCZVIPak2mpygo20WE2yILgUAVLjFJikCYAUvalUHNOYe1NITK0lQ5INWJFqAjmoYJajwc07Ge1Ig6VJWdzVRIjGDzRsqTGQMUoU1SQXsMK+lRNwDUx4qCU1SE2RMeOMVARzzSu2D1poNJyKWo4xZFNEVSbvenAjuaLlJCLCO9SrEMdKQNmp1AxRcbYwR+1Bjz2qb6UUiG0yNUxxUm0Um7FG7IpXJFzijrUe45qRW70rhYAKeKYASakAoTE0JTCKlxSYFWmQ1qRHNLzinmgUx3sNOaYWpznHFQsTSbKTHFvU008imVIozU3NUxAOcUMMGpgnqaCooZVwiHHNWRVcHHTiplPy0CuOphGTTsnNJnvRcbYmAKRm96ZJIBUW/NJuxjLUlLU3dUTPioy9TzozSZYLClH1qAOKcrVaZVmSmmn60bgcUmDTuNRIz1pCDUhHvTCcUNlqNiJhzUbxgirOBTvLBqHc0SM5Ex0erMbOMYbNY/wBuXpxU0d+vrUKTMbLobYmcdR+VDTnjrWdHfKf4qsC5QgdKbmUlYuxXAPerIuFArJE6Z7GphJGQOcUKoUixc3PB5rnr+4zuwa05ykn3XrHuLR2JwwPtWsZrqZzTexQW5dW/Gr0Go471ny2cyjp+VVikykEqa0UkzFc0TqYNQBx8361b+2cda5GKd1PerK3ZxnJqWkaKq7HRm9A4zVOe7bnFZDXmTQLj3ppGbm2StO+48nFCynu1VjLkmmb+aZDkyyz5HWoxmoiwpwJNS13FzDgxB/CkeTNPA4prADsKaRSYm9iDzVeQuTj0qUhgfrUcnFNK5alYiyRirEbcVX644qxGMd/wo5R8xOrk05pMVGWx0qN5NwxkUcrEpIc8wx1pizHPBqAntikUkNScGaKZc84/3qXzSO/FVsjuaR2JHtVcjMm7u5ZF0AfvVct78+tYLk5600TMpzmlys2g7bmxq1x55hOegP8ASr9pcsLWFfRQK5/zTKoJ7Vo2z/ukGe1fT5kv+EDC+svzkY0tcTM1xeN68VPDdksAazBipIWxIOa+TO9WOptnJGc1oJwOawra42gZNaS3IIHNUtSGWWANM8tfSoRcAHrSicUyBXj61C0eDVlX30/ytx4HFKw0VUU1OhIqQQn0pwh5AH51SRS0EMazRtEwyrqVYexGDXz3qEH2O+e0IO62k8tj9OK+i0iwK8K8VWvkeItdyCSb0hfbLbq9fKW1Jo5MYrpMyZc5jHqCce2cVBc5/dn1FWCQ11IRwiAIv4VBdnJjAHQHj3zX0D1R5qIC3bH41XP3TVpsY4/GqpJAIraH8Gfy/UaIn+7+NQPU8n+rHP8AFVc159Q0ii1p8JluAR/DyRXTRxkx+h61zelyeXfLnoQQa6nYAuPTkGtKHwkVNyFlIJZR7EetOUiQVIB3xg1Gy4O4cH09a6UZ3EkB6EfiKo37bbcg/wAWAMfn/Sr+7cOnbpWfqHzLFEPvO/Hp/nmumgr1EAKCsaqeoAFMZxzkVO9VpAM1hJ3dwQ6FDNIqKMliAPx4r6Kht1treK3UcQoqAf7ox/SvBPDFq914m02BBnfcx5HsGBP6CvoVkySfU187nMruMUeng17rZVcdqhZc1caI1H5XPIrxUrHW0VlTFPEZNWVip2z2pi5SsIjSiGrO3ApVA6UncaiiIQil8rmrAUkUoT1FCQNIrNFkivmYARTSqeNsxH5NX1AV+Zee4r5l1ZDBrOqR/wBy7kH5Ma9HA7SRy11ZpnuVyM+FSR3s1P8A44KxPCX+su/ov9a37hMeEP8AtyX/ANAFYfg1d0t5x/Cv9a9vBL/hCxf+JfmjKa/fwOlCmnbTU4jHpTxFx0r5NI6+UpFT6GkAPpV7yeDxUTR89KVhpWK4X2pQpzU+0Cm7eaVh2GhTik21LjmnbM1SRLdiMDjpRUpWoypqrEXGmkyKU0gUmlYBDgikAz0qTYfSnKnHSloBGEpfLqUJihlpoViuy47VHkZ6VM6moypFJjQ5KnB4qsuc1MpqkDRIcVE3tTyaMA02yUmQlaQgVMUzxSGPFSy0iAg0mDUrrimUrg0KFpStICe1OHNO4rELrUDKau7Ce1J5BNQ2UkU8GnJk1YMB9KRYTnpU2LGhTS7etTiLNO8k4q0iGii64FVpRx1rSlhPpVV4Se1DCxlsuTS7auGDk/LQLfPaoaKSKeMCk31ca3NRmDilZlNFcSVZgfNRGE+lWIISMU1clpk4prnFSbDimvE2OlU0RqVpJCKYspzUvkkt7U5LUk9KzaY0mIvzVOkZ9Klhtj0xVxbb2p2KSZVEdBU+lXhBigwe1CQOJR2Uw1ceL2NQmAmrSIcWV8ZoKntVkQU8W+e9MXKZrBqaUPWtI2x9M0htCf4aLDSZnCMmp0h9auLa04Qkdqho0SZWEfFIU4q+IfamtB7Uh2ZnEYpu/FXHhI7VUkiNDQrWF8yo3lIpNjCoJFc54pNsdxGlyc0qyioTG+OlPSJxjis2myUrvUkY5x603BPapUgY4qx9n4oUWWolIAinZHpVnyM9qDAPSqSZXIiJW7YqTtmlWHHbvU3l54rReYNWKnJ7UohY1dWAdcU9YjwAKLCSKaW7GrKwYFXoo1A6U8qoppGiR487MDnJpq3EgP3q1JrBgOlUTasG6VsrM8yzQ5LyQd+KsJqLjHWq32dvSgxtnoaThF7oaclszSTUWHJY1KNXTpvFYrBuB+VQsGB6Gs3RiylUkjoRqQbHIpftinnNc1lqPMkUdTS9gujKVdrc6M3aHvSGVTzxXMG6lXv+dSrfykdKbw8lsylWT3OgDIeqg04RwsfuVgpqLgcg1ah1EE8k1LpTRXPBmn9iiY5BxSmwG3h6ZDeo38QP1q19ojI5IrNSktxqMGUnsZR0INV3t51PK1riRCeDTXKn+IU1Ua3E6MXsY+JAeUNShiB3rUXbjtTwqHqoNUqr6oh0L7My0l9aGcVotBbtn5Rmo2s4GHBxVKoupDoyWxQyKjcgkmr500H7slQyaXMDw2atVIg6ckUgQM09JMDNLJYXK/w8VE8Myj/VmrUovqS1JbokMvHWo9/NVWkZeoIpVlyRxVoRaGCaHwB1xTUYGo5WPpRoO7EMpFI0x6CoSHJwMmp4LV2OSKNkNajOTnNRFSTWk9uQvSmRW+QSRUtlJtFeH7taFuSAOarOmxvrV+ytXmQNnCV9NmOuQ4X1l+cjKk/38i9bwl1JPSmyr5JBHrWhaR7fl6gAClvYDJwhHvXyjjpc7lIqxXXQZq2L3GADmls9KGBkcmrQ0Y7s80lBl37lcXT9c4qW2vC8hBqWTS2AIwRRZ6Yyt0quV3Jaualrk1qxxZHFVba3EYHFaMWBjNWojSsM8nnkU4QgVOrL6Urf7Jq1ELsh8sDtXh3xHX7P4wvUA/1m2f8A8cXn9K93XB69a8V+LtsYvF9rNjiayHPupYf/ABNehlztWscuK1gcZGFwze5qKfnYR1qwAViHf2qvMuI1LDvX0S2PNZDMMHrVMjNWp2BXNU3bC5rSP8GfyH1GTH5QPeq5qeQkxDPrULdq86oaIktn2XMbejCuzjIMaiuMtk8y4jX1YCu0jz5S4HYVrh+pFXoBGQOeajOD1qQnbx29ahaupGSQxgc571RujvvYE6EfNn/P0q6zcVQZg2pZ6eWn5/5zXRQ0bfZMCWTdjrVaSrDjvVdutc7Y4q53/wAJtL+069cagy5W0hwv++/A/TdXr7KK5T4YaZ9h8HJcsv7y9kaX/gA+Vf5Ma7LAIyRXyuOn7Ss/I9ihHlgkVivFJ5YqY4pK5LI1IsAUYqXaKbg0WAZgUYXNO2mkKntSsA4MKVmx0poU+lG1qLANb1r5t8WxiHxfrydMXsn6sTX0qUOPevBfGXh7VrvxxrS2WmXlzvcSr5MDPlWA54HTPH1ruwbtJpmGIWiZ6zdrjwg3/Xiv/osVgeBxmW9/3U/rXS30bJ4RkV1KutiAVPBBEYBB+lc/4BGZr7/dT+te5gV/wh4r/FH80Z1P94gdesftTwh9KmAIpwBr5Wx1lYj1qNkz2q2yZ6imeWBSsPcoOmKZtq+0YNMMIpWDlKyoSamWPipBGR2qZUFCRLgVDGaQxGr2ykKLVE8hnGEk9KesJq75YxSbPepdxqBVEHFOEQHarOwCkP0pD5UQiIZpDCKnGKX5cUAoFRoMmo2tj2FaAC+tG1faiw+Qzvs5pfJPpV/YO1JtHpQHIimsBPaniD2q1jFKAKaHyJFcQD0pGhHpVvHtSFRRYEjPa3J71Ebc+laLIPWo9vvRYOVFIQEdqkWA1ZA60oU0rByIjWAU/wAgVMo45p34Uco7WKrW45pogFWyKNvvT5BWKwgFP8oAVMAKCFosHKVmhFQtbg+lXTg0wgetDQcpS+yLSi1GelXNo9aXa3alyjSKRtB6Uw2fsK0CopoQE9aTiVZGa1kPSlS2CjpWi0eBnNR7aVhOKK4hHpQ0A9KsAU7ANVYnkRSFsKmS3A7Cpx6UAgdaXLcaigWED0qVY1pm4etODgDrT5R2Jdi0FBUYlHrTvNXNNRQrCNGvpUflL6CpTIp7UxmBPBotYLDREvoKURr0AprZpUcCiw+VEnlD0o8sAU3zSe1SIcDLHmqSFYjMY9KbsXNSNITxmnBcLnHNJxGkMCDGcUbFNKzdeKYXwKnkGRvCpqrJACelXlIPtTGUZocBNXKYtQTSGxHXFXQMA0Z4pcguUoG0TcOKcbQc4xVo4/GnACjkBRKsdn0zjFWPITb0qcAAUjOAKORFpWKpgXPamG3zVkEE0uRS5UMqfZx6VLHbjjjmrIUYFPQEHmqUCWRC3x0FN8r5uRV4cj1pjIeeKvkEmQBGxxikKd6mKgVExGaOVA2c1JpysDwKqSaQp5210xhzjAppt/asjDkucq2lgD7tQNpgwSVrrjbcVC9qPSldj5FY5E6Up4xUMmjnOAua7E2Y9KT7ED/DVKTRLgjiDozA8rUcukNt+7Xe/wBnr3WmNpwPG2jnZHsrnnR0ly33aemjnH3a73+zEB+7TxpqjotP2jD2J55JpLjov6UiaXIG+7XoR0tD/DTf7LT+7Q5tjVI4cWDqORQbSTqAcetdydKTptph0pc/dpXB0n0ONS3uM8FqeYLmuwXSkHannSk/u0mkxqm0cWRMO1J58g7EV2L6Sh/hqs+iqT92ocUaqLRzKTNnvUvnfSt7+xE44p/9hpx8tS4XKSZkQDcelXli4Gc1dj0dVPANWRp5A71LpjuY7QZ7mo1ttxwQMVstZuO1EdmwJJWhU2CZhz6cp6IDxVYaUjEZh/SuqNnn+ClWzwfumnyyWzK5U90c2NGi7Jio20BG6E12MdqCAMCpls09BTXOtmJ04vocTF4eAPPP4VeGjMo4FdatkmPu0otV9Kq8nuJU0tjipNJcn7hpo0pwCAldz9iGOlMNouelUnITpI8z1W1a2ePdn5ge1b+jWoeyiJXqoNM8cQiGSywMZV/6V0Wh2gOj2bgdYVP6V9bj3/wg4X1l+cjipw/2iaM6aAQnCj61JDbFlHHetyWyVh92nRWar0FfLrU7FCxVs4BGw3CtDYnoKBBgjinmPjgfjVpWKS6EbQJJjihbdFOcVKoIGKdt4qrIdiPIzUinPambTzx9KeikE5oQWJFp+OKaKeMVVhNCBcfWvMPjHabotGvsdGlt2P1AYf8As1epgdRXGfFKw+1eB5pcZNpPFN/wHO1v/Qq6MLLlrJmFZXgzxQMzYJ9AAKp38m2REHUDn61eiAji85z8igH6n0rLJaaVpnHU19I9jyhrFvJye1QnlR1HFWxEzqSvbrVY9cVrTX7qp6L8wuRSj92PrUUoxtHtVsQPN8o9arXRHnsAcgcVwVFZGiGwSeTcRydlYH9a7vbtiwOnb6Vw1nC1xdwwqMl3A/Wu9nwDtBHHarw99SahUYjHXINQseTUjHkkHg1AxwetdaMkI2OTmqEZD3c79CPl/wA/lVx2yDVC1wyySN1Zuf8AP410U9Kc36fmDRO7daS0tpL29htoRmSd1jQf7THApsnSut+GOnre+NLWVxlLRWuSPdRhf1auHEVOSm5GlKPNNI9xtLKPT7G2sov9XbxLEv0UYpxGKkMgP0pCwPpXyTd3dntJERFJipRg5bsKRmBpD6kdGKeAp70hwDweKB2G4pQKCcUKwz1oFYUKfSlKY70b/egtQFhu32qjp58rx5tP/LXTePqshJ/nWgrKOvWsl3uI/HGmvbQrMWsp0KtII/41PU5rfDu1RXMqyvAk8QKBoGof9cH/AJVyfw+GZr//AHU/ma63xC2dA1HPB8h8j3xXJfD5gk1+T/dT+Zr6TB/8iTF/4l+aOef+8U/Q7rFFRmZfWgSrXydzusONIaa0voKYZPwougSJdnrSFRUYlx3NO8wGk2UPwMUhcDio2k6iojIR0ouKxZMgFN8wE1VLmk3mi47ItlhnINNLDHfNVw5oLk96lisStJ0wRTPNNMwMil2ZPSiwWHqxz1p4Y9qjCnPSnYNFgJN30o8xduahYHFRnOPpQwJmlHanCSqvNLkgcUmItBwetKXAwRVXcegpdxODTTGWPM9xSeZUYxTWYCquBJupC3NQNKBTDcL60rjLQNODCqJuVHpQLpTSuBoFwBTfMqn9pWnLMrdKLhoWfM54pfNx1qHeKQsMUXETed0xSGUntUIYelO3UXAeXNJu9aAPSkOBRcY9TUvBHcVWDDPWpPMOOtNMVhZGxwKaj803IJoUc0bjJ2YFKhpSeKQHJxTAULSHAqQg4zUeCetACZppNKU4NNNAaAH5xTqgyQelPDcUCHjJzUZdg1SA8U2VAehoQmOV91O5zUcQI4q4kRIzRa4X0Kzk4NRxh2bgVdaMZ45pyxqvQZqkguRRxsTzStUpYYIAxTQMiiwIjQ7ckintMNtMlBAA7mkWPPBNVYBASxNNlU4qykQHSh0FKwXKaZXAp5yacV+bpUiRk81LRRCcmkIxVhkwuajwPWhoCHkt0qYDA6U5YyTilfA4AosK5Cz4yKiYk8091pAKkaGBmApSacoBNKwGaNAHxtU24VCijHWlzTTsS2To4zUzN8tU0cZq0hBXrTUhNkTZJ4qJkOKnfCnioXlpOQh5XHagLkZxTgQcD1qdEGAO9SlcrYreXTGiB7VZIxx6U3FS0NFUQjpipVhHpUqgZp3tQkDSI/KUUGEHtUlLkYp2QkkV/JGelP8AIA7VJnml3UrDsVzCKeLdfSnk0oehJBZDPIXHSg2wPapt9G/riqSCxCLcU4wADpUgcH60jvgU7XEQNAPSojAP7tWlkBp2B1pOKKKf2deu2lEA/u1ZOB2oHf07UKIXIRB/s0phUdqsCmuMj3osgKjQqe1KsIHap8DjJxShVzRZCIvIz2pDbg9qtZAHSgU+UdysIAKesAzzU2M0dKfKA0IopVUDn3oJA70ZzRyoQ8YIwRTSo9KKMGnZAjhfiFjztPwD91//AGWur8P4Ggafx/ywT+Vcn8Qj++sP91//AGWuq0A/8SCwz/zwT+VfU4//AJEWF9ZfnI4aX+8zNRgvNKqoD+FMDDPNNL4NfLpI7WPK55owKb5gqNpQDVaAiRsYoAFMVw3pmnZ60xi4A5o4NML4HIoV1IpICZRR0FRiQetDSDnmquG5IH9qyPGciL4J1lnUEG1YAH1JAH61rIynArmfiRI0XgPUNp+80S/m4zWlFXqRRFTSLPCrl/PiSJBhB1+tQmMAAAVLMVjAAGTnGaYCD2NfUo8NgABE+azWOGJNX5eIWNU4oWnlCqOO57AVvD+FP5fmBNv8mzaT14FZBJJJPerl/cJIwhh/1ScD3PrVOvLqyu7I1ijc8Lx7tTeQj5UjJzjvkCujuHDSHnHpWXo00C2qyr+4JXa69Q2P4hnpV5prdskzLz711UY2jcym7uxXkYAdars+B1qab7Ofuzj6VVdBjIbNakpNjZJSFZgeQCahtVAtwfUk0T5WFz36U6PCwIAewNbp2o+r/JBYVxkivUfhNpxiXUNTfuBbR/ozH/0GvLVOZAM55r3PwRbi18IWIAIMgaVvclj/AEFePmdXlo27nZg4Xnd9DqhIuOaUspFUssc804OQOpr5tM9WxbD4xTS4qDePemOxzzRcZZMgFKGyKpBzU8b0Jgx0jMOlQtKwzipZHzVY0XJTHfaWHXNSfaCQKrEd6QdaLlFvzmxy1U4pMeMdEY5yVnX/AMcB/pUwBNVmAHiXQG6f6RIufrG3+FbUHaojKsvcY3xHPt07Uo887JFrk/BcmyW891T+tdP4oTbBqh9pP15rlPCP+tuvov8AWvp8NpkuL/xL80ccta9P0Oy849jUizDuaqKCakRDXyFzvuy15maQtUa8GpAuaLlCg5p27FJtIpvOaLgPJJphNPxxTCOaLgJT1XNCpUgwKpIBhQU3bU+AcdTSmPiiwXIcU5Ac9KDwcUoYUCuPXqM0jEUbsniomPNDAfjdmmNGcZojb5qmdhilZAVSuKbipWwaYSBUsBMetOGMUwMCacaLghrNVaSZhnmpnqrKpPGKVwZUlu3FUpL1x3q+1sWHSqstkSalt9Auip9tf1o+3yDFWRpxxSpp2e1TqO6IEvHJHJFalpcFupqn9gORxVmO3aMUK/ULo0BJxzShsioUjYgZzVlYmwDWiTZNxocilEnNI4OcVLBCOp61SQkyWM8cio5GAqYrjvVeVCemTVWsO4xDuNT5qKOMnH61MMAgYpWGthvzZ6U6PJzxUoAOaEXdnBppBcjk4Q5qGOTmrUqA8dahCgZwKGguSxtkYpDSxjjGacV9qEgbFKjb1qu9WO1RMp54qrCISOB60gU5qwkRPOKmEHqKVmFysq45xSNknpVh1CimgZPA49adguRxrg9KtKSRUBOGxU6AgU0rAx4FLjikDUFuM5qhJEEpK0schAFRyHLc0g65NRfUqxIeeuKei45pgHWp4hxz60xMeitjOKYyfMcirGdvHao2b1HNO5KbKzLg05GBGMY4qTGabs5zk1NykxrZI6VCQA1T8Y61G+39Km4Nj4zQyg5qONsAj3olk9KHJCuRyYH0poxjqKrSzFmI9Kg8xxWTmCkXs4ag1ViZs5Jq0GBxS5xp3HrxUTybal3LyKqzEYNDkJj0kJap/tG0c1nIzZp7s+3mpuxXLT3FRecp71SaRs4HWmYds9qhyE2b6EZBqwZMKQaz4puOtE052kZrpTshORNJcAnrTPOJOBVIMSasQnke9Te4lJlyME8npSlsGkEgEeKhZwT1qrlt3Ji/NG8Gos8Uwtik9SkWN3NP7VTEuDzUyTKaB3JDSUx5BnimrJk9aBXJqRn21H5uAearTTHHWmguTNc4brTWnznmqBfJPJpVYZ607hcuxzEHOatCUYzms1GGalaTC0Duiw0/epI5FJFZZmOanic5GOtAXTNLOMnNN3Z71CZDtpqvg807oZYIyaclRCQEZqVXX1ouguPPFAobHFApk3AYwCaRiKOaa3TmncdyF5D0zT4iT3qu7jdkChZTkmpuBd3Y7UMeKp+c+KUyOR1o5kK5x3j85msf91/6V0+gs39hWH/XBf5Vynjo5lsev3X/AKV1Ghsf7Csef+WC/wAq+px7/wCELC+svzkcVL/eZmkZD0phc9800nnOaaWNfLKR2pkgkxTGcGoXcAdaj8ynzMLloOB0NAkOTzVMy8Uwz4o5gui+8mRTPNIHWqom4pnmg5zS5gTRcWfNSiQ8VnrIOtSicCjmHdGnG+O9cn8S5s+C50z96aIf+PZ/pW8txxXIfEqQyeD5gM5E8RAH+9it8NL99H1M6usGeTNiZVYdSAce9CwO/Y1JII4dnnzCOJFAwPvH1qrNrjHMdlCAP7zDJr6tzSR4rTextaN4ebWdThs5C8cDZaR0XkKB+meBn3711OrfD6xt9CvDp0t39pWAsF4fzSuWxgDOT93jHbg858+0jVLnR9ZttWlPnyRE/I7Y3AgqfocE/wD166jW/iZ9u0Se0g0zy3uYWid3l3BN2QcAAZ+Xvxyehxz5eM+vTqp4e/JZX279e54WY0sxlioPDP3NL7b31v30PODV2ysbm4l/dQbzsLKG4BGcZ96ZZ2bXUnXbGD8zf0HvW6+pP9pae3towwQR7skfKOAPTtXTTpuWrPoXKxROj3W8+fMAT1wc4qYWUcXRiR7nvSTahdOf+PWPPqRmofNvX4Mixj0VQK6UlHYhu+5dgt92Sq5x1J4H5mkmubaH5fNVnH9zoKz5IpZyBJPJJ7E8UNbwW6dNznoDVQU5y5YrUVke2eBtI0uXwpaXTWtrcTXCyGSVo9xOSVK/MM4x8pA4PPXOTw/xMsLTStet1sYoYEltwzwxKVAIJG7GNoBAA4/unI5ycfR/GetaBZfZrW8P2cbisTorBCw6jIyMHnHTPY5OcbWdevdbvDdX07TzFQu4gAADsAOAPp6n1r53D5bisPmM686vNB36vrsrWtp/wxw0cJWjXdSUtHcWx33l7DbQjMsrhEH+0TgV9I20aW1rFbp/q4UVF+gGK8H+Gtutx41tmYZEEcko9iFwD+Zr3QMQKeZ1XKaifR4OCUWywJVoLjHWqZkHPNNaY4615Z1F/euM5qKSQHv+NU1nJNKz8daAJvMGetTJMPWsxnINKsx7mgZpmQc80Bs1SWXgVMkoqkLQnamg0m7IpGbFDYyePnmq94QmraI+M4v1H/fSMP60+KT3qpqs5h+wThNxjvoGxkLn58YyeO9XRdpozqK8WW/FqgWuqZ6+W38q4zwYm+a79lX+tdl4paR7DUWkiMTmAkoWDY+UdxxXJ+BF3TXv+6n9a+rw/wDyJsX/AIl+cThf8an6HWLEBTtuBVjaoGajYAmvjz0dCHGTVhBimKtSj0oE3YDzkVG64HQ5qQLtyRTxyBVJCuVNxGR0py8809o1yTSYApJBcUdTTttM7ipgwFWtguMBwae0wqtNJjoarNIfWi5LZbds81D5mDUQc4xmkL880gTLYkJHWmkmoFkqTfkUiroBIQelPaXjrURPvUJJzSuS2W9wOKaQOpqBWOasptOaLXGnchUgHpUxbjOKaFUydKnKgrRygmVMgnrQYw3AFK0eGqVCMYoSFe+g1IF7imPbgVbBGKU07AUhF0GKf9n9B9as7MGpAoAoULjKf2cDHFJ5ALVd4HamMACeKrkC5GsYAGBSnvUjD3pmDnFPlC5F5eTzViMADgUip1qRcAcU0rCFKBuTUZjx0pzMwwKieQ9BTdgVxVC96Vl9KiBwcmpEbLVN0UBQgGliIBp7NSwrzkU0DElU9QOagII6nmrrsATiqbZLZPc02kJCo2Ox5qcAEVEE6HNTKwUYIpaDGYxQaGfJpgfmldAWo0GDn0qJnKkgU/zMLmqjuSaLoETf6wVIEwB2qBGAxVsPlRkCmmhPQrsnzEk1MoAUCmOM9BSgnvSuF9B/AFQSPzinlgO/NRNgnNJsdyM5pRnHSkNCNSuFyRSScYqyMAVWDYOaGnNHMJsn3DNKW464qmHJ5zQ0pA5qXIVyw0wFRfaATgGqskhIqESHPWs3MlysaDS8darPKd1QGbg00sxqHNslybLMc2Dz0p8kgI61SVXJxg08hu+aE2xpsT70hqZUytQqhZgK1ILcFRn0qkmxplLZjNRfNjk1ptAPSmi2THvT5BmYC7Nx1qfySy4rQitFJzxVg26cYFUoCMuG0HcU+W3GMAVfeMKOtRsuRT5FYZkNa/NnFSLANuDxV10w2abtqHAVkQxQtTZIWHHXNXQuO1KVDHpWvKQtiglu2M4qYQlRmrBTB6VIIyy/0o5Q2KZR2X3pgRwcCrqLg4xTmjxzijlY7ooncKawb8aulBSNGMU7FcxnOr035xWj5ak0GBSKGibmbuLHmnqSO9WRbfNTzAMYxSsFygXbdTJCSKvtajtVcwtuxSaHcqovHIp2BVr7OcVCYm3Ec1LuDlYaODTmORTjE2BxTlgYgGi7FzFRR83SrKEDFOa3brijym44NGocw8OpHSpFKgZqLyTwRmlYEDFJtofOIZiCRUiXAHeqjg571CxfkVLbQudmhJfDOKQXvArKMchkXg1K0Mm2lzyFzmslyDzkU95lIrIjSVR0NOMjjHFPnY+ctNNzxTgxPeqK7yc4NTpvA5pczY1PuSMxpRJxVeVmx71GJGzRdi5znfG5zJY8/wAL/wBK6bQyP7Fshn/liv8AKuU8YsWltM+jf0rotFcjR7Pr/ql/lX1uYP8A4QML6y/ORy0pf7RNm0MUxwRUSyEHmnO+Rwa+VTO26IJDUQYUy4m255qBZs96Tmybkryc0wkGmSsAM1W8/nFS52C5aMmB1pVJPOapuxzxU8L/AC0vaCuTluKlj5HvVcnJGKtw7QOapTKTGyZWvP8A4j+IXsLaHToVBedfMZj2wcDHvXoM5U9DXj/xMBfxDFnkLAvH1Jruy6066MsRK0NDioYpLqXLkkdzWgkKooCrUtrAIrQORjcKG+Vd3T0HvX1MIJK7PKk7uxTucmURqOg5psdm9xOlupwxPU9u+at2sEtxMAgG6RsAmtEWi2WvWkcS5JiLHjljhua6KMb8y7p/5hfqSDTkhhWCM44+X19yaiaFYiIhg4HNacilctNPHHnrk1myahY2xO0mWTnk9M1mkkrInViC23YzwKilS2hBMrYqlcaxcT5EYwPaqLLJKd8rk1Kbk1GOrZSj3Lct8CStvHtX1PWoGYKC7nJ9KaMIMmq8jl268VrVmqCdOD1e7/RFJXCSUuaiPFShMgnsKt6XpN7rV8trYQmWUgk8gBR3JJ4ArzakrK7NEr6I7T4S24OrahdH/lnbhB/wJv8A7GvWt/HWua8LaKPDujR2jbGnYl5nXozegJ7AcCt8Nmvm8VXVSo2tj06S5IJMa5OetQl2Jq1tBFVpFIbisOY1UkPXdSluOlNUnFRs/OKOewcyHnBNIBg03mpI1JNCkmLmFQEnirCgikRO9PbpxWiegJjw+BzTGkzTDlutG3ik2NyHJJz1qtrOTphPpNEfykWplHIqHWv+QHdn+6gb8mB/pVU376Jk/daNnxn/AMeuoEd7cn/x2uN8C/669/3U/rXZ+MgW0+7cdDaf0rkPAABnvs/3U/ma+woL/hGxfrH84nn3/fU/Q7DOKQYzmpXj54qLGK+OZ6Fx3anRjJGabxT14pIGx7DAqIkhcU9iTQRVXJuQZOaGY7acwHamMwAouO41WHrSSSYFR7xzUbHNK4rjJGJOeaaue4pW64pvI71DkFx9MY4pN3NDHNPmC4Ic1ZUHAqohANWEkHSjmC45gaj2nNTggrSbRRcLkYHFLvIpHOKjzmmpBclD4qwsmRiqgU1IpxVKQXsT8HrSqgHNVjJg1NHJ60ufUaaJegpQTQGUmnZ4p3C4ob3p5YEe9Vy4zTg2eaaYJokDe9KcHBNRg04t70cw7js5pMDvUYJJp4yKOYLoV8jtSqcCmZOeTTwvvRzBcjc80zApz4U5pgI9aTYXSHlRtoB5phkNKpy2alyC6ZKRx0pUJHegYpeKakFxHkPrTA3vTmXNCoM0+ZhdEijK5qNz04qdQAOtRSAZ68UNsLjV9aRg2c0se0GiTHHNTcLjgSVNRFDxgUIw5GasoFxyaadwuQJkHpU+cgU4hSc4pcCmgbGjmmSZXmpwVGf0qKUbgabFcqmXkjNSKMgHNV2iYNkVYVTip1FdgVLHFIUKdjVmHAbk8U6Yo1OwXZSIz0FMZHJqxkA84qTem3qKm1wbuQRxZ4xTzb5p4kAPXikNwoOAadkBC9pVeW2IFXzNx2qB5Bnk1LgmJoppasSKuxWiYpPNUAEUq3OOKFBISSRYEEY6ComjTPSonum7dKYkxLdabSKuiwIV67auROseQapl+BUfmn1pqyAtvKN3BxQzL1FZzSNu61LvOOTTugTLIuACee9ON105rOaTB4pwclfelcLov+YpB5prSAVSDsKUucUXHdFvctMYiq6sW71N5ZI70BdExIpUIBqpvbOKUO461pcyuXWZex/ClR1UHNUvMc0xmc0XQNl8SKDmlaVD3rM+cc80uXIpXA0C6HpSnaR1rOV3B71L5rY70XC5YJUd6kVkIOazmdmNSK5AouG5eAQkc0rBRVISnPNNeZs0XAvqqEUwwp61TFw2OaT7Q5ouguWWAFNCL6VVaVzS+e+KQXRbKA84p6KuOAKofaXwaFuXA5paA2aQh3DORTTAfTNVEu29Kk+1H3p6BcsrAMDPHNK1orZqsLs5qQXhx1o0ENNko7d6jNkgp32nJPNBuAaTSYALRBg8UvkIPSnJKPwoeXJpcsRirboV9qjezTNIZ9pxTvtY9qLIlsVLJMUotVx0xSLeLTzcjt1osh3IHsge1Rmx5qx9qHqKcLnJ7UnFMDgvHMPkzWXoVf8ApXT6HAf7Csmx1hX+Vc/8QnDy6fj+6/8A7LXVaC6/8I/YA9oE/lX1WYRX9g4Vecvzkc1N2ryFaA0wwPWiXQccVEClfK2SOq5kTWjscEVCLJx0Fbx2UbYqlxTEYhs2K8iq32BvMJ966XEZHamLGm/oKThcdjD+wn0pVtGHauh8qOkMUY9KPZIEzB8hlxxSbHBNbXlp0p3kofSjkQzEEEjDkV5V8S4JT4jjiVfvWqsT9GavdlhjArzD4pWSDU9MuV4DxNG34Op/k1d+WRSxCMK7vA87uR5YWEdgB+VReQGbdKygAZyxwAPU1NM67nfGTzxVOCB9QvCjk+THhpT79hX1bdkeclcvxTwxxiS2ByQR5jjk/QdhVC8lla5hkZyXzgHPOP8AJrQlEZb5MBQMAfSsy8cZR16o3Fb4b+KvO/5CEliYqd8jH19Kr+UvXtTpZie/FVmdieK5G23ZFpE/yJ0qJmLHAoVDjJprOqg47Vu2sPHlXxvfy8vXuPcZI2PlGc0kcRY4/OkRS7Z9auqqwx5JxXFYodaaddapfQ2FjCZZ5DgAdh3JPYDua9t8NeFrfw5pnkRYe5fBnmxy7DsPRR2FVfhn4a/szQDql0mLu/AZQeqwj7o/Hqf+A12uxB2FfPZhinUl7OOyO2jTUVd7mO8RHNLGjZrUkROcAVEqqD0rzLWNblfYwB4qsytk8Vqkoe1QlFJ6CgLlQQkrUDQNuHBrVUAelIQM9qGrj5il5J20+GJg3Srfy0qbQaEkguIIu5HWm+STmrQkXbTTIpNaJjuVvKPpQYeKn3rQZB2obC5VEZzzUeqQltDvx/07uQfouauBh3ApLzbLp1yn96Fxj6qacHaSE3oT+JD5nhlpTzusM/muf61yHgFts19/up/M10Go3bXHgiFzDNH/AKBjMi4DfIOV9q5jwTJ5ct77qn9a+0oP/hExT84/nE4r/vofM9BJUrVWQbaYtxxzTWnBr4tyudyYeYc4qQPVUyZNL5nFTzBzFjzwDzTDdDpioGYmmbTnrT57E8xO0pYYqEk04HFIW5zmjnDmDBxmoWds9KsBxjHFMZVJzScg5iA7sUAMe1T8UDFS2FyuUOelSpHkU/Ip9K4XKzREHihUbNWMikyKLhcVVwKkCcdKj30eYaq4XGyx+9RqmOtSFiaSk2Fx+BihQopuTSZPpTuFxWGTzSqRxmm8nrS4NFwTJQ3enGU1BzSYPGadwuSF2zSGQ02jGafMA9ZT60vmtUJyKDnFHMwuydJlHHpUhnXFUfmpwzQpDTLJnz0pBcEDFV8jvQG9qfMO7HSSFjSLIQKUtmm/hSbEBck1IrdKjwfSgFgaEBY84il881CG9aMj0p3HdlkXHtTfPPNVyRQCKLoLk/2lqQzMe9QmgECncLkm9qDIx70wyYpoepbESBytSrO1QAg08YpJhcnFw1OMw9agxmmkECqUh3LJuB60n2jnrVXminzBcs+apPWnecAOtVc01no5guWTcHtTGuGI61BnPY0ECjnC4rze9Ri4IpGFN8uk5AS+f9aBNzUYjo280XAn87Heo2npuzNNaMg07sVyVZM08NUCqc0/JBoTAczUzzOcilYZxSCPmk2A8SsRjNHmN60gUCnbaLgJvPrQZz0NBAPaomSk2A8OCc04yYFRhacFoTAPNOaeZMgc1HtFIMUXYydJSrAirIuwAeKo4HrQQaLsLlxpl9qPOWqJLYpBu9avnI5mXROvNCzg1SweuaMH3o50HMX/ALQuKYJxzVPax9aNjUnMOYvecMUeetUtrUvlt60ucXMWhMpPSgz+lVAhHenbDnrRzhzMsedxTGmHrURBo2Uudg33JlkBHWjzRnrUIWkK80c4rlgyL60nmKe9V9vFKBRzsLkwdfanFkwKrFeaXBpc7C5MJFzS+YuagAxS45pc7FcmMgpPN461FijAo52FyYS0ebUXFJxRzsLsmWYjvQZyeah4o4NHtGF2PaYmm+aTSUmKlzYrsdvNO8z3qPilyKFIE7D9/FKJcetMFJkUczHdnL+NHLyWeSeFf+ldBo07Lo9muT/qV/lXO+Mf9ZafRv6VvaT/AMgi0/65L/KvrMxl/wAY/hH5y/ORzQ/jSNMzt6mk85vWoc0vFfJqbOm7JfPb1pftD+pqDIozRziuyXz296UTsOc1DmjIo52O7LH2t/eg3T+tQA0cUc7C7JftD5zThcvUQI9Kd8tHOF2Srcv0ya474i5k0i0mIJKTkA/VSf6V1y4rlfiJJt8ORRDkyXKAD1wrGuzATf1iNjOq3yu55SsbzzpEi8sf5dzV4xpaQJbRHuWZu5Pcn3psM0VgGbaTMwxu/wAKo3WoYyFBMjDOfSvsn3ZwLXQLqfb8i9ehNZsr5IXNI0jsWdvwqJQSd3pTw837aNu6K5dBACzEmpETP09aVV3HHbvRLKEUqprWS+q6/ae3kv8AMe42aQLwDVfBYhR+NIWLHNXrS3wNzdSa4L3KY+GEKvI5rZ8L6GfEfiGK1YE2kP725I/uA/d+pPFZUzlQFUEseAAOSTXtfgvw4PDmgpHOv+mz4luW9GI4X6Afrurhx+IVGlZbs0pwu7nQiYhQFAAAwAOgA4AFRmVvSnnrwKaQBXyzkzrGGVqTexpSKABmi7AbvelDNTuOaXFFwELtTd7Zp+KNtFxWG72o3t607bzRtFMYze1G9qftFGygWowu1NEje9SlBQEFAajd59aQuW4PfinlBQqcj61S3DUg1Fifh1pxAxi0Zf8Ax0D+lcr4SJEt1j0X+tdVdjPw5iH/ADyWZPyZxXM+DV3S3f8Aur/WvtqX/IixXrH84nI/40fmdOHagM1TeWKPLr4ezOshyetG5ualKUBBRYLEWWpctipdgpdop2CxDk0hJqbaKCgpWHYg3OOxpQxI71Jso2UrCsyPLZ4NJubNShRSlARTsFiINTt5pQgp2yiwyLeaXead5dGyiwDCxoDkipRGPSjygKdmFhin1p9KEpdvtRYLCcUZpcUYp2HqIKWjFLTsGo3IpTijFLigQzPNOpCPalFJjuxDmm80/il2ihICI5pBmpDijApBdjduaXZ706lAp3C40AAdaMd806k207hcTNFGKMGlcdwJ96axIHWnbaCOtFwuNHPfNLilC0YoQXAYpCBSgGjFO4XG7c0bOadRQFw24704A4603p0pckCgLkucU1hnvUe5s0ZJ7GgLkoX3FKVGO1RgkdaXdTsFxSKjK89RQTzSj6UguOKHFN2HNOB9aWmFxuz2ppU0/NJQK7G4OelKPWnGjHFPQLsZ0oyOlOwKMUBdjQKDj0p/HrRimF2MGKM+lOpMZ70BdiAmlzS4ApMUmO4mfakOTTwKXikFxoWnbDRuHrS+Z709AuM8rNHkmpPM+lBkoHcZ5JFKIyKUze9Hn9KBXIeKTIpgHanbaRNh2VxRkHpTNtLtAHNJhYkGBRkVFk0bu1Fx2JgRSZFRh6M80XCxJkUhNMDc0vfikwsOzSUcetIT70gsLupDRxzQSMc0CsGaTNGR60ZH6UBYN3FLmmnmkJzRYLDjmmlsZFKG45pC1Fg5UG6lyTTeKcDiiwWE5pxBpQaCeaLDshhJzxSgGnYHXNGAe9KwWQzmjn1p4ANLik0FiI5pMmptmaTYBSswsR5NGTUhTjik2UWYWOU8XnMlp9G/pW/pB/4lFp/1yX+VYPi9cSWn0b+lb+kKf7ItDn/lkv8AKvrcx/5J7Cf4pfnI5qa/fyLeTik3Zp9Jt5r5KzOmyGc0U8ijBpWCwwUhJzUmOaQiiwWI8ml3E08LTggosFhoyKUE5p2wU9UoaYCDNef+Ptajnni0qAB2gYvK/wDdYjG0e+Ota3i/xraeH1NlbuJNRdeAORDn+I+/oK8tbULQuzTXOSxyxHJJPUn3r3cpwT5vbVNEtjlrT05UOuJYxuc4JAwBWYEd8tj52PWrEmoaepysUkmOnYVVfUZ5eI4wg6CvoZTT0RzJDmtz/EQEH5/Wo8cFY+gGSaYkcssgDMWb+VOuZkgTyY+W/iauiHJQiqlTd7L9f8gs3ohjziOPaBzVQlpH9SakkQtKMelX7Wy24JHJrDExk68k+7KTSRHa2vILdB/OrrbVUntUjbYlxjFLpOmXHiPWoNMtePMOZHxkRp/Ex+n86ym404uT6Ak5OyOp+HHh06nqZ1u5TNraNiAEcPL6/Rev1r1o5qvYWVvpWnQWNonlwQqEQd8DufcnkmpiTXyGLxDr1HLoehCHKrDc0GkY9sUZNc1irAfakPBoo5NFgsLScikwaXBp2CwA5p1MxTqVh2FzS5ptGeKYWH0VDk5p4JphYfRim5pCaNQsO4oBwQaZzmlxQFkRXJH/AAgF0mfuTXA/8eauZ8Fj97ef7qf1roLmdD4T1e2xJ5sc8rEhTgBgDycY71z3gzPm3mD/AAp/WvtsO75BiPWP5o43/HidfxijimHPakwfWvirnZYkyKAR6VHg+tOANFwsP+Wl4qMKaUDFO4WHcZowKTBoA5pXCwECkOKeQKaVodgsJx6UuKXFAxQg0ACjFOIpKdwsNwKdgUuKQii6CwoK+lISKbR2ouOyHcGk49aQ5ozmgVgPFGaO9H4UBYMmjnmilB60BYQGjIpGpuaAsP60mBSUZNJhYXFHNJk0m6kFhcU6kzmlxQFhMUtNNGaaCw/AxScCkFGc07hYcAKMUg9qQnJoCwvFDY9KYSQaN/ak2Fh4NBqPNLuNK4aEo+tJtHrUe73o3k0XDQfijbTMn1o3UXCw/AowPambqQNRcZJxRnHembqMjNFwHH60YNNzSFh3p3FYfgUdab5g9ab5opXCxKKDTBIKN1F2Ow6kyKTIoDYouHKKTQKTcfyoEmKLhyjwvrSnHrTN3ek31Vw5RxHvSgeppm/vRvo5g5UPOPWm5pN3rSZpXYuUeWo3Cm5oNK7CwuaTNN3e1GTRdhYcTTe4+tHXilAyMUXCwoIoJFJtPrRgnvTuFhePSm4HTFG0jvS7Rmi4co0o2elLsPWpiQRzRxinYkh20oUmpBikBxTAj8s0jRmrG4YHFIW9qVh6FbyzQYzmrFAosIgERp3lmpxiiiw1Yr7DS7M9alxSYosO5H5eKXaSKkwaXbSsBEI6QpUuKbTsSyPZxQIsmpBmnZFCVwREYsVHsOasFs038KLDbI/L70FKkyaWiwiEKaOeDUvWlxwRRYCLBPal2GngAU7IpWAiG4U4ZFSYpCBRYBgNKadilxSsVuRgGl2mn4NFOxNjkfGY/eWf0f8ApW/o4P8AY9n/ANcl/lWB4z5ls/o/9K6LRgP7Gs/+uK/yr63MF/wgYX1l+cjmp/x5E5Q5oCkd6mwDTgor5Ox1JXIME0EGpwlKY6VgsVgGpCpJqz5dJsFFhFfaaeoNS7RmpFjzRYCEKeKxPFetPoekFoCpu5TshU9vVseg/nU3iPxJY+G7TdORJdOP3VuD8ze59FrzC51K51O8e7v5d0zDOOyjsoHYCvUy/L5VZKcl7qMa1VRVluYT2T3FxJNdN5ssjFnkbkk9TnNRPBbQqCIwB6etaNwzKpGCeetZ5jMjEtkg9q+n9mktjh5myptM8nC4RetDgq4RB83tU88qwDy0GH75rOeZmJWIkk/eb1raMY0UqtRei7/8AauySa5EKeXF97+JqghtnmbODyau2mlPJ8zg1rxWyQLzgADmuVqVWTnPqNyS0RnWcALybh8yHFXZGSBckgGqcdwkM9wzcbmyB+JqlcXTSkknjtXVi2lUb72/IlEs07yyBIwWZiAoAyST2A9a9t8C+FV8NaRuuFH9oXQDXB/uAchB9O/vXBfCnS7bUPEFzd3Cbns4hJCD0DFsbj7jt717Ka+WzTFNv2SO6hBL3mNbk0ZFDGm141joAgZpMCloNFgDFGKSjdQApFJilzRmgLoTbRilzxRmgBCtNC0/NGaAuM2ilxTjSYoATFJil59KUCgAA4opaCKdgK8/HhnxGnurfmg/wrmfBh/e3n+6n9a6icY0LxGuOtvGw/Ij+lct4NH728/3V/rX2eE14exHrH80ccv94idccUDFNxQQa+LOxj8jFKGFRc0tFySUEY6UmRUXzUhLUrjuTbqM1Dkik3GlcLk+72pN1QljSgmi4rkuaM4pmTRmmA8NQWFR5NJzT1Hcm3LRvFQHNC5B60g1JsijNM5oyRTGP4oAFA/SgCnqMXFGaXNJ1NMQZzRS4xQelAxuKUIKTNOzmgBNoo20tIaAFAFG0elJThQAm3FGKUik5oAbtpCop3NJzmk0Am3GaTBqTPAozzQAwAgUuKcME0u3NAELDnmmbasbKaVpARYoINSbcUu2izAixSAc1KV5pADRYA2ZpCnvTyCKQA9adgGbKNvvT8GkKNSsAmyjYKUqabsb1osAbfejaMUENQQ1FgE8v3pDF704K3rSgN3pAMCY70FakwaMGgaZHtJpfL96eBS4NFguM2GmlGFSYNLQFxijjrTcHNS7cmgocUBcjCE0uzBqQZpDmgLjNtAQ08AjtS8+lAXRHgilA45p+OKQrQFxvGelGBmgiigLhjvSjHpSYpce9AXEagHIpSKMAUBcM4ppJ9KUijAoC4gkBpC9NVQKXaKtMzHBqUMMUwqKCnpTAUvinKc96iw1KN1AEoIyeaN3pUagjNLzigB28+tJ5hppU0m00ASeZ05pS1R7D60Y96AHiSl3Go8HsaUdKYD85pwpgFOyaGgFJ9qTrRkmgD3oQwxRtpaSmmFkKB60vy0nJphU+tUIfwKM0gBo2n14qGNWFxRx0pCp9abtagdh2cUuRwcUzY3rT1jYihhYARS7gKaYj3o8s0rAO3D1pcg0zy2GKPLbPBoA5Pxp/rbP/df+ldDozD+xrP8A64r/ACrnfGgIls8/3X/pXQ6Op/saz/64r/Kvq8w/5EGF9ZfnI5af8eRfJxSbiKTFJgnFfKHUO38Ub6btpNpoAlEvFAbJwOfQVNp2nyX915QOEAy7dcD/ABNXbfT49V1+fSLPdFYWQAvJlPzyuf4A3YDviumjhpVNdkQ5pFS1s7m8kK20DOR1wOB9SelZ/jaW68KaAt0ZIhdTv5cKfexxlm9DgfrXqVva29nAlvbRLFCg4VRgV4T8atRluvFEViBmK1tlwp6Fn5J/9BFephcup8y5tTnqV5W0PLQ89/qb3V7O80zNkvIck1oTKWAITt2qshhjJz+7/lTJri36/a9o9s178VGKsjibbY1/OhyYCfZfeqMt/exttcxEn0XmnzXcSRt5V07uf4doxVGC+jglMzAyS9s9BW0YwUfaVNunmNJlhNKurxyz/KpOST3NaUGn2dkBuYNIPyrKm12eQYGQKpPfTPn5jXLUrqcuaW5fK7WOjlvo4xwQAP0rJutW3khM7R09/estpHfgk05IsjJrJ1W9gUEtySRzIgY9zzVd2z0qd8eSwHao4UDyrGzKgZgNzdFyep9vWrxkvgfeK/yKij1f4O2jJZarfMOHeOJT67QS381r0wmqWj6TbaLotrp1oQ8USD5x/wAtGPJb8Tz9Ku4FfHYmp7Sq5I9GEeWKGFuaM04gU3jNYWGIDSFxTuKMCkAzf7UhJ9KcFFLxSCw3dSbjTiKQLQTYATQSacAKCBQOw3dSZJp+1aMAUBYYWIpAxp5APpSHaPSgdg3GjdSHFNDCnYW4/fTt3FRFqN471SHsNnb/AIluur/e08H8i3+Ncx4Mx5t5/ur/AFro5yBZ6qP72nS/oR/jXNeDziW7/wB1f619jgv+SexPqvzick/94iddnBxS1Fnmng+9fHWOsdim85o3e9G6iwDs8U3PNBPNKaVgDIo4oAoIFKwDSBSigDNOCjFOwkhKXFOwBQaLIdkNwKMDNKCKQ4FGgXQYFOwKYTTPmzRdBdE3FGB3qMEjrSh8000F0S4GKMVH5gpQ9FwuOIpQfam7xRvFO6C4/NJn2poYUUBcDinDHrTCaB3o0C4/NHWm5pcinoAoxSjFMozxQFyXijatMBpc0JDuOIFGykyKQsKGguLsoKr600EUoxSsIXavrS7aXaMcUBaLIdhu00oApQopdtFkNIjKrScVIUBoEa0WQNDOKbt9Kn2CjaB0p6BZkHSncelPKUwp70gaA4ozQE96XZ7igVmISD0o2Uu0DvSjpQFhpT3pNnoeakHTmg460tAsRbSOtBFPJpeD1osIixRipfLGKbtFFgGYoIp4oIosgGUU7bzS7RRYBtKzU8L7U3YaLDsxgJNKaeqH1p2ylYaREGFOyKUr1xTAposTZjsikJFG0mk8tqQWExScU4ocU0IaLALgUYpdtIRTsAGgZop4x6VIDCKaAPWpSOKZjmmwKzbqQbsU4MPSnGRew5qrEDDuJp67uaYG9qdvo2GOzgDik5PNG7NBPpRcBQaTcaAuadsBPNFwF7UelAGKMGi4CE8UYzSlc0oAFACAdaTGCKcTjvSdqLgGaB70ZoyKLhcCaXJIpMAinjAoTEM5FBzTzil4xVJjIwTRk0/AowKLhqMBNKCadijIpXBCFiKN9KSDQcUXHcN1AkagYNOAUc07jTELt600uak3DmmEp6UrgG9sUB2oDL2FP3KfSi4HH+NSWlsyf7r/ANK3tJcjR7Mf9MV/lWD41OZbP/df+ldBo+Do9n/1xX+VfV5h/wAiDC+svzkctP8AjyLiyZpwalCpxS4X1r5Q6hpNJmnEL2NJxQDOm0MJY6PLfSjA+aU/7iA4/UVU8KXC6P4Gu9auNpllMt0wd9u89AufUnA/GrOokW3w7nJ4zZkf99f/AK60dH05J/CEGnTbkjltPLfYcEb15x7/ADV9Dh4xSinsYxcVK89rq/oefQ/FPWkuvMltrJ4jtDRKjLwCc4OTgkHHORwOOueV+LIP/CXG7Rt8N5bxyxODkFcbeD35Wu/i+EeLoedrG63G0nZBh25O4csQOMYPPU8cc8B4/wDCXjPQ9Pi/tC7k8R6Xb7jFerGTcW6/fcydTtPzclmA2jleh92Sw85L2DV+21z0s8nl8+T6ku97Jrtbf5/qeZ3C+c2Cegz7VSntoowS7ZPYDvXcWHw/1XVNMjvo57WETxCWFZGJJBIxuwCB8pJ79hjrjjtX0u60rVLixvdonhbB2NkEEZBB9CCD689qcIwvepsv6sfJUMdh61R0qU05LdGbujQEYGfQVHt3ZO0AVYESDsKcAK561R1ZXfy8juWhVEDHPYUeSWOF6CrLAscAfWpFjwBxWPKFyGO3A5NJPII1IHWnTziJdo61QZixyaiTtoNK+pLGS8UgP1qGpYeQ69yKRdr8NwexrasuajTl5Nfc/wDgjWjZ7N8MPFH9paV/Y1zJ/pVmv7kk8vF6fVf5V3xzXzVpd9d6JqlvqNo37yFgynsR3B9iODX0fpuo2+raZa6hbf6q4jDqD1Geqn3B4r5rMMO6c+dLRnZRnzKzJDmmlSamZgOlM3815xvZIjwc0YPpTi1Ju5xTENAPrRhs07IHNHmCpATmnYJHWmGSgSigLD8HFAGab5tN3jrTugJPLz3pChoEuKUzLxRoAzy3z1pBGaf5o9aPNFF0IaYyRTfLPrUvmZpN/FK4XRH5dJ5Rp+6jJouFylejy7W7Ofv2dwv/AI6D/Sue8HjMt3/ur/Wt/VmxYTHP/LGUf+Q2rB8Hf628/wB1f5mvsMA/+MexPqvzick/48Tqghpdhp27tRvr4651jNpNOCkelLmjNHMAlJnmnYxRii4Bmg0cClGOtAXGquKXmncU0kZobAUk0hyO9NL470nmD0pXBiZIPBp/Jpm+l3Hmi7FYGzmgZpC/agMaLsQ4jIpMEGk3sKbuPpRdgPKkjrSDI4pA5pN/NF2BLmmFuRxQWPSmk+9CYCl8HinCTjrTOtBzincBwc5pTLimAUhUGmmOw7zhSiUE1HsxQFBNHMFyZZPeneYKg2kUoBzS5h3JvOWgSg96j2cU0YzT5mBOXGOaUOAKiPSkJ6UcwEwPNLvxUG7FIWp8wFjzaUTVWDmgPzS5g1LPm89ad5hx1qqT70vmUcw02WPMpfMqsZKcJFouFywJDRvNQeaKPMFLmHcm3tml3HFQeaPWjziTxTuK7LAal3CoBIaUvRdBdkpPFN3AUzfRvFFwuP3Gk+amhxTtwouJsQ5pdx6Um/2oPNFwHbz60wvnpSHPpRTuMUMaC9NINGMUXCwu404NxTMZpGUii4rE/mijzBioAPelyKfMirk3mUeaKh70uaV0FyTzKQyYqLNGaVxXJfNFIJhUYxRjmi4XJTMtN80dqYVFGAKLgx+/NAdaZxRxRcRJuU0u4VFQDSuBKWBpARUeaAaLoBnlgUGP3qYKDxRsGcGtrEEQUUeXzUm1ckUoC9KXKFyPy8UCPvTsDPSngrT5QuM20YODUmR6U3cvpRyhcaFalwRS5H4U4ODRyjuR4PpSBXwalyOtG4Cnyhci2MRyKQxvU28ml3HFS4hcg8s+lLsOKlLUpcUuUREAwoyfSnlsnpSbhRYdw2mgrSBsGlDGnYLibc8c0bOMU7dmjdQwuMKkUYPpUm7NGR6UrBciIbtQAxHNTDb6UHb6U7ILkX4GgZ96kO30oJ9BRYLjNtG3mpAeaBjNKwXImQ9qQA1OWHY0zApWC5yHjP8A1tn9H/pW/o4P9j2Z/wCmS/yrB8a/62z/AN1/6V0Gj4OjWf8A1xX+VfWZh/yIML6y/ORyw/jyLeTS5p22l2ivlDquRkkU0lip45xxUuBSEjFOO4XNrxLeQz/D0C3bIk8mHHQgggEH3GK7Kwj8mzgixjbGo/JQK8+ltTc2Gi6eBzeamZGH+wi8mvSEA3H0xX0FFuUU2c09FYkqFmyT6U+Q4FYPibXoPDHhy/1m5UMltGSELH53PCrkA4yxAzjjOTXRGLk1Fbsg4mbVtLk8Sajo1jci4urIPJLFAjvsVcZGQMEjIBAJOcjrXhPjTU4ta8VXd3b5+z5WNC0YQnaAMnucnOCecYHGMDufhEy3Os65r+pXMq3c37tZCnyStIxeTOBgEEJ7Dd05FWfF/gAat4ine1mEUjxF/MKgRs4OMHH5E9RXbjJxoT9m3ta/qeLgMkoYWvLEUm7yvvayu76aHkKoP8KVhjjvVnULG60m7ltbuFop4zhkf9CPUHse9UkbJzk1nGSauj1XHXUnRVAyfSq1xdAEhPzp1yZ0t0l8p1hkJCSEEKxHUA98Z5rPzUSqdhqHcVmLHJNIMd6KMVirvUssQgZLA9qYYWBpYjiQDNWY5vmKsBx3r0bKWHi30b/QzbaZXileI47ehr3P4aTtP4PRT0jnkVfocH/2avEpniBI25r2z4TypP4NZe8d3Ip/EKRXjZmv3Njow7vI60igYqy0adzUZROxr52x1kJUGkIqbavrQQmKLBcgx6GmlR3qfYvqKUxA8ZosFyuUBFN2Cp/KHrR5Q9aVguQ7Bik2CpwijjNGxc0WFcgKccUmzIqcqBQEFFmK5WEZz1o8o5qztANG0UWYXIdhx1p23PepCi+tG0YpWYXIdnPWnYI4p4UHvTiooSC5la0MaTcMT0Rv1Uj+tYng0Zlu/ov9a6HXEB0O89o81geCxmW8/wB1f619fl6/4x/FLzj+cTln/GidQFoI9Kn2ijC18hY6rlYo3Y08KcVNtWgqoosFyI0gzUpVcUbVosFyMigcVLhaXatFguRdRSFc9qm2rShFosLmRX2CgIDU5jGaAi0WDmRDsx2oxU+xaTaM07BchKj0o2j0qXYKaVFKw7jMD0owPSn7RRtFFguRlRTfLGc1NtFG0UWC6ItvvRsWpdoxRsFFguQ7RQFHrUhjWkEaiiwXE2LikCgd6ftApuwdaLBcAqmkKLmnhV9aUqtFkFyIg0oAFPKikIHrSskFw4o+X0o+X1o2rnrRYOYacU0kZ708qtJ5amnYOYaSDSgLin+WtGwUWC4ny00haXYpPNL5QxRYLkeM9KTHapVjx0oMYNKwXIttOC07YD3pSnvRYXMMK4pNpp+z3pNlFg5hu0HvShcEUBMU/bxSsO4dqTJHWnAe9BAosFxM8UzcQeak4NHlg0WC4zec9OKPM5p5QU3yxRYLiiQZpfNxSCMUeUOtOwJimTPakVwe9O8sYpPKX0ppDuKHFJ5gzShAKXyxRYLibvek3U7y6TyxmiwXEBoIOaXaM0uKLBcYc8Ckwfen496AppCuM2GnYp200m2nYLiYx3pBnNPK0oTiiwXGHNJj3p5Wl2mhILkWKMHFS7c0bKLBciUHvRgZ6VJto20WC5Fs56ml2npmpdhpNuKLBcQBs9adg+tWcLxjFJtXngVuFiuAaCDU5QA9KdsXjgc0XCxV2v6UYcdqt+XwaAmeuKLi5SvhqTaT2qxs6Cl2tj7uaB2K+3jmm9CcCrIDY+5mlCnulAWKmSe1KQT2q1tUj7tKEAPSgXKyoFPFHNW/LAPSkKKf4aA5WVfwpgz3FXAidxQY1z92gdinhhTsHvVkogHNJ8hGDmkKxV6UHIqfauacQvpxSE0VgTzS1MNnPrSBAaAsRrSipPLxUgQetNDSIcg9qSrBiXruo2oO4oaHYrZxTht75q1tX2o2JjoKVgsVgeTimkk1aCx+1HlxjuKdgsyp0HNBzirgijPUil8lOeRQkFjhPGZzJZ/7r/0roNHz/Y9mR/zyX+VYvjtQs1jjH3X/AKV02iRx/wBh2BJGTCv8q+qzBf8ACDhfWX5yOWH8eQu4jtS7jV4xR+1NMUY9K+VsdVinzjpSbXLBVGSTwB3PYVeEaE8VasbZrnV/7PtiTcRgNczL0tVPYesh7f3eta0qDqS0Jei1NvRNMVr+O6blLOE2sHoXJzI4/H5R/utXRJ1amwwx28CQxKFjRQqqOwFIGwWx6fWvdirKyOZu42Z+ccc9q8N+NHiCC/1Wy0FZC9rpqPf3qmMyRl9uIUYoQ6Bi2wnK481Tzxj2HVb6PTtMu7+d/LggiaSRjn5VAyTxyeAelfM1+L3UPDTarNIr6v4r1Hy4ohzmBGIKAsMoBJ5YHzdFUdjXp5dTTqe0fTT5v/JXZnN6WPQPBGlLpPw3ti0Hlz3qNcznfksrf6s9eMpt4/rmugsY3NrMJc+ZsD/iMA1NDbwxQ2+n267LW1jVFGSeAMKuTyQAKvxQjEmB/CR/KvFxtf2tVvuzenCyuch4g8NWPiS08m9ixKoIinX78f09R6g8VwukfCq5XVW/taaP7BG3Ahc7p/Qf7A9e/pXsnkIO1KIk44rzYYirTi4xehr7NPVnmXxR0iOTwXBLbwJEunSrsSMYCxt8pAA6DO2vEa+tNR0m31TTbmxmH7m5iMTe2RjP4da+VL+ym0/ULizuF2zQSNG4/wBpTg13YCblBxe6MqkbMrVMqMB2PsaZGuW/DirKQ5OXP4V6cI3MWxsar2jII79RTmQgFghOe45qZUlmO2FdsY4LHvTVs2lUyq5XnHSu6MW8M0ujX5MzvrqRIEuAFPyyjpno3/169a+EUrJpeq2x4KTxvjv8ykf+y15R5LA4chx78H8DXffDHWE0zXzaXOHt78LCJDw0bg5XPsc4zXmY2lKdBpLU1pSSkeuEkjvSc1pi2TtS/ZkNfNcrO2xk4akxzyTWsbZM0w2yH0zS5R2M3BHejJFaIt0xjApfssZo5QsZuW9KXNaRtkGB6037KnpRyhYzsUbcVoG2jyRmj7KmcZpcrCxnkUYFXzbL3FAtU4o5WKxQKj1o46E1fNqgHSj7Gh7U+ULGefrTdxrS+yJjpSG1AGcUNBYzQSO9OycdavfZVPQUfYzwMUrMLGJrGTo14P8Api1c/wCDCRNd4/ur/Wus1u1KaJenjiBv5VzPgWIyzXo4wFTP619blq/4QcUvNfmjlqL99E6fLYoy1Xfsx9qPs9fJcrOqxTzik3HOMVeNtSC3wecZosFmVAcU3NXjbA9KYbbmizCzKhz1pQc1dFtgetIbYDtRZhYpYOaMsKt/ZwTR5IGc0mg5SqGbPegkirIiUZ4pGhB6cUrBylXeaduzVjyFo8lRRYOUrbjRvxVryl9KBAlFhcpULZFAJzVzyY6QxLwcU7C5SsTx3ppJAq15aelBiTHSlYLFTeRS5brirAiUnpT/AC1A6c07BYqEv2o3N6VZMY9KQRg9qVgsV8sc8Uh3+lW/LFJ5ftRYLMqZI7UoLelWxECelLsUUWCzKh3elJg9xVzy1x1o2IOtDQmmVMe1HTtVvy0prRx9qLDsysFzS7SOlTYSnbU9KLBYgwaTBxU21PSnAJj1osFisc56Uc1Y2x56U7bGKEgsVcHPSnYqztj60bU7VXKwsyqRikwat+UDS+UuO1HKwsU9ppStWzElAiSjlYWZT2GgqaveUvpTTAvShRCzKRB60m0981eFoD3o+yj1o5GFmUtuRxTgDjFW/svHBpPs/qaOQLMqEMOlJh/Srv2b3pDBijkYWZSO+gF/SrogpTF6ClyMLMp/P6Um9x1FXNnbFNaNR1FPkYWZW3sQcCm739KtbB6UeUPQ0cjCzK+9sU3ec1a8tfSmmIHtU8jAg3U0Mc81Y8oDqKPKHcUcjCzICTQGYd6nEQ9KDEPSjkYWZWLsDxS72z0qfyaUw+1HK0KzK5dvejzGNT+T7UeSfSlZhZkG5qC7ds1L5TZ6UgjPpRZhZkQkel8x896l8s+lIIj6UWYWYzzGzQZCKeIW9KPKb0oswsyPzmA60GRqkMRPajyvahpjF858cilEzgZIqFvN9KVfNAI207sZIbgsBxSiX9Ki+f8Au0o34+7Rdhcn+0ZBpvnHk5qJd3pS9ulF2x3Y8TnJwad9rOMVDjqMCgdjto5mF2TrcH3oN2QahHyn7tDKD2o5mF2Ti5yM0huuOtQBQO1Ls4x60+dhdkpuxnqaPtOTUWwDtzSYGM45pczC5MbhcA4pftBAJ5qHBHaj8ARQpMLsl84tzzR5w4zURQ479aTymxT5hXJjOvpR561GEP5UbBnqaV2wJPOX0pomJ7Ubf9rNJ5eO9O4C+cO4o8/0FNZDgYNL5ZxwRTTAUzE0eYPSk2EDqKNuOe9U2MkEox0oEw9KjKnrimgNilcCUyKe1KJV4qHnrRgn+Gi4icuMdaBJj1qBSQDxmnbnIPy4ouO5ynjYgy2WM/df+ldJozL/AGJZZP8AyxX+Vcz4zH7yzz/df+lb+jg/2PZ/9cV/lX1eYP8A4QML6y/ORyw/jyNgSpjuKbv981XwRS7vUV8qmdVy9FdrY2V/qRUH7Fbl0H+2eE/Wuj8D6Z/Z/hu3kck3N3/pEznqzNyM/hXG6iMeCNY/25YF/DdmvTdOVY9MtUHRYUA/BRXs4WNoIwm7lokYqvJKsXWnTSeUCQhb2FYt7qjhtotXxnlj2+mK6zI4L4sXlzrMuj+DNOkXzdWmMl1tKs6Qx4bO04OOCwwRnyiBnNYNwYNS+K1hpVoiHTPDWmsywzLuAPlgApnJJG6HqeChPXq/wdPeeI/EWr+Mp2miiuM2lgjEriFSCTg5HVV+6cbvM4rM8DSSavqniHxE0jPHeXRjjaXmUIPmCn0GGjGAcfL7CvSnL2FKa/kX/k0v8lp8iErtHdQF41Z3P7xjub29vwrQMjRWkjFuWIVf5sf6Vk7gAeT0NWbrd5xBdih+ZATwobnA/OvkfatqUjttayQ4zP8A3qXz3AHPNVcDHWlGPU1zcxWpaE79M14r8XNHNp4ji1NF/d36fPx/y0Xg/mNpr2HuOa5j4haZ/afhC62pultSLhPXC8Nj/gJaunCVeSqr9TOoro8IigywyODWhCgjAAHFRxIoGB2/rW9oGgal4gvBaaXZyXEvBbYMKgP8TMeFHua+mi0tWcjV9jPVGkYIqszE4AAySa0dC8Ma1qVzDYW1jJ58zEqJPkUAdSWPToffHPSvToPhJc6Bo02s3t8st9B84trdCyBTw2W74BJ6YAB47ivpRxrNgPMSMtcxKrP0DFwBnkZ5I4zXs4KhGvhpyUrf8DX9TyMbjpYbERpKN07fi7aGVqvwmOl6aLrVteggQD949vYyzxxn/aZeg9yBVLQPh7fz6hZ6ho2pabq1nBdRvI9rNtdFDAksjgMK+kEgTyAIlGwAqQV2gjvx3Bri7/wNp2laumv6LD9guoSxlihyI5lK4wV6DB5I6GvnqlaXK7s9pJXQshlikKurKe4cYNRmUjuatveZgSUxiW1c4aInmJx1CnqAeoqhdQNBPtDboyAyN0yp5Br52pG2sTsU+48zD1NHnD1qsQeworG7HdlgSnPBNOLt2NVR+Ip2GB6k+9F2FywHPrQJsH3qvhjyBTckdqLsdy0ZieeKb54yMmocA44OKaQmehouxXLBmyfvUvm9cNVbCe9KMHgUrsLloSk9XzTDcMGIzmoQMjGDSjaM5BNPmYXJxcc/eoNwDxvqAMg/ho+QnpRzDuTCUA8tTjIcZzUHyDmgMnIo5kFyrrkobQ70E/8ALF/5VzPgVist8c4G1Mn/AL6rotZKjRL4Bf8Ali38q5/wKoK6gxAwPLH57q+vyvXIsV6r9Djqv99E7HziehFN86Smkx+lCsnpXyPMjrux3nvntTvtB9KZlDkcU0FOmKXMgux/2hqeJ/rUTbcAim5WnzILlgz4pPP4qIFDTwU9KLjHecKQTDJyaaSnpTcrnBWi6C5L5q+tG4EjBpm1MZC5pC6jgpRcLkw6dqTvzimK3oKRgpPNAEhB7UmWpocAUeavQmkArU4cjrUZdaQOvGRQLqO29Oaftam+YnHFBlUgUXHZIcAVoJ4PFM3rjrS+YtABuI5IoLDg4pvmKTyKdlGNFxWF8z2pplz2FBKAdRUZZT1qWwZIH70uQar7hS7l75ouK7Jt3bNKSuMnmoCRgYNCsnfrRcCYFc9KX5DULMO1J5g6Ci4FjC9Nopvy5Py1H5xA9aTzSTyKaaAl+TPSkCr6UzzBxineb0FO4LzHbUPajahFM3ZOaCV9aaaGP2p60ojX1qHK+9ODYxyadxEpRcj5qAidAxqLeMkU7coGc800xpEmwDvQEGfvHFR7iejZGKRZCOKd0BKUXsTQFwPvVH5hpd/t+tFxkh4/ipOcdajZ+lAlGKd0F0Sgn1qNmPY04NlTTCD6U7oGPDN60Hdkc9ahJFLnj71LQWhNyD96mBSp+/1qPcPWlyuOTRdATYP96kZWP8QqLzB60eZznNGgyUI2OtADdzULSjrmk83Hfii6FoTkNng8UhU/3qgM4HGaXz89xRdA7FjB7kUEDH3qreccYzSebxwaV4hdFnoOtKoBqqJmzxSi4YUXQ7otFV9aXA9aq/aW7ClFwwPIovELon2jPWn7RVb7QfSg3B7CmrBdE+BS/LjtVUzMB93rQLjI+7ildBdFgopPWkCD1qv5xP8ADThMTxtoug0JwoGfm5o2+9QGQjkYzTPOOelDsIs424ORTWI55qEyk9RSCf2xSuhpoiZyQORn15/TFAZ8YBzgdMHioRI+SeMmgB933unPbk1kmSSiSQ5yvFAdhwWyPfv+VR7HJ4kHTn2z6GjDkpyMDjOecD0ouBKxJwQw596X58cAZzk1ESeg6dvajcxLc98HBz79aYDwXIBKGnfeYkg59D1qLI4GGznpSk8dz2x/9elYCVlcKMc/jTCSvBH+TSB8rnr9Of50hKgjnv0FFrD0JQDnLfj36imk7myMZ4FM3gk9AOT1wc/T3pGkSM4288dwCc0wJHZiTnoDijeFHOQOfb86jyOuDyOfWnK6YHJIAzj0oSQKxIZUJJ298d6XcAudpJ9O/wCFR+YhYAHB9On50ccN196dkMcZVUgbu/bmlZz8wXg+xqIhCSU5z2Jz+NOwq7ucE96LIVkG5z2wN3OaXc4ycLjPWkBTj5zyeOe/4UpjG4HnIHPNFkFkB3nJ2ZA5x7Un7zAO3OegyacE75brnt1/GkCnJ+Zzzn2pWQ7CEuCcj35P+NG5gASB608sDkMxz0PFM+U8Fsn6UWE1YA5yAV5Jz1pQWxnqM/TmkAG0nIIz17UoBOSCue2PT8adhC7yMEUbiCTtPSlQ5XG5cZ70AfLgFQCM896QDWfaCNufegnA6HkZp3IOcj2A5zRsYZIAIP8AKiwDQwOQoY0hmUA8nNOGQzcZGPbik3JuA28dOgzmlZgcl4xYNLZ+u1u/0rf0iQf2RaDkkRJ29qwfGYUTWe1SPlfP5it/SEQ6NZktz5Q4I6cV9ZmH/IgwvrL85HND+PIt+aADkEfX3pDJj5vf9KcIoWB+YdB1FNCAqBnPbp/hXyaudNiS5HneDdcCk/K8EvXPG7BxXpemkS6ZauDw0KEfiorz7T4BPBqdgDk3Nk4X3ZeQK6/wbeC78KWD55WPYfqpxXuYN3powqI1J9wHBzxXmnxV1uW00GPRLBN+q65ILOBMgfKcB+SNvO5U5I+/kHivTpehryLQHXxl8V9T8SRxI+maNB9gs5wT+8kycspBKuMNJ3+66HGTmvWwsUpOpLaOvz6L7zCT6Gl4hitPBXwuubaJ2ElpYC3SW3QRsZWAQSAZ4JdtxOc9Tya57wjaW+l+EdLhjIZpYRcSyKm0ln+bn1IBC5/2R06UfGKQXo8PaCw2C+vgftPUxgYT7vf/AFueo+778bG1JC5LEn2OevrXJmVVwwiXWbb+7T/M0oxvL0HhkPrxUhnWUruxgAKD6gVXbyyDlCBu9efpml2Lkja2QeMf4180nbRHVZExZcjnHH4fjSDbz0phROcpgDJz70BAOO3GSO351Nh2JQyHoRTnELqUcAqwKsD0IPBquEAzhsZ6cYNO2kBgMketUrp3Cx5Vpnwz1fUfEX2MbLay84oJ2YFigJwwUcnj1xXv2g+Gz4auLLT9JiSPSEgc3DHBkmnJAUsevTd7dqxNIdF1S1PQ7gOntjmvQIzxXt4avKtH3uhzzSjsEyll+h5xXzZHoA8ZeL/HeipGW1CO4uL2xmyuQ0czgw/N0VzN13AAqCc19L5FeV6DBIv7RPiWdonELacqq5U7WYLakgHuQGXI9x617OCqumptb2v9zRzyV7E/wt8cy6zaHR9WSSHV9PUQTpIx3uFwvmOrfNuz8rcnnrjcBXo7pHOJEHzcYYY7EV498S9Fn8F+J7Tx/ocKrbtKseqWkSkCXcclm4KhX4UkgYbawyxyPV9E1W213RLPVNPcm1uYhJGMg7M9VOCQGByCM8EEVGKpxaVan8MvwfVf5FRfRnLXGnXNjFewNEzRja0bAEhsNgHjvg81BKWGnW7zx7ZUJjVZBjch53AdeCcV2t/ZfbYHjLmNiPldDhgR/T2rgL22uLK6MF0h3HJDHkN2yD6V4GJpez1Wx0QfNoxjyIT8i469CSD+dNGO/Wo8xgrgewHTNBxuJ3LgZHT+deYzaxJk91P4dKeGIyNj47VFuc8IwHP40qlucsoOPfvziiyCxJk84JFNLMT3pNxO758E9eP0oLcDDnPGcD+dKwWJFkJ6A0rEcZzk1CWZRnzOOgGP60rNIf4yAe57HPOKaHYkyAD19/akLDnnFMcuzEDGPb/CkVzgZibp19qLCsP37ScNTt5HG7k03zFXPysaaZcAtjjp3/XFJodh3mkAnOADil8wnjP5ioi/yn5CScfU0jbhkbefrwKLCsSBsZBbGD6UobjGcfWoASWJwwz14yPwpMLnhT1/zzRYViLWSn9i3mGGfJbj8KyPAODBq4OPuREexBb/AOvWjq5X+xrxtuCYSO/Fc/4PZzJdxK+FIRyM9SMgfzNfY5Q+XI8U33X6HLVX76KOzKgAksMfWlCrtzuqqd3JKjOOvSgsT91eeMYzXxzR12LflgnhuophjP8Aeqvk8fKRk+9O8vr1B+vrRYLFhUccbqRs1XKtkcHb7HnihhgZy2c9M+neiwicA0vODzxUJZk5JP17U0sQcbsf40WYWLA6UpA/vdqq72I4YD6+30pQ8hwd4wOOKALPUDntTdpPVqql3ySWHA5PpTvOkC/LjHJ+mKNQLGGHelKvxkmoBO+WJPOc4x2pRO2PbGRxTAm5x3pAH/u1H54AYAZ5HakW4GAWGOSKBE2W/u9KblieVpvnLgntnqKUzcKQCBQwDJLkYpR9DQZRyQRz/SkM4IGSRn9aQAWGecilDLk80eaMc/8A16TzM5BxmlqPUTcM8mgsB704yYUHjH86TeARjHPY/wA6QhA4z1pxZc/exTN4zgkZpSy9sZ+tF2O4u5SBSjnuKZnPQDH4U7PPABpXC4uMd6QYHWjdnsM0bug2D8qLhcXdx1ApFIz94U1s5x5Y+tBwv8APpTuFxxYA9aUSJ0zUZbG75V9vajIGflH8qVwuSb1pPMX1pm4DqoP40hIzkKMfWlcLkvmA96QuPWowo/u579aYRnIEZz9e9HMFyxuHA70E7agBAz8hz356UmFY/dbpknNNMLk/mDOO9LvxnOKrkKDuw5IoBQgEg8+9HNYLk4kIAxil8wg1CGQAjoB707cvHzd6akFyTcSetLk+tNzjknmkZwD1o5gJWJpgzzxTPMXoSacG9+MUc1wJOTj5qTL4wDUZZR/FQGXjLYzTuFx3zZ5pOT3pNw67qUMAPvUrhcNxpvzEnijn+8PrS5z0bOPei4CfPgClJftS5P8AeAoyRwWouFyPc5I+Wn5I7UENk4x9acQSOuaLgJwewpADnpSYI/hpwz2FFwuAAHaj5aaFbPIP0owecUXEOwB2pTjA5pnTrmlA4PNO4x2M0Ej05puMdSaOM9adxDjkihQ1NLAHrTg/GCOaLgKRmk5xTN45yKUYIzRe4x27jHalwKYSKMjAAJp3AkGF5oyPTmodxz3xS7j260bgSgc9qcFGM4GKgGce9GTjFAEbRRMVO8A9uOBTyiLyGX26Yp5GD6jrzSBUJHC47/J3p2swFK56EYxwo6A03auW4Q+/PWngIVIPOcAcHFChRnAz7YNOyGMEKjgYAx069KFhH8TD8uv0qUuq7Rsbn2o85cFtrZPPTPFINBixJtJY4+lM2LuHy89SCf1NSb4zwEf1NKxjZxgMMHIJ7565oYaEROCwdOD6/wD1qbhfLHyZI6ZJH86sMFJILNn/ABoJJJ4A6980rAVsJnBTPHQf/XoMKZ4H68jvU+OAMtkfnTm7Haec/nSsIq+ShLNs5bg49qeVTrtPH+3U4Unpu6GlJCkDC+hyPyzQBW8tQvLnBNK8aMq5OR6A4wcVPnG4AHGeCR/KhkJGQD3ouwK6xKJCM9R29vWjylzgOcA5Gfz4qwFz2JHuKjO3LfL0PTmmBC0bE4D8Y6Z9aUI2MlvTGOpNWhtAHHUD8qHCsOW7jHBoGUmjYY4bPQjHT3wOfxpXj4JG44HA/nVvy17t/vHnpR5SkcuABxjocn6U0gKwx8pwQAOc9/r6U35id2COuDkdKtiBMA7lJOKa1uncJjvk/wAqLAQYI4ySMYJ7UA8ZDZJH04qY23JxtHXgU7ySSowM46g9PrQkFiAMgIyBz1yeePSntIDkBRj608RfMc9Pqab5IJIB7c9wKbVgEBHXI/D3oV1AAPPueMflTjEOhzuzjt2prREjnjr6c0gBXBB6Z5HQjFJuGMELjIzxSNG/JK8sOD/WgROOAmE69c9aLAcp4xKmWzx/dbPH0rf0dVOkWmQceUuePasDxhjzLTryH69e1bmlrjR7TOWHlKcc4zjpX1WYf8iDC+svzkcsP48jQYLx904pCqFh8uc44/wzUbLtyOo9O3vSeo+bB9X59K+UOks2122nXcF2sYIjkBdQeiHhz78Guh8I3KWGpapohYbY5ftNtz96N+eK5U4UDknPXj/HpWbdXV7Yz2d7aHF7ZZW3zyJ4DkmI+rJlsDuvT7td2ErcvusmUbnc/E3xOnhvwPqFwrulzcKbW2KMVYSOCNwYA4KgM3b7uMgkVD4M0SLwv4O0/TvK8q4EQkugdpYzMMvkrwcH5QeeFAycV5xeeI7Pxl8QNOvZJ9un6LCJRG+0ZuWOflIO4gYQ5PGYyMc89O3jCK9ne3tZFYxrulkzhYx7n1PYV9BVqRpUo0+r1fz2X3a/M5FBtnOalcx6/wDGC4njRmj0izEAlibcrSHOQ3HB/eOMZzlPqK6TAOAd2SemM1xXw9SS5tdT1ic+XNf3TMw6KQOdy55xudh1PT2NdorqAR5iE4x1x0/pXj5zUvifZraCS/z/ABudFFWjfuPaPBILnpnpmkZcchz3OO1Rq4IxuHXPWnRkFshjjB+ufwryTYdyFAJ6gYz1pQwDffB5x9cVGW2/j0IzkfhR14569cH/AAoHclJ/2wcngfSkL5XAz+PTI+tQ5bIwMfL6Ht9KdzgFfTJJJx+FCYrlm2n8q7jfHAcHPoPWvQ7G6SeBWBHIrz3S4ku70QTxhoijZB/QgjkGtOx+36HfSRWyS6haNny0QjcrjjaSeBjvXp4J8sbmU1c7mRsROV64NZoODkVRh1DXnG6fTbeAf7d0AB9cA15z4l8XXOnfFbRYbvXI7TSUs3lnW1fdGGKyj58jDH5UxkYHBGDmuLNMiq5rVjKnPl5U912108yYy9mtT2O9trbUNOubK8QSWtxE0M67iAUYYYZGCOCeRXi3gvWf+FY+Pb3wfqFykuh38pmsJowJmDsQqFigByQu1ht+8oIwpJN/V/iHbx2BvbDTZNQh2lkutRuUVGA6ssZIBA9hXn/jbxfZeKdKSG5uzNNb5lgNvZIkcRI5XcXyQeM4HYHBxX1OErJXpVPhl+D7mMo9UfRcniGzyQsV83ullIR/6DWRrN/bXti4CSCRfmQTQvGc9+oFfNn/AAl2u3Wnsza3qst1GD8qncuwDO5m6/U81JpXjvW7BY7n+2LiVlYmW2uBuR17YI7np7Vz4ijKDlTmVG26PaBKmDwBgHJx1z7UjPGeexPUZwKrQ3X2iCO4VQqSIrhcDIyuQP1pxdsDiMAHrj0r5mWjsdd2TF42Yk4Hv/WnB0O4B8kjrVcShtx/d55wMcU3zC3Xye/41NxXJt6EDa44x0OeKd5nOenoRzUAbswTPsaUH/dx35PWpuwuTK/+1gZ+n50POM8gnqc/pTJH27vkXAHHOfpQGU46AYxx69Kq4XHi5Qk4HbHFH2hNxXHfjqT+nSm+pH485/EU3K9SR1wPxoux3ZL5ysOmcn+VKZYQDkfePPPrVfgnGwZAPXvSYVRnaPvcnP8AhRcLss+cNzdunGQBSBwMjPp3GP1qu2wR525H156Uwt+7AKnHPBxmi4XLu6Jhndkeox+VABbqpAxxx/SqTEPg+XkfhVzS5NMjuT/aizGHbwy5IU+4HO2rh7zsDlZFPVoyujXnzHBhbAz7Guf8HKWmuwuc7V/rXo+uabp3/CLaleaeIXQWsn7xDuB4+v8A+quJ+HNhFfTaiJY3ZERMskuwrnd+f/1q+0wGHayPExT3a/NHHOd60WbYRhGMMWTHtTX+U/exmtp/DUQJFvfyR5PSWPPT3FU5PDuqxliiicc48qQHGfY4NfJSw1SO6OtTTKBZPvFv/r0uVZSARkc//WxUM8E9uwFxDJCwxxIrL/OoxIOB97rx3/WueSa3K5kW9ynaR3XnApMIzZxyOpqoHQhuT8w9PalzwCGz6Y/PipuFyyCi5OQMkkEj09qXevlg5wT39O/r0zVUyyAAA47c8frTWkcDhgPxP+c0XC5c4B6nHqcE4z2pXkTp1wT6D/IqqJHUbSo6YweTwM0hkfJO0Y6dce1DYXLRkTgHg7eeh4PWolZd46jqRz+P6VCxbavyqT2x0+opysWGFUdOhx/kVN2K5YYgY+Yj14zSKxfOGAPt/SoPNYt0XGMgEjNMDyBCTGOeM9zTuF0WF2ngHHHQ5FPL8AHB5wM1U3g5AQenXtTg6BsFOpxnJ6D1ppjLOST90DGc/OKfvHZBwCSQfzqpuTkkNznPOTzTPPQHIDZx1xn/AD7UXQFssqgt5ZwMjOc//qo81G+9Ec7sdaqbkVsDcMknGMZ9aV5cjkdQccc+lDYFpQuAyxjJPcnnHb60qbSpbYmSflOc4qoJc4wT7gH0/GmeYRIvzN8w5HPP8qXMLQuuGUjCggc+opoLMwBXBxkdKr+ZuAARvXIpfOYkqWOcDJPYU7oRY+Ypkgr+PNMLvjow4I6dag3k8knB5GRTgWBB657np61N0wJlL5JLlTj25/lRhhyZCcn0qJwdrKWyCo24FN3BCvHTp/8ArpXQicHOcv37035jkB8Dvn/61RhkyWJBwM4A9eKcz8jJxnOMelO4DwMEhWAHXFPX7rEycg8fSoBKeucHpwf1prTgsuWbAyBk5wP6UroCx8xJ+bj1HPWl3v8A7RJPpj881AshOd0vQc5446U5ZM7sS8A8U0kx2JNz4JyTj6YpnnEemM8ZpUkG8YbZ7560pkY7tzrg9jn+lLlQrCmYr1UflxTfNUnBUZHXBpxkH98YPPORTAwLEF8dQM0nEBxMbbRg+v0NIQuO4z6GkLY3AnnPUeg6ULJnPPUdcCjlCwFVyT5jD6HNN8sKP9cx59B/Sn+YhPB78ngfhSeaMjp97kYwfoaOUViJo3ONsp/LpSqr5LeefYYH86eJFbICA9cdeaUBWY5RsfjwCKlQsMaBJ0MwJ/3OfWkZGySJV5PB2dP8aXaecqeeMfT+tJlQcFOwGc/yp8qAcu8gFipPPOMD+dGXBwCuMdcHNCqhPPUD175pwjjaQDcwHc+5pcg7DQWDYJHr3/KnKGIIzmkZBkqpPfnr/wDqpGGFOXyc4zznFPlaE0SBRnBPX2pwUEnLfp61XKMcjcxPHY/ypRuwC2fm5DEcfWlZhYnIXuw96Ty1Ppk571GVIyTzjp2HXrSYOWHb1JwMH60NMLE3lJx6D3pdikAZ6VAuM4PGMDnGDQ0IC8Ah+p5z19qEmFifZ07570hjK4IbNQ+VuOTnpyenSl8pRkbyCATnOTTswsTYbnqOKQB1wMc1E8W2PO84Hv8A1pVhGPlduewIoswsTqXz3/L/AApS7EH/AAqvtP8ACzHHGKVYyGyZj7cGjULEwdgo4/CkEnOAf8KaInXnzBjHTB5/OmeVKclXUHrntinZisT+Z16daXJGePpiq4ifPMg68HHWlKyYPznIAPTj8KLMLE2W54J5p4OB1Oaqnzgfmbvj2p6B2bBPU460K47E+78aTeOOOKiK4yPm684P+FMCkZHzeueOfpT1CxZ3juoxQSmRx+YqHaeCMYx60GNwd3PQd/Wi4tSXcCc7B7cYpSQBkLUJBOfy+lDI4BHPt/jTu+gyYOuOU5pOGPC8VF5bjjkeuO2fWkXcuc4JHbPrSuwJ1V1VshSTTPKcYOetS7D7dfWlaL5QdwB+tbDsReW6jgj6U0xnBAPH16ZqYx/MASKGjUAfX1pXCxEIuxP45pPJY9G/Wpdq4J3Dr60gXAHXnvntTAZ5UgPX9aTyXH3WI9cmpQoJABPtzSsAM7gfbmlYLEHkSZ+9k9+aUxSn+L8jUw5we1L8o/ChILELRTAcN9OaQQzYznnFTAp2zTiUAx1OKqwWK+ycH7/BFJsnMf38Aeoqbcp53n8aeoyCu44qbDsVTHOR98/1p6pOCRux71MQowuT1pxbBIzQkgtYrhJiBkjA4xQEnB/z0q18oP3vf60hOO/JPPtVWQWIAbjGCzegFNDThzkfhj9KtqhLdTShMN93r3PNFhpMp/vi3TP4U4iYfwg49Kshefu8UbCFJGQPTrTSsHKyoBIekY96UeYCu1PpVny2x059fakEb56d+DRYOVkW+cDHQj1FLmXBJyeO3FS7XAOQOvFIVZVB59+9FgsyEyy4HXn8aULLk8sPTIzU2Dt479KU7sZx/kUWCxBl9wKkjjBpp3YwT+YqwQ2BxSlSyjIxt60cqFYgwflye/XHNIpfn5yT345qxsYL2x6ikYNgEAUmh2Zx/jK3lZLadVJiTcrN6E4xWVb+Jr62t44I1g2RqFGVOePxr0NiSoBjwtR7RxmBefavpsHntCng4YTE4dVFG9tbb69n3OadCTm5Rla5wn/CW6jz8sH/AHwf8ab/AMJTf/8APO3/AO+D/jXe4TI/crn6U47M5EAxj+5Wv9tZX/0BL7/+AL2FT+c4BvFN+38EH4If8a5/xB4o1G4cWwdIoyuWCJ949jk56eor1sLGQD5K8+1YXiLwlp/iB0nkMsFzHGY1eMjB7jcp64JPTHXr0x25fneSrERdbCKK7/Fb5WJlRq20lc8x0R43e5M8CzySMHeSUuSxOc5Of/r8mtXCKoSONY0GTtXOMnqea9C0Hw3pmgRTJbCWQzEF3mYMeOg4AGOT27/StG5tLG7XbPaRyDaQMoMjPXB7fhXRV4oy2njHVo4fT+bRPbtb5b7HVgObD1FObuux5xZancWCusJBVzkhs8fTmrR8Q3pGMRAewP8AjXoEdvaQx7IreOME5ISMAZ/CnbID/APyrz8RxDl1eq6lTBqTfVvX8gxXPWqupGVk+h57/wAJFfZBxFx04P8AjSjxJfqTjy+fY/416EVgH/LMflRmEEgQj8qx/tvK/wDoCX3/APAOf2NT+c8+PiW/P/PP8j/jQ3iW/br5X5H/ABr0P/R+vkgcdhSlIsYEa/l/Oj+28r/6Al9//AD2FT+c86/4SO/xjcn5H/Gg+JNQOeU59j/jXoyrb8fu1+mKUxwYI8r8hT/trK/+gJff/wAAfsKn855r/wAJDqSuHinaJgeDGSMfrTYfEOsW8d8sGpTxG9n8+VlIyG77cj5QfQV6Tstw3CDH0zTgsDZAQflVRz7LY/Dg19//AABfV6j+2eSSz3ly5a61C8nB/hkmOP0xWBewiPW7PexWN0MYcAZzyPTk/MOT/SveSkA/5ZKT9K57UrS1v76Gee3RntX3QErjYdynP1yi/qOhIpT4py+jq8La/Zp/ojow2V1sS2oT27nlZ8NWRVVMk5C5xlh/hSf8IvYYA3T8f7Q/wr3C0McsCl41zjBO2pzFbgcoBn2rSPEuAlFSWEWvn/wDCpgqkJODnqjwV9Cmt5VFhcSrHIpjmBlKkqeoyOoPTGP/AK1m38PWFtMsm15NpyFkbIz+GK9Y8S6Q+oWCLZJumjkDbS2MjGD7Z6dfesPQPD97Hq0M93AY4IyxbLckjIxgHPX8CPXPOFbPqdWqqiox5F9l6v7/AMux7+DyzASy6dSrUtV1trbW2mnW5lDXr0d4/wDvmnf8JDf4A3R8f7NekiCDH3AP+AUeRbAcovHonen/AG1lf/QEvv8A+AfP/V6n855r/b96Onlj/gP/ANel/wCEgvfSIfRT/jXpIgtyCdifTZQbaEqPkXrn7lL+2sr/AOgFff8A/aj+r1f5zzY+Ib1s5ER/4Cf8aU+Ib5uoi/74r0kW0AxmNPyp32e3PSNenpT/ALZyv/oBX3//AGofV6v855oPEV6F2hYsf7p/xoHiK+GeIuf9n/69elPbW5/gQc+lC21vxlV9uKP7Zyv/AKAV9/8A9qL6vV/nPN/+Ekv8k/uuePun/GgeJL8IFAiwOnyn/GvSfstv0MaflTWtYOMRJj6Uv7Zyv/oBX3//AGo/q9X+c83/AOEjvj18v8j/AI0f8JJf8/6r/vk/416UtpASSUTgelItnbKBhVz9Kf8AbOV/9AMfv/8AtRewq/znm/8Awkl+CSPK56/Kf8ab/wAJFfbiwEQJ64X/AOvXpJtIM58tMH/Ypxs7b/nmvX0o/trK/wDoBX3/AP2oewq/znmx8S357Q/98f8A16T/AISO+9Iv++f/AK9ektZW5GMDr02c0gsogeUXnjpR/bWV/wDQCvv/APtQ+r1f5zzOTXr545UDhPOUpIY8ruUjBBAOD+Nbvgi8vNLe4uYbZZY5dq/MxGSM9MH39DXXtZ2uSCin2xR9khDYAwKnFcQUpYSWGwtBU+a19b7fJDjh5KSlJ3LcHiy3llRbrTr2B2/jRFkT8SCD+lbcWpaXMoYXag/3TkfoQK5r7InqKQWyA/d4ya8OOMqLc1dJM6i51GxhtXdrtJE6bBlieP7vOa4KSJJJXMJPlM2VBXsfY9K1hbJjJJ+n+FIbVCevWor13VVmgjT5dTHNvJk4YEZ70fZ5SD25+9nuO+K1haLjgYxStboT1xkYrl5DSzMk203pnpikEMx6J9BzWx5KHg8Yxx/hQYcGlyoVmYjQSD+En147ijyn4O3Hfof6VteUevek8rC9eD2pOIWZjeS+ew6+tHlyjcFVeueRW2sYDAr+RokCH5do+uKfKFmYPz9Sh4GOpJ9DTlR8gjIx3B5/StkQoQMY4GOaPKj3ZyvT86nlQWZkCS4bgl8eoel3SqADnqer5rYZVHQJjPP0oWBMZVVIAP8Ak0coWZisrkfNHnGeeB6UvlsSp24GOo6itn7NExGVTI70NbRqABGlLlCzMcxbhyvydwTj8eKTDLg+Xx0HrWwbaMrjYvXig26EcquM9KOVhZmMQQxJBOCSMHoPpQADISfMx3Ge49q2DarjO0fgRQbdMbSoI+lJwYrMyAuCMbux59qRslsYz7jp9a1/syHt0pFtV8zggZ70crCxkiP5fmHVhxz2/lShXIJA5xjjgVrfZlO4bs56cU9bJWB+YdKFBsLMxdmG4XPv/SgCbBPloRnPStk2a84YY7U37Ip6sOQcijkYWZklGw37rH9BTs4kVtvOeK01suuSOP8ACj7EQFBbODRyMLMy2GCPkzj1PSl2ny9qr16dB1rR+x5HQc+9IbMAjGM+vSjlYWZmlHC7jGD6c+lIImJX5BitP7C3BB59D0pGsXOBvHr+VTysVmZ33S3yE9xTwqkZPGQPf2rQ+yvtBGOvrQtq684Hv3oSY7Mzm2kcANj0BoVTlht/PvWgLR9xzk/jxQLdxwU4p2YrMzdrgspDHkcD0pRHwVzx357VpLBJ3VvekNu4GAG5/rRZhZmeA+Sd3T/9VNw2cr26A/8A1qv+S/UhsDpnJp3lNkj0HPFKzCzKAjbGNuPXqaUIcgBT06AkZq60THHApBE3J/T0+lPlYWKgV9uTuXGcdgO1II5QfvZPpn0q75ZPrjuKRo+23rTsFilh9o5YjJGcelOEch5DADHTb3+vrVpoeCNoweCO1NW3xgYXjjNTZ3CzKzRPz82fwOf0oWN+C3ygHrzV3yuVzjjOOT3pDFkdTiqsFioC5z0yD79PxpFL888c5yKum3Y+3cc46U0W+3vwR0zRZgVPnyecg9R15HenAtzlc9MnvwatG3HGQcjqaPs/Iwx60rMCpuZXYgYTtkc/hR8+CABg9sYz9cVbMPPOenFILcgAdaLMCsRxx6dORmkdyMK3ccYOBVswZBBGcdvakNs3GVzg+gptMCsGDDjsR26ijeyjOMEH8h61a+zsM4z19qTyHI6fzqbMCHB+9kjjJ/H0pu9RtG05x3J7VZ8tywJQnaPTOaQwsB359R61VmBEGVQVDcH3z9etNDMTgkA/y/GrBicYHt700xsM8Hr1x0oswIt37vHHHbPSlLlsLktwMY7D0qXyDtYMT26im+UcAqp45pai1EWXJI25zx16Uea/y/us47jGM+tIID+BJzkVII3OeT/wD/61CuO7EEhC/wCrY9274prO2QNpHuOfpR5L/NkkcdB6Uqo4bO7kkdMc/lT1C7I0ldZOFyOoPSpDORhiACeoz6UFH4BIwOnFKYnJzlTg55T+VGqFcabrGfTvmnNc5xgYGPx/GmNDJwAeByMcYpTC/wApOOB68flQm2O4pnQKM5PYnkUizx8DYe3UZoKN0JAz14yee9L5R2jHB9gcUBck29Rk0gKjOWzUJf3welNYqDgE+9Vcdy1tBJIYj8abgnGXzUDzKAABxSrI2Mg59qLhcsEAjgkCkBQr9/vxVcvuOAcGmhRnkgUXC5eDqDww9zQ0w46dOtUVIH8Q56ilU5PJGBRzDuXFdfanCRc5OMVTOAPvf/XoYnqCKpSFcu7l69qXzEJzjNUAXBI3U/fgZDUOY7lrKg8DNPEoGex9Ko+ZJtbBz3oEjZ5x0o5h3LYuGIYAjGfSl3nON3fHSqhZ8HaRg0kY5+ZiPSpuK5b80iQk0pkbJxgeuarsw9vfNRmZ2YHiqUguy4JZCCM/gKTzXz1HtVUSv2an+YxO305/Gq5tAuywJXBDYyT1pxuXwSAKrLMc5I6Gk8w4J5FLnHzMtefJ3HFNMzgEDr7VB5xAGSSKeJm4Ixg96akFyYTYAbOaQTFiSDj6VCJcscY+tDSH1Bo5tQuTiZgeeQKTzgW5446UxJeDnB9qFOTyQaHILkhmUA8A4FIJcnOfwqIqCDhh16Ui7gSCoFHMFy0JwRggDHekEgOVqDJBPH1NI0mMYouO5bJJFN3EgA1BvOSwwcdqaJWb2yaLhdFoyLjBzTWkEagAcZ9fWq/mMxzzintKTwAKOYd0PEm4dMYpGlw2D0qPztxClv0pGbnHpRcm5OLlCpwgoNwmRheMVA3CLwPekGAScfnSbC5YE6Yxt+lMWVTxt/DFMBXnjmmHO4EClcGyYTRsCChBGaXKbQSOtQnkk9KCrdA3ei4X7lgGM85Apr7OTvH0qLy2xjimhF/i4ouF0T/J97jkUjYyecAd6iKoeC1KMH5S2cdKaYXuPIU5IYUhUHGGpm1ueRTypA6g/jRcBxUY5zxVSSzhZixLgk8gVM2/P/16eFd17Eis5xjNWkrmtKtUpO8HYSIeVCFVhtHqKcZGGPm+nFNIIGOOaaykHHUVaVlZGcpOTu9ycndnDUgfbwOajRCc4IpWUg80XAk85ueOMcUfaCwAKjFR7fQ8+lNMTg5PSi7AmEhwAAM+9OMnXvjioljZueuPejY2Dx+VCbHccZDgjBpDIcKCKQq+QQp4pCzFduO9DbFccZkwPkycUI6sPu/jSKcDJX8KC+WGFwD7UuZjHb9smAMn60pl2nlDikLrnHekJ9e1HMwHCQMeAaQuFbJzSlto6VGZGOeO3FF2DJTuIyOnWh5ACQM5+tR+a3cDBpWkB25HtRdiuhxmJ7Ec08OMmqwlKk5HH0pFlZjgL/8AXo5mO5ZEoJ700yLgkscmmFtoAK8+lNBJY/KBz3p8zBskaUheCT+NKLhio45qEEZIx1pxK56HHpU8zFckEzHPHf1p3mse+O9VyPQHmnBRgY60KbFdljfx9/rTSQCM81XaNs4yacInA4bPrmq52Vcn39MCl3tyMYzVUK2c7uBSsrjJ3HrQpMLlvpTNoJwCarbpcYOacpcHJzincLonGOeec00qQR8x71GCWkzg01mJ9aVwuiQBsnrSeW5PUZqMFgMgGlO9hxkUwuiTy3IOSKaInCkE/SkG/HIPFKFcc/pS1AUI2Ru/ClbrkrkVFscdScDvQTkAc+9TdhclJBA+Xp60uwEHINQlcjqcUdG4Le3NFxXRNuUYG05FGMg8H86gJbPX61J5uOcH86Ljuhx9getNJJ65FJ5w3ZAyMUefu+npRcB6nvz6U0ye5+lICCD+tNEir9aLhck3fIOoNODfjjpTDKoAG44ppZT/ABYouBNvODzz3pBIecGolKg4JpQATwTRcCUswGMgnFN3NjJPPpTQVyctSbkyoLc5ouBMLgmPkn2FJ524jAyfpUbMpyB1pDIQCQelHMMlEhPGPwpPMHTp71D5h4bnNIZM/Wi4rk4kTIwec052PUkfnVYNnsRR5m5ulFwuWd2P4qN+Gxnr71WZmORjjFBkBHANFxXLRkwQPfrmk8znPPXPWqnmP+AppmfsKLhctmVcZwelPByvU1TWWnFyT1z6UXC5a3gZ7A0hcYIP4VT3vjlelKZD6HpRcVy5vGc9Bil3dww49u9UzKcD+tIJiDyKLjuXN45zjp6UzzM85H5VAJhg5xTWnXPCk07ibLZk6fN/kUM4JHK571V80MuSpFCuGA4OKVwvctFwOy88j/69JvU9UH4VCGBB4700sOmCM0XB2LSunUqMYo3oASFyar71bFIGA4xzT5hXLIZeOMEDtShk6kZquHAHSlEme1K400T/ALrB+QdaeVRlzhaqq4BxjigOQeR06VXMGhPhOgHpnmlPlscYGAfWoN6t6ZpCUAHPPrSuhlkKnIpNqDpnj3qDOQSG600hsgZ7UcwaFkbCetNKRAg7j1xiq4yHBJpecngUkxaFnajEnOOaPLT5juPT6VUwR3604EnknPHSnzAWkjjBPPY00JH93IJFQF2xxSGRuuBT5kBY8pSD8x470eWoAOQcGq3mv6/gKUO46mkmhExjGQSRgjgU/wAgAD5hjHXFU2b96DznGOvFAmccbicUXQFny1BP3aURfLz6dar+Y3PqaPNcDlvwppoD/9k=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#@title Custom image\n", + "from google.colab import files\n", + "import numpy as np\n", + "from PIL import Image\n", + "from urllib.request import urlopen\n", + "import matplotlib.pyplot as plt\n", + "from vit_utils.visualization import draw_points_and_skeleton, joints_dict\n", + "\n", + "img = np.array(Image.open(list(files.upload().keys())[0]), dtype=np.uint8)\n", + "\n", + "frame_keypoints = model.inference(img)\n", + "img = model.draw(show_yolo=True)\n", + "\n", + "from google.colab.patches import cv2_imshow\n", + "cv2_imshow(img[..., ::-1])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 872 + }, + "id": "Q_Y16sT4xFDD", + "outputId": "4b737319-fff9-4847-bea4-ae8dd51ee5cd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving img1.jpg to img1.jpg\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..0124d5b59a4064547f1e74d0eb42b68aabe38526 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO @@ -0,0 +1,7 @@ +Metadata-Version: 2.1 +Name: easy_ViTPose +Version: 1.1 +Home-page: https://github.com/JunkyByte/easy_ViTPose +Author: JunkyByte +Author-email: adriano.donninelli@hotmail.it +License-File: LICENSE diff --git a/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..8663cfb62011ccb943d311849e01d29103bf7470 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt @@ -0,0 +1,56 @@ +LICENSE +README.md +setup.py +easy_ViTPose/__init__.py +easy_ViTPose/inference.py +easy_ViTPose/sort.py +easy_ViTPose/train.py +easy_ViTPose.egg-info/PKG-INFO +easy_ViTPose.egg-info/SOURCES.txt +easy_ViTPose.egg-info/dependency_links.txt +easy_ViTPose.egg-info/top_level.txt +easy_ViTPose/configs/ViTPose_aic.py +easy_ViTPose/configs/ViTPose_ap10k.py +easy_ViTPose/configs/ViTPose_apt36k.py +easy_ViTPose/configs/ViTPose_coco.py +easy_ViTPose/configs/ViTPose_coco_25.py +easy_ViTPose/configs/ViTPose_common.py +easy_ViTPose/configs/ViTPose_mpii.py +easy_ViTPose/configs/ViTPose_wholebody.py +easy_ViTPose/configs/__init__.py +easy_ViTPose/datasets/COCO.py +easy_ViTPose/datasets/HumanPoseEstimation.py +easy_ViTPose/datasets/__init__.py +easy_ViTPose/vit_models/__init__.py +easy_ViTPose/vit_models/model.py +easy_ViTPose/vit_models/optimizer.py +easy_ViTPose/vit_models/backbone/__init__.py +easy_ViTPose/vit_models/backbone/vit.py +easy_ViTPose/vit_models/head/__init__.py +easy_ViTPose/vit_models/head/topdown_heatmap_base_head.py +easy_ViTPose/vit_models/head/topdown_heatmap_simple_head.py +easy_ViTPose/vit_models/losses/__init__.py +easy_ViTPose/vit_models/losses/classfication_loss.py +easy_ViTPose/vit_models/losses/heatmap_loss.py +easy_ViTPose/vit_models/losses/mesh_loss.py +easy_ViTPose/vit_models/losses/mse_loss.py +easy_ViTPose/vit_models/losses/multi_loss_factory.py +easy_ViTPose/vit_models/losses/regression_loss.py +easy_ViTPose/vit_utils/__init__.py +easy_ViTPose/vit_utils/dist_util.py +easy_ViTPose/vit_utils/inference.py +easy_ViTPose/vit_utils/logging.py +easy_ViTPose/vit_utils/top_down_eval.py +easy_ViTPose/vit_utils/train_valid_fn.py +easy_ViTPose/vit_utils/transform.py +easy_ViTPose/vit_utils/util.py +easy_ViTPose/vit_utils/visualization.py +easy_ViTPose/vit_utils/nms/__init__.py +easy_ViTPose/vit_utils/nms/nms.py +easy_ViTPose/vit_utils/nms/nms_ori.py +easy_ViTPose/vit_utils/nms/setup_linux.py +easy_ViTPose/vit_utils/post_processing/__init__.py +easy_ViTPose/vit_utils/post_processing/group.py +easy_ViTPose/vit_utils/post_processing/nms.py +easy_ViTPose/vit_utils/post_processing/one_euro_filter.py +easy_ViTPose/vit_utils/post_processing/post_transforms.py \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..812bb404d81643c66686cfe4ebbb44f557fdaf3c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt @@ -0,0 +1 @@ +easy_ViTPose diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/ViTPose_Inference-checkpoint.ipynb b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/ViTPose_Inference-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..2310a7c370a859129bab999fb3c1c8a2b5a40b4e --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/ViTPose_Inference-checkpoint.ipynb @@ -0,0 +1,2591 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "4b8faee1-d07c-481e-9470-b4756e2936ba", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import cv2\n", + "from easy_ViTPose import VitInference\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Image to run inference RGB format\n", + "img = cv2.imread('testVITPOSE.jpg')\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + "# set is_video=True to enable tracking in video inference\n", + "# be sure to use VitInference.reset() function to reset the tracker after each video\n", + "# There are a few flags that allows to customize VitInference, be sure to check the class definition\n", + "model_path = r'C:\\Users\\user\\ViTPose/ckpts/vitpose-s-coco_25.pth'\n", + "yolo_path = r'C:\\Users\\user\\ViTPose/yolov8s.pt'\n", + "\n", + "# If you want to use MPS (on new macbooks) use the torch checkpoints for both ViTPose and Yolo\n", + "# If device is None will try to use cuda -> mps -> cpu (otherwise specify 'cpu', 'mps' or 'cuda')\n", + "# dataset and det_class parameters can be inferred from the ckpt name, but you can specify them.\n", + "model = VitInference(model_path, yolo_path, model_name='s', yolo_size=320, is_video=False, device=\"cuda\")\n", + "\n", + "# Infer keypoints, output is a dict where keys are person ids and values are keypoints (np.ndarray (25, 3): (y, x, score))\n", + "# If is_video=True the IDs will be consistent among the ordered video frames.\n", + "keypoints = model.inference(img)\n", + "\n", + "# call model.reset() after each video\n", + "\n", + "img = model.draw(show_yolo=True) # Returns RGB image with drawings\n", + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "772c119d-0e34-488a-bcec-40e0007155aa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9e2a99d2-ece2-4f00-b9e1-e130099026bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "id": "ea96beea-c174-45c4-9119-e3db40f18793", + "metadata": {}, + "source": [ + "# Training the ViT_Pose" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba4a27fc-20e0-433f-9de5-65320f963af9", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) OpenMMLab. All rights reserved.\n", + "import argparse\n", + "import copy\n", + "import os\n", + "import os.path as osp\n", + "import time\n", + "import warnings\n", + "import click\n", + "import yaml\n", + "\n", + "from glob import glob\n", + "\n", + "import torch\n", + "import torch.distributed as dist\n", + "\n", + "from vit_utils.util import init_random_seed, set_random_seed\n", + "from vit_utils.dist_util import get_dist_info, init_dist\n", + "from vit_utils.logging import get_root_logger\n", + "\n", + "import configs.ViTPose_small_coco_256x192 as s_cfg\n", + "# import configs.ViTPose_base_coco_256x192 as b_cfg\n", + "# import configs.ViTPose_large_coco_256x192 as l_cfg\n", + "# import configs.ViTPose_huge_coco_256x192 as h_cfg\n", + "\n", + "from vit_models.model import ViTPose\n", + "from datasets.COCO import COCODataset\n", + "from vit_utils.train_valid_fn import train_model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ef1a26d-9303-4859-9112-bedea1dd46e8", + "metadata": {}, + "outputs": [], + "source": [ + "__file__ = r\"C:\\Users\\user\\ViTPose\\easy_ViTPose\\easy_ViTPose\"\n", + "CUR_PATH = osp.dirname(__file__)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "21be3367-277e-4d8c-8fca-d7524235c21b", + "metadata": {}, + "outputs": [], + "source": [ + "model_name = 's'\n", + "config_path = 'config.yaml'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16e707e1-e55b-4c44-abc3-fd217a60b381", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2d5c73bb-6486-4513-af1c-3c37c08e80f8", + "metadata": {}, + "source": [ + "### Loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41ea408e-c350-48d5-bf88-d9a2a68322c2", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "\n", + "# Load the JSON file\n", + "with open(r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\", 'r') as f:\n", + " coco_data = json.load(f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7bee2d84-71c7-4f53-8154-3b7340bd8708", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "590ad908-cc80-4c4e-a2af-88450a2aa77e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c1fa1c4b-75ff-4ed9-a46d-90c639acae41", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a mapping of image_id to file_name\n", + "image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8b2585-0ef4-4dc2-86ef-ab6d5d799075", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b83f079-efd1-416b-ab6c-29e80e668cff", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dde6eac-a62d-49b1-ad27-a39c114e0f1b", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "37899bdc-69a4-4271-8fd7-aa03148883a2", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example: Process keypoints for one annotation\n", + "# for ann in annotations:\n", + "# keypoints = ann['keypoints']\n", + "# keypoints_array = [keypoints[i:i + 3] for i in range(0, len(keypoints), 3)]\n", + "# print(\"Keypoints:\", keypoints_array)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9942e11-9394-4f67-a5ed-2ee700d33625", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b030648f-8e1f-4abe-8351-a7ae34cb3bb2", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9b30c5c1-6657-4102-8cd6-3f68b100bf61", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "data_dir = r'D:\\ViTPose\\Evaluating\\val2017\\\\'\n", + "dataset = []\n", + "\n", + "for ann in coco_data['annotations']:\n", + " image_id = ann['image_id']\n", + " #print(\"image_id: \", image_id)\n", + " file_name = image_id_to_filename[image_id]\n", + " #print(\"file_name: \", file_name)\n", + " image_path = os.path.join(data_dir, file_name)\n", + " #print(\"image_path: \", image_path)\n", + " # Load the image\n", + " if not os.path.exists(image_path):\n", + " continue\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints_array = np.array([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)])\n", + " \n", + " # Collect data\n", + " dataset.append((image, keypoints_array))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a9c3c26-7d13-4103-97c1-f5d51cef5584", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "47734b7b-3c0f-4e58-abe6-bc6a70dc29c9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "397133\n", + "000000397133.jpg\n" + ] + } + ], + "source": [ + "print(coco_data['images'][0]['id'])\n", + "print(coco_data['images'][0]['file_name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9463a1ea-09be-4138-b6d7-501a4f25c2f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Apply scaling transformation for each keypoint\n", + "def resize_keypoints(keypoints, scale_w, scale_h):\n", + " resized_keypoints = keypoints.clone()\n", + " \n", + " for j in range(keypoints.shape[0]):\n", + " x, y, visibility = keypoints[j]\n", + " # Only resize if visibility > 0 (to ignore invisible keypoints)\n", + " if visibility > 0:\n", + " resized_keypoints[j, 0] = int(x * scale_w)\n", + " resized_keypoints[j, 1] = int(y * scale_h)\n", + " \n", + " return resized_keypoints\n", + "\n", + "\n", + "\n", + "def transformKeypoint(img, target_shape, keypoints):\n", + " orig_width, orig_height = img.width, img.height\n", + " (target_width, target_height) = target_shape\n", + " \n", + " # Scaling factors for width and height\n", + " scale_w = target_width / orig_width\n", + " scale_h = target_height / orig_height\n", + " # Resized keypoints\n", + " resized_keypoints = resize_keypoints(keypoints, scale_w, scale_h)\n", + " \n", + " # Print the resized keypoints\n", + " #print(\"Resized Keypoints:\\n\", resized_keypoints)\n", + " return resized_keypoints\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "012be853-653e-4651-9861-fc2e11a00a00", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be1f8f9d-2c11-4ddc-a646-e193b79d3829", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3faf2805-5a62-4f5a-967b-4e7ec1c32c87", + "metadata": {}, + "outputs": [], + "source": [ + "target_shape = (208, 208)\n", + "import torch\n", + "from torch.utils.data import Dataset\n", + "\n", + "class COCOKeypointsDataset(Dataset):\n", + " def __init__(self, json_path, images_dir, transform=None, transformKP = None):\n", + " with open(json_path, 'r') as f:\n", + " coco_data = json.load(f)\n", + " \n", + " self.image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}\n", + " self.annotations = coco_data['annotations']\n", + " self.images_dir = images_dir\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.annotations)\n", + "\n", + " def __getitem__(self, idx):\n", + " # Get annotation\n", + " ann = self.annotations[idx]\n", + " image_id = ann['image_id']\n", + " file_name = self.image_id_to_filename[image_id]\n", + " image_path = os.path.join(self.images_dir, file_name)\n", + " \n", + " # Load image\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints = torch.tensor([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)], dtype=torch.float32) \n", + " keypoints = transformKeypoint(image, target_shape, keypoints)\n", + " #print(\"keypoints: \", keypoints)\n", + " \n", + " # Apply transformations\n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, keypoints\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "960b56d0-391d-4cd5-886c-c951d5e5bf63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccddf3cf-5b28-4fad-a467-917a53d19d63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47ebf732-8f35-4caa-85ec-5dabb6e95e93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "05380b1e-f0d4-4dcc-84de-147726da3ac4", + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision import transforms\n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((208, 208)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "dataset = COCOKeypointsDataset(\n", + " json_path=r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\",\n", + " images_dir=r'D:\\ViTPose\\Evaluating\\val2017\\\\',\n", + " transform=transform\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "62efbb61-7d6e-4b8d-9fe5-537ca0f7ee04", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "dataloader = DataLoader(dataset, batch_size=4, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c2a8ab8-5496-462d-a58b-f87f06e427bf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d9d940c5-13f6-4b24-a887-28f08f370d04", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Images shape: torch.Size([4, 3, 208, 208])\n", + "Keypoints shape: torch.Size([4, 17, 3])\n", + "keypoints: tensor([[[150., 88., 2.],\n", + " [152., 88., 2.],\n", + " [149., 87., 2.],\n", + " [153., 88., 2.],\n", + " [147., 88., 2.],\n", + " [157., 92., 2.],\n", + " [145., 93., 2.],\n", + " [162., 98., 2.],\n", + " [141., 98., 1.],\n", + " [164., 100., 1.],\n", + " [ 0., 0., 0.],\n", + " [156., 103., 1.],\n", + " [148., 103., 1.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 61., 59., 2.],\n", + " [ 62., 57., 2.],\n", + " [ 60., 57., 2.],\n", + " [ 66., 58., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 72., 69., 2.],\n", + " [ 59., 69., 2.],\n", + " [ 78., 85., 2.],\n", + " [ 59., 80., 2.],\n", + " [ 67., 90., 2.],\n", + " [ 59., 91., 2.],\n", + " [ 73., 102., 2.],\n", + " [ 64., 102., 2.],\n", + " [ 70., 126., 2.],\n", + " [ 58., 123., 2.],\n", + " [ 77., 150., 2.],\n", + " [ 62., 150., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 76., 206., 2.],\n", + " [ 92., 186., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 94., 159., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 89., 137., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 65., 66., 2.],\n", + " [ 68., 63., 2.],\n", + " [ 57., 64., 2.],\n", + " [ 71., 67., 2.],\n", + " [ 48., 68., 2.],\n", + " [ 61., 82., 2.],\n", + " [ 50., 80., 2.],\n", + " [ 58., 100., 2.],\n", + " [ 54., 83., 2.],\n", + " [ 74., 110., 2.],\n", + " [ 53., 82., 2.],\n", + " [ 54., 128., 2.],\n", + " [ 45., 131., 2.],\n", + " [ 58., 148., 2.],\n", + " [ 44., 156., 2.],\n", + " [ 58., 177., 2.],\n", + " [ 39., 186., 2.]]])\n" + ] + } + ], + "source": [ + "for images, keypoints in dataloader:\n", + " print(\"Images shape:\", images.shape)\n", + " print(\"Keypoints shape:\", keypoints.shape)\n", + " print(\"keypoints: \", keypoints)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b26cfb19-15d6-47a6-8114-6ef1385d6fbc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e5e00bc-e79f-408f-bd3c-7663225cde47", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e24981bc-7a91-45ba-bcc5-d79a7604b8b3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "670e81c3-27a2-43ef-a149-f4d88d7214c4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "97e0ee06-e303-4a6c-8cda-eb6087693980", + "metadata": {}, + "source": [ + "### Ending loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8334085f-85d4-4889-9f7f-71e8b7b6adc5", + "metadata": {}, + "outputs": [], + "source": [ + "cfg = {'s':s_cfg}.get(model_name.lower())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b7b53af5-0822-47a4-be61-6f8b2de9f9c6", + "metadata": {}, + "outputs": [], + "source": [ + "# Load config.yaml\n", + "with open(config_path, 'r') as f:\n", + " cfg_yaml = yaml.load(f, Loader=yaml.SafeLoader)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7ef13d0b-2fd5-4313-9822-8b1626da933f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'log_level': 'logging.INFO',\n", + " 'seed': 0,\n", + " 'gpu_ids': [0],\n", + " 'deterministic': True,\n", + " 'cudnn_benchmark': True,\n", + " 'resume_from': 'C:/Users/user/ViTPose/ckpts/vitpose-s-coco_25.pth',\n", + " 'launcher': 'none',\n", + " 'use_amp': False,\n", + " 'validate': True,\n", + " 'autoscale_lr': False,\n", + " 'dist_params': '...'}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg_yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "64402e77-c6b8-49bb-90db-6693de309268", + "metadata": {}, + "outputs": [], + "source": [ + "for k, v in cfg_yaml.items():\n", + " if hasattr(cfg, k):\n", + " raise ValueError(f\"Already exists {k} in config\")\n", + " else:\n", + " cfg.__setattr__(k, v)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98b406f9-d79a-40ed-af8a-e73d4808776a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "057c9e72-4693-4387-a141-a844159b6410", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88841210-3245-47d4-8fea-22a3fdff04ab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "765d06d7-dcc9-46a0-a9bc-9569ff314eec", + "metadata": {}, + "outputs": [], + "source": [ + "# set cudnn_benchmark\n", + "if cfg.cudnn_benchmark:\n", + " torch.backends.cudnn.benchmark = True" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "14bcd3c1-01e4-4308-a693-7cba5b28ec97", + "metadata": {}, + "outputs": [], + "source": [ + "# Set work directory (session-level)\n", + "if not hasattr(cfg, 'work_dir'):\n", + " cfg.__setattr__('work_dir', f\"{CUR_PATH}/runs/train\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fe3506fa-36d0-461e-8f18-856a35ae3268", + "metadata": {}, + "outputs": [], + "source": [ + "if not osp.exists(cfg.work_dir):\n", + " os.makedirs(cfg.work_dir)\n", + "session_list = sorted(glob(f\"{cfg.work_dir}/*\"))\n", + "if len(session_list) == 0:\n", + " session = 1\n", + "else:\n", + " session = int(os.path.basename(session_list[-1])) + 1\n", + "session_dir = osp.join(cfg.work_dir, str(session).zfill(3))\n", + "os.makedirs(session_dir)\n", + "cfg.__setattr__('work_dir', session_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "aaffeee8-3d10-4cb8-ab1b-98f79bdb9910", + "metadata": {}, + "outputs": [], + "source": [ + "if cfg.autoscale_lr:\n", + " # apply the linear scaling rule (https://arxiv.org/abs/1706.02677)\n", + " cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c022f17-9135-4317-a8ca-e7d4b51b4d1a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bc6c864a-6cf0-4599-aa2a-0de7f6fd19ec", + "metadata": {}, + "outputs": [], + "source": [ + "# init distributed env first, since logger depends on the dist info.\n", + "if cfg.launcher == 'none':\n", + " distributed = False\n", + " if len(cfg.gpu_ids) > 1:\n", + " warnings.warn(\n", + " f\"We treat {cfg['gpu_ids']} as gpu-ids, and reset to \"\n", + " f\"{cfg['gpu_ids'][0:1]} as gpu-ids to avoid potential error in \"\n", + " \"non-distribute training time.\")\n", + " cfg.gpu_ids = cfg.gpu_ids[0:1]\n", + "else:\n", + " distributed = True\n", + " init_dist(cfg.launcher, **cfg.dist_params)\n", + " # re-set gpu_ids with distributed training mode\n", + " _, world_size = get_dist_info()\n", + " cfg.gpu_ids = range(world_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "935e56e5-d5d1-4f19-bba0-6d659665c570", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3881144e-53b7-4a2b-b878-0d8c43a17d82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-24 17:08:26,262 - vit_utils - INFO - Distributed training: False\n", + "2024-12-24 17:08:26,263 - vit_utils - INFO - Set random seed to 0, deterministic: True\n" + ] + } + ], + "source": [ + "# init the logger before other steps\n", + "timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())\n", + "log_file = osp.join(session_dir, f'{timestamp}.log')\n", + "logger = get_root_logger(log_file=log_file)\n", + "\n", + "# init the meta dict to record some important information such as\n", + "# environment info and seed, which will be logged\n", + "meta = dict()\n", + "\n", + "# log some basic info\n", + "logger.info(f'Distributed training: {distributed}')\n", + "\n", + "# set random seeds\n", + "seed = init_random_seed(cfg.seed)\n", + "logger.info(f\"Set random seed to {seed}, \"\n", + " f\"deterministic: {cfg.deterministic}\")\n", + "set_random_seed(seed, deterministic=cfg.deterministic)\n", + "meta['seed'] = seed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0588f6f-6fe0-4ac6-9fcf-a2c744e68091", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5878400f-1165-4301-aad8-aef907113a4a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_5392\\1963230343.py:5: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n" + ] + } + ], + "source": [ + "# Set model\n", + "model = ViTPose(cfg.model)\n", + "if cfg.resume_from:\n", + " # Load ckpt partially\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n", + " ckpt_state.pop('keypoint_head.final_layer.bias')\n", + " ckpt_state.pop('keypoint_head.final_layer.weight')\n", + " model.load_state_dict(ckpt_state, strict=False)\n", + "\n", + " # freeze the backbone, leave the head to be finetuned\n", + " model.backbone.frozen_stages = model.backbone.depth - 1\n", + " model.backbone.freeze_ffn = True\n", + " model.backbone.freeze_attn = True\n", + " model.backbone._freeze_stages()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52cef111-bc9c-417d-9770-7595408863be", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "93e7765d-94ca-4a16-b4d6-c95085bfad35", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ViTPose(\n", + " (backbone): ViT(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 384, kernel_size=(16, 16), stride=(16, 16), padding=(2, 2))\n", + " )\n", + " (blocks): ModuleList(\n", + " (0): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.00909090880304575)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (2): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0181818176060915)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (3): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.027272727340459824)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (4): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.036363635212183)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (5): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.045454543083906174)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (6): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.054545458406209946)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (7): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.06363636255264282)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (8): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0727272778749466)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (9): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.08181818574666977)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (10): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.09090909361839294)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (11): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.10000000149011612)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (last_norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " )\n", + " (keypoint_head): TopdownHeatmapSimpleHead(\n", + " (deconv_layers): Sequential(\n", + " (0): ConvTranspose2d(384, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): ConvTranspose2d(256, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " )\n", + " (final_layer): Conv2d(256, 17, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + ")" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "851da2fd-707c-4dc9-bca0-99ac5530374a", + "metadata": {}, + "outputs": [], + "source": [ + "# Set dataset\n", + "datasets_train = dataloader\n", + "datasets_valid = dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d352a68-dccd-4d94-86c7-deb716545df4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5af32dc2-8a9c-4abf-bc31-1454d64622e2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 1:\n", + " - Images: torch.Size([4, 3, 208, 208])\n", + " - Labels: tensor([[[ 83., 46., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 83., 44., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 79., 44., 2.],\n", + " [ 83., 53., 2.],\n", + " [ 75., 54., 2.],\n", + " [ 86., 64., 2.],\n", + " [ 78., 70., 2.],\n", + " [ 90., 78., 2.],\n", + " [ 87., 79., 2.],\n", + " [ 83., 80., 2.],\n", + " [ 78., 81., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 80., 99., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 121., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [200., 83., 2.],\n", + " [ 0., 0., 0.],\n", + " [192., 150., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 48., 2.],\n", + " [ 63., 59., 2.],\n", + " [ 64., 60., 2.],\n", + " [ 70., 82., 2.],\n", + " [ 72., 85., 2.],\n", + " [ 83., 83., 2.],\n", + " [ 76., 62., 2.],\n", + " [ 58., 107., 2.],\n", + " [ 58., 109., 2.],\n", + " [ 83., 87., 2.],\n", + " [ 84., 98., 2.],\n", + " [ 75., 115., 1.],\n", + " [ 77., 141., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]]])\n" + ] + } + ], + "source": [ + "# Iterate Through the DataLoader\n", + "for batch_idx, (images, labels) in enumerate(dataloader):\n", + " print(f\"Batch {batch_idx + 1}:\")\n", + " print(f\" - Images: {images.shape}\") # Shape: (batch_size, 3, H, W)\n", + " print(f\" - Labels: {labels}\") # Tensor of labels\n", + " # Perform operations on images and labels (e.g., training)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c7000fcb-4487-4671-a88c-635da8e17d93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([17, 3])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68165efc-54b3-4774-81d7-5e87b409219f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "48811727-c7b5-48ec-8d2e-234e14cd1312", + "metadata": {}, + "source": [ + "train_model(\n", + " model=model,\n", + " datasets_train=datasets_train,\n", + " datasets_valid=datasets_valid,\n", + " cfg=cfg,\n", + " distributed=distributed,\n", + " validate=cfg.validate,\n", + " timestamp=timestamp,\n", + " meta=meta\n", + " )" + ] + }, + { + "cell_type": "raw", + "id": "62b37ca0-46a6-49e9-8d7b-5f0c69b93f20", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import os.path as osp\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "from vit_models.losses import JointsMSELoss\n", + "from vit_models.optimizer import LayerDecayOptimizer\n", + "\n", + "from torch.nn.parallel import DataParallel, DistributedDataParallel\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.optim.lr_scheduler import LambdaLR, MultiStepLR\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from torch.utils.data.distributed import DistributedSampler\n", + "from torch.cuda.amp import autocast, GradScaler\n", + "from tqdm import tqdm\n", + "from time import time\n", + "\n", + "\n", + "logger = get_root_logger()\n", + "\n", + " \n", + "dataloaders_train = datasets_train\n", + "dataloaders_valid = datasets_valid\n", + "# put model on gpus\n", + "if distributed:\n", + " find_unused_parameters = cfg.get('find_unused_parameters', False)\n", + " # Sets the `find_unused_parameters` parameter in\n", + " # torch.nn.parallel.DistributedDataParallel\n", + "\n", + " model = DistributedDataParallel(\n", + " module=model, \n", + " device_ids=[torch.cuda.current_device()], \n", + " broadcast_buffers=False, \n", + " find_unused_parameters=find_unused_parameters)\n", + "else:\n", + " model = DataParallel(model, device_ids=cfg.gpu_ids)\n", + "\n", + "# Loss function\n", + "criterion = JointsMSELoss(use_target_weight=cfg.model['keypoint_head']['loss_keypoint']['use_target_weight'])\n", + "\n", + "# Optimizer\n", + "optimizer = AdamW(model.parameters(), lr=cfg.optimizer['lr'], betas=cfg.optimizer['betas'], weight_decay=cfg.optimizer['weight_decay'])\n", + "\n", + "# Layer-wise learning rate decay\n", + "lr_mult = [cfg.optimizer['paramwise_cfg']['layer_decay_rate']] * cfg.optimizer['paramwise_cfg']['num_layers']\n", + "layerwise_optimizer = LayerDecayOptimizer(optimizer, lr_mult)\n", + "\n", + "\n", + "# Learning rate scheduler (MultiStepLR)\n", + "milestones = cfg.lr_config['step']\n", + "gamma = 0.1\n", + "scheduler = MultiStepLR(optimizer, milestones, gamma)\n", + "\n", + "# Warm-up scheduler\n", + "num_warmup_steps = cfg.lr_config['warmup_iters'] # Number of warm-up steps\n", + "warmup_factor = cfg.lr_config['warmup_ratio'] # Initial learning rate = warmup_factor * learning_rate\n", + "warmup_scheduler = LambdaLR(\n", + " optimizer,\n", + " lr_lambda=lambda step: warmup_factor + (1.0 - warmup_factor) * step / num_warmup_steps\n", + ")\n", + "\n", + "# AMP setting\n", + "if cfg.use_amp:\n", + " logger.info(\"Using Automatic Mixed Precision (AMP) training...\")\n", + " # Create a GradScaler object for FP16 training\n", + " scaler = GradScaler()\n", + "\n", + "# Logging config\n", + "total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "logger.info(f'''\\n\n", + "#========= [Train Configs] =========#\n", + "# - Num GPUs: {len(cfg.gpu_ids)}\n", + "# - Batch size (per gpu): {cfg.data['samples_per_gpu']}\n", + "# - LR: {cfg.optimizer['lr']: .6f}\n", + "# - Num params: {total_params:,d}\n", + "# - AMP: {cfg.use_amp}\n", + "#===================================# \n", + "''')\n", + "\n", + "global_step = 0\n", + "for dataloader in dataloaders_train:\n", + " print(\"start training\")\n", + " for epoch in range(cfg.total_epochs):\n", + " model.train()\n", + " train_pbar = tqdm(dataloader)\n", + " total_loss = 0\n", + " tic = time()\n", + " for batch_idx, batch in enumerate(train_pbar):\n", + " layerwise_optimizer.zero_grad()\n", + " \n", + " images, targets, target_weights, __ = batch\n", + " images = images.to('cuda').unsqueeze(0)\n", + " targets = targets.to('cuda').unsqueeze(0)\n", + " target_weights = target_weights.to('cuda')\n", + " \n", + " if cfg.use_amp:\n", + " with autocast():\n", + " outputs = model(images)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " scaler.scale(loss).backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " scaler.step(layerwise_optimizer)\n", + " scaler.update()\n", + " else:\n", + " print(images.shape)\n", + " outputs = model(images)\n", + " print(\"outputs: \", outputs.shape)\n", + " print(\"targets: \", targets.shape)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " loss.backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " layerwise_optimizer.step()\n", + " \n", + " if global_step < num_warmup_steps:\n", + " warmup_scheduler.step()\n", + " global_step += 1\n", + " \n", + " total_loss += loss.item()\n", + " train_pbar.set_description(f\"🏋️> Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Loss {loss.item():.4f} | LR {optimizer.param_groups[0]['lr']:.6f} | Step\")\n", + " scheduler.step()\n", + " \n", + " avg_loss_train = total_loss/len(dataloader)\n", + " logger.info(f\"[Summary-train] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (train) {avg_loss_train:.4f} --- {time()-tic:.5f} sec. elapsed\")\n", + " ckpt_name = f\"epoch{str(epoch).zfill(3)}.pth\"\n", + " ckpt_path = osp.join(cfg.work_dir, ckpt_name)\n", + " torch.save(model.module.state_dict(), ckpt_path)\n", + "\n", + " # validation\n", + " if validate:\n", + " tic2 = time()\n", + " avg_loss_valid = valid_model(model, dataloaders_valid, criterion, cfg)\n", + " logger.info(f\"[Summary-valid] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (valid) {avg_loss_valid:.4f} --- {time()-tic2:.5f} sec. elapsed\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c3aaa51-efa5-414c-a0a8-9f3b475ca67e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2f0dd2c-ceaa-40c1-943f-3392c4bb1b3d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc8f7cda-227e-4a03-b694-97af713b73f6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91348ce9-12d7-4882-b222-b9b60cedebec", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e63562-cc6c-460d-aab5-f2f9bb5724cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6b2dd91c-9830-41a3-bddd-6c2f09254a7c", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda')\n", + "# Move model to device\n", + "model = model.to(device)\n", + "\n", + "# Move inputs to device\n", + "images = images.to(device)\n" + ] + }, + { + "cell_type": "markdown", + "id": "faf1e322-2867-47d7-8778-09e83ead56ef", + "metadata": {}, + "source": [ + "## Define my own training process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cbc9686-7e2f-4fcb-af2b-b260fb8051f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4ed1ef2-58d7-4d18-9966-1ebb95adc529", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e568149-21ff-47c5-93f1-35d7290b837f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0a0a470-7c51-4027-b1cb-85d5a52bb28e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "430f8a82-9c8f-4014-b3ff-ac9548213294", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4b00355-74b1-4f87-abd1-2e2dc31846e6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2de2c69e-ebc5-4e96-aa0e-5aab0cc88c31", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "867a6faa-7419-4a01-9719-2739639be673", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "def generate_heatmaps(keypoints, output_size):\n", + " \"\"\"\n", + " Generate heatmaps from keypoints for training.\n", + " Args:\n", + " - keypoints: Tensor of shape (batch_size, num_keypoints, 3) containing (x, y, visibility)\n", + " - output_size: (height, width) of the heatmaps\n", + " Returns:\n", + " - heatmaps: Tensor of shape (batch_size, num_keypoints, height, width)\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros(batch_size, num_keypoints, height, width, device=keypoints.device)\n", + "\n", + " #print(\"heatmaps: \", heatmaps)\n", + " for i in range(batch_size):\n", + " for j in range(num_keypoints):\n", + " x, y, visibility = keypoints[i, j, 0], keypoints[i, j, 1], keypoints[i, j, 2]\n", + " if visibility > 0:\n", + " # Create a Gaussian heatmap for each keypoint\n", + " gaussian = generate_gaussian(x, y, height, width)\n", + " print(\"gaussian max: \", gaussian.max())\n", + " print(\"gaussian min: \", gaussian.min())\n", + " heatmaps[i, j] = gaussian\n", + "\n", + " return heatmaps\n", + "\n", + "def generate_gaussian(x, y, height, width, sigma=1):\n", + " \"\"\"\n", + " Generate a Gaussian heatmap centered at (x, y) with standard deviation sigma.\n", + " \"\"\"\n", + " grid_x, grid_y = torch.meshgrid(torch.arange(0, width), torch.arange(0, height))\n", + " grid = torch.stack([grid_x, grid_y], dim=-1).float()\n", + " \n", + " mean = torch.tensor([x, y], dtype=torch.float32)\n", + " variance = sigma ** 2\n", + " diff = grid - mean\n", + " dist = torch.sum(diff ** 2, dim=-1)\n", + " gaussian = torch.exp(-dist / (2 * variance))\n", + "\n", + " return gaussian\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdf3b94a-370e-481b-a1a6-9c165bc06e34", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3e554ac4-3b6f-4621-8bde-a358e68e8e25", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "images.shape: torch.Size([4, 3, 208, 208])\n", + "labels.shape: torch.Size([4, 17, 3])\n" + ] + } + ], + "source": [ + "for images, labels in dataloader:\n", + " print(\"images.shape: \", images.shape)\n", + " print(\"labels.shape: \", labels.shape)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f2e9ad48-4a8e-4bdd-91a2-68f810e859c4", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[32], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39mimshow(outputs[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 2\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'plt' is not defined" + ] + } + ], + "source": [ + "plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38308db6-5e0c-4d08-91c4-b7408adcb81a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf122f87-f911-4c39-a6fc-4f004d1988ce", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9c5386a0-b07b-47f5-be1e-9af65dcb6de2", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "\n", + "def generate_heatmaps(keypoints, output_size, sigma=2):\n", + " \"\"\"\n", + " Generate ground truth heatmaps for keypoints.\n", + " \n", + " Args:\n", + " keypoints: Tensor of shape (batch_size, num_keypoints, 3) with (x, y, confidence).\n", + " output_size: Tuple (height, width) of the heatmap.\n", + " sigma: Standard deviation of the Gaussian.\n", + " \n", + " Returns:\n", + " heatmaps: Tensor of shape (batch_size, num_keypoints, height, width).\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros((batch_size, num_keypoints, height, width), device=keypoints.device)\n", + "\n", + " for b in range(batch_size):\n", + " for k in range(num_keypoints):\n", + " x, y, confidence = keypoints[b, k]\n", + " \n", + " # Skip keypoints with zero confidence\n", + " if confidence <= 0 or x < 0 or y < 0:\n", + " continue\n", + " \n", + " # Create a meshgrid for Gaussian generation\n", + " xx, yy = torch.meshgrid(torch.arange(width, device=keypoints.device), \n", + " torch.arange(height, device=keypoints.device), \n", + " indexing='xy')\n", + " \n", + " # Calculate the 2D Gaussian heatmap\n", + " heatmap = torch.exp(-((xx - x)**2 + (yy - y)**2) / (2 * sigma**2))\n", + " heatmaps[b, k] = heatmap\n", + "\n", + " return heatmaps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b738642-c839-410a-8ba0-aa9698e70aa0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "6ca3122b-2019-4bc1-a8cd-39e7230d52de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated heatmaps shape: torch.Size([2, 17, 255, 255])\n" + ] + } + ], + "source": [ + "# Example usage\n", + "keypoints = torch.tensor([[[226., 129., 2.], [228., 127., 2.], [225., 127., 2.], [0., 0., 0.], [0., 0., 0.],\n", + " [233., 128., 2.], [218., 130., 2.], [239., 135., 2.], [213., 136., 2.], [243., 139., 2.],\n", + " [211., 137., 2.], [232., 149., 2.], [222., 148., 2.], [232., 169., 2.], [222., 169., 2.],\n", + " [233., 188., 2.], [221., 182., 2.]],\n", + " [[584., 101., 2.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [587., 137., 2.],\n", + " [637., 137., 2.], [567., 196., 2.], [0., 0., 0.], [561., 235., 2.], [619., 214., 2.],\n", + " [589., 222., 2.], [630., 224., 2.], [579., 317., 2.], [614., 309., 2.], [586., 400., 2.],\n", + " [611., 399., 2.]]], device='cuda:0')\n", + "\n", + "heatmaps = generate_heatmaps(keypoints, output_size=(255, 255), sigma=2)\n", + "\n", + "print(\"Generated heatmaps shape:\", heatmaps.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "3615cb01-7df8-43d9-9bd1-16f644df0125", + "metadata": {}, + "outputs": [ + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAGiCAYAAACGUJO6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh8ElEQVR4nO3df2xV9eH/8de57e2l/Li3K6W9rQIWVH7IDx1i7VdlbDS0wBgIS0SZQ0MgstZM8ddqFGRbVsOWbdHhyJIF/EP8lYhEomQItoxZUKt8ENQGGmZh9BaF9V5a6O29ve/vH8h1VyvQ0nJ5t89HciL3nHNv3+edNk/Pvefe6xhjjAAAsIwr2QMAAKArCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEpJC9iaNWt01VVXqV+/fiooKNB7772XrKEAACyUlIC9/PLLWr58uVauXKkPP/xQEydOVHFxsY4dO5aM4QAALOQk48N8CwoKNHnyZP3lL3+RJMViMQ0dOlT333+/fvWrX13q4QAALJR6qX9gW1ubampqVF5eHl/ncrlUVFSk6urqDu8TDocVDofjt2OxmE6cOKHBgwfLcZweHzMAoHsZY3Ty5Enl5eXJ5erak4GXPGBffvml2tvblZOTk7A+JydHn332WYf3qaio0KpVqy7F8AAAl9Dhw4d15ZVXdum+lzxgXVFeXq7ly5fHbweDQQ0bNky3aqZS5U7iyAAAXRFVRDv1pgYNGtTlx7jkAcvKylJKSooaGxsT1jc2Nsrv93d4H4/HI4/H8631qXIr1SFgAGCdr66+uJiXgS75VYhpaWmaNGmStm3bFl8Xi8W0bds2FRYWXurhAAAslZSnEJcvX65Fixbpxhtv1E033aQ///nPamlp0b333puM4QAALJSUgN1xxx364osvtGLFCgUCAV1//fXasmXLty7sAADguyTlfWAXKxQKyefzaarm8BoYAFgoaiKq1CYFg0F5vd4uPQafhQgAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArdXvAnnrqKTmOk7CMHj06vr21tVWlpaUaPHiwBg4cqPnz56uxsbG7hwEA6OV65AzsuuuuU0NDQ3zZuXNnfNuDDz6oN954Q6+++qqqqqp09OhRzZs3ryeGAQDoxVJ75EFTU+X3+7+1PhgM6u9//7s2bNigH/3oR5KkdevWacyYMdq1a5duvvnmnhgOAKAX6pEzsAMHDigvL08jRozQwoULVV9fL0mqqalRJBJRUVFRfN/Ro0dr2LBhqq6u7omhAAB6qW4/AysoKND69es1atQoNTQ0aNWqVbrtttu0b98+BQIBpaWlKSMjI+E+OTk5CgQC3/mY4XBY4XA4fjsUCnX3sAEAlun2gM2YMSP+7wkTJqigoEDDhw/XK6+8ovT09C49ZkVFhVatWtVdQwQA9AI9fhl9RkaGrr32Wh08eFB+v19tbW1qampK2KexsbHD18zOKi8vVzAYjC+HDx/u4VEDAC53PR6w5uZm1dXVKTc3V5MmTZLb7da2bdvi22tra1VfX6/CwsLvfAyPxyOv15uwAAD6tm5/CvHhhx/W7NmzNXz4cB09elQrV65USkqK7rzzTvl8Pi1evFjLly9XZmamvF6v7r//fhUWFnIFIgCgU7o9YEeOHNGdd96p48ePa8iQIbr11lu1a9cuDRkyRJL0pz/9SS6XS/Pnz1c4HFZxcbGee+657h4GAKCXc4wxJtmD6KxQKCSfz6epmqNUx53s4QAAOilqIqrUJgWDwS6/LMRnIQIArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYKVOB2zHjh2aPXu28vLy5DiOXn/99YTtxhitWLFCubm5Sk9PV1FRkQ4cOJCwz4kTJ7Rw4UJ5vV5lZGRo8eLFam5uvqgDAQD0LZ0OWEtLiyZOnKg1a9Z0uH316tV65plntHbtWu3evVsDBgxQcXGxWltb4/ssXLhQ+/fv19atW7V582bt2LFDS5cu7fpRAAD6HMcYY7p8Z8fRxo0bNXfuXElnzr7y8vL00EMP6eGHH5YkBYNB5eTkaP369VqwYIE+/fRTjR07Vu+//75uvPFGSdKWLVs0c+ZMHTlyRHl5eef9uaFQSD6fT1M1R6mOu6vDBwAkSdREVKlNCgaD8nq9XXqMbn0N7NChQwoEAioqKoqv8/l8KigoUHV1tSSpurpaGRkZ8XhJUlFRkVwul3bv3t3h44bDYYVCoYQFANC3dWvAAoGAJCknJydhfU5OTnxbIBBQdnZ2wvbU1FRlZmbG9/mmiooK+Xy++DJ06NDuHDYAwEJWXIVYXl6uYDAYXw4fPpzsIQEAkqxbA+b3+yVJjY2NCesbGxvj2/x+v44dO5awPRqN6sSJE/F9vsnj8cjr9SYsAIC+rVsDlp+fL7/fr23btsXXhUIh7d69W4WFhZKkwsJCNTU1qaamJr7P9u3bFYvFVFBQ0J3DAQD0YqmdvUNzc7MOHjwYv33o0CHt2bNHmZmZGjZsmB544AH99re/1TXXXKP8/Hw9+eSTysvLi1+pOGbMGJWUlGjJkiVau3atIpGIysrKtGDBggu6AhEAAKkLAfvggw/0wx/+MH57+fLlkqRFixZp/fr1evTRR9XS0qKlS5eqqalJt956q7Zs2aJ+/frF7/PCCy+orKxM06ZNk8vl0vz58/XMM890w+EAAPqKi3ofWLLwPjAAsNtl9z4wAAAuFQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFbqdMB27Nih2bNnKy8vT47j6PXXX0/Yfs8998hxnISlpKQkYZ8TJ05o4cKF8nq9ysjI0OLFi9Xc3HxRBwIA6Fs6HbCWlhZNnDhRa9as+c59SkpK1NDQEF9efPHFhO0LFy7U/v37tXXrVm3evFk7duzQ0qVLOz96AECfldrZO8yYMUMzZsw45z4ej0d+v7/DbZ9++qm2bNmi999/XzfeeKMk6dlnn9XMmTP1hz/8QXl5eZ0dEgCgD+qR18AqKyuVnZ2tUaNGadmyZTp+/Hh8W3V1tTIyMuLxkqSioiK5XC7t3r27J4YDAOiFOn0Gdj4lJSWaN2+e8vPzVVdXp8cff1wzZsxQdXW1UlJSFAgElJ2dnTiI1FRlZmYqEAh0+JjhcFjhcDh+OxQKdfewAQCW6faALViwIP7v8ePHa8KECRo5cqQqKys1bdq0Lj1mRUWFVq1a1V1DBAD0Aj1+Gf2IESOUlZWlgwcPSpL8fr+OHTuWsE80GtWJEye+83Wz8vJyBYPB+HL48OGeHjYA4DLX4wE7cuSIjh8/rtzcXElSYWGhmpqaVFNTE99n+/btisViKigo6PAxPB6PvF5vwgIA6Ns6/RRic3Nz/GxKkg4dOqQ9e/YoMzNTmZmZWrVqlebPny+/36+6ujo9+uijuvrqq1VcXCxJGjNmjEpKSrRkyRKtXbtWkUhEZWVlWrBgAVcgAgAuWKfPwD744APdcMMNuuGGGyRJy5cv1w033KAVK1YoJSVFe/fu1U9+8hNde+21Wrx4sSZNmqR//vOf8ng88cd44YUXNHr0aE2bNk0zZ87Urbfeqr/97W/dd1QAgF7PMcaYZA+is0KhkHw+n6ZqjlIdd7KHAwDopKiJqFKbFAwGu/yyEJ+FCACwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArNTtX2gJAOhhjtPxevs+2vaiEDAAsMXZcDkuOa7EiJmYkRT76kbfCBkBA4DL3VfhclJSpJSUr//71XpjjJxIRKY9JpmYTHt7n4gYAQOAy5njnDnjSkmRk+aW088jx+2WPGmS68xlDE4sJnOqVU6kTaYtIrW19YmIETAAuMw5KSly3Kln4jVwgEw/j2L9PTJul5yYkRONndl+Oiw5p2Xa2+VIvT5iBAwALleO8/WZV3o/KcOrSI5PbV63wt9LUbSfI6ddSg0bpR9Ll/u/rUoJpsllYjKtYUmSiUaTfBA9h4ABwOXoq6cOlZIiJ72fnIEDFBni1cnh/XQ6y6VTfqPowJicqKPUU44G/TtNAwIpSk91KeV0qxQzMsZIvfgsjIABwGXszNOHbpl0jyJet04Ncem03yg2rFVZGc063ebWqWaPTp1OlyuSotTTaUrxpEltbXLa2tQ703UGAQOAy5TjcqSUFKmfR7GB/dQ6OFWnrjBKuapZM0d+qv836IC+iHq1v+UKvdU6Xq6oW+5TqfI09JPTGpZJSTlzFqdYrzwLI2AAcLlyXHIcRyY1RTG3S9F+jqKD2pXjbdHkgYd0W7//6ItYo9xOu7Z5r1W0v1vRfi6Z1DNXLZ69SrG36t1HBwA2M4lvTHZikhNz1G4ctcbcajXSqZhb4ZhbsXbXV9u/OtOKxZI06EuHMzAAuIwZY+Rqj8kViSmlzSilxaUToQH6v5ahGuAK64uoV/ta8hRtdsvTKqW0nbmsXsb0+ogRMAC4TJmYkdPeLp1ulSvkVvqxNA383KPTrQP0xqkJ2u67VpFIitpOpmlAnVsDj8SU/mVETstpmXDbV1cg9s7XvyQCBgCXJ3Pmsw1Ne7tMJCKnNay0YJsGNKbKFXXJFfEoPDBNrqiUfsrRgAaj9OPtSm0KS+E2mWj0zEdL9WIEDAAuZ+3tZ96U7Dhy/TdV/d0uuZvT5Al+/UbmlLaY+h9rk/u/rXIFW2RaW6VIpFeffUkEDAAuX8ac+TiotojU3i6nPSZ3a5tS+6WpXz+PjDtFTix25qOkWk5LrWGZ1lbFTrfKRKJfXwTSSxEwALicnY2YiUnhMx8PpXCbXKfDZy6TN+bMPq2tUiQq09b7X/s6i4ABwOXOxGTaFf+UeSclRab1zNepmLNXG7a383UqAIDLzFcxMtHomVA5HbyF1/StL7OUCBgA2MUYybR//e3M/7u+jyFgAGCjPhisb+KjpAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsFKnAlZRUaHJkydr0KBBys7O1ty5c1VbW5uwT2trq0pLSzV48GANHDhQ8+fPV2NjY8I+9fX1mjVrlvr376/s7Gw98sgjikajF380AIA+o1MBq6qqUmlpqXbt2qWtW7cqEolo+vTpamlpie/z4IMP6o033tCrr76qqqoqHT16VPPmzYtvb29v16xZs9TW1qZ3331Xzz//vNavX68VK1Z031EBAHo9xxhjunrnL774QtnZ2aqqqtKUKVMUDAY1ZMgQbdiwQT/96U8lSZ999pnGjBmj6upq3XzzzXrrrbf04x//WEePHlVOTo4kae3atXrsscf0xRdfKC0t7bw/NxQKyefzaarmKNVxd3X4AIAkiZqIKrVJwWBQXq+3S49xUa+BBYNBSVJmZqYkqaamRpFIREVFRfF9Ro8erWHDhqm6ulqSVF1drfHjx8fjJUnFxcUKhULav39/hz8nHA4rFAolLACAvq3LAYvFYnrggQd0yy23aNy4cZKkQCCgtLQ0ZWRkJOybk5OjQCAQ3+d/43V2+9ltHamoqJDP54svQ4cO7eqwAQC9RJcDVlpaqn379umll17qzvF0qLy8XMFgML4cPny4x38mAODyltqVO5WVlWnz5s3asWOHrrzyyvh6v9+vtrY2NTU1JZyFNTY2yu/3x/d57733Eh7v7FWKZ/f5Jo/HI4/H05WhAgB6qU6dgRljVFZWpo0bN2r79u3Kz89P2D5p0iS53W5t27Ytvq62tlb19fUqLCyUJBUWFurjjz/WsWPH4vts3bpVXq9XY8eOvZhjAQD0IZ06AystLdWGDRu0adMmDRo0KP6alc/nU3p6unw+nxYvXqzly5crMzNTXq9X999/vwoLC3XzzTdLkqZPn66xY8fq7rvv1urVqxUIBPTEE0+otLSUsywAwAXr1GX0juN0uH7dunW65557JJ15I/NDDz2kF198UeFwWMXFxXruuecSnh78/PPPtWzZMlVWVmrAgAFatGiRnn76aaWmXlhPuYweAOzWHZfRX9T7wJKFgAGA3ZL+PjAAAJKFgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlToVsIqKCk2ePFmDBg1Sdna25s6dq9ra2oR9pk6dKsdxEpb77rsvYZ/6+nrNmjVL/fv3V3Z2th555BFFo9GLPxoAQJ+R2pmdq6qqVFpaqsmTJysajerxxx/X9OnT9cknn2jAgAHx/ZYsWaJf//rX8dv9+/eP/7u9vV2zZs2S3+/Xu+++q4aGBv385z+X2+3W7373u244JABAX9CpgG3ZsiXh9vr165Wdna2amhpNmTIlvr5///7y+/0dPsY//vEPffLJJ3r77beVk5Oj66+/Xr/5zW/02GOP6amnnlJaWloXDgMA0Ndc1GtgwWBQkpSZmZmw/oUXXlBWVpbGjRun8vJynTp1Kr6turpa48ePV05OTnxdcXGxQqGQ9u/ffzHDAQD0IZ06A/tfsVhMDzzwgG655RaNGzcuvv6uu+7S8OHDlZeXp7179+qxxx5TbW2tXnvtNUlSIBBIiJek+O1AINDhzwqHwwqHw/HboVCoq8MGAPQSXQ5YaWmp9u3bp507dyasX7p0afzf48ePV25urqZNm6a6ujqNHDmySz+roqJCq1at6upQAQC9UJeeQiwrK9PmzZv1zjvv6MorrzznvgUFBZKkgwcPSpL8fr8aGxsT9jl7+7teNysvL1cwGIwvhw8f7sqwAQC9SKcCZoxRWVmZNm7cqO3btys/P/+899mzZ48kKTc3V5JUWFiojz/+WMeOHYvvs3XrVnm9Xo0dO7bDx/B4PPJ6vQkLAKBv69RTiKWlpdqwYYM2bdqkQYMGxV+z8vl8Sk9PV11dnTZs2KCZM2dq8ODB2rt3rx588EFNmTJFEyZMkCRNnz5dY8eO1d13363Vq1crEAjoiSeeUGlpqTweT/cfIQCgV3KMMeaCd3acDtevW7dO99xzjw4fPqyf/exn2rdvn1paWjR06FDdfvvteuKJJxLOmj7//HMtW7ZMlZWVGjBggBYtWqSnn35aqakX1tNQKCSfz6epmqNUx32hwwcAXCaiJqJKbVIwGOzys2qdCtjlIhgMKiMjQ7dqplJFwADANlFFtFNvqqmpST6fr0uP0eWrEJPp5MmTkqSdejPJIwEAXIyTJ092OWBWnoHFYjHV1tZq7NixOnz4MBd1dCAUCmno0KHMzzkwR+fG/Jwfc3Ru55ofY4xOnjypvLw8uVxd+0wNK8/AXC6XrrjiCkniqsTzYH7Ojzk6N+bn/Jijc/uu+enqmddZfJ0KAMBKBAwAYCVrA+bxeLRy5UreO/YdmJ/zY47Ojfk5P+bo3Hp6fqy8iAMAAGvPwAAAfRsBAwBYiYABAKxEwAAAVrIyYGvWrNFVV12lfv36qaCgQO+9916yh5Q0Tz31lBzHSVhGjx4d397a2qrS0lINHjxYAwcO1Pz587/1fWy9yY4dOzR79mzl5eXJcRy9/vrrCduNMVqxYoVyc3OVnp6uoqIiHThwIGGfEydOaOHChfJ6vcrIyNDixYvV3Nx8CY+iZ51vju65555v/U6VlJQk7NOb56iiokKTJ0/WoEGDlJ2drblz56q2tjZhnwv5u6qvr9esWbPUv39/ZWdn65FHHlE0Gr2Uh9IjLmR+pk6d+q3fofvuuy9hn+6YH+sC9vLLL2v58uVauXKlPvzwQ02cOFHFxcUJ3y/W11x33XVqaGiIL//7LdkPPvig3njjDb366quqqqrS0aNHNW/evCSOtme1tLRo4sSJWrNmTYfbV69erWeeeUZr167V7t27NWDAABUXF6u1tTW+z8KFC7V//35t3bpVmzdv1o4dOxK+adx255sjSSopKUn4nXrxxRcTtvfmOaqqqlJpaal27dqlrVu3KhKJaPr06WppaYnvc76/q/b2ds2aNUttbW1699139fzzz2v9+vVasWJFMg6pW13I/EjSkiVLEn6HVq9eHd/WbfNjLHPTTTeZ0tLS+O329naTl5dnKioqkjiq5Fm5cqWZOHFih9uampqM2+02r776anzdp59+aiSZ6urqSzTC5JFkNm7cGL8di8WM3+83v//97+PrmpqajMfjMS+++KIxxphPPvnESDLvv/9+fJ+33nrLOI5j/vOf/1yysV8q35wjY4xZtGiRmTNnznfep6/N0bFjx4wkU1VVZYy5sL+rN99807hcLhMIBOL7/PWvfzVer9eEw+FLewA97JvzY4wxP/jBD8wvf/nL77xPd82PVWdgbW1tqqmpUVFRUXydy+VSUVGRqqurkziy5Dpw4IDy8vI0YsQILVy4UPX19ZKkmpoaRSKRhPkaPXq0hg0b1ifn69ChQwoEAgnz4fP5VFBQEJ+P6upqZWRk6MYbb4zvU1RUJJfLpd27d1/yMSdLZWWlsrOzNWrUKC1btkzHjx+Pb+trcxQMBiVJmZmZki7s76q6ulrjx49XTk5OfJ/i4mKFQiHt37//Eo6+531zfs564YUXlJWVpXHjxqm8vFynTp2Kb+uu+bHqw3y//PJLtbe3Jxy0JOXk5Oizzz5L0qiSq6CgQOvXr9eoUaPU0NCgVatW6bbbbtO+ffsUCASUlpamjIyMhPvk5OTEv027Lzl7zB39/pzdFggElJ2dnbA9NTVVmZmZfWbOSkpKNG/ePOXn56uurk6PP/64ZsyYoerqaqWkpPSpOYrFYnrggQd0yy23aNy4cZJ0QX9XgUCgw9+zs9t6i47mR5LuuusuDR8+XHl5edq7d68ee+wx1dbW6rXXXpPUffNjVcDwbTNmzIj/e8KECSooKNDw4cP1yiuvKD09PYkjg60WLFgQ//f48eM1YcIEjRw5UpWVlZo2bVoSR3bplZaWat++fQmvK+Nr3zU///t66Pjx45Wbm6tp06aprq5OI0eO7Lafb9VTiFlZWUpJSfnW1T6NjY3y+/1JGtXlJSMjQ9dee60OHjwov9+vtrY2NTU1JezTV+fr7DGf6/fH7/d/64KgaDSqEydO9Mk5k6QRI0YoKytLBw8elNR35qisrEybN2/WO++8oyuvvDK+/kL+rvx+f4e/Z2e39QbfNT8dKSgokKSE36HumB+rApaWlqZJkyZp27Zt8XWxWEzbtm1TYWFhEkd2+WhublZdXZ1yc3M1adIkud3uhPmqra1VfX19n5yv/Px8+f3+hPkIhULavXt3fD4KCwvV1NSkmpqa+D7bt29XLBaL/xH2NUeOHNHx48eVm5srqffPkTFGZWVl2rhxo7Zv3678/PyE7Rfyd1VYWKiPP/44IfRbt26V1+vV2LFjL82B9JDzzU9H9uzZI0kJv0PdMj9duOgkqV566SXj8XjM+vXrzSeffGKWLl1qMjIyEq5m6UseeughU1lZaQ4dOmT+9a9/maKiIpOVlWWOHTtmjDHmvvvuM8OGDTPbt283H3zwgSksLDSFhYVJHnXPOXnypPnoo4/MRx99ZCSZP/7xj+ajjz4yn3/+uTHGmKefftpkZGSYTZs2mb1795o5c+aY/Px8c/r06fhjlJSUmBtuuMHs3r3b7Ny501xzzTXmzjvvTNYhdbtzzdHJkyfNww8/bKqrq82hQ4fM22+/bb7//e+ba665xrS2tsYfozfP0bJly4zP5zOVlZWmoaEhvpw6dSq+z/n+rqLRqBk3bpyZPn262bNnj9myZYsZMmSIKS8vT8Yhdavzzc/BgwfNr3/9a/PBBx+YQ4cOmU2bNpkRI0aYKVOmxB+ju+bHuoAZY8yzzz5rhg0bZtLS0sxNN91kdu3alewhJc0dd9xhcnNzTVpamrniiivMHXfcYQ4ePBjffvr0afOLX/zCfO973zP9+/c3t99+u2loaEjiiHvWO++8YyR9a1m0aJEx5syl9E8++aTJyckxHo/HTJs2zdTW1iY8xvHjx82dd95pBg4caLxer7n33nvNyZMnk3A0PeNcc3Tq1Ckzffp0M2TIEON2u83w4cPNkiVLvvU/iL15jjqaG0lm3bp18X0u5O/q3//+t5kxY4ZJT083WVlZ5qGHHjKRSOQSH033O9/81NfXmylTppjMzEzj8XjM1VdfbR555BETDAYTHqc75oevUwEAWMmq18AAADiLgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACv9fzL9WqqHIcFYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAGiCAYAAACGUJO6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiBklEQVR4nO3df3CU9YHH8c+zu9klgeymISSbyI8GqyDyox5izGipd2RIgHpa6IxYrsUOAyNNnFPUenEsSO+mcWjn2rFHj7mZjvQPsa0zRUbGMkfBQD0XlFQOQc2YDDVBskHhspsE8mOz3/sDeNrVCCQkLN/k/Zp5JPs8z26+z3eSefvsPrtxjDFGAABYxpPuAQAAMBgEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgpbQFbPPmzfryl7+sMWPGqKSkRG+99Va6hgIAsFBaAvbb3/5W69at04YNG/TnP/9Zc+bMUXl5uU6dOpWO4QAALOSk48N8S0pKNG/ePP3Hf/yHJCmZTGrSpEl65JFH9C//8i/XejgAAAv5rvU37OnpUV1dnaqrq911Ho9HZWVlikQi/d6nu7tb3d3d7u1kMqkzZ85o/Pjxchxn2McMABhaxhi1t7erqKhIHs/gngy85gH79NNP1dfXp4KCgpT1BQUF+uCDD/q9T01NjTZu3HgthgcAuIaam5s1ceLEQd33mgdsMKqrq7Vu3Tr3diwW0+TJk3W3FsunjDSODAAwGAn16g29puzs7EE/xjUPWF5enrxer1pbW1PWt7a2KhwO93ufQCCgQCDwufU+ZcjnEDAAsM6Fqy+u5mWga34Vot/v19y5c7Vnzx53XTKZ1J49e1RaWnqthwMAsFRankJct26dVq5cqdtvv1133HGHfv7zn6uzs1Pf+9730jEcAICF0hKwBx54QJ988onWr1+vaDSqr371q9q1a9fnLuwAAOCLpOV9YFcrHo8rFArpHt3Ha2AAYKGE6VWtdigWiykYDA7qMfgsRACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFhpyAP27LPPynGclGX69Onu9q6uLlVWVmr8+PEaN26cli1bptbW1qEeBgBghBuWM7Bbb71VLS0t7vLGG2+42x577DG9+uqrevnll7Vv3z6dPHlSS5cuHY5hAABGMN+wPKjPp3A4/Ln1sVhMv/rVr7Rt2zb9wz/8gyTphRde0C233KIDBw7ozjvvHI7hAABGoGE5A/vwww9VVFSkqVOnasWKFWpqapIk1dXVqbe3V2VlZe6+06dP1+TJkxWJRIZjKACAEWrIz8BKSkq0detWTZs2TS0tLdq4caO+9rWv6ejRo4pGo/L7/crJyUm5T0FBgaLR6Bc+Znd3t7q7u93b8Xh8qIcNALDMkAds0aJF7tezZ89WSUmJpkyZot/97nfKzMwc1GPW1NRo48aNQzVEAMAIMOyX0efk5Ojmm29WQ0ODwuGwenp61NbWlrJPa2trv6+ZXVRdXa1YLOYuzc3NwzxqAMD1btgD1tHRocbGRhUWFmru3LnKyMjQnj173O319fVqampSaWnpFz5GIBBQMBhMWQAAo9uQP4X4xBNP6N5779WUKVN08uRJbdiwQV6vVw8++KBCoZBWrVqldevWKTc3V8FgUI888ohKS0u5AhEAMCBDHrATJ07owQcf1OnTpzVhwgTdfffdOnDggCZMmCBJ+tnPfiaPx6Nly5apu7tb5eXl+uUvfznUwwAAjHCOMcakexADFY/HFQqFdI/uk8/JSPdwAAADlDC9qtUOxWKxQb8sxGchAgCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgpQEHbP/+/br33ntVVFQkx3H0yiuvpGw3xmj9+vUqLCxUZmamysrK9OGHH6bsc+bMGa1YsULBYFA5OTlatWqVOjo6rupAAACjy4AD1tnZqTlz5mjz5s39bt+0aZOef/55bdmyRQcPHtTYsWNVXl6urq4ud58VK1bo2LFj2r17t3bu3Kn9+/drzZo1gz8KAMCo4xhjzKDv7Djavn277r//fknnz76Kior0+OOP64knnpAkxWIxFRQUaOvWrVq+fLnef/99zZgxQ2+//bZuv/12SdKuXbu0ePFinThxQkVFRZf9vvF4XKFQSPfoPvmcjMEOHwCQJgnTq1rtUCwWUzAYHNRjDOlrYMePH1c0GlVZWZm7LhQKqaSkRJFIRJIUiUSUk5PjxkuSysrK5PF4dPDgwX4ft7u7W/F4PGUBAIxuQxqwaDQqSSooKEhZX1BQ4G6LRqPKz89P2e7z+ZSbm+vu81k1NTUKhULuMmnSpKEcNgDAQlZchVhdXa1YLOYuzc3N6R4SACDNhjRg4XBYktTa2pqyvrW11d0WDod16tSplO2JREJnzpxx9/msQCCgYDCYsgAARrchDVhxcbHC4bD27NnjrovH4zp48KBKS0slSaWlpWpra1NdXZ27z969e5VMJlVSUjKUwwEAjGC+gd6ho6NDDQ0N7u3jx4/r8OHDys3N1eTJk/Xoo4/q3/7t33TTTTepuLhYP/zhD1VUVOReqXjLLbeooqJCq1ev1pYtW9Tb26uqqiotX778iq5ABABAGkTADh06pL//+793b69bt06StHLlSm3dulU/+MEP1NnZqTVr1qitrU133323du3apTFjxrj3efHFF1VVVaUFCxbI4/Fo2bJlev7554fgcAAAo8VVvQ8sXXgfGADY7bp7HxgAANcKAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKw04YPv379e9996roqIiOY6jV155JWX7Qw89JMdxUpaKioqUfc6cOaMVK1YoGAwqJydHq1atUkdHx1UdCABgdBlwwDo7OzVnzhxt3rz5C/epqKhQS0uLu7z00ksp21esWKFjx45p9+7d2rlzp/bv3681a9YMfPQAgFHLN9A7LFq0SIsWLbrkPoFAQOFwuN9t77//vnbt2qW3335bt99+uyTpF7/4hRYvXqyf/vSnKioqGuiQAACj0LC8BlZbW6v8/HxNmzZNa9eu1enTp91tkUhEOTk5brwkqaysTB6PRwcPHhyO4QAARqABn4FdTkVFhZYuXari4mI1Njbq6aef1qJFixSJROT1ehWNRpWfn586CJ9Pubm5ikaj/T5md3e3uru73dvxeHyohw0AsMyQB2z58uXu17NmzdLs2bN14403qra2VgsWLBjUY9bU1Gjjxo1DNUQAwAgw7JfRT506VXl5eWpoaJAkhcNhnTp1KmWfRCKhM2fOfOHrZtXV1YrFYu7S3Nw83MMGAFznhj1gJ06c0OnTp1VYWChJKi0tVVtbm+rq6tx99u7dq2QyqZKSkn4fIxAIKBgMpiwAgNFtwE8hdnR0uGdTknT8+HEdPnxYubm5ys3N1caNG7Vs2TKFw2E1NjbqBz/4gb7yla+ovLxcknTLLbeooqJCq1ev1pYtW9Tb26uqqiotX76cKxABAFdswGdghw4d0m233abbbrtNkrRu3TrddtttWr9+vbxer44cOaJ//Md/1M0336xVq1Zp7ty5+tOf/qRAIOA+xosvvqjp06drwYIFWrx4se6++27913/919AdFQBgxHOMMSbdgxioeDyuUCike3SffE5GuocDABighOlVrXYoFosN+mUhPgsRAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJV86R4AAOAacpwL/37m/MUkL/xrru14rgIBA4DRwHEkxyPHc+Ff718DZoyRkkYySZmkkZJ9aRzolSNgADDSXYyX1ysnwyd5vecDduEszDFJmd6ETCIhR30yxrHiTIyAAcBI5jjnw+XzyfH75YzNkgJ+mYBfJsMnJ5mUEn3ynO2S6eqSenqVPNcl09d3/mnF6zhkBAwARqqLZ14+n5wxATnjximZm62+cQH1Zmco6ffISRp5eo38p8/JEz8np+OsnL4+qUcyfbrwn+sTAQOAEczxes+feY0ZI5OdpZ68serJ8enclzzqy3TkJIy83dJYr6OA1yOvJKerW7pwBnY9P51IwABgJHL+erGGk5UpExynnnC22m7y61y+o3NFCXlDPerr9srp9KmnIUPjPvYoy++Vv6vnfLzOmfMhu04RMAAYoRyPI3m9UsCv5Ngx6srNUGeRo+6JPZpW3KJbQy36pGecmtpzdaI7LE+vV75zfmW0+qVzPjler4zjuW6fRiRgADCCOV6v5PUqOcanRKaj3lBSwfGdKhn/F80f94E+7v2S/tc/WR99KU+92X4lsjxShk+Ozydz8T1j1ykCBgAjkXPhMnmPI+Pzyvg8SoxxlBzXqxtCMd0xtlF3j+nSCd9f5HWMXsu+VYlMvxIBRybDK8dxJM+F94o51+frYAQMAEYik5SMIyWNnESfnERSvi4jT4dPH8dCOpQ7VWOcen3cW6j/7ZysrvaAxp6TfN1GTuLC5fPJ6/vTOQgYAIxgpq9PTl+fPD0J+c4ZZcS8ip8Zq0iwWB19AX3aM05/ac+V9/98ymiXfOeS0oU3NV+v4bqIgAHACGWS5vx7urp75Gnv0pgzAY096ZEn4Vd99w1qCE1wr0LMbvYo61Sf/P/XI+dct0wi8dc3M1+nCBgAjETGSErK9CVlzp6TI8nv9SjH4yjzU5+6TnqVyMqSJ2Hk7ZLGRnsVON0l7/91ynR0ylx8L9h1jIABwAhm+vrOPx3Y1SWn3Sf/pz55z/mV0elXX8CRJ3HhkzjOdLmfxJHs6TkfvqS5rp9GJGAAMFJdPAvr6Tl/QUbSyNPXJ0/AL9/pv/ksxL6knM5zMl1dMj2955fr/OlDiYABwMhmzPmzsKSR05eUk0i4n0bvXPybYCap5MULN/r6LsTr+j3zuoiAAcBI574epvNnVY5HutTfA7MgXhIBA4DRwRjJXPhbX+qT6eMvMgMAbHIxUNfp5xsOhOfyuwAAcP0hYAAAKxEwAICVBhSwmpoazZs3T9nZ2crPz9f999+v+vr6lH26urpUWVmp8ePHa9y4cVq2bJlaW1tT9mlqatKSJUuUlZWl/Px8Pfnkk0okEld/NACAUWNAAdu3b58qKyt14MAB7d69W729vVq4cKE6OzvdfR577DG9+uqrevnll7Vv3z6dPHlSS5cudbf39fVpyZIl6unp0Ztvvqlf//rX2rp1q9avXz90RwUAGPEcYwZ/zeQnn3yi/Px87du3T/Pnz1csFtOECRO0bds2fetb35IkffDBB7rlllsUiUR055136g9/+IO+8Y1v6OTJkyooKJAkbdmyRU899ZQ++eQT+f3+y37feDyuUCike3SffE7GYIcPAEiThOlVrXYoFospGAwO6jGu6jWwWCwmScrNzZUk1dXVqbe3V2VlZe4+06dP1+TJkxWJRCRJkUhEs2bNcuMlSeXl5YrH4zp27Fi/36e7u1vxeDxlAQCMboMOWDKZ1KOPPqq77rpLM2fOlCRFo1H5/X7l5OSk7FtQUKBoNOru87fxurj94rb+1NTUKBQKucukSZMGO2wAwAgx6IBVVlbq6NGj+s1vfjOU4+lXdXW1YrGYuzQ3Nw/79wQAXN8G9UkcVVVV2rlzp/bv36+JEye668PhsHp6etTW1pZyFtba2qpwOOzu89Zbb6U83sWrFC/u81mBQECBQGAwQwUAjFADOgMzxqiqqkrbt2/X3r17VVxcnLJ97ty5ysjI0J49e9x19fX1ampqUmlpqSSptLRU7777rk6dOuXus3v3bgWDQc2YMeNqjgUAMIoM6AyssrJS27Zt044dO5Sdne2+ZhUKhZSZmalQKKRVq1Zp3bp1ys3NVTAY1COPPKLS0lLdeeedkqSFCxdqxowZ+s53vqNNmzYpGo3qmWeeUWVlJWdZAIArNqDL6B3H6Xf9Cy+8oIceekjS+TcyP/7443rppZfU3d2t8vJy/fKXv0x5evCjjz7S2rVrVVtbq7Fjx2rlypV67rnn5PNdWU+5jB4A7DYUl9Ff1fvA0oWAAYDd0v4+MAAA0oWAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVBhSwmpoazZs3T9nZ2crPz9f999+v+vr6lH3uueceOY6Tsjz88MMp+zQ1NWnJkiXKyspSfn6+nnzySSUSias/GgDAqOEbyM779u1TZWWl5s2bp0QioaeffloLFy7Ue++9p7Fjx7r7rV69Wj/60Y/c21lZWe7XfX19WrJkicLhsN588021tLTou9/9rjIyMvTjH/94CA4JADAaDChgu3btSrm9detW5efnq66uTvPnz3fXZ2VlKRwO9/sY//3f/6333ntPf/zjH1VQUKCvfvWr+td//Vc99dRTevbZZ+X3+wdxGACA0eaqXgOLxWKSpNzc3JT1L774ovLy8jRz5kxVV1fr7Nmz7rZIJKJZs2apoKDAXVdeXq54PK5jx45dzXAAAKPIgM7A/lYymdSjjz6qu+66SzNnznTXf/vb39aUKVNUVFSkI0eO6KmnnlJ9fb1+//vfS5Ki0WhKvCS5t6PRaL/fq7u7W93d3e7teDw+2GEDAEaIQQessrJSR48e1RtvvJGyfs2aNe7Xs2bNUmFhoRYsWKDGxkbdeOONg/peNTU12rhx42CHCgAYgQb1FGJVVZV27typ119/XRMnTrzkviUlJZKkhoYGSVI4HFZra2vKPhdvf9HrZtXV1YrFYu7S3Nw8mGEDAEaQAQXMGKOqqipt375de/fuVXFx8WXvc/jwYUlSYWGhJKm0tFTvvvuuTp065e6ze/duBYNBzZgxo9/HCAQCCgaDKQsAYHQb0FOIlZWV2rZtm3bs2KHs7Gz3NatQKKTMzEw1NjZq27ZtWrx4scaPH68jR47oscce0/z58zV79mxJ0sKFCzVjxgx95zvf0aZNmxSNRvXMM8+osrJSgUBg6I8QADAiOcYYc8U7O06/61944QU99NBDam5u1j/90z/p6NGj6uzs1KRJk/TNb35TzzzzTMpZ00cffaS1a9eqtrZWY8eO1cqVK/Xcc8/J57uynsbjcYVCId2j++RzMq50+ACA60TC9KpWOxSLxQb9rNqAAna9iMViysnJ0d1aLJ8IGADYJqFevaHX1NbWplAoNKjHGPRViOnU3t4uSXpDr6V5JACAq9He3j7ogFl5BpZMJlVfX68ZM2aoubmZizr6EY/HNWnSJObnEpijS2N+Lo85urRLzY8xRu3t7SoqKpLHM7jP1LDyDMzj8eiGG26QJK5KvAzm5/KYo0tjfi6PObq0L5qfwZ55XcSfUwEAWImAAQCsZG3AAoGANmzYwHvHvgDzc3nM0aUxP5fHHF3acM+PlRdxAABg7RkYAGB0I2AAACsRMACAlQgYAMBKVgZs8+bN+vKXv6wxY8aopKREb731VrqHlDbPPvusHMdJWaZPn+5u7+rqUmVlpcaPH69x48Zp2bJln/t7bCPJ/v37de+996qoqEiO4+iVV15J2W6M0fr161VYWKjMzEyVlZXpww8/TNnnzJkzWrFihYLBoHJycrRq1Sp1dHRcw6MYXpebo4ceeuhzP1MVFRUp+4zkOaqpqdG8efOUnZ2t/Px83X///aqvr0/Z50p+r5qamrRkyRJlZWUpPz9fTz75pBKJxLU8lGFxJfNzzz33fO5n6OGHH07ZZyjmx7qA/fa3v9W6deu0YcMG/fnPf9acOXNUXl6e8vfFRptbb71VLS0t7vK3fyX7scce06uvvqqXX35Z+/bt08mTJ7V06dI0jnZ4dXZ2as6cOdq8eXO/2zdt2qTnn39eW7Zs0cGDBzV27FiVl5erq6vL3WfFihU6duyYdu/erZ07d2r//v0pf2ncdpebI0mqqKhI+Zl66aWXUraP5Dnat2+fKisrdeDAAe3evVu9vb1auHChOjs73X0u93vV19enJUuWqKenR2+++aZ+/etfa+vWrVq/fn06DmlIXcn8SNLq1atTfoY2bdrkbhuy+TGWueOOO0xlZaV7u6+vzxQVFZmampo0jip9NmzYYObMmdPvtra2NpORkWFefvlld937779vJJlIJHKNRpg+ksz27dvd28lk0oTDYfOTn/zEXdfW1mYCgYB56aWXjDHGvPfee0aSefvtt919/vCHPxjHcczHH398zcZ+rXx2jowxZuXKlea+++77wvuMtjk6deqUkWT27dtnjLmy36vXXnvNeDweE41G3X3+8z//0wSDQdPd3X1tD2CYfXZ+jDHm61//uvnnf/7nL7zPUM2PVWdgPT09qqurU1lZmbvO4/GorKxMkUgkjSNLrw8//FBFRUWaOnWqVqxYoaamJklSXV2dent7U+Zr+vTpmjx58qicr+PHjysajabMRygUUklJiTsfkUhEOTk5uv322919ysrK5PF4dPDgwWs+5nSpra1Vfn6+pk2bprVr1+r06dPuttE2R7FYTJKUm5sr6cp+ryKRiGbNmqWCggJ3n/LycsXjcR07duwajn74fXZ+LnrxxReVl5enmTNnqrq6WmfPnnW3DdX8WPVhvp9++qn6+vpSDlqSCgoK9MEHH6RpVOlVUlKirVu3atq0aWppadHGjRv1ta99TUePHlU0GpXf71dOTk7KfQoKCty/pj2aXDzm/n5+Lm6LRqPKz89P2e7z+ZSbmztq5qyiokJLly5VcXGxGhsb9fTTT2vRokWKRCLyer2jao6SyaQeffRR3XXXXZo5c6YkXdHvVTQa7ffn7OK2kaK/+ZGkb3/725oyZYqKiop05MgRPfXUU6qvr9fvf/97SUM3P1YFDJ+3aNEi9+vZs2erpKREU6ZM0e9+9ztlZmamcWSw1fLly92vZ82apdmzZ+vGG29UbW2tFixYkMaRXXuVlZU6evRoyuvK+Ksvmp+/fT101qxZKiws1IIFC9TY2Kgbb7xxyL6/VU8h5uXlyev1fu5qn9bWVoXD4TSN6vqSk5Ojm2++WQ0NDQqHw+rp6VFbW1vKPqN1vi4e86V+fsLh8OcuCEokEjpz5syonDNJmjp1qvLy8tTQ0CBp9MxRVVWVdu7cqddff10TJ05011/J71U4HO735+zitpHgi+anPyUlJZKU8jM0FPNjVcD8fr/mzp2rPXv2uOuSyaT27Nmj0tLSNI7s+tHR0aHGxkYVFhZq7ty5ysjISJmv+vp6NTU1jcr5Ki4uVjgcTpmPeDyugwcPuvNRWlqqtrY21dXVufvs3btXyWTS/SUcbU6cOKHTp0+rsLBQ0sifI2OMqqqqtH37du3du1fFxcUp26/k96q0tFTvvvtuSuh3796tYDCoGTNmXJsDGSaXm5/+HD58WJJSfoaGZH4GcdFJWv3mN78xgUDAbN261bz33ntmzZo1JicnJ+VqltHk8ccfN7W1teb48ePmf/7nf0xZWZnJy8szp06dMsYY8/DDD5vJkyebvXv3mkOHDpnS0lJTWlqa5lEPn/b2dvPOO++Yd955x0gy//7v/27eeecd89FHHxljjHnuuedMTk6O2bFjhzly5Ii57777THFxsTl37pz7GBUVFea2224zBw8eNG+88Ya56aabzIMPPpiuQxpyl5qj9vZ288QTT5hIJGKOHz9u/vjHP5q/+7u/MzfddJPp6upyH2Mkz9HatWtNKBQytbW1pqWlxV3Onj3r7nO536tEImFmzpxpFi5caA4fPmx27dplJkyYYKqrq9NxSEPqcvPT0NBgfvSjH5lDhw6Z48ePmx07dpipU6ea+fPnu48xVPNjXcCMMeYXv/iFmTx5svH7/eaOO+4wBw4cSPeQ0uaBBx4whYWFxu/3mxtuuME88MADpqGhwd1+7tw58/3vf9986UtfMllZWeab3/ymaWlpSeOIh9frr79uJH1uWblypTHm/KX0P/zhD01BQYEJBAJmwYIFpr6+PuUxTp8+bR588EEzbtw4EwwGzfe+9z3T3t6ehqMZHpeao7Nnz5qFCxeaCRMmmIyMDDNlyhSzevXqz/0P4kieo/7mRpJ54YUX3H2u5PfqL3/5i1m0aJHJzMw0eXl55vHHHze9vb3X+GiG3uXmp6mpycyfP9/k5uaaQCBgvvKVr5gnn3zSxGKxlMcZivnhz6kAAKxk1WtgAABcRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICV/h8/Z13nZN5emQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(heatmaps[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f238c110-8e4f-4865-bc1c-f8aef0127ef3", + "metadata": {}, + "outputs": [ + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGfCAYAAAAZGgYhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAApPUlEQVR4nO3df4xc1X338c+d/TF2sHeWNWbXLl7iiASTIDvKBswqpCWwjWVFCNeL5EZIdVOUKHRtYTtVi6UGglRprSCFhBRI1KagSnHduKnJ41QhRRu8PCRr116wMKRYEFnxVvasoU93dr2wsz/mPH84HnXx3jM7586dc2f3/ZKuZM+dc8+5Z+7Md+/M935vYIwxAgCgylK+BwAAWJwIQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC/q49rwk08+qccee0zZbFYbNmzQd7/7Xd16660l2xUKBZ07d07Lly9XEARxDQ8AEBNjjMbGxrR69WqlUpbzHBODAwcOmMbGRvMP//AP5o033jBf/vKXTXNzsxkeHi7ZdmhoyEhiYWFhYanxZWhoyPp5HxhT+WKkGzdu1C233KK//du/lXTprGbNmjXauXOnHnroIWvbXC6n5uZm/faVD6tp2ZWR88tnbw9te/S1G0LX3fDD90PX1f+/i9YxmZHR0HWFi+9ZGhYsq8KnPdUYfmJqpmfC+wtsf2mEj8XaTpKZsfTpKKirc2uYspwVW+Y0yj4EDZbXY2raebvhG3V/rYCKsxyPYe/jaTOl/zvzfzQyMqJMJhPavuJfwU1OTmpwcFB79+4tPpZKpdTV1aWBgYErnp/P55XP54v/HxsbkyQ1LUupafmVb7aGqxpD+04tXRK6rr4+/MOpPjUVuk6STBDeZyGwtbUEoMASgIIGSzvLB571wylCAIrhQy8IHAOQ7WtZy5xG2YcgsASgWL4mJgAhSSwBqMT7uNTPKBU/mt99913NzMyotbV11uOtra3KZrNXPL+3t1eZTKa4rFmzptJDAgAkkPc/p/bu3atcLldchoaGfA8JAFAFFf8K7pprrlFdXZ2Gh4dnPT48PKy2trYrnp9Op5VOpys9DABAwlU8ADU2Nqqjo0N9fX3asmWLpEtJCH19fdqxY8e8t9P3Xr2umuMHrjfeuTKIXZZ+x3F38pP29Y2W32Ri+IHeTIf/zmPtz/a7km0fLP3FxpagYdlH1+SFwJa8IHtSiC3RoNR2XfpzTSaxzY21vwhs++/cJ/tY+f4kqWB5X9Vbfues/EdcUSzXAe3Zs0fbt2/Xpz/9ad1666369re/rfHxcX3pS1+KozsAQA2KJQBt27ZN77zzjh5++GFls1l98pOf1PPPP39FYgIAYPGKrRLCjh07yvrKDQCwuHjPggMALE4EIACAFwQgAIAXsf0GFNXXTmxT6kNXltZZcmppaJtl74SnKNaNTYSuM++F14mTJPO+fX2YWNI3LSm61v4ipFrHkmps688xDdV1nKXaWlO0beOxpow75rY6luKJkoZedTHto43zser83oihvFWp11iu5a/iO0/hDAgA4AUBCADgBQEIAOAFAQgA4AUBCADgBQEIAOBFYtOwr3k+rfqGK2/TsPRCfo5nX5LOjoWuCy6Gp1IXSqVZpxzjtDV9MYYq2jGlksaR+hzHWBOVSqwSlctjuO22df9t/UXo06rKtxb38frHdVnAYsEZEADACwIQAMALAhAAwAsCEADACwIQAMALAhAAwIvEpmFf/ash1aeuTMO2pUSbifAU7cJ774V3ViLN2kxOhq6zplpa0lBdUzR9pHbWylh9zI1rGq6tGrK1inapdOpQjpWQI7BXA4+hvxqqhk2K9iWcAQEAvCAAAQC8IAABALwgAAEAvCAAAQC8IAABALwgAAEAvEjsdUBmIi+TmiM335Kvb7tex0xOWTpzvbYiynUgtdGuVFtX1b6tgo99dGY5HuN4/aO0XQjtoqj6WG3XFqY/FN5Okqanw9dZx+P++VgKZ0AAAC8IQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvEpuGXRgbVyGYI63alqI4MxPPYAJL6XzHFMVql3GPkoa6GG6rUO303lpp56NPa7sY3ou++nRiGUukz78Il6JEwRkQAMALAhAAwAsCEADACwIQAMALAhAAwAsCEADAi8SmYZvpKZk5MiODurrwNpY0RGu7kpWQ3dIbq13xF9WXpNfDeoxPW6rBS/b03gSxpT3H9Vq49lntywmMse+/mQqvhu2rynhtHHUAgAWHAAQA8IIABADwggAEAPCCAAQA8IIABADwIrFp2ApS5aeGOqaSJq36chzt4lLtNNS40td9paFWlK2icYn3RqL2w1GUfbAeH9a5s1yi4drOUVBv/zi3pulPznHngcvtYjw2OAMCAHhBAAIAeEEAAgB4QQACAHhBAAIAeEEAAgB4kdw0bFOQNEdaadBgaRSe2hilUi7Vqd24zo2PlGDXsSapqnlc8xbHPiapXUm29HbXdtZthqdLW7ubtFc8t94toMLHaqnK3JdxBgQA8IIABADwggAEAPCCAAQA8IIABADwggAEAPCi7AD00ksv6e6779bq1asVBIGee+65WeuNMXr44Ye1atUqLV26VF1dXXrrrbfKH9nlatgfXEwhfLFuLnBeXLcbBx/jrJW5CT1m5lElvdr7GMexaNv/BXOMO+5j4kQ4VkPZPhtNIZb5ibrNsvd2fHxcGzZs0JNPPjnn+m9+85t64okn9L3vfU/Hjh3TVVddpU2bNmliYqLcrgAAC1jZF6Ju3rxZmzdvnnOdMUbf/va39dd//de65557JEn/+I//qNbWVj333HP64z/+42ijBQAsGBX9DejMmTPKZrPq6uoqPpbJZLRx40YNDAzM2Safz2t0dHTWAgBY+CoagLLZrCSptbV11uOtra3FdR/U29urTCZTXNasWVPJIQEAEsp7FtzevXuVy+WKy9DQkO8hAQCqoKIBqK2tTZI0PDw86/Hh4eHiug9Kp9NqamqatQAAFr6KVsNeu3at2tra1NfXp09+8pOSpNHRUR07dkwPPPBAeRsLqYZtCpU/aYtUmdiW/h0lpTKsO0tFW1t/1nal+rTNuWX/XdtZqwFbKwzXThXtais1Ti9Vpp36sx1v1R1nrUni/JQdgC5evKi33367+P8zZ87o5MmTamlpUXt7u3bt2qW/+Zu/0Uc/+lGtXbtWX//617V69Wpt2bKlkuMGANS4sgPQiRMn9LnPfa74/z179kiStm/frmeffVZ/+Zd/qfHxcX3lK1/RyMiIbr/9dj3//PNasmRJ5UYNAKh5gZnvnYOqZHR0VJlMRncEW1Q/183nHL/WqvQNl/5XY1un7tutdH+uN9WKsl3HdkFd+Fdw1ptq2drF9BVUkrjOm5SsG8T5uCFdrYy1VvZx2kzpxekfK5fLWX/X954FBwBYnAhAAAAvCEAAAC8qmoZdUSGVYeNIF4y2TbffHdz7dOwvtt9Hwv+GcW1n/e0osIzV+pubexq6TaLSe22/q0WseJyYdpbX2Jai7YVtrJYrDeybdN/HRB2rv8MZEADACwIQAMALAhAAwAsCEADACwIQAMALAhAAwIvkpmE7qJWSKVJMY7VVpo6QhRxHBXLnqtax7aPb61ErpVh8VMOOp53t9XerFP+7Ti0rHXOmrZXia6cUT5w4AwIAeEEAAgB4QQACAHhBAAIAeEEAAgB4QQACAHhBAAIAeFFz1wHFkcse5ZqcRF0/YbsOJsLtuqt+u2rH2yok7ToY1/6c28V0q4JqXyPiuo+2W3WUvkamun+LO+9jhNuKcDsGAAB+hwAEAPCCAAQA8IIABADwggAEAPCCAAQA8CK5adimIGmO1FFLiqKPcuNxlPG3trOVnLd36NZOEVKtbWnBjhXuS5bVD21W/de/+pcFLIwUXdfbMdQSH/uYxNvVcAYEAPCCAAQA8IIABADwggAEAPCCAAQA8IIABADwIrFp2EFdnYI5cnV9VCaOpap1XXgesi3VutrtpFIVuC1tU+GHl5myzY11OOEiVPy2bzZB1aCTJoYK3LVU8bva7aLwcbeAUjgDAgB4QQACAHhBAAIAeEEAAgB4QQACAHhBAAIAeJHYNOwwtnTiKKm2sbCNx1Q3DdOaSmnsaZbOaZjVrtwdU8Vv51T7GmkXrc/wOY8jfde1Py+XWlQ51TrKfFc6RduU+Ey5jDMgAIAXBCAAgBcEIACAFwQgAIAXBCAAgBcEIACAFzWXhm1NtbVUynWtFH2JYzqxjbVy85SlXYNlo5Z9tKaSWjZZqu20Jd0yjn20tZNrGe3aqWrsWik6yjEcxz46p4zX0D5WW5IqbAcmkOZxVQRnQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC8Sm4ZtCkYmKK+6q61SrjVFsVQesnW9W+qvLS3ceSzWFFWLIEL6ZsqxOrk1Rdsx1T6G6suXukxONWTXytTx9Vnl1N+YKt7HcewkrcJ2NfeRatgAgEQjAAEAvCAAAQC8IAABALwgAAEAvCAAAQC8KCsA9fb26pZbbtHy5ct17bXXasuWLTp9+vSs50xMTKinp0crVqzQsmXL1N3dreHh4bIHFqSCOZcSjUIXUzChi61dydRmx3ZBXV3o4tyfKYQvdXXhSymufbrOqXUocx8XcS6u47Htfyz9RZi3ONTKnHrZjxjaRdkPX2Mt65Ogv79fPT09Onr0qF544QVNTU3p85//vMbHx4vP2b17tw4fPqyDBw+qv79f586d09atW8vpBgCwCARmvlcMzeGdd97Rtddeq/7+fv3+7/++crmcVq5cqf379+vee++VJL355pu66aabNDAwoNtuu63kNkdHR5XJZPS5+m7Vz3FfGOtFWpa/5qPcD8hMh9+DJqgPv3dNoto1Noa3m5wMXRepT1s72+sR01/kVed6sW3CJOpC1JjmNGkXjSaJyz5Omym9OP1j5XI5NTU1hbaP9BtQLpeTJLW0tEiSBgcHNTU1pa6uruJz1q1bp/b2dg0MDMy5jXw+r9HR0VkLAGDhcw5AhUJBu3bt0mc+8xndfPPNkqRsNqvGxkY1NzfPem5ra6uy2eyc2+nt7VUmkykua9ascR0SAKCGOAegnp4evf766zpw4ECkAezdu1e5XK64DA0NRdoeAKA2OBUj3bFjh37605/qpZde0nXXXVd8vK2tTZOTkxoZGZl1FjQ8PKy2trY5t5VOp5VOp12GAQCoYWUFIGOMdu7cqUOHDunIkSNau3btrPUdHR1qaGhQX1+furu7JUmnT5/W2bNn1dnZWZEBO/+wZ/mB0pQqTG3L07D98Glp51oN27nd1HT4ylJp0a7VqR0TDeKqau3K/UdoyzFX5R+9S81pHD+Yx7OPlZ/TuMQxnqS9N6JWwy4rAPX09Gj//v36yU9+ouXLlxd/18lkMlq6dKkymYzuv/9+7dmzRy0tLWpqatLOnTvV2dk5rww4AMDiUVYAevrppyVJd9xxx6zHn3nmGf3pn/6pJOnxxx9XKpVSd3e38vm8Nm3apKeeeqoigwUALByRrgOKQ6nrgKxsXwdZrlcp+RVUwfJVUn14DDfTlq+9EnQjt1Li+LpscXwFVxvtfPSZpHZx9WmzUL6CCzNtpnSk8K/xXgcEAIArAhAAwAsCEADACwIQAMALpwtRfbJeW1LvFk9LFiO1JCG4/rhvLZw6ZdvHGNrZEjQkyZYMYizFSG37WOVrJKL8CG3jOtZqt4ui2n0ulCKeNq7Hqo9EE5dtBiaQ5lEbljMgAIAXBCAAgBcEIACAFwQgAIAXBCAAgBcEIACAFzWXhh3HPeFL3uIgsKSFWuuvWdIebX1WvT/73yGubV1TO+OodxVXDa1aqnfmqtp91tJtFVz5eI3jOOai3o6BMyAAgBcEIACAFwQgAIAXBCAAgBcEIACAFwQgAIAXtZeGbatMnbLsjiUt0FYpWrJXmbanhYffkttendr11tqWati2ytQl0tCTlhacJNZ9tLxWQcrtkoESg4mlv2rvY9IqftfMMV7iMpRUOh3edNryWRVDFe3imCK1BgDAEQEIAOAFAQgA4AUBCADgBQEIAOAFAQgA4EVi07BNwcgEc6T42So+21ICbe2mp+yDiaGqdckK3E79WSpTO/YnxVPVOmmVouPpMzwtNpbUXksabqnXMEn7mLSK33G0cxWlv8Jkic85B2GvR2ACaR5Z+JwBAQC8IAABALwgAAEAvCAAAQC8IAABALwgAAEAvEhsGnYoW1XrOluqta0atn0arJVibVWtrVW0rV2GN7Okoaauvjp0XeF//setwwiqnaJqZa0iLtkqicfTZ+3051oN27XPavdXqs9Upim8x//Jha6ra2kOXVcYCW/n/L4peYzbmvqp6s0ZEADACwIQAMALAhAAwAsCEADACwIQAMALAhAAwIvkpmGbguYsp2qpMG3lWkW7BNdq2LbKxdb+LGOdefddp21GSd+sNufXynG+I6l2nzH151oNu1b6K9WnLdXaZub/jTiOxlGE19+4ZrCHfHYYy+Uy/1vtfPIAABYUAhAAwAsCEADACwIQAMALAhAAwAsCEADAi+SmYQepuVP8Co75grYq2paK1peahqc32qrI2lIbgzpLFe0YquH6qnYbyrGqsXW+bfNWItXcmt7rWoHZ+nq4pcwm7nVcBIKG8I9JM2WplO/4WiWuGrbls0ohl6EEJpjzKpoP4gwIAOAFAQgA4AUBCADgBQEIAOAFAQgA4AUBCADgRXLTsB2qYdvTcG3p0q6lYN1TJp37dEy1tFftjid900dV41AlKgUnq+Kz65ySoh0Lx/dqlCr71WYd68xk+DqqYQMAahEBCADgBQEIAOAFAQgA4AUBCADgBQEIAOBFWQHo6aef1vr169XU1KSmpiZ1dnbqZz/7WXH9xMSEenp6tGLFCi1btkzd3d0aHh52G9nlatgfXIwJXYJUELq4tosttTVs/0otMfQXaf8dt+vczjoUt/6ipqGHH3OF0CWWfYxJtftcKPuYWpIOXWpKDO/Vy8p651133XXat2+fBgcHdeLECd15552655579MYbb0iSdu/ercOHD+vgwYPq7+/XuXPntHXr1vJ3GACw4AVmvlcMhWhpadFjjz2me++9VytXrtT+/ft17733SpLefPNN3XTTTRoYGNBtt902r+2Njo4qk8nojtRW1QcNVz7Bcj+goN5y345py307LO2kCBdx2i5+jHI2U2Gl/lqxXvxou1eI6/6XuGjUSYn5tr3GC+ECz1IXRcaxj9W+aNbHRbq2Pm1nOoWJfBzDqbqweZ02U3px+sfK5XJqamoKbe/8KTgzM6MDBw5ofHxcnZ2dGhwc1NTUlLq6uorPWbdundrb2zUwMBC6nXw+r9HR0VkLAGDhKzsAnTp1SsuWLVM6ndZXv/pVHTp0SB//+MeVzWbV2Nio5ubmWc9vbW1VNpsN3V5vb68ymUxxWbNmTdk7AQCoPWUHoBtvvFEnT57UsWPH9MADD2j79u369a9/7TyAvXv3KpfLFZehoSHnbQEAakfZxUgbGxt1ww03SJI6Ojp0/Phxfec739G2bds0OTmpkZGRWWdBw8PDamtrC91eOp1WOl1jWSEAgMgi/xJeKBSUz+fV0dGhhoYG9fX1FdedPn1aZ8+eVWdnZ9RuAAALTFlnQHv37tXmzZvV3t6usbEx7d+/X0eOHNHPf/5zZTIZ3X///dqzZ49aWlrU1NSknTt3qrOzc94ZcLNU+nYMtq4i3I7BagFkyJVk2Q/XWxzEc6uCeG7/UO3bKiQt02sxZLM5b3PSchuDWmJ9j0e7HUNZAejChQv6kz/5E50/f16ZTEbr16/Xz3/+c/3hH/6hJOnxxx9XKpVSd3e38vm8Nm3apKeeeqqcLgAAi0Tk64AqrXgdULBl7uuAbGxnDpbrh2xnVZH6tEnQGVCk64AS9Fd+lL+ca2WscbTz0WeS2pVq6yrK65EoDp9V02ZKRwr/Gt91QAAAREEAAgB4QQACAHhBAAIAeFH2hahVE1Ym31aMtM7yo58JX2ctqKmYfhQt0aeTOBIiSrHsR6AY0tst+xhXqrWN9cdt6+sRU+o/Kq7ayQTJS8O3vefm7jMwwZxX0XwQZ0AAAC8IQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvkpuGHVYNO1X59OW46mS59hlHxefYak9ZKonHkjLqXH3bR6XoKqeF+0j7rpFUcx+116rdZ03Vl/sdzoAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXhCAAABeJDcNO6watrVys1uKdly363VN/Q3qLS/L9HRVxyLVTnpnlH10fq1iSu926i9KVfME9RnHnHq5JbelUryxXL7g3J+H285HxRkQAMALAhAAwAsCEADACwIQAMALAhAAwAsCEADAi+SmYYexVt+1NLOlRCasUq6ZnHLapnsV7eqmEkvxzHmUfYynOnnl5zV5Fb8Xxj7GIqa0+DhUuqq/MfPbHmdAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC8IQAAAL2ouDds5DdOSvh2k3NMlq11FN3Gpnda0+PCKv87Vd11fxxLp+1GOgYXO+p5zfP2d+4tJtauhu85plOPUdawuafGBCaR5DJUzIACAFwQgAIAXBCAAgBcEIACAFwQgAIAXBCAAgBc1l4ZtY08XDM8JLJVKXfW0UEuqdeIqBVc7Ldx5buzjjGVeY0hR9iHKvLps0yaOVOIofcZyGYbjZ1VcFd/jxBkQAMALAhAAwAsCEADACwIQAMALAhAAwAsCEADAiwWVhu0qcdV3F0j6brUr/vpKJQ0VQ4p64vbRURz7EWWbC6KqfUwV3+PcD86AAABeEIAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXiyoNOy4KuXGkTIaR4XhpImjOrlrZeKFkr682PfRlZcUbcfK7c5KpES791n+pR/GzK8vzoAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXhCAAABeRApA+/btUxAE2rVrV/GxiYkJ9fT0aMWKFVq2bJm6u7s1PDwcdZwAgAXG+Tqg48eP6/vf/77Wr18/6/Hdu3fr3/7t33Tw4EFlMhnt2LFDW7du1S9/+cvIg41LbNdPuN5WodrtgBrheh1YlO3GIa5rFqvdZ9g2AxNI87ic0ekM6OLFi7rvvvv0d3/3d7r66quLj+dyOf3gBz/Qt771Ld15553q6OjQM888o1/96lc6evSoS1cAgAXKKQD19PToC1/4grq6umY9Pjg4qKmpqVmPr1u3Tu3t7RoYGIg2UgDAglL2V3AHDhzQK6+8ouPHj1+xLpvNqrGxUc3NzbMeb21tVTabnXN7+Xxe+Xy++P/R0dFyhwQAqEFlnQENDQ3pwQcf1A9/+EMtWbKkIgPo7e1VJpMpLmvWrKnIdgEAyVZWABocHNSFCxf0qU99SvX19aqvr1d/f7+eeOIJ1dfXq7W1VZOTkxoZGZnVbnh4WG1tbXNuc+/evcrlcsVlaGjIeWcAALWjrK/g7rrrLp06dWrWY1/60pe0bt06/dVf/ZXWrFmjhoYG9fX1qbu7W5J0+vRpnT17Vp2dnXNuM51OK51OOw4fAFCrygpAy5cv18033zzrsauuukorVqwoPn7//fdrz549amlpUVNTk3bu3KnOzk7ddtttlRt1iDjK+JdqW2JAyWln3WadW3+1xJqiLpGmXl2x3I4ggmrfAsTHbTWc+4zxs6Pi9wN6/PHHlUql1N3drXw+r02bNumpp56qdDcAgBoXmPneOahKRkdHlclkdEdqq+qDhivWV/uvER99xtJuJvwv/KDO/ldMzeyjrV2pfbTNT63sYw0d467iOqtI0uuRuH10+OyYNlN6cfrHyuVyampqCm1PLTgAgBcEIACAFwQgAIAXBCAAgBcVz4KrRSXTHhdClemSacgLnGtqO2IRR/KC9X1c4vgPUm7Hh2ufrv1F4ZreHTQ2hq+0JCjMxyL/VAIA+EIAAgB4QQACAHhBAAIAeEEAAgB4QQACAHhBGrbmUyeLFF4g6ey1zuzv4Xhqs4X3mbRq2FaF6fL7mmeJUc6AAABeEIAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXpCGrRirYS+EKtpAlfmoMF3tPuNKtY6jT5eU8cAE0jymhjMgAIAXBCAAgBcEIACAFwQgAIAXBCAAgBcEIACAFwsqDTuONMNL23VM7zRU0Qbm4lqZOa4K09Wuap20atjWPq2fY3XuAxJnQAAATwhAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC8WVBq2a5qhj8q0rlzHWkv7iIXPNUU5QoclVlf3kolaqoZdau6i4AwIAOAFAQgA4AUBCADgBQEIAOAFAQgA4AUBCADgxYJKw3ZVuhp2clKYa6n6LpAYJSrTx/H+iCWdPII4xhO2TWPm1xdnQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvCEAAAC8IQAAAL2rvOiBrafCZyrfzoZbGWitKlpRnXistlluHxPTeiKPPpF2XF8f1TGHbDEwgzeMOF5wBAQC8IAABALwgAAEAvCAAAQC8IAABALwgAAEAvKi9NOwSZdUr3s6HWhprrWBOqy6eW4fE8zo692k9ruoq3s7MWNK+6yz9KULqt+s+zgNnQAAALwhAAAAvCEAAAC8IQAAALwhAAAAvygpA3/jGNxQEwaxl3bp1xfUTExPq6enRihUrtGzZMnV3d2t4eLjigwYA1L6yz4A+8YlP6Pz588Xl5ZdfLq7bvXu3Dh8+rIMHD6q/v1/nzp3T1q1bKzpgV6ZgQhcAcBKkwpc42vkQ41jLvg6ovr5ebW1tVzyey+X0gx/8QPv379edd94pSXrmmWd000036ejRo7rtttsiDxYAsHCUHcLeeustrV69Wh/5yEd033336ezZs5KkwcFBTU1Nqaurq/jcdevWqb29XQMDA5UbMQBgQSjrDGjjxo169tlndeONN+r8+fN69NFH9dnPflavv/66stmsGhsb1dzcPKtNa2urstls6Dbz+bzy+Xzx/6Ojo+XtAQCgJpUVgDZv3lz89/r167Vx40Zdf/31+tGPfqSlS5c6DaC3t1ePPvqoU1sAQO2K9CtSc3OzPvaxj+ntt99WW1ubJicnNTIyMus5w8PDc/5mdNnevXuVy+WKy9DQUJQhAQBqRKQAdPHiRf3mN7/RqlWr1NHRoYaGBvX19RXXnz59WmfPnlVnZ2foNtLptJqammYtAICFr6yv4P7iL/5Cd999t66//nqdO3dOjzzyiOrq6vTFL35RmUxG999/v/bs2aOWlhY1NTVp586d6uzsrF4GnKVqq61SbKRU7BgrxS5k1jn3MafV7rPKVZRLVwNP0D766M/S1hQsf6dX+3WMIoZ9DGtnzPw+U8sKQP/1X/+lL37xi/rv//5vrVy5UrfffruOHj2qlStXSpIef/xxpVIpdXd3K5/Pa9OmTXrqqafK6QIAsEgEZr6hqkpGR0eVyWR0R2qr6oOGK9Zb7yPieK+MUmdA1e7T/V4plW8XV58lOgzvL4Y5lTy8jq79xdCuZNtq72OV+yvV1nrBpeuxWuXXv1Rb130MazdtpnSk8K/K5XLWn1USeNktAGAxIAABALwgAAEAvCi7FlzcLv8kNW2m5lwfGMt3wMby/agtk6PEz2DV7tPeX3XbxdWnvUPL9+oxzOmlttV+HV37q3y70m2rvY/V7a9UW+vf6c7HanVf/1JtXfcxrN3lz+9SnwGJC0BjY2OSpJfNYWmusZfKJg0z7Tyk6vfp2l+120Vt66Lac+qjT9f+ohzjtbKPPt7/rmla1X4dfexjiXZjY2PKZDKh6xOXBVcoFHTu3DktX75cQRBodHRUa9as0dDQEBepfgBzE465CcfchGNuwpUzN8YYjY2NafXq1Uqlws+uEncGlEqldN11113xOFUSwjE34ZibcMxNOOYm3HznxnbmcxlJCAAALwhAAAAvEh+A0um0HnnkEaXTad9DSRzmJhxzE465CcfchItjbhKXhAAAWBwSfwYEAFiYCEAAAC8IQAAALwhAAAAvEh2AnnzySX34wx/WkiVLtHHjRv3Hf/yH7yF58dJLL+nuu+/W6tWrFQSBnnvuuVnrjTF6+OGHtWrVKi1dulRdXV166623/Ay2inp7e3XLLbdo+fLluvbaa7VlyxadPn161nMmJibU09OjFStWaNmyZeru7tbw8LCnEVfP008/rfXr1xcvGuzs7NTPfvaz4vrFOi9z2bdvn4Ig0K5du4qPLeb5+cY3vqEgCGYt69atK66v5NwkNgD98z//s/bs2aNHHnlEr7zyijZs2KBNmzbpwoULvodWdePj49qwYYOefPLJOdd/85vf1BNPPKHvfe97OnbsmK666ipt2rRJExMTVR5pdfX396unp0dHjx7VCy+8oKmpKX3+85/X+Ph48Tm7d+/W4cOHdfDgQfX39+vcuXPaunWrx1FXx3XXXad9+/ZpcHBQJ06c0J133ql77rlHb7zxhqTFOy8fdPz4cX3/+9/X+vXrZz2+2OfnE5/4hM6fP19cXn755eK6is6NSahbb73V9PT0FP8/MzNjVq9ebXp7ez2Oyj9J5tChQ8X/FwoF09bWZh577LHiYyMjIyadTpt/+qd/8jBCfy5cuGAkmf7+fmPMpXloaGgwBw8eLD7nP//zP40kMzAw4GuY3lx99dXm7//+75mX3xkbGzMf/ehHzQsvvGD+4A/+wDz44IPGGI6bRx55xGzYsGHOdZWem0SeAU1OTmpwcFBdXV3Fx1KplLq6ujQwMOBxZMlz5swZZbPZWXOVyWS0cePGRTdXuVxOktTS0iJJGhwc1NTU1Ky5Wbdundrb2xfV3MzMzOjAgQMaHx9XZ2cn8/I7PT09+sIXvjBrHiSOG0l66623tHr1an3kIx/Rfffdp7Nnz0qq/NwkrhipJL377ruamZlRa2vrrMdbW1v15ptvehpVMmWzWUmac64ur1sMCoWCdu3apc985jO6+eabJV2am8bGRjU3N8967mKZm1OnTqmzs1MTExNatmyZDh06pI9//OM6efLkop4XSTpw4IBeeeUVHT9+/Ip1i/242bhxo5599lndeOONOn/+vB599FF99rOf1euvv17xuUlkAALK1dPTo9dff33Wd9WL3Y033qiTJ08ql8vpX/7lX7R9+3b19/f7HpZ3Q0NDevDBB/XCCy9oyZIlvoeTOJs3by7+e/369dq4caOuv/56/ehHP9LSpUsr2lciv4K75pprVFdXd0VmxfDwsNra2jyNKpkuz8dinqsdO3bopz/9qV588cVZt/Joa2vT5OSkRkZGZj1/scxNY2OjbrjhBnV0dKi3t1cbNmzQd77znUU/L4ODg7pw4YI+9alPqb6+XvX19erv79cTTzyh+vp6tba2Lur5+aDm5mZ97GMf09tvv13xYyeRAaixsVEdHR3q6+srPlYoFNTX16fOzk6PI0uetWvXqq2tbdZcjY6O6tixYwt+rowx2rFjhw4dOqRf/OIXWrt27az1HR0damhomDU3p0+f1tmzZxf83MylUCgon88v+nm56667dOrUKZ08ebK4fPrTn9Z9991X/Pdinp8Punjxon7zm99o1apVlT92HBMlYnfgwAGTTqfNs88+a37961+br3zlK6a5udlks1nfQ6u6sbEx8+qrr5pXX33VSDLf+ta3zKuvvmp++9vfGmOM2bdvn2lubjY/+clPzGuvvWbuueces3btWvP+++97Hnm8HnjgAZPJZMyRI0fM+fPni8t7771XfM5Xv/pV097ebn7xi1+YEydOmM7OTtPZ2elx1NXx0EMPmf7+fnPmzBnz2muvmYceesgEQWD+/d//3RizeOclzP/OgjNmcc/P1772NXPkyBFz5swZ88tf/tJ0dXWZa665xly4cMEYU9m5SWwAMsaY7373u6a9vd00NjaaW2+91Rw9etT3kLx48cUXjS7dfX3Wsn37dmPMpVTsr3/966a1tdWk02lz1113mdOnT/sddBXMNSeSzDPPPFN8zvvvv2/+/M//3Fx99dXmQx/6kPmjP/ojc/78eX+DrpI/+7M/M9dff71pbGw0K1euNHfddVcx+BizeOclzAcD0GKen23btplVq1aZxsZG83u/93tm27Zt5u233y6ur+TccDsGAIAXifwNCACw8BGAAABeEIAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXhCAAABeEIAAAF4QgAAAXhCAAABeEIAAAF78f6jJWKVFUeC4AAAAAElFTkSuQmCC", + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGfCAYAAAAZGgYhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAArPklEQVR4nO3df2xd9X3/8de5sX2TkfiahNRORkxTtU1oUVLVlOC13dbgNYoqBIu7sQppaYdWwZyIJJ028tUKRZrkrEilpQu02miiSssyMi1UtAJGDTEbc7JgiAp05Asoajwldkr3zbVj8I/4fr5/pL2rsc/7xp/jcz/32s+HdCRyjz/38zmfe+59c+59n/cncs45AQBQZpnQAwAAzE8EIABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQBA1aT3x3r179cADD6i/v1/r16/Xt7/9bd1www0l2xUKBZ05c0ZLlixRFEVpDQ8AkBLnnIaGhrRy5UplMsZ1jkvBwYMHXV1dnfve977nXnvtNfenf/qnrqGhwQ0MDJRs29fX5ySxsbGxsVX51tfXZ37eR87NfjHSDRs26BOf+IT+9m//VtKlq5pVq1Zp+/btuueee8y2+XxeDQ0N+tlL71f94qmR8//0r49t+/SPr4/d1/zkcOy+mrP/zxyTCoX4XUMX4tuNj9vPGyOqq4vd5y5ejG9ojFPW/4WUuNJ0FyfM/T6iBSl8+2sdx4R9DNa7wByrMeeU+a0e1qkz319Hc24mpp+ci25c/3bxcZ0/f165XC62/ax/BTc2Nqbe3l7t3r27+Fgmk1FbW5t6enqm/P3o6KhGR0eL/x4aGpIk1S/OqH7J1Dd+9kJtbN+ZhQtj99XUxH8A1WSysfsuMQJQNBbfzPMrxCgyAlBkBRIjAJntSgSgyAh6nqJowaw/p3kcUYkApPhPGXOsxpxbz4nKYn3dP99fR3NurM+cEm2lFJIQ3n77bU1MTKixsXHS442Njerv75/y952dncrlcsVt1apVsz0kAEAFCp4Ft3v3buXz+eLW19cXekgAgDKY9a/grrrqKi1YsEADAwOTHh8YGFBTU9OUv89ms8pmS30FBgCYa2Y9ANXV1amlpUVdXV269dZbJV1KQujq6tK2bdsu+3leGJGumObnnrcuLI9tM14f/33kOysWxe5b/O4ScyzRmbdj97mx+N+AzO8/jaSAwq/9JjZbrG9izcSGUgrG9+MZ47vjcaNPo53Vn5Us4CZKfFdttTXGGtUabyEj8cH8Xt0Yq9Wf95xK3q/jnGgnyVnfBVXSWBMco29bc24SSuU+oF27dmnr1q26/vrrdcMNN+ib3/ymhoeH9aUvfSmN7gAAVSiVAHTbbbfp5z//ue6991719/frYx/7mJ566qkpiQkAgPkrtUoI27Ztm9FXbgCA+SV4FhwAYH4iAAEAgiAAAQCCSO03oKTufPaLyiyaWlonOxA/5NzP459vyf/9Rey+6H/y5lgK77xj7o9jpjcvMMq7WHXLPNuZCZol6qSZZXyckd5cKG87Zx2G1V+Ctmbqs/WUxiviSr0esQ0957REn5GMcy6N17/s/SXos2raJWhb4txJgisgAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAEIABAEBWbhr386AItqJuaNpgdjE97zf5P/BLY0fC7sfvcyOxXn5YkZ1ZuNhpaac+WtNqZVXSNtlY731W+rbEm6c+3rdnOaGgcR2Q9ZxpzmqTPFFN0p+V7jldTn+V+/5dqm6QCdwlcAQEAgiAAAQCCIAABAIIgAAEAgiAAAQCCIAABAIKo2DTsZUd+pppM3dQd01TILhqLT8Mu5Adj90WRkWYoyY0aadpGdWoztdXssMKq6BqptmYV5Uz86eWbop5Gf5IURUZ1amusvu180/CN5/TuLwnr3DErt1dJf/I/58reX4iK3wlxBQQACIIABAAIggAEAAiCAAQACIIABAAIggAEAAiCAAQACKJi7wOK497+n/id2Wx8u7Gx+H2lOg1RHr2cEizHEDm/e518y/+b/Vn3wfjek5WgbZI+Y/nOTamx+C6rUGlLh8x2O0mRdX9RCn369hfVTXPf5K8rxN/r4wJ9VlXJJyQAYK4hAAEAgiAAAQCCIAABAIIgAAEAgiAAAQCCqNg07MLQkArR1LRCZyy5EBmp1jJKnJtl3KWyL49Q7vL/Vvl3SYrKPVajdr73MZZajiFjpKim0Kd3fym8Fr9sbOw0+rSWDij70iEJlhypmrEmWBrB+py7eDF+n2+K/mXgCggAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAEIABBExaZha2JCiuz04Pdyzkg1TVLttcwVeFOpFO3bX5I+ree1XlojXdRK0fbuL6U+zbkxzg0rRdvsL0mKriWlKuNerPdUiVT7VPqspHZGtWspweej9RonnHOugAAAQRCAAABBEIAAAEEQgAAAQRCAAABBEIAAAEFUbhp2HKtSrFW1NUmFWc8+fSsFJ6pqHCdJumSJatk+fZrpu75jTekYy12522Qdo3WeJrkNwXit3LhxjLUJ0uLj+rPeU7XGx5lnfyX7zMT36dvO+7MqY7/GmZr4PgvvvOPXZ0JcAQEAgiAAAQCCIAABAIIgAAEAgiAAAQCCIAABAIKovjRs76qt5a+i61spuNwVhq10YclOb3XjF412num7RtanmdqcJO3Xtzq1UUVbhfi58a7cnUY7yfv9kUo6vcH7vZEgDd37fWydG3aHfu1KVMMujI7Ofp8JcQUEAAiCAAQACIIABAAIggAEAAiCAAQACIIABAAIYsYB6Pnnn9fNN9+slStXKooiPf7445P2O+d07733asWKFVq0aJHa2tr0xhtvzNZ45SYmYjcVXOxmtivVZ8HFbt7tXCF2821XYjB+7aRLlaLjNt921vH7vla+45R9XpmvRxpzY7HOcWucpTbr/MhEsZvve6PsrOO7nPfAbPeZQjt38aK5efdpnTcJzTgADQ8Pa/369dq7d++0+7/+9a/roYce0ne+8x0dO3ZMV1xxhTZt2qSRkZHEgwUAzB0zvhF18+bN2rx587T7nHP65je/qb/6q7/SLbfcIkn6/ve/r8bGRj3++OP6oz/6o2SjBQDMGbP6G9CpU6fU39+vtra24mO5XE4bNmxQT0/PtG1GR0c1ODg4aQMAzH2zGoD6+/slSY2NjZMeb2xsLO57r87OTuVyueK2atWq2RwSAKBCBc+C2717t/L5fHHr6+sLPSQAQBnMagBqamqSJA0MDEx6fGBgoLjvvbLZrOrr6ydtAIC5b1arYa9evVpNTU3q6urSxz72MUnS4OCgjh07prvuumtW+jAr0xr7IudfYTqV6tRpVF+2UnjNarclUn99Kz57jtW3+rb3OEP0ab0eVrqtdY7Ls/pyAmWvTl3udiH6rLRjTLHi+YwD0IULF/Tmm28W/33q1CmdOHFCS5cuVXNzs3bs2KG//uu/1oc+9CGtXr1aX/3qV7Vy5UrdeuutiQYKAJhbZhyAXnzxRX3mM58p/nvXrl2SpK1bt2r//v36i7/4Cw0PD+vLX/6yzp8/r0996lN66qmntHDhwtkbNQCg6kXOuYq6ZXlwcFC5XE4bF/6haqK6KfvNO3pT+XpK9lciRlvrzn1zsSqrvxSOsVSFAf8F6Yx2Y2Px7eqmvu6J+7O+RkvQ1rtdGq9/kq9DynzOmXy/8knyVVG5+5zjx3jRjeu58UPK5/Pm7/rBs+AAAPMTAQgAEAQBCAAQxKymYZeDVWU3iuL3me1KZK+aba2UaftJ/dpdRmXnmfZXMpXW+i3LaGv+7mL9JmX8PpRGO6n0b0SxfF8PX8a56P2bo/zfH2a7Wr9zI8oYv6uZ56Jfu1Jt7feqX+p7FBlz46yxev52mKhteun9XAEBAIIgAAEAgiAAAQCCIAABAIIgAAEAgiAAAQCCqLo0bDOdNKVq2CbfKtPGcfiWcPFNw3UXx2P3SVJUU1vWPr1L8Xi2k9IpjRNZr7+V+m5l4fqe4yVS7X3fH77VsEulhVdKu0uNZ///080KaCn0V6nmz5ECACoKAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAEIABBExd4H5JzkNDVX3rzvxCgbnmQ5BpPnMge+5f/tcvRGf0lK9Ze5T3O57hTaSf7H6L0MdpLls1PoL5XlGIzlUbzL/6fSLkSfs9/Oei2kBK9jeqsxcAUEAAiDAAQACIIABAAIggAEAAiCAAQACIIABAAIomLTsKNIiqJp0l+tlNgQyzFY6b2+achWu1rjJaum5RisdtW0HIMv3+UYUuK9rIJnO2++SxXMgyUOkrwWZX8df2nuvyoAgIpEAAIABEEAAgAEQQACAARBAAIABEEAAgAEUbFp2HHVsE1Gaq9Z7TXjn2brW9XaN9fWjY7G7otqjTTkJNWwx+OrTCtjpFob7aKa+FPPOkazP892UoJq2NZzelaKTqUydYmKxlUz1hDVsD2Vu8J4yWrYvq+jVdU8Ia6AAABBEIAAAEEQgAAAQRCAAABBEIAAAEEQgAAAQVRsGnZcNWxnVbW1qmFbac8l0pA1YaQT+1ZuNqpauzGjv2zWrz+rMrWVZq0S6d1GJW1zrL7p5L79laqG7Vll3LsCu3mu+qUEm+niJVLJzT4r6BirqRp2KhXGk1T8D7FaQAlcAQEAgiAAAQCCIAABAIIgAAEAgiAAAQCCIAABAIKo2DTsuGrYVtVizwLTpau9GimcvtWwrVRrs52VvmxVmDbSl0tWii53VWvf6tvWnJZKw7XOK4tRRdi7qrFZmduY7yQVjX2rTPtKpao11bAtaVQ1T4orIABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAVm4YdVw3brOprVbW2UhRLVa01MnTNqtZWdeqa2vh2VhpunWd/VtXuEinhVnVqK73Vu3K3VQ3bmhvPOb3U2Ph/sZIpvHFPmUI15BTa/bLx7Lez3nPlrmo9H6phl0olT6GqufkaXwaugAAAQRCAAABBEIAAAEEQgAAAQRCAAABBEIAAAEHMKA27s7NT//Iv/6LXX39dixYt0m/91m/pb/7mb7RmzZri34yMjOgrX/mKDh48qNHRUW3atEkPP/ywGhsbZzSwuGrYZhsrtddKJSyZoRvf1kphjoy0cKs6tdnOqoZtpS97VtGWEozVt+K3Z2Fq33Tp0k9rVAquNc6N8RSqIfu2M8YplXrvGKn/Vlq8cYuCXX18HlTD9q2GblXmL3GrgZWmnaiSegIzugLq7u5WR0eHjh49qmeeeUbj4+P67Gc/q+Hh4eLf7Ny5U0888YQOHTqk7u5unTlzRlu2bJn1gQMAqtuMroCeeuqpSf/ev3+/3ve+96m3t1e//du/rXw+r0cffVQHDhzQxo0bJUn79u3Ttddeq6NHj+rGG2+cvZEDAKpaot+A8vm8JGnp0qWSpN7eXo2Pj6utra34N2vXrlVzc7N6enqmfY7R0VENDg5O2gAAc593ACoUCtqxY4c++clP6rrrrpMk9ff3q66uTg0NDZP+trGxUf39/dM+T2dnp3K5XHFbtWqV75AAAFXEOwB1dHTo1Vdf1cGDBxMNYPfu3crn88Wtr68v0fMBAKqDVzHSbdu26Yc//KGef/55XX311cXHm5qaNDY2pvPnz0+6ChoYGFBTU9O0z5XNZpU1ilYCAOamGQUg55y2b9+uw4cP68iRI1q9evWk/S0tLaqtrVVXV5fa29slSSdPntTp06fV2to6o4HFVcO2EgK9K1NbVbQluXEj1dqq+GylaFuVmz37s1Jbfccp2ZW0zT6tCtxmNWzP9F0jRTXKlEjD9a0ybKWvplXV2Ke/Um1LvAdmu92cqYbtWw3aev19X4skr3+SSuoJzCgAdXR06MCBA/rBD36gJUuWFH/XyeVyWrRokXK5nO644w7t2rVLS5cuVX19vbZv367W1lYy4AAAk8woAD3yyCOSpN/93d+d9Pi+ffv0xS9+UZL04IMPKpPJqL29fdKNqAAA/LoZfwVXysKFC7V3717t3bvXe1AAgLmPWnAAgCAIQACAIAhAAIAgCEAAgCC8bkQth7jlGKyy4ZrwXBqhVBlzY7kC7+URrCUO0ugvyX1QvktOGH2a/Xm2812qQCpRct4q5W8ev2eJe98lB5JIZZmDamlnt/VdHsNkPKfZn3E/W8lz3LOteQ9dwvuruAICAARBAAIABEEAAgAEQQACAARBAAIABEEAAgAEUbFp2F7LMfguG2CV/1eJFGZrmQOrne9SBb7LMXguVSGlNK+eyyqUTqeNe8ryl5v37jPEkgNzZXmESulP/q+/2c5I+49k307ivVxJinPHFRAAIAgCEAAgCAIQACAIAhAAIAgCEAAgCAIQACCIik3DdhNOLppZyq1Ztbmm1qtdkrZmO6uqtVUN27c/K7W7VLpoiWrhsXwr/npWtY5q44/DqkydpG06Y7VeK+PcsFLijXaXGldSderZr/hdsuK9MT+ppPAbx29WtS4keB+bw6EaNgBgHiEAAQCCIAABAIIgAAEAgiAAAQCCIAABAIKo2DTsaEGkaJoUPzPV1LfCtJG+LEnu4rhXW7NdrTFW3/7SqoZtVOA102mNtNDIGSmjvu0MSVJUU6lqbLWz5juFdpcaz+2q1qmlKPtOuXkcxvvYeI1LppobYzXnh2rYAIC5hgAEAAiCAAQACIIABAAIggAEAAiCAAQACKJi07Cdk5ympj9a6YLelaKNtGepROrjuNWnkfps9WmkPZrtnFF92j5Em1m52GBV9U2jXUpSScO1OzR2plRhukqqWpe9vwR9eleYtoZiVjy3U82921rHTzVsAEA1IgABAIIgAAEAgiAAAQCCIAABAIIgAAEAgqjYNOw4ZmpjiGrY2Wx8uxTSwr2rYSeoomumWnpWwzYK/vq3S4l3JeVyV5hOkhJbJVWtg7DG6lu53apcXjA+qxJVw/ZMp6caNgBgriEAAQCCIAABAIIgAAEAgiAAAQCCIAABAIKo3DTsgpOiMlXDNipaX2prVLU20ru9q1r7pj1bjHbeacYqf6Vo3/6sdknamsdY7grTIaph+0qjwnRKr7/JeF5zrNN8tl0W3/d/ibbWWDMLPT//LgNXQACAIAhAAIAgCEAAgCAIQACAIAhAAIAgCEAAgCAqNw07E0nR1PRgN26kNvpWiq6Nr6J9qU8jvdto613V2kzRjm8XZTwr2pZK7fSt+JsC35RxsxJwWm2rqRp2lfB+/Uu1s1Kmrba+7w3fiu/Ga2y+/yWzAndkdGpW2Y47jsv8XJj7ZywAoCIRgAAAQRCAAABBEIAAAEEQgAAAQRCAAABBzCgAPfLII1q3bp3q6+tVX1+v1tZWPfnkk8X9IyMj6ujo0LJly7R48WK1t7drYGDAb2QFN+0WZaLYzV0cj93MduNj5qbMgtjN6lNRJnYz2xncxET8VnCxm/mcRjsX8zoUN09pjDWKothNrmBvdqdzu908UPIcz0Txm8V4b6TxnvJ9/7uCkyYmYjfvsSb8bJhRALr66qu1Z88e9fb26sUXX9TGjRt1yy236LXXXpMk7dy5U0888YQOHTqk7u5unTlzRlu2bJlJFwCAeSJyzvn/b6ykpUuX6oEHHtDnP/95LV++XAcOHNDnP/95SdLrr7+ua6+9Vj09Pbrxxhsv6/kGBweVy+X0mdo/UM10N11aa1pYN5saN2G5iyXWtMh4rsGSxro+njcbmsdv3WhWoq15HFafxjoiUa3f+iOZOuvm3hKvsXWM1vzMhXYh+ixzu1Lr1ljnnNmnteaX7+dRifejL3MtNXOdpZnfiH3Rjeu58UPK5/Oqr6+P/Tvv34AmJiZ08OBBDQ8Pq7W1Vb29vRofH1dbW1vxb9auXavm5mb19PTEPs/o6KgGBwcnbQCAuW/GAeiVV17R4sWLlc1mdeedd+rw4cP6yEc+ov7+ftXV1amhoWHS3zc2Nqq/vz/2+To7O5XL5YrbqlWrZnwQAIDqM+MAtGbNGp04cULHjh3TXXfdpa1bt+qnP/2p9wB2796tfD5f3Pr6+ryfCwBQPWZcjLSurk4f/OAHJUktLS06fvy4vvWtb+m2227T2NiYzp8/P+kqaGBgQE1NTbHPl81mlc1mZz5yAEBVS3wfUKFQ0OjoqFpaWlRbW6uurq7ivpMnT+r06dNqbW1N2g0AYI6Z0RXQ7t27tXnzZjU3N2toaEgHDhzQkSNH9PTTTyuXy+mOO+7Qrl27tHTpUtXX12v79u1qbW297Ay4SeKWYxgzMks8lziIauxpMLNZfJeA8G3nm5FmKFWqPlpgZPpcTKfP+LEY2UNWQmeSpQqqZVmF+XCMnpIsx2FKYTkGs51vhqBUYs7TybwrZUYB6Ny5c/rjP/5jnT17VrlcTuvWrdPTTz+t3/u935MkPfjgg8pkMmpvb9fo6Kg2bdqkhx9+OJWBAwCqW+L7gGZb8T6g7B9Oex+QGzMWh/O9Airxf0flvpJJ5QoowT1J1hWieX9NGveBWHdYW1dVpe7M9m07F9qF6NO3XRrnTVp9VlI7KZV7luKkfh8QAABJEIAAAEEQgAAAQRCAAABBzPhG1LIpOCma5odDzx/SvNuV4N3W+uHf3GcUFDTGksnGv9QFI7VdkjThmdxgsIsfGu2sH0szxulcMkXdN719DrQL0WeSsfpI8vp7d+l5jlvtpvtMvIx2pfr0Fpe8YaWS/3rzWRwKAACXjQAEAAiCAAQACIIABAAIggAEAAiCAAQACKJy07A9eNdXM+q5lWzrW5vNt26V0c5KfLRK/pWsTO1bJ8tIbfWtTuxd1biaKkX7Knd/ofqsEt4V3612vlW0U+ozKc4eAEAQBCAAQBAEIABAEAQgAEAQBCAAQBAEIABAEHMqDdu3MnWSathWqrVvVVsVjPEUjFTzFKrvJmlrVt+tqOrLIfosd8XnNEohB+pzLjDeNyGqYXt/VsU+4eW14QoIABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQROWmYWciKZqmCquRoexdDbtEhWUzTduoBhxlSqX+xrSrMV4WqxquZ9pryaq9VopmGpVyrXTSEJWpy90nxzj3+Va1rrRq2CVSv0uZ52cBACAUAhAAIAgCEAAgCAIQACAIAhAAIAgCEAAgiIpNw44iKZomDdtVUcVfs8JsbXxqoxv3rGptpZpn4l/qklV0UxiryUr7NCuXz5Fq2CGqb1fTWD2EqPieRlXrENWwMzXG+1+kYQMAqhABCAAQBAEIABAEAQgAEAQBCAAQBAEIABBExaZhOzd9ip9ZuTqtSrElqmXHtvOsIptKO4Pv8SVqOx+qL5e7z/leYdqQpGq79/vKs8J0atWwPds6lyzV2sIZCwAIggAEAAiCAAQACIIABAAIggAEAAiCAAQACKJi07DjmBWfjTRU34q2SdqWvRq27zHO+0rRJdr6Knfl9hCV4qtEatWwjerUJuM5U+kvVJ8lcAUEAAiCAAQACIIABAAIggAEAAiCAAQACIIABAAIourSsFOphl2i2q13dVrP1FfvKrq+qbZJqihXS1VrjjG9tlXQX2rVsK198XeMpPNZZfWXpM8UcQUEAAiCAAQACIIABAAIggAEAAiCAAQACIIABAAIIlEA2rNnj6Io0o4dO4qPjYyMqKOjQ8uWLdPixYvV3t6ugYGBpOMEAMwx3vcBHT9+XN/97ne1bt26SY/v3LlTP/rRj3To0CHlcjlt27ZNW7Zs0QsvvDCj548iKYqm5qYXPMuGB1mOwVo6IhM/9eXuj+UYQvRZQe2StvVR5v6SLMeQRp9pLKuS2pITxtIx1hIPl8PrCujChQu6/fbb9Xd/93e68sori4/n83k9+uij+sY3vqGNGzeqpaVF+/bt03/8x3/o6NGjiQYKAJhbvAJQR0eHPve5z6mtrW3S4729vRofH5/0+Nq1a9Xc3Kyenp5kIwUAzCkz/gru4MGDeumll3T8+PEp+/r7+1VXV6eGhoZJjzc2Nqq/v3/a5xsdHdXo6Gjx34ODgzMdEgCgCs3oCqivr0933323/uEf/kELFy6clQF0dnYql8sVt1WrVs3K8wIAKtuMAlBvb6/OnTunj3/846qpqVFNTY26u7v10EMPqaamRo2NjRobG9P58+cntRsYGFBTU9O0z7l7927l8/ni1tfX530wAIDqMaOv4G666Sa98sorkx770pe+pLVr1+ov//IvtWrVKtXW1qqrq0vt7e2SpJMnT+r06dNqbW2d9jmz2ayy2azn8AEA1WpGAWjJkiW67rrrJj12xRVXaNmyZcXH77jjDu3atUtLly5VfX29tm/frtbWVt14440zGphzktPUFD/vpQoSlBv3LeXu3c5aciKFdixVkJIQfWJaSZZjKHef5W6XtG0Ss74e0IMPPqhMJqP29naNjo5q06ZNevjhh2e7GwBAlYucc8nuJJplg4ODyuVy+kz2D1UT1U79A+NmS1lXAL7tQvRp3dxl/Z9KGu1C9Flpx1ju13E+nOOV1C5En3PlGGPO8YtuXM+NH1I+n1d9fX1sc74jAAAEQQACAARBAAIABEEAAgAEMetZcGkzKz4baa+pVcNOoQJ3OlWtqRRtq/6Kz9Wk3JWiSzKe1/f9X+7+0qqGnckalfvHxs0+S+EKCAAQBAEIABAEAQgAEAQBCAAQBAEIABAEAQgAEETVpWGbFZ9DVMO2+vRMtTWP0Uq1DFEpulqqWs+HY0yizH16V3xPq2qz72eHWdMvhf4M3tXwZc+ru3jR+3lL4QoIABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQRNWlYZe7MnWiPtOoau29JC/VsG3VMtaUqmiXu88y95dWpeiKaldiSW7zMycQroAAAEEQgAAAQRCAAABBEIAAAEEQgAAAQRCAAABBVF5e3i9FkRRF01Ro9a1MHaIatm+fVF+unHZJ26IiJKmi7ds2lXYpfcaFwjsLABAEAQgAEAQBCAAQBAEIABAEAQgAEAQBCAAQRMWmYcepuGrYKVS1razqyyXa+qqmYwxRnRoVo2qqYQeo+J0UV0AAgCAIQACAIAhAAIAgCEAAgCAIQACAIAhAAIAgKjYN2znJaWpqYIhKsdECIw/RTF/0zF+spkrRvqrpGKtlrNVU8buK+vN9H3u3862i7ft5k6DPpLgCAgAEQQACAARBAAIABEEAAgAEQQACAARBAAIABEEAAgAEUbH3AUWRFEVTc9MLIZZjmJiIb1sbP4Vu/GJ8u4wx9dW0VIGvajrGihprSstGlHvJiTL3Z72HpXTej+bnhtFfOsu4SJW4dAhXQACAIAhAAIAgCEAAgCAIQACAIAhAAIAgCEAAgCAqNg07jllyPMRyDCm0mxeqaemIajEf5sbzGBMtN+DbZ7k/N0K8/nHzepmft/PgjAUAVCICEAAgCAIQACAIAhAAIAgCEAAgiBkFoK997WuKomjStnbt2uL+kZERdXR0aNmyZVq8eLHa29s1MDAw64MGAFS/Gadhf/SjH9WPf/zj/32Cmv99ip07d+pHP/qRDh06pFwup23btmnLli164YUXZme0kl3xtRAfT91FozJ1qbTHENWJ5zrmdPbNh7kJcYzVUtU8RDXsuMrdLr6i96+bcQCqqalRU1PTlMfz+bweffRRHThwQBs3bpQk7du3T9dee62OHj2qG2+8caZdAQDmsBn/BvTGG29o5cqV+sAHPqDbb79dp0+fliT19vZqfHxcbW1txb9du3atmpub1dPTM3sjBgDMCTO6AtqwYYP279+vNWvW6OzZs7r//vv16U9/Wq+++qr6+/tVV1enhoaGSW0aGxvV398f+5yjo6MaHR0t/ntwcHBmRwAAqEozCkCbN28u/ve6deu0YcMGXXPNNXrssce0aNEirwF0dnbq/vvv92oLAKheidKwGxoa9OEPf1hvvvmmmpqaNDY2pvPnz0/6m4GBgWl/M/qV3bt3K5/PF7e+vr4kQwIAVIlEAejChQt66623tGLFCrW0tKi2tlZdXV3F/SdPntTp06fV2toa+xzZbFb19fWTNgDA3Dejr+D+/M//XDfffLOuueYanTlzRvfdd58WLFigL3zhC8rlcrrjjju0a9cuLV26VPX19dq+fbtaW1u9MuDchJOLpkkr9K0wm816tUvSZ9krPoeoMF3uPkNUCi53n779Jam+Xu4+q2VOQ/RZTceYsBr2jALQf//3f+sLX/iCfvGLX2j58uX61Kc+paNHj2r58uWSpAcffFCZTEbt7e0aHR3Vpk2b9PDDD8+kCwDAPBE5d5l3DJXJ4OCgcrmcPlP7B6qJaqf+QZJ1Pcot7iYtyT6OSmoXos80XuMkx5hGn9V0HleSEHNaSedqlRzjRTeu50YfUz6fN39WoRYcACAIAhAAIAgCEAAgiBnXgkvbr36SuujGY/6gir47t35es46jktqF6DON1zjJMabRZzWdx5UkxJxW0rlaJcf4q8/vUikGFReAhoaGJEn/dvHxsAMBACQyNDSkXC4Xu7/isuAKhYLOnDmjJUuWKIoiDQ4OatWqVerr6+Mm1fdgbuIxN/GYm3jMTbyZzI1zTkNDQ1q5cqUymfhfeiruCiiTyejqq6+e8jhVEuIxN/GYm3jMTTzmJt7lzo115fMrJCEAAIIgAAEAgqj4AJTNZnXfffcpm6SW2xzF3MRjbuIxN/GYm3hpzE3FJSEAAOaHir8CAgDMTQQgAEAQBCAAQBAEIABAEBUdgPbu3av3v//9WrhwoTZs2KD//M//DD2kIJ5//nndfPPNWrlypaIo0uOPPz5pv3NO9957r1asWKFFixapra1Nb7zxRpjBllFnZ6c+8YlPaMmSJXrf+96nW2+9VSdPnpz0NyMjI+ro6NCyZcu0ePFitbe3a2BgINCIy+eRRx7RunXrijcNtra26sknnyzun6/zMp09e/YoiiLt2LGj+Nh8np+vfe1riqJo0rZ27dri/tmcm4oNQP/0T/+kXbt26b777tNLL72k9evXa9OmTTp37lzooZXd8PCw1q9fr7179067/+tf/7oeeughfec739GxY8d0xRVXaNOmTRoZGSnzSMuru7tbHR0dOnr0qJ555hmNj4/rs5/9rIaHh4t/s3PnTj3xxBM6dOiQuru7debMGW3ZsiXgqMvj6quv1p49e9Tb26sXX3xRGzdu1C233KLXXntN0vydl/c6fvy4vvvd72rdunWTHp/v8/PRj35UZ8+eLW7//u//Xtw3q3PjKtQNN9zgOjo6iv+emJhwK1eudJ2dnQFHFZ4kd/jw4eK/C4WCa2pqcg888EDxsfPnz7tsNuv+8R//McAIwzl37pyT5Lq7u51zl+ahtrbWHTp0qPg3//Vf/+UkuZ6enlDDDObKK690f//3f8+8/NLQ0JD70Ic+5J555hn3O7/zO+7uu+92znHe3HfffW79+vXT7pvtuanIK6CxsTH19vaqra2t+Fgmk1FbW5t6enoCjqzynDp1Sv39/ZPmKpfLacOGDfNurvL5vCRp6dKlkqTe3l6Nj49Pmpu1a9equbl5Xs3NxMSEDh48qOHhYbW2tjIvv9TR0aHPfe5zk+ZB4ryRpDfeeEMrV67UBz7wAd1+++06ffq0pNmfm4orRipJb7/9tiYmJtTY2Djp8cbGRr3++uuBRlWZ+vv7JWnaufrVvvmgUChox44d+uQnP6nrrrtO0qW5qaurU0NDw6S/nS9z88orr6i1tVUjIyNavHixDh8+rI985CM6ceLEvJ4XSTp48KBeeuklHT9+fMq++X7ebNiwQfv379eaNWt09uxZ3X///fr0pz+tV199ddbnpiIDEDBTHR0devXVVyd9Vz3frVmzRidOnFA+n9c///M/a+vWreru7g49rOD6+vp0991365lnntHChQtDD6fibN68ufjf69at04YNG3TNNdfoscce06JFi2a1r4r8Cu6qq67SggULpmRWDAwMqKmpKdCoKtOv5mM+z9W2bdv0wx/+UM8999ykpTyampo0Njam8+fPT/r7+TI3dXV1+uAHP6iWlhZ1dnZq/fr1+ta3vjXv56W3t1fnzp3Txz/+cdXU1Kimpkbd3d166KGHVFNTo8bGxnk9P+/V0NCgD3/4w3rzzTdn/dypyABUV1enlpYWdXV1FR8rFArq6upSa2trwJFVntWrV6upqWnSXA0ODurYsWNzfq6cc9q2bZsOHz6sZ599VqtXr560v6WlRbW1tZPm5uTJkzp9+vScn5vpFAoFjY6Ozvt5uemmm/TKK6/oxIkTxe3666/X7bffXvzv+Tw/73XhwgW99dZbWrFixeyfO56JEqk7ePCgy2azbv/+/e6nP/2p+/KXv+waGhpcf39/6KGV3dDQkHv55Zfdyy+/7CS5b3zjG+7ll192P/vZz5xzzu3Zs8c1NDS4H/zgB+4nP/mJu+WWW9zq1avdu+++G3jk6brrrrtcLpdzR44ccWfPni1u77zzTvFv7rzzTtfc3OyeffZZ9+KLL7rW1lbX2toacNTlcc8997ju7m536tQp95Of/MTdc889Looi96//+q/Oufk7L3F+PQvOufk9P1/5ylfckSNH3KlTp9wLL7zg2tra3FVXXeXOnTvnnJvduanYAOScc9/+9rddc3Ozq6urczfccIM7evRo6CEF8dxzzzlJU7atW7c65y6lYn/1q191jY2NLpvNuptuusmdPHky7KDLYLo5keT27dtX/Jt3333X/dmf/Zm78sor3W/8xm+43//933dnz54NN+gy+ZM/+RN3zTXXuLq6Ord8+XJ30003FYOPc/N3XuK8NwDN5/m57bbb3IoVK1xdXZ37zd/8TXfbbbe5N998s7h/NueG5RgAAEFU5G9AAIC5jwAEAAiCAAQACIIABAAIggAEAAiCAAQACIIABAAIggAEAAiCAAQACIIABAAIggAEAAiCAAQACOL/A8Azf5JwutSSAAAAAElFTkSuQmCC", + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(outputs[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89ae76ec-92b7-4773-8893-fa1028f1c0a2", + "metadata": {}, + "outputs": [], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][5].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d55e9df0-d46a-445a-8032-6ff5bd566ea7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d55944fe-f7bd-463c-bda9-848d3ac29275", + "metadata": {}, + "source": [ + "## convert keypoint" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "83242f5c-71ae-4c95-a8fa-d385904d00d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 0.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]],\n", + "\n", + " [[0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]],\n", + "\n", + " [[0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]],\n", + "\n", + " [[0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]]])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "\n", + "# Original and target sizes\n", + "original_size = (208, 208) # Replace with actual dimensions\n", + "target_size = (52, 52)\n", + "\n", + "# Resizing function\n", + "def resize_keypoints_new(keypoints, original_size, target_size):\n", + " original_height, original_width = original_size\n", + " target_height, target_width = target_size\n", + " \n", + " scale_x = int(target_width / original_width)\n", + " scale_y = int(target_height / original_height)\n", + " \n", + " resized_keypoints = keypoints.clone()\n", + " resized_keypoints[..., 0] *= scale_x\n", + " resized_keypoints[..., 1] *= scale_y\n", + " \n", + " return resized_keypoints\n", + "\n", + "# Resized keypoints\n", + "resized_keypoints = resize_keypoints_new(keypoints, original_size, target_size)\n", + "print(resized_keypoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "718c212b-ebb5-4ddb-8b7c-88537ea6f85f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f4ef8c2-e3d2-4e7d-8388-d4b4ddc18587", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e2e1b2cd-c9ce-4149-a89c-ddd210196fb7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][2].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9f12e02-03b0-47bb-85fb-d9723e50e0e5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3b414522-0a5e-4a11-83e6-20aa0fc04d2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 3, 208, 208])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5dc276a4-7c8b-4972-90d0-e3c77fb9c199", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 17, 52, 52])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gt_heatmaps.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "b1c06c2b-8708-4a24-9abe-33901f646d90", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [1/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:28<00:00, 13.18batch/s, loss=4.61]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Loss: 4.6097\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [2/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:32<00:00, 12.96batch/s, loss=3.91]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [2/10], Loss: 3.9105\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [3/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:28<00:00, 13.17batch/s, loss=3.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [3/10], Loss: 3.7892\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [4/10]: 100%|███████████████████████████████████████████████████| 2751/2751 [03:30<00:00, 13.08batch/s, loss=3.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [4/10], Loss: 3.7024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [5/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:30<00:00, 13.09batch/s, loss=3.63]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [5/10], Loss: 3.6335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [6/10]: 1%|▌ | 30/2751 [00:02<03:28, 13.04batch/s, loss=3.77]\n", + "\n", + "KeyboardInterrupt\n", + "\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader\n", + "from tqdm import tqdm # Import tqdm\n", + "\n", + "optimizer = optim.Adam(model.parameters(), lr=1e-4)\n", + "criterion = torch.nn.MSELoss()\n", + "\n", + "# Define training loop\n", + "num_epochs = 10 # Number of epochs\n", + "for epoch in range(num_epochs):\n", + " model.train() # Set model to training mode\n", + " running_loss = 0.0\n", + "\n", + " # Wrap the DataLoader with tqdm to show the progress\n", + " with tqdm(dataloader, desc=f\"Epoch [{epoch + 1}/{num_epochs}]\", unit='batch') as pbar:\n", + " for images, labels in pbar:\n", + " # Send images and labels to GPU if needed\n", + " images = images.cuda()\n", + " labels = labels.cuda()\n", + "\n", + " optimizer.zero_grad() # Zero the gradients\n", + "\n", + " # Forward pass\n", + " outputs = model(images) # The model outputs keypoint heatmaps\n", + " #print(outputs.shape)\n", + "\n", + " original_size = (208, 208)\n", + " target_size = (52, 52)\n", + " labels = resize_keypoints_new(labels, original_size, target_size)\n", + " gt_heatmaps = generate_heatmaps(labels, output_size=outputs.shape[2:]) # Implement this\n", + " loss = criterion(outputs*100, gt_heatmaps*100)\n", + "\n", + " # Backward pass and optimization\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + "\n", + " # Update the tqdm progress bar with the current loss\n", + " pbar.set_postfix(loss=running_loss / (pbar.n + 1)) # Display the average loss\n", + "\n", + " # Print loss for the current epoch\n", + " avg_loss = running_loss / len(dataloader)\n", + " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cac52986-3416-4280-8092-9b197ac006ad", + "metadata": {}, + "outputs": [], + "source": [ + "input_tensor.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5dbc351-bb56-450f-85c7-225902b2a9b8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12157857-e9bf-4645-a137-3e5ddf0d3141", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a27d991-83b5-485f-8e50-9273601dedab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fdd034a0-c159-4b2f-8f49-abdbd49844bd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88eab6b5-72f5-4407-a2d1-c9f74dfb2f8b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/__init__-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..5353d47e15e1c92f1d90b61771b9aaea109fd938 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/__init__-checkpoint.py @@ -0,0 +1,5 @@ +from .inference import VitInference + +__all__ = [ + 'VitInference' +] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/config-checkpoint.yaml b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/config-checkpoint.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8cf121d164a4c48ebec1a30b4d865bc213cc4f6f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/config-checkpoint.yaml @@ -0,0 +1,15 @@ +# Train config --------------------------------------- +log_level: logging.INFO +seed: 0 +gpu_ids: 0 +deterministic: True +cudnn_benchmark: True # Use cudnn +resume_from: "C:/Users/user/ViTPose/ckpts/vitpose-s-coco_25.pth" # CKPT path +#resume_from: False +gpu_ids: [0] +launcher: 'none' # When distributed training ['none', 'pytorch', 'slurm', 'mpi'] +use_amp: False +validate: True +autoscale_lr: False +dist_params: + ... diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..ace72e5cfb9f577b1ca596de53ef10de42f4450b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/inference-checkpoint.py @@ -0,0 +1,337 @@ +import abc +import os +from typing import Optional +import typing + +import cv2 +import numpy as np +import torch + +from ultralytics import YOLO + +from .configs.ViTPose_common import data_cfg +from .sort import Sort +from .vit_models.model import ViTPose +from .vit_utils.inference import draw_bboxes, pad_image +from .vit_utils.top_down_eval import keypoints_from_heatmaps +from .vit_utils.util import dyn_model_import, infer_dataset_by_path +from .vit_utils.visualization import draw_points_and_skeleton, joints_dict + +try: + import torch_tensorrt +except ModuleNotFoundError: + pass + +try: + import onnxruntime +except ModuleNotFoundError: + pass + +__all__ = ['VitInference'] +np.bool = np.bool_ +MEAN = [0.485, 0.456, 0.406] +STD = [0.229, 0.224, 0.225] + + +DETC_TO_YOLO_YOLOC = { + 'human': [0], + 'cat': [15], + 'dog': [16], + 'horse': [17], + 'sheep': [18], + 'cow': [19], + 'elephant': [20], + 'bear': [21], + 'zebra': [22], + 'giraffe': [23], + 'animals': [15, 16, 17, 18, 19, 20, 21, 22, 23] +} + + +class VitInference: + """ + Class for performing inference using ViTPose models with YOLOv8 human detection and SORT tracking. + + Args: + model (str): Path to the ViT model file (.pth, .onnx, .engine). + yolo (str): Path of the YOLOv8 model to load. + model_name (str, optional): Name of the ViT model architecture to use. + Valid values are 's', 'b', 'l', 'h'. + Defaults to None, is necessary when using .pth checkpoints. + det_class (str, optional): the detection class. if None it is inferred by the dataset. + valid values are 'human', 'cat', 'dog', 'horse', 'sheep', + 'cow', 'elephant', 'bear', 'zebra', 'giraffe', + 'animals' (which is all previous but human) + dataset (str, optional): Name of the dataset. If None it's extracted from the file name. + Valid values are 'coco', 'coco_25', 'wholebody', 'mpii', + 'ap10k', 'apt36k', 'aic' + yolo_size (int, optional): Size of the input image for YOLOv8 model. Defaults to 320. + device (str, optional): Device to use for inference. Defaults to 'cuda' if available, else 'cpu'. + is_video (bool, optional): Flag indicating if the input is video. Defaults to False. + single_pose (bool, optional): Flag indicating if the video (on images this flag has no effect) + will contain a single pose. + In this case the SORT tracker is not used (increasing performance) + but people id tracking + won't be consistent among frames. + yolo_step (int, optional): The tracker can be used to predict the bboxes instead of yolo for performance, + this flag specifies how often yolo is applied (e.g. 1 applies yolo every frame). + This does not have any effect when is_video is False. + """ + + def __init__(self, model: str, + yolo: str, + model_name: Optional[str] = None, + det_class: Optional[str] = None, + dataset: Optional[str] = None, + yolo_size: Optional[int] = 320, + device: Optional[str] = None, + is_video: Optional[bool] = False, + single_pose: Optional[bool] = False, + yolo_step: Optional[int] = 1): + assert os.path.isfile(model), f'The model file {model} does not exist' + assert os.path.isfile(yolo), f'The YOLOv8 model {yolo} does not exist' + + # Device priority is cuda / mps / cpu + if device is None: + if torch.cuda.is_available(): + device = 'cuda' + elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): + device = 'mps' + else: + device = 'cpu' + + self.device = device + self.yolo = YOLO(yolo, task='detect') + self.yolo_size = yolo_size + self.yolo_step = yolo_step + self.is_video = is_video + self.single_pose = single_pose + self.reset() + + # State saving during inference + self.save_state = True # Can be disabled manually + self._img = None + self._yolo_res = None + self._tracker_res = None + self._keypoints = None + + # Use extension to decide which kind of model has been loaded + use_onnx = model.endswith('.onnx') + use_trt = model.endswith('.engine') + + + # Extract dataset name + if dataset is None: + dataset = infer_dataset_by_path(model) + + assert dataset in ['mpii', 'coco', 'coco_25', 'wholebody', 'aic', 'ap10k', 'apt36k'], \ + 'The specified dataset is not valid' + + # Dataset can now be set for visualization + self.dataset = dataset + + # if we picked the dataset switch to correct yolo classes if not set + if det_class is None: + det_class = 'animals' if dataset in ['ap10k', 'apt36k'] else 'human' + self.yolo_classes = DETC_TO_YOLO_YOLOC[det_class] + + assert model_name in [None, 's', 'b', 'l', 'h'], \ + f'The model name {model_name} is not valid' + + # onnx / trt models do not require model_cfg specification + if model_name is None: + assert use_onnx or use_trt, \ + 'Specify the model_name if not using onnx / trt' + else: + # Dynamically import the model class + model_cfg = dyn_model_import(self.dataset, model_name) + + self.target_size = data_cfg['image_size'] + if use_onnx: + self._ort_session = onnxruntime.InferenceSession(model, + providers=['CUDAExecutionProvider', + 'CPUExecutionProvider']) + inf_fn = self._inference_onnx + else: + self._vit_pose = ViTPose(model_cfg) + self._vit_pose.eval() + + if use_trt: + self._vit_pose = torch.jit.load(model) + else: + ckpt = torch.load(model, map_location='cpu', weights_only=True) + if 'state_dict' in ckpt: + self._vit_pose.load_state_dict(ckpt['state_dict']) + else: + self._vit_pose.load_state_dict(ckpt) + self._vit_pose.to(torch.device(device)) + + inf_fn = self._inference_torch + + # Override _inference abstract with selected engine + self._inference = inf_fn # type: ignore + + def reset(self): + """ + Reset the inference class to be ready for a new video. + This will reset the internal counter of frames, on videos + this is necessary to reset the tracker. + """ + min_hits = 3 if self.yolo_step == 1 else 1 + use_tracker = self.is_video and not self.single_pose + self.tracker = Sort(max_age=self.yolo_step, + min_hits=min_hits, + iou_threshold=0.3) if use_tracker else None # TODO: Params + self.frame_counter = 0 + + @classmethod + def postprocess(cls, heatmaps, org_w, org_h): + """ + Postprocess the heatmaps to obtain keypoints and their probabilities. + + Args: + heatmaps (ndarray): Heatmap predictions from the model. + org_w (int): Original width of the image. + org_h (int): Original height of the image. + + Returns: + ndarray: Processed keypoints with probabilities. + """ + points, prob = keypoints_from_heatmaps(heatmaps=heatmaps, + center=np.array([[org_w // 2, + org_h // 2]]), + scale=np.array([[org_w, org_h]]), + unbiased=True, use_udp=True) + return np.concatenate([points[:, :, ::-1], prob], axis=2) + + @abc.abstractmethod + def _inference(self, img: np.ndarray) -> np.ndarray: + """ + Abstract method for performing inference on an image. + It is overloaded by each inference engine. + + Args: + img (ndarray): Input image for inference. + + Returns: + ndarray: Inference results. + """ + raise NotImplementedError + + def inference(self, img: np.ndarray) -> dict[typing.Any, typing.Any]: + """ + Perform inference on the input image. + + Args: + img (ndarray): Input image for inference in RGB format. + + Returns: + dict[typing.Any, typing.Any]: Inference results. + """ + + # First use YOLOv8 for detection + res_pd = np.empty((0, 5)) + results = None + if (self.tracker is None or + (self.frame_counter % self.yolo_step == 0 or self.frame_counter < 3)): + results = self.yolo(img[..., ::-1], verbose=False, imgsz=self.yolo_size, + device=self.device if self.device != 'cuda' else 0, + classes=self.yolo_classes)[0] + res_pd = np.array([r[:5].tolist() for r in # TODO: Confidence threshold + results.boxes.data.cpu().numpy() if r[4] > 0.35]).reshape((-1, 5)) + self.frame_counter += 1 + + frame_keypoints = {} + scores_bbox = {} + ids = None + if self.tracker is not None: + res_pd = self.tracker.update(res_pd) + ids = res_pd[:, 5].astype(int).tolist() + + # Prepare boxes for inference + bboxes = res_pd[:, :4].round().astype(int) + scores = res_pd[:, 4].tolist() + pad_bbox = 10 + + if ids is None: + ids = range(len(bboxes)) + + for bbox, id, score in zip(bboxes, ids, scores): + # TODO: Slightly bigger bbox + bbox[[0, 2]] = np.clip(bbox[[0, 2]] + [-pad_bbox, pad_bbox], 0, img.shape[1]) + bbox[[1, 3]] = np.clip(bbox[[1, 3]] + [-pad_bbox, pad_bbox], 0, img.shape[0]) + + # Crop image and pad to 3/4 aspect ratio + img_inf = img[bbox[1]:bbox[3], bbox[0]:bbox[2]] + img_inf, (left_pad, top_pad) = pad_image(img_inf, 3 / 4) + + keypoints = self._inference(img_inf)[0] + # Transform keypoints to original image + keypoints[:, :2] += bbox[:2][::-1] - [top_pad, left_pad] + frame_keypoints[id] = keypoints + scores_bbox[id] = score # Replace this with avg_keypoint_conf*person_obj_conf. For now, only person_obj_conf from yolo is being used. + + if self.save_state: + self._img = img + self._yolo_res = results + self._tracker_res = (bboxes, ids, scores) + self._keypoints = frame_keypoints + self._scores_bbox = scores_bbox + + return frame_keypoints + + def draw(self, show_yolo=True, show_raw_yolo=False, confidence_threshold=0.5): + """ + Draw keypoints and bounding boxes on the image. + + Args: + show_yolo (bool, optional): Whether to show YOLOv8 bounding boxes. Default is True. + show_raw_yolo (bool, optional): Whether to show raw YOLOv8 bounding boxes. Default is False. + + Returns: + ndarray: Image with keypoints and bounding boxes drawn. + """ + img = self._img.copy() + bboxes, ids, scores = self._tracker_res + + if self._yolo_res is not None and (show_raw_yolo or (self.tracker is None and show_yolo)): + img = np.array(self._yolo_res.plot())[..., ::-1] + + if show_yolo and self.tracker is not None: + img = draw_bboxes(img, bboxes, ids, scores) + + img = np.array(img)[..., ::-1] # RGB to BGR for cv2 modules + for idx, k in self._keypoints.items(): + img = draw_points_and_skeleton(img.copy(), k, + joints_dict()[self.dataset]['skeleton'], + person_index=idx, + points_color_palette='gist_rainbow', + skeleton_color_palette='jet', + points_palette_samples=10, + confidence_threshold=confidence_threshold) + return img[..., ::-1] # Return RGB as original + + def pre_img(self, img): + org_h, org_w = img.shape[:2] + img_input = cv2.resize(img, self.target_size, interpolation=cv2.INTER_LINEAR) / 255 + img_input = ((img_input - MEAN) / STD).transpose(2, 0, 1)[None].astype(np.float32) + return img_input, org_h, org_w + + @torch.no_grad() + def _inference_torch(self, img: np.ndarray) -> np.ndarray: + # Prepare input data + img_input, org_h, org_w = self.pre_img(img) + img_input = torch.from_numpy(img_input).to(torch.device(self.device)) + + # Feed to model + heatmaps = self._vit_pose(img_input).detach().cpu().numpy() + return self.postprocess(heatmaps, org_w, org_h) + + def _inference_onnx(self, img: np.ndarray) -> np.ndarray: + # Prepare input data + img_input, org_h, org_w = self.pre_img(img) + + # Feed to model + ort_inputs = {self._ort_session.get_inputs()[0].name: img_input} + heatmaps = self._ort_session.run(None, ort_inputs)[0] + return self.postprocess(heatmaps, org_w, org_h) \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/testVITPOSE-checkpoint.jpg b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/testVITPOSE-checkpoint.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1950afe3c02fa46ea40e1c98b9b31ad9efc55b86 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/testVITPOSE-checkpoint.jpg differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/train-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/train-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..8b25629805235a94dc8263b88855d28c9060f0c2 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/.ipynb_checkpoints/train-checkpoint.py @@ -0,0 +1,174 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import copy +import os +import os.path as osp +import time +import warnings +import click +import yaml + +from glob import glob + +import torch +import torch.distributed as dist + +from vit_utils.util import init_random_seed, set_random_seed +from vit_utils.dist_util import get_dist_info, init_dist +from vit_utils.logging import get_root_logger + +import configs.ViTPose_small_coco_256x192 as s_cfg +import configs.ViTPose_base_coco_256x192 as b_cfg +import configs.ViTPose_large_coco_256x192 as l_cfg +import configs.ViTPose_huge_coco_256x192 as h_cfg + +from vit_models.model import ViTPose +from datasets.COCO import COCODataset +from vit_utils.train_valid_fn import train_model + +CUR_PATH = osp.dirname(__file__) + +@click.command() +@click.option('--config-path', type=click.Path(exists=True), default='config.yaml', required=True, help='train config file path') +@click.option('--model-name', type=str, default='b', required=True, help='[b: ViT-B, l: ViT-L, h: ViT-H]') +def main(config_path, model_name): + + cfg = {'b':b_cfg, + 's':s_cfg, + 'l':l_cfg, + 'h':h_cfg}.get(model_name.lower()) + # Load config.yaml + with open(config_path, 'r') as f: + cfg_yaml = yaml.load(f, Loader=yaml.SafeLoader) + + for k, v in cfg_yaml.items(): + if hasattr(cfg, k): + raise ValueError(f"Already exists {k} in config") + else: + cfg.__setattr__(k, v) + + # set cudnn_benchmark + if cfg.cudnn_benchmark: + torch.backends.cudnn.benchmark = True + + # Set work directory (session-level) + if not hasattr(cfg, 'work_dir'): + cfg.__setattr__('work_dir', f"{CUR_PATH}/runs/train") + + if not osp.exists(cfg.work_dir): + os.makedirs(cfg.work_dir) + session_list = sorted(glob(f"{cfg.work_dir}/*")) + if len(session_list) == 0: + session = 1 + else: + session = int(os.path.basename(session_list[-1])) + 1 + session_dir = osp.join(cfg.work_dir, str(session).zfill(3)) + os.makedirs(session_dir) + cfg.__setattr__('work_dir', session_dir) + + + if cfg.autoscale_lr: + # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) + cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8 + + # init distributed env first, since logger depends on the dist info. + if cfg.launcher == 'none': + distributed = False + if len(cfg.gpu_ids) > 1: + warnings.warn( + f"We treat {cfg['gpu_ids']} as gpu-ids, and reset to " + f"{cfg['gpu_ids'][0:1]} as gpu-ids to avoid potential error in " + "non-distribute training time.") + cfg.gpu_ids = cfg.gpu_ids[0:1] + else: + distributed = True + init_dist(cfg.launcher, **cfg.dist_params) + # re-set gpu_ids with distributed training mode + _, world_size = get_dist_info() + cfg.gpu_ids = range(world_size) + + # init the logger before other steps + timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) + log_file = osp.join(session_dir, f'{timestamp}.log') + logger = get_root_logger(log_file=log_file) + + # init the meta dict to record some important information such as + # environment info and seed, which will be logged + meta = dict() + + # log some basic info + logger.info(f'Distributed training: {distributed}') + + # set random seeds + seed = init_random_seed(cfg.seed) + logger.info(f"Set random seed to {seed}, " + f"deterministic: {cfg.deterministic}") + set_random_seed(seed, deterministic=cfg.deterministic) + meta['seed'] = seed + + # Set model + model = ViTPose(cfg.model) + if cfg.resume_from: + # Load ckpt partially + ckpt_state = torch.load(cfg.resume_from)['state_dict'] + ckpt_state.pop('keypoint_head.final_layer.bias') + ckpt_state.pop('keypoint_head.final_layer.weight') + model.load_state_dict(ckpt_state, strict=False) + + # freeze the backbone, leave the head to be finetuned + model.backbone.frozen_stages = model.backbone.depth - 1 + model.backbone.freeze_ffn = True + model.backbone.freeze_attn = True + model.backbone._freeze_stages() + + # Set dataset + datasets_train = COCODataset( + root_path=cfg.data_root, + data_version="feet_train", + is_train=True, + use_gt_bboxes=True, + image_width=192, + image_height=256, + scale=True, + scale_factor=0.35, + flip_prob=0.5, + rotate_prob=0.5, + rotation_factor=45., + half_body_prob=0.3, + use_different_joints_weight=True, + heatmap_sigma=3, + soft_nms=False + ) + + datasets_valid = COCODataset( + root_path=cfg.data_root, + data_version="feet_val", + is_train=False, + use_gt_bboxes=True, + image_width=192, + image_height=256, + scale=False, + scale_factor=0.35, + flip_prob=0.5, + rotate_prob=0.5, + rotation_factor=45., + half_body_prob=0.3, + use_different_joints_weight=True, + heatmap_sigma=3, + soft_nms=False + ) + + train_model( + model=model, + datasets_train=datasets_train, + datasets_valid=datasets_valid, + cfg=cfg, + distributed=distributed, + validate=cfg.validate, + timestamp=timestamp, + meta=meta + ) + + +if __name__ == '__main__': + main() diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb b/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..636534d6375bd61eb181b0cf2080f175d6130a87 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb @@ -0,0 +1,2423 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "dcfcb0a2-93fb-4f3c-aa40-56fbe6a5dcff", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "from easy_ViTPose import VitInference\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Image to run inference RGB format\n", + "img = cv2.imread('testVITPOSE.jpg')\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + "# set is_video=True to enable tracking in video inference\n", + "# be sure to use VitInference.reset() function to reset the tracker after each video\n", + "# There are a few flags that allows to customize VitInference, be sure to check the class definition\n", + "model_path = r'C:\\Users\\user\\ViTPose/ckpts/vitpose-s-coco_25.pth'\n", + "yolo_path = r'C:\\Users\\user\\ViTPose/yolov8s.pt'\n", + "\n", + "# If you want to use MPS (on new macbooks) use the torch checkpoints for both ViTPose and Yolo\n", + "# If device is None will try to use cuda -> mps -> cpu (otherwise specify 'cpu', 'mps' or 'cuda')\n", + "# dataset and det_class parameters can be inferred from the ckpt name, but you can specify them.\n", + "model = VitInference(model_path, yolo_path, model_name='s', yolo_size=320, is_video=False, device=\"cuda\")\n", + "\n", + "# Infer keypoints, output is a dict where keys are person ids and values are keypoints (np.ndarray (25, 3): (y, x, score))\n", + "# If is_video=True the IDs will be consistent among the ordered video frames.\n", + "keypoints = model.inference(img)\n", + "\n", + "# call model.reset() after each video\n", + "\n", + "img = model.draw(show_yolo=True) # Returns RGB image with drawings\n", + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "772c119d-0e34-488a-bcec-40e0007155aa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9e2a99d2-ece2-4f00-b9e1-e130099026bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "id": "ea96beea-c174-45c4-9119-e3db40f18793", + "metadata": {}, + "source": [ + "# Training the ViT_Pose" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba4a27fc-20e0-433f-9de5-65320f963af9", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) OpenMMLab. All rights reserved.\n", + "import argparse\n", + "import copy\n", + "import os\n", + "import os.path as osp\n", + "import time\n", + "import warnings\n", + "import click\n", + "import yaml\n", + "\n", + "from glob import glob\n", + "\n", + "import torch\n", + "import torch.distributed as dist\n", + "\n", + "from vit_utils.util import init_random_seed, set_random_seed\n", + "from vit_utils.dist_util import get_dist_info, init_dist\n", + "from vit_utils.logging import get_root_logger\n", + "\n", + "import configs.ViTPose_small_coco_256x192 as s_cfg\n", + "# import configs.ViTPose_base_coco_256x192 as b_cfg\n", + "# import configs.ViTPose_large_coco_256x192 as l_cfg\n", + "# import configs.ViTPose_huge_coco_256x192 as h_cfg\n", + "\n", + "from vit_models.model import ViTPose\n", + "from datasets.COCO import COCODataset\n", + "from vit_utils.train_valid_fn import train_model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ef1a26d-9303-4859-9112-bedea1dd46e8", + "metadata": {}, + "outputs": [], + "source": [ + "__file__ = r\"C:\\Users\\user\\ViTPose\\easy_ViTPose\\easy_ViTPose\"\n", + "CUR_PATH = osp.dirname(__file__)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "21be3367-277e-4d8c-8fca-d7524235c21b", + "metadata": {}, + "outputs": [], + "source": [ + "model_name = 's'\n", + "config_path = 'config.yaml'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16e707e1-e55b-4c44-abc3-fd217a60b381", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2d5c73bb-6486-4513-af1c-3c37c08e80f8", + "metadata": {}, + "source": [ + "### Loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41ea408e-c350-48d5-bf88-d9a2a68322c2", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "\n", + "# Load the JSON file\n", + "with open(r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\", 'r') as f:\n", + " coco_data = json.load(f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7bee2d84-71c7-4f53-8154-3b7340bd8708", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "590ad908-cc80-4c4e-a2af-88450a2aa77e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c1fa1c4b-75ff-4ed9-a46d-90c639acae41", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a mapping of image_id to file_name\n", + "image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8b2585-0ef4-4dc2-86ef-ab6d5d799075", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b83f079-efd1-416b-ab6c-29e80e668cff", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dde6eac-a62d-49b1-ad27-a39c114e0f1b", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "37899bdc-69a4-4271-8fd7-aa03148883a2", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example: Process keypoints for one annotation\n", + "# for ann in annotations:\n", + "# keypoints = ann['keypoints']\n", + "# keypoints_array = [keypoints[i:i + 3] for i in range(0, len(keypoints), 3)]\n", + "# print(\"Keypoints:\", keypoints_array)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9942e11-9394-4f67-a5ed-2ee700d33625", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b030648f-8e1f-4abe-8351-a7ae34cb3bb2", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9b30c5c1-6657-4102-8cd6-3f68b100bf61", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "data_dir = r'D:\\ViTPose\\Evaluating\\val2017\\\\'\n", + "dataset = []\n", + "\n", + "for ann in coco_data['annotations']:\n", + " image_id = ann['image_id']\n", + " #print(\"image_id: \", image_id)\n", + " file_name = image_id_to_filename[image_id]\n", + " #print(\"file_name: \", file_name)\n", + " image_path = os.path.join(data_dir, file_name)\n", + " #print(\"image_path: \", image_path)\n", + " # Load the image\n", + " if not os.path.exists(image_path):\n", + " continue\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints_array = np.array([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)])\n", + " \n", + " # Collect data\n", + " dataset.append((image, keypoints_array))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a9c3c26-7d13-4103-97c1-f5d51cef5584", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "47734b7b-3c0f-4e58-abe6-bc6a70dc29c9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "397133\n", + "000000397133.jpg\n" + ] + } + ], + "source": [ + "print(coco_data['images'][0]['id'])\n", + "print(coco_data['images'][0]['file_name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9463a1ea-09be-4138-b6d7-501a4f25c2f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Apply scaling transformation for each keypoint\n", + "def resize_keypoints(keypoints, scale_w, scale_h):\n", + " resized_keypoints = keypoints.clone()\n", + " \n", + " for j in range(keypoints.shape[0]):\n", + " x, y, visibility = keypoints[j]\n", + " # Only resize if visibility > 0 (to ignore invisible keypoints)\n", + " if visibility > 0:\n", + " resized_keypoints[j, 0] = int(x * scale_w)\n", + " resized_keypoints[j, 1] = int(y * scale_h)\n", + " \n", + " return resized_keypoints\n", + "\n", + "\n", + "\n", + "def transformKeypoint(img, target_shape, keypoints):\n", + " orig_width, orig_height = img.width, img.height\n", + " (target_width, target_height) = target_shape\n", + " \n", + " # Scaling factors for width and height\n", + " scale_w = target_width / orig_width\n", + " scale_h = target_height / orig_height\n", + " # Resized keypoints\n", + " resized_keypoints = resize_keypoints(keypoints, scale_w, scale_h)\n", + " \n", + " # Print the resized keypoints\n", + " #print(\"Resized Keypoints:\\n\", resized_keypoints)\n", + " return resized_keypoints\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "012be853-653e-4651-9861-fc2e11a00a00", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be1f8f9d-2c11-4ddc-a646-e193b79d3829", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3faf2805-5a62-4f5a-967b-4e7ec1c32c87", + "metadata": {}, + "outputs": [], + "source": [ + "target_shape = (208, 208)\n", + "import torch\n", + "from torch.utils.data import Dataset\n", + "\n", + "class COCOKeypointsDataset(Dataset):\n", + " def __init__(self, json_path, images_dir, transform=None, transformKP = None):\n", + " with open(json_path, 'r') as f:\n", + " coco_data = json.load(f)\n", + " \n", + " self.image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}\n", + " self.annotations = coco_data['annotations']\n", + " self.images_dir = images_dir\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.annotations)\n", + "\n", + " def __getitem__(self, idx):\n", + " # Get annotation\n", + " ann = self.annotations[idx]\n", + " image_id = ann['image_id']\n", + " file_name = self.image_id_to_filename[image_id]\n", + " image_path = os.path.join(self.images_dir, file_name)\n", + " \n", + " # Load image\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints = torch.tensor([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)], dtype=torch.float32) \n", + " keypoints = transformKeypoint(image, target_shape, keypoints)\n", + " #print(\"keypoints: \", keypoints)\n", + " \n", + " # Apply transformations\n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, keypoints\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "960b56d0-391d-4cd5-886c-c951d5e5bf63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccddf3cf-5b28-4fad-a467-917a53d19d63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47ebf732-8f35-4caa-85ec-5dabb6e95e93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "05380b1e-f0d4-4dcc-84de-147726da3ac4", + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision import transforms\n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((208, 208)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "dataset = COCOKeypointsDataset(\n", + " json_path=r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\",\n", + " images_dir=r'D:\\ViTPose\\Evaluating\\val2017\\\\',\n", + " transform=transform\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "62efbb61-7d6e-4b8d-9fe5-537ca0f7ee04", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "dataloader = DataLoader(dataset, batch_size=4, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c2a8ab8-5496-462d-a58b-f87f06e427bf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d9d940c5-13f6-4b24-a887-28f08f370d04", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Images shape: torch.Size([4, 3, 208, 208])\n", + "Keypoints shape: torch.Size([4, 17, 3])\n", + "keypoints: tensor([[[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [150., 2., 2.],\n", + " [146., 10., 2.],\n", + " [ 0., 0., 0.],\n", + " [145., 18., 2.],\n", + " [ 0., 0., 0.],\n", + " [148., 20., 2.],\n", + " [151., 19., 2.],\n", + " [146., 33., 1.],\n", + " [151., 33., 1.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[152., 67., 2.],\n", + " [155., 65., 2.],\n", + " [150., 64., 2.],\n", + " [158., 65., 2.],\n", + " [ 0., 0., 0.],\n", + " [163., 81., 2.],\n", + " [146., 76., 2.],\n", + " [166., 104., 2.],\n", + " [140., 88., 2.],\n", + " [160., 123., 2.],\n", + " [141., 99., 2.],\n", + " [156., 119., 2.],\n", + " [146., 115., 2.],\n", + " [154., 149., 2.],\n", + " [142., 146., 2.],\n", + " [152., 177., 2.],\n", + " [144., 171., 2.]]])\n" + ] + } + ], + "source": [ + "for images, keypoints in dataloader:\n", + " print(\"Images shape:\", images.shape)\n", + " print(\"Keypoints shape:\", keypoints.shape)\n", + " print(\"keypoints: \", keypoints)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b26cfb19-15d6-47a6-8114-6ef1385d6fbc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e5e00bc-e79f-408f-bd3c-7663225cde47", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e24981bc-7a91-45ba-bcc5-d79a7604b8b3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "670e81c3-27a2-43ef-a149-f4d88d7214c4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "97e0ee06-e303-4a6c-8cda-eb6087693980", + "metadata": {}, + "source": [ + "### Ending loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8334085f-85d4-4889-9f7f-71e8b7b6adc5", + "metadata": {}, + "outputs": [], + "source": [ + "cfg = {'s':s_cfg}.get(model_name.lower())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b7b53af5-0822-47a4-be61-6f8b2de9f9c6", + "metadata": {}, + "outputs": [], + "source": [ + "# Load config.yaml\n", + "with open(config_path, 'r') as f:\n", + " cfg_yaml = yaml.load(f, Loader=yaml.SafeLoader)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7ef13d0b-2fd5-4313-9822-8b1626da933f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'log_level': 'logging.INFO',\n", + " 'seed': 0,\n", + " 'gpu_ids': [0],\n", + " 'deterministic': True,\n", + " 'cudnn_benchmark': True,\n", + " 'resume_from': 'C:/Users/user/ViTPose/ckpts/vitpose-s-coco_25.pth',\n", + " 'launcher': 'none',\n", + " 'use_amp': False,\n", + " 'validate': True,\n", + " 'autoscale_lr': False,\n", + " 'dist_params': '...'}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg_yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "64402e77-c6b8-49bb-90db-6693de309268", + "metadata": {}, + "outputs": [], + "source": [ + "for k, v in cfg_yaml.items():\n", + " if hasattr(cfg, k):\n", + " raise ValueError(f\"Already exists {k} in config\")\n", + " else:\n", + " cfg.__setattr__(k, v)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98b406f9-d79a-40ed-af8a-e73d4808776a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "057c9e72-4693-4387-a141-a844159b6410", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88841210-3245-47d4-8fea-22a3fdff04ab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "765d06d7-dcc9-46a0-a9bc-9569ff314eec", + "metadata": {}, + "outputs": [], + "source": [ + "# set cudnn_benchmark\n", + "if cfg.cudnn_benchmark:\n", + " torch.backends.cudnn.benchmark = True" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "14bcd3c1-01e4-4308-a693-7cba5b28ec97", + "metadata": {}, + "outputs": [], + "source": [ + "# Set work directory (session-level)\n", + "if not hasattr(cfg, 'work_dir'):\n", + " cfg.__setattr__('work_dir', f\"{CUR_PATH}/runs/train\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fe3506fa-36d0-461e-8f18-856a35ae3268", + "metadata": {}, + "outputs": [], + "source": [ + "if not osp.exists(cfg.work_dir):\n", + " os.makedirs(cfg.work_dir)\n", + "session_list = sorted(glob(f\"{cfg.work_dir}/*\"))\n", + "if len(session_list) == 0:\n", + " session = 1\n", + "else:\n", + " session = int(os.path.basename(session_list[-1])) + 1\n", + "session_dir = osp.join(cfg.work_dir, str(session).zfill(3))\n", + "os.makedirs(session_dir)\n", + "cfg.__setattr__('work_dir', session_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "aaffeee8-3d10-4cb8-ab1b-98f79bdb9910", + "metadata": {}, + "outputs": [], + "source": [ + "if cfg.autoscale_lr:\n", + " # apply the linear scaling rule (https://arxiv.org/abs/1706.02677)\n", + " cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c022f17-9135-4317-a8ca-e7d4b51b4d1a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bc6c864a-6cf0-4599-aa2a-0de7f6fd19ec", + "metadata": {}, + "outputs": [], + "source": [ + "# init distributed env first, since logger depends on the dist info.\n", + "if cfg.launcher == 'none':\n", + " distributed = False\n", + " if len(cfg.gpu_ids) > 1:\n", + " warnings.warn(\n", + " f\"We treat {cfg['gpu_ids']} as gpu-ids, and reset to \"\n", + " f\"{cfg['gpu_ids'][0:1]} as gpu-ids to avoid potential error in \"\n", + " \"non-distribute training time.\")\n", + " cfg.gpu_ids = cfg.gpu_ids[0:1]\n", + "else:\n", + " distributed = True\n", + " init_dist(cfg.launcher, **cfg.dist_params)\n", + " # re-set gpu_ids with distributed training mode\n", + " _, world_size = get_dist_info()\n", + " cfg.gpu_ids = range(world_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "935e56e5-d5d1-4f19-bba0-6d659665c570", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3881144e-53b7-4a2b-b878-0d8c43a17d82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-25 08:52:31,377 - vit_utils - INFO - Distributed training: False\n", + "2024-12-25 08:52:31,378 - vit_utils - INFO - Set random seed to 0, deterministic: True\n" + ] + } + ], + "source": [ + "# init the logger before other steps\n", + "timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())\n", + "log_file = osp.join(session_dir, f'{timestamp}.log')\n", + "logger = get_root_logger(log_file=log_file)\n", + "\n", + "# init the meta dict to record some important information such as\n", + "# environment info and seed, which will be logged\n", + "meta = dict()\n", + "\n", + "# log some basic info\n", + "logger.info(f'Distributed training: {distributed}')\n", + "\n", + "# set random seeds\n", + "seed = init_random_seed(cfg.seed)\n", + "logger.info(f\"Set random seed to {seed}, \"\n", + " f\"deterministic: {cfg.deterministic}\")\n", + "set_random_seed(seed, deterministic=cfg.deterministic)\n", + "meta['seed'] = seed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0588f6f-6fe0-4ac6-9fcf-a2c744e68091", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5878400f-1165-4301-aad8-aef907113a4a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_19640\\1963230343.py:5: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n" + ] + } + ], + "source": [ + "# Set model\n", + "model = ViTPose(cfg.model)\n", + "if cfg.resume_from:\n", + " # Load ckpt partially\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n", + " ckpt_state.pop('keypoint_head.final_layer.bias')\n", + " ckpt_state.pop('keypoint_head.final_layer.weight')\n", + " model.load_state_dict(ckpt_state, strict=False)\n", + "\n", + " # freeze the backbone, leave the head to be finetuned\n", + " model.backbone.frozen_stages = model.backbone.depth - 1\n", + " model.backbone.freeze_ffn = True\n", + " model.backbone.freeze_attn = True\n", + " model.backbone._freeze_stages()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52cef111-bc9c-417d-9770-7595408863be", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "93e7765d-94ca-4a16-b4d6-c95085bfad35", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ViTPose(\n", + " (backbone): ViT(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 384, kernel_size=(16, 16), stride=(16, 16), padding=(2, 2))\n", + " )\n", + " (blocks): ModuleList(\n", + " (0): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.00909090880304575)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (2): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0181818176060915)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (3): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.027272727340459824)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (4): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.036363635212183)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (5): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.045454543083906174)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (6): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.054545458406209946)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (7): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.06363636255264282)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (8): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0727272778749466)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (9): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.08181818574666977)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (10): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.09090909361839294)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (11): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.10000000149011612)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (last_norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " )\n", + " (keypoint_head): TopdownHeatmapSimpleHead(\n", + " (deconv_layers): Sequential(\n", + " (0): ConvTranspose2d(384, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): ConvTranspose2d(256, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " )\n", + " (final_layer): Conv2d(256, 17, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + ")" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "851da2fd-707c-4dc9-bca0-99ac5530374a", + "metadata": {}, + "outputs": [], + "source": [ + "# Set dataset\n", + "datasets_train = dataloader\n", + "datasets_valid = dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d352a68-dccd-4d94-86c7-deb716545df4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5af32dc2-8a9c-4abf-bc31-1454d64622e2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 1:\n", + " - Images: torch.Size([4, 3, 208, 208])\n", + " - Labels: tensor([[[ 83., 46., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 83., 44., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 79., 44., 2.],\n", + " [ 83., 53., 2.],\n", + " [ 75., 54., 2.],\n", + " [ 86., 64., 2.],\n", + " [ 78., 70., 2.],\n", + " [ 90., 78., 2.],\n", + " [ 87., 79., 2.],\n", + " [ 83., 80., 2.],\n", + " [ 78., 81., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 80., 99., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 121., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [200., 83., 2.],\n", + " [ 0., 0., 0.],\n", + " [192., 150., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 48., 2.],\n", + " [ 63., 59., 2.],\n", + " [ 64., 60., 2.],\n", + " [ 70., 82., 2.],\n", + " [ 72., 85., 2.],\n", + " [ 83., 83., 2.],\n", + " [ 76., 62., 2.],\n", + " [ 58., 107., 2.],\n", + " [ 58., 109., 2.],\n", + " [ 83., 87., 2.],\n", + " [ 84., 98., 2.],\n", + " [ 75., 115., 1.],\n", + " [ 77., 141., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]]])\n" + ] + } + ], + "source": [ + "# Iterate Through the DataLoader\n", + "for batch_idx, (images, labels) in enumerate(dataloader):\n", + " print(f\"Batch {batch_idx + 1}:\")\n", + " print(f\" - Images: {images.shape}\") # Shape: (batch_size, 3, H, W)\n", + " print(f\" - Labels: {labels}\") # Tensor of labels\n", + " # Perform operations on images and labels (e.g., training)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c7000fcb-4487-4671-a88c-635da8e17d93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([17, 3])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68165efc-54b3-4774-81d7-5e87b409219f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "48811727-c7b5-48ec-8d2e-234e14cd1312", + "metadata": {}, + "source": [ + "train_model(\n", + " model=model,\n", + " datasets_train=datasets_train,\n", + " datasets_valid=datasets_valid,\n", + " cfg=cfg,\n", + " distributed=distributed,\n", + " validate=cfg.validate,\n", + " timestamp=timestamp,\n", + " meta=meta\n", + " )" + ] + }, + { + "cell_type": "raw", + "id": "62b37ca0-46a6-49e9-8d7b-5f0c69b93f20", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import os.path as osp\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "from vit_models.losses import JointsMSELoss\n", + "from vit_models.optimizer import LayerDecayOptimizer\n", + "\n", + "from torch.nn.parallel import DataParallel, DistributedDataParallel\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.optim.lr_scheduler import LambdaLR, MultiStepLR\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from torch.utils.data.distributed import DistributedSampler\n", + "from torch.cuda.amp import autocast, GradScaler\n", + "from tqdm import tqdm\n", + "from time import time\n", + "\n", + "\n", + "logger = get_root_logger()\n", + "\n", + " \n", + "dataloaders_train = datasets_train\n", + "dataloaders_valid = datasets_valid\n", + "# put model on gpus\n", + "if distributed:\n", + " find_unused_parameters = cfg.get('find_unused_parameters', False)\n", + " # Sets the `find_unused_parameters` parameter in\n", + " # torch.nn.parallel.DistributedDataParallel\n", + "\n", + " model = DistributedDataParallel(\n", + " module=model, \n", + " device_ids=[torch.cuda.current_device()], \n", + " broadcast_buffers=False, \n", + " find_unused_parameters=find_unused_parameters)\n", + "else:\n", + " model = DataParallel(model, device_ids=cfg.gpu_ids)\n", + "\n", + "# Loss function\n", + "criterion = JointsMSELoss(use_target_weight=cfg.model['keypoint_head']['loss_keypoint']['use_target_weight'])\n", + "\n", + "# Optimizer\n", + "optimizer = AdamW(model.parameters(), lr=cfg.optimizer['lr'], betas=cfg.optimizer['betas'], weight_decay=cfg.optimizer['weight_decay'])\n", + "\n", + "# Layer-wise learning rate decay\n", + "lr_mult = [cfg.optimizer['paramwise_cfg']['layer_decay_rate']] * cfg.optimizer['paramwise_cfg']['num_layers']\n", + "layerwise_optimizer = LayerDecayOptimizer(optimizer, lr_mult)\n", + "\n", + "\n", + "# Learning rate scheduler (MultiStepLR)\n", + "milestones = cfg.lr_config['step']\n", + "gamma = 0.1\n", + "scheduler = MultiStepLR(optimizer, milestones, gamma)\n", + "\n", + "# Warm-up scheduler\n", + "num_warmup_steps = cfg.lr_config['warmup_iters'] # Number of warm-up steps\n", + "warmup_factor = cfg.lr_config['warmup_ratio'] # Initial learning rate = warmup_factor * learning_rate\n", + "warmup_scheduler = LambdaLR(\n", + " optimizer,\n", + " lr_lambda=lambda step: warmup_factor + (1.0 - warmup_factor) * step / num_warmup_steps\n", + ")\n", + "\n", + "# AMP setting\n", + "if cfg.use_amp:\n", + " logger.info(\"Using Automatic Mixed Precision (AMP) training...\")\n", + " # Create a GradScaler object for FP16 training\n", + " scaler = GradScaler()\n", + "\n", + "# Logging config\n", + "total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "logger.info(f'''\\n\n", + "#========= [Train Configs] =========#\n", + "# - Num GPUs: {len(cfg.gpu_ids)}\n", + "# - Batch size (per gpu): {cfg.data['samples_per_gpu']}\n", + "# - LR: {cfg.optimizer['lr']: .6f}\n", + "# - Num params: {total_params:,d}\n", + "# - AMP: {cfg.use_amp}\n", + "#===================================# \n", + "''')\n", + "\n", + "global_step = 0\n", + "for dataloader in dataloaders_train:\n", + " print(\"start training\")\n", + " for epoch in range(cfg.total_epochs):\n", + " model.train()\n", + " train_pbar = tqdm(dataloader)\n", + " total_loss = 0\n", + " tic = time()\n", + " for batch_idx, batch in enumerate(train_pbar):\n", + " layerwise_optimizer.zero_grad()\n", + " \n", + " images, targets, target_weights, __ = batch\n", + " images = images.to('cuda').unsqueeze(0)\n", + " targets = targets.to('cuda').unsqueeze(0)\n", + " target_weights = target_weights.to('cuda')\n", + " \n", + " if cfg.use_amp:\n", + " with autocast():\n", + " outputs = model(images)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " scaler.scale(loss).backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " scaler.step(layerwise_optimizer)\n", + " scaler.update()\n", + " else:\n", + " print(images.shape)\n", + " outputs = model(images)\n", + " print(\"outputs: \", outputs.shape)\n", + " print(\"targets: \", targets.shape)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " loss.backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " layerwise_optimizer.step()\n", + " \n", + " if global_step < num_warmup_steps:\n", + " warmup_scheduler.step()\n", + " global_step += 1\n", + " \n", + " total_loss += loss.item()\n", + " train_pbar.set_description(f\"🏋️> Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Loss {loss.item():.4f} | LR {optimizer.param_groups[0]['lr']:.6f} | Step\")\n", + " scheduler.step()\n", + " \n", + " avg_loss_train = total_loss/len(dataloader)\n", + " logger.info(f\"[Summary-train] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (train) {avg_loss_train:.4f} --- {time()-tic:.5f} sec. elapsed\")\n", + " ckpt_name = f\"epoch{str(epoch).zfill(3)}.pth\"\n", + " ckpt_path = osp.join(cfg.work_dir, ckpt_name)\n", + " torch.save(model.module.state_dict(), ckpt_path)\n", + "\n", + " # validation\n", + " if validate:\n", + " tic2 = time()\n", + " avg_loss_valid = valid_model(model, dataloaders_valid, criterion, cfg)\n", + " logger.info(f\"[Summary-valid] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (valid) {avg_loss_valid:.4f} --- {time()-tic2:.5f} sec. elapsed\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c3aaa51-efa5-414c-a0a8-9f3b475ca67e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2f0dd2c-ceaa-40c1-943f-3392c4bb1b3d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc8f7cda-227e-4a03-b694-97af713b73f6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91348ce9-12d7-4882-b222-b9b60cedebec", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e63562-cc6c-460d-aab5-f2f9bb5724cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6b2dd91c-9830-41a3-bddd-6c2f09254a7c", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda')\n", + "# Move model to device\n", + "model = model.to(device)\n", + "\n", + "# Move inputs to device\n", + "images = images.to(device)\n" + ] + }, + { + "cell_type": "markdown", + "id": "faf1e322-2867-47d7-8778-09e83ead56ef", + "metadata": {}, + "source": [ + "## Define my own training process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cbc9686-7e2f-4fcb-af2b-b260fb8051f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4ed1ef2-58d7-4d18-9966-1ebb95adc529", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e568149-21ff-47c5-93f1-35d7290b837f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0a0a470-7c51-4027-b1cb-85d5a52bb28e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "430f8a82-9c8f-4014-b3ff-ac9548213294", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4b00355-74b1-4f87-abd1-2e2dc31846e6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2de2c69e-ebc5-4e96-aa0e-5aab0cc88c31", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "867a6faa-7419-4a01-9719-2739639be673", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "def generate_heatmaps(keypoints, output_size):\n", + " \"\"\"\n", + " Generate heatmaps from keypoints for training.\n", + " Args:\n", + " - keypoints: Tensor of shape (batch_size, num_keypoints, 3) containing (x, y, visibility)\n", + " - output_size: (height, width) of the heatmaps\n", + " Returns:\n", + " - heatmaps: Tensor of shape (batch_size, num_keypoints, height, width)\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros(batch_size, num_keypoints, height, width, device=keypoints.device)\n", + "\n", + " #print(\"heatmaps: \", heatmaps)\n", + " for i in range(batch_size):\n", + " for j in range(num_keypoints):\n", + " x, y, visibility = keypoints[i, j, 0], keypoints[i, j, 1], keypoints[i, j, 2]\n", + " if visibility > 0:\n", + " # Create a Gaussian heatmap for each keypoint\n", + " gaussian = generate_gaussian(x, y, height, width)\n", + " print(\"gaussian max: \", gaussian.max())\n", + " print(\"gaussian min: \", gaussian.min())\n", + " heatmaps[i, j] = gaussian\n", + "\n", + " return heatmaps\n", + "\n", + "def generate_gaussian(x, y, height, width, sigma=1):\n", + " \"\"\"\n", + " Generate a Gaussian heatmap centered at (x, y) with standard deviation sigma.\n", + " \"\"\"\n", + " grid_x, grid_y = torch.meshgrid(torch.arange(0, width), torch.arange(0, height))\n", + " grid = torch.stack([grid_x, grid_y], dim=-1).float()\n", + " \n", + " mean = torch.tensor([x, y], dtype=torch.float32)\n", + " variance = sigma ** 2\n", + " diff = grid - mean\n", + " dist = torch.sum(diff ** 2, dim=-1)\n", + " gaussian = torch.exp(-dist / (2 * variance))\n", + "\n", + " return gaussian\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdf3b94a-370e-481b-a1a6-9c165bc06e34", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3e554ac4-3b6f-4621-8bde-a358e68e8e25", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "images.shape: torch.Size([4, 3, 208, 208])\n", + "labels.shape: torch.Size([4, 17, 3])\n" + ] + } + ], + "source": [ + "for images, labels in dataloader:\n", + " print(\"images.shape: \", images.shape)\n", + " print(\"labels.shape: \", labels.shape)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f2e9ad48-4a8e-4bdd-91a2-68f810e859c4", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[32], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39mimshow(outputs[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 2\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'plt' is not defined" + ] + } + ], + "source": [ + "plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38308db6-5e0c-4d08-91c4-b7408adcb81a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf122f87-f911-4c39-a6fc-4f004d1988ce", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9c5386a0-b07b-47f5-be1e-9af65dcb6de2", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "\n", + "def generate_heatmaps(keypoints, output_size, sigma=2):\n", + " \"\"\"\n", + " Generate ground truth heatmaps for keypoints.\n", + " \n", + " Args:\n", + " keypoints: Tensor of shape (batch_size, num_keypoints, 3) with (x, y, confidence).\n", + " output_size: Tuple (height, width) of the heatmap.\n", + " sigma: Standard deviation of the Gaussian.\n", + " \n", + " Returns:\n", + " heatmaps: Tensor of shape (batch_size, num_keypoints, height, width).\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros((batch_size, num_keypoints, height, width), device=keypoints.device)\n", + "\n", + " for b in range(batch_size):\n", + " for k in range(num_keypoints):\n", + " x, y, confidence = keypoints[b, k]\n", + " \n", + " # Skip keypoints with zero confidence\n", + " if confidence <= 0 or x < 0 or y < 0:\n", + " continue\n", + " \n", + " # Create a meshgrid for Gaussian generation\n", + " xx, yy = torch.meshgrid(torch.arange(width, device=keypoints.device), \n", + " torch.arange(height, device=keypoints.device), \n", + " indexing='xy')\n", + " \n", + " # Calculate the 2D Gaussian heatmap\n", + " heatmap = torch.exp(-((xx - x)**2 + (yy - y)**2) / (2 * sigma**2))\n", + " heatmaps[b, k] = heatmap\n", + "\n", + " return heatmaps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b738642-c839-410a-8ba0-aa9698e70aa0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "6ca3122b-2019-4bc1-a8cd-39e7230d52de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated heatmaps shape: torch.Size([2, 17, 255, 255])\n" + ] + } + ], + "source": [ + "# Example usage\n", + "keypoints = torch.tensor([[[226., 129., 2.], [228., 127., 2.], [225., 127., 2.], [0., 0., 0.], [0., 0., 0.],\n", + " [233., 128., 2.], [218., 130., 2.], [239., 135., 2.], [213., 136., 2.], [243., 139., 2.],\n", + " [211., 137., 2.], [232., 149., 2.], [222., 148., 2.], [232., 169., 2.], [222., 169., 2.],\n", + " [233., 188., 2.], [221., 182., 2.]],\n", + " [[584., 101., 2.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [587., 137., 2.],\n", + " [637., 137., 2.], [567., 196., 2.], [0., 0., 0.], [561., 235., 2.], [619., 214., 2.],\n", + " [589., 222., 2.], [630., 224., 2.], [579., 317., 2.], [614., 309., 2.], [586., 400., 2.],\n", + " [611., 399., 2.]]], device='cuda:0')\n", + "\n", + "heatmaps = generate_heatmaps(keypoints, output_size=(255, 255), sigma=2)\n", + "\n", + "print(\"Generated heatmaps shape:\", heatmaps.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3615cb01-7df8-43d9-9bd1-16f644df0125", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAGiCAYAAACGUJO6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh+klEQVR4nO3de3BU5eH/8c/Z3ewSLrtpCMkmcjHgBSkXLWLMaKktGRKgVIXOiNIWOwyMNHGqeGscBbGdbxzaaTtaWqYzHekfopYZkZGpTBEM1BqipPJDUPM1+VEDJRsQftlNAtlks8/vD2TblXBJSFif5P2aOQ57ztnNc57Jztuze3bjGGOMAACwjCvVAwAAoDcIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASikL2Lp163T11VdryJAhKigo0HvvvZeqoQAALJSSgL366qtauXKlVq9erX/+85+aNm2aiouLdezYsVQMBwBgIScVX+ZbUFCgGTNm6He/+50kKR6Pa8yYMXrwwQf1s5/97EoPBwBgIc+V/oEdHR2qqalReXl5Yp3L5VJRUZGqqqq6vU80GlU0Gk3cjsfjOnnypEaOHCnHcfp9zACAvmWMUUtLi/Ly8uRy9e7FwCsesM8//1xdXV3KyclJWp+Tk6NPPvmk2/tUVFRozZo1V2J4AIAr6PDhwxo9enSv7nvFA9Yb5eXlWrlyZeJ2OBzW2LFjdbvmyqO0FI4MANAbMXXqHf1VI0aM6PVjXPGAZWVlye12q6mpKWl9U1OTgsFgt/fx+Xzy+XznrPcoTR6HgAGAdb64+uJy3ga64lcher1eTZ8+XTt27Eisi8fj2rFjhwoLC6/0cAAAlkrJS4grV67UkiVLdPPNN+uWW27Rb3/7W7W1tenHP/5xKoYDALBQSgJ2zz336Pjx41q1apVCoZBuvPFGbdu27ZwLOwAAOJ+UfA7sckUiEQUCAd2hO3kPDAAsFDOdqtQWhcNh+f3+Xj0G34UIALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAK/V5wJ555hk5jpO0TJw4MbG9vb1dpaWlGjlypIYPH66FCxeqqampr4cBABjg+uUM7Otf/7oaGxsTyzvvvJPY9vDDD+uNN97Qpk2btGvXLh09elQLFizoj2EAAAYwT788qMejYDB4zvpwOKw//elP2rhxo77zne9Ikl588UXdcMMN2rNnj2699db+GA4AYADqlzOwTz/9VHl5eRo/frwWL16shoYGSVJNTY06OztVVFSU2HfixIkaO3asqqqq+mMoAIABqs/PwAoKCrRhwwZdf/31amxs1Jo1a/TNb35TBw4cUCgUktfrVUZGRtJ9cnJyFAqFzvuY0WhU0Wg0cTsSifT1sAEAlunzgM2ZMyfx76lTp6qgoEDjxo3TX/7yF6Wnp/fqMSsqKrRmzZq+GiIAYADo98voMzIydN1116murk7BYFAdHR1qbm5O2qepqanb98zOKi8vVzgcTiyHDx/u51EDAL7q+j1gra2tqq+vV25urqZPn660tDTt2LEjsb22tlYNDQ0qLCw872P4fD75/f6kBQAwuPX5S4iPPvqo5s+fr3Hjxuno0aNavXq13G637r33XgUCAS1dulQrV65UZmam/H6/HnzwQRUWFnIFIgCgR/o8YEeOHNG9996rEydOaNSoUbr99tu1Z88ejRo1SpL0m9/8Ri6XSwsXLlQ0GlVxcbF+//vf9/UwAAADnGOMMakeRE9FIhEFAgHdoTvlcdJSPRwAQA/FTKcqtUXhcLjXbwvxXYgAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFipxwHbvXu35s+fr7y8PDmOo9dffz1puzFGq1atUm5urtLT01VUVKRPP/00aZ+TJ09q8eLF8vv9ysjI0NKlS9Xa2npZBwIAGFx6HLC2tjZNmzZN69at63b72rVr9fzzz2v9+vWqrq7WsGHDVFxcrPb29sQ+ixcv1sGDB7V9+3Zt3bpVu3fv1vLly3t/FACAQccxxphe39lxtHnzZt11112Szpx95eXl6ZFHHtGjjz4qSQqHw8rJydGGDRu0aNEiffzxx5o0aZLef/993XzzzZKkbdu2ae7cuTpy5Ijy8vIu+nMjkYgCgYDu0J3yOGm9HT4AIEViplOV2qJwOCy/39+rx+jT98AOHTqkUCikoqKixLpAIKCCggJVVVVJkqqqqpSRkZGIlyQVFRXJ5XKpurq628eNRqOKRCJJCwBgcOvTgIVCIUlSTk5O0vqcnJzEtlAopOzs7KTtHo9HmZmZiX2+rKKiQoFAILGMGTOmL4cNALCQFVchlpeXKxwOJ5bDhw+nekgAgBTr04AFg0FJUlNTU9L6pqamxLZgMKhjx44lbY/FYjp58mRiny/z+Xzy+/1JCwBgcOvTgOXn5ysYDGrHjh2JdZFIRNXV1SosLJQkFRYWqrm5WTU1NYl9du7cqXg8roKCgr4cDgBgAPP09A6tra2qq6tL3D506JD27dunzMxMjR07Vg899JB+8Ytf6Nprr1V+fr6efvpp5eXlJa5UvOGGG1RSUqJly5Zp/fr16uzsVFlZmRYtWnRJVyACACD1ImB79+7Vt7/97cTtlStXSpKWLFmiDRs26PHHH1dbW5uWL1+u5uZm3X777dq2bZuGDBmSuM9LL72ksrIyzZo1Sy6XSwsXLtTzzz/fB4cDABgsLutzYKnC58AAwG5fuc+BAQBwpRAwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAK3lSPQAAQB9wnPNvM+bKjeMKImAAYDvHkZwzL6g5ruSQmbiRFP/ixsAKGQEDAFt9ES7H5cjxeCS3W3K55LhdUtzIGCOns1OmKy6ZuExX14CKGAEDABs5jhy3W3K75Xg8coYOleNNk9I8Mh63nK64nFiXTHtUTjQqE4tJHR0DKmIEDABs5XbL8Xrl+LxyRgyTSfcpPsSjuNcjVywup7NLTutpOa0uqb39TLzOvqQ4ACJGwADANl+cfbl8PjnDhsqMGKaOXL+iGWnqGO5SbIgjd4fkiRqlHx+itOM+uVra5JIUj5+W6ZLO/MduBAwAbHL2fS+PR0ofIuMfrs5Rw9U8fohO5ziKfs0o5u+S+5RLnlaXhjf45E9zyXvcLXdHp5zOmNQhGWP/WRgBAwDLOC7nzMUaXq+6hvrUGUjT6WxHp/K6lJZzWlcFWtV8Kl1t4SFyt/vka/HIfdort88rx+2WccVSfQh9goABgE0cV+IMzAzxKhbw6XSmR6dGdyl7wgl9K7dOtw3/X33cfpU+iIxRdfQaeSMeeU6nKe1zn5TmkROLyTgu619GJGAAYBuXc2bxuBX3utQ1RJK/U+MDJ1Q4vE7fST+pDPcpdRmX9vrHKjbUo9gQR8btluM4F/7Qs0X4KikAsFncnLmoMObSqZhXka4hao7H1BIfotYun+Ixl5wuyYn/130sf+/rLM7AAMA2cXNmiXXJ3RmXJ2rktLl1tNWv/zN8rIa5OvRxe57+tzVbps0jd7vk7jByBtBnwCQCBgB2MXHJODKxmFyno/I0tyt9iFsj/q9X/+90ll475tffMibqVJtP8UiaRtR7NLyxS74TUTmtpxXv6Pziw8zxi/+srzgCBgCWMXEjdXXJtLfLafPKd9KjYSGPXDGXoi0+RYd75T3tyHNKGtYY15CTHXJHojIdHVJX15llACBgAGAT88U3aXR1yUQ75Go9JZfjaNgRt9JavepMfJA5LnfUKP3zDqUdb5PTckrmdLtMZ+xMAAfAS4kEDABsY8yZlwHbo4rH43KiHfK2dyitySt502TS3FL8i6+SOtUu03ZKpqNT8dPtA+blQ4mAAYCdzkasQ/85m2qPyvGc+XJfxf9zlmY6OmRisf/EawCcfUkEDADsZeJffK/hmT+V4rjdic96GWP+E7Gu+ICLl0TAAMBexkim68wrgl1dZ75d45x9BuYfs5QIGAAMDF/E7Jxv2RiA4TqLgAHAQDKAg/VlfJUUAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACv1OGC7d+/W/PnzlZeXJ8dx9Prrrydtv//+++U4TtJSUlKStM/Jkye1ePFi+f1+ZWRkaOnSpWptbb2sAwEADC49DlhbW5umTZumdevWnXefkpISNTY2JpaXX345afvixYt18OBBbd++XVu3btXu3bu1fPnyno8eADBo9fgvMs+ZM0dz5sy54D4+n0/BYLDbbR9//LG2bdum999/XzfffLMk6YUXXtDcuXP1q1/9Snl5eT0dEgBgEOqX98AqKyuVnZ2t66+/XitWrNCJEycS26qqqpSRkZGIlyQVFRXJ5XKpurq6P4YDABiAenwGdjElJSVasGCB8vPzVV9fryeffFJz5sxRVVWV3G63QqGQsrOzkwfh8SgzM1OhUKjbx4xGo4pGo4nbkUikr4cNALBMnwds0aJFiX9PmTJFU6dO1YQJE1RZWalZs2b16jErKiq0Zs2avhoiAGAA6PfL6MePH6+srCzV1dVJkoLBoI4dO5a0TywW08mTJ8/7vll5ebnC4XBiOXz4cH8PGwDwFdfvATty5IhOnDih3NxcSVJhYaGam5tVU1OT2Gfnzp2Kx+MqKCjo9jF8Pp/8fn/SAgAY3Hr8EmJra2vibEqSDh06pH379ikzM1OZmZlas2aNFi5cqGAwqPr6ej3++OO65pprVFxcLEm64YYbVFJSomXLlmn9+vXq7OxUWVmZFi1axBWIAIBL1uMzsL179+qmm27STTfdJElauXKlbrrpJq1atUput1v79+/X9773PV133XVaunSppk+frr///e/y+XyJx3jppZc0ceJEzZo1S3PnztXtt9+uP/7xj313VACAAc8xxphUD6KnIpGIAoGA7tCd8jhpqR4OAKCHYqZTldqicDjc67eF+C5EAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCs1KOAVVRUaMaMGRoxYoSys7N11113qba2Nmmf9vZ2lZaWauTIkRo+fLgWLlyopqampH0aGho0b948DR06VNnZ2XrssccUi8Uu/2gAAINGjwK2a9culZaWas+ePdq+fbs6Ozs1e/ZstbW1JfZ5+OGH9cYbb2jTpk3atWuXjh49qgULFiS2d3V1ad68eero6NC7776rP//5z9qwYYNWrVrVd0cFABjwHGOM6e2djx8/ruzsbO3atUszZ85UOBzWqFGjtHHjRn3/+9+XJH3yySe64YYbVFVVpVtvvVVvvvmmvvvd7+ro0aPKycmRJK1fv15PPPGEjh8/Lq/Xe9GfG4lEFAgEdIfulMdJ6+3wAQApEjOdqtQWhcNh+f3+Xj3GZb0HFg6HJUmZmZmSpJqaGnV2dqqoqCixz8SJEzV27FhVVVVJkqqqqjRlypREvCSpuLhYkUhEBw8e7PbnRKNRRSKRpAUAMLj1OmDxeFwPPfSQbrvtNk2ePFmSFAqF5PV6lZGRkbRvTk6OQqFQYp//jtfZ7We3daeiokKBQCCxjBkzprfDBgAMEL0OWGlpqQ4cOKBXXnmlL8fTrfLycoXD4cRy+PDhfv+ZAICvNk9v7lRWVqatW7dq9+7dGj16dGJ9MBhUR0eHmpubk87CmpqaFAwGE/u89957SY939irFs/t8mc/nk8/n681QAQADVI/OwIwxKisr0+bNm7Vz507l5+cnbZ8+fbrS0tK0Y8eOxLra2lo1NDSosLBQklRYWKgPP/xQx44dS+yzfft2+f1+TZo06XKOBQAwiPToDKy0tFQbN27Uli1bNGLEiMR7VoFAQOnp6QoEAlq6dKlWrlypzMxM+f1+PfjggyosLNStt94qSZo9e7YmTZqkH/7wh1q7dq1CoZCeeuoplZaWcpYFALhkPbqM3nGcbte/+OKLuv/++yWd+SDzI488opdfflnRaFTFxcX6/e9/n/Ty4GeffaYVK1aosrJSw4YN05IlS/Tcc8/J47m0nnIZPQDYrS8uo7+sz4GlCgEDALul/HNgAACkCgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACv1KGAVFRWaMWOGRowYoezsbN11112qra1N2ueOO+6Q4zhJywMPPJC0T0NDg+bNm6ehQ4cqOztbjz32mGKx2OUfDQBg0PD0ZOddu3aptLRUM2bMUCwW05NPPqnZs2fro48+0rBhwxL7LVu2TM8++2zi9tChQxP/7urq0rx58xQMBvXuu++qsbFRP/rRj5SWlqb/+Z//6YNDAgAMBj0K2LZt25Jub9iwQdnZ2aqpqdHMmTMT64cOHapgMNjtY/ztb3/TRx99pLfeeks5OTm68cYb9fOf/1xPPPGEnnnmGXm93l4cBgBgsLms98DC4bAkKTMzM2n9Sy+9pKysLE2ePFnl5eU6depUYltVVZWmTJminJycxLri4mJFIhEdPHjwcoYDABhEenQG9t/i8bgeeugh3XbbbZo8eXJi/X333adx48YpLy9P+/fv1xNPPKHa2lq99tprkqRQKJQUL0mJ26FQqNufFY1GFY1GE7cjkUhvhw0AGCB6HbDS0lIdOHBA77zzTtL65cuXJ/49ZcoU5ebmatasWaqvr9eECRN69bMqKiq0Zs2a3g4VADAA9eolxLKyMm3dulVvv/22Ro8efcF9CwoKJEl1dXWSpGAwqKampqR9zt4+3/tm5eXlCofDieXw4cO9GTYAYADpUcCMMSorK9PmzZu1c+dO5efnX/Q++/btkyTl5uZKkgoLC/Xhhx/q2LFjiX22b98uv9+vSZMmdfsYPp9Pfr8/aQEADG49egmxtLRUGzdu1JYtWzRixIjEe1aBQEDp6emqr6/Xxo0bNXfuXI0cOVL79+/Xww8/rJkzZ2rq1KmSpNmzZ2vSpEn64Q9/qLVr1yoUCumpp55SaWmpfD5f3x8hAGBAcowx5pJ3dpxu17/44ou6//77dfjwYf3gBz/QgQMH1NbWpjFjxujuu+/WU089lXTW9Nlnn2nFihWqrKzUsGHDtGTJEj333HPyeC6tp5FIRIFAQHfoTnmctEsdPgDgKyJmOlWpLQqHw71+Va1HAfuqCIfDysjI0O2aK48IGADYJqZOvaO/qrm5WYFAoFeP0eurEFOppaVFkvSO/prikQAALkdLS0uvA2blGVg8Hldtba0mTZqkw4cPc1FHNyKRiMaMGcP8XABzdGHMz8UxRxd2ofkxxqilpUV5eXlyuXr3nRpWnoG5XC5dddVVksRViRfB/Fwcc3RhzM/FMUcXdr756e2Z11n8ORUAgJUIGADAStYGzOfzafXq1Xx27DyYn4tjji6M+bk45ujC+nt+rLyIAwAAa8/AAACDGwEDAFiJgAEArETAAABWsjJg69at09VXX60hQ4aooKBA7733XqqHlDLPPPOMHMdJWiZOnJjY3t7ertLSUo0cOVLDhw/XwoULz/l7bAPJ7t27NX/+fOXl5clxHL3++utJ240xWrVqlXJzc5Wenq6ioiJ9+umnSfucPHlSixcvlt/vV0ZGhpYuXarW1tYreBT962JzdP/995/zO1VSUpK0z0Ceo4qKCs2YMUMjRoxQdna27rrrLtXW1ibtcynPq4aGBs2bN09Dhw5Vdna2HnvsMcVisSt5KP3iUubnjjvuOOd36IEHHkjapy/mx7qAvfrqq1q5cqVWr16tf/7zn5o2bZqKi4uT/r7YYPP1r39djY2NieW//0r2ww8/rDfeeEObNm3Srl27dPToUS1YsCCFo+1fbW1tmjZtmtatW9ft9rVr1+r555/X+vXrVV1drWHDhqm4uFjt7e2JfRYvXqyDBw9q+/bt2rp1q3bv3p30l8Ztd7E5kqSSkpKk36mXX345aftAnqNdu3aptLRUe/bs0fbt29XZ2anZs2erra0tsc/FnlddXV2aN2+eOjo69O677+rPf/6zNmzYoFWrVqXikPrUpcyPJC1btizpd2jt2rWJbX02P8Yyt9xyiyktLU3c7urqMnl5eaaioiKFo0qd1atXm2nTpnW7rbm52aSlpZlNmzYl1n388cdGkqmqqrpCI0wdSWbz5s2J2/F43ASDQfPLX/4ysa65udn4fD7z8ssvG2OM+eijj4wk8/777yf2efPNN43jOObf//73FRv7lfLlOTLGmCVLlpg777zzvPcZbHN07NgxI8ns2rXLGHNpz6u//vWvxuVymVAolNjnD3/4g/H7/SYajV7ZA+hnX54fY4z51re+ZX7605+e9z59NT9WnYF1dHSopqZGRUVFiXUul0tFRUWqqqpK4chS69NPP1VeXp7Gjx+vxYsXq6GhQZJUU1Ojzs7OpPmaOHGixo4dOyjn69ChQwqFQknzEQgEVFBQkJiPqqoqZWRk6Oabb07sU1RUJJfLperq6is+5lSprKxUdna2rr/+eq1YsUInTpxIbBtscxQOhyVJmZmZki7teVVVVaUpU6YoJycnsU9xcbEikYgOHjx4BUff/748P2e99NJLysrK0uTJk1VeXq5Tp04ltvXV/Fj1Zb6ff/65urq6kg5aknJycvTJJ5+kaFSpVVBQoA0bNuj6669XY2Oj1qxZo29+85s6cOCAQqGQvF6vMjIyku6Tk5OT+Gvag8nZY+7u9+fstlAopOzs7KTtHo9HmZmZg2bOSkpKtGDBAuXn56u+vl5PPvmk5syZo6qqKrnd7kE1R/F4XA899JBuu+02TZ48WZIu6XkVCoW6/T07u22g6G5+JOm+++7TuHHjlJeXp/379+uJJ55QbW2tXnvtNUl9Nz9WBQznmjNnTuLfU6dOVUFBgcaNG6e//OUvSk9PT+HIYKtFixYl/j1lyhRNnTpVEyZMUGVlpWbNmpXCkV15paWlOnDgQNL7yviP883Pf78fOmXKFOXm5mrWrFmqr6/XhAkT+uznW/USYlZWltxu9zlX+zQ1NSkYDKZoVF8tGRkZuu6661RXV6dgMKiOjg41Nzcn7TNY5+vsMV/o9ycYDJ5zQVAsFtPJkycH5ZxJ0vjx45WVlaW6ujpJg2eOysrKtHXrVr399tsaPXp0Yv2lPK+CwWC3v2dntw0E55uf7hQUFEhS0u9QX8yPVQHzer2aPn26duzYkVgXj8e1Y8cOFRYWpnBkXx2tra2qr69Xbm6upk+frrS0tKT5qq2tVUNDw6Ccr/z8fAWDwaT5iEQiqq6uTsxHYWGhmpubVVNTk9hn586disfjiSfhYHPkyBGdOHFCubm5kgb+HBljVFZWps2bN2vnzp3Kz89P2n4pz6vCwkJ9+OGHSaHfvn27/H6/Jk2adGUOpJ9cbH66s2/fPklK+h3qk/npxUUnKfXKK68Yn89nNmzYYD766COzfPlyk5GRkXQ1y2DyyCOPmMrKSnPo0CHzj3/8wxQVFZmsrCxz7NgxY4wxDzzwgBk7dqzZuXOn2bt3ryksLDSFhYUpHnX/aWlpMR988IH54IMPjCTz61//2nzwwQfms88+M8YY89xzz5mMjAyzZcsWs3//fnPnnXea/Px8c/r06cRjlJSUmJtuuslUV1ebd955x1x77bXm3nvvTdUh9bkLzVFLS4t59NFHTVVVlTl06JB56623zDe+8Q1z7bXXmvb29sRjDOQ5WrFihQkEAqaystI0NjYmllOnTiX2udjzKhaLmcmTJ5vZs2ebffv2mW3btplRo0aZ8vLyVBxSn7rY/NTV1Zlnn33W7N271xw6dMhs2bLFjB8/3sycOTPxGH01P9YFzBhjXnjhBTN27Fjj9XrNLbfcYvbs2ZPqIaXMPffcY3Jzc43X6zVXXXWVueeee0xdXV1i++nTp81PfvIT87Wvfc0MHTrU3H333aaxsTGFI+5fb7/9tpF0zrJkyRJjzJlL6Z9++mmTk5NjfD6fmTVrlqmtrU16jBMnTph7773XDB8+3Pj9fvPjH//YtLS0pOBo+seF5ujUqVNm9uzZZtSoUSYtLc2MGzfOLFu27Jz/QRzIc9Td3EgyL774YmKfS3le/etf/zJz5swx6enpJisryzzyyCOms7PzCh9N37vY/DQ0NJiZM2eazMxM4/P5zDXXXGMee+wxEw6Hkx6nL+aHP6cCALCSVe+BAQBwFgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABW+v8d0V2BGpROHwAAAABJRU5ErkJggg==", + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAGiCAYAAACGUJO6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiE0lEQVR4nO3df2zUdYL/8ddnOtOhBWa6pbTTyo8t+ANYfugC1kaX846GFjhPhUvEZXdxQyCyrVlFXa/GBdnbbA17ubu4xx655CL7h/grEYlklxyCLetaqnYlCGpj+2UtLkxBuM60hU7nx/v7BzLnaAVaWoZ35/lIJnQ+n898+v680+bJZ+bTGccYYwQAgGVc6R4AAACDQcAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFZKW8C2bNmib3/72xo1apTKysr0zjvvpGsoAAALpSVgL730ktavX6+NGzfqz3/+s+bMmaPKykqdPHkyHcMBAFjISceb+ZaVlWn+/Pn6j//4D0lSIpHQxIkT9dBDD+mf/umfrvZwAAAWcl/tb9jX16fm5mbV1tYml7lcLlVUVKixsbHfx0QiEUUikeT9RCKhM2fOaNy4cXIcZ9jHDAAYWsYYdXV1qaSkRC7X4J4MvOoB+/zzzxWPx1VUVJSyvKioSB9//HG/j6mrq9OmTZuuxvAAAFfRsWPHNGHChEE99qoHbDBqa2u1fv365P1QKKRJkybpDi2RW540jgwAMBgxRfWWfq+xY8cOeh9XPWAFBQXKyspSR0dHyvKOjg4FAoF+H+P1euX1er+23C2P3A4BAwDrfHH1xZW8DHTVr0LMzs7W3LlztXfv3uSyRCKhvXv3qry8/GoPBwBgqbQ8hbh+/XqtWrVK8+bN06233qp///d/V09Pj3784x+nYzgAAAulJWD33XefTp06pQ0bNigYDOrmm2/W7t27v3ZhBwAA3yQtfwd2pcLhsPx+v+7U3bwGBgAWipmo6rVToVBIPp9vUPvgvRABAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgpSEP2NNPPy3HcVJu06ZNS67v7e1VdXW1xo0bpzFjxmj58uXq6OgY6mEAAEa4YTkD+853vqMTJ04kb2+99VZy3SOPPKLXX39dr7zyihoaGnT8+HEtW7ZsOIYBABjB3MOyU7dbgUDga8tDoZD++7//W9u3b9ff/d3fSZKee+45TZ8+XQcOHNBtt902HMMBAIxAw3IG9sknn6ikpERTpkzRypUr1d7eLklqbm5WNBpVRUVFcttp06Zp0qRJamxsHI6hAABGqCE/AysrK9O2bdt000036cSJE9q0aZO+973v6fDhwwoGg8rOzlZeXl7KY4qKihQMBr9xn5FIRJFIJHk/HA4P9bABAJYZ8oAtXrw4+fXs2bNVVlamyZMn6+WXX1ZOTs6g9llXV6dNmzYN1RABACPAsF9Gn5eXpxtvvFGtra0KBALq6+tTZ2dnyjYdHR39vmZ2QW1trUKhUPJ27NixYR41AOBaN+wB6+7uVltbm4qLizV37lx5PB7t3bs3ub6lpUXt7e0qLy//xn14vV75fL6UGwAgsw35U4iPPfaY7rrrLk2ePFnHjx/Xxo0blZWVpfvvv19+v1+rV6/W+vXrlZ+fL5/Pp4ceekjl5eVcgQgAGJAhD9hnn32m+++/X6dPn9b48eN1xx136MCBAxo/frwk6d/+7d/kcrm0fPlyRSIRVVZW6re//e1QDwMAMMI5xhiT7kEMVDgclt/v1526W27Hk+7hAAAGKGaiqtdOhUKhQb8sxHshAgCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgpQEHbP/+/brrrrtUUlIix3H02muvpaw3xmjDhg0qLi5WTk6OKioq9Mknn6Rsc+bMGa1cuVI+n095eXlavXq1uru7r+hAAACZZcAB6+np0Zw5c7Rly5Z+12/evFnPPvustm7dqqamJo0ePVqVlZXq7e1NbrNy5UodOXJEe/bs0a5du7R//36tXbt28EcBAMg4jjHGDPrBjqMdO3bonnvukXT+7KukpESPPvqoHnvsMUlSKBRSUVGRtm3bphUrVuijjz7SjBkz9O6772revHmSpN27d2vJkiX67LPPVFJScsnvGw6H5ff7dafultvxDHb4AIA0iZmo6rVToVBIPp9vUPsY0tfAjh49qmAwqIqKiuQyv9+vsrIyNTY2SpIaGxuVl5eXjJckVVRUyOVyqampqd/9RiIRhcPhlBsAILMNacCCwaAkqaioKGV5UVFRcl0wGFRhYWHKerfbrfz8/OQ2X1VXVye/35+8TZw4cSiHDQCwkBVXIdbW1ioUCiVvx44dS/eQAABpNqQBCwQCkqSOjo6U5R0dHcl1gUBAJ0+eTFkfi8V05syZ5DZf5fV65fP5Um4AgMw2pAErLS1VIBDQ3r17k8vC4bCamppUXl4uSSovL1dnZ6eam5uT2+zbt0+JREJlZWVDORwAwAjmHugDuru71dramrx/9OhRHTx4UPn5+Zo0aZIefvhh/fKXv9QNN9yg0tJS/fznP1dJSUnySsXp06erqqpKa9as0datWxWNRlVTU6MVK1Zc1hWIAABIgwjYe++9p7/9279N3l+/fr0kadWqVdq2bZt+9rOfqaenR2vXrlVnZ6fuuOMO7d69W6NGjUo+5vnnn1dNTY0WLlwol8ul5cuX69lnnx2CwwEAZIor+juwdOHvwADAbtfc34EBAHC1EDAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASu50DwAA0A/H+eLfr5xnmMQX/5qrO55rEAEDgGuJ40iOS05WluRyzv/7JSYelxLm/L8mkdEhI2AAcK34Urwcj1uO2y153MnlSsTlRGMysZgkycQlKXMjRsAA4FrgfHG2lZUll9crJzdH8mbL5I6S+eIszInH5ZztlRPpk+ntVeJcrxSPf3E2lnkRI2AAcC1wXHLcbjnZ2XK+5VfCP1rxsaPUW5CtePb518Oy+oy8p/vk7u6T63+75JJkeiMyCXPhdCyjEDAASLcLZ18ej+T1yozJVXRcrnrzPeoJZCk+SjKO5D4nxbMdjTqTpexYQk5vRIon5MQTMhn4ehgBA4BrgJPlkpPtkTM6R5Hxo9U1wauzAUfdU2JyjY3KcaR4l0fRv7jVN8Ylf8LI23NOiselaFQm7sq4szACBgDpdOECjawsOaNGyYzOUW+BR90THJ2dHFPZrFZNHxNUlpPQ4a4SNWVNVcLjUXa3R57TOXJFYzKRPqkven5fGXQWRsAA4Frgckkul4zbpdgoR7HRRm5fn2aP/avm5f4/ZTtxeZy4DvqvU3SMW7FRrvMXd2S55DiOHJeTaSdgBAwA0s1xOXIcR3I5Mm6X4tmO4qOMxo7u1Yycv+pmb6c8chRO/FW+0b36PCdX8WyX5D4fvUxFwAAgzUzCyBgjJ56QE43Lfc7I0+1SKJSrP3XdoJ6EVx4npuaeUp3pHCNPl0uec0ZONC7F4jIZ9LThlxEwALgWxONSLCanN6rs7oSy/9elaIdXDeOuV9vYArldCf0llC/T4ZX3jKPsrricSFSKxaRE4vyl9BmGgAFAOhkjKXE+QtGonEifsjujyvncJZPl0uej8nVqtF+Oy0hdbo0+7lLOKaPscFROb59MNHo+fsl9ZQ4CBgDXABOLSed6JUmeoEf+6BjlfJ6tnFMexb0uyZGyeqWcz6PKDvXJfapLJtx1/g+ZY7H/e5PfDELAACDdjDn/FGA0JjkRubp6lCVp1Dmv3L2jFPecv1AjK5qQOxSRczYip6tHiS/idf6dODLr7EsiYABwbTCJ85fB90mJnrNy4gm5zkXkORuRx/3FO9LH4nLORWSiUZlzvefPvC68K30GImAAcC344rUwE0tI5xIyfX3n35Xe7ZZcX3w2WMIoEYudf/PeC2/im3xs5iFgAHCt+CJEFz7zS/G4TDSWEjCZL644zMD3PvwqAgYA15oLZ2NxSY6RvvwOG3wicxIBA4Br0YVAZdr7Qw1A5r4HCQDAagQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAVhpwwPbv36+77rpLJSUlchxHr732Wsr6Bx54QI7jpNyqqqpStjlz5oxWrlwpn8+nvLw8rV69Wt3d3Vd0IACAzDLggPX09GjOnDnasmXLN25TVVWlEydOJG8vvPBCyvqVK1fqyJEj2rNnj3bt2qX9+/dr7dq1Ax89ACBjDfgDLRcvXqzFixdfdBuv16tAINDvuo8++ki7d+/Wu+++q3nz5kmSfvOb32jJkiX6l3/5F5WUlAx0SACADDQsr4HV19ersLBQN910k9atW6fTp08n1zU2NiovLy8ZL0mqqKiQy+VSU1PTcAwHADACDfgM7FKqqqq0bNkylZaWqq2tTU8++aQWL16sxsZGZWVlKRgMqrCwMHUQbrfy8/MVDAb73WckElEkEkneD4fDQz1sAIBlhjxgK1asSH49a9YszZ49W1OnTlV9fb0WLlw4qH3W1dVp06ZNQzVEAMAIMOyX0U+ZMkUFBQVqbW2VJAUCAZ08eTJlm1gspjNnznzj62a1tbUKhULJ27Fjx4Z72ACAa9ywB+yzzz7T6dOnVVxcLEkqLy9XZ2enmpubk9vs27dPiURCZWVl/e7D6/XK5/Ol3AAAmW3ATyF2d3cnz6Yk6ejRozp48KDy8/OVn5+vTZs2afny5QoEAmpra9PPfvYzXX/99aqsrJQkTZ8+XVVVVVqzZo22bt2qaDSqmpoarVixgisQAQCXbcBnYO+9955uueUW3XLLLZKk9evX65ZbbtGGDRuUlZWlQ4cO6R/+4R904403avXq1Zo7d67++Mc/yuv1Jvfx/PPPa9q0aVq4cKGWLFmiO+64Q//1X/81dEcFABjxHGOMSfcgBiocDsvv9+tO3S2340n3cAAAAxQzUdVrp0Kh0KBfFuK9EAEAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsNKAAlZXV6f58+dr7NixKiws1D333KOWlpaUbXp7e1VdXa1x48ZpzJgxWr58uTo6OlK2aW9v19KlS5Wbm6vCwkI9/vjjisViV340AICMMaCANTQ0qLq6WgcOHNCePXsUjUa1aNEi9fT0JLd55JFH9Prrr+uVV15RQ0ODjh8/rmXLliXXx+NxLV26VH19fXr77bf1u9/9Ttu2bdOGDRuG7qgAACOeY4wxg33wqVOnVFhYqIaGBi1YsEChUEjjx4/X9u3b9Y//+I+SpI8//ljTp09XY2OjbrvtNv3hD3/Q3//93+v48eMqKiqSJG3dulVPPPGETp06pezs7Et+33A4LL/frzt1t9yOZ7DDBwCkScxEVa+dCoVC8vl8g9rHFb0GFgqFJEn5+fmSpObmZkWjUVVUVCS3mTZtmiZNmqTGxkZJUmNjo2bNmpWMlyRVVlYqHA7ryJEj/X6fSCSicDiccgMAZLZBByyRSOjhhx/W7bffrpkzZ0qSgsGgsrOzlZeXl7JtUVGRgsFgcpsvx+vC+gvr+lNXVye/35+8TZw4cbDDBgCMEIMOWHV1tQ4fPqwXX3xxKMfTr9raWoVCoeTt2LFjw/49AQDXNvdgHlRTU6Ndu3Zp//79mjBhQnJ5IBBQX1+fOjs7U87COjo6FAgEktu88847Kfu7cJXihW2+yuv1yuv1DmaoAIARakBnYMYY1dTUaMeOHdq3b59KS0tT1s+dO1cej0d79+5NLmtpaVF7e7vKy8slSeXl5frggw908uTJ5DZ79uyRz+fTjBkzruRYAAAZZEBnYNXV1dq+fbt27typsWPHJl+z8vv9ysnJkd/v1+rVq7V+/Xrl5+fL5/PpoYceUnl5uW677TZJ0qJFizRjxgz98Ic/1ObNmxUMBvXUU0+purqasywAwGUb0GX0juP0u/y5557TAw88IOn8HzI/+uijeuGFFxSJRFRZWanf/va3KU8Pfvrpp1q3bp3q6+s1evRorVq1Ss8884zc7svrKZfRA4DdhuIy+iv6O7B0IWAAYLe0/x0YAADpQsAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoDClhdXZ3mz5+vsWPHqrCwUPfcc49aWlpStrnzzjvlOE7K7cEHH0zZpr29XUuXLlVubq4KCwv1+OOPKxaLXfnRAAAyhnsgGzc0NKi6ulrz589XLBbTk08+qUWLFunDDz/U6NGjk9utWbNGv/jFL5L3c3Nzk1/H43EtXbpUgUBAb7/9tk6cOKEf/ehH8ng8+tWvfjUEhwQAyAQDCtju3btT7m/btk2FhYVqbm7WggULkstzc3MVCAT63cf//M//6MMPP9Qbb7yhoqIi3Xzzzfrnf/5nPfHEE3r66aeVnZ09iMMAAGSaK3oNLBQKSZLy8/NTlj///PMqKCjQzJkzVVtbq7NnzybXNTY2atasWSoqKkouq6ysVDgc1pEjR65kOACADDKgM7AvSyQSevjhh3X77bdr5syZyeXf//73NXnyZJWUlOjQoUN64okn1NLSoldffVWSFAwGU+IlKXk/GAz2+70ikYgikUjyfjgcHuywAQAjxKADVl1drcOHD+utt95KWb527drk17NmzVJxcbEWLlyotrY2TZ06dVDfq66uTps2bRrsUAEAI9CgnkKsqanRrl279Oabb2rChAkX3basrEyS1NraKkkKBALq6OhI2ebC/W963ay2tlahUCh5O3bs2GCGDQAYQQYUMGOMampqtGPHDu3bt0+lpaWXfMzBgwclScXFxZKk8vJyffDBBzp58mRymz179sjn82nGjBn97sPr9crn86XcAACZbUBPIVZXV2v79u3auXOnxo4dm3zNyu/3KycnR21tbdq+fbuWLFmicePG6dChQ3rkkUe0YMECzZ49W5K0aNEizZgxQz/84Q+1efNmBYNBPfXUU6qurpbX6x36IwQAjEiOMcZc9saO0+/y5557Tg888ICOHTumH/zgBzp8+LB6eno0ceJE3XvvvXrqqadSzpo+/fRTrVu3TvX19Ro9erRWrVqlZ555Rm735fU0HA7L7/frTt0tt+O53OEDAK4RMRNVvXYqFAoN+lm1AQXsWhEKhZSXl6c7tERuETAAsE1MUb2l36uzs1N+v39Q+xj0VYjp1NXVJUl6S79P80gAAFeiq6tr0AGz8gwskUiopaVFM2bM0LFjx7ioox/hcFgTJ05kfi6CObo45ufSmKOLu9j8GGPU1dWlkpISuVyDe08NK8/AXC6XrrvuOkniqsRLYH4ujTm6OObn0piji/um+RnsmdcFfJwKAMBKBAwAYCVrA+b1erVx40b+duwbMD+XxhxdHPNzaczRxQ33/Fh5EQcAANaegQEAMhsBAwBYiYABAKxEwAAAVrIyYFu2bNG3v/1tjRo1SmVlZXrnnXfSPaS0efrpp+U4Tspt2rRpyfW9vb2qrq7WuHHjNGbMGC1fvvxrn8c2kuzfv1933XWXSkpK5DiOXnvttZT1xhht2LBBxcXFysnJUUVFhT755JOUbc6cOaOVK1fK5/MpLy9Pq1evVnd391U8iuF1qTl64IEHvvYzVVVVlbLNSJ6juro6zZ8/X2PHjlVhYaHuuecetbS0pGxzOb9X7e3tWrp0qXJzc1VYWKjHH39csVjsah7KsLic+bnzzju/9jP04IMPpmwzFPNjXcBeeuklrV+/Xhs3btSf//xnzZkzR5WVlSmfL5ZpvvOd7+jEiRPJ25c/JfuRRx7R66+/rldeeUUNDQ06fvy4li1blsbRDq+enh7NmTNHW7Zs6Xf95s2b9eyzz2rr1q1qamrS6NGjVVlZqd7e3uQ2K1eu1JEjR7Rnzx7t2rVL+/fvT/mkcdtdao4kqaqqKuVn6oUXXkhZP5LnqKGhQdXV1Tpw4ID27NmjaDSqRYsWqaenJ7nNpX6v4vG4li5dqr6+Pr399tv63e9+p23btmnDhg3pOKQhdTnzI0lr1qxJ+RnavHlzct2QzY+xzK233mqqq6uT9+PxuCkpKTF1dXVpHFX6bNy40cyZM6ffdZ2dncbj8ZhXXnklueyjjz4ykkxjY+NVGmH6SDI7duxI3k8kEiYQCJhf//rXyWWdnZ3G6/WaF154wRhjzIcffmgkmXfffTe5zR/+8AfjOI7561//etXGfrV8dY6MMWbVqlXm7rvv/sbHZNocnTx50kgyDQ0NxpjL+736/e9/b1wulwkGg8lt/vM//9P4fD4TiUSu7gEMs6/OjzHG/M3f/I356U9/+o2PGar5seoMrK+vT83NzaqoqEguc7lcqqioUGNjYxpHll6ffPKJSkpKNGXKFK1cuVLt7e2SpObmZkWj0ZT5mjZtmiZNmpSR83X06FEFg8GU+fD7/SorK0vOR2Njo/Ly8jRv3rzkNhUVFXK5XGpqarrqY06X+vp6FRYW6qabbtK6det0+vTp5LpMm6NQKCRJys/Pl3R5v1eNjY2aNWuWioqKkttUVlYqHA7ryJEjV3H0w++r83PB888/r4KCAs2cOVO1tbU6e/Zsct1QzY9Vb+b7+eefKx6Ppxy0JBUVFenjjz9O06jSq6ysTNu2bdNNN92kEydOaNOmTfre976nw4cPKxgMKjs7W3l5eSmPKSoqSn6adia5cMz9/fxcWBcMBlVYWJiy3u12Kz8/P2PmrKqqSsuWLVNpaana2tr05JNPavHixWpsbFRWVlZGzVEikdDDDz+s22+/XTNnzpSky/q9CgaD/f6cXVg3UvQ3P5L0/e9/X5MnT1ZJSYkOHTqkJ554Qi0tLXr11VclDd38WBUwfN3ixYuTX8+ePVtlZWWaPHmyXn75ZeXk5KRxZLDVihUrkl/PmjVLs2fP1tSpU1VfX6+FCxemcWRXX3V1tQ4fPpzyujL+zzfNz5dfD501a5aKi4u1cOFCtbW1aerUqUP2/a16CrGgoEBZWVlfu9qno6NDgUAgTaO6tuTl5enGG29Ua2urAoGA+vr61NnZmbJNps7XhWO+2M9PIBD42gVBsVhMZ86cycg5k6QpU6aooKBAra2tkjJnjmpqarRr1y69+eabmjBhQnL55fxeBQKBfn/OLqwbCb5pfvpTVlYmSSk/Q0MxP1YFLDs7W3PnztXevXuTyxKJhPbu3avy8vI0juza0d3drba2NhUXF2vu3LnyeDwp89XS0qL29vaMnK/S0lIFAoGU+QiHw2pqakrOR3l5uTo7O9Xc3JzcZt++fUokEslfwkzz2Wef6fTp0youLpY08ufIGKOamhrt2LFD+/btU2lpacr6y/m9Ki8v1wcffJAS+j179sjn82nGjBlX50CGyaXmpz8HDx6UpJSfoSGZn0FcdJJWL774ovF6vWbbtm3mww8/NGvXrjV5eXkpV7NkkkcffdTU19ebo0ePmj/96U+moqLCFBQUmJMnTxpjjHnwwQfNpEmTzL59+8x7771nysvLTXl5eZpHPXy6urrM+++/b95//30jyfzrv/6ref/9982nn35qjDHmmWeeMXl5eWbnzp3m0KFD5u677zalpaXm3LlzyX1UVVWZW265xTQ1NZm33nrL3HDDDeb+++9P1yENuYvNUVdXl3nsscdMY2OjOXr0qHnjjTfMd7/7XXPDDTeY3t7e5D5G8hytW7fO+P1+U19fb06cOJG8nT17NrnNpX6vYrGYmTlzplm0aJE5ePCg2b17txk/frypra1NxyENqUvNT2trq/nFL35h3nvvPXP06FGzc+dOM2XKFLNgwYLkPoZqfqwLmDHG/OY3vzGTJk0y2dnZ5tZbbzUHDhxI95DS5r777jPFxcUmOzvbXHfddea+++4zra2tyfXnzp0zP/nJT8y3vvUtk5uba+69915z4sSJNI54eL355ptG0tduq1atMsacv5T+5z//uSkqKjJer9csXLjQtLS0pOzj9OnT5v777zdjxowxPp/P/PjHPzZdXV1pOJrhcbE5Onv2rFm0aJEZP3688Xg8ZvLkyWbNmjVf+w/iSJ6j/uZGknnuueeS21zO79Vf/vIXs3jxYpOTk2MKCgrMo48+aqLR6FU+mqF3qflpb283CxYsMPn5+cbr9Zrrr7/ePP744yYUCqXsZyjmh49TAQBYyarXwAAAuICAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAK/1/BR1YmHA/vGcAAAAASUVORK5CYII=", + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(heatmaps[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "f238c110-8e4f-4865-bc1c-f8aef0127ef3", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'outputs' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[36], line 4\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m17\u001b[39m):\n\u001b[1;32m----> 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(\u001b[43moutputs\u001b[49m[\u001b[38;5;241m0\u001b[39m][i]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 5\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'outputs' is not defined" + ] + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(outputs[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89ae76ec-92b7-4773-8893-fa1028f1c0a2", + "metadata": {}, + "outputs": [], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][5].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d55e9df0-d46a-445a-8032-6ff5bd566ea7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d55944fe-f7bd-463c-bda9-848d3ac29275", + "metadata": {}, + "source": [ + "## convert keypoint" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "83242f5c-71ae-4c95-a8fa-d385904d00d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]],\n", + "\n", + " [[0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]]], device='cuda:0')\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "\n", + "# Original and target sizes\n", + "original_size = (208, 208) # Replace with actual dimensions\n", + "target_size = (52, 52)\n", + "\n", + "# Resizing function\n", + "def resize_keypoints_new(keypoints, original_size, target_size):\n", + " original_height, original_width = original_size\n", + " target_height, target_width = target_size\n", + " \n", + " scale_x = int(target_width / original_width)\n", + " scale_y = int(target_height / original_height)\n", + " \n", + " resized_keypoints = keypoints.clone()\n", + " resized_keypoints[..., 0] *= scale_x\n", + " resized_keypoints[..., 1] *= scale_y\n", + " \n", + " return resized_keypoints\n", + "\n", + "# Resized keypoints\n", + "resized_keypoints = resize_keypoints_new(keypoints, original_size, target_size)\n", + "print(resized_keypoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "718c212b-ebb5-4ddb-8b7c-88537ea6f85f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f4ef8c2-e3d2-4e7d-8388-d4b4ddc18587", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "e2e1b2cd-c9ce-4149-a89c-ddd210196fb7", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'gt_heatmaps' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[38], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m#plt.imshow(outputs[0][0].cpu().detach().numpy())\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(\u001b[43mgt_heatmaps\u001b[49m[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'gt_heatmaps' is not defined" + ] + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][2].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9f12e02-03b0-47bb-85fb-d9723e50e0e5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3b414522-0a5e-4a11-83e6-20aa0fc04d2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 3, 208, 208])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "5dc276a4-7c8b-4972-90d0-e3c77fb9c199", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'gt_heatmaps' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mgt_heatmaps\u001b[49m\u001b[38;5;241m.\u001b[39mshape\n", + "\u001b[1;31mNameError\u001b[0m: name 'gt_heatmaps' is not defined" + ] + } + ], + "source": [ + "gt_heatmaps.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1c06c2b-8708-4a24-9abe-33901f646d90", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [1/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:34<00:00, 12.80batch/s, loss=4.61]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Loss: 4.6097\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [2/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:34<00:00, 12.81batch/s, loss=3.91]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [2/10], Loss: 3.9105\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [3/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:31<00:00, 13.01batch/s, loss=3.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [3/10], Loss: 3.7892\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [4/10]: 100%|███████████████████████████████████████████████████| 2751/2751 [03:37<00:00, 12.67batch/s, loss=3.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [4/10], Loss: 3.7024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [5/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:30<00:00, 13.09batch/s, loss=3.63]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [5/10], Loss: 3.6335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [6/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:31<00:00, 13.01batch/s, loss=3.58]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [6/10], Loss: 3.5774\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [7/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:25<00:00, 13.37batch/s, loss=3.52]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [7/10], Loss: 3.5167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [8/10]: 99%|█████████████████████████████████████████████████▌| 2730/2751 [03:26<00:01, 12.95batch/s, loss=3.48]" + ] + } + ], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader\n", + "from tqdm import tqdm # Import tqdm\n", + "\n", + "optimizer = optim.Adam(model.parameters(), lr=1e-4)\n", + "criterion = torch.nn.MSELoss()\n", + "\n", + "# Define training loop\n", + "num_epochs = 10 # Number of epochs\n", + "for epoch in range(num_epochs):\n", + " model.train() # Set model to training mode\n", + " running_loss = 0.0\n", + "\n", + " # Wrap the DataLoader with tqdm to show the progress\n", + " with tqdm(dataloader, desc=f\"Epoch [{epoch + 1}/{num_epochs}]\", unit='batch') as pbar:\n", + " for images, labels in pbar:\n", + " # Send images and labels to GPU if needed\n", + " images = images.cuda()\n", + " labels = labels.cuda()\n", + "\n", + " optimizer.zero_grad() # Zero the gradients\n", + "\n", + " # Forward pass\n", + " outputs = model(images) # The model outputs keypoint heatmaps\n", + " #print(outputs.shape)\n", + "\n", + " original_size = (208, 208)\n", + " target_size = (52, 52)\n", + " labels = resize_keypoints_new(labels, original_size, target_size)\n", + " gt_heatmaps = generate_heatmaps(labels, output_size=outputs.shape[2:]) # Implement this\n", + " loss = criterion(outputs*100, gt_heatmaps*100)\n", + "\n", + " # Backward pass and optimization\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + "\n", + " # Update the tqdm progress bar with the current loss\n", + " pbar.set_postfix(loss=running_loss / (pbar.n + 1)) # Display the average loss\n", + "\n", + " # Print loss for the current epoch\n", + " avg_loss = running_loss / len(dataloader)\n", + " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cac52986-3416-4280-8092-9b197ac006ad", + "metadata": {}, + "outputs": [], + "source": [ + "input_tensor.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5dbc351-bb56-450f-85c7-225902b2a9b8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12157857-e9bf-4645-a137-3e5ddf0d3141", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a27d991-83b5-485f-8e50-9273601dedab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fdd034a0-c159-4b2f-8f49-abdbd49844bd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88eab6b5-72f5-4407-a2d1-c9f74dfb2f8b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5353d47e15e1c92f1d90b61771b9aaea109fd938 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/__init__.py @@ -0,0 +1,5 @@ +from .inference import VitInference + +__all__ = [ + 'VitInference' +] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/config.yaml b/ViTPose/easy_ViTPose/easy_ViTPose/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8cf121d164a4c48ebec1a30b4d865bc213cc4f6f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/config.yaml @@ -0,0 +1,15 @@ +# Train config --------------------------------------- +log_level: logging.INFO +seed: 0 +gpu_ids: 0 +deterministic: True +cudnn_benchmark: True # Use cudnn +resume_from: "C:/Users/user/ViTPose/ckpts/vitpose-s-coco_25.pth" # CKPT path +#resume_from: False +gpu_ids: [0] +launcher: 'none' # When distributed training ['none', 'pytorch', 'slurm', 'mpi'] +use_amp: False +validate: True +autoscale_lr: False +dist_params: + ... diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_common-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_common-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..bb86dc50a3c718b18c951995cb52cc6324fc8021 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_common-checkpoint.py @@ -0,0 +1,195 @@ +# Common configuration +optimizer = dict(type='AdamW', lr=1e-3, betas=(0.9, 0.999), weight_decay=0.1, + constructor='LayerDecayOptimizerConstructor', + paramwise_cfg=dict( + num_layers=12, + layer_decay_rate=1 - 2e-4, + custom_keys={ + 'bias': dict(decay_multi=0.), + 'pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + } + ) + ) + +optimizer_config = dict(grad_clip=dict(max_norm=1., norm_type=2)) + +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=300, + warmup_ratio=0.001, + step=[3]) + +total_epochs = 4 +target_type = 'GaussianHeatmap' + +data_cfg = dict( + image_size=[192, 256], + heatmap_size=[48, 64], + soft_nms=False, + nms_thr=1.0, + oks_thr=0.9, + vis_thr=0.2, + use_gt_bbox=False, + det_bbox_thr=0.0, + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', +) + +data_root = '/home/adryw/dataset/COCO17' +data = dict( + samples_per_gpu=64, + workers_per_gpu=6, + val_dataloader=dict(samples_per_gpu=128), + test_dataloader=dict(samples_per_gpu=128), + train=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/train2017/', + data_cfg=data_cfg), + val=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_val2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg), + test=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_val2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg) +) + +model_small = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=384, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.1, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=384, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_base = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.3, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=768, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_large = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=1024, + depth=24, + num_heads=16, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.5, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=1024, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_huge = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=1280, + depth=32, + num_heads=16, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.55, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=1280, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_small_coco_256x192-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_small_coco_256x192-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..203cd6b61b09b826e744a61d8b15ea4e13ea0bb0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_small_coco_256x192-checkpoint.py @@ -0,0 +1,173 @@ +_base_ = [ + '../../../../_base_/default_runtime.py', + '../../../../_base_/datasets/coco.py' +] +evaluation = dict(interval=10, metric='mAP', save_best='AP') + +optimizer = dict(type='AdamW', lr=5e-4, betas=(0.9, 0.999), weight_decay=0.1, + constructor='LayerDecayOptimizerConstructor', + paramwise_cfg=dict( + num_layers=12, + layer_decay_rate=0.8, + custom_keys={ + 'bias': dict(decay_multi=0.), + 'pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + } + ) + ) + +optimizer_config = dict(grad_clip=dict(max_norm=1., norm_type=2)) + +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=0.001, + step=[170, 200]) +total_epochs = 210 +target_type = 'GaussianHeatmap' +channel_cfg = dict( + num_output_channels=17, + dataset_joints=17, + dataset_channel=[ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], + ], + inference_channel=[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 + ]) + +# model settings +model = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=384, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.1, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=384, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + out_channels=channel_cfg['num_output_channels'], + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +data_cfg = dict( + image_size=[192, 256], + heatmap_size=[48, 64], + num_output_channels=channel_cfg['num_output_channels'], + num_joints=channel_cfg['dataset_joints'], + dataset_channel=channel_cfg['dataset_channel'], + inference_channel=channel_cfg['inference_channel'], + soft_nms=False, + nms_thr=1.0, + oks_thr=0.9, + vis_thr=0.9, + use_gt_bbox=False, + det_bbox_thr=0.0, + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', +) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='TopDownRandomFlip', flip_prob=0.5), + dict( + type='TopDownHalfBodyTransform', + num_joints_half_body=8, + prob_half_body=0.3), + dict( + type='TopDownGetRandomScaleRotation', rot_factor=40, scale_factor=0.5), + dict(type='TopDownAffine', use_udp=True), + dict(type='ToTensor'), + dict( + type='NormalizeTensor', + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]), + dict( + type='TopDownGenerateTarget', + sigma=2, + encoding='UDP', + target_type=target_type), + dict( + type='Collect', + keys=['img', 'target', 'target_weight'], + meta_keys=[ + 'image_file', 'joints_3d', 'joints_3d_visible', 'center', 'scale', + 'rotation', 'bbox_score', 'flip_pairs' + ]), +] + +val_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='TopDownAffine', use_udp=True), + dict(type='ToTensor'), + dict( + type='NormalizeTensor', + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]), + dict( + type='Collect', + keys=['img'], + meta_keys=[ + 'image_file', 'center', 'scale', 'rotation', 'bbox_score', + 'flip_pairs' + ]), +] + +test_pipeline = val_pipeline + +data_root = r'D:\ViTPose\Evaluating' +data = dict( + samples_per_gpu=4, + workers_per_gpu=4, + val_dataloader=dict(samples_per_gpu=4), + test_dataloader=dict(samples_per_gpu=4), + train=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/train2017/', + data_cfg=data_cfg, + pipeline=train_pipeline, + # dataset_info={{_base_.dataset_info}} + ), + val=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg, + pipeline=val_pipeline, + # dataset_info={{_base_.dataset_info}} + ), + test=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg, + pipeline=test_pipeline, + #dataset_info={{_base_.dataset_info}} + ), +) + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_wholebody-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_wholebody-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..1b4f3c62e07b68da583e46c429bf234019ad3f6d --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/.ipynb_checkpoints/ViTPose_wholebody-checkpoint.py @@ -0,0 +1,20 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=133, + dataset_joints=133, + dataset_channel=[ + list(range(133)), + ], + inference_channel=list(range(133))) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_aic.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_aic.py new file mode 100644 index 0000000000000000000000000000000000000000..0277c1a590bda5574a97f98ef8bde404471834ed --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_aic.py @@ -0,0 +1,20 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=14, + dataset_joints=14, + dataset_channel=[ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], + ], + inference_channel=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_ap10k.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_ap10k.py new file mode 100644 index 0000000000000000000000000000000000000000..069780672e8bd2975b7cd2bb2e1d37fdd20a7f74 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_ap10k.py @@ -0,0 +1,22 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=17, + dataset_joints=17, + dataset_channel=[ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], + ], + inference_channel=[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 + ]) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_apt36k.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_apt36k.py new file mode 100644 index 0000000000000000000000000000000000000000..069780672e8bd2975b7cd2bb2e1d37fdd20a7f74 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_apt36k.py @@ -0,0 +1,22 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=17, + dataset_joints=17, + dataset_channel=[ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], + ], + inference_channel=[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 + ]) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b46feff089fd81b5072a38ce667b21350a1e3d6a --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco.py @@ -0,0 +1,18 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=17, + dataset_joints=17, + dataset_channel=list(range(17)), + inference_channel=list(range(17))) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco_25.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco_25.py new file mode 100644 index 0000000000000000000000000000000000000000..e5d820221377fa2196b63d04cbe4ffbb75f09249 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_coco_25.py @@ -0,0 +1,20 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=25, + dataset_joints=25, + dataset_channel=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24], ], + inference_channel=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24]) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_common.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_common.py new file mode 100644 index 0000000000000000000000000000000000000000..bb86dc50a3c718b18c951995cb52cc6324fc8021 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_common.py @@ -0,0 +1,195 @@ +# Common configuration +optimizer = dict(type='AdamW', lr=1e-3, betas=(0.9, 0.999), weight_decay=0.1, + constructor='LayerDecayOptimizerConstructor', + paramwise_cfg=dict( + num_layers=12, + layer_decay_rate=1 - 2e-4, + custom_keys={ + 'bias': dict(decay_multi=0.), + 'pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + } + ) + ) + +optimizer_config = dict(grad_clip=dict(max_norm=1., norm_type=2)) + +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=300, + warmup_ratio=0.001, + step=[3]) + +total_epochs = 4 +target_type = 'GaussianHeatmap' + +data_cfg = dict( + image_size=[192, 256], + heatmap_size=[48, 64], + soft_nms=False, + nms_thr=1.0, + oks_thr=0.9, + vis_thr=0.2, + use_gt_bbox=False, + det_bbox_thr=0.0, + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', +) + +data_root = '/home/adryw/dataset/COCO17' +data = dict( + samples_per_gpu=64, + workers_per_gpu=6, + val_dataloader=dict(samples_per_gpu=128), + test_dataloader=dict(samples_per_gpu=128), + train=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/train2017/', + data_cfg=data_cfg), + val=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_val2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg), + test=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_val2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg) +) + +model_small = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=384, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.1, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=384, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_base = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.3, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=768, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_large = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=1024, + depth=24, + num_heads=16, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.5, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=1024, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +model_huge = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=1280, + depth=32, + num_heads=16, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.55, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=1280, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_mpii.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_mpii.py new file mode 100644 index 0000000000000000000000000000000000000000..9f31bbd3e581d4c49ab0797b8885c9ce903da6c0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_mpii.py @@ -0,0 +1,18 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=16, + dataset_joints=16, + dataset_channel=list(range(16)), + inference_channel=list(range(16))) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_small_coco_256x192.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_small_coco_256x192.py new file mode 100644 index 0000000000000000000000000000000000000000..203cd6b61b09b826e744a61d8b15ea4e13ea0bb0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_small_coco_256x192.py @@ -0,0 +1,173 @@ +_base_ = [ + '../../../../_base_/default_runtime.py', + '../../../../_base_/datasets/coco.py' +] +evaluation = dict(interval=10, metric='mAP', save_best='AP') + +optimizer = dict(type='AdamW', lr=5e-4, betas=(0.9, 0.999), weight_decay=0.1, + constructor='LayerDecayOptimizerConstructor', + paramwise_cfg=dict( + num_layers=12, + layer_decay_rate=0.8, + custom_keys={ + 'bias': dict(decay_multi=0.), + 'pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + } + ) + ) + +optimizer_config = dict(grad_clip=dict(max_norm=1., norm_type=2)) + +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=0.001, + step=[170, 200]) +total_epochs = 210 +target_type = 'GaussianHeatmap' +channel_cfg = dict( + num_output_channels=17, + dataset_joints=17, + dataset_channel=[ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], + ], + inference_channel=[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 + ]) + +# model settings +model = dict( + type='TopDown', + pretrained=None, + backbone=dict( + type='ViT', + img_size=(256, 192), + patch_size=16, + embed_dim=384, + depth=12, + num_heads=12, + ratio=1, + use_checkpoint=False, + mlp_ratio=4, + qkv_bias=True, + drop_path_rate=0.1, + ), + keypoint_head=dict( + type='TopdownHeatmapSimpleHead', + in_channels=384, + num_deconv_layers=2, + num_deconv_filters=(256, 256), + num_deconv_kernels=(4, 4), + extra=dict(final_conv_kernel=1, ), + out_channels=channel_cfg['num_output_channels'], + loss_keypoint=dict(type='JointsMSELoss', use_target_weight=True)), + train_cfg=dict(), + test_cfg=dict( + flip_test=True, + post_process='default', + shift_heatmap=False, + target_type=target_type, + modulate_kernel=11, + use_udp=True)) + +data_cfg = dict( + image_size=[192, 256], + heatmap_size=[48, 64], + num_output_channels=channel_cfg['num_output_channels'], + num_joints=channel_cfg['dataset_joints'], + dataset_channel=channel_cfg['dataset_channel'], + inference_channel=channel_cfg['inference_channel'], + soft_nms=False, + nms_thr=1.0, + oks_thr=0.9, + vis_thr=0.9, + use_gt_bbox=False, + det_bbox_thr=0.0, + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', +) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='TopDownRandomFlip', flip_prob=0.5), + dict( + type='TopDownHalfBodyTransform', + num_joints_half_body=8, + prob_half_body=0.3), + dict( + type='TopDownGetRandomScaleRotation', rot_factor=40, scale_factor=0.5), + dict(type='TopDownAffine', use_udp=True), + dict(type='ToTensor'), + dict( + type='NormalizeTensor', + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]), + dict( + type='TopDownGenerateTarget', + sigma=2, + encoding='UDP', + target_type=target_type), + dict( + type='Collect', + keys=['img', 'target', 'target_weight'], + meta_keys=[ + 'image_file', 'joints_3d', 'joints_3d_visible', 'center', 'scale', + 'rotation', 'bbox_score', 'flip_pairs' + ]), +] + +val_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='TopDownAffine', use_udp=True), + dict(type='ToTensor'), + dict( + type='NormalizeTensor', + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]), + dict( + type='Collect', + keys=['img'], + meta_keys=[ + 'image_file', 'center', 'scale', 'rotation', 'bbox_score', + 'flip_pairs' + ]), +] + +test_pipeline = val_pipeline + +data_root = r'D:\ViTPose\Evaluating' +data = dict( + samples_per_gpu=4, + workers_per_gpu=4, + val_dataloader=dict(samples_per_gpu=4), + test_dataloader=dict(samples_per_gpu=4), + train=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/train2017/', + data_cfg=data_cfg, + pipeline=train_pipeline, + # dataset_info={{_base_.dataset_info}} + ), + val=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg, + pipeline=val_pipeline, + # dataset_info={{_base_.dataset_info}} + ), + test=dict( + type='TopDownCocoDataset', + ann_file=f'{data_root}/annotations/person_keypoints_train2017.json', + img_prefix=f'{data_root}/val2017/', + data_cfg=data_cfg, + pipeline=test_pipeline, + #dataset_info={{_base_.dataset_info}} + ), +) + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_wholebody.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_wholebody.py new file mode 100644 index 0000000000000000000000000000000000000000..1b4f3c62e07b68da583e46c429bf234019ad3f6d --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/ViTPose_wholebody.py @@ -0,0 +1,20 @@ +from .ViTPose_common import * + +# Channel configuration +channel_cfg = dict( + num_output_channels=133, + dataset_joints=133, + dataset_channel=[ + list(range(133)), + ], + inference_channel=list(range(133))) + +# Set models channels +data_cfg['num_output_channels'] = channel_cfg['num_output_channels'] +data_cfg['num_joints']= channel_cfg['dataset_joints'] +data_cfg['dataset_channel']= channel_cfg['dataset_channel'] +data_cfg['inference_channel']= channel_cfg['inference_channel'] + +names = ['small', 'base', 'large', 'huge'] +for name in names: + globals()[f'model_{name}']['keypoint_head']['out_channels'] = channel_cfg['num_output_channels'] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_coco_25.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_coco_25.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e6386673ffd14845d935cfb6817a4767b421974 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_coco_25.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_common.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_common.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51618fa01737ba697d74116d9d1bcb61f9d3664b Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_common.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_small_coco_256x192.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_small_coco_256x192.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..93f09999f2eccd611e5cc46e989f3032f2ae4e3f Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/ViTPose_small_coco_256x192.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f417669dbbb937603d3656c034cce4948a16345e Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/configs/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/300w.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/300w.py new file mode 100644 index 0000000000000000000000000000000000000000..689d1e1b5e07a7f7d7ba47c6003106c887b64667 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/300w.py @@ -0,0 +1,384 @@ +dataset_info = dict( + dataset_name='300w', + paper_info=dict( + author='Sagonas, Christos and Antonakos, Epameinondas ' + 'and Tzimiropoulos, Georgios and Zafeiriou, Stefanos ' + 'and Pantic, Maja', + title='300 faces in-the-wild challenge: ' + 'Database and results', + container='Image and vision computing', + year='2016', + homepage='https://ibug.doc.ic.ac.uk/resources/300-W/', + ), + keypoint_info={ + 0: + dict( + name='kpt-0', id=0, color=[255, 255, 255], type='', swap='kpt-16'), + 1: + dict( + name='kpt-1', id=1, color=[255, 255, 255], type='', swap='kpt-15'), + 2: + dict( + name='kpt-2', id=2, color=[255, 255, 255], type='', swap='kpt-14'), + 3: + dict( + name='kpt-3', id=3, color=[255, 255, 255], type='', swap='kpt-13'), + 4: + dict( + name='kpt-4', id=4, color=[255, 255, 255], type='', swap='kpt-12'), + 5: + dict( + name='kpt-5', id=5, color=[255, 255, 255], type='', swap='kpt-11'), + 6: + dict( + name='kpt-6', id=6, color=[255, 255, 255], type='', swap='kpt-10'), + 7: + dict(name='kpt-7', id=7, color=[255, 255, 255], type='', swap='kpt-9'), + 8: + dict(name='kpt-8', id=8, color=[255, 255, 255], type='', swap=''), + 9: + dict(name='kpt-9', id=9, color=[255, 255, 255], type='', swap='kpt-7'), + 10: + dict( + name='kpt-10', id=10, color=[255, 255, 255], type='', + swap='kpt-6'), + 11: + dict( + name='kpt-11', id=11, color=[255, 255, 255], type='', + swap='kpt-5'), + 12: + dict( + name='kpt-12', id=12, color=[255, 255, 255], type='', + swap='kpt-4'), + 13: + dict( + name='kpt-13', id=13, color=[255, 255, 255], type='', + swap='kpt-3'), + 14: + dict( + name='kpt-14', id=14, color=[255, 255, 255], type='', + swap='kpt-2'), + 15: + dict( + name='kpt-15', id=15, color=[255, 255, 255], type='', + swap='kpt-1'), + 16: + dict( + name='kpt-16', id=16, color=[255, 255, 255], type='', + swap='kpt-0'), + 17: + dict( + name='kpt-17', + id=17, + color=[255, 255, 255], + type='', + swap='kpt-26'), + 18: + dict( + name='kpt-18', + id=18, + color=[255, 255, 255], + type='', + swap='kpt-25'), + 19: + dict( + name='kpt-19', + id=19, + color=[255, 255, 255], + type='', + swap='kpt-24'), + 20: + dict( + name='kpt-20', + id=20, + color=[255, 255, 255], + type='', + swap='kpt-23'), + 21: + dict( + name='kpt-21', + id=21, + color=[255, 255, 255], + type='', + swap='kpt-22'), + 22: + dict( + name='kpt-22', + id=22, + color=[255, 255, 255], + type='', + swap='kpt-21'), + 23: + dict( + name='kpt-23', + id=23, + color=[255, 255, 255], + type='', + swap='kpt-20'), + 24: + dict( + name='kpt-24', + id=24, + color=[255, 255, 255], + type='', + swap='kpt-19'), + 25: + dict( + name='kpt-25', + id=25, + color=[255, 255, 255], + type='', + swap='kpt-18'), + 26: + dict( + name='kpt-26', + id=26, + color=[255, 255, 255], + type='', + swap='kpt-17'), + 27: + dict(name='kpt-27', id=27, color=[255, 255, 255], type='', swap=''), + 28: + dict(name='kpt-28', id=28, color=[255, 255, 255], type='', swap=''), + 29: + dict(name='kpt-29', id=29, color=[255, 255, 255], type='', swap=''), + 30: + dict(name='kpt-30', id=30, color=[255, 255, 255], type='', swap=''), + 31: + dict( + name='kpt-31', + id=31, + color=[255, 255, 255], + type='', + swap='kpt-35'), + 32: + dict( + name='kpt-32', + id=32, + color=[255, 255, 255], + type='', + swap='kpt-34'), + 33: + dict(name='kpt-33', id=33, color=[255, 255, 255], type='', swap=''), + 34: + dict( + name='kpt-34', + id=34, + color=[255, 255, 255], + type='', + swap='kpt-32'), + 35: + dict( + name='kpt-35', + id=35, + color=[255, 255, 255], + type='', + swap='kpt-31'), + 36: + dict( + name='kpt-36', + id=36, + color=[255, 255, 255], + type='', + swap='kpt-45'), + 37: + dict( + name='kpt-37', + id=37, + color=[255, 255, 255], + type='', + swap='kpt-44'), + 38: + dict( + name='kpt-38', + id=38, + color=[255, 255, 255], + type='', + swap='kpt-43'), + 39: + dict( + name='kpt-39', + id=39, + color=[255, 255, 255], + type='', + swap='kpt-42'), + 40: + dict( + name='kpt-40', + id=40, + color=[255, 255, 255], + type='', + swap='kpt-47'), + 41: + dict( + name='kpt-41', + id=41, + color=[255, 255, 255], + type='', + swap='kpt-46'), + 42: + dict( + name='kpt-42', + id=42, + color=[255, 255, 255], + type='', + swap='kpt-39'), + 43: + dict( + name='kpt-43', + id=43, + color=[255, 255, 255], + type='', + swap='kpt-38'), + 44: + dict( + name='kpt-44', + id=44, + color=[255, 255, 255], + type='', + swap='kpt-37'), + 45: + dict( + name='kpt-45', + id=45, + color=[255, 255, 255], + type='', + swap='kpt-36'), + 46: + dict( + name='kpt-46', + id=46, + color=[255, 255, 255], + type='', + swap='kpt-41'), + 47: + dict( + name='kpt-47', + id=47, + color=[255, 255, 255], + type='', + swap='kpt-40'), + 48: + dict( + name='kpt-48', + id=48, + color=[255, 255, 255], + type='', + swap='kpt-54'), + 49: + dict( + name='kpt-49', + id=49, + color=[255, 255, 255], + type='', + swap='kpt-53'), + 50: + dict( + name='kpt-50', + id=50, + color=[255, 255, 255], + type='', + swap='kpt-52'), + 51: + dict(name='kpt-51', id=51, color=[255, 255, 255], type='', swap=''), + 52: + dict( + name='kpt-52', + id=52, + color=[255, 255, 255], + type='', + swap='kpt-50'), + 53: + dict( + name='kpt-53', + id=53, + color=[255, 255, 255], + type='', + swap='kpt-49'), + 54: + dict( + name='kpt-54', + id=54, + color=[255, 255, 255], + type='', + swap='kpt-48'), + 55: + dict( + name='kpt-55', + id=55, + color=[255, 255, 255], + type='', + swap='kpt-59'), + 56: + dict( + name='kpt-56', + id=56, + color=[255, 255, 255], + type='', + swap='kpt-58'), + 57: + dict(name='kpt-57', id=57, color=[255, 255, 255], type='', swap=''), + 58: + dict( + name='kpt-58', + id=58, + color=[255, 255, 255], + type='', + swap='kpt-56'), + 59: + dict( + name='kpt-59', + id=59, + color=[255, 255, 255], + type='', + swap='kpt-55'), + 60: + dict( + name='kpt-60', + id=60, + color=[255, 255, 255], + type='', + swap='kpt-64'), + 61: + dict( + name='kpt-61', + id=61, + color=[255, 255, 255], + type='', + swap='kpt-63'), + 62: + dict(name='kpt-62', id=62, color=[255, 255, 255], type='', swap=''), + 63: + dict( + name='kpt-63', + id=63, + color=[255, 255, 255], + type='', + swap='kpt-61'), + 64: + dict( + name='kpt-64', + id=64, + color=[255, 255, 255], + type='', + swap='kpt-60'), + 65: + dict( + name='kpt-65', + id=65, + color=[255, 255, 255], + type='', + swap='kpt-67'), + 66: + dict(name='kpt-66', id=66, color=[255, 255, 255], type='', swap=''), + 67: + dict( + name='kpt-67', + id=67, + color=[255, 255, 255], + type='', + swap='kpt-65'), + }, + skeleton_info={}, + joint_weights=[1.] * 68, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aflw.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aflw.py new file mode 100644 index 0000000000000000000000000000000000000000..ad62fd034a9ef9567aa3d95d29ab212240324862 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aflw.py @@ -0,0 +1,83 @@ +dataset_info = dict( + dataset_name='aflw', + paper_info=dict( + author='Koestinger, Martin and Wohlhart, Paul and ' + 'Roth, Peter M and Bischof, Horst', + title='Annotated facial landmarks in the wild: ' + 'A large-scale, real-world database for facial ' + 'landmark localization', + container='2011 IEEE international conference on computer ' + 'vision workshops (ICCV workshops)', + year='2011', + homepage='https://www.tugraz.at/institute/icg/research/' + 'team-bischof/lrs/downloads/aflw/', + ), + keypoint_info={ + 0: + dict(name='kpt-0', id=0, color=[255, 255, 255], type='', swap='kpt-5'), + 1: + dict(name='kpt-1', id=1, color=[255, 255, 255], type='', swap='kpt-4'), + 2: + dict(name='kpt-2', id=2, color=[255, 255, 255], type='', swap='kpt-3'), + 3: + dict(name='kpt-3', id=3, color=[255, 255, 255], type='', swap='kpt-2'), + 4: + dict(name='kpt-4', id=4, color=[255, 255, 255], type='', swap='kpt-1'), + 5: + dict(name='kpt-5', id=5, color=[255, 255, 255], type='', swap='kpt-0'), + 6: + dict( + name='kpt-6', id=6, color=[255, 255, 255], type='', swap='kpt-11'), + 7: + dict( + name='kpt-7', id=7, color=[255, 255, 255], type='', swap='kpt-10'), + 8: + dict(name='kpt-8', id=8, color=[255, 255, 255], type='', swap='kpt-9'), + 9: + dict(name='kpt-9', id=9, color=[255, 255, 255], type='', swap='kpt-8'), + 10: + dict( + name='kpt-10', id=10, color=[255, 255, 255], type='', + swap='kpt-7'), + 11: + dict( + name='kpt-11', id=11, color=[255, 255, 255], type='', + swap='kpt-6'), + 12: + dict( + name='kpt-12', + id=12, + color=[255, 255, 255], + type='', + swap='kpt-14'), + 13: + dict(name='kpt-13', id=13, color=[255, 255, 255], type='', swap=''), + 14: + dict( + name='kpt-14', + id=14, + color=[255, 255, 255], + type='', + swap='kpt-12'), + 15: + dict( + name='kpt-15', + id=15, + color=[255, 255, 255], + type='', + swap='kpt-17'), + 16: + dict(name='kpt-16', id=16, color=[255, 255, 255], type='', swap=''), + 17: + dict( + name='kpt-17', + id=17, + color=[255, 255, 255], + type='', + swap='kpt-15'), + 18: + dict(name='kpt-18', id=18, color=[255, 255, 255], type='', swap='') + }, + skeleton_info={}, + joint_weights=[1.] * 19, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic.py new file mode 100644 index 0000000000000000000000000000000000000000..8d30f606006fdbf243ac88f8bfd0b631cfa74f9a --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic.py @@ -0,0 +1,140 @@ +dataset_info = dict( + dataset_name='aic', + paper_info=dict( + author='Wu, Jiahong and Zheng, He and Zhao, Bo and ' + 'Li, Yixin and Yan, Baoming and Liang, Rui and ' + 'Wang, Wenjia and Zhou, Shipei and Lin, Guosen and ' + 'Fu, Yanwei and others', + title='Ai challenger: A large-scale dataset for going ' + 'deeper in image understanding', + container='arXiv', + year='2017', + homepage='https://github.com/AIChallenger/AI_Challenger_2017', + ), + keypoint_info={ + 0: + dict( + name='right_shoulder', + id=0, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 1: + dict( + name='right_elbow', + id=1, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 2: + dict( + name='right_wrist', + id=2, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 3: + dict( + name='left_shoulder', + id=3, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 4: + dict( + name='left_elbow', + id=4, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 5: + dict( + name='left_wrist', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 6: + dict( + name='right_hip', + id=6, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 7: + dict( + name='right_knee', + id=7, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 8: + dict( + name='right_ankle', + id=8, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 9: + dict( + name='left_hip', + id=9, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 10: + dict( + name='left_knee', + id=10, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 11: + dict( + name='left_ankle', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 12: + dict( + name='head_top', + id=12, + color=[51, 153, 255], + type='upper', + swap=''), + 13: + dict(name='neck', id=13, color=[51, 153, 255], type='upper', swap='') + }, + skeleton_info={ + 0: + dict(link=('right_wrist', 'right_elbow'), id=0, color=[255, 128, 0]), + 1: dict( + link=('right_elbow', 'right_shoulder'), id=1, color=[255, 128, 0]), + 2: dict(link=('right_shoulder', 'neck'), id=2, color=[51, 153, 255]), + 3: dict(link=('neck', 'left_shoulder'), id=3, color=[51, 153, 255]), + 4: dict(link=('left_shoulder', 'left_elbow'), id=4, color=[0, 255, 0]), + 5: dict(link=('left_elbow', 'left_wrist'), id=5, color=[0, 255, 0]), + 6: dict(link=('right_ankle', 'right_knee'), id=6, color=[255, 128, 0]), + 7: dict(link=('right_knee', 'right_hip'), id=7, color=[255, 128, 0]), + 8: dict(link=('right_hip', 'left_hip'), id=8, color=[51, 153, 255]), + 9: dict(link=('left_hip', 'left_knee'), id=9, color=[0, 255, 0]), + 10: dict(link=('left_knee', 'left_ankle'), id=10, color=[0, 255, 0]), + 11: dict(link=('head_top', 'neck'), id=11, color=[51, 153, 255]), + 12: dict( + link=('right_shoulder', 'right_hip'), id=12, color=[51, 153, 255]), + 13: + dict(link=('left_shoulder', 'left_hip'), id=13, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1. + ], + + # 'https://github.com/AIChallenger/AI_Challenger_2017/blob/master/' + # 'Evaluation/keypoint_eval/keypoint_eval.py#L50' + # delta = 2 x sigma + sigmas=[ + 0.01388152, 0.01515228, 0.01057665, 0.01417709, 0.01497891, 0.01402144, + 0.03909642, 0.03686941, 0.01981803, 0.03843971, 0.03412318, 0.02415081, + 0.01291456, 0.01236173 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic_info.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic_info.py new file mode 100644 index 0000000000000000000000000000000000000000..b0ad79e33d41e64234a85294ee00409d85de8209 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/aic_info.py @@ -0,0 +1,140 @@ +aic_info = dict( + dataset_name='aic', + paper_info=dict( + author='Wu, Jiahong and Zheng, He and Zhao, Bo and ' + 'Li, Yixin and Yan, Baoming and Liang, Rui and ' + 'Wang, Wenjia and Zhou, Shipei and Lin, Guosen and ' + 'Fu, Yanwei and others', + title='Ai challenger: A large-scale dataset for going ' + 'deeper in image understanding', + container='arXiv', + year='2017', + homepage='https://github.com/AIChallenger/AI_Challenger_2017', + ), + keypoint_info={ + 0: + dict( + name='right_shoulder', + id=0, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 1: + dict( + name='right_elbow', + id=1, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 2: + dict( + name='right_wrist', + id=2, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 3: + dict( + name='left_shoulder', + id=3, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 4: + dict( + name='left_elbow', + id=4, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 5: + dict( + name='left_wrist', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 6: + dict( + name='right_hip', + id=6, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 7: + dict( + name='right_knee', + id=7, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 8: + dict( + name='right_ankle', + id=8, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 9: + dict( + name='left_hip', + id=9, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 10: + dict( + name='left_knee', + id=10, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 11: + dict( + name='left_ankle', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 12: + dict( + name='head_top', + id=12, + color=[51, 153, 255], + type='upper', + swap=''), + 13: + dict(name='neck', id=13, color=[51, 153, 255], type='upper', swap='') + }, + skeleton_info={ + 0: + dict(link=('right_wrist', 'right_elbow'), id=0, color=[255, 128, 0]), + 1: dict( + link=('right_elbow', 'right_shoulder'), id=1, color=[255, 128, 0]), + 2: dict(link=('right_shoulder', 'neck'), id=2, color=[51, 153, 255]), + 3: dict(link=('neck', 'left_shoulder'), id=3, color=[51, 153, 255]), + 4: dict(link=('left_shoulder', 'left_elbow'), id=4, color=[0, 255, 0]), + 5: dict(link=('left_elbow', 'left_wrist'), id=5, color=[0, 255, 0]), + 6: dict(link=('right_ankle', 'right_knee'), id=6, color=[255, 128, 0]), + 7: dict(link=('right_knee', 'right_hip'), id=7, color=[255, 128, 0]), + 8: dict(link=('right_hip', 'left_hip'), id=8, color=[51, 153, 255]), + 9: dict(link=('left_hip', 'left_knee'), id=9, color=[0, 255, 0]), + 10: dict(link=('left_knee', 'left_ankle'), id=10, color=[0, 255, 0]), + 11: dict(link=('head_top', 'neck'), id=11, color=[51, 153, 255]), + 12: dict( + link=('right_shoulder', 'right_hip'), id=12, color=[51, 153, 255]), + 13: + dict(link=('left_shoulder', 'left_hip'), id=13, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1.2, 1.5, 1., 1. + ], + + # 'https://github.com/AIChallenger/AI_Challenger_2017/blob/master/' + # 'Evaluation/keypoint_eval/keypoint_eval.py#L50' + # delta = 2 x sigma + sigmas=[ + 0.01388152, 0.01515228, 0.01057665, 0.01417709, 0.01497891, 0.01402144, + 0.03909642, 0.03686941, 0.01981803, 0.03843971, 0.03412318, 0.02415081, + 0.01291456, 0.01236173 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/animalpose.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/animalpose.py new file mode 100644 index 0000000000000000000000000000000000000000..7f614f75a637df7edf42c77fac19f983bc134c67 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/animalpose.py @@ -0,0 +1,166 @@ +dataset_info = dict( + dataset_name='animalpose', + paper_info=dict( + author='Cao, Jinkun and Tang, Hongyang and Fang, Hao-Shu and ' + 'Shen, Xiaoyong and Lu, Cewu and Tai, Yu-Wing', + title='Cross-Domain Adaptation for Animal Pose Estimation', + container='The IEEE International Conference on ' + 'Computer Vision (ICCV)', + year='2019', + homepage='https://sites.google.com/view/animal-pose/', + ), + keypoint_info={ + 0: + dict( + name='L_Eye', id=0, color=[0, 255, 0], type='upper', swap='R_Eye'), + 1: + dict( + name='R_Eye', + id=1, + color=[255, 128, 0], + type='upper', + swap='L_Eye'), + 2: + dict( + name='L_EarBase', + id=2, + color=[0, 255, 0], + type='upper', + swap='R_EarBase'), + 3: + dict( + name='R_EarBase', + id=3, + color=[255, 128, 0], + type='upper', + swap='L_EarBase'), + 4: + dict(name='Nose', id=4, color=[51, 153, 255], type='upper', swap=''), + 5: + dict(name='Throat', id=5, color=[51, 153, 255], type='upper', swap=''), + 6: + dict( + name='TailBase', id=6, color=[51, 153, 255], type='lower', + swap=''), + 7: + dict( + name='Withers', id=7, color=[51, 153, 255], type='upper', swap=''), + 8: + dict( + name='L_F_Elbow', + id=8, + color=[0, 255, 0], + type='upper', + swap='R_F_Elbow'), + 9: + dict( + name='R_F_Elbow', + id=9, + color=[255, 128, 0], + type='upper', + swap='L_F_Elbow'), + 10: + dict( + name='L_B_Elbow', + id=10, + color=[0, 255, 0], + type='lower', + swap='R_B_Elbow'), + 11: + dict( + name='R_B_Elbow', + id=11, + color=[255, 128, 0], + type='lower', + swap='L_B_Elbow'), + 12: + dict( + name='L_F_Knee', + id=12, + color=[0, 255, 0], + type='upper', + swap='R_F_Knee'), + 13: + dict( + name='R_F_Knee', + id=13, + color=[255, 128, 0], + type='upper', + swap='L_F_Knee'), + 14: + dict( + name='L_B_Knee', + id=14, + color=[0, 255, 0], + type='lower', + swap='R_B_Knee'), + 15: + dict( + name='R_B_Knee', + id=15, + color=[255, 128, 0], + type='lower', + swap='L_B_Knee'), + 16: + dict( + name='L_F_Paw', + id=16, + color=[0, 255, 0], + type='upper', + swap='R_F_Paw'), + 17: + dict( + name='R_F_Paw', + id=17, + color=[255, 128, 0], + type='upper', + swap='L_F_Paw'), + 18: + dict( + name='L_B_Paw', + id=18, + color=[0, 255, 0], + type='lower', + swap='R_B_Paw'), + 19: + dict( + name='R_B_Paw', + id=19, + color=[255, 128, 0], + type='lower', + swap='L_B_Paw') + }, + skeleton_info={ + 0: dict(link=('L_Eye', 'R_Eye'), id=0, color=[51, 153, 255]), + 1: dict(link=('L_Eye', 'L_EarBase'), id=1, color=[0, 255, 0]), + 2: dict(link=('R_Eye', 'R_EarBase'), id=2, color=[255, 128, 0]), + 3: dict(link=('L_Eye', 'Nose'), id=3, color=[0, 255, 0]), + 4: dict(link=('R_Eye', 'Nose'), id=4, color=[255, 128, 0]), + 5: dict(link=('Nose', 'Throat'), id=5, color=[51, 153, 255]), + 6: dict(link=('Throat', 'Withers'), id=6, color=[51, 153, 255]), + 7: dict(link=('TailBase', 'Withers'), id=7, color=[51, 153, 255]), + 8: dict(link=('Throat', 'L_F_Elbow'), id=8, color=[0, 255, 0]), + 9: dict(link=('L_F_Elbow', 'L_F_Knee'), id=9, color=[0, 255, 0]), + 10: dict(link=('L_F_Knee', 'L_F_Paw'), id=10, color=[0, 255, 0]), + 11: dict(link=('Throat', 'R_F_Elbow'), id=11, color=[255, 128, 0]), + 12: dict(link=('R_F_Elbow', 'R_F_Knee'), id=12, color=[255, 128, 0]), + 13: dict(link=('R_F_Knee', 'R_F_Paw'), id=13, color=[255, 128, 0]), + 14: dict(link=('TailBase', 'L_B_Elbow'), id=14, color=[0, 255, 0]), + 15: dict(link=('L_B_Elbow', 'L_B_Knee'), id=15, color=[0, 255, 0]), + 16: dict(link=('L_B_Knee', 'L_B_Paw'), id=16, color=[0, 255, 0]), + 17: dict(link=('TailBase', 'R_B_Elbow'), id=17, color=[255, 128, 0]), + 18: dict(link=('R_B_Elbow', 'R_B_Knee'), id=18, color=[255, 128, 0]), + 19: dict(link=('R_B_Knee', 'R_B_Paw'), id=19, color=[255, 128, 0]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.2, 1.2, + 1.5, 1.5, 1.5, 1.5 + ], + + # Note: The original paper did not provide enough information about + # the sigmas. We modified from 'https://github.com/cocodataset/' + # 'cocoapi/blob/master/PythonAPI/pycocotools/cocoeval.py#L523' + sigmas=[ + 0.025, 0.025, 0.026, 0.035, 0.035, 0.10, 0.10, 0.10, 0.107, 0.107, + 0.107, 0.107, 0.087, 0.087, 0.087, 0.087, 0.089, 0.089, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k.py new file mode 100644 index 0000000000000000000000000000000000000000..aecc173c2653bfc9f7b702ac2e2b49225ad5cccf --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k.py @@ -0,0 +1,142 @@ +dataset_info = dict( + dataset_name='ap10k', + paper_info=dict( + author='Yu, Hang and Xu, Yufei and Zhang, Jing and ' + 'Zhao, Wei and Guan, Ziyu and Tao, Dacheng', + title='AP-10K: A Benchmark for Animal Pose Estimation in the Wild', + container='35th Conference on Neural Information Processing Systems ' + '(NeurIPS 2021) Track on Datasets and Bench-marks.', + year='2021', + homepage='https://github.com/AlexTheBad/AP-10K', + ), + keypoint_info={ + 0: + dict( + name='L_Eye', id=0, color=[0, 255, 0], type='upper', swap='R_Eye'), + 1: + dict( + name='R_Eye', + id=1, + color=[255, 128, 0], + type='upper', + swap='L_Eye'), + 2: + dict(name='Nose', id=2, color=[51, 153, 255], type='upper', swap=''), + 3: + dict(name='Neck', id=3, color=[51, 153, 255], type='upper', swap=''), + 4: + dict( + name='Root of tail', + id=4, + color=[51, 153, 255], + type='lower', + swap=''), + 5: + dict( + name='L_Shoulder', + id=5, + color=[51, 153, 255], + type='upper', + swap='R_Shoulder'), + 6: + dict( + name='L_Elbow', + id=6, + color=[51, 153, 255], + type='upper', + swap='R_Elbow'), + 7: + dict( + name='L_F_Paw', + id=7, + color=[0, 255, 0], + type='upper', + swap='R_F_Paw'), + 8: + dict( + name='R_Shoulder', + id=8, + color=[0, 255, 0], + type='upper', + swap='L_Shoulder'), + 9: + dict( + name='R_Elbow', + id=9, + color=[255, 128, 0], + type='upper', + swap='L_Elbow'), + 10: + dict( + name='R_F_Paw', + id=10, + color=[0, 255, 0], + type='lower', + swap='L_F_Paw'), + 11: + dict( + name='L_Hip', + id=11, + color=[255, 128, 0], + type='lower', + swap='R_Hip'), + 12: + dict( + name='L_Knee', + id=12, + color=[255, 128, 0], + type='lower', + swap='R_Knee'), + 13: + dict( + name='L_B_Paw', + id=13, + color=[0, 255, 0], + type='lower', + swap='R_B_Paw'), + 14: + dict( + name='R_Hip', id=14, color=[0, 255, 0], type='lower', + swap='L_Hip'), + 15: + dict( + name='R_Knee', + id=15, + color=[0, 255, 0], + type='lower', + swap='L_Knee'), + 16: + dict( + name='R_B_Paw', + id=16, + color=[0, 255, 0], + type='lower', + swap='L_B_Paw'), + }, + skeleton_info={ + 0: dict(link=('L_Eye', 'R_Eye'), id=0, color=[0, 0, 255]), + 1: dict(link=('L_Eye', 'Nose'), id=1, color=[0, 0, 255]), + 2: dict(link=('R_Eye', 'Nose'), id=2, color=[0, 0, 255]), + 3: dict(link=('Nose', 'Neck'), id=3, color=[0, 255, 0]), + 4: dict(link=('Neck', 'Root of tail'), id=4, color=[0, 255, 0]), + 5: dict(link=('Neck', 'L_Shoulder'), id=5, color=[0, 255, 255]), + 6: dict(link=('L_Shoulder', 'L_Elbow'), id=6, color=[0, 255, 255]), + 7: dict(link=('L_Elbow', 'L_F_Paw'), id=6, color=[0, 255, 255]), + 8: dict(link=('Neck', 'R_Shoulder'), id=7, color=[6, 156, 250]), + 9: dict(link=('R_Shoulder', 'R_Elbow'), id=8, color=[6, 156, 250]), + 10: dict(link=('R_Elbow', 'R_F_Paw'), id=9, color=[6, 156, 250]), + 11: dict(link=('Root of tail', 'L_Hip'), id=10, color=[0, 255, 255]), + 12: dict(link=('L_Hip', 'L_Knee'), id=11, color=[0, 255, 255]), + 13: dict(link=('L_Knee', 'L_B_Paw'), id=12, color=[0, 255, 255]), + 14: dict(link=('Root of tail', 'R_Hip'), id=13, color=[6, 156, 250]), + 15: dict(link=('R_Hip', 'R_Knee'), id=14, color=[6, 156, 250]), + 16: dict(link=('R_Knee', 'R_B_Paw'), id=15, color=[6, 156, 250]), + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.025, 0.025, 0.026, 0.035, 0.035, 0.079, 0.072, 0.062, 0.079, 0.072, + 0.062, 0.107, 0.087, 0.089, 0.107, 0.087, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k_info.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k_info.py new file mode 100644 index 0000000000000000000000000000000000000000..0238abfd830c1f5866b6cf3c2f4730a2d915fa03 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ap10k_info.py @@ -0,0 +1,142 @@ +ap10k_info = dict( + dataset_name='ap10k', + paper_info=dict( + author='Yu, Hang and Xu, Yufei and Zhang, Jing and ' + 'Zhao, Wei and Guan, Ziyu and Tao, Dacheng', + title='AP-10K: A Benchmark for Animal Pose Estimation in the Wild', + container='35th Conference on Neural Information Processing Systems ' + '(NeurIPS 2021) Track on Datasets and Bench-marks.', + year='2021', + homepage='https://github.com/AlexTheBad/AP-10K', + ), + keypoint_info={ + 0: + dict( + name='L_Eye', id=0, color=[0, 255, 0], type='upper', swap='R_Eye'), + 1: + dict( + name='R_Eye', + id=1, + color=[255, 128, 0], + type='upper', + swap='L_Eye'), + 2: + dict(name='Nose', id=2, color=[51, 153, 255], type='upper', swap=''), + 3: + dict(name='Neck', id=3, color=[51, 153, 255], type='upper', swap=''), + 4: + dict( + name='Root of tail', + id=4, + color=[51, 153, 255], + type='lower', + swap=''), + 5: + dict( + name='L_Shoulder', + id=5, + color=[51, 153, 255], + type='upper', + swap='R_Shoulder'), + 6: + dict( + name='L_Elbow', + id=6, + color=[51, 153, 255], + type='upper', + swap='R_Elbow'), + 7: + dict( + name='L_F_Paw', + id=7, + color=[0, 255, 0], + type='upper', + swap='R_F_Paw'), + 8: + dict( + name='R_Shoulder', + id=8, + color=[0, 255, 0], + type='upper', + swap='L_Shoulder'), + 9: + dict( + name='R_Elbow', + id=9, + color=[255, 128, 0], + type='upper', + swap='L_Elbow'), + 10: + dict( + name='R_F_Paw', + id=10, + color=[0, 255, 0], + type='lower', + swap='L_F_Paw'), + 11: + dict( + name='L_Hip', + id=11, + color=[255, 128, 0], + type='lower', + swap='R_Hip'), + 12: + dict( + name='L_Knee', + id=12, + color=[255, 128, 0], + type='lower', + swap='R_Knee'), + 13: + dict( + name='L_B_Paw', + id=13, + color=[0, 255, 0], + type='lower', + swap='R_B_Paw'), + 14: + dict( + name='R_Hip', id=14, color=[0, 255, 0], type='lower', + swap='L_Hip'), + 15: + dict( + name='R_Knee', + id=15, + color=[0, 255, 0], + type='lower', + swap='L_Knee'), + 16: + dict( + name='R_B_Paw', + id=16, + color=[0, 255, 0], + type='lower', + swap='L_B_Paw'), + }, + skeleton_info={ + 0: dict(link=('L_Eye', 'R_Eye'), id=0, color=[0, 0, 255]), + 1: dict(link=('L_Eye', 'Nose'), id=1, color=[0, 0, 255]), + 2: dict(link=('R_Eye', 'Nose'), id=2, color=[0, 0, 255]), + 3: dict(link=('Nose', 'Neck'), id=3, color=[0, 255, 0]), + 4: dict(link=('Neck', 'Root of tail'), id=4, color=[0, 255, 0]), + 5: dict(link=('Neck', 'L_Shoulder'), id=5, color=[0, 255, 255]), + 6: dict(link=('L_Shoulder', 'L_Elbow'), id=6, color=[0, 255, 255]), + 7: dict(link=('L_Elbow', 'L_F_Paw'), id=6, color=[0, 255, 255]), + 8: dict(link=('Neck', 'R_Shoulder'), id=7, color=[6, 156, 250]), + 9: dict(link=('R_Shoulder', 'R_Elbow'), id=8, color=[6, 156, 250]), + 10: dict(link=('R_Elbow', 'R_F_Paw'), id=9, color=[6, 156, 250]), + 11: dict(link=('Root of tail', 'L_Hip'), id=10, color=[0, 255, 255]), + 12: dict(link=('L_Hip', 'L_Knee'), id=11, color=[0, 255, 255]), + 13: dict(link=('L_Knee', 'L_B_Paw'), id=12, color=[0, 255, 255]), + 14: dict(link=('Root of tail', 'R_Hip'), id=13, color=[6, 156, 250]), + 15: dict(link=('R_Hip', 'R_Knee'), id=14, color=[6, 156, 250]), + 16: dict(link=('R_Knee', 'R_B_Paw'), id=15, color=[6, 156, 250]), + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.025, 0.025, 0.026, 0.035, 0.035, 0.079, 0.072, 0.062, 0.079, 0.072, + 0.062, 0.107, 0.087, 0.089, 0.107, 0.087, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/atrw.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/atrw.py new file mode 100644 index 0000000000000000000000000000000000000000..84d3fb370cbb1158fbcf0c7a7cce95f3c4fc3c77 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/atrw.py @@ -0,0 +1,144 @@ +dataset_info = dict( + dataset_name='atrw', + paper_info=dict( + author='Li, Shuyuan and Li, Jianguo and Tang, Hanlin ' + 'and Qian, Rui and Lin, Weiyao', + title='ATRW: A Benchmark for Amur Tiger ' + 'Re-identification in the Wild', + container='Proceedings of the 28th ACM ' + 'International Conference on Multimedia', + year='2020', + homepage='https://cvwc2019.github.io/challenge.html', + ), + keypoint_info={ + 0: + dict( + name='left_ear', + id=0, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 1: + dict( + name='right_ear', + id=1, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 2: + dict(name='nose', id=2, color=[51, 153, 255], type='upper', swap=''), + 3: + dict( + name='right_shoulder', + id=3, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 4: + dict( + name='right_front_paw', + id=4, + color=[255, 128, 0], + type='upper', + swap='left_front_paw'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='left_front_paw', + id=6, + color=[0, 255, 0], + type='upper', + swap='right_front_paw'), + 7: + dict( + name='right_hip', + id=7, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 8: + dict( + name='right_knee', + id=8, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 9: + dict( + name='right_back_paw', + id=9, + color=[255, 128, 0], + type='lower', + swap='left_back_paw'), + 10: + dict( + name='left_hip', + id=10, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 11: + dict( + name='left_knee', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 12: + dict( + name='left_back_paw', + id=12, + color=[0, 255, 0], + type='lower', + swap='right_back_paw'), + 13: + dict(name='tail', id=13, color=[51, 153, 255], type='lower', swap=''), + 14: + dict( + name='center', id=14, color=[51, 153, 255], type='lower', swap=''), + }, + skeleton_info={ + 0: + dict(link=('left_ear', 'nose'), id=0, color=[51, 153, 255]), + 1: + dict(link=('right_ear', 'nose'), id=1, color=[51, 153, 255]), + 2: + dict(link=('nose', 'center'), id=2, color=[51, 153, 255]), + 3: + dict( + link=('left_shoulder', 'left_front_paw'), id=3, color=[0, 255, 0]), + 4: + dict(link=('left_shoulder', 'center'), id=4, color=[0, 255, 0]), + 5: + dict( + link=('right_shoulder', 'right_front_paw'), + id=5, + color=[255, 128, 0]), + 6: + dict(link=('right_shoulder', 'center'), id=6, color=[255, 128, 0]), + 7: + dict(link=('tail', 'center'), id=7, color=[51, 153, 255]), + 8: + dict(link=('right_back_paw', 'right_knee'), id=8, color=[255, 128, 0]), + 9: + dict(link=('right_knee', 'right_hip'), id=9, color=[255, 128, 0]), + 10: + dict(link=('right_hip', 'tail'), id=10, color=[255, 128, 0]), + 11: + dict(link=('left_back_paw', 'left_knee'), id=11, color=[0, 255, 0]), + 12: + dict(link=('left_knee', 'left_hip'), id=12, color=[0, 255, 0]), + 13: + dict(link=('left_hip', 'tail'), id=13, color=[0, 255, 0]), + }, + joint_weights=[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], + sigmas=[ + 0.0277, 0.0823, 0.0831, 0.0202, 0.0716, 0.0263, 0.0646, 0.0302, 0.0440, + 0.0316, 0.0333, 0.0547, 0.0263, 0.0683, 0.0539 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco.py new file mode 100644 index 0000000000000000000000000000000000000000..787e834b8a54480b46288ce062d716dfec0bcc4f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco.py @@ -0,0 +1,181 @@ +dataset_info = dict( + dataset_name='coco', + paper_info=dict( + author='Lin, Tsung-Yi and Maire, Michael and ' + 'Belongie, Serge and Hays, James and ' + 'Perona, Pietro and Ramanan, Deva and ' + r'Doll{\'a}r, Piotr and Zitnick, C Lawrence', + title='Microsoft coco: Common objects in context', + container='European conference on computer vision', + year='2014', + homepage='http://cocodataset.org/', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody.py new file mode 100644 index 0000000000000000000000000000000000000000..a739c97a725952a7c4e63da3a523a4136307efa9 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody.py @@ -0,0 +1,1154 @@ +dataset_info = dict( + dataset_name='coco_wholebody', + paper_info=dict( + author='Jin, Sheng and Xu, Lumin and Xu, Jin and ' + 'Wang, Can and Liu, Wentao and ' + 'Qian, Chen and Ouyang, Wanli and Luo, Ping', + title='Whole-Body Human Pose Estimation in the Wild', + container='Proceedings of the European ' + 'Conference on Computer Vision (ECCV)', + year='2020', + homepage='https://github.com/jin-s13/COCO-WholeBody/', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 17: + dict( + name='left_big_toe', + id=17, + color=[255, 128, 0], + type='lower', + swap='right_big_toe'), + 18: + dict( + name='left_small_toe', + id=18, + color=[255, 128, 0], + type='lower', + swap='right_small_toe'), + 19: + dict( + name='left_heel', + id=19, + color=[255, 128, 0], + type='lower', + swap='right_heel'), + 20: + dict( + name='right_big_toe', + id=20, + color=[255, 128, 0], + type='lower', + swap='left_big_toe'), + 21: + dict( + name='right_small_toe', + id=21, + color=[255, 128, 0], + type='lower', + swap='left_small_toe'), + 22: + dict( + name='right_heel', + id=22, + color=[255, 128, 0], + type='lower', + swap='left_heel'), + 23: + dict( + name='face-0', + id=23, + color=[255, 255, 255], + type='', + swap='face-16'), + 24: + dict( + name='face-1', + id=24, + color=[255, 255, 255], + type='', + swap='face-15'), + 25: + dict( + name='face-2', + id=25, + color=[255, 255, 255], + type='', + swap='face-14'), + 26: + dict( + name='face-3', + id=26, + color=[255, 255, 255], + type='', + swap='face-13'), + 27: + dict( + name='face-4', + id=27, + color=[255, 255, 255], + type='', + swap='face-12'), + 28: + dict( + name='face-5', + id=28, + color=[255, 255, 255], + type='', + swap='face-11'), + 29: + dict( + name='face-6', + id=29, + color=[255, 255, 255], + type='', + swap='face-10'), + 30: + dict( + name='face-7', + id=30, + color=[255, 255, 255], + type='', + swap='face-9'), + 31: + dict(name='face-8', id=31, color=[255, 255, 255], type='', swap=''), + 32: + dict( + name='face-9', + id=32, + color=[255, 255, 255], + type='', + swap='face-7'), + 33: + dict( + name='face-10', + id=33, + color=[255, 255, 255], + type='', + swap='face-6'), + 34: + dict( + name='face-11', + id=34, + color=[255, 255, 255], + type='', + swap='face-5'), + 35: + dict( + name='face-12', + id=35, + color=[255, 255, 255], + type='', + swap='face-4'), + 36: + dict( + name='face-13', + id=36, + color=[255, 255, 255], + type='', + swap='face-3'), + 37: + dict( + name='face-14', + id=37, + color=[255, 255, 255], + type='', + swap='face-2'), + 38: + dict( + name='face-15', + id=38, + color=[255, 255, 255], + type='', + swap='face-1'), + 39: + dict( + name='face-16', + id=39, + color=[255, 255, 255], + type='', + swap='face-0'), + 40: + dict( + name='face-17', + id=40, + color=[255, 255, 255], + type='', + swap='face-26'), + 41: + dict( + name='face-18', + id=41, + color=[255, 255, 255], + type='', + swap='face-25'), + 42: + dict( + name='face-19', + id=42, + color=[255, 255, 255], + type='', + swap='face-24'), + 43: + dict( + name='face-20', + id=43, + color=[255, 255, 255], + type='', + swap='face-23'), + 44: + dict( + name='face-21', + id=44, + color=[255, 255, 255], + type='', + swap='face-22'), + 45: + dict( + name='face-22', + id=45, + color=[255, 255, 255], + type='', + swap='face-21'), + 46: + dict( + name='face-23', + id=46, + color=[255, 255, 255], + type='', + swap='face-20'), + 47: + dict( + name='face-24', + id=47, + color=[255, 255, 255], + type='', + swap='face-19'), + 48: + dict( + name='face-25', + id=48, + color=[255, 255, 255], + type='', + swap='face-18'), + 49: + dict( + name='face-26', + id=49, + color=[255, 255, 255], + type='', + swap='face-17'), + 50: + dict(name='face-27', id=50, color=[255, 255, 255], type='', swap=''), + 51: + dict(name='face-28', id=51, color=[255, 255, 255], type='', swap=''), + 52: + dict(name='face-29', id=52, color=[255, 255, 255], type='', swap=''), + 53: + dict(name='face-30', id=53, color=[255, 255, 255], type='', swap=''), + 54: + dict( + name='face-31', + id=54, + color=[255, 255, 255], + type='', + swap='face-35'), + 55: + dict( + name='face-32', + id=55, + color=[255, 255, 255], + type='', + swap='face-34'), + 56: + dict(name='face-33', id=56, color=[255, 255, 255], type='', swap=''), + 57: + dict( + name='face-34', + id=57, + color=[255, 255, 255], + type='', + swap='face-32'), + 58: + dict( + name='face-35', + id=58, + color=[255, 255, 255], + type='', + swap='face-31'), + 59: + dict( + name='face-36', + id=59, + color=[255, 255, 255], + type='', + swap='face-45'), + 60: + dict( + name='face-37', + id=60, + color=[255, 255, 255], + type='', + swap='face-44'), + 61: + dict( + name='face-38', + id=61, + color=[255, 255, 255], + type='', + swap='face-43'), + 62: + dict( + name='face-39', + id=62, + color=[255, 255, 255], + type='', + swap='face-42'), + 63: + dict( + name='face-40', + id=63, + color=[255, 255, 255], + type='', + swap='face-47'), + 64: + dict( + name='face-41', + id=64, + color=[255, 255, 255], + type='', + swap='face-46'), + 65: + dict( + name='face-42', + id=65, + color=[255, 255, 255], + type='', + swap='face-39'), + 66: + dict( + name='face-43', + id=66, + color=[255, 255, 255], + type='', + swap='face-38'), + 67: + dict( + name='face-44', + id=67, + color=[255, 255, 255], + type='', + swap='face-37'), + 68: + dict( + name='face-45', + id=68, + color=[255, 255, 255], + type='', + swap='face-36'), + 69: + dict( + name='face-46', + id=69, + color=[255, 255, 255], + type='', + swap='face-41'), + 70: + dict( + name='face-47', + id=70, + color=[255, 255, 255], + type='', + swap='face-40'), + 71: + dict( + name='face-48', + id=71, + color=[255, 255, 255], + type='', + swap='face-54'), + 72: + dict( + name='face-49', + id=72, + color=[255, 255, 255], + type='', + swap='face-53'), + 73: + dict( + name='face-50', + id=73, + color=[255, 255, 255], + type='', + swap='face-52'), + 74: + dict(name='face-51', id=74, color=[255, 255, 255], type='', swap=''), + 75: + dict( + name='face-52', + id=75, + color=[255, 255, 255], + type='', + swap='face-50'), + 76: + dict( + name='face-53', + id=76, + color=[255, 255, 255], + type='', + swap='face-49'), + 77: + dict( + name='face-54', + id=77, + color=[255, 255, 255], + type='', + swap='face-48'), + 78: + dict( + name='face-55', + id=78, + color=[255, 255, 255], + type='', + swap='face-59'), + 79: + dict( + name='face-56', + id=79, + color=[255, 255, 255], + type='', + swap='face-58'), + 80: + dict(name='face-57', id=80, color=[255, 255, 255], type='', swap=''), + 81: + dict( + name='face-58', + id=81, + color=[255, 255, 255], + type='', + swap='face-56'), + 82: + dict( + name='face-59', + id=82, + color=[255, 255, 255], + type='', + swap='face-55'), + 83: + dict( + name='face-60', + id=83, + color=[255, 255, 255], + type='', + swap='face-64'), + 84: + dict( + name='face-61', + id=84, + color=[255, 255, 255], + type='', + swap='face-63'), + 85: + dict(name='face-62', id=85, color=[255, 255, 255], type='', swap=''), + 86: + dict( + name='face-63', + id=86, + color=[255, 255, 255], + type='', + swap='face-61'), + 87: + dict( + name='face-64', + id=87, + color=[255, 255, 255], + type='', + swap='face-60'), + 88: + dict( + name='face-65', + id=88, + color=[255, 255, 255], + type='', + swap='face-67'), + 89: + dict(name='face-66', id=89, color=[255, 255, 255], type='', swap=''), + 90: + dict( + name='face-67', + id=90, + color=[255, 255, 255], + type='', + swap='face-65'), + 91: + dict( + name='left_hand_root', + id=91, + color=[255, 255, 255], + type='', + swap='right_hand_root'), + 92: + dict( + name='left_thumb1', + id=92, + color=[255, 128, 0], + type='', + swap='right_thumb1'), + 93: + dict( + name='left_thumb2', + id=93, + color=[255, 128, 0], + type='', + swap='right_thumb2'), + 94: + dict( + name='left_thumb3', + id=94, + color=[255, 128, 0], + type='', + swap='right_thumb3'), + 95: + dict( + name='left_thumb4', + id=95, + color=[255, 128, 0], + type='', + swap='right_thumb4'), + 96: + dict( + name='left_forefinger1', + id=96, + color=[255, 153, 255], + type='', + swap='right_forefinger1'), + 97: + dict( + name='left_forefinger2', + id=97, + color=[255, 153, 255], + type='', + swap='right_forefinger2'), + 98: + dict( + name='left_forefinger3', + id=98, + color=[255, 153, 255], + type='', + swap='right_forefinger3'), + 99: + dict( + name='left_forefinger4', + id=99, + color=[255, 153, 255], + type='', + swap='right_forefinger4'), + 100: + dict( + name='left_middle_finger1', + id=100, + color=[102, 178, 255], + type='', + swap='right_middle_finger1'), + 101: + dict( + name='left_middle_finger2', + id=101, + color=[102, 178, 255], + type='', + swap='right_middle_finger2'), + 102: + dict( + name='left_middle_finger3', + id=102, + color=[102, 178, 255], + type='', + swap='right_middle_finger3'), + 103: + dict( + name='left_middle_finger4', + id=103, + color=[102, 178, 255], + type='', + swap='right_middle_finger4'), + 104: + dict( + name='left_ring_finger1', + id=104, + color=[255, 51, 51], + type='', + swap='right_ring_finger1'), + 105: + dict( + name='left_ring_finger2', + id=105, + color=[255, 51, 51], + type='', + swap='right_ring_finger2'), + 106: + dict( + name='left_ring_finger3', + id=106, + color=[255, 51, 51], + type='', + swap='right_ring_finger3'), + 107: + dict( + name='left_ring_finger4', + id=107, + color=[255, 51, 51], + type='', + swap='right_ring_finger4'), + 108: + dict( + name='left_pinky_finger1', + id=108, + color=[0, 255, 0], + type='', + swap='right_pinky_finger1'), + 109: + dict( + name='left_pinky_finger2', + id=109, + color=[0, 255, 0], + type='', + swap='right_pinky_finger2'), + 110: + dict( + name='left_pinky_finger3', + id=110, + color=[0, 255, 0], + type='', + swap='right_pinky_finger3'), + 111: + dict( + name='left_pinky_finger4', + id=111, + color=[0, 255, 0], + type='', + swap='right_pinky_finger4'), + 112: + dict( + name='right_hand_root', + id=112, + color=[255, 255, 255], + type='', + swap='left_hand_root'), + 113: + dict( + name='right_thumb1', + id=113, + color=[255, 128, 0], + type='', + swap='left_thumb1'), + 114: + dict( + name='right_thumb2', + id=114, + color=[255, 128, 0], + type='', + swap='left_thumb2'), + 115: + dict( + name='right_thumb3', + id=115, + color=[255, 128, 0], + type='', + swap='left_thumb3'), + 116: + dict( + name='right_thumb4', + id=116, + color=[255, 128, 0], + type='', + swap='left_thumb4'), + 117: + dict( + name='right_forefinger1', + id=117, + color=[255, 153, 255], + type='', + swap='left_forefinger1'), + 118: + dict( + name='right_forefinger2', + id=118, + color=[255, 153, 255], + type='', + swap='left_forefinger2'), + 119: + dict( + name='right_forefinger3', + id=119, + color=[255, 153, 255], + type='', + swap='left_forefinger3'), + 120: + dict( + name='right_forefinger4', + id=120, + color=[255, 153, 255], + type='', + swap='left_forefinger4'), + 121: + dict( + name='right_middle_finger1', + id=121, + color=[102, 178, 255], + type='', + swap='left_middle_finger1'), + 122: + dict( + name='right_middle_finger2', + id=122, + color=[102, 178, 255], + type='', + swap='left_middle_finger2'), + 123: + dict( + name='right_middle_finger3', + id=123, + color=[102, 178, 255], + type='', + swap='left_middle_finger3'), + 124: + dict( + name='right_middle_finger4', + id=124, + color=[102, 178, 255], + type='', + swap='left_middle_finger4'), + 125: + dict( + name='right_ring_finger1', + id=125, + color=[255, 51, 51], + type='', + swap='left_ring_finger1'), + 126: + dict( + name='right_ring_finger2', + id=126, + color=[255, 51, 51], + type='', + swap='left_ring_finger2'), + 127: + dict( + name='right_ring_finger3', + id=127, + color=[255, 51, 51], + type='', + swap='left_ring_finger3'), + 128: + dict( + name='right_ring_finger4', + id=128, + color=[255, 51, 51], + type='', + swap='left_ring_finger4'), + 129: + dict( + name='right_pinky_finger1', + id=129, + color=[0, 255, 0], + type='', + swap='left_pinky_finger1'), + 130: + dict( + name='right_pinky_finger2', + id=130, + color=[0, 255, 0], + type='', + swap='left_pinky_finger2'), + 131: + dict( + name='right_pinky_finger3', + id=131, + color=[0, 255, 0], + type='', + swap='left_pinky_finger3'), + 132: + dict( + name='right_pinky_finger4', + id=132, + color=[0, 255, 0], + type='', + swap='left_pinky_finger4') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]), + 19: + dict(link=('left_ankle', 'left_big_toe'), id=19, color=[0, 255, 0]), + 20: + dict(link=('left_ankle', 'left_small_toe'), id=20, color=[0, 255, 0]), + 21: + dict(link=('left_ankle', 'left_heel'), id=21, color=[0, 255, 0]), + 22: + dict( + link=('right_ankle', 'right_big_toe'), id=22, color=[255, 128, 0]), + 23: + dict( + link=('right_ankle', 'right_small_toe'), + id=23, + color=[255, 128, 0]), + 24: + dict(link=('right_ankle', 'right_heel'), id=24, color=[255, 128, 0]), + 25: + dict( + link=('left_hand_root', 'left_thumb1'), id=25, color=[255, 128, + 0]), + 26: + dict(link=('left_thumb1', 'left_thumb2'), id=26, color=[255, 128, 0]), + 27: + dict(link=('left_thumb2', 'left_thumb3'), id=27, color=[255, 128, 0]), + 28: + dict(link=('left_thumb3', 'left_thumb4'), id=28, color=[255, 128, 0]), + 29: + dict( + link=('left_hand_root', 'left_forefinger1'), + id=29, + color=[255, 153, 255]), + 30: + dict( + link=('left_forefinger1', 'left_forefinger2'), + id=30, + color=[255, 153, 255]), + 31: + dict( + link=('left_forefinger2', 'left_forefinger3'), + id=31, + color=[255, 153, 255]), + 32: + dict( + link=('left_forefinger3', 'left_forefinger4'), + id=32, + color=[255, 153, 255]), + 33: + dict( + link=('left_hand_root', 'left_middle_finger1'), + id=33, + color=[102, 178, 255]), + 34: + dict( + link=('left_middle_finger1', 'left_middle_finger2'), + id=34, + color=[102, 178, 255]), + 35: + dict( + link=('left_middle_finger2', 'left_middle_finger3'), + id=35, + color=[102, 178, 255]), + 36: + dict( + link=('left_middle_finger3', 'left_middle_finger4'), + id=36, + color=[102, 178, 255]), + 37: + dict( + link=('left_hand_root', 'left_ring_finger1'), + id=37, + color=[255, 51, 51]), + 38: + dict( + link=('left_ring_finger1', 'left_ring_finger2'), + id=38, + color=[255, 51, 51]), + 39: + dict( + link=('left_ring_finger2', 'left_ring_finger3'), + id=39, + color=[255, 51, 51]), + 40: + dict( + link=('left_ring_finger3', 'left_ring_finger4'), + id=40, + color=[255, 51, 51]), + 41: + dict( + link=('left_hand_root', 'left_pinky_finger1'), + id=41, + color=[0, 255, 0]), + 42: + dict( + link=('left_pinky_finger1', 'left_pinky_finger2'), + id=42, + color=[0, 255, 0]), + 43: + dict( + link=('left_pinky_finger2', 'left_pinky_finger3'), + id=43, + color=[0, 255, 0]), + 44: + dict( + link=('left_pinky_finger3', 'left_pinky_finger4'), + id=44, + color=[0, 255, 0]), + 45: + dict( + link=('right_hand_root', 'right_thumb1'), + id=45, + color=[255, 128, 0]), + 46: + dict( + link=('right_thumb1', 'right_thumb2'), id=46, color=[255, 128, 0]), + 47: + dict( + link=('right_thumb2', 'right_thumb3'), id=47, color=[255, 128, 0]), + 48: + dict( + link=('right_thumb3', 'right_thumb4'), id=48, color=[255, 128, 0]), + 49: + dict( + link=('right_hand_root', 'right_forefinger1'), + id=49, + color=[255, 153, 255]), + 50: + dict( + link=('right_forefinger1', 'right_forefinger2'), + id=50, + color=[255, 153, 255]), + 51: + dict( + link=('right_forefinger2', 'right_forefinger3'), + id=51, + color=[255, 153, 255]), + 52: + dict( + link=('right_forefinger3', 'right_forefinger4'), + id=52, + color=[255, 153, 255]), + 53: + dict( + link=('right_hand_root', 'right_middle_finger1'), + id=53, + color=[102, 178, 255]), + 54: + dict( + link=('right_middle_finger1', 'right_middle_finger2'), + id=54, + color=[102, 178, 255]), + 55: + dict( + link=('right_middle_finger2', 'right_middle_finger3'), + id=55, + color=[102, 178, 255]), + 56: + dict( + link=('right_middle_finger3', 'right_middle_finger4'), + id=56, + color=[102, 178, 255]), + 57: + dict( + link=('right_hand_root', 'right_ring_finger1'), + id=57, + color=[255, 51, 51]), + 58: + dict( + link=('right_ring_finger1', 'right_ring_finger2'), + id=58, + color=[255, 51, 51]), + 59: + dict( + link=('right_ring_finger2', 'right_ring_finger3'), + id=59, + color=[255, 51, 51]), + 60: + dict( + link=('right_ring_finger3', 'right_ring_finger4'), + id=60, + color=[255, 51, 51]), + 61: + dict( + link=('right_hand_root', 'right_pinky_finger1'), + id=61, + color=[0, 255, 0]), + 62: + dict( + link=('right_pinky_finger1', 'right_pinky_finger2'), + id=62, + color=[0, 255, 0]), + 63: + dict( + link=('right_pinky_finger2', 'right_pinky_finger3'), + id=63, + color=[0, 255, 0]), + 64: + dict( + link=('right_pinky_finger3', 'right_pinky_finger4'), + id=64, + color=[0, 255, 0]) + }, + joint_weights=[1.] * 133, + # 'https://github.com/jin-s13/COCO-WholeBody/blob/master/' + # 'evaluation/myeval_wholebody.py#L175' + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089, 0.068, 0.066, 0.066, + 0.092, 0.094, 0.094, 0.042, 0.043, 0.044, 0.043, 0.040, 0.035, 0.031, + 0.025, 0.020, 0.023, 0.029, 0.032, 0.037, 0.038, 0.043, 0.041, 0.045, + 0.013, 0.012, 0.011, 0.011, 0.012, 0.012, 0.011, 0.011, 0.013, 0.015, + 0.009, 0.007, 0.007, 0.007, 0.012, 0.009, 0.008, 0.016, 0.010, 0.017, + 0.011, 0.009, 0.011, 0.009, 0.007, 0.013, 0.008, 0.011, 0.012, 0.010, + 0.034, 0.008, 0.008, 0.009, 0.008, 0.008, 0.007, 0.010, 0.008, 0.009, + 0.009, 0.009, 0.007, 0.007, 0.008, 0.011, 0.008, 0.008, 0.008, 0.01, + 0.008, 0.029, 0.022, 0.035, 0.037, 0.047, 0.026, 0.025, 0.024, 0.035, + 0.018, 0.024, 0.022, 0.026, 0.017, 0.021, 0.021, 0.032, 0.02, 0.019, + 0.022, 0.031, 0.029, 0.022, 0.035, 0.037, 0.047, 0.026, 0.025, 0.024, + 0.035, 0.018, 0.024, 0.022, 0.026, 0.017, 0.021, 0.021, 0.032, 0.02, + 0.019, 0.022, 0.031 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_face.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_face.py new file mode 100644 index 0000000000000000000000000000000000000000..d53d2da86b749c2c14ad0d4d2ba3565b69dc622d --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_face.py @@ -0,0 +1,448 @@ +dataset_info = dict( + dataset_name='coco_wholebody_face', + paper_info=dict( + author='Jin, Sheng and Xu, Lumin and Xu, Jin and ' + 'Wang, Can and Liu, Wentao and ' + 'Qian, Chen and Ouyang, Wanli and Luo, Ping', + title='Whole-Body Human Pose Estimation in the Wild', + container='Proceedings of the European ' + 'Conference on Computer Vision (ECCV)', + year='2020', + homepage='https://github.com/jin-s13/COCO-WholeBody/', + ), + keypoint_info={ + 0: + dict( + name='face-0', + id=0, + color=[255, 255, 255], + type='', + swap='face-16'), + 1: + dict( + name='face-1', + id=1, + color=[255, 255, 255], + type='', + swap='face-15'), + 2: + dict( + name='face-2', + id=2, + color=[255, 255, 255], + type='', + swap='face-14'), + 3: + dict( + name='face-3', + id=3, + color=[255, 255, 255], + type='', + swap='face-13'), + 4: + dict( + name='face-4', + id=4, + color=[255, 255, 255], + type='', + swap='face-12'), + 5: + dict( + name='face-5', + id=5, + color=[255, 255, 255], + type='', + swap='face-11'), + 6: + dict( + name='face-6', + id=6, + color=[255, 255, 255], + type='', + swap='face-10'), + 7: + dict( + name='face-7', id=7, color=[255, 255, 255], type='', + swap='face-9'), + 8: + dict(name='face-8', id=8, color=[255, 255, 255], type='', swap=''), + 9: + dict( + name='face-9', id=9, color=[255, 255, 255], type='', + swap='face-7'), + 10: + dict( + name='face-10', + id=10, + color=[255, 255, 255], + type='', + swap='face-6'), + 11: + dict( + name='face-11', + id=11, + color=[255, 255, 255], + type='', + swap='face-5'), + 12: + dict( + name='face-12', + id=12, + color=[255, 255, 255], + type='', + swap='face-4'), + 13: + dict( + name='face-13', + id=13, + color=[255, 255, 255], + type='', + swap='face-3'), + 14: + dict( + name='face-14', + id=14, + color=[255, 255, 255], + type='', + swap='face-2'), + 15: + dict( + name='face-15', + id=15, + color=[255, 255, 255], + type='', + swap='face-1'), + 16: + dict( + name='face-16', + id=16, + color=[255, 255, 255], + type='', + swap='face-0'), + 17: + dict( + name='face-17', + id=17, + color=[255, 255, 255], + type='', + swap='face-26'), + 18: + dict( + name='face-18', + id=18, + color=[255, 255, 255], + type='', + swap='face-25'), + 19: + dict( + name='face-19', + id=19, + color=[255, 255, 255], + type='', + swap='face-24'), + 20: + dict( + name='face-20', + id=20, + color=[255, 255, 255], + type='', + swap='face-23'), + 21: + dict( + name='face-21', + id=21, + color=[255, 255, 255], + type='', + swap='face-22'), + 22: + dict( + name='face-22', + id=22, + color=[255, 255, 255], + type='', + swap='face-21'), + 23: + dict( + name='face-23', + id=23, + color=[255, 255, 255], + type='', + swap='face-20'), + 24: + dict( + name='face-24', + id=24, + color=[255, 255, 255], + type='', + swap='face-19'), + 25: + dict( + name='face-25', + id=25, + color=[255, 255, 255], + type='', + swap='face-18'), + 26: + dict( + name='face-26', + id=26, + color=[255, 255, 255], + type='', + swap='face-17'), + 27: + dict(name='face-27', id=27, color=[255, 255, 255], type='', swap=''), + 28: + dict(name='face-28', id=28, color=[255, 255, 255], type='', swap=''), + 29: + dict(name='face-29', id=29, color=[255, 255, 255], type='', swap=''), + 30: + dict(name='face-30', id=30, color=[255, 255, 255], type='', swap=''), + 31: + dict( + name='face-31', + id=31, + color=[255, 255, 255], + type='', + swap='face-35'), + 32: + dict( + name='face-32', + id=32, + color=[255, 255, 255], + type='', + swap='face-34'), + 33: + dict(name='face-33', id=33, color=[255, 255, 255], type='', swap=''), + 34: + dict( + name='face-34', + id=34, + color=[255, 255, 255], + type='', + swap='face-32'), + 35: + dict( + name='face-35', + id=35, + color=[255, 255, 255], + type='', + swap='face-31'), + 36: + dict( + name='face-36', + id=36, + color=[255, 255, 255], + type='', + swap='face-45'), + 37: + dict( + name='face-37', + id=37, + color=[255, 255, 255], + type='', + swap='face-44'), + 38: + dict( + name='face-38', + id=38, + color=[255, 255, 255], + type='', + swap='face-43'), + 39: + dict( + name='face-39', + id=39, + color=[255, 255, 255], + type='', + swap='face-42'), + 40: + dict( + name='face-40', + id=40, + color=[255, 255, 255], + type='', + swap='face-47'), + 41: + dict( + name='face-41', + id=41, + color=[255, 255, 255], + type='', + swap='face-46'), + 42: + dict( + name='face-42', + id=42, + color=[255, 255, 255], + type='', + swap='face-39'), + 43: + dict( + name='face-43', + id=43, + color=[255, 255, 255], + type='', + swap='face-38'), + 44: + dict( + name='face-44', + id=44, + color=[255, 255, 255], + type='', + swap='face-37'), + 45: + dict( + name='face-45', + id=45, + color=[255, 255, 255], + type='', + swap='face-36'), + 46: + dict( + name='face-46', + id=46, + color=[255, 255, 255], + type='', + swap='face-41'), + 47: + dict( + name='face-47', + id=47, + color=[255, 255, 255], + type='', + swap='face-40'), + 48: + dict( + name='face-48', + id=48, + color=[255, 255, 255], + type='', + swap='face-54'), + 49: + dict( + name='face-49', + id=49, + color=[255, 255, 255], + type='', + swap='face-53'), + 50: + dict( + name='face-50', + id=50, + color=[255, 255, 255], + type='', + swap='face-52'), + 51: + dict(name='face-51', id=52, color=[255, 255, 255], type='', swap=''), + 52: + dict( + name='face-52', + id=52, + color=[255, 255, 255], + type='', + swap='face-50'), + 53: + dict( + name='face-53', + id=53, + color=[255, 255, 255], + type='', + swap='face-49'), + 54: + dict( + name='face-54', + id=54, + color=[255, 255, 255], + type='', + swap='face-48'), + 55: + dict( + name='face-55', + id=55, + color=[255, 255, 255], + type='', + swap='face-59'), + 56: + dict( + name='face-56', + id=56, + color=[255, 255, 255], + type='', + swap='face-58'), + 57: + dict(name='face-57', id=57, color=[255, 255, 255], type='', swap=''), + 58: + dict( + name='face-58', + id=58, + color=[255, 255, 255], + type='', + swap='face-56'), + 59: + dict( + name='face-59', + id=59, + color=[255, 255, 255], + type='', + swap='face-55'), + 60: + dict( + name='face-60', + id=60, + color=[255, 255, 255], + type='', + swap='face-64'), + 61: + dict( + name='face-61', + id=61, + color=[255, 255, 255], + type='', + swap='face-63'), + 62: + dict(name='face-62', id=62, color=[255, 255, 255], type='', swap=''), + 63: + dict( + name='face-63', + id=63, + color=[255, 255, 255], + type='', + swap='face-61'), + 64: + dict( + name='face-64', + id=64, + color=[255, 255, 255], + type='', + swap='face-60'), + 65: + dict( + name='face-65', + id=65, + color=[255, 255, 255], + type='', + swap='face-67'), + 66: + dict(name='face-66', id=66, color=[255, 255, 255], type='', swap=''), + 67: + dict( + name='face-67', + id=67, + color=[255, 255, 255], + type='', + swap='face-65') + }, + skeleton_info={}, + joint_weights=[1.] * 68, + + # 'https://github.com/jin-s13/COCO-WholeBody/blob/master/' + # 'evaluation/myeval_wholebody.py#L177' + sigmas=[ + 0.042, 0.043, 0.044, 0.043, 0.040, 0.035, 0.031, 0.025, 0.020, 0.023, + 0.029, 0.032, 0.037, 0.038, 0.043, 0.041, 0.045, 0.013, 0.012, 0.011, + 0.011, 0.012, 0.012, 0.011, 0.011, 0.013, 0.015, 0.009, 0.007, 0.007, + 0.007, 0.012, 0.009, 0.008, 0.016, 0.010, 0.017, 0.011, 0.009, 0.011, + 0.009, 0.007, 0.013, 0.008, 0.011, 0.012, 0.010, 0.034, 0.008, 0.008, + 0.009, 0.008, 0.008, 0.007, 0.010, 0.008, 0.009, 0.009, 0.009, 0.007, + 0.007, 0.008, 0.011, 0.008, 0.008, 0.008, 0.01, 0.008 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_hand.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_hand.py new file mode 100644 index 0000000000000000000000000000000000000000..585ed789bdd053699059383df679c0699bee4777 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_hand.py @@ -0,0 +1,147 @@ +dataset_info = dict( + dataset_name='coco_wholebody_hand', + paper_info=dict( + author='Jin, Sheng and Xu, Lumin and Xu, Jin and ' + 'Wang, Can and Liu, Wentao and ' + 'Qian, Chen and Ouyang, Wanli and Luo, Ping', + title='Whole-Body Human Pose Estimation in the Wild', + container='Proceedings of the European ' + 'Conference on Computer Vision (ECCV)', + year='2020', + homepage='https://github.com/jin-s13/COCO-WholeBody/', + ), + keypoint_info={ + 0: + dict(name='wrist', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='thumb1', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb3', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict(name='thumb4', id=4, color=[255, 128, 0], type='', swap=''), + 5: + dict( + name='forefinger1', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger3', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='forefinger4', id=8, color=[255, 153, 255], type='', swap=''), + 9: + dict( + name='middle_finger1', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger3', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='middle_finger4', + id=12, + color=[102, 178, 255], + type='', + swap=''), + 13: + dict( + name='ring_finger1', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger3', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict( + name='ring_finger4', id=16, color=[255, 51, 51], type='', swap=''), + 17: + dict(name='pinky_finger1', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger3', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='pinky_finger4', id=20, color=[0, 255, 0], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[ + 0.029, 0.022, 0.035, 0.037, 0.047, 0.026, 0.025, 0.024, 0.035, 0.018, + 0.024, 0.022, 0.026, 0.017, 0.021, 0.021, 0.032, 0.02, 0.019, 0.022, + 0.031 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_info.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_info.py new file mode 100644 index 0000000000000000000000000000000000000000..b0ce8100b1718d64b3c61a0f909f5a17bc393944 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/coco_wholebody_info.py @@ -0,0 +1,1154 @@ +cocowholebody_info = dict( + dataset_name='coco_wholebody', + paper_info=dict( + author='Jin, Sheng and Xu, Lumin and Xu, Jin and ' + 'Wang, Can and Liu, Wentao and ' + 'Qian, Chen and Ouyang, Wanli and Luo, Ping', + title='Whole-Body Human Pose Estimation in the Wild', + container='Proceedings of the European ' + 'Conference on Computer Vision (ECCV)', + year='2020', + homepage='https://github.com/jin-s13/COCO-WholeBody/', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 17: + dict( + name='left_big_toe', + id=17, + color=[255, 128, 0], + type='lower', + swap='right_big_toe'), + 18: + dict( + name='left_small_toe', + id=18, + color=[255, 128, 0], + type='lower', + swap='right_small_toe'), + 19: + dict( + name='left_heel', + id=19, + color=[255, 128, 0], + type='lower', + swap='right_heel'), + 20: + dict( + name='right_big_toe', + id=20, + color=[255, 128, 0], + type='lower', + swap='left_big_toe'), + 21: + dict( + name='right_small_toe', + id=21, + color=[255, 128, 0], + type='lower', + swap='left_small_toe'), + 22: + dict( + name='right_heel', + id=22, + color=[255, 128, 0], + type='lower', + swap='left_heel'), + 23: + dict( + name='face-0', + id=23, + color=[255, 255, 255], + type='', + swap='face-16'), + 24: + dict( + name='face-1', + id=24, + color=[255, 255, 255], + type='', + swap='face-15'), + 25: + dict( + name='face-2', + id=25, + color=[255, 255, 255], + type='', + swap='face-14'), + 26: + dict( + name='face-3', + id=26, + color=[255, 255, 255], + type='', + swap='face-13'), + 27: + dict( + name='face-4', + id=27, + color=[255, 255, 255], + type='', + swap='face-12'), + 28: + dict( + name='face-5', + id=28, + color=[255, 255, 255], + type='', + swap='face-11'), + 29: + dict( + name='face-6', + id=29, + color=[255, 255, 255], + type='', + swap='face-10'), + 30: + dict( + name='face-7', + id=30, + color=[255, 255, 255], + type='', + swap='face-9'), + 31: + dict(name='face-8', id=31, color=[255, 255, 255], type='', swap=''), + 32: + dict( + name='face-9', + id=32, + color=[255, 255, 255], + type='', + swap='face-7'), + 33: + dict( + name='face-10', + id=33, + color=[255, 255, 255], + type='', + swap='face-6'), + 34: + dict( + name='face-11', + id=34, + color=[255, 255, 255], + type='', + swap='face-5'), + 35: + dict( + name='face-12', + id=35, + color=[255, 255, 255], + type='', + swap='face-4'), + 36: + dict( + name='face-13', + id=36, + color=[255, 255, 255], + type='', + swap='face-3'), + 37: + dict( + name='face-14', + id=37, + color=[255, 255, 255], + type='', + swap='face-2'), + 38: + dict( + name='face-15', + id=38, + color=[255, 255, 255], + type='', + swap='face-1'), + 39: + dict( + name='face-16', + id=39, + color=[255, 255, 255], + type='', + swap='face-0'), + 40: + dict( + name='face-17', + id=40, + color=[255, 255, 255], + type='', + swap='face-26'), + 41: + dict( + name='face-18', + id=41, + color=[255, 255, 255], + type='', + swap='face-25'), + 42: + dict( + name='face-19', + id=42, + color=[255, 255, 255], + type='', + swap='face-24'), + 43: + dict( + name='face-20', + id=43, + color=[255, 255, 255], + type='', + swap='face-23'), + 44: + dict( + name='face-21', + id=44, + color=[255, 255, 255], + type='', + swap='face-22'), + 45: + dict( + name='face-22', + id=45, + color=[255, 255, 255], + type='', + swap='face-21'), + 46: + dict( + name='face-23', + id=46, + color=[255, 255, 255], + type='', + swap='face-20'), + 47: + dict( + name='face-24', + id=47, + color=[255, 255, 255], + type='', + swap='face-19'), + 48: + dict( + name='face-25', + id=48, + color=[255, 255, 255], + type='', + swap='face-18'), + 49: + dict( + name='face-26', + id=49, + color=[255, 255, 255], + type='', + swap='face-17'), + 50: + dict(name='face-27', id=50, color=[255, 255, 255], type='', swap=''), + 51: + dict(name='face-28', id=51, color=[255, 255, 255], type='', swap=''), + 52: + dict(name='face-29', id=52, color=[255, 255, 255], type='', swap=''), + 53: + dict(name='face-30', id=53, color=[255, 255, 255], type='', swap=''), + 54: + dict( + name='face-31', + id=54, + color=[255, 255, 255], + type='', + swap='face-35'), + 55: + dict( + name='face-32', + id=55, + color=[255, 255, 255], + type='', + swap='face-34'), + 56: + dict(name='face-33', id=56, color=[255, 255, 255], type='', swap=''), + 57: + dict( + name='face-34', + id=57, + color=[255, 255, 255], + type='', + swap='face-32'), + 58: + dict( + name='face-35', + id=58, + color=[255, 255, 255], + type='', + swap='face-31'), + 59: + dict( + name='face-36', + id=59, + color=[255, 255, 255], + type='', + swap='face-45'), + 60: + dict( + name='face-37', + id=60, + color=[255, 255, 255], + type='', + swap='face-44'), + 61: + dict( + name='face-38', + id=61, + color=[255, 255, 255], + type='', + swap='face-43'), + 62: + dict( + name='face-39', + id=62, + color=[255, 255, 255], + type='', + swap='face-42'), + 63: + dict( + name='face-40', + id=63, + color=[255, 255, 255], + type='', + swap='face-47'), + 64: + dict( + name='face-41', + id=64, + color=[255, 255, 255], + type='', + swap='face-46'), + 65: + dict( + name='face-42', + id=65, + color=[255, 255, 255], + type='', + swap='face-39'), + 66: + dict( + name='face-43', + id=66, + color=[255, 255, 255], + type='', + swap='face-38'), + 67: + dict( + name='face-44', + id=67, + color=[255, 255, 255], + type='', + swap='face-37'), + 68: + dict( + name='face-45', + id=68, + color=[255, 255, 255], + type='', + swap='face-36'), + 69: + dict( + name='face-46', + id=69, + color=[255, 255, 255], + type='', + swap='face-41'), + 70: + dict( + name='face-47', + id=70, + color=[255, 255, 255], + type='', + swap='face-40'), + 71: + dict( + name='face-48', + id=71, + color=[255, 255, 255], + type='', + swap='face-54'), + 72: + dict( + name='face-49', + id=72, + color=[255, 255, 255], + type='', + swap='face-53'), + 73: + dict( + name='face-50', + id=73, + color=[255, 255, 255], + type='', + swap='face-52'), + 74: + dict(name='face-51', id=74, color=[255, 255, 255], type='', swap=''), + 75: + dict( + name='face-52', + id=75, + color=[255, 255, 255], + type='', + swap='face-50'), + 76: + dict( + name='face-53', + id=76, + color=[255, 255, 255], + type='', + swap='face-49'), + 77: + dict( + name='face-54', + id=77, + color=[255, 255, 255], + type='', + swap='face-48'), + 78: + dict( + name='face-55', + id=78, + color=[255, 255, 255], + type='', + swap='face-59'), + 79: + dict( + name='face-56', + id=79, + color=[255, 255, 255], + type='', + swap='face-58'), + 80: + dict(name='face-57', id=80, color=[255, 255, 255], type='', swap=''), + 81: + dict( + name='face-58', + id=81, + color=[255, 255, 255], + type='', + swap='face-56'), + 82: + dict( + name='face-59', + id=82, + color=[255, 255, 255], + type='', + swap='face-55'), + 83: + dict( + name='face-60', + id=83, + color=[255, 255, 255], + type='', + swap='face-64'), + 84: + dict( + name='face-61', + id=84, + color=[255, 255, 255], + type='', + swap='face-63'), + 85: + dict(name='face-62', id=85, color=[255, 255, 255], type='', swap=''), + 86: + dict( + name='face-63', + id=86, + color=[255, 255, 255], + type='', + swap='face-61'), + 87: + dict( + name='face-64', + id=87, + color=[255, 255, 255], + type='', + swap='face-60'), + 88: + dict( + name='face-65', + id=88, + color=[255, 255, 255], + type='', + swap='face-67'), + 89: + dict(name='face-66', id=89, color=[255, 255, 255], type='', swap=''), + 90: + dict( + name='face-67', + id=90, + color=[255, 255, 255], + type='', + swap='face-65'), + 91: + dict( + name='left_hand_root', + id=91, + color=[255, 255, 255], + type='', + swap='right_hand_root'), + 92: + dict( + name='left_thumb1', + id=92, + color=[255, 128, 0], + type='', + swap='right_thumb1'), + 93: + dict( + name='left_thumb2', + id=93, + color=[255, 128, 0], + type='', + swap='right_thumb2'), + 94: + dict( + name='left_thumb3', + id=94, + color=[255, 128, 0], + type='', + swap='right_thumb3'), + 95: + dict( + name='left_thumb4', + id=95, + color=[255, 128, 0], + type='', + swap='right_thumb4'), + 96: + dict( + name='left_forefinger1', + id=96, + color=[255, 153, 255], + type='', + swap='right_forefinger1'), + 97: + dict( + name='left_forefinger2', + id=97, + color=[255, 153, 255], + type='', + swap='right_forefinger2'), + 98: + dict( + name='left_forefinger3', + id=98, + color=[255, 153, 255], + type='', + swap='right_forefinger3'), + 99: + dict( + name='left_forefinger4', + id=99, + color=[255, 153, 255], + type='', + swap='right_forefinger4'), + 100: + dict( + name='left_middle_finger1', + id=100, + color=[102, 178, 255], + type='', + swap='right_middle_finger1'), + 101: + dict( + name='left_middle_finger2', + id=101, + color=[102, 178, 255], + type='', + swap='right_middle_finger2'), + 102: + dict( + name='left_middle_finger3', + id=102, + color=[102, 178, 255], + type='', + swap='right_middle_finger3'), + 103: + dict( + name='left_middle_finger4', + id=103, + color=[102, 178, 255], + type='', + swap='right_middle_finger4'), + 104: + dict( + name='left_ring_finger1', + id=104, + color=[255, 51, 51], + type='', + swap='right_ring_finger1'), + 105: + dict( + name='left_ring_finger2', + id=105, + color=[255, 51, 51], + type='', + swap='right_ring_finger2'), + 106: + dict( + name='left_ring_finger3', + id=106, + color=[255, 51, 51], + type='', + swap='right_ring_finger3'), + 107: + dict( + name='left_ring_finger4', + id=107, + color=[255, 51, 51], + type='', + swap='right_ring_finger4'), + 108: + dict( + name='left_pinky_finger1', + id=108, + color=[0, 255, 0], + type='', + swap='right_pinky_finger1'), + 109: + dict( + name='left_pinky_finger2', + id=109, + color=[0, 255, 0], + type='', + swap='right_pinky_finger2'), + 110: + dict( + name='left_pinky_finger3', + id=110, + color=[0, 255, 0], + type='', + swap='right_pinky_finger3'), + 111: + dict( + name='left_pinky_finger4', + id=111, + color=[0, 255, 0], + type='', + swap='right_pinky_finger4'), + 112: + dict( + name='right_hand_root', + id=112, + color=[255, 255, 255], + type='', + swap='left_hand_root'), + 113: + dict( + name='right_thumb1', + id=113, + color=[255, 128, 0], + type='', + swap='left_thumb1'), + 114: + dict( + name='right_thumb2', + id=114, + color=[255, 128, 0], + type='', + swap='left_thumb2'), + 115: + dict( + name='right_thumb3', + id=115, + color=[255, 128, 0], + type='', + swap='left_thumb3'), + 116: + dict( + name='right_thumb4', + id=116, + color=[255, 128, 0], + type='', + swap='left_thumb4'), + 117: + dict( + name='right_forefinger1', + id=117, + color=[255, 153, 255], + type='', + swap='left_forefinger1'), + 118: + dict( + name='right_forefinger2', + id=118, + color=[255, 153, 255], + type='', + swap='left_forefinger2'), + 119: + dict( + name='right_forefinger3', + id=119, + color=[255, 153, 255], + type='', + swap='left_forefinger3'), + 120: + dict( + name='right_forefinger4', + id=120, + color=[255, 153, 255], + type='', + swap='left_forefinger4'), + 121: + dict( + name='right_middle_finger1', + id=121, + color=[102, 178, 255], + type='', + swap='left_middle_finger1'), + 122: + dict( + name='right_middle_finger2', + id=122, + color=[102, 178, 255], + type='', + swap='left_middle_finger2'), + 123: + dict( + name='right_middle_finger3', + id=123, + color=[102, 178, 255], + type='', + swap='left_middle_finger3'), + 124: + dict( + name='right_middle_finger4', + id=124, + color=[102, 178, 255], + type='', + swap='left_middle_finger4'), + 125: + dict( + name='right_ring_finger1', + id=125, + color=[255, 51, 51], + type='', + swap='left_ring_finger1'), + 126: + dict( + name='right_ring_finger2', + id=126, + color=[255, 51, 51], + type='', + swap='left_ring_finger2'), + 127: + dict( + name='right_ring_finger3', + id=127, + color=[255, 51, 51], + type='', + swap='left_ring_finger3'), + 128: + dict( + name='right_ring_finger4', + id=128, + color=[255, 51, 51], + type='', + swap='left_ring_finger4'), + 129: + dict( + name='right_pinky_finger1', + id=129, + color=[0, 255, 0], + type='', + swap='left_pinky_finger1'), + 130: + dict( + name='right_pinky_finger2', + id=130, + color=[0, 255, 0], + type='', + swap='left_pinky_finger2'), + 131: + dict( + name='right_pinky_finger3', + id=131, + color=[0, 255, 0], + type='', + swap='left_pinky_finger3'), + 132: + dict( + name='right_pinky_finger4', + id=132, + color=[0, 255, 0], + type='', + swap='left_pinky_finger4') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]), + 19: + dict(link=('left_ankle', 'left_big_toe'), id=19, color=[0, 255, 0]), + 20: + dict(link=('left_ankle', 'left_small_toe'), id=20, color=[0, 255, 0]), + 21: + dict(link=('left_ankle', 'left_heel'), id=21, color=[0, 255, 0]), + 22: + dict( + link=('right_ankle', 'right_big_toe'), id=22, color=[255, 128, 0]), + 23: + dict( + link=('right_ankle', 'right_small_toe'), + id=23, + color=[255, 128, 0]), + 24: + dict(link=('right_ankle', 'right_heel'), id=24, color=[255, 128, 0]), + 25: + dict( + link=('left_hand_root', 'left_thumb1'), id=25, color=[255, 128, + 0]), + 26: + dict(link=('left_thumb1', 'left_thumb2'), id=26, color=[255, 128, 0]), + 27: + dict(link=('left_thumb2', 'left_thumb3'), id=27, color=[255, 128, 0]), + 28: + dict(link=('left_thumb3', 'left_thumb4'), id=28, color=[255, 128, 0]), + 29: + dict( + link=('left_hand_root', 'left_forefinger1'), + id=29, + color=[255, 153, 255]), + 30: + dict( + link=('left_forefinger1', 'left_forefinger2'), + id=30, + color=[255, 153, 255]), + 31: + dict( + link=('left_forefinger2', 'left_forefinger3'), + id=31, + color=[255, 153, 255]), + 32: + dict( + link=('left_forefinger3', 'left_forefinger4'), + id=32, + color=[255, 153, 255]), + 33: + dict( + link=('left_hand_root', 'left_middle_finger1'), + id=33, + color=[102, 178, 255]), + 34: + dict( + link=('left_middle_finger1', 'left_middle_finger2'), + id=34, + color=[102, 178, 255]), + 35: + dict( + link=('left_middle_finger2', 'left_middle_finger3'), + id=35, + color=[102, 178, 255]), + 36: + dict( + link=('left_middle_finger3', 'left_middle_finger4'), + id=36, + color=[102, 178, 255]), + 37: + dict( + link=('left_hand_root', 'left_ring_finger1'), + id=37, + color=[255, 51, 51]), + 38: + dict( + link=('left_ring_finger1', 'left_ring_finger2'), + id=38, + color=[255, 51, 51]), + 39: + dict( + link=('left_ring_finger2', 'left_ring_finger3'), + id=39, + color=[255, 51, 51]), + 40: + dict( + link=('left_ring_finger3', 'left_ring_finger4'), + id=40, + color=[255, 51, 51]), + 41: + dict( + link=('left_hand_root', 'left_pinky_finger1'), + id=41, + color=[0, 255, 0]), + 42: + dict( + link=('left_pinky_finger1', 'left_pinky_finger2'), + id=42, + color=[0, 255, 0]), + 43: + dict( + link=('left_pinky_finger2', 'left_pinky_finger3'), + id=43, + color=[0, 255, 0]), + 44: + dict( + link=('left_pinky_finger3', 'left_pinky_finger4'), + id=44, + color=[0, 255, 0]), + 45: + dict( + link=('right_hand_root', 'right_thumb1'), + id=45, + color=[255, 128, 0]), + 46: + dict( + link=('right_thumb1', 'right_thumb2'), id=46, color=[255, 128, 0]), + 47: + dict( + link=('right_thumb2', 'right_thumb3'), id=47, color=[255, 128, 0]), + 48: + dict( + link=('right_thumb3', 'right_thumb4'), id=48, color=[255, 128, 0]), + 49: + dict( + link=('right_hand_root', 'right_forefinger1'), + id=49, + color=[255, 153, 255]), + 50: + dict( + link=('right_forefinger1', 'right_forefinger2'), + id=50, + color=[255, 153, 255]), + 51: + dict( + link=('right_forefinger2', 'right_forefinger3'), + id=51, + color=[255, 153, 255]), + 52: + dict( + link=('right_forefinger3', 'right_forefinger4'), + id=52, + color=[255, 153, 255]), + 53: + dict( + link=('right_hand_root', 'right_middle_finger1'), + id=53, + color=[102, 178, 255]), + 54: + dict( + link=('right_middle_finger1', 'right_middle_finger2'), + id=54, + color=[102, 178, 255]), + 55: + dict( + link=('right_middle_finger2', 'right_middle_finger3'), + id=55, + color=[102, 178, 255]), + 56: + dict( + link=('right_middle_finger3', 'right_middle_finger4'), + id=56, + color=[102, 178, 255]), + 57: + dict( + link=('right_hand_root', 'right_ring_finger1'), + id=57, + color=[255, 51, 51]), + 58: + dict( + link=('right_ring_finger1', 'right_ring_finger2'), + id=58, + color=[255, 51, 51]), + 59: + dict( + link=('right_ring_finger2', 'right_ring_finger3'), + id=59, + color=[255, 51, 51]), + 60: + dict( + link=('right_ring_finger3', 'right_ring_finger4'), + id=60, + color=[255, 51, 51]), + 61: + dict( + link=('right_hand_root', 'right_pinky_finger1'), + id=61, + color=[0, 255, 0]), + 62: + dict( + link=('right_pinky_finger1', 'right_pinky_finger2'), + id=62, + color=[0, 255, 0]), + 63: + dict( + link=('right_pinky_finger2', 'right_pinky_finger3'), + id=63, + color=[0, 255, 0]), + 64: + dict( + link=('right_pinky_finger3', 'right_pinky_finger4'), + id=64, + color=[0, 255, 0]) + }, + joint_weights=[1.] * 133, + # 'https://github.com/jin-s13/COCO-WholeBody/blob/master/' + # 'evaluation/myeval_wholebody.py#L175' + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089, 0.068, 0.066, 0.066, + 0.092, 0.094, 0.094, 0.042, 0.043, 0.044, 0.043, 0.040, 0.035, 0.031, + 0.025, 0.020, 0.023, 0.029, 0.032, 0.037, 0.038, 0.043, 0.041, 0.045, + 0.013, 0.012, 0.011, 0.011, 0.012, 0.012, 0.011, 0.011, 0.013, 0.015, + 0.009, 0.007, 0.007, 0.007, 0.012, 0.009, 0.008, 0.016, 0.010, 0.017, + 0.011, 0.009, 0.011, 0.009, 0.007, 0.013, 0.008, 0.011, 0.012, 0.010, + 0.034, 0.008, 0.008, 0.009, 0.008, 0.008, 0.007, 0.010, 0.008, 0.009, + 0.009, 0.009, 0.007, 0.007, 0.008, 0.011, 0.008, 0.008, 0.008, 0.01, + 0.008, 0.029, 0.022, 0.035, 0.037, 0.047, 0.026, 0.025, 0.024, 0.035, + 0.018, 0.024, 0.022, 0.026, 0.017, 0.021, 0.021, 0.032, 0.02, 0.019, + 0.022, 0.031, 0.029, 0.022, 0.035, 0.037, 0.047, 0.026, 0.025, 0.024, + 0.035, 0.018, 0.024, 0.022, 0.026, 0.017, 0.021, 0.021, 0.032, 0.02, + 0.019, 0.022, 0.031 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/cofw.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/cofw.py new file mode 100644 index 0000000000000000000000000000000000000000..976f067d5d401f308bf88d80c85b0f60cf25799e --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/cofw.py @@ -0,0 +1,134 @@ +dataset_info = dict( + dataset_name='cofw', + paper_info=dict( + author='Burgos-Artizzu, Xavier P and Perona, ' + r'Pietro and Doll{\'a}r, Piotr', + title='Robust face landmark estimation under occlusion', + container='Proceedings of the IEEE international ' + 'conference on computer vision', + year='2013', + homepage='http://www.vision.caltech.edu/xpburgos/ICCV13/', + ), + keypoint_info={ + 0: + dict(name='kpt-0', id=0, color=[255, 255, 255], type='', swap='kpt-1'), + 1: + dict(name='kpt-1', id=1, color=[255, 255, 255], type='', swap='kpt-0'), + 2: + dict(name='kpt-2', id=2, color=[255, 255, 255], type='', swap='kpt-3'), + 3: + dict(name='kpt-3', id=3, color=[255, 255, 255], type='', swap='kpt-2'), + 4: + dict(name='kpt-4', id=4, color=[255, 255, 255], type='', swap='kpt-6'), + 5: + dict(name='kpt-5', id=5, color=[255, 255, 255], type='', swap='kpt-7'), + 6: + dict(name='kpt-6', id=6, color=[255, 255, 255], type='', swap='kpt-4'), + 7: + dict(name='kpt-7', id=7, color=[255, 255, 255], type='', swap='kpt-5'), + 8: + dict(name='kpt-8', id=8, color=[255, 255, 255], type='', swap='kpt-9'), + 9: + dict(name='kpt-9', id=9, color=[255, 255, 255], type='', swap='kpt-8'), + 10: + dict( + name='kpt-10', + id=10, + color=[255, 255, 255], + type='', + swap='kpt-11'), + 11: + dict( + name='kpt-11', + id=11, + color=[255, 255, 255], + type='', + swap='kpt-10'), + 12: + dict( + name='kpt-12', + id=12, + color=[255, 255, 255], + type='', + swap='kpt-14'), + 13: + dict( + name='kpt-13', + id=13, + color=[255, 255, 255], + type='', + swap='kpt-15'), + 14: + dict( + name='kpt-14', + id=14, + color=[255, 255, 255], + type='', + swap='kpt-12'), + 15: + dict( + name='kpt-15', + id=15, + color=[255, 255, 255], + type='', + swap='kpt-13'), + 16: + dict( + name='kpt-16', + id=16, + color=[255, 255, 255], + type='', + swap='kpt-17'), + 17: + dict( + name='kpt-17', + id=17, + color=[255, 255, 255], + type='', + swap='kpt-16'), + 18: + dict( + name='kpt-18', + id=18, + color=[255, 255, 255], + type='', + swap='kpt-19'), + 19: + dict( + name='kpt-19', + id=19, + color=[255, 255, 255], + type='', + swap='kpt-18'), + 20: + dict(name='kpt-20', id=20, color=[255, 255, 255], type='', swap=''), + 21: + dict(name='kpt-21', id=21, color=[255, 255, 255], type='', swap=''), + 22: + dict( + name='kpt-22', + id=22, + color=[255, 255, 255], + type='', + swap='kpt-23'), + 23: + dict( + name='kpt-23', + id=23, + color=[255, 255, 255], + type='', + swap='kpt-22'), + 24: + dict(name='kpt-24', id=24, color=[255, 255, 255], type='', swap=''), + 25: + dict(name='kpt-25', id=25, color=[255, 255, 255], type='', swap=''), + 26: + dict(name='kpt-26', id=26, color=[255, 255, 255], type='', swap=''), + 27: + dict(name='kpt-27', id=27, color=[255, 255, 255], type='', swap=''), + 28: + dict(name='kpt-28', id=28, color=[255, 255, 255], type='', swap='') + }, + skeleton_info={}, + joint_weights=[1.] * 29, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/crowdpose.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/crowdpose.py new file mode 100644 index 0000000000000000000000000000000000000000..358d36f25af9ffead1b18e347227151551e20b70 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/crowdpose.py @@ -0,0 +1,147 @@ +dataset_info = dict( + dataset_name='crowdpose', + paper_info=dict( + author='Li, Jiefeng and Wang, Can and Zhu, Hao and ' + 'Mao, Yihuan and Fang, Hao-Shu and Lu, Cewu', + title='CrowdPose: Efficient Crowded Scenes Pose Estimation ' + 'and A New Benchmark', + container='Proceedings of IEEE Conference on Computer ' + 'Vision and Pattern Recognition (CVPR)', + year='2019', + homepage='https://github.com/Jeff-sjtu/CrowdPose', + ), + keypoint_info={ + 0: + dict( + name='left_shoulder', + id=0, + color=[51, 153, 255], + type='upper', + swap='right_shoulder'), + 1: + dict( + name='right_shoulder', + id=1, + color=[51, 153, 255], + type='upper', + swap='left_shoulder'), + 2: + dict( + name='left_elbow', + id=2, + color=[51, 153, 255], + type='upper', + swap='right_elbow'), + 3: + dict( + name='right_elbow', + id=3, + color=[51, 153, 255], + type='upper', + swap='left_elbow'), + 4: + dict( + name='left_wrist', + id=4, + color=[51, 153, 255], + type='upper', + swap='right_wrist'), + 5: + dict( + name='right_wrist', + id=5, + color=[0, 255, 0], + type='upper', + swap='left_wrist'), + 6: + dict( + name='left_hip', + id=6, + color=[255, 128, 0], + type='lower', + swap='right_hip'), + 7: + dict( + name='right_hip', + id=7, + color=[0, 255, 0], + type='lower', + swap='left_hip'), + 8: + dict( + name='left_knee', + id=8, + color=[255, 128, 0], + type='lower', + swap='right_knee'), + 9: + dict( + name='right_knee', + id=9, + color=[0, 255, 0], + type='lower', + swap='left_knee'), + 10: + dict( + name='left_ankle', + id=10, + color=[255, 128, 0], + type='lower', + swap='right_ankle'), + 11: + dict( + name='right_ankle', + id=11, + color=[0, 255, 0], + type='lower', + swap='left_ankle'), + 12: + dict( + name='top_head', id=12, color=[255, 128, 0], type='upper', + swap=''), + 13: + dict(name='neck', id=13, color=[0, 255, 0], type='upper', swap='') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('top_head', 'neck'), id=12, color=[51, 153, 255]), + 13: + dict(link=('right_shoulder', 'neck'), id=13, color=[51, 153, 255]), + 14: + dict(link=('left_shoulder', 'neck'), id=14, color=[51, 153, 255]) + }, + joint_weights=[ + 0.2, 0.2, 0.2, 1.3, 1.5, 0.2, 1.3, 1.5, 0.2, 0.2, 0.5, 0.2, 0.2, 0.5 + ], + sigmas=[ + 0.079, 0.079, 0.072, 0.072, 0.062, 0.062, 0.107, 0.107, 0.087, 0.087, + 0.089, 0.089, 0.079, 0.079 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_full.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_full.py new file mode 100644 index 0000000000000000000000000000000000000000..97691273af17f780fb53964baa6a695df76a4ebd --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_full.py @@ -0,0 +1,74 @@ +dataset_info = dict( + dataset_name='deepfashion_full', + paper_info=dict( + author='Liu, Ziwei and Luo, Ping and Qiu, Shi ' + 'and Wang, Xiaogang and Tang, Xiaoou', + title='DeepFashion: Powering Robust Clothes Recognition ' + 'and Retrieval with Rich Annotations', + container='Proceedings of IEEE Conference on Computer ' + 'Vision and Pattern Recognition (CVPR)', + year='2016', + homepage='http://mmlab.ie.cuhk.edu.hk/projects/' + 'DeepFashion/LandmarkDetection.html', + ), + keypoint_info={ + 0: + dict( + name='left collar', + id=0, + color=[255, 255, 255], + type='', + swap='right collar'), + 1: + dict( + name='right collar', + id=1, + color=[255, 255, 255], + type='', + swap='left collar'), + 2: + dict( + name='left sleeve', + id=2, + color=[255, 255, 255], + type='', + swap='right sleeve'), + 3: + dict( + name='right sleeve', + id=3, + color=[255, 255, 255], + type='', + swap='left sleeve'), + 4: + dict( + name='left waistline', + id=0, + color=[255, 255, 255], + type='', + swap='right waistline'), + 5: + dict( + name='right waistline', + id=1, + color=[255, 255, 255], + type='', + swap='left waistline'), + 6: + dict( + name='left hem', + id=2, + color=[255, 255, 255], + type='', + swap='right hem'), + 7: + dict( + name='right hem', + id=3, + color=[255, 255, 255], + type='', + swap='left hem'), + }, + skeleton_info={}, + joint_weights=[1.] * 8, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_lower.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_lower.py new file mode 100644 index 0000000000000000000000000000000000000000..65995e1e80d490c7cddad0f8ab18260d042ca9f0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_lower.py @@ -0,0 +1,46 @@ +dataset_info = dict( + dataset_name='deepfashion_lower', + paper_info=dict( + author='Liu, Ziwei and Luo, Ping and Qiu, Shi ' + 'and Wang, Xiaogang and Tang, Xiaoou', + title='DeepFashion: Powering Robust Clothes Recognition ' + 'and Retrieval with Rich Annotations', + container='Proceedings of IEEE Conference on Computer ' + 'Vision and Pattern Recognition (CVPR)', + year='2016', + homepage='http://mmlab.ie.cuhk.edu.hk/projects/' + 'DeepFashion/LandmarkDetection.html', + ), + keypoint_info={ + 0: + dict( + name='left waistline', + id=0, + color=[255, 255, 255], + type='', + swap='right waistline'), + 1: + dict( + name='right waistline', + id=1, + color=[255, 255, 255], + type='', + swap='left waistline'), + 2: + dict( + name='left hem', + id=2, + color=[255, 255, 255], + type='', + swap='right hem'), + 3: + dict( + name='right hem', + id=3, + color=[255, 255, 255], + type='', + swap='left hem'), + }, + skeleton_info={}, + joint_weights=[1.] * 4, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_upper.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_upper.py new file mode 100644 index 0000000000000000000000000000000000000000..4f34e2aeb716a64831d62c20327517b6093c67f7 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/deepfashion_upper.py @@ -0,0 +1,60 @@ +dataset_info = dict( + dataset_name='deepfashion_upper', + paper_info=dict( + author='Liu, Ziwei and Luo, Ping and Qiu, Shi ' + 'and Wang, Xiaogang and Tang, Xiaoou', + title='DeepFashion: Powering Robust Clothes Recognition ' + 'and Retrieval with Rich Annotations', + container='Proceedings of IEEE Conference on Computer ' + 'Vision and Pattern Recognition (CVPR)', + year='2016', + homepage='http://mmlab.ie.cuhk.edu.hk/projects/' + 'DeepFashion/LandmarkDetection.html', + ), + keypoint_info={ + 0: + dict( + name='left collar', + id=0, + color=[255, 255, 255], + type='', + swap='right collar'), + 1: + dict( + name='right collar', + id=1, + color=[255, 255, 255], + type='', + swap='left collar'), + 2: + dict( + name='left sleeve', + id=2, + color=[255, 255, 255], + type='', + swap='right sleeve'), + 3: + dict( + name='right sleeve', + id=3, + color=[255, 255, 255], + type='', + swap='left sleeve'), + 4: + dict( + name='left hem', + id=4, + color=[255, 255, 255], + type='', + swap='right hem'), + 5: + dict( + name='right hem', + id=5, + color=[255, 255, 255], + type='', + swap='left hem'), + }, + skeleton_info={}, + joint_weights=[1.] * 6, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/fly.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/fly.py new file mode 100644 index 0000000000000000000000000000000000000000..46386b630a519106f825cc4b2556e10563f03577 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/fly.py @@ -0,0 +1,237 @@ +dataset_info = dict( + dataset_name='fly', + paper_info=dict( + author='Pereira, Talmo D and Aldarondo, Diego E and ' + 'Willmore, Lindsay and Kislin, Mikhail and ' + 'Wang, Samuel S-H and Murthy, Mala and Shaevitz, Joshua W', + title='Fast animal pose estimation using deep neural networks', + container='Nature methods', + year='2019', + homepage='https://github.com/jgraving/DeepPoseKit-Data', + ), + keypoint_info={ + 0: + dict(name='head', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='eyeL', id=1, color=[255, 255, 255], type='', swap='eyeR'), + 2: + dict(name='eyeR', id=2, color=[255, 255, 255], type='', swap='eyeL'), + 3: + dict(name='neck', id=3, color=[255, 255, 255], type='', swap=''), + 4: + dict(name='thorax', id=4, color=[255, 255, 255], type='', swap=''), + 5: + dict(name='abdomen', id=5, color=[255, 255, 255], type='', swap=''), + 6: + dict( + name='forelegR1', + id=6, + color=[255, 255, 255], + type='', + swap='forelegL1'), + 7: + dict( + name='forelegR2', + id=7, + color=[255, 255, 255], + type='', + swap='forelegL2'), + 8: + dict( + name='forelegR3', + id=8, + color=[255, 255, 255], + type='', + swap='forelegL3'), + 9: + dict( + name='forelegR4', + id=9, + color=[255, 255, 255], + type='', + swap='forelegL4'), + 10: + dict( + name='midlegR1', + id=10, + color=[255, 255, 255], + type='', + swap='midlegL1'), + 11: + dict( + name='midlegR2', + id=11, + color=[255, 255, 255], + type='', + swap='midlegL2'), + 12: + dict( + name='midlegR3', + id=12, + color=[255, 255, 255], + type='', + swap='midlegL3'), + 13: + dict( + name='midlegR4', + id=13, + color=[255, 255, 255], + type='', + swap='midlegL4'), + 14: + dict( + name='hindlegR1', + id=14, + color=[255, 255, 255], + type='', + swap='hindlegL1'), + 15: + dict( + name='hindlegR2', + id=15, + color=[255, 255, 255], + type='', + swap='hindlegL2'), + 16: + dict( + name='hindlegR3', + id=16, + color=[255, 255, 255], + type='', + swap='hindlegL3'), + 17: + dict( + name='hindlegR4', + id=17, + color=[255, 255, 255], + type='', + swap='hindlegL4'), + 18: + dict( + name='forelegL1', + id=18, + color=[255, 255, 255], + type='', + swap='forelegR1'), + 19: + dict( + name='forelegL2', + id=19, + color=[255, 255, 255], + type='', + swap='forelegR2'), + 20: + dict( + name='forelegL3', + id=20, + color=[255, 255, 255], + type='', + swap='forelegR3'), + 21: + dict( + name='forelegL4', + id=21, + color=[255, 255, 255], + type='', + swap='forelegR4'), + 22: + dict( + name='midlegL1', + id=22, + color=[255, 255, 255], + type='', + swap='midlegR1'), + 23: + dict( + name='midlegL2', + id=23, + color=[255, 255, 255], + type='', + swap='midlegR2'), + 24: + dict( + name='midlegL3', + id=24, + color=[255, 255, 255], + type='', + swap='midlegR3'), + 25: + dict( + name='midlegL4', + id=25, + color=[255, 255, 255], + type='', + swap='midlegR4'), + 26: + dict( + name='hindlegL1', + id=26, + color=[255, 255, 255], + type='', + swap='hindlegR1'), + 27: + dict( + name='hindlegL2', + id=27, + color=[255, 255, 255], + type='', + swap='hindlegR2'), + 28: + dict( + name='hindlegL3', + id=28, + color=[255, 255, 255], + type='', + swap='hindlegR3'), + 29: + dict( + name='hindlegL4', + id=29, + color=[255, 255, 255], + type='', + swap='hindlegR4'), + 30: + dict( + name='wingL', id=30, color=[255, 255, 255], type='', swap='wingR'), + 31: + dict( + name='wingR', id=31, color=[255, 255, 255], type='', swap='wingL'), + }, + skeleton_info={ + 0: dict(link=('eyeL', 'head'), id=0, color=[255, 255, 255]), + 1: dict(link=('eyeR', 'head'), id=1, color=[255, 255, 255]), + 2: dict(link=('neck', 'head'), id=2, color=[255, 255, 255]), + 3: dict(link=('thorax', 'neck'), id=3, color=[255, 255, 255]), + 4: dict(link=('abdomen', 'thorax'), id=4, color=[255, 255, 255]), + 5: dict(link=('forelegR2', 'forelegR1'), id=5, color=[255, 255, 255]), + 6: dict(link=('forelegR3', 'forelegR2'), id=6, color=[255, 255, 255]), + 7: dict(link=('forelegR4', 'forelegR3'), id=7, color=[255, 255, 255]), + 8: dict(link=('midlegR2', 'midlegR1'), id=8, color=[255, 255, 255]), + 9: dict(link=('midlegR3', 'midlegR2'), id=9, color=[255, 255, 255]), + 10: dict(link=('midlegR4', 'midlegR3'), id=10, color=[255, 255, 255]), + 11: + dict(link=('hindlegR2', 'hindlegR1'), id=11, color=[255, 255, 255]), + 12: + dict(link=('hindlegR3', 'hindlegR2'), id=12, color=[255, 255, 255]), + 13: + dict(link=('hindlegR4', 'hindlegR3'), id=13, color=[255, 255, 255]), + 14: + dict(link=('forelegL2', 'forelegL1'), id=14, color=[255, 255, 255]), + 15: + dict(link=('forelegL3', 'forelegL2'), id=15, color=[255, 255, 255]), + 16: + dict(link=('forelegL4', 'forelegL3'), id=16, color=[255, 255, 255]), + 17: dict(link=('midlegL2', 'midlegL1'), id=17, color=[255, 255, 255]), + 18: dict(link=('midlegL3', 'midlegL2'), id=18, color=[255, 255, 255]), + 19: dict(link=('midlegL4', 'midlegL3'), id=19, color=[255, 255, 255]), + 20: + dict(link=('hindlegL2', 'hindlegL1'), id=20, color=[255, 255, 255]), + 21: + dict(link=('hindlegL3', 'hindlegL2'), id=21, color=[255, 255, 255]), + 22: + dict(link=('hindlegL4', 'hindlegL3'), id=22, color=[255, 255, 255]), + 23: dict(link=('wingL', 'neck'), id=23, color=[255, 255, 255]), + 24: dict(link=('wingR', 'neck'), id=24, color=[255, 255, 255]) + }, + joint_weights=[1.] * 32, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/freihand2d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/freihand2d.py new file mode 100644 index 0000000000000000000000000000000000000000..ae047426320b314865e250e5d2bbb3b6eadd69de --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/freihand2d.py @@ -0,0 +1,144 @@ +dataset_info = dict( + dataset_name='freihand', + paper_info=dict( + author='Zimmermann, Christian and Ceylan, Duygu and ' + 'Yang, Jimei and Russell, Bryan and ' + 'Argus, Max and Brox, Thomas', + title='Freihand: A dataset for markerless capture of hand pose ' + 'and shape from single rgb images', + container='Proceedings of the IEEE International ' + 'Conference on Computer Vision', + year='2019', + homepage='https://lmb.informatik.uni-freiburg.de/projects/freihand/', + ), + keypoint_info={ + 0: + dict(name='wrist', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='thumb1', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb3', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict(name='thumb4', id=4, color=[255, 128, 0], type='', swap=''), + 5: + dict( + name='forefinger1', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger3', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='forefinger4', id=8, color=[255, 153, 255], type='', swap=''), + 9: + dict( + name='middle_finger1', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger3', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='middle_finger4', + id=12, + color=[102, 178, 255], + type='', + swap=''), + 13: + dict( + name='ring_finger1', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger3', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict( + name='ring_finger4', id=16, color=[255, 51, 51], type='', swap=''), + 17: + dict(name='pinky_finger1', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger3', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='pinky_finger4', id=20, color=[0, 255, 0], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/h36m.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/h36m.py new file mode 100644 index 0000000000000000000000000000000000000000..f6be31f4044775b2ff40ac32befd7cae8b30594f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/h36m.py @@ -0,0 +1,152 @@ +dataset_info = dict( + dataset_name='h36m', + paper_info=dict( + author='Ionescu, Catalin and Papava, Dragos and ' + 'Olaru, Vlad and Sminchisescu, Cristian', + title='Human3.6M: Large Scale Datasets and Predictive ' + 'Methods for 3D Human Sensing in Natural Environments', + container='IEEE Transactions on Pattern Analysis and ' + 'Machine Intelligence', + year='2014', + homepage='http://vision.imar.ro/human3.6m/description.php', + ), + keypoint_info={ + 0: + dict(name='root', id=0, color=[51, 153, 255], type='lower', swap=''), + 1: + dict( + name='right_hip', + id=1, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 2: + dict( + name='right_knee', + id=2, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 3: + dict( + name='right_foot', + id=3, + color=[255, 128, 0], + type='lower', + swap='left_foot'), + 4: + dict( + name='left_hip', + id=4, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 5: + dict( + name='left_knee', + id=5, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 6: + dict( + name='left_foot', + id=6, + color=[0, 255, 0], + type='lower', + swap='right_foot'), + 7: + dict(name='spine', id=7, color=[51, 153, 255], type='upper', swap=''), + 8: + dict(name='thorax', id=8, color=[51, 153, 255], type='upper', swap=''), + 9: + dict( + name='neck_base', + id=9, + color=[51, 153, 255], + type='upper', + swap=''), + 10: + dict(name='head', id=10, color=[51, 153, 255], type='upper', swap=''), + 11: + dict( + name='left_shoulder', + id=11, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 12: + dict( + name='left_elbow', + id=12, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 13: + dict( + name='left_wrist', + id=13, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 14: + dict( + name='right_shoulder', + id=14, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 15: + dict( + name='right_elbow', + id=15, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 16: + dict( + name='right_wrist', + id=16, + color=[255, 128, 0], + type='upper', + swap='left_wrist') + }, + skeleton_info={ + 0: + dict(link=('root', 'left_hip'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_hip', 'left_knee'), id=1, color=[0, 255, 0]), + 2: + dict(link=('left_knee', 'left_foot'), id=2, color=[0, 255, 0]), + 3: + dict(link=('root', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('right_hip', 'right_knee'), id=4, color=[255, 128, 0]), + 5: + dict(link=('right_knee', 'right_foot'), id=5, color=[255, 128, 0]), + 6: + dict(link=('root', 'spine'), id=6, color=[51, 153, 255]), + 7: + dict(link=('spine', 'thorax'), id=7, color=[51, 153, 255]), + 8: + dict(link=('thorax', 'neck_base'), id=8, color=[51, 153, 255]), + 9: + dict(link=('neck_base', 'head'), id=9, color=[51, 153, 255]), + 10: + dict(link=('thorax', 'left_shoulder'), id=10, color=[0, 255, 0]), + 11: + dict(link=('left_shoulder', 'left_elbow'), id=11, color=[0, 255, 0]), + 12: + dict(link=('left_elbow', 'left_wrist'), id=12, color=[0, 255, 0]), + 13: + dict(link=('thorax', 'right_shoulder'), id=13, color=[255, 128, 0]), + 14: + dict( + link=('right_shoulder', 'right_elbow'), id=14, color=[255, 128, + 0]), + 15: + dict(link=('right_elbow', 'right_wrist'), id=15, color=[255, 128, 0]) + }, + joint_weights=[1.] * 17, + sigmas=[], + stats_info=dict(bbox_center=(528., 427.), bbox_scale=400.)) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/halpe.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/halpe.py new file mode 100644 index 0000000000000000000000000000000000000000..cccf9f4c60b332dd5f662d1d18520e4807791731 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/halpe.py @@ -0,0 +1,1157 @@ +dataset_info = dict( + dataset_name='halpe', + paper_info=dict( + author='Li, Yong-Lu and Xu, Liang and Liu, Xinpeng and Huang, Xijie' + ' and Xu, Yue and Wang, Shiyi and Fang, Hao-Shu' + ' and Ma, Ze and Chen, Mingyang and Lu, Cewu', + title='PaStaNet: Toward Human Activity Knowledge Engine', + container='CVPR', + year='2020', + homepage='https://github.com/Fang-Haoshu/Halpe-FullBody/', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 17: + dict(name='head', id=17, color=[255, 128, 0], type='upper', swap=''), + 18: + dict(name='neck', id=18, color=[255, 128, 0], type='upper', swap=''), + 19: + dict(name='hip', id=19, color=[255, 128, 0], type='lower', swap=''), + 20: + dict( + name='left_big_toe', + id=20, + color=[255, 128, 0], + type='lower', + swap='right_big_toe'), + 21: + dict( + name='right_big_toe', + id=21, + color=[255, 128, 0], + type='lower', + swap='left_big_toe'), + 22: + dict( + name='left_small_toe', + id=22, + color=[255, 128, 0], + type='lower', + swap='right_small_toe'), + 23: + dict( + name='right_small_toe', + id=23, + color=[255, 128, 0], + type='lower', + swap='left_small_toe'), + 24: + dict( + name='left_heel', + id=24, + color=[255, 128, 0], + type='lower', + swap='right_heel'), + 25: + dict( + name='right_heel', + id=25, + color=[255, 128, 0], + type='lower', + swap='left_heel'), + 26: + dict( + name='face-0', + id=26, + color=[255, 255, 255], + type='', + swap='face-16'), + 27: + dict( + name='face-1', + id=27, + color=[255, 255, 255], + type='', + swap='face-15'), + 28: + dict( + name='face-2', + id=28, + color=[255, 255, 255], + type='', + swap='face-14'), + 29: + dict( + name='face-3', + id=29, + color=[255, 255, 255], + type='', + swap='face-13'), + 30: + dict( + name='face-4', + id=30, + color=[255, 255, 255], + type='', + swap='face-12'), + 31: + dict( + name='face-5', + id=31, + color=[255, 255, 255], + type='', + swap='face-11'), + 32: + dict( + name='face-6', + id=32, + color=[255, 255, 255], + type='', + swap='face-10'), + 33: + dict( + name='face-7', + id=33, + color=[255, 255, 255], + type='', + swap='face-9'), + 34: + dict(name='face-8', id=34, color=[255, 255, 255], type='', swap=''), + 35: + dict( + name='face-9', + id=35, + color=[255, 255, 255], + type='', + swap='face-7'), + 36: + dict( + name='face-10', + id=36, + color=[255, 255, 255], + type='', + swap='face-6'), + 37: + dict( + name='face-11', + id=37, + color=[255, 255, 255], + type='', + swap='face-5'), + 38: + dict( + name='face-12', + id=38, + color=[255, 255, 255], + type='', + swap='face-4'), + 39: + dict( + name='face-13', + id=39, + color=[255, 255, 255], + type='', + swap='face-3'), + 40: + dict( + name='face-14', + id=40, + color=[255, 255, 255], + type='', + swap='face-2'), + 41: + dict( + name='face-15', + id=41, + color=[255, 255, 255], + type='', + swap='face-1'), + 42: + dict( + name='face-16', + id=42, + color=[255, 255, 255], + type='', + swap='face-0'), + 43: + dict( + name='face-17', + id=43, + color=[255, 255, 255], + type='', + swap='face-26'), + 44: + dict( + name='face-18', + id=44, + color=[255, 255, 255], + type='', + swap='face-25'), + 45: + dict( + name='face-19', + id=45, + color=[255, 255, 255], + type='', + swap='face-24'), + 46: + dict( + name='face-20', + id=46, + color=[255, 255, 255], + type='', + swap='face-23'), + 47: + dict( + name='face-21', + id=47, + color=[255, 255, 255], + type='', + swap='face-22'), + 48: + dict( + name='face-22', + id=48, + color=[255, 255, 255], + type='', + swap='face-21'), + 49: + dict( + name='face-23', + id=49, + color=[255, 255, 255], + type='', + swap='face-20'), + 50: + dict( + name='face-24', + id=50, + color=[255, 255, 255], + type='', + swap='face-19'), + 51: + dict( + name='face-25', + id=51, + color=[255, 255, 255], + type='', + swap='face-18'), + 52: + dict( + name='face-26', + id=52, + color=[255, 255, 255], + type='', + swap='face-17'), + 53: + dict(name='face-27', id=53, color=[255, 255, 255], type='', swap=''), + 54: + dict(name='face-28', id=54, color=[255, 255, 255], type='', swap=''), + 55: + dict(name='face-29', id=55, color=[255, 255, 255], type='', swap=''), + 56: + dict(name='face-30', id=56, color=[255, 255, 255], type='', swap=''), + 57: + dict( + name='face-31', + id=57, + color=[255, 255, 255], + type='', + swap='face-35'), + 58: + dict( + name='face-32', + id=58, + color=[255, 255, 255], + type='', + swap='face-34'), + 59: + dict(name='face-33', id=59, color=[255, 255, 255], type='', swap=''), + 60: + dict( + name='face-34', + id=60, + color=[255, 255, 255], + type='', + swap='face-32'), + 61: + dict( + name='face-35', + id=61, + color=[255, 255, 255], + type='', + swap='face-31'), + 62: + dict( + name='face-36', + id=62, + color=[255, 255, 255], + type='', + swap='face-45'), + 63: + dict( + name='face-37', + id=63, + color=[255, 255, 255], + type='', + swap='face-44'), + 64: + dict( + name='face-38', + id=64, + color=[255, 255, 255], + type='', + swap='face-43'), + 65: + dict( + name='face-39', + id=65, + color=[255, 255, 255], + type='', + swap='face-42'), + 66: + dict( + name='face-40', + id=66, + color=[255, 255, 255], + type='', + swap='face-47'), + 67: + dict( + name='face-41', + id=67, + color=[255, 255, 255], + type='', + swap='face-46'), + 68: + dict( + name='face-42', + id=68, + color=[255, 255, 255], + type='', + swap='face-39'), + 69: + dict( + name='face-43', + id=69, + color=[255, 255, 255], + type='', + swap='face-38'), + 70: + dict( + name='face-44', + id=70, + color=[255, 255, 255], + type='', + swap='face-37'), + 71: + dict( + name='face-45', + id=71, + color=[255, 255, 255], + type='', + swap='face-36'), + 72: + dict( + name='face-46', + id=72, + color=[255, 255, 255], + type='', + swap='face-41'), + 73: + dict( + name='face-47', + id=73, + color=[255, 255, 255], + type='', + swap='face-40'), + 74: + dict( + name='face-48', + id=74, + color=[255, 255, 255], + type='', + swap='face-54'), + 75: + dict( + name='face-49', + id=75, + color=[255, 255, 255], + type='', + swap='face-53'), + 76: + dict( + name='face-50', + id=76, + color=[255, 255, 255], + type='', + swap='face-52'), + 77: + dict(name='face-51', id=77, color=[255, 255, 255], type='', swap=''), + 78: + dict( + name='face-52', + id=78, + color=[255, 255, 255], + type='', + swap='face-50'), + 79: + dict( + name='face-53', + id=79, + color=[255, 255, 255], + type='', + swap='face-49'), + 80: + dict( + name='face-54', + id=80, + color=[255, 255, 255], + type='', + swap='face-48'), + 81: + dict( + name='face-55', + id=81, + color=[255, 255, 255], + type='', + swap='face-59'), + 82: + dict( + name='face-56', + id=82, + color=[255, 255, 255], + type='', + swap='face-58'), + 83: + dict(name='face-57', id=83, color=[255, 255, 255], type='', swap=''), + 84: + dict( + name='face-58', + id=84, + color=[255, 255, 255], + type='', + swap='face-56'), + 85: + dict( + name='face-59', + id=85, + color=[255, 255, 255], + type='', + swap='face-55'), + 86: + dict( + name='face-60', + id=86, + color=[255, 255, 255], + type='', + swap='face-64'), + 87: + dict( + name='face-61', + id=87, + color=[255, 255, 255], + type='', + swap='face-63'), + 88: + dict(name='face-62', id=88, color=[255, 255, 255], type='', swap=''), + 89: + dict( + name='face-63', + id=89, + color=[255, 255, 255], + type='', + swap='face-61'), + 90: + dict( + name='face-64', + id=90, + color=[255, 255, 255], + type='', + swap='face-60'), + 91: + dict( + name='face-65', + id=91, + color=[255, 255, 255], + type='', + swap='face-67'), + 92: + dict(name='face-66', id=92, color=[255, 255, 255], type='', swap=''), + 93: + dict( + name='face-67', + id=93, + color=[255, 255, 255], + type='', + swap='face-65'), + 94: + dict( + name='left_hand_root', + id=94, + color=[255, 255, 255], + type='', + swap='right_hand_root'), + 95: + dict( + name='left_thumb1', + id=95, + color=[255, 128, 0], + type='', + swap='right_thumb1'), + 96: + dict( + name='left_thumb2', + id=96, + color=[255, 128, 0], + type='', + swap='right_thumb2'), + 97: + dict( + name='left_thumb3', + id=97, + color=[255, 128, 0], + type='', + swap='right_thumb3'), + 98: + dict( + name='left_thumb4', + id=98, + color=[255, 128, 0], + type='', + swap='right_thumb4'), + 99: + dict( + name='left_forefinger1', + id=99, + color=[255, 153, 255], + type='', + swap='right_forefinger1'), + 100: + dict( + name='left_forefinger2', + id=100, + color=[255, 153, 255], + type='', + swap='right_forefinger2'), + 101: + dict( + name='left_forefinger3', + id=101, + color=[255, 153, 255], + type='', + swap='right_forefinger3'), + 102: + dict( + name='left_forefinger4', + id=102, + color=[255, 153, 255], + type='', + swap='right_forefinger4'), + 103: + dict( + name='left_middle_finger1', + id=103, + color=[102, 178, 255], + type='', + swap='right_middle_finger1'), + 104: + dict( + name='left_middle_finger2', + id=104, + color=[102, 178, 255], + type='', + swap='right_middle_finger2'), + 105: + dict( + name='left_middle_finger3', + id=105, + color=[102, 178, 255], + type='', + swap='right_middle_finger3'), + 106: + dict( + name='left_middle_finger4', + id=106, + color=[102, 178, 255], + type='', + swap='right_middle_finger4'), + 107: + dict( + name='left_ring_finger1', + id=107, + color=[255, 51, 51], + type='', + swap='right_ring_finger1'), + 108: + dict( + name='left_ring_finger2', + id=108, + color=[255, 51, 51], + type='', + swap='right_ring_finger2'), + 109: + dict( + name='left_ring_finger3', + id=109, + color=[255, 51, 51], + type='', + swap='right_ring_finger3'), + 110: + dict( + name='left_ring_finger4', + id=110, + color=[255, 51, 51], + type='', + swap='right_ring_finger4'), + 111: + dict( + name='left_pinky_finger1', + id=111, + color=[0, 255, 0], + type='', + swap='right_pinky_finger1'), + 112: + dict( + name='left_pinky_finger2', + id=112, + color=[0, 255, 0], + type='', + swap='right_pinky_finger2'), + 113: + dict( + name='left_pinky_finger3', + id=113, + color=[0, 255, 0], + type='', + swap='right_pinky_finger3'), + 114: + dict( + name='left_pinky_finger4', + id=114, + color=[0, 255, 0], + type='', + swap='right_pinky_finger4'), + 115: + dict( + name='right_hand_root', + id=115, + color=[255, 255, 255], + type='', + swap='left_hand_root'), + 116: + dict( + name='right_thumb1', + id=116, + color=[255, 128, 0], + type='', + swap='left_thumb1'), + 117: + dict( + name='right_thumb2', + id=117, + color=[255, 128, 0], + type='', + swap='left_thumb2'), + 118: + dict( + name='right_thumb3', + id=118, + color=[255, 128, 0], + type='', + swap='left_thumb3'), + 119: + dict( + name='right_thumb4', + id=119, + color=[255, 128, 0], + type='', + swap='left_thumb4'), + 120: + dict( + name='right_forefinger1', + id=120, + color=[255, 153, 255], + type='', + swap='left_forefinger1'), + 121: + dict( + name='right_forefinger2', + id=121, + color=[255, 153, 255], + type='', + swap='left_forefinger2'), + 122: + dict( + name='right_forefinger3', + id=122, + color=[255, 153, 255], + type='', + swap='left_forefinger3'), + 123: + dict( + name='right_forefinger4', + id=123, + color=[255, 153, 255], + type='', + swap='left_forefinger4'), + 124: + dict( + name='right_middle_finger1', + id=124, + color=[102, 178, 255], + type='', + swap='left_middle_finger1'), + 125: + dict( + name='right_middle_finger2', + id=125, + color=[102, 178, 255], + type='', + swap='left_middle_finger2'), + 126: + dict( + name='right_middle_finger3', + id=126, + color=[102, 178, 255], + type='', + swap='left_middle_finger3'), + 127: + dict( + name='right_middle_finger4', + id=127, + color=[102, 178, 255], + type='', + swap='left_middle_finger4'), + 128: + dict( + name='right_ring_finger1', + id=128, + color=[255, 51, 51], + type='', + swap='left_ring_finger1'), + 129: + dict( + name='right_ring_finger2', + id=129, + color=[255, 51, 51], + type='', + swap='left_ring_finger2'), + 130: + dict( + name='right_ring_finger3', + id=130, + color=[255, 51, 51], + type='', + swap='left_ring_finger3'), + 131: + dict( + name='right_ring_finger4', + id=131, + color=[255, 51, 51], + type='', + swap='left_ring_finger4'), + 132: + dict( + name='right_pinky_finger1', + id=132, + color=[0, 255, 0], + type='', + swap='left_pinky_finger1'), + 133: + dict( + name='right_pinky_finger2', + id=133, + color=[0, 255, 0], + type='', + swap='left_pinky_finger2'), + 134: + dict( + name='right_pinky_finger3', + id=134, + color=[0, 255, 0], + type='', + swap='left_pinky_finger3'), + 135: + dict( + name='right_pinky_finger4', + id=135, + color=[0, 255, 0], + type='', + swap='left_pinky_finger4') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('left_hip', 'hip'), id=2, color=[0, 255, 0]), + 3: + dict(link=('right_ankle', 'right_knee'), id=3, color=[255, 128, 0]), + 4: + dict(link=('right_knee', 'right_hip'), id=4, color=[255, 128, 0]), + 5: + dict(link=('right_hip', 'hip'), id=5, color=[255, 128, 0]), + 6: + dict(link=('head', 'neck'), id=6, color=[51, 153, 255]), + 7: + dict(link=('neck', 'hip'), id=7, color=[51, 153, 255]), + 8: + dict(link=('neck', 'left_shoulder'), id=8, color=[0, 255, 0]), + 9: + dict(link=('left_shoulder', 'left_elbow'), id=9, color=[0, 255, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('neck', 'right_shoulder'), id=11, color=[255, 128, 0]), + 12: + dict( + link=('right_shoulder', 'right_elbow'), id=12, color=[255, 128, + 0]), + 13: + dict(link=('right_elbow', 'right_wrist'), id=13, color=[255, 128, 0]), + 14: + dict(link=('left_eye', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('nose', 'left_eye'), id=15, color=[51, 153, 255]), + 16: + dict(link=('nose', 'right_eye'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_eye', 'left_ear'), id=17, color=[51, 153, 255]), + 18: + dict(link=('right_eye', 'right_ear'), id=18, color=[51, 153, 255]), + 19: + dict(link=('left_ear', 'left_shoulder'), id=19, color=[51, 153, 255]), + 20: + dict( + link=('right_ear', 'right_shoulder'), id=20, color=[51, 153, 255]), + 21: + dict(link=('left_ankle', 'left_big_toe'), id=21, color=[0, 255, 0]), + 22: + dict(link=('left_ankle', 'left_small_toe'), id=22, color=[0, 255, 0]), + 23: + dict(link=('left_ankle', 'left_heel'), id=23, color=[0, 255, 0]), + 24: + dict( + link=('right_ankle', 'right_big_toe'), id=24, color=[255, 128, 0]), + 25: + dict( + link=('right_ankle', 'right_small_toe'), + id=25, + color=[255, 128, 0]), + 26: + dict(link=('right_ankle', 'right_heel'), id=26, color=[255, 128, 0]), + 27: + dict(link=('left_wrist', 'left_thumb1'), id=27, color=[255, 128, 0]), + 28: + dict(link=('left_thumb1', 'left_thumb2'), id=28, color=[255, 128, 0]), + 29: + dict(link=('left_thumb2', 'left_thumb3'), id=29, color=[255, 128, 0]), + 30: + dict(link=('left_thumb3', 'left_thumb4'), id=30, color=[255, 128, 0]), + 31: + dict( + link=('left_wrist', 'left_forefinger1'), + id=31, + color=[255, 153, 255]), + 32: + dict( + link=('left_forefinger1', 'left_forefinger2'), + id=32, + color=[255, 153, 255]), + 33: + dict( + link=('left_forefinger2', 'left_forefinger3'), + id=33, + color=[255, 153, 255]), + 34: + dict( + link=('left_forefinger3', 'left_forefinger4'), + id=34, + color=[255, 153, 255]), + 35: + dict( + link=('left_wrist', 'left_middle_finger1'), + id=35, + color=[102, 178, 255]), + 36: + dict( + link=('left_middle_finger1', 'left_middle_finger2'), + id=36, + color=[102, 178, 255]), + 37: + dict( + link=('left_middle_finger2', 'left_middle_finger3'), + id=37, + color=[102, 178, 255]), + 38: + dict( + link=('left_middle_finger3', 'left_middle_finger4'), + id=38, + color=[102, 178, 255]), + 39: + dict( + link=('left_wrist', 'left_ring_finger1'), + id=39, + color=[255, 51, 51]), + 40: + dict( + link=('left_ring_finger1', 'left_ring_finger2'), + id=40, + color=[255, 51, 51]), + 41: + dict( + link=('left_ring_finger2', 'left_ring_finger3'), + id=41, + color=[255, 51, 51]), + 42: + dict( + link=('left_ring_finger3', 'left_ring_finger4'), + id=42, + color=[255, 51, 51]), + 43: + dict( + link=('left_wrist', 'left_pinky_finger1'), + id=43, + color=[0, 255, 0]), + 44: + dict( + link=('left_pinky_finger1', 'left_pinky_finger2'), + id=44, + color=[0, 255, 0]), + 45: + dict( + link=('left_pinky_finger2', 'left_pinky_finger3'), + id=45, + color=[0, 255, 0]), + 46: + dict( + link=('left_pinky_finger3', 'left_pinky_finger4'), + id=46, + color=[0, 255, 0]), + 47: + dict(link=('right_wrist', 'right_thumb1'), id=47, color=[255, 128, 0]), + 48: + dict( + link=('right_thumb1', 'right_thumb2'), id=48, color=[255, 128, 0]), + 49: + dict( + link=('right_thumb2', 'right_thumb3'), id=49, color=[255, 128, 0]), + 50: + dict( + link=('right_thumb3', 'right_thumb4'), id=50, color=[255, 128, 0]), + 51: + dict( + link=('right_wrist', 'right_forefinger1'), + id=51, + color=[255, 153, 255]), + 52: + dict( + link=('right_forefinger1', 'right_forefinger2'), + id=52, + color=[255, 153, 255]), + 53: + dict( + link=('right_forefinger2', 'right_forefinger3'), + id=53, + color=[255, 153, 255]), + 54: + dict( + link=('right_forefinger3', 'right_forefinger4'), + id=54, + color=[255, 153, 255]), + 55: + dict( + link=('right_wrist', 'right_middle_finger1'), + id=55, + color=[102, 178, 255]), + 56: + dict( + link=('right_middle_finger1', 'right_middle_finger2'), + id=56, + color=[102, 178, 255]), + 57: + dict( + link=('right_middle_finger2', 'right_middle_finger3'), + id=57, + color=[102, 178, 255]), + 58: + dict( + link=('right_middle_finger3', 'right_middle_finger4'), + id=58, + color=[102, 178, 255]), + 59: + dict( + link=('right_wrist', 'right_ring_finger1'), + id=59, + color=[255, 51, 51]), + 60: + dict( + link=('right_ring_finger1', 'right_ring_finger2'), + id=60, + color=[255, 51, 51]), + 61: + dict( + link=('right_ring_finger2', 'right_ring_finger3'), + id=61, + color=[255, 51, 51]), + 62: + dict( + link=('right_ring_finger3', 'right_ring_finger4'), + id=62, + color=[255, 51, 51]), + 63: + dict( + link=('right_wrist', 'right_pinky_finger1'), + id=63, + color=[0, 255, 0]), + 64: + dict( + link=('right_pinky_finger1', 'right_pinky_finger2'), + id=64, + color=[0, 255, 0]), + 65: + dict( + link=('right_pinky_finger2', 'right_pinky_finger3'), + id=65, + color=[0, 255, 0]), + 66: + dict( + link=('right_pinky_finger3', 'right_pinky_finger4'), + id=66, + color=[0, 255, 0]) + }, + joint_weights=[1.] * 136, + + # 'https://github.com/Fang-Haoshu/Halpe-FullBody/blob/master/' + # 'HalpeCOCOAPI/PythonAPI/halpecocotools/cocoeval.py#L245' + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089, 0.08, 0.08, 0.08, + 0.089, 0.089, 0.089, 0.089, 0.089, 0.089, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, + 0.015, 0.015, 0.015, 0.015, 0.015, 0.015 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/horse10.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/horse10.py new file mode 100644 index 0000000000000000000000000000000000000000..60cec1fa50429cb9fc9da82c6e429472cbefd622 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/horse10.py @@ -0,0 +1,201 @@ +dataset_info = dict( + dataset_name='horse10', + paper_info=dict( + author='Mathis, Alexander and Biasi, Thomas and ' + 'Schneider, Steffen and ' + 'Yuksekgonul, Mert and Rogers, Byron and ' + 'Bethge, Matthias and ' + 'Mathis, Mackenzie W', + title='Pretraining boosts out-of-domain robustness ' + 'for pose estimation', + container='Proceedings of the IEEE/CVF Winter Conference on ' + 'Applications of Computer Vision', + year='2021', + homepage='http://www.mackenziemathislab.org/horse10', + ), + keypoint_info={ + 0: + dict(name='Nose', id=0, color=[255, 153, 255], type='upper', swap=''), + 1: + dict(name='Eye', id=1, color=[255, 153, 255], type='upper', swap=''), + 2: + dict( + name='Nearknee', + id=2, + color=[255, 102, 255], + type='upper', + swap=''), + 3: + dict( + name='Nearfrontfetlock', + id=3, + color=[255, 102, 255], + type='upper', + swap=''), + 4: + dict( + name='Nearfrontfoot', + id=4, + color=[255, 102, 255], + type='upper', + swap=''), + 5: + dict( + name='Offknee', id=5, color=[255, 102, 255], type='upper', + swap=''), + 6: + dict( + name='Offfrontfetlock', + id=6, + color=[255, 102, 255], + type='upper', + swap=''), + 7: + dict( + name='Offfrontfoot', + id=7, + color=[255, 102, 255], + type='upper', + swap=''), + 8: + dict( + name='Shoulder', + id=8, + color=[255, 153, 255], + type='upper', + swap=''), + 9: + dict( + name='Midshoulder', + id=9, + color=[255, 153, 255], + type='upper', + swap=''), + 10: + dict( + name='Elbow', id=10, color=[255, 153, 255], type='upper', swap=''), + 11: + dict( + name='Girth', id=11, color=[255, 153, 255], type='upper', swap=''), + 12: + dict( + name='Wither', id=12, color=[255, 153, 255], type='upper', + swap=''), + 13: + dict( + name='Nearhindhock', + id=13, + color=[255, 51, 255], + type='lower', + swap=''), + 14: + dict( + name='Nearhindfetlock', + id=14, + color=[255, 51, 255], + type='lower', + swap=''), + 15: + dict( + name='Nearhindfoot', + id=15, + color=[255, 51, 255], + type='lower', + swap=''), + 16: + dict(name='Hip', id=16, color=[255, 153, 255], type='lower', swap=''), + 17: + dict( + name='Stifle', id=17, color=[255, 153, 255], type='lower', + swap=''), + 18: + dict( + name='Offhindhock', + id=18, + color=[255, 51, 255], + type='lower', + swap=''), + 19: + dict( + name='Offhindfetlock', + id=19, + color=[255, 51, 255], + type='lower', + swap=''), + 20: + dict( + name='Offhindfoot', + id=20, + color=[255, 51, 255], + type='lower', + swap=''), + 21: + dict( + name='Ischium', + id=21, + color=[255, 153, 255], + type='lower', + swap='') + }, + skeleton_info={ + 0: + dict(link=('Nose', 'Eye'), id=0, color=[255, 153, 255]), + 1: + dict(link=('Eye', 'Wither'), id=1, color=[255, 153, 255]), + 2: + dict(link=('Wither', 'Hip'), id=2, color=[255, 153, 255]), + 3: + dict(link=('Hip', 'Ischium'), id=3, color=[255, 153, 255]), + 4: + dict(link=('Ischium', 'Stifle'), id=4, color=[255, 153, 255]), + 5: + dict(link=('Stifle', 'Girth'), id=5, color=[255, 153, 255]), + 6: + dict(link=('Girth', 'Elbow'), id=6, color=[255, 153, 255]), + 7: + dict(link=('Elbow', 'Shoulder'), id=7, color=[255, 153, 255]), + 8: + dict(link=('Shoulder', 'Midshoulder'), id=8, color=[255, 153, 255]), + 9: + dict(link=('Midshoulder', 'Wither'), id=9, color=[255, 153, 255]), + 10: + dict( + link=('Nearknee', 'Nearfrontfetlock'), + id=10, + color=[255, 102, 255]), + 11: + dict( + link=('Nearfrontfetlock', 'Nearfrontfoot'), + id=11, + color=[255, 102, 255]), + 12: + dict( + link=('Offknee', 'Offfrontfetlock'), id=12, color=[255, 102, 255]), + 13: + dict( + link=('Offfrontfetlock', 'Offfrontfoot'), + id=13, + color=[255, 102, 255]), + 14: + dict( + link=('Nearhindhock', 'Nearhindfetlock'), + id=14, + color=[255, 51, 255]), + 15: + dict( + link=('Nearhindfetlock', 'Nearhindfoot'), + id=15, + color=[255, 51, 255]), + 16: + dict( + link=('Offhindhock', 'Offhindfetlock'), + id=16, + color=[255, 51, 255]), + 17: + dict( + link=('Offhindfetlock', 'Offhindfoot'), + id=17, + color=[255, 51, 255]) + }, + joint_weights=[1.] * 22, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand2d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand2d.py new file mode 100644 index 0000000000000000000000000000000000000000..e60dfc795a826445d2efdfbe77062642a6ab46f0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand2d.py @@ -0,0 +1,142 @@ +dataset_info = dict( + dataset_name='interhand2d', + paper_info=dict( + author='Moon, Gyeongsik and Yu, Shoou-I and Wen, He and ' + 'Shiratori, Takaaki and Lee, Kyoung Mu', + title='InterHand2.6M: A dataset and baseline for 3D ' + 'interacting hand pose estimation from a single RGB image', + container='arXiv', + year='2020', + homepage='https://mks0601.github.io/InterHand2.6M/', + ), + keypoint_info={ + 0: + dict(name='thumb4', id=0, color=[255, 128, 0], type='', swap=''), + 1: + dict(name='thumb3', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb1', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict( + name='forefinger4', id=4, color=[255, 153, 255], type='', swap=''), + 5: + dict( + name='forefinger3', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger1', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='middle_finger4', + id=8, + color=[102, 178, 255], + type='', + swap=''), + 9: + dict( + name='middle_finger3', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger1', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='ring_finger4', id=12, color=[255, 51, 51], type='', swap=''), + 13: + dict( + name='ring_finger3', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger1', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict(name='pinky_finger4', id=16, color=[0, 255, 0], type='', swap=''), + 17: + dict(name='pinky_finger3', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger1', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='wrist', id=20, color=[255, 255, 255], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand3d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand3d.py new file mode 100644 index 0000000000000000000000000000000000000000..26b7ccf71a787d0aa698c57a9757a4dc9f2be412 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/interhand3d.py @@ -0,0 +1,487 @@ +dataset_info = dict( + dataset_name='interhand3d', + paper_info=dict( + author='Moon, Gyeongsik and Yu, Shoou-I and Wen, He and ' + 'Shiratori, Takaaki and Lee, Kyoung Mu', + title='InterHand2.6M: A dataset and baseline for 3D ' + 'interacting hand pose estimation from a single RGB image', + container='arXiv', + year='2020', + homepage='https://mks0601.github.io/InterHand2.6M/', + ), + keypoint_info={ + 0: + dict( + name='right_thumb4', + id=0, + color=[255, 128, 0], + type='', + swap='left_thumb4'), + 1: + dict( + name='right_thumb3', + id=1, + color=[255, 128, 0], + type='', + swap='left_thumb3'), + 2: + dict( + name='right_thumb2', + id=2, + color=[255, 128, 0], + type='', + swap='left_thumb2'), + 3: + dict( + name='right_thumb1', + id=3, + color=[255, 128, 0], + type='', + swap='left_thumb1'), + 4: + dict( + name='right_forefinger4', + id=4, + color=[255, 153, 255], + type='', + swap='left_forefinger4'), + 5: + dict( + name='right_forefinger3', + id=5, + color=[255, 153, 255], + type='', + swap='left_forefinger3'), + 6: + dict( + name='right_forefinger2', + id=6, + color=[255, 153, 255], + type='', + swap='left_forefinger2'), + 7: + dict( + name='right_forefinger1', + id=7, + color=[255, 153, 255], + type='', + swap='left_forefinger1'), + 8: + dict( + name='right_middle_finger4', + id=8, + color=[102, 178, 255], + type='', + swap='left_middle_finger4'), + 9: + dict( + name='right_middle_finger3', + id=9, + color=[102, 178, 255], + type='', + swap='left_middle_finger3'), + 10: + dict( + name='right_middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap='left_middle_finger2'), + 11: + dict( + name='right_middle_finger1', + id=11, + color=[102, 178, 255], + type='', + swap='left_middle_finger1'), + 12: + dict( + name='right_ring_finger4', + id=12, + color=[255, 51, 51], + type='', + swap='left_ring_finger4'), + 13: + dict( + name='right_ring_finger3', + id=13, + color=[255, 51, 51], + type='', + swap='left_ring_finger3'), + 14: + dict( + name='right_ring_finger2', + id=14, + color=[255, 51, 51], + type='', + swap='left_ring_finger2'), + 15: + dict( + name='right_ring_finger1', + id=15, + color=[255, 51, 51], + type='', + swap='left_ring_finger1'), + 16: + dict( + name='right_pinky_finger4', + id=16, + color=[0, 255, 0], + type='', + swap='left_pinky_finger4'), + 17: + dict( + name='right_pinky_finger3', + id=17, + color=[0, 255, 0], + type='', + swap='left_pinky_finger3'), + 18: + dict( + name='right_pinky_finger2', + id=18, + color=[0, 255, 0], + type='', + swap='left_pinky_finger2'), + 19: + dict( + name='right_pinky_finger1', + id=19, + color=[0, 255, 0], + type='', + swap='left_pinky_finger1'), + 20: + dict( + name='right_wrist', + id=20, + color=[255, 255, 255], + type='', + swap='left_wrist'), + 21: + dict( + name='left_thumb4', + id=21, + color=[255, 128, 0], + type='', + swap='right_thumb4'), + 22: + dict( + name='left_thumb3', + id=22, + color=[255, 128, 0], + type='', + swap='right_thumb3'), + 23: + dict( + name='left_thumb2', + id=23, + color=[255, 128, 0], + type='', + swap='right_thumb2'), + 24: + dict( + name='left_thumb1', + id=24, + color=[255, 128, 0], + type='', + swap='right_thumb1'), + 25: + dict( + name='left_forefinger4', + id=25, + color=[255, 153, 255], + type='', + swap='right_forefinger4'), + 26: + dict( + name='left_forefinger3', + id=26, + color=[255, 153, 255], + type='', + swap='right_forefinger3'), + 27: + dict( + name='left_forefinger2', + id=27, + color=[255, 153, 255], + type='', + swap='right_forefinger2'), + 28: + dict( + name='left_forefinger1', + id=28, + color=[255, 153, 255], + type='', + swap='right_forefinger1'), + 29: + dict( + name='left_middle_finger4', + id=29, + color=[102, 178, 255], + type='', + swap='right_middle_finger4'), + 30: + dict( + name='left_middle_finger3', + id=30, + color=[102, 178, 255], + type='', + swap='right_middle_finger3'), + 31: + dict( + name='left_middle_finger2', + id=31, + color=[102, 178, 255], + type='', + swap='right_middle_finger2'), + 32: + dict( + name='left_middle_finger1', + id=32, + color=[102, 178, 255], + type='', + swap='right_middle_finger1'), + 33: + dict( + name='left_ring_finger4', + id=33, + color=[255, 51, 51], + type='', + swap='right_ring_finger4'), + 34: + dict( + name='left_ring_finger3', + id=34, + color=[255, 51, 51], + type='', + swap='right_ring_finger3'), + 35: + dict( + name='left_ring_finger2', + id=35, + color=[255, 51, 51], + type='', + swap='right_ring_finger2'), + 36: + dict( + name='left_ring_finger1', + id=36, + color=[255, 51, 51], + type='', + swap='right_ring_finger1'), + 37: + dict( + name='left_pinky_finger4', + id=37, + color=[0, 255, 0], + type='', + swap='right_pinky_finger4'), + 38: + dict( + name='left_pinky_finger3', + id=38, + color=[0, 255, 0], + type='', + swap='right_pinky_finger3'), + 39: + dict( + name='left_pinky_finger2', + id=39, + color=[0, 255, 0], + type='', + swap='right_pinky_finger2'), + 40: + dict( + name='left_pinky_finger1', + id=40, + color=[0, 255, 0], + type='', + swap='right_pinky_finger1'), + 41: + dict( + name='left_wrist', + id=41, + color=[255, 255, 255], + type='', + swap='right_wrist'), + }, + skeleton_info={ + 0: + dict(link=('right_wrist', 'right_thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('right_thumb1', 'right_thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('right_thumb2', 'right_thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_thumb3', 'right_thumb4'), id=3, color=[255, 128, 0]), + 4: + dict( + link=('right_wrist', 'right_forefinger1'), + id=4, + color=[255, 153, 255]), + 5: + dict( + link=('right_forefinger1', 'right_forefinger2'), + id=5, + color=[255, 153, 255]), + 6: + dict( + link=('right_forefinger2', 'right_forefinger3'), + id=6, + color=[255, 153, 255]), + 7: + dict( + link=('right_forefinger3', 'right_forefinger4'), + id=7, + color=[255, 153, 255]), + 8: + dict( + link=('right_wrist', 'right_middle_finger1'), + id=8, + color=[102, 178, 255]), + 9: + dict( + link=('right_middle_finger1', 'right_middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('right_middle_finger2', 'right_middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('right_middle_finger3', 'right_middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict( + link=('right_wrist', 'right_ring_finger1'), + id=12, + color=[255, 51, 51]), + 13: + dict( + link=('right_ring_finger1', 'right_ring_finger2'), + id=13, + color=[255, 51, 51]), + 14: + dict( + link=('right_ring_finger2', 'right_ring_finger3'), + id=14, + color=[255, 51, 51]), + 15: + dict( + link=('right_ring_finger3', 'right_ring_finger4'), + id=15, + color=[255, 51, 51]), + 16: + dict( + link=('right_wrist', 'right_pinky_finger1'), + id=16, + color=[0, 255, 0]), + 17: + dict( + link=('right_pinky_finger1', 'right_pinky_finger2'), + id=17, + color=[0, 255, 0]), + 18: + dict( + link=('right_pinky_finger2', 'right_pinky_finger3'), + id=18, + color=[0, 255, 0]), + 19: + dict( + link=('right_pinky_finger3', 'right_pinky_finger4'), + id=19, + color=[0, 255, 0]), + 20: + dict(link=('left_wrist', 'left_thumb1'), id=20, color=[255, 128, 0]), + 21: + dict(link=('left_thumb1', 'left_thumb2'), id=21, color=[255, 128, 0]), + 22: + dict(link=('left_thumb2', 'left_thumb3'), id=22, color=[255, 128, 0]), + 23: + dict(link=('left_thumb3', 'left_thumb4'), id=23, color=[255, 128, 0]), + 24: + dict( + link=('left_wrist', 'left_forefinger1'), + id=24, + color=[255, 153, 255]), + 25: + dict( + link=('left_forefinger1', 'left_forefinger2'), + id=25, + color=[255, 153, 255]), + 26: + dict( + link=('left_forefinger2', 'left_forefinger3'), + id=26, + color=[255, 153, 255]), + 27: + dict( + link=('left_forefinger3', 'left_forefinger4'), + id=27, + color=[255, 153, 255]), + 28: + dict( + link=('left_wrist', 'left_middle_finger1'), + id=28, + color=[102, 178, 255]), + 29: + dict( + link=('left_middle_finger1', 'left_middle_finger2'), + id=29, + color=[102, 178, 255]), + 30: + dict( + link=('left_middle_finger2', 'left_middle_finger3'), + id=30, + color=[102, 178, 255]), + 31: + dict( + link=('left_middle_finger3', 'left_middle_finger4'), + id=31, + color=[102, 178, 255]), + 32: + dict( + link=('left_wrist', 'left_ring_finger1'), + id=32, + color=[255, 51, 51]), + 33: + dict( + link=('left_ring_finger1', 'left_ring_finger2'), + id=33, + color=[255, 51, 51]), + 34: + dict( + link=('left_ring_finger2', 'left_ring_finger3'), + id=34, + color=[255, 51, 51]), + 35: + dict( + link=('left_ring_finger3', 'left_ring_finger4'), + id=35, + color=[255, 51, 51]), + 36: + dict( + link=('left_wrist', 'left_pinky_finger1'), + id=36, + color=[0, 255, 0]), + 37: + dict( + link=('left_pinky_finger1', 'left_pinky_finger2'), + id=37, + color=[0, 255, 0]), + 38: + dict( + link=('left_pinky_finger2', 'left_pinky_finger3'), + id=38, + color=[0, 255, 0]), + 39: + dict( + link=('left_pinky_finger3', 'left_pinky_finger4'), + id=39, + color=[0, 255, 0]), + }, + joint_weights=[1.] * 42, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/jhmdb.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/jhmdb.py new file mode 100644 index 0000000000000000000000000000000000000000..1f931fc9f1bf5e1d6588cc713eee18f62e77f4a1 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/jhmdb.py @@ -0,0 +1,129 @@ +dataset_info = dict( + dataset_name='jhmdb', + paper_info=dict( + author='H. Jhuang and J. Gall and S. Zuffi and ' + 'C. Schmid and M. J. Black', + title='Towards understanding action recognition', + container='International Conf. on Computer Vision (ICCV)', + year='2013', + homepage='http://jhmdb.is.tue.mpg.de/dataset', + ), + keypoint_info={ + 0: + dict(name='neck', id=0, color=[255, 128, 0], type='upper', swap=''), + 1: + dict(name='belly', id=1, color=[255, 128, 0], type='upper', swap=''), + 2: + dict(name='head', id=2, color=[255, 128, 0], type='upper', swap=''), + 3: + dict( + name='right_shoulder', + id=3, + color=[0, 255, 0], + type='upper', + swap='left_shoulder'), + 4: + dict( + name='left_shoulder', + id=4, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 5: + dict( + name='right_hip', + id=5, + color=[0, 255, 0], + type='lower', + swap='left_hip'), + 6: + dict( + name='left_hip', + id=6, + color=[51, 153, 255], + type='lower', + swap='right_hip'), + 7: + dict( + name='right_elbow', + id=7, + color=[51, 153, 255], + type='upper', + swap='left_elbow'), + 8: + dict( + name='left_elbow', + id=8, + color=[51, 153, 255], + type='upper', + swap='right_elbow'), + 9: + dict( + name='right_knee', + id=9, + color=[51, 153, 255], + type='lower', + swap='left_knee'), + 10: + dict( + name='left_knee', + id=10, + color=[255, 128, 0], + type='lower', + swap='right_knee'), + 11: + dict( + name='right_wrist', + id=11, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 12: + dict( + name='left_wrist', + id=12, + color=[255, 128, 0], + type='upper', + swap='right_wrist'), + 13: + dict( + name='right_ankle', + id=13, + color=[0, 255, 0], + type='lower', + swap='left_ankle'), + 14: + dict( + name='left_ankle', + id=14, + color=[0, 255, 0], + type='lower', + swap='right_ankle') + }, + skeleton_info={ + 0: dict(link=('right_ankle', 'right_knee'), id=0, color=[255, 128, 0]), + 1: dict(link=('right_knee', 'right_hip'), id=1, color=[255, 128, 0]), + 2: dict(link=('right_hip', 'belly'), id=2, color=[255, 128, 0]), + 3: dict(link=('belly', 'left_hip'), id=3, color=[0, 255, 0]), + 4: dict(link=('left_hip', 'left_knee'), id=4, color=[0, 255, 0]), + 5: dict(link=('left_knee', 'left_ankle'), id=5, color=[0, 255, 0]), + 6: dict(link=('belly', 'neck'), id=6, color=[51, 153, 255]), + 7: dict(link=('neck', 'head'), id=7, color=[51, 153, 255]), + 8: dict(link=('neck', 'right_shoulder'), id=8, color=[255, 128, 0]), + 9: dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('right_elbow', 'right_wrist'), id=10, color=[255, 128, 0]), + 11: dict(link=('neck', 'left_shoulder'), id=11, color=[0, 255, 0]), + 12: + dict(link=('left_shoulder', 'left_elbow'), id=12, color=[0, 255, 0]), + 13: dict(link=('left_elbow', 'left_wrist'), id=13, color=[0, 255, 0]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.2, 1.2, 1.5, 1.5, 1.5, 1.5 + ], + # Adapted from COCO dataset. + sigmas=[ + 0.025, 0.107, 0.025, 0.079, 0.079, 0.107, 0.107, 0.072, 0.072, 0.087, + 0.087, 0.062, 0.062, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/locust.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/locust.py new file mode 100644 index 0000000000000000000000000000000000000000..3a6fafddfad3edd8ab17fe065d6e4c1b357e6697 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/locust.py @@ -0,0 +1,263 @@ +dataset_info = dict( + dataset_name='locust', + paper_info=dict( + author='Graving, Jacob M and Chae, Daniel and Naik, Hemal and ' + 'Li, Liang and Koger, Benjamin and Costelloe, Blair R and ' + 'Couzin, Iain D', + title='DeepPoseKit, a software toolkit for fast and robust ' + 'animal pose estimation using deep learning', + container='Elife', + year='2019', + homepage='https://github.com/jgraving/DeepPoseKit-Data', + ), + keypoint_info={ + 0: + dict(name='head', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='neck', id=1, color=[255, 255, 255], type='', swap=''), + 2: + dict(name='thorax', id=2, color=[255, 255, 255], type='', swap=''), + 3: + dict(name='abdomen1', id=3, color=[255, 255, 255], type='', swap=''), + 4: + dict(name='abdomen2', id=4, color=[255, 255, 255], type='', swap=''), + 5: + dict( + name='anttipL', + id=5, + color=[255, 255, 255], + type='', + swap='anttipR'), + 6: + dict( + name='antbaseL', + id=6, + color=[255, 255, 255], + type='', + swap='antbaseR'), + 7: + dict(name='eyeL', id=7, color=[255, 255, 255], type='', swap='eyeR'), + 8: + dict( + name='forelegL1', + id=8, + color=[255, 255, 255], + type='', + swap='forelegR1'), + 9: + dict( + name='forelegL2', + id=9, + color=[255, 255, 255], + type='', + swap='forelegR2'), + 10: + dict( + name='forelegL3', + id=10, + color=[255, 255, 255], + type='', + swap='forelegR3'), + 11: + dict( + name='forelegL4', + id=11, + color=[255, 255, 255], + type='', + swap='forelegR4'), + 12: + dict( + name='midlegL1', + id=12, + color=[255, 255, 255], + type='', + swap='midlegR1'), + 13: + dict( + name='midlegL2', + id=13, + color=[255, 255, 255], + type='', + swap='midlegR2'), + 14: + dict( + name='midlegL3', + id=14, + color=[255, 255, 255], + type='', + swap='midlegR3'), + 15: + dict( + name='midlegL4', + id=15, + color=[255, 255, 255], + type='', + swap='midlegR4'), + 16: + dict( + name='hindlegL1', + id=16, + color=[255, 255, 255], + type='', + swap='hindlegR1'), + 17: + dict( + name='hindlegL2', + id=17, + color=[255, 255, 255], + type='', + swap='hindlegR2'), + 18: + dict( + name='hindlegL3', + id=18, + color=[255, 255, 255], + type='', + swap='hindlegR3'), + 19: + dict( + name='hindlegL4', + id=19, + color=[255, 255, 255], + type='', + swap='hindlegR4'), + 20: + dict( + name='anttipR', + id=20, + color=[255, 255, 255], + type='', + swap='anttipL'), + 21: + dict( + name='antbaseR', + id=21, + color=[255, 255, 255], + type='', + swap='antbaseL'), + 22: + dict(name='eyeR', id=22, color=[255, 255, 255], type='', swap='eyeL'), + 23: + dict( + name='forelegR1', + id=23, + color=[255, 255, 255], + type='', + swap='forelegL1'), + 24: + dict( + name='forelegR2', + id=24, + color=[255, 255, 255], + type='', + swap='forelegL2'), + 25: + dict( + name='forelegR3', + id=25, + color=[255, 255, 255], + type='', + swap='forelegL3'), + 26: + dict( + name='forelegR4', + id=26, + color=[255, 255, 255], + type='', + swap='forelegL4'), + 27: + dict( + name='midlegR1', + id=27, + color=[255, 255, 255], + type='', + swap='midlegL1'), + 28: + dict( + name='midlegR2', + id=28, + color=[255, 255, 255], + type='', + swap='midlegL2'), + 29: + dict( + name='midlegR3', + id=29, + color=[255, 255, 255], + type='', + swap='midlegL3'), + 30: + dict( + name='midlegR4', + id=30, + color=[255, 255, 255], + type='', + swap='midlegL4'), + 31: + dict( + name='hindlegR1', + id=31, + color=[255, 255, 255], + type='', + swap='hindlegL1'), + 32: + dict( + name='hindlegR2', + id=32, + color=[255, 255, 255], + type='', + swap='hindlegL2'), + 33: + dict( + name='hindlegR3', + id=33, + color=[255, 255, 255], + type='', + swap='hindlegL3'), + 34: + dict( + name='hindlegR4', + id=34, + color=[255, 255, 255], + type='', + swap='hindlegL4') + }, + skeleton_info={ + 0: dict(link=('neck', 'head'), id=0, color=[255, 255, 255]), + 1: dict(link=('thorax', 'neck'), id=1, color=[255, 255, 255]), + 2: dict(link=('abdomen1', 'thorax'), id=2, color=[255, 255, 255]), + 3: dict(link=('abdomen2', 'abdomen1'), id=3, color=[255, 255, 255]), + 4: dict(link=('antbaseL', 'anttipL'), id=4, color=[255, 255, 255]), + 5: dict(link=('eyeL', 'antbaseL'), id=5, color=[255, 255, 255]), + 6: dict(link=('forelegL2', 'forelegL1'), id=6, color=[255, 255, 255]), + 7: dict(link=('forelegL3', 'forelegL2'), id=7, color=[255, 255, 255]), + 8: dict(link=('forelegL4', 'forelegL3'), id=8, color=[255, 255, 255]), + 9: dict(link=('midlegL2', 'midlegL1'), id=9, color=[255, 255, 255]), + 10: dict(link=('midlegL3', 'midlegL2'), id=10, color=[255, 255, 255]), + 11: dict(link=('midlegL4', 'midlegL3'), id=11, color=[255, 255, 255]), + 12: + dict(link=('hindlegL2', 'hindlegL1'), id=12, color=[255, 255, 255]), + 13: + dict(link=('hindlegL3', 'hindlegL2'), id=13, color=[255, 255, 255]), + 14: + dict(link=('hindlegL4', 'hindlegL3'), id=14, color=[255, 255, 255]), + 15: dict(link=('antbaseR', 'anttipR'), id=15, color=[255, 255, 255]), + 16: dict(link=('eyeR', 'antbaseR'), id=16, color=[255, 255, 255]), + 17: + dict(link=('forelegR2', 'forelegR1'), id=17, color=[255, 255, 255]), + 18: + dict(link=('forelegR3', 'forelegR2'), id=18, color=[255, 255, 255]), + 19: + dict(link=('forelegR4', 'forelegR3'), id=19, color=[255, 255, 255]), + 20: dict(link=('midlegR2', 'midlegR1'), id=20, color=[255, 255, 255]), + 21: dict(link=('midlegR3', 'midlegR2'), id=21, color=[255, 255, 255]), + 22: dict(link=('midlegR4', 'midlegR3'), id=22, color=[255, 255, 255]), + 23: + dict(link=('hindlegR2', 'hindlegR1'), id=23, color=[255, 255, 255]), + 24: + dict(link=('hindlegR3', 'hindlegR2'), id=24, color=[255, 255, 255]), + 25: + dict(link=('hindlegR4', 'hindlegR3'), id=25, color=[255, 255, 255]) + }, + joint_weights=[1.] * 35, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/macaque.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/macaque.py new file mode 100644 index 0000000000000000000000000000000000000000..926ca30d3cf89d69c6526bd42b453428a12f6752 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/macaque.py @@ -0,0 +1,183 @@ +dataset_info = dict( + dataset_name='macaque', + paper_info=dict( + author='Labuguen, Rollyn and Matsumoto, Jumpei and ' + 'Negrete, Salvador and Nishimaru, Hiroshi and ' + 'Nishijo, Hisao and Takada, Masahiko and ' + 'Go, Yasuhiro and Inoue, Ken-ichi and Shibata, Tomohiro', + title='MacaquePose: A novel "in the wild" macaque monkey pose dataset ' + 'for markerless motion capture', + container='bioRxiv', + year='2020', + homepage='http://www.pri.kyoto-u.ac.jp/datasets/' + 'macaquepose/index.html', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mhp.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mhp.py new file mode 100644 index 0000000000000000000000000000000000000000..9c8c03c2f546cfeceacf45573d24a132daf51c7f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mhp.py @@ -0,0 +1,156 @@ +dataset_info = dict( + dataset_name='mhp', + paper_info=dict( + author='Zhao, Jian and Li, Jianshu and Cheng, Yu and ' + 'Sim, Terence and Yan, Shuicheng and Feng, Jiashi', + title='Understanding humans in crowded scenes: ' + 'Deep nested adversarial learning and a ' + 'new benchmark for multi-human parsing', + container='Proceedings of the 26th ACM ' + 'international conference on Multimedia', + year='2018', + homepage='https://lv-mhp.github.io/dataset', + ), + keypoint_info={ + 0: + dict( + name='right_ankle', + id=0, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 1: + dict( + name='right_knee', + id=1, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 2: + dict( + name='right_hip', + id=2, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 3: + dict( + name='left_hip', + id=3, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 4: + dict( + name='left_knee', + id=4, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 5: + dict( + name='left_ankle', + id=5, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 6: + dict(name='pelvis', id=6, color=[51, 153, 255], type='lower', swap=''), + 7: + dict(name='thorax', id=7, color=[51, 153, 255], type='upper', swap=''), + 8: + dict( + name='upper_neck', + id=8, + color=[51, 153, 255], + type='upper', + swap=''), + 9: + dict( + name='head_top', id=9, color=[51, 153, 255], type='upper', + swap=''), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='right_elbow', + id=11, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 12: + dict( + name='right_shoulder', + id=12, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 13: + dict( + name='left_shoulder', + id=13, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 14: + dict( + name='left_elbow', + id=14, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 15: + dict( + name='left_wrist', + id=15, + color=[0, 255, 0], + type='upper', + swap='right_wrist') + }, + skeleton_info={ + 0: + dict(link=('right_ankle', 'right_knee'), id=0, color=[255, 128, 0]), + 1: + dict(link=('right_knee', 'right_hip'), id=1, color=[255, 128, 0]), + 2: + dict(link=('right_hip', 'pelvis'), id=2, color=[255, 128, 0]), + 3: + dict(link=('pelvis', 'left_hip'), id=3, color=[0, 255, 0]), + 4: + dict(link=('left_hip', 'left_knee'), id=4, color=[0, 255, 0]), + 5: + dict(link=('left_knee', 'left_ankle'), id=5, color=[0, 255, 0]), + 6: + dict(link=('pelvis', 'thorax'), id=6, color=[51, 153, 255]), + 7: + dict(link=('thorax', 'upper_neck'), id=7, color=[51, 153, 255]), + 8: + dict(link=('upper_neck', 'head_top'), id=8, color=[51, 153, 255]), + 9: + dict(link=('upper_neck', 'right_shoulder'), id=9, color=[255, 128, 0]), + 10: + dict( + link=('right_shoulder', 'right_elbow'), id=10, color=[255, 128, + 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('upper_neck', 'left_shoulder'), id=12, color=[0, 255, 0]), + 13: + dict(link=('left_shoulder', 'left_elbow'), id=13, color=[0, 255, 0]), + 14: + dict(link=('left_elbow', 'left_wrist'), id=14, color=[0, 255, 0]) + }, + joint_weights=[ + 1.5, 1.2, 1., 1., 1.2, 1.5, 1., 1., 1., 1., 1.5, 1.2, 1., 1., 1.2, 1.5 + ], + # Adapted from COCO dataset. + sigmas=[ + 0.089, 0.083, 0.107, 0.107, 0.083, 0.089, 0.026, 0.026, 0.026, 0.026, + 0.062, 0.072, 0.179, 0.179, 0.072, 0.062 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpi_inf_3dhp.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpi_inf_3dhp.py new file mode 100644 index 0000000000000000000000000000000000000000..ed088c2df06dcd1d112b782039e212f7b020cee6 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpi_inf_3dhp.py @@ -0,0 +1,132 @@ +dataset_info = dict( + dataset_name='mpi_inf_3dhp', + paper_info=dict( + author='ehta, Dushyant and Rhodin, Helge and Casas, Dan and ' + 'Fua, Pascal and Sotnychenko, Oleksandr and Xu, Weipeng and ' + 'Theobalt, Christian', + title='Monocular 3D Human Pose Estimation In The Wild Using Improved ' + 'CNN Supervision', + container='2017 international conference on 3D vision (3DV)', + year='2017', + homepage='http://gvv.mpi-inf.mpg.de/3dhp-dataset', + ), + keypoint_info={ + 0: + dict( + name='head_top', id=0, color=[51, 153, 255], type='upper', + swap=''), + 1: + dict(name='neck', id=1, color=[51, 153, 255], type='upper', swap=''), + 2: + dict( + name='right_shoulder', + id=2, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 3: + dict( + name='right_elbow', + id=3, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 4: + dict( + name='right_wrist', + id=4, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='left_elbow', + id=6, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 7: + dict( + name='left_wrist', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 8: + dict( + name='right_hip', + id=8, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 9: + dict( + name='right_knee', + id=9, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 10: + dict( + name='right_ankle', + id=10, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='left_knee', + id=12, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 13: + dict( + name='left_ankle', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 14: + dict(name='root', id=14, color=[51, 153, 255], type='lower', swap=''), + 15: + dict(name='spine', id=15, color=[51, 153, 255], type='upper', swap=''), + 16: + dict(name='head', id=16, color=[51, 153, 255], type='upper', swap='') + }, + skeleton_info={ + 0: dict(link=('neck', 'right_shoulder'), id=0, color=[255, 128, 0]), + 1: dict( + link=('right_shoulder', 'right_elbow'), id=1, color=[255, 128, 0]), + 2: + dict(link=('right_elbow', 'right_wrist'), id=2, color=[255, 128, 0]), + 3: dict(link=('neck', 'left_shoulder'), id=3, color=[0, 255, 0]), + 4: dict(link=('left_shoulder', 'left_elbow'), id=4, color=[0, 255, 0]), + 5: dict(link=('left_elbow', 'left_wrist'), id=5, color=[0, 255, 0]), + 6: dict(link=('root', 'right_hip'), id=6, color=[255, 128, 0]), + 7: dict(link=('right_hip', 'right_knee'), id=7, color=[255, 128, 0]), + 8: dict(link=('right_knee', 'right_ankle'), id=8, color=[255, 128, 0]), + 9: dict(link=('root', 'left_hip'), id=9, color=[0, 255, 0]), + 10: dict(link=('left_hip', 'left_knee'), id=10, color=[0, 255, 0]), + 11: dict(link=('left_knee', 'left_ankle'), id=11, color=[0, 255, 0]), + 12: dict(link=('head_top', 'head'), id=12, color=[51, 153, 255]), + 13: dict(link=('head', 'neck'), id=13, color=[51, 153, 255]), + 14: dict(link=('neck', 'spine'), id=14, color=[51, 153, 255]), + 15: dict(link=('spine', 'root'), id=15, color=[51, 153, 255]) + }, + joint_weights=[1.] * 17, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii.py new file mode 100644 index 0000000000000000000000000000000000000000..2723baead1314b66ec97ba44a4c5a80fa905ae0d --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii.py @@ -0,0 +1,155 @@ +dataset_info = dict( + dataset_name='mpii', + paper_info=dict( + author='Mykhaylo Andriluka and Leonid Pishchulin and ' + 'Peter Gehler and Schiele, Bernt', + title='2D Human Pose Estimation: New Benchmark and ' + 'State of the Art Analysis', + container='IEEE Conference on Computer Vision and ' + 'Pattern Recognition (CVPR)', + year='2014', + homepage='http://human-pose.mpi-inf.mpg.de/', + ), + keypoint_info={ + 0: + dict( + name='right_ankle', + id=0, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 1: + dict( + name='right_knee', + id=1, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 2: + dict( + name='right_hip', + id=2, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 3: + dict( + name='left_hip', + id=3, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 4: + dict( + name='left_knee', + id=4, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 5: + dict( + name='left_ankle', + id=5, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 6: + dict(name='pelvis', id=6, color=[51, 153, 255], type='lower', swap=''), + 7: + dict(name='thorax', id=7, color=[51, 153, 255], type='upper', swap=''), + 8: + dict( + name='upper_neck', + id=8, + color=[51, 153, 255], + type='upper', + swap=''), + 9: + dict( + name='head_top', id=9, color=[51, 153, 255], type='upper', + swap=''), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='right_elbow', + id=11, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 12: + dict( + name='right_shoulder', + id=12, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 13: + dict( + name='left_shoulder', + id=13, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 14: + dict( + name='left_elbow', + id=14, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 15: + dict( + name='left_wrist', + id=15, + color=[0, 255, 0], + type='upper', + swap='right_wrist') + }, + skeleton_info={ + 0: + dict(link=('right_ankle', 'right_knee'), id=0, color=[255, 128, 0]), + 1: + dict(link=('right_knee', 'right_hip'), id=1, color=[255, 128, 0]), + 2: + dict(link=('right_hip', 'pelvis'), id=2, color=[255, 128, 0]), + 3: + dict(link=('pelvis', 'left_hip'), id=3, color=[0, 255, 0]), + 4: + dict(link=('left_hip', 'left_knee'), id=4, color=[0, 255, 0]), + 5: + dict(link=('left_knee', 'left_ankle'), id=5, color=[0, 255, 0]), + 6: + dict(link=('pelvis', 'thorax'), id=6, color=[51, 153, 255]), + 7: + dict(link=('thorax', 'upper_neck'), id=7, color=[51, 153, 255]), + 8: + dict(link=('upper_neck', 'head_top'), id=8, color=[51, 153, 255]), + 9: + dict(link=('upper_neck', 'right_shoulder'), id=9, color=[255, 128, 0]), + 10: + dict( + link=('right_shoulder', 'right_elbow'), id=10, color=[255, 128, + 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('upper_neck', 'left_shoulder'), id=12, color=[0, 255, 0]), + 13: + dict(link=('left_shoulder', 'left_elbow'), id=13, color=[0, 255, 0]), + 14: + dict(link=('left_elbow', 'left_wrist'), id=14, color=[0, 255, 0]) + }, + joint_weights=[ + 1.5, 1.2, 1., 1., 1.2, 1.5, 1., 1., 1., 1., 1.5, 1.2, 1., 1., 1.2, 1.5 + ], + # Adapted from COCO dataset. + sigmas=[ + 0.089, 0.083, 0.107, 0.107, 0.083, 0.089, 0.026, 0.026, 0.026, 0.026, + 0.062, 0.072, 0.179, 0.179, 0.072, 0.062 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_info.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_info.py new file mode 100644 index 0000000000000000000000000000000000000000..ba52a9c8e64516fdb48e1011ef2c8deeb29acbba --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_info.py @@ -0,0 +1,155 @@ +mpii_info = dict( + dataset_name='mpii', + paper_info=dict( + author='Mykhaylo Andriluka and Leonid Pishchulin and ' + 'Peter Gehler and Schiele, Bernt', + title='2D Human Pose Estimation: New Benchmark and ' + 'State of the Art Analysis', + container='IEEE Conference on Computer Vision and ' + 'Pattern Recognition (CVPR)', + year='2014', + homepage='http://human-pose.mpi-inf.mpg.de/', + ), + keypoint_info={ + 0: + dict( + name='right_ankle', + id=0, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 1: + dict( + name='right_knee', + id=1, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 2: + dict( + name='right_hip', + id=2, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 3: + dict( + name='left_hip', + id=3, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 4: + dict( + name='left_knee', + id=4, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 5: + dict( + name='left_ankle', + id=5, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 6: + dict(name='pelvis', id=6, color=[51, 153, 255], type='lower', swap=''), + 7: + dict(name='thorax', id=7, color=[51, 153, 255], type='upper', swap=''), + 8: + dict( + name='upper_neck', + id=8, + color=[51, 153, 255], + type='upper', + swap=''), + 9: + dict( + name='head_top', id=9, color=[51, 153, 255], type='upper', + swap=''), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='right_elbow', + id=11, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 12: + dict( + name='right_shoulder', + id=12, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 13: + dict( + name='left_shoulder', + id=13, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 14: + dict( + name='left_elbow', + id=14, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 15: + dict( + name='left_wrist', + id=15, + color=[0, 255, 0], + type='upper', + swap='right_wrist') + }, + skeleton_info={ + 0: + dict(link=('right_ankle', 'right_knee'), id=0, color=[255, 128, 0]), + 1: + dict(link=('right_knee', 'right_hip'), id=1, color=[255, 128, 0]), + 2: + dict(link=('right_hip', 'pelvis'), id=2, color=[255, 128, 0]), + 3: + dict(link=('pelvis', 'left_hip'), id=3, color=[0, 255, 0]), + 4: + dict(link=('left_hip', 'left_knee'), id=4, color=[0, 255, 0]), + 5: + dict(link=('left_knee', 'left_ankle'), id=5, color=[0, 255, 0]), + 6: + dict(link=('pelvis', 'thorax'), id=6, color=[51, 153, 255]), + 7: + dict(link=('thorax', 'upper_neck'), id=7, color=[51, 153, 255]), + 8: + dict(link=('upper_neck', 'head_top'), id=8, color=[51, 153, 255]), + 9: + dict(link=('upper_neck', 'right_shoulder'), id=9, color=[255, 128, 0]), + 10: + dict( + link=('right_shoulder', 'right_elbow'), id=10, color=[255, 128, + 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('upper_neck', 'left_shoulder'), id=12, color=[0, 255, 0]), + 13: + dict(link=('left_shoulder', 'left_elbow'), id=13, color=[0, 255, 0]), + 14: + dict(link=('left_elbow', 'left_wrist'), id=14, color=[0, 255, 0]) + }, + joint_weights=[ + 1.5, 1.2, 1., 1., 1.2, 1.5, 1., 1., 1., 1., 1.5, 1.2, 1., 1., 1.2, 1.5 + ], + # Adapted from COCO dataset. + sigmas=[ + 0.089, 0.083, 0.107, 0.107, 0.083, 0.089, 0.026, 0.026, 0.026, 0.026, + 0.062, 0.072, 0.179, 0.179, 0.072, 0.062 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_trb.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_trb.py new file mode 100644 index 0000000000000000000000000000000000000000..ddb7e9e53aea7d1206732e946705340b70d47ef2 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/mpii_trb.py @@ -0,0 +1,380 @@ +dataset_info = dict( + dataset_name='mpii_trb', + paper_info=dict( + author='Duan, Haodong and Lin, Kwan-Yee and Jin, Sheng and ' + 'Liu, Wentao and Qian, Chen and Ouyang, Wanli', + title='TRB: A Novel Triplet Representation for ' + 'Understanding 2D Human Body', + container='Proceedings of the IEEE International ' + 'Conference on Computer Vision', + year='2019', + homepage='https://github.com/kennymckormick/' + 'Triplet-Representation-of-human-Body', + ), + keypoint_info={ + 0: + dict( + name='left_shoulder', + id=0, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 1: + dict( + name='right_shoulder', + id=1, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 2: + dict( + name='left_elbow', + id=2, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 3: + dict( + name='right_elbow', + id=3, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 4: + dict( + name='left_wrist', + id=4, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 5: + dict( + name='right_wrist', + id=5, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 6: + dict( + name='left_hip', + id=6, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 7: + dict( + name='right_hip', + id=7, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 8: + dict( + name='left_knee', + id=8, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 9: + dict( + name='right_knee', + id=9, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 10: + dict( + name='left_ankle', + id=10, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 11: + dict( + name='right_ankle', + id=11, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 12: + dict(name='head', id=12, color=[51, 153, 255], type='upper', swap=''), + 13: + dict(name='neck', id=13, color=[51, 153, 255], type='upper', swap=''), + 14: + dict( + name='right_neck', + id=14, + color=[255, 255, 255], + type='upper', + swap='left_neck'), + 15: + dict( + name='left_neck', + id=15, + color=[255, 255, 255], + type='upper', + swap='right_neck'), + 16: + dict( + name='medial_right_shoulder', + id=16, + color=[255, 255, 255], + type='upper', + swap='medial_left_shoulder'), + 17: + dict( + name='lateral_right_shoulder', + id=17, + color=[255, 255, 255], + type='upper', + swap='lateral_left_shoulder'), + 18: + dict( + name='medial_right_bow', + id=18, + color=[255, 255, 255], + type='upper', + swap='medial_left_bow'), + 19: + dict( + name='lateral_right_bow', + id=19, + color=[255, 255, 255], + type='upper', + swap='lateral_left_bow'), + 20: + dict( + name='medial_right_wrist', + id=20, + color=[255, 255, 255], + type='upper', + swap='medial_left_wrist'), + 21: + dict( + name='lateral_right_wrist', + id=21, + color=[255, 255, 255], + type='upper', + swap='lateral_left_wrist'), + 22: + dict( + name='medial_left_shoulder', + id=22, + color=[255, 255, 255], + type='upper', + swap='medial_right_shoulder'), + 23: + dict( + name='lateral_left_shoulder', + id=23, + color=[255, 255, 255], + type='upper', + swap='lateral_right_shoulder'), + 24: + dict( + name='medial_left_bow', + id=24, + color=[255, 255, 255], + type='upper', + swap='medial_right_bow'), + 25: + dict( + name='lateral_left_bow', + id=25, + color=[255, 255, 255], + type='upper', + swap='lateral_right_bow'), + 26: + dict( + name='medial_left_wrist', + id=26, + color=[255, 255, 255], + type='upper', + swap='medial_right_wrist'), + 27: + dict( + name='lateral_left_wrist', + id=27, + color=[255, 255, 255], + type='upper', + swap='lateral_right_wrist'), + 28: + dict( + name='medial_right_hip', + id=28, + color=[255, 255, 255], + type='lower', + swap='medial_left_hip'), + 29: + dict( + name='lateral_right_hip', + id=29, + color=[255, 255, 255], + type='lower', + swap='lateral_left_hip'), + 30: + dict( + name='medial_right_knee', + id=30, + color=[255, 255, 255], + type='lower', + swap='medial_left_knee'), + 31: + dict( + name='lateral_right_knee', + id=31, + color=[255, 255, 255], + type='lower', + swap='lateral_left_knee'), + 32: + dict( + name='medial_right_ankle', + id=32, + color=[255, 255, 255], + type='lower', + swap='medial_left_ankle'), + 33: + dict( + name='lateral_right_ankle', + id=33, + color=[255, 255, 255], + type='lower', + swap='lateral_left_ankle'), + 34: + dict( + name='medial_left_hip', + id=34, + color=[255, 255, 255], + type='lower', + swap='medial_right_hip'), + 35: + dict( + name='lateral_left_hip', + id=35, + color=[255, 255, 255], + type='lower', + swap='lateral_right_hip'), + 36: + dict( + name='medial_left_knee', + id=36, + color=[255, 255, 255], + type='lower', + swap='medial_right_knee'), + 37: + dict( + name='lateral_left_knee', + id=37, + color=[255, 255, 255], + type='lower', + swap='lateral_right_knee'), + 38: + dict( + name='medial_left_ankle', + id=38, + color=[255, 255, 255], + type='lower', + swap='medial_right_ankle'), + 39: + dict( + name='lateral_left_ankle', + id=39, + color=[255, 255, 255], + type='lower', + swap='lateral_right_ankle'), + }, + skeleton_info={ + 0: + dict(link=('head', 'neck'), id=0, color=[51, 153, 255]), + 1: + dict(link=('neck', 'left_shoulder'), id=1, color=[51, 153, 255]), + 2: + dict(link=('neck', 'right_shoulder'), id=2, color=[51, 153, 255]), + 3: + dict(link=('left_shoulder', 'left_elbow'), id=3, color=[0, 255, 0]), + 4: + dict( + link=('right_shoulder', 'right_elbow'), id=4, color=[255, 128, 0]), + 5: + dict(link=('left_elbow', 'left_wrist'), id=5, color=[0, 255, 0]), + 6: + dict(link=('right_elbow', 'right_wrist'), id=6, color=[255, 128, 0]), + 7: + dict(link=('left_shoulder', 'left_hip'), id=7, color=[51, 153, 255]), + 8: + dict(link=('right_shoulder', 'right_hip'), id=8, color=[51, 153, 255]), + 9: + dict(link=('left_hip', 'right_hip'), id=9, color=[51, 153, 255]), + 10: + dict(link=('left_hip', 'left_knee'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_hip', 'right_knee'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_knee', 'left_ankle'), id=12, color=[0, 255, 0]), + 13: + dict(link=('right_knee', 'right_ankle'), id=13, color=[255, 128, 0]), + 14: + dict(link=('right_neck', 'left_neck'), id=14, color=[255, 255, 255]), + 15: + dict( + link=('medial_right_shoulder', 'lateral_right_shoulder'), + id=15, + color=[255, 255, 255]), + 16: + dict( + link=('medial_right_bow', 'lateral_right_bow'), + id=16, + color=[255, 255, 255]), + 17: + dict( + link=('medial_right_wrist', 'lateral_right_wrist'), + id=17, + color=[255, 255, 255]), + 18: + dict( + link=('medial_left_shoulder', 'lateral_left_shoulder'), + id=18, + color=[255, 255, 255]), + 19: + dict( + link=('medial_left_bow', 'lateral_left_bow'), + id=19, + color=[255, 255, 255]), + 20: + dict( + link=('medial_left_wrist', 'lateral_left_wrist'), + id=20, + color=[255, 255, 255]), + 21: + dict( + link=('medial_right_hip', 'lateral_right_hip'), + id=21, + color=[255, 255, 255]), + 22: + dict( + link=('medial_right_knee', 'lateral_right_knee'), + id=22, + color=[255, 255, 255]), + 23: + dict( + link=('medial_right_ankle', 'lateral_right_ankle'), + id=23, + color=[255, 255, 255]), + 24: + dict( + link=('medial_left_hip', 'lateral_left_hip'), + id=24, + color=[255, 255, 255]), + 25: + dict( + link=('medial_left_knee', 'lateral_left_knee'), + id=25, + color=[255, 255, 255]), + 26: + dict( + link=('medial_left_ankle', 'lateral_left_ankle'), + id=26, + color=[255, 255, 255]) + }, + joint_weights=[1.] * 40, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ochuman.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ochuman.py new file mode 100644 index 0000000000000000000000000000000000000000..e6e86ba48dbecc43a7258ff7a9e80d572ef6a806 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/ochuman.py @@ -0,0 +1,181 @@ +dataset_info = dict( + dataset_name='ochuman', + paper_info=dict( + author='Zhang, Song-Hai and Li, Ruilong and Dong, Xin and ' + 'Rosin, Paul and Cai, Zixi and Han, Xi and ' + 'Yang, Dingcheng and Huang, Haozhi and Hu, Shi-Min', + title='Pose2seg: Detection free human instance segmentation', + container='Proceedings of the IEEE conference on computer ' + 'vision and pattern recognition', + year='2019', + homepage='https://github.com/liruilong940607/OCHumanApi', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/onehand10k.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/onehand10k.py new file mode 100644 index 0000000000000000000000000000000000000000..833f1863d5afbefa2a93d7c81dd4ea6034e003f8 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/onehand10k.py @@ -0,0 +1,142 @@ +dataset_info = dict( + dataset_name='onehand10k', + paper_info=dict( + author='Wang, Yangang and Peng, Cong and Liu, Yebin', + title='Mask-pose cascaded cnn for 2d hand pose estimation ' + 'from single color image', + container='IEEE Transactions on Circuits and Systems ' + 'for Video Technology', + year='2018', + homepage='https://www.yangangwang.com/papers/WANG-MCC-2018-10.html', + ), + keypoint_info={ + 0: + dict(name='wrist', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='thumb1', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb3', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict(name='thumb4', id=4, color=[255, 128, 0], type='', swap=''), + 5: + dict( + name='forefinger1', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger3', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='forefinger4', id=8, color=[255, 153, 255], type='', swap=''), + 9: + dict( + name='middle_finger1', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger3', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='middle_finger4', + id=12, + color=[102, 178, 255], + type='', + swap=''), + 13: + dict( + name='ring_finger1', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger3', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict( + name='ring_finger4', id=16, color=[255, 51, 51], type='', swap=''), + 17: + dict(name='pinky_finger1', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger3', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='pinky_finger4', id=20, color=[0, 255, 0], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_body3d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_body3d.py new file mode 100644 index 0000000000000000000000000000000000000000..662340951d69395aeb44dc9a01826bed511232ab --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_body3d.py @@ -0,0 +1,160 @@ +dataset_info = dict( + dataset_name='panoptic_pose_3d', + paper_info=dict( + author='Joo, Hanbyul and Simon, Tomas and Li, Xulong' + 'and Liu, Hao and Tan, Lei and Gui, Lin and Banerjee, Sean' + 'and Godisart, Timothy and Nabbe, Bart and Matthews, Iain' + 'and Kanade, Takeo and Nobuhara, Shohei and Sheikh, Yaser', + title='Panoptic Studio: A Massively Multiview System ' + 'for Interaction Motion Capture', + container='IEEE Transactions on Pattern Analysis' + ' and Machine Intelligence', + year='2017', + homepage='http://domedb.perception.cs.cmu.edu', + ), + keypoint_info={ + 0: + dict(name='neck', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict(name='nose', id=1, color=[51, 153, 255], type='upper', swap=''), + 2: + dict(name='mid_hip', id=2, color=[0, 255, 0], type='lower', swap=''), + 3: + dict( + name='left_shoulder', + id=3, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 4: + dict( + name='left_elbow', + id=4, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 5: + dict( + name='left_wrist', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 6: + dict( + name='left_hip', + id=6, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 7: + dict( + name='left_knee', + id=7, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 8: + dict( + name='left_ankle', + id=8, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 9: + dict( + name='right_shoulder', + id=9, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 10: + dict( + name='right_elbow', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 11: + dict( + name='right_wrist', + id=11, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='right_knee', + id=13, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 14: + dict( + name='right_ankle', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_ankle'), + 15: + dict( + name='left_eye', + id=15, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 16: + dict( + name='left_ear', + id=16, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 17: + dict( + name='right_eye', + id=17, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 18: + dict( + name='right_ear', + id=18, + color=[51, 153, 255], + type='upper', + swap='left_ear') + }, + skeleton_info={ + 0: dict(link=('nose', 'neck'), id=0, color=[51, 153, 255]), + 1: dict(link=('neck', 'left_shoulder'), id=1, color=[0, 255, 0]), + 2: dict(link=('neck', 'right_shoulder'), id=2, color=[255, 128, 0]), + 3: dict(link=('left_shoulder', 'left_elbow'), id=3, color=[0, 255, 0]), + 4: dict( + link=('right_shoulder', 'right_elbow'), id=4, color=[255, 128, 0]), + 5: dict(link=('left_elbow', 'left_wrist'), id=5, color=[0, 255, 0]), + 6: + dict(link=('right_elbow', 'right_wrist'), id=6, color=[255, 128, 0]), + 7: dict(link=('left_ankle', 'left_knee'), id=7, color=[0, 255, 0]), + 8: dict(link=('left_knee', 'left_hip'), id=8, color=[0, 255, 0]), + 9: dict(link=('right_ankle', 'right_knee'), id=9, color=[255, 128, 0]), + 10: dict(link=('right_knee', 'right_hip'), id=10, color=[255, 128, 0]), + 11: dict(link=('mid_hip', 'left_hip'), id=11, color=[0, 255, 0]), + 12: dict(link=('mid_hip', 'right_hip'), id=12, color=[255, 128, 0]), + 13: dict(link=('mid_hip', 'neck'), id=13, color=[51, 153, 255]), + }, + joint_weights=[ + 1.0, 1.0, 1.0, 1.0, 1.2, 1.5, 1.0, 1.2, 1.5, 1.0, 1.2, 1.5, 1.0, 1.2, + 1.5, 1.0, 1.0, 1.0, 1.0 + ], + sigmas=[ + 0.026, 0.026, 0.107, 0.079, 0.072, 0.062, 0.107, 0.087, 0.089, 0.079, + 0.072, 0.062, 0.107, 0.087, 0.089, 0.025, 0.035, 0.025, 0.035 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_hand2d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_hand2d.py new file mode 100644 index 0000000000000000000000000000000000000000..5d01b9a02434b3b98fbd5ea5ada5056fab03dfba --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/panoptic_hand2d.py @@ -0,0 +1,143 @@ +dataset_info = dict( + dataset_name='panoptic_hand2d', + paper_info=dict( + author='Simon, Tomas and Joo, Hanbyul and ' + 'Matthews, Iain and Sheikh, Yaser', + title='Hand keypoint detection in single images using ' + 'multiview bootstrapping', + container='Proceedings of the IEEE conference on ' + 'Computer Vision and Pattern Recognition', + year='2017', + homepage='http://domedb.perception.cs.cmu.edu/handdb.html', + ), + keypoint_info={ + 0: + dict(name='wrist', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='thumb1', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb3', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict(name='thumb4', id=4, color=[255, 128, 0], type='', swap=''), + 5: + dict( + name='forefinger1', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger3', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='forefinger4', id=8, color=[255, 153, 255], type='', swap=''), + 9: + dict( + name='middle_finger1', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger3', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='middle_finger4', + id=12, + color=[102, 178, 255], + type='', + swap=''), + 13: + dict( + name='ring_finger1', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger3', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict( + name='ring_finger4', id=16, color=[255, 51, 51], type='', swap=''), + 17: + dict(name='pinky_finger1', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger3', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='pinky_finger4', id=20, color=[0, 255, 0], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/posetrack18.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/posetrack18.py new file mode 100644 index 0000000000000000000000000000000000000000..18e18911bcd3a3e7984933c5b658959ab10be55b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/posetrack18.py @@ -0,0 +1,176 @@ +dataset_info = dict( + dataset_name='posetrack18', + paper_info=dict( + author='Andriluka, Mykhaylo and Iqbal, Umar and ' + 'Insafutdinov, Eldar and Pishchulin, Leonid and ' + 'Milan, Anton and Gall, Juergen and Schiele, Bernt', + title='Posetrack: A benchmark for human pose estimation and tracking', + container='Proceedings of the IEEE Conference on ' + 'Computer Vision and Pattern Recognition', + year='2018', + homepage='https://posetrack.net/users/download.php', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='head_bottom', + id=1, + color=[51, 153, 255], + type='upper', + swap=''), + 2: + dict( + name='head_top', id=2, color=[51, 153, 255], type='upper', + swap=''), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('nose', 'head_bottom'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'head_top'), id=13, color=[51, 153, 255]), + 14: + dict( + link=('head_bottom', 'left_shoulder'), id=14, color=[51, 153, + 255]), + 15: + dict( + link=('head_bottom', 'right_shoulder'), + id=15, + color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089 + ]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/rhd2d.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/rhd2d.py new file mode 100644 index 0000000000000000000000000000000000000000..d5df97eee1364895d3ac15019c049cbb512e51bf --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/rhd2d.py @@ -0,0 +1,141 @@ +dataset_info = dict( + dataset_name='rhd2d', + paper_info=dict( + author='Christian Zimmermann and Thomas Brox', + title='Learning to Estimate 3D Hand Pose from Single RGB Images', + container='arXiv', + year='2017', + homepage='https://lmb.informatik.uni-freiburg.de/resources/' + 'datasets/RenderedHandposeDataset.en.html', + ), + keypoint_info={ + 0: + dict(name='wrist', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='thumb1', id=1, color=[255, 128, 0], type='', swap=''), + 2: + dict(name='thumb2', id=2, color=[255, 128, 0], type='', swap=''), + 3: + dict(name='thumb3', id=3, color=[255, 128, 0], type='', swap=''), + 4: + dict(name='thumb4', id=4, color=[255, 128, 0], type='', swap=''), + 5: + dict( + name='forefinger1', id=5, color=[255, 153, 255], type='', swap=''), + 6: + dict( + name='forefinger2', id=6, color=[255, 153, 255], type='', swap=''), + 7: + dict( + name='forefinger3', id=7, color=[255, 153, 255], type='', swap=''), + 8: + dict( + name='forefinger4', id=8, color=[255, 153, 255], type='', swap=''), + 9: + dict( + name='middle_finger1', + id=9, + color=[102, 178, 255], + type='', + swap=''), + 10: + dict( + name='middle_finger2', + id=10, + color=[102, 178, 255], + type='', + swap=''), + 11: + dict( + name='middle_finger3', + id=11, + color=[102, 178, 255], + type='', + swap=''), + 12: + dict( + name='middle_finger4', + id=12, + color=[102, 178, 255], + type='', + swap=''), + 13: + dict( + name='ring_finger1', id=13, color=[255, 51, 51], type='', swap=''), + 14: + dict( + name='ring_finger2', id=14, color=[255, 51, 51], type='', swap=''), + 15: + dict( + name='ring_finger3', id=15, color=[255, 51, 51], type='', swap=''), + 16: + dict( + name='ring_finger4', id=16, color=[255, 51, 51], type='', swap=''), + 17: + dict(name='pinky_finger1', id=17, color=[0, 255, 0], type='', swap=''), + 18: + dict(name='pinky_finger2', id=18, color=[0, 255, 0], type='', swap=''), + 19: + dict(name='pinky_finger3', id=19, color=[0, 255, 0], type='', swap=''), + 20: + dict(name='pinky_finger4', id=20, color=[0, 255, 0], type='', swap='') + }, + skeleton_info={ + 0: + dict(link=('wrist', 'thumb1'), id=0, color=[255, 128, 0]), + 1: + dict(link=('thumb1', 'thumb2'), id=1, color=[255, 128, 0]), + 2: + dict(link=('thumb2', 'thumb3'), id=2, color=[255, 128, 0]), + 3: + dict(link=('thumb3', 'thumb4'), id=3, color=[255, 128, 0]), + 4: + dict(link=('wrist', 'forefinger1'), id=4, color=[255, 153, 255]), + 5: + dict(link=('forefinger1', 'forefinger2'), id=5, color=[255, 153, 255]), + 6: + dict(link=('forefinger2', 'forefinger3'), id=6, color=[255, 153, 255]), + 7: + dict(link=('forefinger3', 'forefinger4'), id=7, color=[255, 153, 255]), + 8: + dict(link=('wrist', 'middle_finger1'), id=8, color=[102, 178, 255]), + 9: + dict( + link=('middle_finger1', 'middle_finger2'), + id=9, + color=[102, 178, 255]), + 10: + dict( + link=('middle_finger2', 'middle_finger3'), + id=10, + color=[102, 178, 255]), + 11: + dict( + link=('middle_finger3', 'middle_finger4'), + id=11, + color=[102, 178, 255]), + 12: + dict(link=('wrist', 'ring_finger1'), id=12, color=[255, 51, 51]), + 13: + dict( + link=('ring_finger1', 'ring_finger2'), id=13, color=[255, 51, 51]), + 14: + dict( + link=('ring_finger2', 'ring_finger3'), id=14, color=[255, 51, 51]), + 15: + dict( + link=('ring_finger3', 'ring_finger4'), id=15, color=[255, 51, 51]), + 16: + dict(link=('wrist', 'pinky_finger1'), id=16, color=[0, 255, 0]), + 17: + dict( + link=('pinky_finger1', 'pinky_finger2'), id=17, color=[0, 255, 0]), + 18: + dict( + link=('pinky_finger2', 'pinky_finger3'), id=18, color=[0, 255, 0]), + 19: + dict( + link=('pinky_finger3', 'pinky_finger4'), id=19, color=[0, 255, 0]) + }, + joint_weights=[1.] * 21, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/wflw.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/wflw.py new file mode 100644 index 0000000000000000000000000000000000000000..63fe47aaf1f0941a3fefaeed7632fb13082186e2 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/wflw.py @@ -0,0 +1,582 @@ +dataset_info = dict( + dataset_name='wflw', + paper_info=dict( + author='Wu, Wayne and Qian, Chen and Yang, Shuo and Wang, ' + 'Quan and Cai, Yici and Zhou, Qiang', + title='Look at boundary: A boundary-aware face alignment algorithm', + container='Proceedings of the IEEE conference on computer ' + 'vision and pattern recognition', + year='2018', + homepage='https://wywu.github.io/projects/LAB/WFLW.html', + ), + keypoint_info={ + 0: + dict( + name='kpt-0', id=0, color=[255, 255, 255], type='', swap='kpt-32'), + 1: + dict( + name='kpt-1', id=1, color=[255, 255, 255], type='', swap='kpt-31'), + 2: + dict( + name='kpt-2', id=2, color=[255, 255, 255], type='', swap='kpt-30'), + 3: + dict( + name='kpt-3', id=3, color=[255, 255, 255], type='', swap='kpt-29'), + 4: + dict( + name='kpt-4', id=4, color=[255, 255, 255], type='', swap='kpt-28'), + 5: + dict( + name='kpt-5', id=5, color=[255, 255, 255], type='', swap='kpt-27'), + 6: + dict( + name='kpt-6', id=6, color=[255, 255, 255], type='', swap='kpt-26'), + 7: + dict( + name='kpt-7', id=7, color=[255, 255, 255], type='', swap='kpt-25'), + 8: + dict( + name='kpt-8', id=8, color=[255, 255, 255], type='', swap='kpt-24'), + 9: + dict( + name='kpt-9', id=9, color=[255, 255, 255], type='', swap='kpt-23'), + 10: + dict( + name='kpt-10', + id=10, + color=[255, 255, 255], + type='', + swap='kpt-22'), + 11: + dict( + name='kpt-11', + id=11, + color=[255, 255, 255], + type='', + swap='kpt-21'), + 12: + dict( + name='kpt-12', + id=12, + color=[255, 255, 255], + type='', + swap='kpt-20'), + 13: + dict( + name='kpt-13', + id=13, + color=[255, 255, 255], + type='', + swap='kpt-19'), + 14: + dict( + name='kpt-14', + id=14, + color=[255, 255, 255], + type='', + swap='kpt-18'), + 15: + dict( + name='kpt-15', + id=15, + color=[255, 255, 255], + type='', + swap='kpt-17'), + 16: + dict(name='kpt-16', id=16, color=[255, 255, 255], type='', swap=''), + 17: + dict( + name='kpt-17', + id=17, + color=[255, 255, 255], + type='', + swap='kpt-15'), + 18: + dict( + name='kpt-18', + id=18, + color=[255, 255, 255], + type='', + swap='kpt-14'), + 19: + dict( + name='kpt-19', + id=19, + color=[255, 255, 255], + type='', + swap='kpt-13'), + 20: + dict( + name='kpt-20', + id=20, + color=[255, 255, 255], + type='', + swap='kpt-12'), + 21: + dict( + name='kpt-21', + id=21, + color=[255, 255, 255], + type='', + swap='kpt-11'), + 22: + dict( + name='kpt-22', + id=22, + color=[255, 255, 255], + type='', + swap='kpt-10'), + 23: + dict( + name='kpt-23', id=23, color=[255, 255, 255], type='', + swap='kpt-9'), + 24: + dict( + name='kpt-24', id=24, color=[255, 255, 255], type='', + swap='kpt-8'), + 25: + dict( + name='kpt-25', id=25, color=[255, 255, 255], type='', + swap='kpt-7'), + 26: + dict( + name='kpt-26', id=26, color=[255, 255, 255], type='', + swap='kpt-6'), + 27: + dict( + name='kpt-27', id=27, color=[255, 255, 255], type='', + swap='kpt-5'), + 28: + dict( + name='kpt-28', id=28, color=[255, 255, 255], type='', + swap='kpt-4'), + 29: + dict( + name='kpt-29', id=29, color=[255, 255, 255], type='', + swap='kpt-3'), + 30: + dict( + name='kpt-30', id=30, color=[255, 255, 255], type='', + swap='kpt-2'), + 31: + dict( + name='kpt-31', id=31, color=[255, 255, 255], type='', + swap='kpt-1'), + 32: + dict( + name='kpt-32', id=32, color=[255, 255, 255], type='', + swap='kpt-0'), + 33: + dict( + name='kpt-33', + id=33, + color=[255, 255, 255], + type='', + swap='kpt-46'), + 34: + dict( + name='kpt-34', + id=34, + color=[255, 255, 255], + type='', + swap='kpt-45'), + 35: + dict( + name='kpt-35', + id=35, + color=[255, 255, 255], + type='', + swap='kpt-44'), + 36: + dict( + name='kpt-36', + id=36, + color=[255, 255, 255], + type='', + swap='kpt-43'), + 37: + dict( + name='kpt-37', + id=37, + color=[255, 255, 255], + type='', + swap='kpt-42'), + 38: + dict( + name='kpt-38', + id=38, + color=[255, 255, 255], + type='', + swap='kpt-50'), + 39: + dict( + name='kpt-39', + id=39, + color=[255, 255, 255], + type='', + swap='kpt-49'), + 40: + dict( + name='kpt-40', + id=40, + color=[255, 255, 255], + type='', + swap='kpt-48'), + 41: + dict( + name='kpt-41', + id=41, + color=[255, 255, 255], + type='', + swap='kpt-47'), + 42: + dict( + name='kpt-42', + id=42, + color=[255, 255, 255], + type='', + swap='kpt-37'), + 43: + dict( + name='kpt-43', + id=43, + color=[255, 255, 255], + type='', + swap='kpt-36'), + 44: + dict( + name='kpt-44', + id=44, + color=[255, 255, 255], + type='', + swap='kpt-35'), + 45: + dict( + name='kpt-45', + id=45, + color=[255, 255, 255], + type='', + swap='kpt-34'), + 46: + dict( + name='kpt-46', + id=46, + color=[255, 255, 255], + type='', + swap='kpt-33'), + 47: + dict( + name='kpt-47', + id=47, + color=[255, 255, 255], + type='', + swap='kpt-41'), + 48: + dict( + name='kpt-48', + id=48, + color=[255, 255, 255], + type='', + swap='kpt-40'), + 49: + dict( + name='kpt-49', + id=49, + color=[255, 255, 255], + type='', + swap='kpt-39'), + 50: + dict( + name='kpt-50', + id=50, + color=[255, 255, 255], + type='', + swap='kpt-38'), + 51: + dict(name='kpt-51', id=51, color=[255, 255, 255], type='', swap=''), + 52: + dict(name='kpt-52', id=52, color=[255, 255, 255], type='', swap=''), + 53: + dict(name='kpt-53', id=53, color=[255, 255, 255], type='', swap=''), + 54: + dict(name='kpt-54', id=54, color=[255, 255, 255], type='', swap=''), + 55: + dict( + name='kpt-55', + id=55, + color=[255, 255, 255], + type='', + swap='kpt-59'), + 56: + dict( + name='kpt-56', + id=56, + color=[255, 255, 255], + type='', + swap='kpt-58'), + 57: + dict(name='kpt-57', id=57, color=[255, 255, 255], type='', swap=''), + 58: + dict( + name='kpt-58', + id=58, + color=[255, 255, 255], + type='', + swap='kpt-56'), + 59: + dict( + name='kpt-59', + id=59, + color=[255, 255, 255], + type='', + swap='kpt-55'), + 60: + dict( + name='kpt-60', + id=60, + color=[255, 255, 255], + type='', + swap='kpt-72'), + 61: + dict( + name='kpt-61', + id=61, + color=[255, 255, 255], + type='', + swap='kpt-71'), + 62: + dict( + name='kpt-62', + id=62, + color=[255, 255, 255], + type='', + swap='kpt-70'), + 63: + dict( + name='kpt-63', + id=63, + color=[255, 255, 255], + type='', + swap='kpt-69'), + 64: + dict( + name='kpt-64', + id=64, + color=[255, 255, 255], + type='', + swap='kpt-68'), + 65: + dict( + name='kpt-65', + id=65, + color=[255, 255, 255], + type='', + swap='kpt-75'), + 66: + dict( + name='kpt-66', + id=66, + color=[255, 255, 255], + type='', + swap='kpt-74'), + 67: + dict( + name='kpt-67', + id=67, + color=[255, 255, 255], + type='', + swap='kpt-73'), + 68: + dict( + name='kpt-68', + id=68, + color=[255, 255, 255], + type='', + swap='kpt-64'), + 69: + dict( + name='kpt-69', + id=69, + color=[255, 255, 255], + type='', + swap='kpt-63'), + 70: + dict( + name='kpt-70', + id=70, + color=[255, 255, 255], + type='', + swap='kpt-62'), + 71: + dict( + name='kpt-71', + id=71, + color=[255, 255, 255], + type='', + swap='kpt-61'), + 72: + dict( + name='kpt-72', + id=72, + color=[255, 255, 255], + type='', + swap='kpt-60'), + 73: + dict( + name='kpt-73', + id=73, + color=[255, 255, 255], + type='', + swap='kpt-67'), + 74: + dict( + name='kpt-74', + id=74, + color=[255, 255, 255], + type='', + swap='kpt-66'), + 75: + dict( + name='kpt-75', + id=75, + color=[255, 255, 255], + type='', + swap='kpt-65'), + 76: + dict( + name='kpt-76', + id=76, + color=[255, 255, 255], + type='', + swap='kpt-82'), + 77: + dict( + name='kpt-77', + id=77, + color=[255, 255, 255], + type='', + swap='kpt-81'), + 78: + dict( + name='kpt-78', + id=78, + color=[255, 255, 255], + type='', + swap='kpt-80'), + 79: + dict(name='kpt-79', id=79, color=[255, 255, 255], type='', swap=''), + 80: + dict( + name='kpt-80', + id=80, + color=[255, 255, 255], + type='', + swap='kpt-78'), + 81: + dict( + name='kpt-81', + id=81, + color=[255, 255, 255], + type='', + swap='kpt-77'), + 82: + dict( + name='kpt-82', + id=82, + color=[255, 255, 255], + type='', + swap='kpt-76'), + 83: + dict( + name='kpt-83', + id=83, + color=[255, 255, 255], + type='', + swap='kpt-87'), + 84: + dict( + name='kpt-84', + id=84, + color=[255, 255, 255], + type='', + swap='kpt-86'), + 85: + dict(name='kpt-85', id=85, color=[255, 255, 255], type='', swap=''), + 86: + dict( + name='kpt-86', + id=86, + color=[255, 255, 255], + type='', + swap='kpt-84'), + 87: + dict( + name='kpt-87', + id=87, + color=[255, 255, 255], + type='', + swap='kpt-83'), + 88: + dict( + name='kpt-88', + id=88, + color=[255, 255, 255], + type='', + swap='kpt-92'), + 89: + dict( + name='kpt-89', + id=89, + color=[255, 255, 255], + type='', + swap='kpt-91'), + 90: + dict(name='kpt-90', id=90, color=[255, 255, 255], type='', swap=''), + 91: + dict( + name='kpt-91', + id=91, + color=[255, 255, 255], + type='', + swap='kpt-89'), + 92: + dict( + name='kpt-92', + id=92, + color=[255, 255, 255], + type='', + swap='kpt-88'), + 93: + dict( + name='kpt-93', + id=93, + color=[255, 255, 255], + type='', + swap='kpt-95'), + 94: + dict(name='kpt-94', id=94, color=[255, 255, 255], type='', swap=''), + 95: + dict( + name='kpt-95', + id=95, + color=[255, 255, 255], + type='', + swap='kpt-93'), + 96: + dict( + name='kpt-96', + id=96, + color=[255, 255, 255], + type='', + swap='kpt-97'), + 97: + dict( + name='kpt-97', + id=97, + color=[255, 255, 255], + type='', + swap='kpt-96') + }, + skeleton_info={}, + joint_weights=[1.] * 98, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/zebra.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/zebra.py new file mode 100644 index 0000000000000000000000000000000000000000..bc4f9ecd75c4df458181aca442ff6b74864737fb --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/datasets/zebra.py @@ -0,0 +1,64 @@ +dataset_info = dict( + dataset_name='zebra', + paper_info=dict( + author='Graving, Jacob M and Chae, Daniel and Naik, Hemal and ' + 'Li, Liang and Koger, Benjamin and Costelloe, Blair R and ' + 'Couzin, Iain D', + title='DeepPoseKit, a software toolkit for fast and robust ' + 'animal pose estimation using deep learning', + container='Elife', + year='2019', + homepage='https://github.com/jgraving/DeepPoseKit-Data', + ), + keypoint_info={ + 0: + dict(name='snout', id=0, color=[255, 255, 255], type='', swap=''), + 1: + dict(name='head', id=1, color=[255, 255, 255], type='', swap=''), + 2: + dict(name='neck', id=2, color=[255, 255, 255], type='', swap=''), + 3: + dict( + name='forelegL1', + id=3, + color=[255, 255, 255], + type='', + swap='forelegR1'), + 4: + dict( + name='forelegR1', + id=4, + color=[255, 255, 255], + type='', + swap='forelegL1'), + 5: + dict( + name='hindlegL1', + id=5, + color=[255, 255, 255], + type='', + swap='hindlegR1'), + 6: + dict( + name='hindlegR1', + id=6, + color=[255, 255, 255], + type='', + swap='hindlegL1'), + 7: + dict(name='tailbase', id=7, color=[255, 255, 255], type='', swap=''), + 8: + dict(name='tailtip', id=8, color=[255, 255, 255], type='', swap='') + }, + skeleton_info={ + 0: dict(link=('head', 'snout'), id=0, color=[255, 255, 255]), + 1: dict(link=('neck', 'head'), id=1, color=[255, 255, 255]), + 2: dict(link=('forelegL1', 'neck'), id=2, color=[255, 255, 255]), + 3: dict(link=('forelegR1', 'neck'), id=3, color=[255, 255, 255]), + 4: dict(link=('hindlegL1', 'tailbase'), id=4, color=[255, 255, 255]), + 5: dict(link=('hindlegR1', 'tailbase'), id=5, color=[255, 255, 255]), + 6: dict(link=('tailbase', 'neck'), id=6, color=[255, 255, 255]), + 7: dict(link=('tailtip', 'tailbase'), id=7, color=[255, 255, 255]) + }, + joint_weights=[1.] * 9, + sigmas=[]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/default_runtime.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/default_runtime.py new file mode 100644 index 0000000000000000000000000000000000000000..42dd37f8ae716de1cf1a26bb8ab1a1fb4430b01c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/default_runtime.py @@ -0,0 +1,19 @@ +checkpoint_config = dict(interval=10) + +log_config = dict( + interval=50, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook') + ]) + +log_level = 'INFO' +load_from = None +resume_from = None +dist_params = dict(backend='nccl') +workflow = [('train', 1)] + +# disable opencv multithreading to avoid system being overloaded +opencv_num_threads = 0 +# set multi-process start method as `fork` to speed up the training +mp_start_method = 'fork' diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/filters/gausian_filter.py b/ViTPose/easy_ViTPose/easy_ViTPose/configs/_base_/filters/gausian_filter.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/COCO.py b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/COCO.py new file mode 100644 index 0000000000000000000000000000000000000000..38bd55ac499e4bff480f3bc16f7a32fdd7f611f4 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/COCO.py @@ -0,0 +1,556 @@ +# Part of this code is derived/taken from https://github.com/leoxiaobin/deep-high-resolution-net.pytorch +import os +import sys +import pickle +import random + +import cv2 +import json_tricks as json +import numpy as np +from pycocotools.coco import COCO +from torchvision import transforms +import torchvision.transforms.functional as F +from tqdm import tqdm +from PIL import Image + +from .HumanPoseEstimation import HumanPoseEstimationDataset as Dataset + +sys.path.append(os.path.dirname(os.path.dirname(__file__))) +from vit_utils.transform import fliplr_joints, affine_transform, get_affine_transform + +import numpy as np + + +class COCODataset(Dataset): + """ + COCODataset class. + """ + + def __init__(self, root_path="./datasets/COCO", data_version="train2017", + is_train=True, use_gt_bboxes=True, bbox_path="", + image_width=288, image_height=384, + scale=True, scale_factor=0.35, flip_prob=0.5, rotate_prob=0.5, rotation_factor=45., half_body_prob=0.3, + use_different_joints_weight=False, heatmap_sigma=3, soft_nms=False): + """ + Initializes a new COCODataset object. + + Image and annotation indexes are loaded and stored in memory. + Annotations are preprocessed to have a simple list of annotations to iterate over. + + Bounding boxes can be loaded from the ground truth or from a pickle file (in this case, no annotations are + provided). + + Args: + root_path (str): dataset root path. + Default: "./datasets/COCO" + data_version (str): desired version/folder of COCO. Possible options are "train2017", "val2017". + Default: "train2017" + is_train (bool): train or eval mode. If true, train mode is used. + Default: True + use_gt_bboxes (bool): use ground truth bounding boxes. If False, bbox_path is required. + Default: True + bbox_path (str): bounding boxes pickle file path. + Default: "" + image_width (int): image width. + Default: 288 + image_height (int): image height. + Default: ``384`` + color_rgb (bool): rgb or bgr color mode. If True, rgb color mode is used. + Default: True + scale (bool): scale mode. + Default: True + scale_factor (float): scale factor. + Default: 0.35 + flip_prob (float): flip probability. + Default: 0.5 + rotate_prob (float): rotate probability. + Default: 0.5 + rotation_factor (float): rotation factor. + Default: 45. + half_body_prob (float): half body probability. + Default: 0.3 + use_different_joints_weight (bool): use different joints weights. + If true, the following joints weights will be used: + [1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, 1.5] + Default: False + heatmap_sigma (float): sigma of the gaussian used to create the heatmap. + Default: 3 + soft_nms (bool): enable soft non-maximum suppression. + Default: False + """ + super(COCODataset, self).__init__() + + self.root_path = root_path + self.data_version = data_version + self.is_train = is_train + self.use_gt_bboxes = use_gt_bboxes + self.bbox_path = bbox_path + self.scale = scale # ToDo Check + self.scale_factor = scale_factor + self.flip_prob = flip_prob + self.rotate_prob = rotate_prob + self.rotation_factor = rotation_factor + self.half_body_prob = half_body_prob + self.use_different_joints_weight = use_different_joints_weight # ToDo Check + self.heatmap_sigma = heatmap_sigma + self.soft_nms = soft_nms + + # Image & annotation path + self.data_path = f"{root_path}/{data_version}" + self.annotation_path = f"{root_path}/annotations/person_keypoints_{data_version}.json" + + self.image_size = (image_width, image_height) + self.aspect_ratio = image_width * 1.0 / image_height + + self.heatmap_size = (int(image_width / 4), int(image_height / 4)) + self.heatmap_type = 'gaussian' + self.pixel_std = 200 # I don't understand the meaning of pixel_std (=200) in the original implementation + + self.num_joints = 25 + self.num_joints_half_body = 15 + + # eye, ear, shoulder, elbow, wrist, hip, knee, ankle + self.flip_pairs = [[1, 2], [3, 4], [6, 7], [8, 9], [10, 11], [12, 13], + [15, 16], [17, 18], [19, 22], [20, 23], [21, 24]] + self.upper_body_ids = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] + self.lower_body_ids = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] + self.joints_weight = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, + 1.5, 1.5, 1., 1., 1., 1.2, 1.2, 1.5, 1.5, + 1.5, 1.5, 1.5, 1.5, 1.5, + 1.5]).reshape((self.num_joints, 1)) + + self.transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), + ]) + + # Load COCO dataset - Create COCO object then load images and annotations + self.coco = COCO(self.annotation_path) + + # Create a list of annotations and the corresponding image (each image can contain more than one detection) + + """ Load bboxes and joints + - if self.use_gt_bboxes -> Load GT bboxes and joints + - else -> Load pre-predicted bboxes by a detector (as YOLOv3) and null joints + """ + + if not self.use_gt_bboxes: + """ + bboxes must be saved as the original COCO annotations + i.e. the format must be: + bboxes = { + '': [ + { + 'id': , # progressive id for debugging + 'clean_bbox': np.array([, , , ])} + }, + ... + ], + ... + } + """ + with open(self.bbox_path, 'rb') as fd: + bboxes = pickle.load(fd) + + self.data = [] + # load annotations for each image of COCO + for imgId in tqdm(self.coco.getImgIds(), desc="Prepare images, annotations ... "): + ann_ids = self.coco.getAnnIds(imgIds=imgId, iscrowd=False) # annotation ids + img = self.coco.loadImgs(imgId)[0] # load img + + if self.use_gt_bboxes: + objs = self.coco.loadAnns(ann_ids) + + # sanitize bboxes + valid_objs = [] + for obj in objs: + # Skip non-person objects (it should never happen) + if obj['category_id'] != 1: + continue + + # ignore objs without keypoints annotation + if max(obj['keypoints']) == 0 and max(obj['foot_kpts']) == 0: + continue + + x, y, w, h = obj['bbox'] + x1 = np.max((0, x)) + y1 = np.max((0, y)) + x2 = np.min((img['width'] - 1, x1 + np.max((0, w - 1)))) + y2 = np.min((img['height'] - 1, y1 + np.max((0, h - 1)))) + + # Use only valid bounding boxes + if obj['area'] > 0 and x2 >= x1 and y2 >= y1: + obj['clean_bbox'] = [x1, y1, x2 - x1, y2 - y1] + valid_objs.append(obj) + + objs = valid_objs + + else: + objs = bboxes[imgId] + + # for each annotation of this image, add the formatted annotation to self.data + for obj in objs: + joints = np.zeros((self.num_joints, 2), dtype=np.float) + joints_visibility = np.ones((self.num_joints, 2), dtype=np.float) + + # Add foot data to keypoints + obj['keypoints'].extend(obj['foot_kpts']) + + if self.use_gt_bboxes: + """ COCO pre-processing + + - Moved above + - Skip non-person objects (it should never happen) + if obj['category_id'] != 1: + continue + + # ignore objs without keypoints annotation + if max(obj['keypoints']) == 0: + continue + """ + + # Not all joints are already present, skip them + vjoints = list(range(self.num_joints)) + vjoints.remove(5) + vjoints.remove(14) + + for idx, pt in enumerate(vjoints): + if pt == 5 or pt == 14: + continue # Neck and hip are manually filled + joints[pt, 0] = obj['keypoints'][idx * 3 + 0] + joints[pt, 1] = obj['keypoints'][idx * 3 + 1] + t_vis = int(np.clip(obj['keypoints'][idx * 3 + 2], 0, 1)) + """ + - COCO: + if visibility == 0 -> keypoint is not in the image. + if visibility == 1 -> keypoint is in the image BUT not visible + (e.g. behind an object). + if visibility == 2 -> keypoint looks clearly + (i.e. it is not hidden). + """ + joints_visibility[pt, 0] = t_vis + joints_visibility[pt, 1] = t_vis + + center, scale = self._box2cs(obj['clean_bbox'][:4]) + + # Add neck and c-hip (check utils/visualization.py for keypoints) + joints[5, 0] = (joints[6, 0] + joints[7, 0]) / 2 + joints[5, 1] = (joints[6, 1] + joints[7, 1]) / 2 + joints_visibility[5, :] = min(joints_visibility[6, 0], + joints_visibility[7, 0]) + joints[14, 0] = (joints[12, 0] + joints[13, 0]) / 2 + joints[14, 1] = (joints[12, 1] + joints[13, 1]) / 2 + joints_visibility[14, :] = min(joints_visibility[12, 0], + joints_visibility[13, 0]) + + self.data.append({ + 'imgId': imgId, + 'annId': obj['id'], + 'imgPath': f"{self.root_path}/{self.data_version}/{imgId:012d}.jpg", + 'center': center, + 'scale': scale, + 'joints': joints, + 'joints_visibility': joints_visibility, + }) + + # Done check if we need prepare_data -> We should not + print('\nCOCO dataset loaded!') + + # Default values + self.bbox_thre = 1.0 + self.image_thre = 0.0 + self.in_vis_thre = 0.2 + self.nms_thre = 1.0 + self.oks_thre = 0.9 + + def __len__(self): + return len(self.data) + + def __getitem__(self, index): + # index = 0 + joints_data = self.data[index].copy() + + # Load image + try: + image = np.array(Image.open(joints_data['imgPath'])) + if image.ndim == 2: + # Some images are grayscale and will fail the trasform, convert to RGB + image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB) + except: + raise ValueError(f"Fail to read {joints_data['imgPath']}") + + joints = joints_data['joints'] + joints_vis = joints_data['joints_visibility'] + + c = joints_data['center'] + s = joints_data['scale'] + score = joints_data['score'] if 'score' in joints_data else 1 + r = 0 + + # Apply data augmentation + if self.is_train: + if (self.half_body_prob and random.random() < self.half_body_prob and + np.sum(joints_vis[:, 0]) > self.num_joints_half_body): + c_half_body, s_half_body = self._half_body_transform(joints, joints_vis) + + if c_half_body is not None and s_half_body is not None: + c, s = c_half_body, s_half_body + + sf = self.scale_factor + rf = self.rotation_factor + + if self.scale: + # A random scale factor in [1 - sf, 1 + sf] + s = s * np.clip(random.random() * sf + 1, 1 - sf, 1 + sf) + + if self.rotate_prob and random.random() < self.rotate_prob: + # A random rotation factor in [-2 * rf, 2 * rf] + r = np.clip(random.random() * rf, -rf * 2, rf * 2) + else: + r = 0 + + if self.flip_prob and random.random() < self.flip_prob: + image = image[:, ::-1, :] + joints, joints_vis = fliplr_joints(joints, joints_vis, + image.shape[1], + self.flip_pairs) + c[0] = image.shape[1] - c[0] - 1 + + # Apply affine transform on joints and image + trans = get_affine_transform(c, s, self.pixel_std, r, self.image_size) + image = cv2.warpAffine( + image, + trans, + (int(self.image_size[0]), int(self.image_size[1])), + flags=cv2.INTER_LINEAR + ) + + for i in range(self.num_joints): + if joints_vis[i, 0] > 0.: + joints[i, 0:2] = affine_transform(joints[i, 0:2], trans) + + # Convert image to tensor and normalize + if self.transform is not None: # I could remove this check + image = self.transform(image) + + target, target_weight = self._generate_target(joints, joints_vis) + + # Update metadata + joints_data['joints'] = joints + joints_data['joints_visibility'] = joints_vis + joints_data['center'] = c + joints_data['scale'] = s + joints_data['rotation'] = r + joints_data['score'] = score + + # from utils.visualization import draw_points_and_skeleton, joints_dict + # image = np.rollaxis(image.detach().cpu().numpy(), 0, 3) + # joints = np.hstack((joints[:, ::-1], joints_vis[:, 0][..., None])) + # image = draw_points_and_skeleton(image.copy(), joints, + # joints_dict()['coco']['skeleton'], + # person_index=0, + # points_color_palette='gist_rainbow', + # skeleton_color_palette='jet', + # points_palette_samples=10, + # confidence_threshold=0.4) + # cv2.imshow('', image) + # cv2.waitKey(0) + + return image, target.astype(np.float32), target_weight.astype(np.float32), joints_data + + + # Private methods + def _box2cs(self, box): + x, y, w, h = box[:4] + return self._xywh2cs(x, y, w, h) + + def _xywh2cs(self, x, y, w, h): + center = np.zeros((2,), dtype=np.float32) + center[0] = x + w * 0.5 + center[1] = y + h * 0.5 + + if w > self.aspect_ratio * h: + h = w * 1.0 / self.aspect_ratio + elif w < self.aspect_ratio * h: + w = h * self.aspect_ratio + scale = np.array( + [w * 1.0 / self.pixel_std, h * 1.0 / self.pixel_std], + dtype=np.float32) + if center[0] != -1: + scale = scale * 1.25 + + return center, scale + + def _half_body_transform(self, joints, joints_vis): + upper_joints = [] + lower_joints = [] + for joint_id in range(self.num_joints): + if joints_vis[joint_id][0] > 0: + if joint_id in self.upper_body_ids: + upper_joints.append(joints[joint_id]) + else: + lower_joints.append(joints[joint_id]) + + if random.random() < 0.5 and len(upper_joints) > 2: + selected_joints = upper_joints + else: + selected_joints = lower_joints \ + if len(lower_joints) > 2 else upper_joints + + if len(selected_joints) < 2: + return None, None + + selected_joints = np.array(selected_joints, dtype=np.float32) + center = selected_joints.mean(axis=0)[:2] + + left_top = np.amin(selected_joints, axis=0) + right_bottom = np.amax(selected_joints, axis=0) + + w = right_bottom[0] - left_top[0] + h = right_bottom[1] - left_top[1] + + if w > self.aspect_ratio * h: + h = w * 1.0 / self.aspect_ratio + elif w < self.aspect_ratio * h: + w = h * self.aspect_ratio + + scale = np.array( + [ + w * 1.0 / self.pixel_std, + h * 1.0 / self.pixel_std + ], + dtype=np.float32 + ) + + scale = scale * 1.5 + + return center, scale + + def _generate_target(self, joints, joints_vis): + """ + :param joints: [num_joints, 2] + :param joints_vis: [num_joints, 2] + :return: target, target_weight(1: visible, 0: invisible) + """ + target_weight = np.ones((self.num_joints, 1), dtype=np.float32) + target_weight[:, 0] = joints_vis[:, 0] + + if self.heatmap_type == 'gaussian': + target = np.zeros((self.num_joints, + self.heatmap_size[1], + self.heatmap_size[0]), + dtype=np.float32) + + tmp_size = self.heatmap_sigma * 3 + + for joint_id in range(self.num_joints): + feat_stride = np.asarray(self.image_size) / np.asarray(self.heatmap_size) + mu_x = int(joints[joint_id][0] / feat_stride[0] + 0.5) + mu_y = int(joints[joint_id][1] / feat_stride[1] + 0.5) + # Check that any part of the gaussian is in-bounds + ul = [int(mu_x - tmp_size), int(mu_y - tmp_size)] + br = [int(mu_x + tmp_size + 1), int(mu_y + tmp_size + 1)] + if ul[0] >= self.heatmap_size[0] or ul[1] >= self.heatmap_size[1] \ + or br[0] < 0 or br[1] < 0: + # If not, just return the image as is + target_weight[joint_id] = 0 + continue + + # # Generate gaussian + size = 2 * tmp_size + 1 + x = np.arange(0, size, 1, np.float32) + y = x[:, np.newaxis] + x0 = y0 = size // 2 + # The gaussian is not normalized, we want the center value to equal 1 + g = np.exp(- ((x - x0) ** 2 + (y - y0) ** 2) / (2 * self.heatmap_sigma ** 2)) + + # Usable gaussian range + g_x = max(0, -ul[0]), min(br[0], self.heatmap_size[0]) - ul[0] + g_y = max(0, -ul[1]), min(br[1], self.heatmap_size[1]) - ul[1] + # Image range + img_x = max(0, ul[0]), min(br[0], self.heatmap_size[0]) + img_y = max(0, ul[1]), min(br[1], self.heatmap_size[1]) + + v = target_weight[joint_id] + if v > 0.5: + target[joint_id][img_y[0]:img_y[1], img_x[0]:img_x[1]] = \ + g[g_y[0]:g_y[1], g_x[0]:g_x[1]] + else: + raise NotImplementedError + + if self.use_different_joints_weight: + target_weight = np.multiply(target_weight, self.joints_weight) + + return target, target_weight + + def _write_coco_keypoint_results(self, keypoints, res_file): + data_pack = [ + { + 'cat_id': 1, # 1 == 'person' + 'cls': 'person', + 'ann_type': 'keypoints', + 'keypoints': keypoints + } + ] + + results = self._coco_keypoint_results_one_category_kernel(data_pack[0]) + with open(res_file, 'w') as f: + json.dump(results, f, sort_keys=True, indent=4) + try: + json.load(open(res_file)) + except Exception: + content = [] + with open(res_file, 'r') as f: + for line in f: + content.append(line) + content[-1] = ']' + with open(res_file, 'w') as f: + for c in content: + f.write(c) + + def _coco_keypoint_results_one_category_kernel(self, data_pack): + cat_id = data_pack['cat_id'] + keypoints = data_pack['keypoints'] + cat_results = [] + + for img_kpts in keypoints: + if len(img_kpts) == 0: + continue + + _key_points = np.array([img_kpts[k]['keypoints'] for k in range(len(img_kpts))], dtype=np.float32) + key_points = np.zeros((_key_points.shape[0], self.num_joints * 3), dtype=np.float32) + + for ipt in range(self.num_joints): + key_points[:, ipt * 3 + 0] = _key_points[:, ipt, 0] + key_points[:, ipt * 3 + 1] = _key_points[:, ipt, 1] + key_points[:, ipt * 3 + 2] = _key_points[:, ipt, 2] # keypoints score. + + result = [ + { + 'image_id': img_kpts[k]['image'], + 'category_id': cat_id, + 'keypoints': list(key_points[k]), + 'score': img_kpts[k]['score'].astype(np.float32), + 'center': list(img_kpts[k]['center']), + 'scale': list(img_kpts[k]['scale']) + } + for k in range(len(img_kpts)) + ] + cat_results.extend(result) + + return cat_results + + +if __name__ == '__main__': + # from skimage import io + coco = COCODataset(root_path=f"{os.path.dirname(__file__)}/COCO", data_version="traincoex", rotate_prob=0., half_body_prob=0.) + item = coco[1] + # io.imsave("tmp.jpg", item[0].permute(1,2,0).numpy()) + print() + print(item[1].shape) + print('ok!!') + # img = np.clip(np.transpose(item[0].numpy(), (1, 2, 0))[:, :, ::-1] * np.asarray([0.229, 0.224, 0.225]) + + # np.asarray([0.485, 0.456, 0.406]), 0, 1) * 255 + # cv2.imwrite('./tmp.png', img.astype(np.uint8)) + # print(item[-1]) + pass diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/HumanPoseEstimation.py b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/HumanPoseEstimation.py new file mode 100644 index 0000000000000000000000000000000000000000..a9c2b621e400fff9633f8a20944ee41e5d993d8b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/HumanPoseEstimation.py @@ -0,0 +1,17 @@ +from torch.utils.data import Dataset + + +class HumanPoseEstimationDataset(Dataset): + """ + HumanPoseEstimationDataset class. + + Generic class for HPE datasets. + """ + def __init__(self): + pass + + def __len__(self): + pass + + def __getitem__(self, item): + pass \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/COCO.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/COCO.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74d15af73a67bb4d8077a9125e8fe80f47318ca8 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/COCO.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/HumanPoseEstimation.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/HumanPoseEstimation.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..733470d1647eea27421dce5623cec8dcc1cc5e2e Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/HumanPoseEstimation.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cbbf85be3ee361fd4536f05bdd308fc10ef99ad Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/datasets/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..cb8c3390b66cb2f8cfdbbd8119104152b760a01e --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/PKG-INFO @@ -0,0 +1,4 @@ +Metadata-Version: 2.1 +Name: easy-ViTPose +Version: 0.1 +License-File: LICENSE diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..021af7d90288d4d93299a88a2386c4e5ac7f413b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/SOURCES.txt @@ -0,0 +1,35 @@ +LICENSE +README.md +setup.py +src/easy_ViTPose.egg-info/PKG-INFO +src/easy_ViTPose.egg-info/SOURCES.txt +src/easy_ViTPose.egg-info/dependency_links.txt +src/easy_ViTPose.egg-info/top_level.txt +src/vit_models/__init__.py +src/vit_models/model.py +src/vit_models/optimizer.py +src/vit_models/losses/__init__.py +src/vit_models/losses/classfication_loss.py +src/vit_models/losses/heatmap_loss.py +src/vit_models/losses/mesh_loss.py +src/vit_models/losses/mse_loss.py +src/vit_models/losses/multi_loss_factory.py +src/vit_models/losses/regression_loss.py +src/vit_utils/__init__.py +src/vit_utils/dist_util.py +src/vit_utils/inference.py +src/vit_utils/logging.py +src/vit_utils/top_down_eval.py +src/vit_utils/train_valid_fn.py +src/vit_utils/transform.py +src/vit_utils/util.py +src/vit_utils/visualization.py +src/vit_utils/nms/__init__.py +src/vit_utils/nms/nms.py +src/vit_utils/nms/nms_ori.py +src/vit_utils/nms/setup_linux.py +src/vit_utils/post_processing/__init__.py +src/vit_utils/post_processing/group.py +src/vit_utils/post_processing/nms.py +src/vit_utils/post_processing/one_euro_filter.py +src/vit_utils/post_processing/post_transforms.py \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..d3f5a12faa99758192ecc4ed3fc22c9249232e86 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f19413a74506f34168662e139ec66327cc8a5481 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/easy_ViTPose.egg-info/top_level.txt @@ -0,0 +1,2 @@ +vit_models +vit_utils diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/inference.py b/ViTPose/easy_ViTPose/easy_ViTPose/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..ace72e5cfb9f577b1ca596de53ef10de42f4450b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/inference.py @@ -0,0 +1,337 @@ +import abc +import os +from typing import Optional +import typing + +import cv2 +import numpy as np +import torch + +from ultralytics import YOLO + +from .configs.ViTPose_common import data_cfg +from .sort import Sort +from .vit_models.model import ViTPose +from .vit_utils.inference import draw_bboxes, pad_image +from .vit_utils.top_down_eval import keypoints_from_heatmaps +from .vit_utils.util import dyn_model_import, infer_dataset_by_path +from .vit_utils.visualization import draw_points_and_skeleton, joints_dict + +try: + import torch_tensorrt +except ModuleNotFoundError: + pass + +try: + import onnxruntime +except ModuleNotFoundError: + pass + +__all__ = ['VitInference'] +np.bool = np.bool_ +MEAN = [0.485, 0.456, 0.406] +STD = [0.229, 0.224, 0.225] + + +DETC_TO_YOLO_YOLOC = { + 'human': [0], + 'cat': [15], + 'dog': [16], + 'horse': [17], + 'sheep': [18], + 'cow': [19], + 'elephant': [20], + 'bear': [21], + 'zebra': [22], + 'giraffe': [23], + 'animals': [15, 16, 17, 18, 19, 20, 21, 22, 23] +} + + +class VitInference: + """ + Class for performing inference using ViTPose models with YOLOv8 human detection and SORT tracking. + + Args: + model (str): Path to the ViT model file (.pth, .onnx, .engine). + yolo (str): Path of the YOLOv8 model to load. + model_name (str, optional): Name of the ViT model architecture to use. + Valid values are 's', 'b', 'l', 'h'. + Defaults to None, is necessary when using .pth checkpoints. + det_class (str, optional): the detection class. if None it is inferred by the dataset. + valid values are 'human', 'cat', 'dog', 'horse', 'sheep', + 'cow', 'elephant', 'bear', 'zebra', 'giraffe', + 'animals' (which is all previous but human) + dataset (str, optional): Name of the dataset. If None it's extracted from the file name. + Valid values are 'coco', 'coco_25', 'wholebody', 'mpii', + 'ap10k', 'apt36k', 'aic' + yolo_size (int, optional): Size of the input image for YOLOv8 model. Defaults to 320. + device (str, optional): Device to use for inference. Defaults to 'cuda' if available, else 'cpu'. + is_video (bool, optional): Flag indicating if the input is video. Defaults to False. + single_pose (bool, optional): Flag indicating if the video (on images this flag has no effect) + will contain a single pose. + In this case the SORT tracker is not used (increasing performance) + but people id tracking + won't be consistent among frames. + yolo_step (int, optional): The tracker can be used to predict the bboxes instead of yolo for performance, + this flag specifies how often yolo is applied (e.g. 1 applies yolo every frame). + This does not have any effect when is_video is False. + """ + + def __init__(self, model: str, + yolo: str, + model_name: Optional[str] = None, + det_class: Optional[str] = None, + dataset: Optional[str] = None, + yolo_size: Optional[int] = 320, + device: Optional[str] = None, + is_video: Optional[bool] = False, + single_pose: Optional[bool] = False, + yolo_step: Optional[int] = 1): + assert os.path.isfile(model), f'The model file {model} does not exist' + assert os.path.isfile(yolo), f'The YOLOv8 model {yolo} does not exist' + + # Device priority is cuda / mps / cpu + if device is None: + if torch.cuda.is_available(): + device = 'cuda' + elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): + device = 'mps' + else: + device = 'cpu' + + self.device = device + self.yolo = YOLO(yolo, task='detect') + self.yolo_size = yolo_size + self.yolo_step = yolo_step + self.is_video = is_video + self.single_pose = single_pose + self.reset() + + # State saving during inference + self.save_state = True # Can be disabled manually + self._img = None + self._yolo_res = None + self._tracker_res = None + self._keypoints = None + + # Use extension to decide which kind of model has been loaded + use_onnx = model.endswith('.onnx') + use_trt = model.endswith('.engine') + + + # Extract dataset name + if dataset is None: + dataset = infer_dataset_by_path(model) + + assert dataset in ['mpii', 'coco', 'coco_25', 'wholebody', 'aic', 'ap10k', 'apt36k'], \ + 'The specified dataset is not valid' + + # Dataset can now be set for visualization + self.dataset = dataset + + # if we picked the dataset switch to correct yolo classes if not set + if det_class is None: + det_class = 'animals' if dataset in ['ap10k', 'apt36k'] else 'human' + self.yolo_classes = DETC_TO_YOLO_YOLOC[det_class] + + assert model_name in [None, 's', 'b', 'l', 'h'], \ + f'The model name {model_name} is not valid' + + # onnx / trt models do not require model_cfg specification + if model_name is None: + assert use_onnx or use_trt, \ + 'Specify the model_name if not using onnx / trt' + else: + # Dynamically import the model class + model_cfg = dyn_model_import(self.dataset, model_name) + + self.target_size = data_cfg['image_size'] + if use_onnx: + self._ort_session = onnxruntime.InferenceSession(model, + providers=['CUDAExecutionProvider', + 'CPUExecutionProvider']) + inf_fn = self._inference_onnx + else: + self._vit_pose = ViTPose(model_cfg) + self._vit_pose.eval() + + if use_trt: + self._vit_pose = torch.jit.load(model) + else: + ckpt = torch.load(model, map_location='cpu', weights_only=True) + if 'state_dict' in ckpt: + self._vit_pose.load_state_dict(ckpt['state_dict']) + else: + self._vit_pose.load_state_dict(ckpt) + self._vit_pose.to(torch.device(device)) + + inf_fn = self._inference_torch + + # Override _inference abstract with selected engine + self._inference = inf_fn # type: ignore + + def reset(self): + """ + Reset the inference class to be ready for a new video. + This will reset the internal counter of frames, on videos + this is necessary to reset the tracker. + """ + min_hits = 3 if self.yolo_step == 1 else 1 + use_tracker = self.is_video and not self.single_pose + self.tracker = Sort(max_age=self.yolo_step, + min_hits=min_hits, + iou_threshold=0.3) if use_tracker else None # TODO: Params + self.frame_counter = 0 + + @classmethod + def postprocess(cls, heatmaps, org_w, org_h): + """ + Postprocess the heatmaps to obtain keypoints and their probabilities. + + Args: + heatmaps (ndarray): Heatmap predictions from the model. + org_w (int): Original width of the image. + org_h (int): Original height of the image. + + Returns: + ndarray: Processed keypoints with probabilities. + """ + points, prob = keypoints_from_heatmaps(heatmaps=heatmaps, + center=np.array([[org_w // 2, + org_h // 2]]), + scale=np.array([[org_w, org_h]]), + unbiased=True, use_udp=True) + return np.concatenate([points[:, :, ::-1], prob], axis=2) + + @abc.abstractmethod + def _inference(self, img: np.ndarray) -> np.ndarray: + """ + Abstract method for performing inference on an image. + It is overloaded by each inference engine. + + Args: + img (ndarray): Input image for inference. + + Returns: + ndarray: Inference results. + """ + raise NotImplementedError + + def inference(self, img: np.ndarray) -> dict[typing.Any, typing.Any]: + """ + Perform inference on the input image. + + Args: + img (ndarray): Input image for inference in RGB format. + + Returns: + dict[typing.Any, typing.Any]: Inference results. + """ + + # First use YOLOv8 for detection + res_pd = np.empty((0, 5)) + results = None + if (self.tracker is None or + (self.frame_counter % self.yolo_step == 0 or self.frame_counter < 3)): + results = self.yolo(img[..., ::-1], verbose=False, imgsz=self.yolo_size, + device=self.device if self.device != 'cuda' else 0, + classes=self.yolo_classes)[0] + res_pd = np.array([r[:5].tolist() for r in # TODO: Confidence threshold + results.boxes.data.cpu().numpy() if r[4] > 0.35]).reshape((-1, 5)) + self.frame_counter += 1 + + frame_keypoints = {} + scores_bbox = {} + ids = None + if self.tracker is not None: + res_pd = self.tracker.update(res_pd) + ids = res_pd[:, 5].astype(int).tolist() + + # Prepare boxes for inference + bboxes = res_pd[:, :4].round().astype(int) + scores = res_pd[:, 4].tolist() + pad_bbox = 10 + + if ids is None: + ids = range(len(bboxes)) + + for bbox, id, score in zip(bboxes, ids, scores): + # TODO: Slightly bigger bbox + bbox[[0, 2]] = np.clip(bbox[[0, 2]] + [-pad_bbox, pad_bbox], 0, img.shape[1]) + bbox[[1, 3]] = np.clip(bbox[[1, 3]] + [-pad_bbox, pad_bbox], 0, img.shape[0]) + + # Crop image and pad to 3/4 aspect ratio + img_inf = img[bbox[1]:bbox[3], bbox[0]:bbox[2]] + img_inf, (left_pad, top_pad) = pad_image(img_inf, 3 / 4) + + keypoints = self._inference(img_inf)[0] + # Transform keypoints to original image + keypoints[:, :2] += bbox[:2][::-1] - [top_pad, left_pad] + frame_keypoints[id] = keypoints + scores_bbox[id] = score # Replace this with avg_keypoint_conf*person_obj_conf. For now, only person_obj_conf from yolo is being used. + + if self.save_state: + self._img = img + self._yolo_res = results + self._tracker_res = (bboxes, ids, scores) + self._keypoints = frame_keypoints + self._scores_bbox = scores_bbox + + return frame_keypoints + + def draw(self, show_yolo=True, show_raw_yolo=False, confidence_threshold=0.5): + """ + Draw keypoints and bounding boxes on the image. + + Args: + show_yolo (bool, optional): Whether to show YOLOv8 bounding boxes. Default is True. + show_raw_yolo (bool, optional): Whether to show raw YOLOv8 bounding boxes. Default is False. + + Returns: + ndarray: Image with keypoints and bounding boxes drawn. + """ + img = self._img.copy() + bboxes, ids, scores = self._tracker_res + + if self._yolo_res is not None and (show_raw_yolo or (self.tracker is None and show_yolo)): + img = np.array(self._yolo_res.plot())[..., ::-1] + + if show_yolo and self.tracker is not None: + img = draw_bboxes(img, bboxes, ids, scores) + + img = np.array(img)[..., ::-1] # RGB to BGR for cv2 modules + for idx, k in self._keypoints.items(): + img = draw_points_and_skeleton(img.copy(), k, + joints_dict()[self.dataset]['skeleton'], + person_index=idx, + points_color_palette='gist_rainbow', + skeleton_color_palette='jet', + points_palette_samples=10, + confidence_threshold=confidence_threshold) + return img[..., ::-1] # Return RGB as original + + def pre_img(self, img): + org_h, org_w = img.shape[:2] + img_input = cv2.resize(img, self.target_size, interpolation=cv2.INTER_LINEAR) / 255 + img_input = ((img_input - MEAN) / STD).transpose(2, 0, 1)[None].astype(np.float32) + return img_input, org_h, org_w + + @torch.no_grad() + def _inference_torch(self, img: np.ndarray) -> np.ndarray: + # Prepare input data + img_input, org_h, org_w = self.pre_img(img) + img_input = torch.from_numpy(img_input).to(torch.device(self.device)) + + # Feed to model + heatmaps = self._vit_pose(img_input).detach().cpu().numpy() + return self.postprocess(heatmaps, org_w, org_h) + + def _inference_onnx(self, img: np.ndarray) -> np.ndarray: + # Prepare input data + img_input, org_h, org_w = self.pre_img(img) + + # Feed to model + ort_inputs = {self._ort_session.get_inputs()[0].name: img_input} + heatmaps = self._ort_session.run(None, ort_inputs)[0] + return self.postprocess(heatmaps, org_w, org_h) \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/sort.py b/ViTPose/easy_ViTPose/easy_ViTPose/sort.py new file mode 100644 index 0000000000000000000000000000000000000000..388ce2455bde185606869f09d64ac47a74ad9fa3 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/sort.py @@ -0,0 +1,266 @@ +""" + SORT: A Simple, Online and Realtime Tracker + Copyright (C) 2016-2020 Alex Bewley alex@bewley.ai + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +""" +from __future__ import print_function + +import os +import numpy as np +import matplotlib + +import matplotlib.pyplot as plt +import matplotlib.patches as patches +from skimage import io + +import glob +import time +import argparse +from filterpy.kalman import KalmanFilter + +np.random.seed(0) + + +def linear_assignment(cost_matrix): + try: + import lap + _, x, y = lap.lapjv(cost_matrix, extend_cost=True) + return np.array([[y[i], i] for i in x if i >= 0]) + except ImportError: + from scipy.optimize import linear_sum_assignment + x, y = linear_sum_assignment(cost_matrix) + return np.array(list(zip(x, y))) + + +def iou_batch(bb_test, bb_gt): + """ + From SORT: Computes IOU between two bboxes in the form [x1,y1,x2,y2] + """ + bb_gt = np.expand_dims(bb_gt, 0) + bb_test = np.expand_dims(bb_test, 1) + + xx1 = np.maximum(bb_test[..., 0], bb_gt[..., 0]) + yy1 = np.maximum(bb_test[..., 1], bb_gt[..., 1]) + xx2 = np.minimum(bb_test[..., 2], bb_gt[..., 2]) + yy2 = np.minimum(bb_test[..., 3], bb_gt[..., 3]) + w = np.maximum(0., xx2 - xx1) + h = np.maximum(0., yy2 - yy1) + wh = w * h + o = wh / ((bb_test[..., 2] - bb_test[..., 0]) * (bb_test[..., 3] - bb_test[..., 1]) + + (bb_gt[..., 2] - bb_gt[..., 0]) * (bb_gt[..., 3] - bb_gt[..., 1]) - wh) + return(o) + + +def convert_bbox_to_z(bbox): + """ + Takes a bounding box in the form [x1,y1,x2,y2] and returns z in the form + [x,y,s,r] where x,y is the centre of the box and s is the scale/area and r is + the aspect ratio + """ + w = bbox[2] - bbox[0] + h = bbox[3] - bbox[1] + x = bbox[0] + w/2. + y = bbox[1] + h/2. + s = w * h # scale is just area + r = w / float(h) + return np.array([x, y, s, r]).reshape((4, 1)) + + +def convert_x_to_bbox(x, score=None): + """ + Takes a bounding box in the centre form [x,y,s,r] and returns it in the form + [x1,y1,x2,y2] where x1,y1 is the top left and x2,y2 is the bottom right + """ + w = np.sqrt(x[2] * x[3]) + h = x[2] / w + if(score == None): + return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2.]).reshape((1, 4)) + else: + return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2., score]).reshape((1, 5)) + + +class KalmanBoxTracker(object): + """ + This class represents the internal state of individual tracked objects observed as bbox. + """ + count = 0 + + def __init__(self, bbox, score): + """ + Initialises a tracker using initial bounding box. + """ + # define constant velocity model + self.kf = KalmanFilter(dim_x=7, dim_z=4) + self.kf.F = np.array([[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [ + 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]]) + self.kf.H = np.array([[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]]) + + self.kf.R[2:, 2:] *= 10. + self.kf.P[4:, 4:] *= 1000. # give high uncertainty to the unobservable initial velocities + self.kf.P *= 10. + self.kf.Q[-1, -1] *= 0.01 + self.kf.Q[4:, 4:] *= 0.01 + + self.kf.x[:4] = convert_bbox_to_z(bbox) + self.time_since_update = 0 + self.id = KalmanBoxTracker.count + KalmanBoxTracker.count += 1 + self.history = [] + self.hits = 0 + self.hit_streak = 0 + self.age = 0 + self.score = score + + def update(self, bbox, score): + """ + Updates the state vector with observed bbox. + """ + self.time_since_update = 0 + self.history = [] + self.hits += 1 + self.hit_streak += 1 + self.kf.update(convert_bbox_to_z(bbox)) + self.score = score + + def predict(self): + """ + Advances the state vector and returns the predicted bounding box estimate. + """ + if((self.kf.x[6]+self.kf.x[2]) <= 0): + self.kf.x[6] *= 0.0 + self.kf.predict() + self.age += 1 + if(self.time_since_update > 0): + self.hit_streak = 0 + self.time_since_update += 1 + self.history.append(convert_x_to_bbox(self.kf.x)) + return self.history[-1] + + def get_state(self): + """ + Returns the current bounding box estimate. + """ + return convert_x_to_bbox(self.kf.x) + + +def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3): + """ + Assigns detections to tracked object (both represented as bounding boxes) + + Returns 3 lists of matches, unmatched_detections and unmatched_trackers + """ + if(len(trackers) == 0): + return np.empty((0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5), dtype=int) + + iou_matrix = iou_batch(detections, trackers) + + if min(iou_matrix.shape) > 0: + a = (iou_matrix > iou_threshold).astype(np.int32) + if a.sum(1).max() == 1 and a.sum(0).max() == 1: + matched_indices = np.stack(np.where(a), axis=1) + else: + matched_indices = linear_assignment(-iou_matrix) + else: + matched_indices = np.empty(shape=(0, 2)) + + unmatched_detections = [] + for d, det in enumerate(detections): + if(d not in matched_indices[:, 0]): + unmatched_detections.append(d) + unmatched_trackers = [] + for t, trk in enumerate(trackers): + if(t not in matched_indices[:, 1]): + unmatched_trackers.append(t) + + # filter out matched with low IOU + matches = [] + for m in matched_indices: + if(iou_matrix[m[0], m[1]] < iou_threshold): + unmatched_detections.append(m[0]) + unmatched_trackers.append(m[1]) + else: + matches.append(m.reshape(1, 2)) + if(len(matches) == 0): + matches = np.empty((0, 2), dtype=int) + else: + matches = np.concatenate(matches, axis=0) + + return matches, np.array(unmatched_detections), np.array(unmatched_trackers) + + +class Sort(object): + def __init__(self, max_age=1, min_hits=3, iou_threshold=0.3): + """ + Sets key parameters for SORT + """ + self.max_age = max_age + self.min_hits = min_hits + self.iou_threshold = iou_threshold + self.trackers = [] + self.frame_count = 0 + + def update(self, dets=np.empty((0, 5))): + """ + Params: + dets - a numpy array of detections in the format [[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...] + Requires: this method must be called once for each frame even with empty detections (use np.empty((0, 5)) for frames without detections). + Returns the a similar array, where the last column is the object ID. + + NOTE: The number of objects returned may differ from the number of detections provided. + """ + self.frame_count += 1 + empty_dets = dets.shape[0] == 0 + + # get predicted locations from existing trackers. + trks = np.zeros((len(self.trackers), 5)) + to_del = [] + ret = [] + for t, trk in enumerate(trks): + pos = self.trackers[t].predict()[0] + trk[:] = [pos[0], pos[1], pos[2], pos[3], 0] + if np.any(np.isnan(pos)): + to_del.append(t) + trks = np.ma.compress_rows(np.ma.masked_invalid(trks)) + for t in reversed(to_del): + self.trackers.pop(t) + matched, unmatched_dets, unmatched_trks = associate_detections_to_trackers(dets, trks, self.iou_threshold) + + # update matched trackers with assigned detections + for m in matched: + self.trackers[m[1]].update(dets[m[0], :], dets[m[0], -1]) + + # create and initialise new trackers for unmatched detections + for i in unmatched_dets: + trk = KalmanBoxTracker(dets[i, :], dets[i, -1]) + self.trackers.append(trk) + + i = len(self.trackers) + unmatched = [] + for trk in reversed(self.trackers): + d = trk.get_state()[0] + if (trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits): + ret.append(np.concatenate((d, [trk.score, trk.id+1])).reshape(1, -1)) # +1 as MOT benchmark requires positive + i -= 1 + # remove dead tracklet + if(trk.time_since_update > self.max_age): + self.trackers.pop(i) + if empty_dets: + unmatched.append(np.concatenate((d, [trk.score, trk.id + 1])).reshape(1, -1)) + + if len(ret): + return np.concatenate(ret) + elif empty_dets: + return np.concatenate(unmatched) if len(unmatched) else np.empty((0, 6)) + return np.empty((0, 6)) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/testVITPOSE.jpg b/ViTPose/easy_ViTPose/easy_ViTPose/testVITPOSE.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1950afe3c02fa46ea40e1c98b9b31ad9efc55b86 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/testVITPOSE.jpg differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/to_onnx.ipynb b/ViTPose/easy_ViTPose/easy_ViTPose/to_onnx.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3d22de5a5563619adc1bf24bb72f4a947355238c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/to_onnx.ipynb @@ -0,0 +1,188 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "\n", + "from vit_models.model import ViTPose\n", + "from configs.ViTPose_coco import model_small as model_cfg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Torch to ONNX" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================ Diagnostic Run torch.onnx.export version 2.0.1 ================\n", + "verbose: False, log level: Level.ERROR\n", + "======================= 0 NONE 0 NOTE 0 WARNING 0 ERROR ========================\n", + "\n", + ">>> Saved at: /Users/junkybyte/Documents/easy_ViTPose/easy_ViTPose/ckpts/vitpose-25-s.onnx\n" + ] + } + ], + "source": [ + "CKPT_PATH = \"ckpts/vitpose-25-s.pth\"\n", + "C, H, W = (3, 256, 192)\n", + "\n", + "model = ViTPose(model_cfg)\n", + "ckpt = torch.load(CKPT_PATH, map_location='cpu', weights_only=True)\n", + "model.load_state_dict(ckpt)\n", + "model.eval()\n", + "\n", + "output_onnx = 'ckpts/vitpose-25-s.onnx'\n", + "input_names = [\"input_0\"]\n", + "output_names = [\"output_0\"]\n", + "\n", + "device = next(model.parameters()).device\n", + "inputs = torch.randn(1, C, H, W).to(device)\n", + "\n", + "dynamic_axes = {'input_0' : {0 : 'batch_size'},\n", + " 'output_0' : {0 : 'batch_size'}}\n", + "\n", + "torch_out = torch.onnx.export(model, inputs, output_onnx, export_params=True, verbose=False,\n", + " input_names=input_names, output_names=output_names, \n", + " opset_version=11, dynamic_axes = dynamic_axes)\n", + "print(f\">>> Saved at: {os.path.abspath(output_onnx)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inference with ONNX" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>> Original image size: 798 X 720 (height X width)\n", + ">>> Resized image size: 256 X 192 (height X width)\n", + ">>> Scale change: 3.1171875, 3.75\n", + ">>> Output size: (1, 25, 64, 48) ---> 0.0390 sec. elapsed [ 25.6 fps]\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAHXCAYAAABwPhdhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9aaxlyXUeCn4rYp9z7pRzZlVlzVVksUqkSA2kaFmi+ahnyYT1ZEA2ZEGth7YG0z/aMOA/FmzAMER5gOA/lhuwANkwYL4HA3owZPQTu90NSRblZ1kUKQ7iUEUVWXNVVs7Tnc+wI1b/WFPsc7NYWe1y84k+QRQz895z9o5YsWKtb41BzMxYjdVYjdVYjdV4G0f6Vk9gNVZjNVZjNb79xkq5rMZqrMZqrMbbPlbKZTVWYzVWYzXe9rFSLquxGquxGqvxto+VclmN1ViN1ViNt32slMtqrMZqrMZqvO1jpVxWYzVWYzVW420fK+WyGquxGquxGm/7WCmX1ViN1ViN1Xjbx0q5rMZq/P9xEBE+/vGPf6unsRqr8d98rJTLanxbjU984hMgIv+v6zo88MAD+Nmf/Vm8/vrr3+rpHRmf/vSn8fGPfxy3b9/+Vk9lNVbjbR3dt3oCq7Ea/y3GP/yH/xCPPfYYptMpPvOZz+ATn/gE/st/+S94+umnsba29q2eno9Pf/rT+KVf+iX87M/+LE6ePPmtns5qrMbbNlbKZTW+Lcdf/It/ER/4wAcAAB/72Mdw9uxZ/NN/+k/xyU9+Ej/5kz/5LZ7daqzGt/9YucVW47+L8ef+3J8DALzwwgv+s2effRY/8RM/gdOnT2NtbQ0f+MAH8MlPfnLwvcVigV/6pV/CE088gbW1NZw5cwYf+tCH8Du/8zv+mY985CP4yEc+cuSdP/uzP4tHH330Def08Y9/HL/wC78AAHjsscfclffyyy///77Q1ViN/5OMleWyGv9dDBPYp06dAgA888wz+MEf/EE88MAD+Ht/7+9hc3MT/+7f/Tv8+I//OP79v//3+Mt/+S8DEAXwy7/8y/jYxz6GD37wg9jZ2cHnP/95fPGLX8SP/MiP/FfN6a/8lb+Cb3zjG/j1X/91/Mqv/ArOnj0LADh37tx/1XNXYzX+zzBWymU1vi3H9vY2rl+/jul0is9+9rP4pV/6JUwmE/zYj/0YAOBv/+2/jYcffhif+9znMJlMAAB/82/+TXzoQx/C3/27f9eVy3/4D/8BP/qjP4p/9a/+1ds+x/e973343u/9Xvz6r/86fvzHf/ybWjmrsRp/2sbKLbYa35bjh3/4h3Hu3Dk89NBD+Imf+Alsbm7ik5/8JB588EHcvHkTn/rUp/CTP/mT2N3dxfXr13H9+nXcuHEDH/3oR/Hcc895ZtnJkyfxzDPP4LnnnvsWr2g1VuNP11gpl9X4thy/+qu/it/5nd/Bb/zGb+BHf/RHcf36dbdQnn/+eTAz/sE/+Ac4d+7c4L9f/MVfBABcvXoVgGSd3b59G+9617vw3ve+F7/wC7+Ar3zlK9+yda3GavxpGSu32Gp8W44PfvCDni324z/+4/jQhz6En/7pn8bXv/511FoBAH/n7/wdfPSjH73j99/5zncCAD784Q/jhRdewG/+5m/it3/7t/Gv//W/xq/8yq/g137t1/Cxj30MgBRG3um28FLKf4ulrcZq/KkYK+WyGt/2I+eMX/7lX8YP/dAP4V/8i3+Bn//5nwcAjEYj/PAP//Cbfv/06dP4uZ/7Ofzcz/0c9vb28OEPfxgf//jHXbmcOnUKL7744pHvvfLKK2/6bCJ6i6tZjdX40zFWbrHV+O9ifOQjH8EHP/hB/PN//s9x/PhxfOQjH8G//Jf/EpcuXTry2WvXrvnfb9y4Mfjd1tYW3vnOd2I2m/nP3vGOd+DZZ58dfO/LX/4y/uAP/uBN57W5uQkAqwr91fi2GyvLZTX+uxm/8Au/gL/6V/8qPvGJT+BXf/VX8aEPfQjvfe978Tf+xt/A448/jitXruAP//APceHCBXz5y18GALz73e/GRz7yEbz//e/H6dOn8fnPfx6/8Ru/gb/1t/6WP/fnf/7n8c/+2T/DRz/6Ufz1v/7XcfXqVfzar/0a3vOe92BnZ+ebzun9738/AODv//2/j5/6qZ/CaDTCX/pLf8mVzmqsxp/awauxGt9G49/8m3/DAPhzn/vckd+VUvgd73gHv+Md7+C+7/mFF17gv/bX/hrfd999PBqN+IEHHuAf+7Ef49/4jd/w7/zjf/yP+YMf/CCfPHmS19fX+amnnuJ/8k/+Cc/n88Gz/+2//bf8+OOP83g85u/+7u/m3/qt3+Kf+Zmf4UceeWTwOQD8i7/4i4Of/aN/9I/4gQce4JQSA+CXXnrp7SLHaqzGt2wQ8x0ikauxGquxGquxGv8VYxVzWY3VWI3VWI23fayUy2qsxmqsxmq87WOlXFZjNVZjNVbjbR8r5bIaq7Eaq7Eab/tYKZfVWI3VWI3VeNvHSrmsxmqsxmqsxts+VsplNVZjNVZjNd72cdcV+n/yyv8bVhDDsJ5I5D9hruAKSKskAlECg0EsP2Mi+ZPhTf7arkrc/KPW6u9K9kIdR1sxxXOlgaB8oe3ZxMwgGs6ZmQDUwWdYViLvpQSyn3MFgcEEcGV/fkqdzJUZKQ319PL75WfJfx4/s6aHpGuxf9t/GPxM1kJv+I74ub2nDhor2veX52G0jX+SUoNBYBBl2L76cwb7wbK3lGLu1b7Ng32TJ1dfn2x+0IH1WZQSjLegvzFGsTUQERhAQhrQsdbiaydKA2Yb0lO+kgY0sVkCRLWhSbtP9hNjagKIQCBAeY2b8wFmp529o91LWTArv9nP7d9F3ktGt5gn+Z4Qaq0Nn8saqKEV29yb3QUYlat/HhBagO37yfdBGn4yGMWfAz3XYP2Kfc/Pop1PpTUqKMme1lqCpsp8zttIMPEU/MoxR6MhkS2m+S0rD8kP5axmpVl8yvaGmYE0FCyDM11DPjjdSH5Rdb+4Vrg80eUQCMSp2a84e8wVoOBnKM3lPfI742xCRkpJ6W9rCf7wSULZUP9n+zAcIVdaGWTNXAeywQUvAUy2tQCA73joh/Bm466VS9VNMk5qRBJ0B0GNJmAwKBFIP2j8GhsTa6Ujz1QGh9AfS/QJetkhjz/tofZvEW8hDILpQ8j4pkO2yH8OqKSxv7fCXxlEGbnWCmoY1ITv8uRbYT5kNptzbL7NsZ1r+4yWIdrPm4IdrhFLgqedk30+hJIc3yqHJqVGcrSdfkX4GD0IQLL1sT5XGYCE61HZjkEjBipAZIKFbMdEwBCroLH1AEDywwvdN6AipwRWIZtzB0J2nh0q5wRKRxWtCWkXI8xCgwGxQnm4QPXDHNSTCd7BMUAEcG0AROxRqQWAKQjZGOYStCeZu+278KC+35So7Scp/WwfktIqtKKsVKfRAgBmatBe0r+3Jz4P+cgVh81lqKBDUfsXjvKsKk97PnOAmJTa/fFX6hSNj+J1DDR0gfPVcBtMYLIAiJiaK6ZaGYkIta0zJwKZbAA56JR3BJ/GhEJAD3ktL4FIdtlqe+2ysQEitpZloO68nYyOyzIhFNEA6FHwc214MtYwHG+l5v4t9Rbj5v8BuFAALb9Ud55NsNPyEb3jswcHrtGqLaGWkYcJzTho+nfT2mzKTFGaC+TsBOfBuzD4mYjC2uC9RkCTHMjEUEUT37e5AckRUItU4zN1YA3I82MdJuTj3zxQNMPvDX/eKlJj7nhvrEX4KwHICCFG4JqRuqzfT6pcdR6GkFK2hYZQZdk/QYSmmlVdVAjjoILRC48kPXgNVgMlO7qhoCDCNVESS9iEOqlw1LcIuZMrn4ZQIUhB4GT8ORSW7PTmga5nwAWJ72NlF+QBT6q+6k7IEarsCohCMYt13AhP1QrEJnyFVwYQjIMnl3mAdB2UkgtD8SQQEsUpZrb9KbpLnW2v8syQJ9kEXjN46V+t0BOLt+VN+y942b+DOrSaaCiQ2+/pJ8DELsdbxQkDscxgbhUe/BkmzzgWpnQPAjGG6x2eO1Pk7XMdosaP7JlHqGY0Uj6gqvRubIYjinEIlNsznVICG5rHcJ7xrHaIfKhc/HfVQTHCMEBDm7cw7lq5mDY3hGbujqCwatpGCHMBoB6JWsOstClX+UOUdPMMRkWl1hpRDaKKIlAG6dIZRByIU1FnywhVrYywaNTqYBW0qiD9GLbK0gVSGZyyWkzQF6eJflwUL7DE1Iq+aPBoFbbLiC9cC8Qtg+UQMksIZOgOIRVioUwFuYYiMMUPQ12cXdDboREXRhF6sH3W5qeKc1negdV9GPsrjExAAhL3YCz0ndVOMELIinJpD2Vj6ENUYQKo0zUqnWtjCVa3WZ0+rJMRmROAgQf0VfWmm2e0JuUdglhHpnfg7r3hf3ZeRLCZa8T2ZYjczbUawonVpdjyNFBqo/jVqiLY+lvXkZNe5rIk4GRrzOrWs+KCrgCqYMQiVxcw5Jy0ANBG8m+L0q8GtMiAgdLLXUGhYNxDYGeTWAQHEeAWkikgdnDfKkfnPVuD8qo8u3XRwQGeWeumCFndUKwIonVhN2+DilqI9annvjdet/2pOkfhLRE5xXmQQEEDkl1slU3sHHyfTfJyrTBvnZBGXIsma0xWye/ZQaTPX9fOCDdercE73BC3gQDxhP8WlostNFB960sNZB1mHPnEU0o+qSAYQjAYYR1hia88JQqM4SYKQ1wzKgRs4ToHO8w+T0ZDuLrErMHrYVFU/677XE2bG2q2OUKVJodJKoIk3DaJks5H6MM1lEv4lymsGxVgULOdiBX9y6EhJlRUpZnRwxBePDfQY4o164EK/WjCNfaZyvBgcS2ozqDkel4OL8F1SIMauaUph8vE+MRfR+R8IvI0fNaxn3pQEg3+7fxCgrYyLf9eXVw+d1GSlcXtlFITnwO5kB0KQ4BRGmEIVXo0EDeDrVgSEDancB3qnqqCEOHdnq2Ia4hiq0JrmAKqS8oETuOwgmQeOefB3prYkdhMxLxYaUNQMdacoQBwGgvTOEOrx1w1EQOsoMDXVEBU1ctTVIDb3tYQ7BQuPOIK8gBue14FsZmbmznp3J2dlJGW1jygl8Xx2OlUawGTKDRzx4qcatzVyvMEqPuoOo/a80xBtPKxBYpV10vOk6aEALemG1AclnejTRionJR2aN455IlgRX2Gu6fhPOAKjQNMhixvRC5MpoRb+W7GXSuXvl8MFp4QSkMC8DIT95szw3yzgRbis2b+ueBWkhSJngFESJWQaKSH3IinfmhIkJkoK8GGQUkhjhGe/F1VN9QQu7hZQlgQZQRPEMKqEDTteJcyKveiZFKnb00qtOxfGSllZVY7+OHOGVh5BvYo+aFyueAKrzbrMfXSMBOWGMwUWkjzoAubUNPnuJwyn78GcdniACFNQuhUf9fwva1EC9TpDE0FjmIBDb6zP8cOytA9qVYJmzpQIa3MUZldYVhg2w5XGyezmAnXoBGTOLVE+fNgbsJCbLIl+NZ5rFlpswYQ3FcvPGtKAc5/zBpMr4BZh6xClNHrfotyMaVYi/C+BHVDEbaJn6Fkwt3RbodYeKq4XNDKmhN1ogzI3J1C68qsQWtW+RwATYSyCXXDusn/7q4aVd4tgGM2uRFKIsFctUUFuimRMuA3ZnW3D5QLgOqZRZo0oM9NCUkteGb25Bw5x+GVuKMbjOK8VjCS0zdFwN95IywGOUsEwyhuS5MBhcY+JQLX6oI+qbyJPdZzVknnLWugRM5TIPJnAcLbrbudlE8tbBexXgSYQSNXdH6p8bg4oH+T8ZaUS0wmoVIFennVEB2J0iEiN/fFCjFFpFk8LkNZXBytoIVp2EaY+5+iUISaSf+tCscPmTF4ox/cDCQnkHw3OcJ2lG+CiQxRWKAsDTZKXDPVERWY4IAABKakJmczL3I7TYVWrJkrI7mPO4SixId6p3OgVMRB4fBfD11k8N/nnHW/NFBP5iZLutzin08q5Cr3jcCP55mgXlYq7VyWXRpQRA5l4loCwTbq0f9slUs1xMfBN631Vhl+oOU7xd/v/8/CK6hyMD34wIyayJFj5YKwnKBo2wRAC18ApnCvwtErhTxgRk45BKry1BHAZa5O/Vzl3kGUuQ/NwgEIRZF9uPYagKWkLHVo0TK3FlsZ7K1l1lVagKhzSyK+HEkIVMjXCAY4aWZlNTTPSDTSc1rAKPDdIvMomAtGzlUb2xTA0+srks/BlLfT3q25Ieu4LlOO818zATAvgsoyhsyPgvcNXJKt0R7MplyqsA5XAFnjWDRMMDCebtzQDgDMI2FuKbTAKjwuBkhbPk5EKHZuEEqkclXQkFyhhceice8SuVKNc6lnFKH0l4FiJTqSEftm4+7dYsqA8mKWObMeUhXViQLNHAmS2iLM9CRBEURpgHKgCIrUnZQ8wGjWg5HVDq86NQyBm7JzFGgfJIAyFGPBUX2VOSUVsMO0WNtcFcqaIu2HTNFTUdCz7B5kUtxhzEHhboiMn6RCX+npAqIip85pXkoRYeM+dzRMEK4Q2yuiBsHr6PsegcgZqJJMIKBEDp6MIpiWw6IwRjRWlFUmMCc/kEYnmKBXJWCMa3Evea64V2SfYp5tgkO8s6pf2w6qpGMm6nw/CUAtoZC59qo8KdAjaqDVyqBsrh/owUku4CuKrssC4vbudq6IgLIpVlfaTaB1sJ6KqusSi5lRS9X8F7UgWFEtWqsezXmiZk4tuCswNojzBt8xQ71mEVUO96oIniRniXqQJneE0a8xS+XZcNkAKI1AFW0sQIUl28/BF1kyATdxpuRCMilaR1V3KwHmUiYipCWXjcTtlhSOCUXfr1BO8tmMWpaFeUFY0VVBFmmWmii/Nk5TmVW5MIgKIlifGwGs6yMOq0xlTmr4g1WJyF6bdWBnRniTkmbssSQ81Fr0PSq7NE1Z6BTxW5dRADyJhtn/bZ8Jt3co69aVa3QopSzx4Tcfd61cEo2FUVBlA1SomwCinOBa1nSEMwcPJkvUKfNmZUA0i87BGGTBUzvNALR+prLtg2lg/YgaISJYTSO3aFrJ6Omv1RWZ+5Ib1ExiooAqwJxQaw9zJ+SUVMjLdxoLHMmNsXbdyVRo4/MUt5MtJaUWWdnTKqoKZLDM25gpZw2iKiPC5syKBlm+TxEcUXqL9SIKPCGnrC4wUQxEfQC2aqgmmC8lAwWp+U4wnVlkkmli6xF+KdxrlhUctUtMRXlLg+6UkvNX7IfwBZWEnDqlBw32WBRGuD9FiTSQxBRvCZet0V2+Zgex4SFmtSyj/kkIYeFWJX9tMoVc0AIm7uIcKKp1gBZCknWPxTYm5+vWxWxZ/+w8z4HY1TLkb1ojzf45E4gSG1HgtFwD1rgDyf9m31MlYXvk+x9/sy9WirqaWKepUsl2oqpvT0N3WW3S4NkUMIeisA9a1AqJxPfhYEzXqP+uBc7X9gyhiRHXkH9jnervev9Hm5rfIVVVyii+zwNrl0UXG6h2njBqEcGscjYF3boRiZozQZpSb5mvQWiXc7pXxBWJeLhes8S4LJ3RUDBCE1PwDWi5i3H3lkvtnEhcevejMidUVHBVjWwpyKoVU7Kgd8QukvoGW0EXSJ6b/STXqkQW61Dl0QJj2UI99EAt4q/2IDnCPWd+SXVbIrG4gHpz/aQQJuBhTIGZUGsQtzCcScVSaAWEKS3/iQpNgrnSLMHAkgJiI+VLtYr0qOpK8niVbnytBZVzJEw0CtF9p0TqruihPzAxF2mHvS7JazhMccRa7DtH2Motp2V3GByEiCIyd6AFqaFCfuhLD4tRFTQM3ek8mj1JlFTgZ5TmgMh3TTAkoOjhgNZMENS3rRZEGha3yvkxxd8eWp9ajBI/kqDt0ucJMCvBPpjsL2Trc80XSsueZ4kJiAQTEeDGl/F+4wGzEIeC7ygAEFoyCtclCwnK+5YwY4pRCeBWU3NmXZnAa0MYxkvyGfvTELARwYU/sSrqhBDMravI+FMBLBc/D/B5NsRnajg25he/Tw4UDYya3AKijizWDV93K4RjHYwKs5jlO+7NIPOYCOpOKG4Fwgsti09VEisNwLOvVTcHJidTAagUX1uAIZWr+jzxLNm5N1603R0CCVu7nQ0cUep3N95CnYtpxyrCT4nrxjKJXw4EpMbMKoUaxKvCNrFkPlF1wSh+REFzJqBKYbWWAGJzI1Txr5s60Y1314qnfjYaGCzKKgVjuqaG+jy59x/Kr01BmiKwYO+Q4U3I23tiFwBXpiYUKoNoOkBAQKAF+Wwwh89H6e7ZJhCGqLUgFVUDejhiaYz24FZUVeT2Afb8dpsPuctS3HRtJpMd9GUlIIx6p/gK/PNUyFGBYV87yMyMUnvNqjNFZcrTqBRpk5ZwoDsuypcKmDMszgfIeTWlyHo4MrG4MJM9x1xo5M+WvxDCTWLKjvT5PdoR9FCA4buKhk7V1062ErdeAkQsP1eAUNWanlbYWXKDeQpU+JMIXJuzifXmqRhmSwUAaT8jrhVD0knnHIjXdoU1WkBgTwNPqRP4UFvhawIR7jqv/u6oYHcApsTkYgrMwGFyBh7G6RpaEyHreaulzQ6Ff949CYC6BiU9O6ek82ozFRMqw89wrRXwWFjzLBIqhes7XMrMFeSubz0KSdZieXiAKUxWOUrIMMuNwbyAcyIZjyQEnjXL0bLedMXUqlQ7c0X2C2axD2NXtZU1lXyPlsHjm423EHMpLkilaltYy+sabOksiD4xNBWyRWL6WR6mX4rSUUZqCKfawDG0Yyg30cn5NlqENKQ0IrBVelPztThk4kBQFFQzDLgK0w2zpYw5SokA5/KhDyWsGSqKjIVGC32GteyYw0xxCiLBTHJXDtUEdktvYZJ56cEQFxlcTpH/l9RalOcocqLk77Av+asHqaLwgxP58IFg2BSCK8IQQKSK3/dE98njZ8FdjRtz6LMON5c9UBSIpMyyu7MkA6Y6Shu2KpGl9lWDnVUns9ThwNqsGOozF7DvH7dppM3sOXhAV9PiFzRoQsCMKwRWkIYhTcjopD54U8qOnCUTEQCSSRdm1GQCNuZl8jf4tzexKO/RTKdwx9pcGYwsKcHMArBbtE6icFpqCNpdxJ7BwIIAgWRMwYGVU2r5JsFiBpKNRYh4CINr35yRFsrZvwXyVx7GNVoA0GxaAFT7N0uXBEoBSi1nsyod3LJuAGGs0xTKUIETAdxbHLkFxKZ0izNHYXEPAuIaJM3KrLyAWaYuV9nOCwEo7iFyUKcgTJav8gQAoxeXOMRTYntk66keHzXSVP9MgMA3H3dvueiBFKVKKMY7TfoaoEys9FNa2Af1IeanNVSkgp/M9LYNklx84k61NfthD9cFfNGO3mBsFwLTDxObArBuGHLIDa2UolXKihxk7tXnZPGjQNjyu8pF3XhVs3FMCUnMqFiWU8oav+gdHQ4znOC9kggiBFNKgCY++Fp1Paxzay3lME+EYSuzxC40pTsYg13/GO9Ziq/Mp/q2xYEReRwIBq6szS/sT2cWn7kdpNogvZC6EAVqqaZizXrwWN0rkWQReyH7JC7EcLmx/p0HStbicIBmB3kwc4n2nl7b+Lir1XU46nFhbN+tte380AZ+a/OOSPbwP5aUjgsGkLiduYKq0h2WHQanBTENAtitP9wUbmtFtufEeHyI0oMfRRAyCFkt+0iHN3cZaVy19dG37wplJS4Zs6wrhxsnhLDtfVLFoBmSkAy0Nl7q3TCIAHT6iopkfeAYsOKwylIzI+5uq6VxpoWoPZl3qT1McYg7uQEn1egytPTbNcSa2tIB8wCIheBAxdPyh21XWC0pLuQKOdpqRSJE1gy7Ng4la4XzvuxzhpRQcJDMD4fJkKGycCXThCoCEMc+v9m4a+WSASzU78exywAXEZayEjkAKrQXPIVXREOEhAX6SjE0r1rR4jLKUCllpNSBke2kAND+S7qPZorbxgA6B0MLbKa6ENiEhbt/QJ65wzwbHA7zjBsCTpqxMUDmEBgcufSMUhuLA0WFXwbX5AzhpBtYdRT1QqpEsmUZecCuqFKyGgf4oSu1opReEWgwi2XPldKrwIgkCmMaXwvQoKkY7toZCARhXNEr7Ac/Pq+6SzsnuGWZWn802+P0M43eQQtMbEpDrEqK8Cs3CesDwUZLAiAs49ayHArHAbz1eZpi9in7x0zohKKREVl/LQJm7XJA/pN41yAhYnDgQ0kP4wIce00hFGXdvLyNOuekafXyPYmJLqX0Nko3paRWRFUQUGHB6lAsbTYcVNm2a7IYAOvPWt5nnUdSK7F11bRuuKgb8u8xlIoaG2LrFkHhdnM9IjxcLaFNf+ExwPa5DYhrvSv2b2DIC0Fo+53xQ8igI4pRPx8eCXVHa6Gv7LmCJhV5bVJHrU2cst01A9lsdNUzop4bP+/Ox8HbbuktPU/4yfaX8bYrl0XZxrzOtU2CZUlpDrv6IFvk22pz07xs0SW0iykIC0eyVIgIVC2c5ceyOfxhxqXcpsLaM8MsJCTwYCNEyQFmgsqojYAUYhdJ3QWQUh4UY8V7qjw7ydoqi1IMGUFu6ZFaNLXx17ZIwJGv1soQCMhaN2MZPRpLkrNih1aLqRrT1f3TMWOft6196dzK7i0rav+6Pd92QmUTqW+92lpMCDVCXn31tVqKcViAfoCbTDQ7tLZflhQR6sr2iH1/hL6SBi1JaGEdmNvTeEeC17H4UprYC7fCsLVEjtJkWTiGwIyfB7X0P4JbVu0j23csxz/avWtpFnQKBe2f1v9zhU1iHaqbX63BcEm1Q/jVJbLzlUzL3HRi5b+Rd2RIrlb0tdabCW9D9+FOlrhWUquhNN85MlsEWBvyhvGMuaMDcGgMp5FU9p1vJjTN0g2l0/6uVaBLcTGybtXtmuPLgz1NogBNJibq/F0ckxgogVAAMuod+SjeO1QgAYxMWSWvWYrswyGhKu68F0fHXSuXw8UuqsYlEtTVUCMDrHJ1T7MtLJmQcGQaAjGpmWp+VYal9kqBWIIJrGUkGcNNV83AMEIYooVtugelgliK+1z4GDN6Kmkb10Gj/ExJcWhxr6oFVLhGU0xxn1SYPz8sIVn/ENXJITZ/cRVphKSIyywqcdPIC6NQ1WI4MccWlScagaABS+/vtBz7GK5NfsSAtSJhy6ySz5TStqE5+n1xgRVHcjbn1u3kSprbuMsQ9UXtwFDARuYYOX0MXFgmFPt89PMKV0wIWEeFZdeYozQ0rj7EO4x+tt43HARUpngOScILNYKidUEM90MBlmgIB0yylvbd9rzW+iNVzG3GU2yV8Hv1XxxVomqFYKF0slRtboCIKYvl2qRwfYdyRTPfUHpth2eoFSJ71oO59++6gLV363lksLvRQhlyHGGgQVIK8iyBo6ULhkkmywogQETwx1BJss7tKD/cCRgMjoyupZKB9QqQlGRkXWsBA5VdNth7jF/a2OBRXrKX0GC9dxp2xts4cqIAbEet+zceb6HlflFBB7cylef1J1KN2woDGqS8GXoHWoHqBGgFLOJzA1eBxzzsnTx8hj4HyVxslkp5J4QWxCKI4PPK1eYOjxDUw+e01lKFoUj1F+tbvTynCZDHITbLB25Nyf0wKoiTxCFSSkhMqJ43by11oqAzmC180yZ0LXtOzO/ie8PNoTBkG7SxPTfho75egmelmZusDeSbab/sYllGUYZQQ/gErS092jw3DHMBtEHSOKSDfVS3ozriZCuJVJcW8b1TKHjjI0Nt1ffH09R0M0KQDK07tkk280GkI6ukz1av5RbAcO6UJMFClIi+S1E2wwKzTRoyGR3b/WqVfNA1KvJ9O/RdFagtYLB0dlMU5Ps+QN/ufhtaX+HuaYVv7PdAwfh3hgLbUTVFBwlX4EoN2E8IyLDkjoKcDGRo3zRO6lZq4qgus4axSyiIg62zmR8R6R1FYemY1dhmWbVgL1aYEN6JJYFvPEKA1cJVf57FMxnF9lg32uWdrcHAY1OOYKUeXvKBSIqytCfW9XIVzopap8jEM/luZyn2+m1WLnaG3JrQRZCZUWAtrAzNb83aW2RttG0DoqKywtxabow2FE7BjG+4Ru1HRJAYgz2vdW3Fu5VtuGEATTKAWxghcE0gGRq2fH6ThtYKHqrtl323JvgDwQVjA9EmJ5CpzVAZQgVzpEy2ypcQjSqzWmx+VJaEcYtE5Pfyb2MsDsZqLTufVIvmhCfCJIfOq4K5b6wu+3kzZ/3CgGGJhY4UAWz/2wDtDhnd3AlG45ZXBb2WJZ6hgbVksKC9jgCqSH1NCiKgyNHB0xHLQdY18GU7E8V+tXSJPqnses3JjVAq7bpD2bV72yrPo+dJ3haaqUWzwmNqfbv1swQEwbizgOEB7QyEtFbqwD3dzkd519dGPPidyZXldVqqbtWODJyqyx5ugQKO0i7eGzSvfLT01BroGqFsP4brbmmyFJttlKR/MzSs06KBpf57z+JrQKDsB/S+rKV9aAUVie1r72NlTgJFJ4lEIUa4Oe8pSX620cx+jsFSvum4e+ViDlsTtkXxoU2SxYQLE7BZqKO2YLw2b1y+0xbtBSO2DNmaavacZWEjw4oXCdaGZmg1HH2GC1OtUm/xaYsK7W4IIEm9DjpnfGs66c9mxtIZGhzS1t0hb1GBoHtK0I1PgZxBvT6/+lzRWE4ASedlJf9QiR+dS/wZMRGzLGItA9ji7GZ/j4u+ACAygZbz53133M3Vuq0ai8QDtPA9MmDSuhiGf2/XaIK+5RerAwoFH8piqNxagS9AIZSP8XG47KxfWyjp5UacR59rc4Q/b/i5o2DE6BnNUdst4YELdDiWJIEKEGro2q4JLIpdHU4IV6ZZMc2Tl/aiPePt3L4Z0h3Qmtpg9dHPWf1cakEbbHtUHinoEisngRAF2tbiBwi5Qy3dDDAvza0qaEjxxub3ZrEMedIO8vLa9eTKvurkW26zT5lC0JM8lBPc7F+zB7LIRolRKBb3wOh7PerCHJccBioSBZRUSfrPq/Pk3Yy3YLk06AzwQHogawyQmhGhZd5lxrPnhsC+0/sCSUaF8VH3yJ2QnAmYb2YJDRkP3hbG4iGRCdNW20B+xwRiu7iqBDpo0Ouy4FpGccUEiKLonHIwCEsvrBo2oBY+AuaWaAUdUdYgYDC9lbmK2zKC5aZIh3tlAji6CscesCNI+Tz8YATt70Rnis/bjDQryOmz7CNu/qTBc62bwZBZlgX4nXlD+dBWwJbmHfsyqGeh4LnA2dGUNYBSKG87eGF9HlVYgT7TgA+GNUV34mmbi+0zo+08MaSH0DsEQSOMHXQJJZoGwoBa+i6UqDhiFwAxpPmy4Gx5pX13O787zzdAYgDBo6CoVaB3AorCL7ZTdgqoofWwGNBAFCOE7vA8NKMBgrE2bta6ZKGSE3s4lCZ+IDiEhcxeeFW8QjSgafuOdo4DkN0oFDOABrLIFFuiO+5Fu48y1eQg0njqCGJ+g/GWlAugxXyDg6KoRmlkCw7EHIjzm6E4m7htnGVvteig/byMeFdrvbTIj9lq5YbxGSP60aKg5vBrqxdnVzNEmFzcsCFsb1Heoueoy4g51yU6NLn3zJBeMvZbc8sVw0dGZP+u09V6FXEIF3MZeNU/4rmMqvdoyIfFLWApvboHbP5ny9jSvTCLwJ7WbI/RPqyTIaJWsOU0qnaplx66RFrE5Z9V+jY1KHZyWuVqxZymqCPYHIcl2ryQu0jl+0FL+FzsuwowdA8dIC5Z3qFQWvfukE/bufhOOM/YlQG2tlbJhFB261I5uLU4hooUiCSMhjaueNr9qjDFAmQFJD2sM0V7rtt5L3sYhG9kjhFUPuq+HipNO48JTJqKT5EmYuu3uVr9TVirxk8cNR6BJZxeIHXbEqJJKNhb1htvU7P/YUnb/3Ezj0ZJuWBYkmvU8kpbC9XAHBrSdhmE2L62gGUZvBvfRDx1aa6Iq5pNmpLOy5USAigdBVj6PAN5d1BIdxpv7Zpj17btCwhEjJT4iC+8PSit0DmKDoI5DdHWKuZszsPFtge27TPVvtOUnvysDt5hqKKtywlhkJCTmaTJ56S/xaCWwFGBHnLl5toSvgLmJgqXE2BdoIkIGVkz7wrkFsBeGZycoYe1NRYP0jkla4BHamnId7y1uTfObJQAIRCMNRJs3B+RimpoWtwJgYDsfhoGPIWbG5ofRXMxeIDSQzg0CpcxuE7YaNu6no5Yg5ruXllm2t7RMxykhzUEsfHLMi/ZWuN9yjsUiQwtL8d3cOQ57WeHYzluhiHcVGGXKCtfNh76pceFO4YAsgJM2dvkYAmhKEEgvzJAQAMnuWCMl5+LUHDfbD1HrY7ggyEAtHMX/1HSbEfbG27fEcorRKTx6pD+9nGLA7MDJVZgCO1mrd0i9JZcCYC356VJ7PA/Wtc/D3iy3ceGIgMaDB7otLD5Y6BIWumzbI3Ln5YhF3zHAJqeMKoTKA6/6oij+6gRH4p362pduxIq2EH0m4+774qc2jvnbUL2kvDNhmnLS4zRCIsBs9khGZqYOWe/f2RI/JhTq+Vzzuj7HmH+tp8dvt9/RMm7VuUaiQnyIsv0CCXZDqLWnWOM6b+UeEsiVM6NctBLnlRgJ8rwPm1k7R5qk6pKg/fK/EXI2FUH0E6yMEXitgcvKYygcYObJEMF0AuzgLZie8iACFBBANU0UO5ELHn6TeysVS5DIKHU4KqlO0tWrReJJr85T5sc+H/UKJuBsleycMMf/hnt4mzWhdQkDVFgoOGjcRARyOFHsnmgOdyxZ0GXo8Hd9u+6F4xmX2Lv4jzZs22CoZaIrBRAXy1iVRsVWsak+c4N6Ni6A1wJfirKy1Jsa7G3ZYXZnm0i8TS0GZV2ZoFwZ93J5eT8g9p8T7IUCUBK6uYlYz1u9rEMnnfElRXqoNkvhuUUGu2YJdbi1uiSoloGSMtANwSw0bM9c/IzYS+5uerIPfdGX27T7iNjNdbWyrZm3+z3JneImt/IGMTkjNeI3DsTcjl0R7tu8v9fEsLfZLwl5WIBvVZQxEJVyKahcJE/g5kBqEUiWVysq1H2QLKmeQPFZKhFPmNC0q0Q/UjKSRly6FsF7sSA0vMrG4JL7BX/LePEBgdyst+16Xv2s9wINq7GTHowSA65fF5SLu0Ay+dU2eiGRy3QUOkytEafLfCqtG9QjisPbWnf1orEapSepP3H9ODK++xOC9s7mbMpIkJCdkXSWIsNvVvlH8OeJX/3auT2sDA8pTspg1sen5zBqH/yvWhAw9CVEs82BcMc+xAdDVphEt9rawaI9N4fFuFUWJT6UYunFcZtnOvOfm6bH6PhU8i5kbloAS0fPXu20zn5jUSwwCsaC1nWay6q1rJo96Pt5J1MRalsD1ewWbbtGu3qCnlu8Z56bQPHo/zQnDWl5Z2AnCkt7wyMcONEY8ej4E/foOBLV+oX1MSeRGzjKKgSqoRihp6zO1nldvcMEKDAnskk5zkZ3Qd1dK2MakFY0MvBPAUwtMSO4FN73lJmXjPHo3Ere759ght6D12t4kW4O6sFeIvZYplMknOY2M5kbPxxZOFGkGU0UJmR2AJQRrhoU88MR5fGQMkyGJRoKSUrXPfPkgavl5m0HYyELmXACugoAdkkkqGN5lDogQvF3bheGkUXTjQGjAZlATG34yD7dcpJr2xGAipQQah56F8fCi+gSyTZe5ALfKpqF2dcR+BKr2oMl4ap1azH1AWnDfHB2/sCGJBaEJI2mxAt5klToJlKCHr7TuMeAdquAxmJh3wjdBSVSco3ov5F1NnEvWurCQhflI2l5AKQ1pOoBd6syZQMOO5WsQNnisaUcyqSRaNqys0l4U+zg4cj51HzDNJKeeumbZaFuRpjnwEoj9n6lL8Y2oMuXBh+qQEBsNYp1vwVgMTtqloY5mtvE17Y/5QXqapK4Zr082A81CB2t5jsLOnfpd3KsAlpq1ws284UC3Mvwh6QBqMeLyK1YsJKZFW27X/LwDBpyxpyACXJMVSLvodiHSqDWjlVapGrkY2HGtAzVC52XmX4dRaIcgXSXnvJALLTXIPmHNlYDjgaC8hG8LwqfjJ+qo2CbralcUcuZ492XYbHRa38Yqm7R26zVd/CeAsB/TxooOYB1GYZVhRIyhDm1oKZ+Tw8PNn7Hyk6ZQApIZMRqkPKFrhr0VhC7hIsLhKWkRLcBLwDYcv7bwO5qoj8JkXyeBWj6H5Y8LStIpY/iQlZG8KZpYIkzEJt8JkJOY1QuIDZam8A84W3N+0JjwcCNVfkEImjsSawxOAYHDJmueUQXYY0BRwK48pSDyAHvEWUZh0aKjKBm4/wWG6QMCBWRaJQbn7QLbNJthjswgtIg3szAJji1ZGSCR9Bf1ULIpeFSVisIXxE3ho6lH3OWRv5sdl9gCUKCOvq+weARd2knQoNFn++d2qm3nks5mD8KTyTmpor2eshepX1mOXCaqkYaI5uBOzdCJoODMmslFaYt2Ajo3BF7kRec5XLo9r7kmyYshMwIXcyUXPP0KBpp7A9iLSFSGJwY9HWarckisXh8bvGvZO0Gr1ykZsyoQ0YE7z9fHIrLnjeBCIza6cOan4PyM2QcoNll7Kvj0XrAARk2OVvVr08BJUDulDW89cBsN5nBEsAas+M7a4BFjsFdnhMvRBSFND6O00xR1IEQfnJ69jsPysureiS8jOzv5vBYLLbPluvEnzuAviK8++yhcnMg0y6ux1337iSRn4gGKz3ZTSWCAgZSXoiNppVECHkTnBrRWH/r21ZmMRna3UyRNDPNgKf9TZGFxLJhQBVcRsIA9p95YY4TeCqgjEmIwaxaX6CZ3EpsXNrLXg6r/2gORiN1E+UPKYCPcBsCEUPWSKLTzVZP0k3nlzXhvDwy8nsnSYM1dIbBCAV9YBcmBvDSPV/6+KBB/5yTiBkMBKgee2C5kxRNS4uE4kcwf4QdHH4RTZKwzyhX4ahevM7O/NSe1fQEAkmAw4NIk5MIF1fUrqlZEhSn6nXV7vtY5ZAEn5LzNDe+85f5gr0QyRwc7A+o3P0ftQ9rCQ8a8ChETpJ76QPwWMuTt1HDpo2TNbMDf4dJyCWBR/BLu8wQd7uhxiEIeQ46d7anT76IkqhjOyKYBFjyfffBaeu3nrf1TqMUTJX2G2SUEVgysX7ZsFqWgiZRZlI6xeOs0OEnJrOH65chNYGUszdKZ8JRD4AOpXBJLLGrMKGqA3NZR3ivh/5fsRZyCDqAHQgP9MhE80QCmvO/t5W9cuemVWth9e/Q1Rg8SBA4rXJrhIHYUhrPVc8nL/LFHufAnCzmoRH7F6tAOEDvgIwjIvenQVz98oltx9VtwQFkRLZ7YWm9ZrWKwRkFhTUEpxyoypMwOr9ApTtkq6qgjuDOGnjx+SboCoZRLlpY9G6k1p0aOjJhFXMk+yGQm4FtwodkCuKpIWS7T0iUKWYFYVo/k3EWvT9hOqt/q21diWZR6LkWTLGngRSPdYK70A/lhARd2LEfti1yIb27HMt2tf7i2D30Zsr0A4KJej97uwKA4g4iH7bn+fp48b4uq/C4Ir0uIkNOa+Kb76aO8fXv4z0kyo8ARDUKGUi9oNXawWnJmCrkW5xoVp7f4C5Q9u2xpMRlD8cbFC4pSrrc2DboHU7jWCAvRuG0sfySOfJpeaeapWxKx4lSyMo4ui1BcJwF5XwRh4IuVIXAySaXGgln49Z//GO5rw1sVITS60CNxIEmYSv4xZDcUNZo0xQdZrAi0EdPQJUkTKjckLlXpWdWMLZlLwCLUlYaYFfgtzlIv/OSflZ+6fJPFmuY2c7y2E7+toBPwdeaGmuNFsnmlgY6x4nOwMKoMgSA6RWjbKeClcGRhOhbqYssgDWJwy6Bv1MLSrfMo64fO1KkOZnrXJx4GGWjuq6nLOeWaOCKcFWSZpD+k5Zvt98vKWAPjSzSBB7pDb6QXE0Ff7AlhCJYmJGXEHIeujNB6wWhRz8bojA9cZBM31NEYQ2h2+8KZdhCqQyhiOxLFZKGgFEYBSp762q+KzNfk5oBUJKWmymJqP4cxWtQpE5RxA2QQUeDYNkSXP7ieQuexuOzBiqxMWd03YndgtRN71tYpnQwe7CEBRrn1GGAy193+IxIhScZk3FL6UhU7dAIqUk9+FwFeVhjOi2JrSlS2qAB7yepdaMxH1c0asXIQmCVrRsW22om0KxouU9MjNe52iHtskitDYf3HSpHiB/gl95EFfgJuTcxAhZgMMw7Zmbucj7GRIrEGXeRHtU86vORtyV0/KA8on3hqHB88PtGIFvUj6m2g197KbIdF+ZWb0H7bNs/h7FESHvitHiJPA9drCU47y1XZOjRUk8GzC3r+lys1MqElckHgEsncEkxiHV9lJAKq1pKuttrB6AJn2XKVBbT7M3BiyhLlCF9g4kmcHW8t9iDWRfDQXnoI1F7qVGPhhtElcwZyC7zIZZ6N5lgeG1dsbTYtEuZRgmrTlTxR9P1A4C1YDZUhcTKHDSNYgajphuSqHkbOoiIxrPQmtp+T6++bh75WJKQAlbYaZ1CB1DiiasAjVbMDuQpChTFdSIDWNIgF4wufm7VdFUSbt1IVe5iQM1hNArPLOiVLKOrt4jymntys1a5dfYgWbeJgr1wJHRJPkm2DwB8UEjJTCSCoyiPY8ixVJyz4cC232phrgGLj1oVTacES2+YbaOB0d9JuKKYhRABVdrgLKmPgqaJ98/gJG7jFpqYxU1IIIZrfC0v8sNeRYURoPUVJm7oOxcwHSK9ij3qJVAceGG0kRcnsRJXCx22M31pKeiUYFq2JLuH4AsvdgSxVzJLbRIsQ+6cDyLWdGqWmUpee2EdGeo3v3bv+fCsmqPpl4VYfR9Ez4wRRDWb1W3ZFKXTig2VUR2jhCAS1eqFmE8MyHcLVxDuUB/X1EB6ziANFDUljiQIIJmOSZgezPkB3X9ImthYouEZUvFfaYZSaR0hAl8xOVsEICQYa40yRYzfkgamq+pOJ9V1OhJJ8LEdcNgMHy+g4sObQ5o6J5EUVu/QhHuanXpfKF7myihUuPapSzemgaES/0eNcrFFHnCCIYdWK82YacLiWvHZZYBQTtbdm2yhA9kzarC/VPkoCyUJPs7FPQConCacVRJ3914S40rZYObQ8HBJP45Y3D/SRCWG+aO6wFVYFo+vX42Ndkz8nhzichbUkpax61vaYSDZYHId5MymWiMUHjy/kgrtAe1AowARUsANFBPR7KhbH0tKnJz1hZg8FTXb7ECO7jW7kE9R0LDtljSH9WkBjqtzTXkPij41bDWGVplvswTblHBU0YDJduz5SKpdv+Xx1EEHfNt9z1+6gpU38JmoUBdOvb7RjgYbWytZum1KL5Fje1a5HFqaSNSMcXbGFbGnZSL+eiNAI7kyYCFuu4UHyT9rt1cmayzdTYaxUFtrTd7aM5Zry+5U6KCUzCEedPcMXnWWdBWCe7vlu1WS4ZocCGZc5MJcnsdqvNN61KlIwwh6/LW/MpfZnUnj8VKfIJ0UiYBxLUuHcZJrTfJRvQlaauaiIElRL8x8XhYJbopY1VoykvO3xRzJkpN9brxQtQyCXhrAWC4hwgANbVSTvdluvi+Q2M4sSfte03mRWcE9j229fgJ1TXJH620pcaLEiDBxRMwAPpmvRt4NLAqn2tkKoU79m7H3VfoK9LmWv0mSid0c6iFAuanU01LDYdATT63CFrEjIbiYgZH4E4W1qJnI9Cy2eZuInuDV6iWI89JlrmiLhEynW+b6owVTOsHqEHovn51OwiisXU3Oe/UMoIqLJb1WouTEC6x7lAo5kpSQQN4HAggRdWKmvUQRkDRZiuCiXy/tHdqE+CW9bSri1kfFSxDRhwOXQdb0D01z02K4BPkmtqoIYEqFENYcYRc+8rTba+b+yyOzI/CvVNqCSHa8M5y/r/9yQ5KTBFYS5yY1zKNdKdtK5dd5LC2Hn6g1c3EiHok86HnNJznnWgegGF53TYNlkC2vzNIGFY3Nehc52/27Bu8H80zlpuUGu+5waopz64otQLU4l9GtbDEVYHYc0nQent62jVA452O9pd4wARjZEyx/781mA3ZEmdPHhV+rTiXR8/BG9EorATl+hQ3yXoMRls8+Z7aXvo8QjFS81x2JoPLXH+feUkoYCgD3kUk5G7wu1kvATT0t3evU3y8hfYvki5o7pzh1aAmJNoZRHDY9roVliGRh98yn7CjWgrGkECpanBu+1fpU48gWHJit3OK75IrD+sU6ogAGjAnm0s7R3sWfDPkAISbwlCGCxmbgbmZGtTSrr1dS1DLhKsdQGGjcEeQ67G43jaaXQ7ozhpEJU2FbmYQtUtauX8HhhpeRnY3HBdxJ8vEMzeMrZOdRKR++Ia3PCuCXVg2hPFn3IkX/BEgEKoH2uX3IdyP+pSbZ7CtQSxJy16zwDQ3ws/cW6oemrvih4Io4m2tsAPiGvDYa/tewZA3WhTpQqEeXYcIb0u0MPeSubNJz6WmzxM0FRiABcrvsMVMIciabThCO8sMM+uFIO5NMvrDOk3os9i+C4kFuUtH2rQkMqEcmZAGUly/tnyrlrmJTyGLuW31P4ZeUtjo1IHMAMIzgOa7bzxc/qDZDyZPZBEAajKl+rOHnoMWKywDGAoeqPY+SWixHRkE+MlmbWdoyFvLZyAb3blZi7kMvwnIWB53r1xcu+sG29tj5ktDBYLWAgyyJGATruJe4BDQViMB1b4Vxd0MR/O07e9GpDYH/E5MT86EZiq6Cmifl0IJtZYPV9ZUa3tA+KIZHIaKISQ29oqNI/uZ796yUFtSBn5Q4kc299bHb38x+uYkDQg9SOl0UkGkSrOllvmEqVEaLeO1DHsn6yWeGP8ypo6fN6jKTzw3M2mLuJp9dIvWFDgdASbDeTVzJsDzEpvDsuwOW/63v1ybtXKlxuVqPDf8uCksESisPa0ie9GEmHwmOy1A0ESK4RnxaaiSNcXMZEka7C/WVw7ob2fULBBbU+RJERqGhAOUZn2eBEBDNhRr0TKp7pxNJEklBKJO6MCt0BVLpTZWDzVzjH8nmEJp1zg0UExwR9U+AI3LSlp1nBdCe893+zx7p7sAjyiW5l3+/TsIXJdDBpYRVoEJ92QAGCorlgUp+/+sPY3xvitjMku6ORe+r3YBXrNs47+UgvdUXrXyYajP4kzd+dzfedy1cumLXHeak2XvNFkJTSdY+zNZIRAa/2rlgfvCOJbVNcQMKcrKSVP5ajzRoYVu2BET3DaJcEchAUMgVmsjCpINvZP6Wk0gOMNxZGF5cFvQxrI2Z0bc/sYi0BwjmeK0gLcKVm4Ptq8nZmx/DA45GmY1JZiSr93mYgwWh7PC+nZZUZQxpj9HlTgvuZ9sg3wLfN2xj8tzj+CzfUGY1x7rli3sYDXH9w5MvOz2dNoxw27ojOea71h7NFEotWXF8kb8AqibxuNVTZzEZqtCJ9rHmb9a3pk0AG19sARdBt10Br5y5lZBNXxuwooxeL7vg+7lADBx8/RGqEfrESj+a/ullQEQiDipPqnh+VplMtly2ge0OXqrYqTrlpALkPNU1epy2UB2zuQU2V63iiApzxtNyN5F8n6bZwBbwFvguC5tPA9KP+da47dmVXdSoMuuep1pADr9jiQLDRWAnUEBbpY5Gt93HZKs5ku+x/ELgMuS3tMZH7lMbAhGvK+cxcFsbbWVS80cna+OdqG407j7a471+s8yaKQ3PPDhv9bcdouZmPCnCChKBT68+62u+I5mmAnWtl8PGi3PnDx4ChSAoxrX32VWQvtsQ8wEwBB+UyE9vLI0kIcFlJddHeY+szlrEnDME1hyNdFAiIfPMzbR0Fk7b7SuFAS9gklVKBiLNsqA0cPTpYE7Ctw2W8bWY0JcUniTp7Lar6jZR/luGqzL3+/vgki22vwO9cghbekypLXtktFGlGjMQd/BJICiQWJvFr8wC87506jVIPpqdU/NxV3t+qwWhkHgYvtAcPceZC8UJrhAkzlY3AXNu1LQmBHI1blgCLqGdPSFt9pfKQgVNKZskn+8BS9GC3saA55912a0yeetGC9e6+CGrFatif806fWmkAIctXvUFgYDXNuU3EYhDfZY98T2zY+DcdCdRij6APGmtYb0vRMICoXcCHN77B1eyGxn5igoAMl1zkPXfEMDpfcbWRTtHgZ4JAxdY0f5AogzRJaZ5grnzlRbHm8pFZnZLqtiWO+hOPgt2hlWGrNAet2s8LUDANcCeBV3BdFooEhIkedA2TCaQyrviHvWCRa4N2UAyJ3cgSLuIFzAWuQpAkueVFFKc3CaZAZQpHGCoQH8yHBjdWNEzQdrB5xGyOiGtUxqmSvWX0toFAjCEJ8dPmOwoTARerbZdIL+rHJcq5q96AwYoGdrx1LN9tIXNgeXrKUHKw+gNbNDyVGzDkP1rtCbn9lnao3WH4EgG4HA7M0uDaZKd5oKyTWKOqYwrPQAHplfWCJs8bUErRkw/jKekndUv28nEKfQoY0hKf96OrtZUDKhRFn3X3uLUQ4kDp170xVi4E7zHSFNgKhBX1cwts9LitoJ2VhERxQtD3hLQng84NEm21xH9e+EpdDytX7Pkkv8y0c7/7bfb+/fGX4OmgrcdEIA9Mw0fw4Eoq4NjWJEC56MfkEH+1kA6DsDE5glYcIe4S5UloXHOE1bqcL1J3yTuhJWYBcKYFjsaVYG6btijpEcYv/l3KHtXI5m3u1gMCgZQLBOIwbS76zIlsddKxfTkNL3R15AtnCIJvTKXyeOTJ7AEq9QAiTPgLFgVgVXaazXBqhM6LSB5kCT8P2X55IixuXz0oguO6GyAzC/OMMAtLKkrUEFlvxYkDihQZamULQqeXjdL+C9z5QBvKOBF30pOm7mWzmSJkIJmXAhWNW9zbaR0Y6tQGgq9NU95EgFLnxEUUdmWusCiX8rhZ0e0E7WpiTspBh/NKnazLCecm3lPTu/hIBo90twZnYBQdwAGILUUZCAm+p3cZhAs+exgw2CVUsHcmNePrBKfy3kZXkoGJKIKpZoe6up8ZTu3xKKtSaCSa84rEVAFIFQWISJZMiZAoa+15CkTU8tfrPKTDg1YC4cLdobwpdlgCHAiVJU8Q6722SgPABYo1VSqG/ZdLIueZ/VhlliQymWjWlTM/BhZ8ZcRcEerTLxrzVKMZRLq+Ba+cJgLk4X4R3jR5c+ei7C4efyQHarodkwNb+1yF0+NGdmMFql2L7Jj7PFviDWrH4+pwQgu2vQFTzXyDQk52pde7j7nBdh8omafy0rnFY+G3AaghJTVDEXCW9Ex4+3Wbl45TQSqmcZKZLUbI4m7R7LFbIxVzlAVtXsglQ/xSi+56SCaMgITfDXlMNAQMYcwv0F2F0nOrnBB4euIGi9iW6cLiFMT7Me2k3h5rG2QeSKyRC0kq8RDuTPXUabQro2/mFKJxB5OwSZq5CqcuAq6yVRzhjke2LL93stAG/r0gI5d0GRiWkVZ00BnSFyS3se0sNIrXEfdRQm71wtcTCuloab4jA6fIn4zfLCo2UOqaK0tHIGYzH8bItIdDamfsS90x7Wxp/v7rDwz4cRkEJgNMor54xS+/isC0J5vhXOAfA7dYjJBTY7j7DTO2gpz6p3yA4DoDUlQ6tAMq5EYUsLLgaqxhePCCP2rtvkHmYO+rGLWc8ebPecSJuLGrc0WV5AWC+MwMS+P9y2KcpLglF4M+dO5qxHrVr7kxSfYYZf7WFXaaRQOzCrG0RSzG170tAyFEi8P4bxRBIeUG9ANG2NT1qMTYCb0jsV9QwklztDwMAORgDhwaX8jeGcDMghQgIW54u1GHhQkEQAGnDnsot857yoN55p33nz8RZa7qvAdEZi/zlX+E1vhOQBvmWfpG2uOT4t+B03vvERoSmvJZfz1dLkVNBTkop4sVrkvYagohmbrkEZhQSKOROYGwWmDCvUpaSsL7IKGd2got5Nc1oKTLswpQHIJCJQ1fstlvLtjV4G9cxicNTmbkJlAlaE19CqePuXoDdBlQ3MbWgptEVckkaYlFDtVkxDmCyM6IrJhL8xoElYK25Lyd1lR0GdH2tZnx5zASg60ztkfxlbsPGLPytYxYoXbf/k4ETbH+mN1vJjxJyApoiuEZL23nDrqDAhiyeYvWAgYcjry0ixjV8lRfQpdQATimaj3dktEgJhSBzCwMD197SUGbpa3FOgey7ZSm2VvdExhH2todFaN5XPwgWU1THZ7EJpt3Oy+Iq5n2OdJkiVx/QMMUrz/KzWEzv/E0iaYLprfehWa110lblJU/bdEcWTUtP5t3WFUTNn+3zLH7aGyFIzsGXPt7vtDYC0VpG3ZuJQSmQyDwY0LONzmIxkyNX3TAV/dDRo5LTrLXaZZZ0H7HsWHyaQ9a81SdAGq4aepG8y3kLjyuVb+4JQvomNYAOa/Rv8RH25ZAijYRRq0wXhyM5Qs/lJl/VmWkqd7bqu6bM1PPiDwCOMeCJuvJFdG4cgtZ/M0lJGrNVSpOHXs9ohbP//iAmp73eBdqRfFwY0bunc9wWUMlJOg8/4Ov1nRuNYc6vlSqloUzH1IRGjaRCSpQWbs8oZTp8nbSm0Kt2a9nkfLBWawMAVGAIxXEvtOpbH3ZjhwZt6GCEXS9kFckEruJUi7TB6JEraCyuynkzQsllDTj6do1keFLGmtuu0PsVwEcy1IK12RFjVdr3qXhy0e9FnCB8WF8K1WiKKSiPDxgMhHgKldfMYaidYK5alObtwjSW359jOafvveFerNFya+Xyapywpe8CvFW/arNj6rULehTYT2nNM1orlDXhCvtz8lTlkyZLMaud8lO/Y+YcH3wvFY89v07m9VQw3W2ZYRechz7S2LjTcQAU13DzfaO3eIkbz+zaOGjvIzODCWpbYZvvaVA00CZip7iVTMAs4/9zNuPuAfpdDoAAgNj+ybWwdoK/2gNgiqiPg7KaoAlm/xGhwb7Uxsi7cFKZ3oDXltPQuoD1QreUyZMp2yPwjZ9yDXi0IUUTBgPYrM1ebVu0XC3KbeyQin/He5N8HDRkpArR3zv5IKck+QONQDXoRumjsiFp3lwihLo99H4Dh7YDCO+wtOlSbO2oJ685hGqxTbKQ/62dTdWUMWAzDXGu2TiMmlFZDYbU8lkGN/915TUmodK3FNi15O53KLG3bqUPR3ydWy2FRMB6to3BB8UC6KVVRUrF/SlXOsOsdQG2Llma/lI6VpcdYsrVyVvoKTRwc1bjGwDIg2+CrJ1846aKDxdBCaOnVgBwHHjxwYTsf3NH6upMgaV1hywLMnhN3iLAqDIMnRJArOAbvsxb/Bi5DQAqtTSCmht52aRz0GJUjcsfXLpMLoOPgrnXpWfcIHlg9IQCwRI+AkaQMGDQjp1MLZv17ZMC1qS9xi00/I/7LO9DflEKj7HR97uZSUDw45za3QjBLR9ODdHeqpCG7tQZEtxXjtWV36xuPu1cu5k9XsoEAyroBtUFYhnqoRUOykGKJNpUBrk019lAp2Z8pRcoriKLZo31ON7MuBR0ZVjxkJmhkkrV+8XaQClw7DMYAcS94xJhMMMg6A6VLHn/cTSKyJdqDCwCpQJNJEvSNdVcN9sVlaxXUWcFdAeqSyQtIFpMKpqCRCCS7U0cObotUFQH5WsyltORDH/S20gNKDKu4H9LRZT6IxP/v3aObNRqSzjk7k5PzQVzbSmSWIxpLghAXirHpQpiiFrpljWUU1FrRpQ6H0ylQGGUubQ+5jrC3s4/FYoGDw32cOLmBM+c2kboFChdx87nQVsqxWQ2mHGL9EbSWSKG19ydzGzrStr9bHZfMm23/teW6CGVRdIJ8lwQFR93YsgC0Pl3M0eE6GqAaOJPeejxQTAFK5Bg0VpudG5P/DW3asx/p9QbmdH7WgZnCeg3amesWIMqWBxKPBvxcBh3Zf0ft/9sxJWrqyhzXw4SvoSZqXtPKzQA1Q+sOoIG3JBYjrnQ7fxZPSoO9sSeYW7VFr+0DzTmtMszcUg29GeZZsM8BTOY+V6Wu+zzsvtG7YjLlUZ2QrDQ2EgVoiHe/3TEXUFNEODSNgt9sYsndIMasIHFXmTKwUD0pWvb+gHozZPID2G5ybNTQL13juSSBY9HadgEUu1IQQbzcHVnmHcIcA/cEN4giUEJV4S1NwZMG360zcWsxcfOOAoCqoGiznNtPBl3N6iLpCwVFqvrAOJj6eUeR4d+3miTY+/2jvCQkVDBScsVHfveGPtvQob3S0FajiFo3pDF7K4DuhChd2SPODiNiB6IXw50mc2CkFpTYfBiAXd0ABmVGqRWlFly/fgPTg4rXL1zDpNvC4d4MW+vHcPL4GSQa4/jGcezcvIlrV1/BQ4+ewcbxCcBNXFDp4OuhAlBFwkgOqCoy46qoDWBH2eH2gO+T/C3qsIzeZmE6IODqHXhd6g4gpGyQyx9XgtV/H24Z+V5qukiQWs3tfopusXC0PR0+z/Z+oMG+aqso2Z/l+2IaHm+ENTeoO2IvaL5jExp+t+WtcGsOphlPaXhNpmcpzLT06cYCQPB2+xx/h2eIcmwLhO/YFLZPfijLgnZB73YG7PVAkfYP66/m4NLKLpo0YfdO2IOqxPXcm1MQfRZlSNhPuyiYouLG9UfW7aNqndKbj7fQWwxLTKI/A2tqqjKstnA3ErmPHTFRb+OO4hZINIhcZlS41rUW+j4Y3t4gOolCz6kKZw5ftdxCB7QZEv4OZpRSYNfaDtbpjbuU7WpBY1mr4kqO0Mj/HgxnvZooZS3RMd/y8orbgKEE+1oXhnQIhl+sNTjXbZdb0u5XOdYja0pIllXTfNbEB+vchg+2SRqEcK4dQL32oPiUGktxILga9B0uG8F58nv5l8WmBmDCvyd8w1XiRTl3nr3U9z0O9vdQuODlF17Dyy9exNeeeRmvv3YFZUGolYB5xcb6Os7ffy/e854n8a4nn0CtjMPDGTaPj3UvcqD4pX2KICsJYlz+CNq1iiAa/Mo7V6sSslT+gUvG3BDs62bA6WlKyunZInFPY7d5xD6ZUpaygAZwLAvT9kqIBtiZO86ARIvql/c/aOWUuwOlqu8p61pNGcqZUoHvjzehClc65DzcuoRjvlFHpEtDxELcOlLLo9bhWbK1GLgImjKadh6+Xo+zEAWYXuL/dvXt39mBZfwJaH2XeX8UjFSTZQ4IAtwROICWX5JXUWsPUEHrNQrXdCRjDTLJ3JVu/735eEt1LjbMdPcsIoZbNd7VVf/fzP9I0T26WUKnNmh6dLTMaz5wNuHNgOVG1SOZDIawAb8JMR3d5NbvP2BEt6o0i8Isliq3SqaUNb4hm8EcmyVM2wgdBjrINbvWtaBVLnZg27mnpnCnaIFh1swWZycnjfm0Y01hfSEyztyUXsqk09qLUKTsDQ0Bi/OEiGj3y/bjqHqJ0Vo4Le25Bm8kS2x3i4dsafFaAgpLX7pEUJOeJOGBCPv7B6ilYDSe4GtffhrPfPUFPP2l53Hp9ZvY2dnHaDTG2mSMk8ePI3UJ836KE6e2cM+9p8E4jp73MZ8WTNZHQUvGUMFo7KWSXYplN6Ci4QWOPfZzICDHrRkE74WSHwqf9mbQZgINzwby9XYfg+8HHVuvg/GKXQ7nFk3bIVomaCLPFcwyAFtWYCGEhqqkFeTDtbR8o0pbf+ZKj1t5omtKoUxa2g1jSHYedX1ZM8NUe3leqCnuOwCkWNswA8+Ec6sEwJoc4y7qNAQWS8PmyNw3dFOvSC1KwehOYG52uwLEDoV5cUQpmZvfpsSeCdrGs0I+qgLnXt7unUp0Pwby/85JSMvjLVToxwgNnpoDFD5EAtTniwaNtGW9ShyCP8c8A2w3o8lXm89QfJebli5vpLDkpwDiHgL2uQT7COgxn+owC8tGTurEU3TJbBsu35VVMzz5ly32E6m+LnSbvxeuTfqjf7SZmc0tkL9bIfYzlyXNiV0u5jQ7SV3f3p6jeY8JwfgRK1M2HWhNt5illkIpeOYTsQFJn/dAbDQocrBnYJCmQsslV8ovXCVxBGINSuX7GDkRDg4W2NnexsFBj/lshnvOnUQeAYv5Ateu3ManPvWf8cXPfwXbN6fYWDuOUV7Hsc2M8bjDxuYEDz34IOazA2wd28Crr7+OWT/Hww/fh25UQWkTIMKEO6QuBHtr5QkbC12IWiHaHkZqbmA1TazCQj8XVyTbQVcR13yn9b/HHOxnkn6a9YbCcIHqn43rpj1LDjqc/4Mf7PdJ11lVufISbwkPqvjjZSHUCOFWM3M7+2C5SLAK5efAho0mMUdm1kYZppkMGAn6jlTtAFODuJPbN1YcrNEtL/40edAmbCjIROORgQoq65JN3OwaY0hWdno0O6hWYGnOv/FIWAxuTVBV2mR5Dlkmb4WnGRdTmeRswEt7bPLDrR93iZWGRwC7v69VrHcz3kIRZdvQDnBPhk3atIUthI2QVtW5HHRsBYs8kEjcDymzX9tpxXMDpcEcL2/Yk4jgyWUkSFsKAxsl5TGFFgkNUR2povTX2FqUVVgzoGRLmogJQ9vha7GgWXa23CW0JxNrqdwyUbtmGihZyyizyVGjQG1vWmHFLBYIQRMdAPAAhjeZcTB3hByAcIGYgon1hIJlp1VknDHkUqi4BdQ+2/7pE2ZS011GKdo+paprisbY2d7HtWu38OorV7G+dgKXLt/EzRu3cfHiDUz39/Hu97wDGxsZn/n0Z/D8C6/i5IlTOHHsPKZ7l5ASUAqjyxmPPPwQ3v3uJ/GN557FE088ih/80Pej54IvfPELOH//Gdx7/jxu374F5oyd7R2cOLWFtc2JH24XNrafDDnwb1C7xMViX+YXv5NjiJa+O+QNrnWgvEzQmtKp2t4mGv5rKyFXUBaTbMlu1v9wNkdRqu69CbX2c+G7aqyZ1mcfyFjiotVdceJpkNhAVp4RXtLvuItaA+WIWKidCaEcKWjCkGbN2shrnQyYWhzVCnvDHeVn1velbfGvT1Z3E1SZQOUMiOROJTv/QvlB5r/JPP+RY4FwBYpQ7yVRx3iBwtXPdgWE3QWkZ8yVZzJQsAglr4oxJesGQCaW3CpDoxhN4RDVZg+OJvG80bhr5VJq7+3GBTk3SEqFWK0NutZ2KNLzS5Fd29PGFkSkFbaA1Q0wWJmuwO7ZNsQQ+8GNRk5IVOElrAzdAAs8mYBTpGkIiBmlDOthwirLyvxhOciqLbAqQTtdihxCkitG7ZZJAnmb9qXzOxitSyIOmB0KYUO7Xz0+o+avIidWX2yypATWxAZV6tZoMe7hcSwDEwbt+4eBx0hDBGR9pK3MQ5AIPSsTkt4BXkpdujLVqspbQGA71LhT9ZCWRUXOCYsCXL10DS+9+Bpq3+Hy63u4dPlV3Lq5h53dPdy8sQ3iiqtXbuDG9ctIlDCfMXAs4fKlq1jMesypR+0ZG5ubOHHsFL7+7PO48PpF9POKg/0e73n3u/GeJ74H091DTPcZG2snQOgxmazh6tVruO/+ezAaJ59/qWlw97mkXCvad7eSCqwq64jD79pf9h9sWdrOa6UpmAvaK5hQQWwNIG0fe1gShjxDsuUEWNj+xHXTeoaW3TWaPWR/t4x3SR1WBUZ2uVkAMuP5ynpGVNKb68buTBFaFVSIkrFCXpMNA1cbcdPTsOo6zPUMvZlyOT4KQGVBm4prlqJng3rRc+NuMmXDGjOtkdpsYQBQaWhkAtoC5TENi2vYftVqnp04C9Jkt13D0IVtLbHc+oGBtKpiTmPKAMK0bsGeyECzOuX3knEq0jQ7eKjcByh3uik4rKKkGMY/d6dciJdhyxuMz3/jf2vQsaELm6+aeC6Y499u/lca1nYghKcFaUmNTPludFF9o+FERNz/be+utYcJVzsE4rpRgmqgvG0QGM9kbS4YcCjSTEkOGiwgJt9p6xyIpDmhtfhoVALamMidlFooDhnS7bn4Wq1FS1GlHVwnBy4y3gjWbl8sF2szYkFRbpad9LCKK08AhMapYGhdP1wZQELK2VNgTWjY4bCYVtvFmpoiQQb858JRciNoytmVi1mH6Dp86Ut/gosXbuKJx5/AYrbAH3/+GVy+dBvfePYVjMcddnd2pUalLLC1sYHt7R1Mp/tYLObo8gjQmpEuJ3TdGMeOHcPZs6exs7OHmzdvoUsJZ44fx7l7zuD+B+7H6XtO4oknH8W5e0/h7L1nUDBDz/uYrBMsO4jZeMJ4oOX/5Jax0TunzvfcPm9cYftlgMaKAlvQQagKdOLKiiiANLBn/G8QKkCN/EkDF5yj1Yb30XSWjvm1v0fDdGj4FgIUq9VpIazWylq9L5+rtaASIRMJQFPlpOpA3uOtWMKiIa+hcZPFz7sLZRS5toNT3JtCpqQrcpKODJadz1pvI4sh3w5XQiytfGQ/ejAvYKABqqwISWM2gLneGD3iyoC4fTVkqPVpVJFov/du4029Gw9lgihJywaEziPDas+koDlkbxXkDnd9m4WEhExJHXwmF5IqzwVqXaiVQy4nBbxkfP93/N/wZuPu73PpF0PFsWQaybx10soA3qAP1kYi6gYsSJ7aZzaxD7n7RTdv0H/MXqiKoAojtnF8iXsoavDaF1WIVIRxa/INlQPbuBmYnVlIFYu1YLfnmZNi6OYJJqhUVcHkhvEB4jo4ZGhccI5CqT3IIvDNpVFBShtTLs0BYpIKXMARbFwnXTVtujotg+EFYdZaBcFQ0it6OOYEBiOpe41RCktGjR4WuZJBFRKrYiWg1oUcMFXkIjCPKtikKJeocx5KqcPN2zfwqd/7T3j/d30YtVZcv3EJfT1ERsIoEToAjz78IC5cfB27syn6vmB7exvQdHNODCJDgGP0pcet27eQcsKjjzyAY8c30M9meOqdj+PwYB+L2SFmu+t4+bmL4DLCYjHC7Z1rOHV2DcdOjrC2Ae0W27hs1JWg51n21M6DB6YLiBNqY12zbYLuY0pycyVVtTZLQQhTSUeWs2i+eYvbyN+RDJnLYzO1iFr4wJoqMkJIG6Jm9cm40HJ0LEon0jWEgVKSWiOz4G0uFttMLqDV8laOrrWiEsBeIwYFSxHjIOulBVMcwjcOWJS+5EV+qpC5gkmSPUgLM+P7UiRYdc+iZYy+lMleHsBQrXFhpiIInoMGKrUVg8pZlc9ZcN4UZAOqmrMNbj5BgAjNcOGZXKpFeJjQ8BdBM2kLQB0yjYW2taBLHZh7VPRx22dKqh6yepYg2WwqH8USH+n6RLlUJt93OZcJyynfbzTe0mVhpghkL4bCVTb76HWzLToHIlAEI7ehFneloXmuPCtZTERdTNUCTmqNRJtk0oMM2P3wSU9am9I6RGaaqVPtAAHhTpMbHdt76IllM2RD1PeJSEUNFN+DqCArwmc/XOGWqrWoxWWV2IqIyJQaodTi7eAB6UMlSrV1yZFXCITOd5MmLMjGshRamGIyC0Tqgkrt9aCZYDSllyKG5W064PvrLW0qeXPBylWRUiipoRsQIMooIHDfQyrTCaM8wWJ+gC984cv40hdewR/9p/8Fh3s7mM9nuOfe8/jOp96NP/sD78f+/h4ODg/x2usFO9u3cf3aVTBXaeejHYmJCKPRCAxGzoSNtXUkYlx47VXkboy19XXszeY4dvwUrl6+gp2dXfzZH/x+jLoON6/fxMbGFqZ7PRIKagHWNwBkVfhZ0ajG+AIkBP2JAEpmEbYXsdmh1fvltVVNVbfrQH7ZGYD11hrupbhOi+6j7GlpFZg+J3mG0ZIVA4s9Gn9GjdOgIJjZaVrqsBbF1u3NLA3YKRCybtqsvdRKa3r7hVe2ppaXWQVzEuVRK5av2I5zp65itT6ixMFqRZqaIhXQtcb5MMUoWyNnkyBA0SwdO1Phuja9VAAFMrUYADDXdawnrFFVKpo9WJuYnNHSEru4inxI/hxVxtSDa0WljA4dREbMUVnOX19nQLVLHApSN0HR67eNp2xilTISLVSB9pKoQS1oIICTW+FvNu5eudTijRBlPkNTwvesEdx2iOLaXLN6IEwL+wfcejGt3H6a2bK1KkjUe7yDqwo1cStIVpqnN2gFa8WR5oTk4hixzeIKE+vFuroOL0dLSVMXmR2FJ0VGrcDQT6tCtGBYdF4OBpUN83iRpsy0AWNzJaUkh6uwIh4e7kEE/Nt5aMZJxUAYtQkW4c+v3qrfBZ8W7rEKOMuaE9oaqjk6qvbsAhSpsqEu+XfpS1zw1gFcMqgWQbk98PLVV/Gbn/wU/vPvPo3ZfodR7tClDmujEbavb+Ngfxf7+zvYPzjAiy+8gAsXXsF0OgUzI6cM5CyIs0jq6aL0WsPEGE1GSDnhA+9/P373U7+HtJ0xm81w7uxZnDx5EufvOYczZ85ha3MLo8kYi77HdHaAuhjj5ecuY/1Yj3PnT2CynoHSi2JxyzX2tqEGzF0GNNeEk7jZLLWWSqOoa7+0X52DHGvnbzc7wi3zVuAtxSLgoFyfGWnqA7DF7fcI3DQANbRMxj/++DizptwARiktf8WcuJbGbS+SmUzSq0utdfPFubJYS0FZirc44DJEb9acPUOFfNaYWTXDXgFuG1MU5Wn1Iy34Yvg5ViAmdS7w74nVEvFQOKhqA+FqSbgCY+kk0GTKmhwY0LUCFRnS4WCuz1uINVEmSOMt9IuCPh2g5z3I1RRaD6R0LYuFvAcBLqM3JNQzI1ayuevc6wNx9y/qDHcz7j6gX4pUl+u6BRXG7y2o3zJ4FBfZpxgtu7fKxTIo5MwZ01uvJdOc+oxBhahtLqlLQuMK6idjPQ1RzAmYZRBKh93Ety47EfiPQ0tE0sImWw80S20GUOvgcxaDqFS1/UfjvmioIF0dzC9rh4O8cJTVMjPKRbBN/j6oyxtYZ9alNRid1WWTXNAZXS1YyZGdotQwk5mg7gF/vrrobK02D92nlKLljsVgitOoNgkGjLrokWgELgWH+zP83u99Ab/1Hz6Pa1f2MT2YYz7bByFjMhrjO558AqdPHMf+/gE+//kvYHt7Gzdv3cKoG8k947lzAWou1aRdugsXMDr0vfjNn/nas7j3nnvx9ee+gZu3b+P29g7e+c534OTpU7h4+TIuX76Mvlbcd/5e3HPvPdjf3wPVDaAeqlVmSSMiaEypW3wheKc4Py/vFTR2d9SqHJwSgHq3ZpuHuOC3Z9baXJTXKJr2uWG9R3aXK0QNdtv3xM0SwtAETgAynR6ZwknxrGaYHDXBZVXe0eY+K5I2RRlZpuI0IHePS0dvO58B3FiVtigka/TIgzlyDTpUiEa3wL9ZfjIf645gCsXiScVllRyhsExEFtRm39sUbz1rDscixiarK03dSqvIjMaynkQZkjw8B5BQiDEBY2N+DI/d+2Fs71/HSzf+CFiTVkeJ1lASY4FDVF5glLOAUg4erHpho5OLNSmlamy3iZeVWu5QS3jncfftXxp3mBHH0vESRVV+K/jAd55Ey+yeYGmwCvbPEHCmWGxzXOCptSNnlgEUV05RBMQNY1YHEn6omippjpPTvH/5cDK4SDU/JWmbbhdMgUMhyWet/Yy1hbGf23wZdiEVNTS2xZpdlVQZllJs77/JRkFPUYHLfE2NtHiXKyhFiq5cBg828zEC823oq91nv4hLkY3zhymhqsIBWelBqKWiloqUM3LXAVQx6+f4vf/jj/D/+N//ADRdA80LyqJHzh1KAQ6mU1y6dBlrow5Xrl/HzZs3sbOzi8oVW1vHMFlbR+mjRxw1vekM8S8WC+zu7gIAXn/9Es6ePon19TXsTWe4vbOLL3/5q3j22WfxAx/8IM6dOo17z9+L6fQQu7u3sbm5hcPZAU6fOYaUe8nyIohbwtF9ZEUFv4cit91uY1pHLYwGRUPQpCn2xOy94krjHkvandragJChKLNObT9bIG2C2LaaNBisH6y1iDDWfSQ700fKCiKpAdw+IxRZJQTa5wrLlPJ73NXNY8k2DJZ6EQbMXQ2PQcGVil8PbEkNDkBNIRKs3ozMK+GKtDoNXF4RRK5RDykorG6pyRuK6tbs58Vc5raNjPi7UlaFVMgICQn0YmVDXYlMau1bJxJCpPILiImqOnFr5ZTRHR5DvZCQukOcPLOFjgl9nzAqx/HAyfchra3jpct/hDK+gVpmzhcWpzJl4nJQ0sMaPmC3VI+GFd543H3LfTXnWQUyE8F6oBRmd3vUZlOPompzMVnaKbk8a5u7hXDu3RXQxirA2iRE3VFssIiiKZ9X1ZOQkNgYUrV1QyDxT2szCLbbGwFocI6Q5O4NsFYUae+yCnfJiWqrSKwFpLWCm/5q5jy15ALYb2rVALH91JS0zDWlhNLQJHlGiM6T/EzIdlgBHpkgh+wXS/wmZWHgSgXiogmlB4RCdZoTBgWPcieG0DOZKY1W1EgHArmoTOlYG8VGkv5da8W1a7dw9uw5jEkU59ee/hr+j9/9MtLhhsTAGDh97AwOZzPwiDGfz3H1+nVcvnIZlRldHoFSxiiJP7zrRmAAi8VCEBcYGQmgjMl4Ikq6cTXmnLC9uwsiwv3nzuGpp57CmdOn8B1PvAvz0uPkyZM4c/o0vvSlP8ZkMsHa2gZ2dndwtp6C1HxIgNgr8wcgxBC1BrbjqEogmxR4kPsDhL5+7Tepsu4kEcCrZSM2R5G/rMWl7U4IY1QQKDe1KgxvTVKpauGlYTEN9Vt1NyPcos6xBMtMjBFI29dNOXjZ3ONcwJrSKlmMZtFJenRkiOrDK8Do1UrUs6neuBrISYuRhR6l9jEr3wvr0UVO97YODRzKyBUuM6Lnm4IwMCQpCZqso3U60Cwqs3SYQegNSopy8BT8cDG7G8VkBEspg3d/RgV5hw8CKMtPOYFTJ160nQmuP7sDeukKTszXcPw77wPTDMxjpFsTjArh3qcew/WLL+FW3YUlrLvHBQBR18xB/+YAWEC5jTYW/mbj7oso3V2i6xykCVNMyCfVDsv9JzcDBTSEoLVgn6l885NK8WbjFDLNShJoa14h82QrWGrdU8O5LP/Eg3ho5j74njJk1Z8zHFlJgE+YzxjJK5V1b9KSVddeLaAWc1xHsDSPNkZj/28bHx0SANcyMgt9X/UDQpSli6weBfYAqrkAq3+vfT/5O/kOP21Jr3SlpiGiusESEkovAe3S9xiNJ+jnhFdfvorMx3D67Dq2d27hc59+Hg/f+y7Mt18BV0bXjUFEmMzXMFvMMZ5MsLu7q/UzCZRHGI1HyB2BKsmhqyTKS4JMQB7BSjtSTr536+vrmEwmOHv2LNbXJxh1HdbXJ/jO97wHm2vruPD669h64AG89OKL2Nvbx8H+FBcv/gkuXn0VDzz+fqwpaHHlutRxoKVMYwQruKjBha6Y4iyZgKPmELcZhex80aQNE7w2TPiwKei0+VAIXDuvFVZLoqDM+Ka9SM4RuQj5BHuOPsviEx5XsFobwON4mu0o7paW1+SseGaZCWNmVbyWKCO86/cmaZyLjXeJNeOxTRoiJWeBXZZHGBY4W8mCzMTqhKxmRM8LV8jFXdTsoyTzmNdBQEEFsHyVQDuM9hR7YVsz4B0/dUYhnVNWvq5IdQ3Y7XDtC9eBC3PMb97E7e84gcPpPjpM0F8hHLywg531F3D69BYSH+h6JogizFaJLM2ULMEn5JBYxm3fu28+3kLjyuaBrEabmk4u+9QcNo+LBZc9PqwB83heCGATTKjLGxPvFcRpKKOiLcqMYPbyppgQF6YxAV40DbidgLnaALtzJNxdbHeEsDK/9yeLBnquHNj8xtZmwpRiKE2bY7J1+Uqqf942n5ldMYgvmQJosCUmMLz1l7oLwUXQIgSlArVhKgkmWxfUUElGUHu+7V2QKgSO/MCZVC2CFNBHrJdaMT2cYjyaYDqdCR+UhHG3hutXbwFgvPzK63jt+dv4s+//Hly5cBUvv/I6xuM1PPnEO9H3C1y/eROXr18DE2G8to6UsjTlTISeC9BLwW0pak0A4FKxKAvUnNF1Paze5fjx49jZ2cbe3h6m00Pcd999+I6nnsL6+jquXL2Ka1ev4uTxE6DKODg4wO72DrZv7+D8fedx5uwJ1D6BS0LhHh6HQMQ/7JoGT7luiThIhNFsSAIs4hiZiWIhiBVeRAkZ7zUgS6xKe7eAHYZ0ikDqBLjonpjt5DE8Im3dEm4tOzHRFNVAnv6dq7qPIznH40UNo5iQ9H5ZjdvKXFMSUzXeS2ibp5EqBIal9MKVgnc6N9c3WyoyqReAnIbWrdqsAXMPDwAf2TPaDgtOCeXxcF+aC5LVq2FCz2Kmd5JNdxrmijPZVds4qyvnZo1iSiIXIE0zLj19DYtXd8HbB+jXp6B7Mw7LIfYvMw5fXgCv7+HqiYKNvZuYYSb3CaGT+7Rsw9EC6+Hs4HwQSjUU0puPtxBzGSG0OLsAvaN1QOHnNktFiBXMZ3e8mGiLr0YGiyMA43rOyAnuQqrNYiOrpkUAMb+if7eeQstmfft3ZtJUXz2sLAdBnqUKk1Nj6gry9Dbr8gbPkqu1tUqMcfSzTXw/Dh18DU5be1dDE7E+OJQkh1BLpgghwmtR+0ZYGI0qvOLYvm405Jivz0GFHTWfMZrJlCoIkvEVylHcHjkn7O3tgjnh1v4eNtdP4uyp+3D1yjXs3Jxi+2bF/HCOY2tjPPWOJ/DKy69jdjjDzs3b+JG/8D/imeeew/Vbt7xi3CyjjjI2JhMsaIbRKGM2qwFodLm1VMymcywScOLECVFMSW4r7fuKG9dv4Stf/iqeeNe7cPnqVfSLHkSiqM6cPoMud3jk0YextbkJppPIHcB9D4x3QWSB/LbTg75Y55oounlLJbvtX/BK0NkylhIKV2SGomQLWgegAAR5s4IOOXcCdipYQV1cASFyNM6j7O5CnulzstgCwyry0ZzxZdg3OPtUbCVgJi3ciNhotViLu4+s+lwvFmvdLSpIWeMeAYAKmOzqY+X35kx5kWttz0VxcGbvMMWmRjYiFZs1mypAXqQpCwXksjlLF4/kGACSHUodWrh4p5haS0u31PzfS+ngRm2u6OoE2N3A9a/fQHl1H9jexs7sFp78gfdj89R5XP7GJRy8tIu0N8ficB/3fNf7cOqRp3D5pSsgvg3OFTw4twQcmWuA26Q3p5rNJdj17rTLXSuXtfGmVnqqi6iYu8p8kQRYcIrjoq647tNM5opgBChqV9cNwoUkKNxy8U2At8opGgJSZkfO9jm/057h7VfkXRacJICiet4EgczDiiQj8Ecat5CDqFlQpPELs+A4tHqgV0FGXh8CRJNHwDc6vNomXOAZY6QMHhk+EX8y9xu39GFvxafv8A/49wmmleOGwOQxfe2bRhRnyOZQrajV9jUElSFbM2Xl8Yx+scBk0mE2A8AZN3Z3cePGAdbGmzhx4iRefP4lXLxwFcc2t/DKKy/iXe96Es8+ew/2pwscHOzhhRdfxI1r17C3syM9qDIBKaH2PcaTEUZEOHX2DOazOQ4PDzE9nLngABidthAqlTGbzbBYLLBYLAAGFvMe08M5+kXBc1//BtY2N7C+uY7dvV0gER557FFcfP01rG+s4cSpk3j22T/B1RvX8O7veQDH7xFak3Ov7T87OVS9IMS6ppgrYVkLUVvlziDJMNREDBnhlvYYBpEL+Kz3yzMCnLmlAtZak+TI2u4yYWfKpSnbFjd7L/3fTBFiaZjApTBu/UPc8KzbQr42uySM/TnxKakb6WMyqeoZ4Tg7KmOqf0tPMDvLNwKxOC+0sijOPiFKHZpK/gHNzEWka2sC9SGieHgmEV4R6DOsiDSxzD2TSNSUtfaGLO4iQKHjNcxvjbD3ygJpew1pmjGrPd71Z74Pj77zvbjxyj7mL83QX7+F+d427rvnXkzqHLh5BcRzJMqYQ0pKQmFTg8TavbS5smnfBpze3XgLyuWcEC/pxGoBao+KhTefA5lSMGZS/2CSSvWk18JaV+HoWWVpjlJXK7UcsmEpVT9AoeFlsawtEIplNuj/ZSQwpEVLtUPhfG55S8JKlhCb9QZJ9QkgWypvHmnbh0BWVq8gItxSe8VvXBSVtZaReM/bDJDmNyao/QArilKW9sOmwkQeHPUjttkWE3MLybPlNDGAmiQAjuyP1lVmc5MEDUnU8Iw8nzG8DUfrlhC6IOaswoUrgzKkNcvWOvb3Z9jY7PClbzyLExvn0B/2ePrLz6BLE5w+eRqvX3wdxzY38d73PIXPffHL6LY28cWvPI3XXnsVlRm5G8l10pWxNplgMh7j5s3r2NraRM4JZ8+cwoljx3H52nX0ReJh1boOMTCdLTDqEubzOYgSxqMJuDJ2d3dRS4+zOePsPWdRSo9XX30Ve/t72vSy4ObNmxhPJji2uYXjxzbQ5WnE1wap30aH+Ju5TU1Yl6png7LUFvhtkfGl5JZy9dqJNsYCalytZJyf4tfWWQJoXEG2byUQLMOvYzDRHEK3RuwsAeb7b4VlnM1411FXkASnGUVpJpa0xMEYoKH7y3QyWbq3sr7wc/Gz1CojAgb0kZR3BRk8/Gz8PRRlpO/bv0MxHP0zLJmICYf7zJW7W31m4RjE6EAq61AFAIESchmD0ANYoCdZKdURJosTuPX8LqaXp+j6ETDdRcEUj3/v9+L8k+/CxRcuod/Zx/RgF/t7N3F8cwPzNMdXXv5DPPbYDuab+2Ba6BJE1oRXJg320njVvSvqXjSX7ZID/Q3H3bfcT9KjqWggXrTdCKARcmcCUK0BtkZoohhyyshJMnlYew+1Pb0ISSu6s7Q24V6rRGscSs0nqywtSsAS7K+1YJwIlsZIoGi0RgWlLnBE2zJr5lCGBghE+Nt97yxopKgSzN1E+iFxFV82k2b8SF5/1krwpAjJUJP7rQnBfqRH0wwHl9pmgrNSpKLHApI/nxsGMKZmrx+Rg28ojgbrtYaCResLDARYUNGEiJpzcs8MQw6MKXP93TCjrxVY8HnohrqU9DUloJYe6xsdZospFv0BvvG1Z3FifAqnT5zBjWu3sHniOCZra5jNprj/gfvxwAP34ctfew63dw8wrwXraxN0qUPpKxb9ArMqICfnEa5fv47NzQ1813e9D0DG/Itfwu2dXUnfZgEgCYzxeIzjx49hd2fb08j3Dw6wtbUOTozJZIzDg0PcOjzE+toL4Oefw9nTp/DIIw/j0ccex0MPPoTxeIT5fAbqK1KXXam88aGriGaPFaitLQPAui44j1iCjAnrpEIWTUFyq9QN9i/FEjTG2LaLN9DiGK1RQDJUkAv36DPDRW1zPqo8AlSYRWAxFlOEAp4s8K2WGzRuZTUsZgUQQ803LZwmhIKKID/F0mCZocaDCvN8buHehdM1pegiAT23Sa3Ao8rIrJF4jNGp9VR4fV6SGJ83vYQl88iTiCTDNKcRNhYTnN94FBsn78fBYoq96Q3MyxTz/hB7N/Zw4+Ud7F/YwQQdKu9itn8Tm+sbePQ73o0rV2+iv7WLfvcmyv4N5DzD1ek21s6exIPf9SD2NrcxS5L2nKpmtWksSsRDQMc2rBCA082WO+z7G4+3oFw05c9ETDGXGCAoPlB1QUHlHNciU4dKI4AlsGyFZ65c0giUxnIAqSJzRYZclAO1etTORqoVXHthPG1WSCl5Hy/zm1bugVS9Md7gXhKIlZHTGCnJ1cvS+aLCctsZQKeITNi6ovAC1pAQVRSMta4Rua8+JEhqthW0DeioJ7eyxUMkviPFSUKXpNZhV8Vt1+URElnjQ21iqRsdVqLpCmUCR5SSFZZRkVPnKZxJ29ubMtKUAFjBcUJGSUqzqu4CYj0wkmYqrgZromhrzTEXBKKvmgZd+oLTp07gvvvvwVf/6PeRTmdQBa5euYa6APq+x/50ipQSzt97Fq9duoKr129ibTTCZJwxGY9weDDHYiEZSLPpFJO1NaSUsb6+gb29fRwezjAeS58l9ttHASTCfD7H7dvbEm9ZHKAv0u2bE0A5YX9/D7u7OyAiXOhGSMQ4trmB6XSKZ776DI6fOIar1y7hu04/hPU0Ag9qBIyew6QUCT+YoJWjbGnRpQg/EVrr2wL2oTyET9UKh1qe5v6isB6M8vb+1Ag4gwcu9BEKasChYearhZsR7jlWHhwGv0VYFnu6z8Mqze0UybmN9i2VJQYTDV5VOKMBQNGJBpa6LIqFGuXSJk/AaWCu8RaRu+ZxK49iiq1OsefoLz3zMoWLW3qXhUViLrpwtQEWk4l4nPIEV3Q0Bu2NsLjQ49SDJ7B1+hGcPb0OLA4xPdjDM1/4PK4//TLqwRR1foDDMgPNp9jY2MC5c/fitW98Tc7Bzk0cHuzgsKvg82M89OT92HzkNHiSsdBea6VqVh7EGjTgEUpXs0oNzJsbUGWxzf9ovu2dx1tQLmuaTujsqeatNogjEXy1VnQ5g5P0uJEFWH8tzd63dgqWyZWSHh5lAhDkwi01j9X9JTFtmUNlRi2KkDiB0cGCkdIeJUlbBLUqoNW1tsmJRKGBxSVBHYFzAbjTDCsRuFTFLUAgdLQBCRiyh5CSd7IVJpbMHs2YUkGBJsCYNPBftVWFAEzGCIrmUDVIC1gGifQnG4lVB2mN7deXNkjDlIacHW2w11QqE6CFmGrpeNCzDd5Xd5EUTdNkbRdRmUEpiyXqrhg1+80Xr8iTm+rmWqWeojJrQz3Cgw/ehwceuQfHR5uYHTJOHjuJ3Z09rG1s4IUXXsa5s2fwyCMP4+LVm7h86Sr6ukBWd85knEE0wWKhl4gxkNMIB/szvPTiKxhP1nB4cAgu0gWXYN2ipelj3y/EhVkL1tbWMJqMsbGxhvF4jPlijunhFGfPnMGVK1fQ5YT1cYeN9TWcO3cvbt28iYsXL+A7+/PIaQ1V/eKuoE3qNAdQQLEI92F/vrYRIcVn2ZocAiGoQsIK4u78dyERgx/iu4DVjwgiFydtJEZZSYEpM1uPueHYLQXjZWoyoapZwyiqKGT/SZvUCo8s1UWY3iG5VRXQLEPrsg0gGq5yWDVkfG5rjgeGB6BF1hzK2Hr46c9MkVkRp1kvw1TbJfeeyqL2fTT4DA29EaaAFAhUKP5M4lHoaof+NnD1T27i9M4Gusc3AVTMd3dw89XX8dzXnsHFV14BFjPwYh9dnSPVgpSBs2fPIuWM+c4N7O/vohQgHz+B7/vzfx67o9dwMLqCOQmfp6JXNVIFsAAAvwdGqFNAZF3Os/60zdzrkJPeytpkzb3ZuGvlsuh33R1jKNbQlZBb8tTjIJkpSAB62G1mTnczu7gBN7COm5LuaPe/e/trM6Ute8YC/YB8FgmFCxJL9WyCemdNwCpgS2pxJIglRR0DidXoyBAYa750RfQaD2JllghuaUWtVcSzCECoJSefzXH87VZLjdMQkrqiJFAp57HGhuf2qmIGsRRSIcP7pVligWVmEREqqe9cJgVrS5EUXSZiINte2nqEVqXIPDrt7upVyUa/lMWSskpqZuTG1SmxFt0j7tFDlOSoGwNZ0slPnjqGp77zcVx9dRdpznjowQfx2msX0JeCnZ1d/MEffhZPPvUkrl+/jlIWmM0PsegzJnWCcTfCxsYa+r5iNltgvphj3lfkrkPXZdDhDESERx55GJubW3jttVcBBhbWe6xLzlfj0QiT8RgoFf2sB3fCpLe3t5GIMBlvYmtrC/fccw+6LuPV167g1o0buHLxKs48cEyFpyp6QPnF2oioK4lJa3NE8HgbHYR7ZNDTi/Q5bM9TviK51jluUTTFYRaO7WMDwpUnpTmiuVIN1bBmidlBtE4N8neCgKVS+6Z7eY5DLJysvGGV8sr6TXqz/FyVlsZijW9UXw2EuPv7m5iQ/Zu107HHaMxaczCT/KxAZUwoEqOM/aEygRvQS/Ys6LmOVGEZ7WVlajGi15eMXFHDzp9sLRKSFD2mhA4JVBIW24zLT99At7eJjZP34+buFAdf+iquXLqEm9evoZ8egBd7KDgEcsEoMTaOjXHq9H1ASdi7fRX7h9vIGejWN3DyoXtwzyMPYefqJRQmpDSWsy9mstLPGmra1SOMBAMq6rp14Ar9WdRTkfHiXYy7Vi7T2WXvZivE7pQnA0GrwQ/uBZUnZIAYtVjrazXR1cIhIu1yPAbzFF2eqDtJfKu2GPOBimehoNaFYuRi0B+1L0g0UsEHyfJgBooJahbN7e6GJDfdsR5wNqaUVEdCMJlU81e3oOwwRBp2iQNSCXbNqnWHNeVXiiGllnm92gFuwrvSIs0YCiGhHrnBYZQMoRH80iIARB3IDj8xwL0Iu8afLJe/JVdIDJbgYifxLEln7hXwRTfqoStA58AREIYlbVSJUZVaMJvPUFlcLikTjh07hpNnrqEuJvi9z30Gj9z/KNbXJ3jlwkUczgp2D27h1u4XcXB4iNR14HnCdLYAM6HPFZMJMJlMkFIHohkWRVuHM5BHGWvjMY5vbeHWrVvIRFj0C5RS0I0EoZUiabPz+QyjLqPWgrwGLEqP9a0NAIxR12FrawMnTpzAZG0Nt29v48KF13Hrxg30C+1wQAoItAGpxKoscYUcNKWE6LCt/wvBqgrKz2wIQCa45ZkIyFpNbQfcLpETcWfZTiZUI7jcdWEhyLMteUQQLXuasMUfis8zJb2JDiRpwGxo0KwkS9ARPmndUe4eMuXj/NLrd2nwrCghQKMw7KxQYykQGBZPDesRsMsFIxMsrDI0z4MjcVJCm9KVtvkxH9b6KNWaTtNYi4FcAxXJvQ8DC4mkg0fXr2F+K+HWS/s4PXoEG+c2sb99G3/8mU+Duw59LSDuUWiOjhfIteD0Aw8h1Tn2r7yKwytXQCDMS0EZJ6Szx3BzvoeaX8XXL/w2+tEMlFgwvt8emrUvWafWLDspUoLvndAlimCXY7iyp29zhf683/esEZuRbFv11GPSg1QVtZK1StC6AokbMErp5TtJUL1kknUY5bG6T8zyYYCyuwAEZRQU7jWwb4ia1RrpVMGEC4GhFxIpJStXFDBq7SRnnDqxMNDD0mhrlaK1SC+VA2nqzu6JMCEqG2IZNNbFWO9GR43ePGg2T5Vc1kQErpKlJa1x4UopGJmazfetlmUR4uAqUiNtyGfCXphN6CouPFJmyz4veMGbCMtKZpVCLa2RmtFWIBiBTEOX0vHW3mMpm4yUOxweHoKQMZ8tkLuEjfUz+MT/65O4+eo26mKCWnps784wnS2QMmH/9i66UYfpfIG+MPrKKNM5JiPWtOI5uq7DeDzGBo2wtraOfrFAygmj8QT7+/s4ONjH+fP3AABee/U15Jw9wCqgpWI2n2IyHoG5YjJZA4ExGo1wfHMTjz30EE6dOIH5dIrXXruA27e2UUsVN0QaIWURUBanE2poY0VLMPF9FEt83NyLbv9Z4obwm2ZyqXAtXhuiG1zZ+d5clqYoUpMqnKhqexILJAuiFoGpn4NYmdLF2hLYLUOr16MeAX1urQ47k4M85rY4kbznoJ1Fb5BIZjXIf95Cv7WKyIQ7u3IzQCb0MRcO+TloR3zXLLvmgAADT4q9M6wpciHq7noXtEvxMOqcJqI0s2S9SoU0kmagUuqAfoyDa4TtCzOM5sew3mXcuvwSeLYPdBOUxUKarVJFlyq68QjEwCZ6lP1d7N7ewUECZqmCj6+he/genPnOx3CiK6hpjgW2UVDBNEYCKYBsLhA0ZmnoY0rEwIB/lq1swoBjckV8N+Pu278oInbJ5oK41xYtACg7ApNbDXukJEHLzISUoAdbC736CqiVkChh0R/CL/dxC8OaJiZHfXYsFhx3TBMkaJVUWcjlU0CF3JMQjSUBSoQFIApPs9iyCQcS4UN++E2wWpGVCmVKummWXWN/t+aYrAdL51SzZtyxK7twdWRIQxBT3p6TA66QW/W06IurIcdApWDSItEOke5qh1q+V0qDFFn3z1yLHMWhpvhkXiWQtpavuPvMnl31ELLMmglegJpSAhKjn0vsbWtjE10eY4d3cPLUJi5fvoqd7QX2Z3N848XnQcQ4mBYs+gV4zujGYyyKJGUwydxqKZjN51j0vWYhztHlGcajNRw7toWzZ09hY2Mdt3Z2cfnKVayvr6EbZTz/3HOwVivM0lesaoB8OptjPB5hNBphMu6wsbmJYxubGI86UK3YWFvzin1ixvraOrpuhMl4HX3DUyDymiQRuK07Ifk1CpYu3OBaUM7ITdxRBJ9Y25UL5PI0LZLkph+ZGkceM2huMrT9Nj4pdYGq7Um80l2Fb6lzAD2AHlx7Pe9qWZPeQaNWK0jm4aKALZbBiuwb48YLJc1itzgQ4AH1Js7h7Nm4CM1akdID+NrZa+daoTkUnPZzctmlpiK3z9LvKkAm7gbPpcRtnaHTdZg5JU54OU9FARgjV6ArwCa2MJ9OcP3yHP31jLw7wsH2FWwf7gAETPIINffIXQfLept0HTaPHUPiGS5942nQ9g1MUwXdfxon3/dOdOeOozu+jsVaD6oVHY/06FbdoxrnvakCcsWN6jfbhiJlWDsf8YiYrDEA27hv32TctXKJ57UaHCKEWl+7m6NZzEQv+5ZsM7cgzCcPAqUOTEmbIhZVMHJgEuYAV/QVqCDk1HnOS2VTGipA0YOSVBxnMhNXnQqluJvK+5ypi4aIsdDbE62osGopuGX1CENJ5oz8HU7oQF56qKmCkF0hmrtQegPZd7WVBUHXpNel+q1+EBdWFYXHmkUGlkSGSA0VYQaWJIWUO+3tZXdfWw8lvYXSDhGAyiO1GkfRVociaaNSVROfgwG9Ilnrdppq36oCR+I/so7MwCR30tSTpEp/72AflRj/n//nb+PS65ex0a2Bug6HhzNMF3PUIsKon80wGo1cqxnSlLiQdceWfZstFrh45TIuXb2EB+6/H13Xgesc27f3cO3aZeFX5ZO+iOsza22B1GEB467DudOnMBp1qKUgocNoPMJ4bQ03bt3AlUuvY//2DUzWJ1hfX4MlRlR1KQj/sDYlbIWW3UiqnXS9m4MdI/JbAmWteikUQxoyAqBUPI21WmZUgziTuWDV8lagqbVlIjQSLyR+oha21IH0IFNgsouoZQ6QZiWSxF2ktEBoVdjcwMIXqdpZENdaqXN9Luu5NuUht5KK4RJCaiikNXOOGrcMZXAlZE/zb7IjYfzIsOt8vUFpTapHOuVVBSkQayOpuVdZ4ED7PEmeYQGLan377zkhEYOLWnp5gYJN+Rn3OLboMEHGpIyx1XfoZh3W60k8/9pNlD1gdjgFHx6icEU3XgejYA5g0o0xWhshMSGVQ4xGYxzuXcbpB+/F2lMPYLpYw4nzZ7B+/gy6E5soqde+bUaTkaQWm3tagSfBbWM1EOxfWUFh45HS88XmbUkGAJrsU8Rnv9m4e+XiMRVosJjcFGfLYVfm8EIyrYympOrHNogU6RXNIKMwXa0Ntnyw+KKZSd1o8E6txny1wLNNVM/q+sPlIFaJgRY17dW9kJJV+8uze47Mlcoa/TANb+nXLOnOrO8RBG+fgR4iEcxSwa9z07oTQ42ZJNvNhJO3nQGBqh1KC8Q1qMFdC9aROiGlEZJX0Fv2kiorivWSuhAJcwBQV5HtW7gDAPZnGZ1qZS/8g7kmmiKsan2rVKCBIMpC/dvHj23h4pWX8alPfRW/9ztfBHHCaDTBxvoEh9ND9FXmV6q02+9LwWg0cuu2cFhuOWd0Oaubao5aRfG/+NJLIvTsYCRzNzF6VcyTyUTQfKkYdxmjUYd5P8fl69ewub6OjbV1rK+tY21tDffffz9efvEl9L24PO45fy9Onz2NLk2w4AUSyWFMlaVzgFXCG8BRdrQTkow/LdBKAJLBINnbZHwM43NNRTfAYrU1DTtA+TRl6x0lAXAASKmAFUxkdW+VsnDBbllbXCtSnsCD+0hI3NSWACArjFbhhKSeiFrBCvCqFuix7ltSKwYQL0its0ZEMYDi3beN14zHEyTLTe6l7xHxLDsb6oaFKC3j3koFcs2v0lgTc+QzGh+zs0pwcCzF14wMQ+pZ5IU9hoBCQO2AtXkFo8PWgjDGGPccnMYkH8fGlDHaeAB0eRf97m1cuHEVN2YzHNSKWheoWeqzRt2aWBiJkLPECsejNYy640DZw8XDbRy//yxOnXkElR8ApxEqErhnjGgESQOq6FFAI2vImZ2qAGnMNZKRlFNEKpJwpHGbe0OIYGUFZg8Kp9hlaG8+3kJXZPZLkDyoRhChqm4WQlazvKIUYbic7ergYCPSRVK2xamwteCbKpWqKAswi1utHl+uICdrp5JSQq+FjzBNq9/JOeszrY5kGEAdonG4sLTnpyYGIgal1Q3ocxq0bt/zuiAiR/+Vos8YJTmcXA1psCfuiGCuqKha1KnzdCoEDYzhmbWzQWW9QtZiC9r9VV1sKY0kKQ7SolwuD6omhgZuDcsSYndrslo7lsFHsHRzQe7BeOFZtNRNQt8vkMeM3/nt/wQuhM2NDhubGUQVuZOb8+LmSumiLG5KQ1pmwQiNu67DZH2E/YMDEDHG4wkWiwXG4zFmsxn6voggITHzJf5nd2hUyRYbjTAZS4dl0ozFWhhraxOcO3cOV69cwa2bN8F9j9NnT2JjawxQj1JmYCIBDEkzD00gQc+F8zT87MAsWfVUmMCzjeQq4gKwZBblegbg/u9I2RX6kyP+oTSw7snC30RVgZQG55O80+5q7711vwWwDahYa/7qNWWSOZZggXWJNZFU1leppxDhZqDL2kMVnQcpn7AqFrlJVs6cWpRJk0/VGifqXSgmEyxkrnKzLeSEJktSALQmJqFCM6QYMBef0amaFwQaa0AF1R4FUxS1uHJhJC7Ii4R1EMaLgtP9KYxv3Ea3U9Gd/y7gmdeQJ2fQlz1c//RnsbNJuHSMcGtrDFCHSRphWgvQVRRlh9Gow2htBJSCEyeO48HveBxfv/AHePg9T6FsdljQBGv1JDbpGNYnp7A1Pom18SYyAQdlD69vX8DtxSuo3Vxclil5eyxvoWVyzfnIrBThU2E/PavUHGCO2KvIrbdZucRlV2ExBHqAI3PTl8LsepjM5aVtRrwlu6cWm9vFpL3+SVFzAdJsoKLPV6aw9hvGqHD2Usb1e86V8ZRycSe2aHXLMuGqfmWkyJ5U4kprGsGglYvESuz9tUpw14Nn5gI0VShoyC9HIjWtNV4hukWEqJlRlsWjIlz2GZH+G2a8WRcWdGXvMkBmCcLqX9Rv7yVE2myQq86v18MuvFWhz65y4AGSOqA2W4yBUpUp2fZHhSIFJEiJMOsPcXt3FzdvH+CJdz+Kd7/nMVx6/SKe/tKLOJwudA26XlRkS3bQ9GhWFwxICjL7xQLHNjcwGh3H3t4+RqMODLnTZTQag6ig1Iq+aG+tKi5EcEXqEjrKGGVJzsg5YWvzOE5uncCYEtbX1nHzxg3cvnULr7/2GrhUnDp3Av/Xn/kY1k8x5ottraORPeMknRC4EXjGzbJ/YxAImTqYT94tajd2hMdIgVGFZUomrRVTdgW5VyCyBFlSCRFFe+As6euU/cIuu1lSAImhVrVOrPu27ZrGD2wlSV1t1VyuJuhbV7kpPCT43SEcsVJpe9OKHoa5jcVlKNZKgsZwHV2b9acATecngKCD9/6DqV47DwWlMjKNJYOVq5xwGnnM1bLZapU4cU2MhIpEPRa0wKIWjEDYACGXiuOLTZzY7zH7rc9jct86cOUA6cl3YPc3/wtGz19A+v7vxMXPfhF7ly7i0mPncHjf4yAiZDDmdQaqc9TZAiVldF1GysCkJJwYTbCRCd0EOHb+PMqYcCyNcDqfwqmt+zEaH0emCagQFtM56v4Bzpx+GKP7H8CzlwsWfEMTdqSEgJCQaaTyTuRxbZqBVu7l800mn7jyrcTCeEN+nu1c38W4+67I5ueF1uiTMgW3Aq16p+CkGpKrxDXsvvT4bo2sF2tHcGTS5gZiRXeQ9GMSc9+FjjOdEQYioKugbVgaMsUarPDT04VVWKZWKCyhd6lZUARgtgRZnCW7BWJhCInDVC32NBDIDZpVIUQJXFRhJHZE5Tc8qq9enAzFXYxmnSVIUV0oFGtFI6i61iLxH72TQm6a0yI5TSWwa6DD99rUTBDkamf/vsw9W1c/+74pTmb1yyeng7kHAcJrr72CUns89e7H8Og77scrr74IpIqtzTHKzgFQCTV36IvNLQKLA77gitlsJv2+trYwHo+wu7ePnDIKkl4aFum30r7dsgAzMmUFO4S6WGAxTTjAPnixwD1nTmEyySjcY3rQY22yhvHZMzhx9hQefOQRrB1jXH3xj3Hm9H1Ik2O4cvNZHOIQNc1RU1HMZe4IBVVJnDFEAWYkjd1qj+AWFgeHKbsoytbYVUIn7s0q11K1tVwJSWvEEojGIB6jkttPKA5wCLUuACqopca7OQK+YNYTrzRPUpcVwImVr5RfyDwCarFUoS/DlGIALnAAFLMUzJVKSeWMxT4TAdyJdcSWqiz0YKMx4MXMmQmcyOWF3FEv9O+qtJ0f5zHWasa4L8g9A6kD5Q1gNgPtbGM8mWAxXkdPa6hlitRXbO12GG0X0K0Zyldewmi6gXIKmF/Zxfixitf/8DPYOnUO6cvPYu+1KxglQkcJoBEyMUqdotYD1IUVmAOjboyt9Q2cHI2A+Qxbo4TF/hSntx7CKE2wNifcfv4y+tO7WHv4JGpi0GyBnes3MX39BrZObaJ7xxls5JOYpQymglp6MBd0qUNOYwCdxHsTgSBuS4/7Yu6XnknKsvAWWOOEDbjIKYPr25yK3HvATwRWYhEsSU39qgwSHX8V9quESimhMNRnXuG1IYqMbWjeiTIEvHOoC382/asB/yYoaG6HUooE/ymL0GeJNyRFmX5DIoAuKxqHWtgagDcESok17TosHlAGcULNMncJ/GnbQF1vNQXCZuWpUmJRSH42oDcmqqtGJiKHxiw/NusO4jKU600t6aGNGQlSZSQg9b5GEctV057V1adKkGGxFpZsKFekcCERQXyAi2TH5ZQdWLTX+AJuvIjw08K0nCVZYdRNwNTjwYdO48aNS6h1ip2dQzzyyGO4eOEymBN2d3ZBLHGgbJ4Lc6H4quRnfam4dOkKFmcXOgfGfD5zNySrcqFE6LIWzxJhNOoAluD+dA5UdKg8w4ljx/GB938PJl3GsS25N2b75g4WBGydOolSgSuvXcJDD5xBf2EH9577HiBlpO40Xpg+h76TLCyLT0Ldm2Cp9xH0X12wMsTNY5dpGc2KuZTAsPR01ucl5UOr0bLBas3I78UUEndTgtzjkbRJptVAkGd1imVprs6GFVlOh7h2xcKSeEsHwhhEHVCTxLtI3Sw81+4OYpEwd3aoxWpBj1pnSoPO91b+3oklBrH1Se+AKpy8dsOKhyllII0k6UEyX9BrfLNAu1twBqUCqj0mibDRZ6zdmmJyaR/55ZvAjUOk3QMsbm+j31zD2uMPY+09T+Lm730dXS44+Rc+Aj5+DIurFzG+cgNpxuAF4ebXv470wk2sf/h7cfUzX8DO11/D5PoN1P0D9PPrOHz1AkaloHQViQpS6lFSxWK2wLVLZ/D6xXfhiSe/guPjA4AJW1vH8fATT2LOPbZOnMBoYwPjnR1cungZly5cxPalK3ji0cdwZnqIc/c/gFvXruPK9at44YtfwAPvegjHTj2Ew24Gu2abSOSdZCCaJ0bLLniMRAtxlTMjpQmYFjC3KiOjahFmymtiQTYg34L8bzbuWrlMclxiJCal2PISjIK2hKgY3hWf/LBIL6+MWglkBVQJgLqWsqEWrb6nlMCam8/a/ddap9jzE+x+Fo2l6CFInYllDTq7gMqN4Cwwd4UJw9HI7r4oyLV42q+0mU/KzJ2j/1LmMIdZ0lTTsIzMoknuLpLYjbXFSNLWhcQdkEjSCO2ecaBHqoSasuoby/oosiTtSJCTKjSSDBhBKUCpM5SyAKNIwJkIVMN1lj0wRwAnBQXm57bqXTFwCOoWJdLrkc09GsVlki6uV2GzxWWkYlkaforSTynh1PEzePzx8/iud78X29tz7B18BXv9Ic6dP4Y03sGidjjYqxh1HZiLZgGpciYM9y0B09kcly9fx2QywtbWJsbjhMW8x2w+Ra0Fo5HEAs1yyNr5IZG0/egrAX3B2miEBOBwbx9bp09i99ZtjEcjrBNw4t57sL23i+s3t/H8M1/HZ//91/C9D5zCpVu/i4t/9Id48qf/J6yfSOhT8uC40wIdkt4RErDGBOoI0pGiwK4fBhNGpPuICtYmrKQEUI6HwY14pMIIc1GxpqOCQRiBq1gS/hVN4qgaJPebGhvAZhaO9CfTTLhicZ8O4CioZbXWxCMQHbjFbOpgN7BWXggqAoFI6t+kuDcjYQymDKoaD4TWubG66FjjkARQUYVGjEJAX4uUPLBUla9Th46BNK84fnsBev4qDr/yKraffhWTKwfI+wt0lZArg2rBAozD/GmMvu97sDE+hgtf+iwe3bgH43vOYPT8K0ijhDLuMN/dw/5XXwWvJWx//gvYefkCuvkUi5deQX9wgMWkguZzFBDmHaOOKvqyj9l0ji//8Z/Bb//2/4xSRvjcH13BT/30r+Ds2QMsplNQBe59+FHcvHYDX//iZ7F76xZu7+/icLqPsr+Lz3/+AraeO4knHnsHDvb3cGXvBvKjW+jeeRyHo7ko2RpA3YSsuKgzAhwDtfSwxBCRPyITxUpMkIvmBDhAQyCJcoCEuxh3rVy21s4N/i2ISpBKyhYEVj8SNEMqi3/ZMpdSyqIo2O4JNwIIE9daUeschoLNP2u37KXUSWC+KkJSv2HfL1Aro+tGmslE2uFYy35UMZIeFHkW+YHwjJncqfumiAVVi/p0SfufjQAk8U7XHtSJFVZqceFrkM/cgFV9/UmRuxwWE8iatUWdW1iSor0A80IsPBbF5T4qVLVkRFlaTzaxyrSWBnK4+zITdKKuNHFDamYN98pMMt/aBFUTdeJm03boVWnp7ggVckZrMYHI0ALshkTJSMv6bGW4NMITD38n9t5TkBJj8/g6mCre/33vw//w534Au/uH+Lf/6/+OZ59+RbKEkDDKUKEicyiVNc3anSFAyliUitu3t9HlDl0ndOi6DrBeblC3gAm9nDFO0slgfTLGqZMnsJjP8frF11EWh3jw3nux3o1wfLyG0WiMg4MDEAivvfQC+PVXMT7NuPXiZexeeQ2HN65j8/zD0qrDFIvG2RIm6LrOLX8p0FU6MsQtxQvlS0GbpbDGV8J/XhV0sFoFlAMEiE9cAtKWiuoJI4ODW30vmTR5BpFlJABN3aswV6cKKJLswVIXYO1RBQUYBFLLzFx8osCL18CRFkMnZKyBWBtxAqJgtBkqtAMBcUFm5XNx/CnShlr9jJ56cJVC5ATCuAInFhmTGbDejZF2Z5i+eAGzL7yI6TOXgeuHSDNggwjIQNeNkEsBj5M4TEvFJoDDz3wBu6MJ8nQHN//j7+L8D/wZcJ3h4LDg8JVt3Lp+DfXGbewudoAMpIOKmgvoYIrSzzHtBAiUKpmS8+1bmN1ex/UX9vClL/5Z9P0EAHDjxn342lffi+//4H/E9b7Hn0xneHeXce3iVVy9chmHiykW8xkW80MseIp5f4CyW/DVCz1OPf4g7vvu9+LYfWfBXQLXHtS4thid8lcGpTEyjQTQpqSWdZXMTpU5YGvCm3Q/JLPQXJ7MLJ3tDejdxbhr5TIen1V9ZUJO2jW7i4XNXDV3kDBYTl24d1JCqYqkEoDCnlEjZndF5RmkkFE6HoOKNJVUZJ3TSHyp1TqwFqmFgaS0JnSh+CzDDRZ8jDQ8Uy5Fm1ImLXhEBtJIEGSpeugZaiVkUQSQoJisuyBzQcpJL7BrMrsI6DXFMmc5TMSdpIqyuBy6PAIpXQpXad9fi7gNIBYAWTcEFe6UWNN7O88mkmw4S3MWAUG08BqFVCusuTQs3ZJdKoHIUmSllkgUnjU1lOC5yghxFbK58VRYa42qCBC1LNXNkt1PJs9/9KEnQWmC7d3r+NJXn8ajjz2Gs+fOoFKPNCLMy0zN+gzP/NPuwUUVFWWLWShXktyvA2Ys+h7zhabZquvPLBVzcaaUgMqoVDDuMrifY/v2bYwnE+zu7eL45gR7e3uYHDuOtXGHRV+wfeM2zp48hvntW/iO+8+i372C3Snjqf/5pzA6fQbAFibdmt4jY1WnGaAOXbLO4eZCtNqwACIMa9VByKlqmEXdgazXR1APKDCwO5JgSSHC6fLcWpE6UsRqAoVdoMv5QIA4SKDe8hHtllKvtCdSd1VFl0wZJrWUdY5ZPQ/oNfMKGGVRcoQxgARitfztJJKCTiavD5LvCvhgaNZlrUhdwYgTOiKMUsLmgpHnBeulw3gG4GCBfPsQe69dxf6rz2Pn2VeQLt1Ams6RSkXqOqRuJK71BHCqmGlsMaND3/WYkzgqkeWe+unN6yjnz+D1//hZ7F++jDKdYoyM/cPbmOhVABUL6RLfCwjomLAoPXbnc+zNFrj0hau49vufQZkxJuWvAHjK5eS5M8+jn09xWAuulYKvf+WrOJj26JO4EOd1BhzrcOrcw9g6dwYnz96DY2fOYLy1Kd3UiwbkQei1DsobgGpmZ86dehHU1ZyBzCMserlUT3q6mtQSj0jbUYVIuCqnkVqkb64vgLegXHKeIDKUBG1YgM76a0b+MztKtxYvkqpK4H4BAtB1CTXVKKYiePsJcEbKrH3Hoj23XJc7llvkimW29M74XZrIkkyQdJKBVkpBNgGsAtTQqxRNqz/SrS8ALB11M7KvK3UjgMdyoOsCqWoMJCvBWQuuzDIBkFJFzp0fZnHtRWHbqJt48WjUPyTvGSVV3dn3wQonCeyHMiWgG43BWoTJAKgWAZE1S/A3xb3jpALXLmSjZJYjq8tT7tbRbRVhPFLwYKnGbBklKryTWBGWNWTxKzGMktcgoVaMJxt4/NF34mB2Htdv7OLmtW08+ND9OHPPafyn3/9DSMPIDrwQK6UUtV6ZveZI7HeCJUSIm0zeJ581ThSl6Decluq1Ml1WyysTjh3bwubaGua9IPnJeITjm+t45Px5jLuE7cM5bu/v4/yxLZzbmODhs2N033gBu7dvY+/Ck7jnz3wf+vkurqWRFvuJpU3a7zppSjATaXFspHMmTd9nTZmWDewQGWekNTwao0jmbhNLlezskfm8pJO1WeqDO1t8/2XfqrtuBf1HAgqrghfFXIqkLXOtoDRCYnHbpTyCdBy3RB/SgssFWLPCiDr1/ZODM8kETZIFB0JJ0pCVmZHNRZMqMkujx8kCWF/MsbZfMdnpMZoyaG+GemsXfPEG5tdu42D/ALPpFLeuXEW9vYPRbIFREjchd3L2+2SZT+LqqUkSXuwqAK4VnLNYSSPCfH8Xr/znP8DeK68B8xmYKxalIC1mqCkLv2tMb7/McXNxAJ4DL2zfwKwWzGvBxuY6Ns6fw9Z3P4U/v/ll/P5nPo/r187jqXf9IR5+8AV0HQHU47Ac4uLl58GVcVDnmOUFHv2up3DPOx5BXl9HN1pD7kYoTFio50KCkpJ1msBAVhDK8IJKzyZUN7j83fbC3NjyuTZ+Kh6aoiUoAlCslONuxl0rly53LniXTSOLNZS+V5RorUM6+CVeioq6HG6paCcQ/tlSonqeMEHyNhMMUu2bk2R1sd6m12UJMKc08diFx4KIxA0HRtdJLymp2THkq4cHGZRDOJZ+IanBSZMgWcx6a01NfQWSuQ30OYmcRqbdiazdO8mB1xxf8ncretNmh2LxmPWnlkOyu1zk+1JhrXGolLw1T/T6UtnKkoHk0AMxJwaDanXhLMKQhbZJ3VmlqnFi6c5V3RaAW7Bqgml2OSxXVsNA/n6r7pdZZ+Q0xtZGwsMPPYzbt65jbWMNFy5ewv0P3o8Tx7fwWr2IcSfV+ft7M4l/IV5JmbxvVUqEnCTgXCw7SdOnjUYgTdKoknI6zmOMRkn2XC3d9a01PHjmNDbX1nD+zBmcPHEMezu3ceb0KTz9J1/DrFbs7+7g8VPnwPu3wXv7GC0qbj77Ah4pQKYRKPfgKskOrMK2s95T0Hog0CAoGi1b1JyFpf5rlhsnEHrJZKQ2c86SXbQhf7VuBjV4RxVWygacIhbEAChVb28kbco65esCSoZSyQVWzp1Us6tlKe4vywRUoV3sqt4iCLhp7y4PzACNQVpr1UMucut0rpkT1mqHjQUwOejR7UyRbh2gu3UAPpijHiwkiYCBvD9DHU+Qt9ax9/zLmO3uATs72MgJnIFFhbvjS5V+d7W2sSoGIHxRe7ucsIfcX8JIpWL6lT9Bt+gxR4+UgH62wKgbodQ5rs+nuD2f4vWDHfS1YK+fY7MbYZI73Lu2hfPHjmPv1Dr6j34fFiePYX2xj798/l9i59YIJzauyBlhVdp9xWx+E3MAfPIk3vdDH8Hp8/djQYTKGZUSSl+QRiP1pkgBJYM1gw9xTtXLIZ51s3575YlOz6reptsUVppFJZ+v6jYDAK0/qxWDu+W+ybj7IkrMkFx4NgeB1N8OkmhEY92Ima8psIYgLehYpDleGmQdCaXN5ZVJW5aQITUGs7kC5OpcZnGdiUdqoQROQgydYztvIjH3S23QbGVAK44tvztrdS8pQmBAUnw1W4vULVi11T4UDcimWBdZ2auqKF+EYdSuQIvlUpZAuGXBgAu4LlSBZ8C6EasV4YFcfYEI9gVQ1VJkEUuJejDkYjVOGryHxXpEvkk8Re6IMR4jSKZeyibs5D8pmo40bvPVW8NY1owds3baS5KguFi8j4xaeoB63HPuOMZrhJ2dPdRasLe7h63NMU6d2AAtCJvrm3hl/xIWGscRa1aTEqyHPaDrhNbniCJjVWwmuJMGrNfHI5w6cRwnT2yJZdv3mEzWwHWBWzeu4aAb4+TmFmpOOFwcYjqb4qUXX8Jhn3B1dohLiynuObGO+TyjjE5g/cQxlPkB9tYLEs9Ul1uQvEfCOuw+lqx99Vgp6SjTzoyuDalHxDAl4ylpske0WBLkL61/AORwWcjV30VdmNbyCFrcLLSsupdMrVILN5U0rhQXaqdXEeSs2cFVzmPW5BRTeMKnkshRNMmEUqeqULujIwE5I9eKjgljZIxKwXjaY7TfY7w9R9qeIe1MgVt74Ft7KNsH2DucAkXa1Uisl7DICeO1Dey9dAn9tVvAbIpxInAm9O6ytdYw5LQmhjcwhTV01f+kDx8rQKjg2R4qV2QwDmcLbB8e4tWZtG+5OT9ERwlrOWM9Zzx5/Bw2c4f10QSJJPZHPWN6eAA+3oFTxaLfw9b6FKi91kcl9P0Ci/kMBylj/Z4H8D1//kdw8pFHsSgL5NojQ9yWpWqHATU/kwNPqwCSJrFtMTMgHRgY2kTXLVrlLQpPg8hPBecK/tsuyFJ9wLibcffKpd/TgigVbnozGdiSZiGbUa3GgcDWtdSu6YVpw+qTT5CUUEuNZJZqcrtxMYoRhSCSZpv1PYvGxdOLQuBeD20VtEuMlEfeHdZvkmTZ2xjiVgHsP01vBMQCg5i/hc1PnsEJGmS0jrhyyCv3QFGXQ04SmGbNKaMuWrxUqR5fFBE1pqREEYtrR+6Yyq4Ind5kVc8AWLL0amGg12w4ZDFjeQGr0hagZnuI2EvYDXUaJK9yCVcioELcBTIfURIgay9Swdx7+3qGuElMR6pOAhVjSFa3iRSxlTLDxgah8gJ/8Pv/GSiE++89j7/wIz8EmgN/8sffwP7entZKAaNxFm7oi2TLpXYt0G44dlAkE68aH+l/k9EYk67DsfV1PHL+XqyvTbC9vYPpbIo8TthY38DxrRM4/8D9mM5meOf953FwexevXbiAMtnCd7/7gzh13/1Yv/ckbn+xRzp1Aumhk1iUm5j3c7CmgBMYXBYoBaA8AbsfXH5XWNLPyWiu++mdCaxlDgz0TCAZigtRpKnXQPoI8IJD6wOnCTPaPaMyI1WLvVg/MfEo1NaaUdCYVBlUC9ATHPRxb2n7DEojBRQSR5F7X8K6FmVfkalghIQRKqjvQYuC9WnB+GCO0c4CeXsB2mdgXsF9Rd2fYXb7AP3tXezfuIn929vo9w+Q5jPMp3O/uiBr4eqYMvZ2dqR2JBEm4zXUXtKQQdGhvEIyymwUtpY2FQS9u0hLJcTzwZjXgnnf46WDPfS14tr0EPNasJbFJfbek6dxbDzBMcqSbk8Vi/kCXOaYYoE1AkZzxv71y+CthZR0zKeoZQYmoCRCKYSSOmw88RS+53s/gHsffhw0GWPaT1G5ILdWf5ZGvBYz9Ia+lTQbFeqFUNCl9WUV1rKnWtgPVocnhbuA+RVU4sNilSZjxUNh8uDNx1touX8oglsgt6APc3lV0jmJ6VlKkfoXbQhI1EECwJKGyBxBdIbdLyLSyMCapSAzrE2BIasE4Q+pG7ADmFLWrIfQwJYhtujn8pym/5c8X81IeSHatGTSWIy4siUN2hQUMyNzQr/QrB21AMLMNreh+DGr1c4UKzgjRxrD60NNGFafP0BIVa8eJSsGpOEa2dahcyetvbH6FVJrA+Z6DJeaAIU6MKulCQJBaj81e6jabXaCVFGB0hdI1pDGQ6hDwULRIjX7Cl+jZFCJZWr+3Ifvvw/XnryNM6fvwXe/5z14+umv4qF3ncErLx/DzrVdoIrLMY8ItS+grgNnSTlPROBCkMvJNB6lQm08mWA+l6uT1dDHeNTh5OYWNsYj1CL8Mh6PkUfmMgXWttYxX8wx6Ua4tbOHJx5+BP+X/+kv4QvPfB3ve+ydmKDDAx/+EA5/8EH83+/7Cm6MD/Ezh6/jA4tjWPAC3PegUQegYgzZC6oMWgAlSSHgghZY8AgdOuSUUEtFTdKEsLLE5jhlsGbqdHUGEKNiAa5zUK2oml0lafua1UNJLN3SA5xR7a6V2oHQAVkKCw29MwO1LEDoUdAhk4GXiJFVt2yquLBYCjkLdcACKMTI1GHUS/XLWhphXDPyrSlG23vob95CvbGL/tIOupszYFox2tjE6N7zSMdPgroJ5vtTUSSXrmL/6hVMb24Di4LUF1ApUs9WFcQkQl8KegWB81olwSVLWv5iPgeK390p8iolqb3RxJlSCjokuVbCOk2zpOfPyhyXDvew3y9waz7DzmKBTs/Hfevr2ADh/s0tjMdjdClhzgWlL1hM59g/3qHeexz7xFjPI2zf3EE6voHdvW0c3GTg+DqoY8zH66DJOsanTuD4PWfx4LveiZPnHwBRwrzsAXP1aVW5IsTAm8mBudcRScq/ABeLq2ndYTVQWFAKaXxbLHvyLg3qVlPxleyOKzYruGjGqc3g7qwW4C213J/p3xSRmyssWW1IjZhD07JZwjM97B71yj1I+4jVmgdmlvX+ahWAWy02D71rXuI87NrVglQAXJDqP0KZaIDc7luRRCi1vuzyMi1C0uZbsEBYtZRNCBpAInjvpBquvIjjQN1gmrnjJqfVgtRA8wDarnjyCA4EvIQU5A6dPgQ2VyRuTF1VDv9f2v402Lbkyu/Dfpm59z7jnd/8ai5UYSiggAK6AfQ8kQ22GmxSFOfwLNtyiArTCjssS1Y4wtYH+4slh8NhUkHR/sCg5CCbpMxB3exu9gw00I2hMdWEGt483vmeae+dmcsfVube5xaa7EJE+yBe4b07nLN37sw1/Nd//ReQ20NS1GHW3iVJ+GuMSoa79Bp7J6tOoC8CK+aaocDYFfK1vrC+XzKFOxntxD5SRmCuo+l9PfeBZ3n37rtMJoHRBjz/oets727x1S99h8f3IkVlcc4yGDkKsbStlo9d7r1CyC07ebvEqBGkNYayKPFJo2wwGLK9u8tqueT+o8daHzAFtnKMBiWj8Yjj41MKW/LktatEH5mfzPiBVz7F5/70zzN/cAcbV8zffYP/7Wf+gD+4vgDgNf9N/tm7n2QSHFgYrSLDxlCcNsR7R4yffYZ6MuHAHXJWNExCyVAMYQCNSZNBxSfadgUINgYkeiLQGq9QHxFxOVdJezUGDAFJRAxVyUVl9DNmaT0WT2ajxZifuu4R76CUQExU+0692KYRAUnlQuUACy1ii+rRDYPh4txRLR3Vo5r2tZvM37zB6p17zB+f4ZaBajhkcOUy7oWnqZ69BgNHO1+wfO0Gp48esny4z+r4jLBYUoo2z9rCpZ0VldmXrltLkvpvMep0RAyEHBhlCDud37TX1cnnMxwJxhLFE6TlpKk5alYsfMv91ULNtjFcG47Yq0quDCqMVXipbT3zes7x/JQgQrCGZuCIL+7yzF//M+z8wMeYOWXFNgenDIYDnh6PuPX4IePxlMFgSCgcw8GQYljhBo4QI208US281HicI+2OsZfsqQagecaPBqwZ0+4qJpKtau6bQ9l4+lDTD0VIgUZMNbqQXXL+WZJEDLl/8f8PzsXkTnch3UyGrRRC6T7UkOQpEubdzduW7G66+kpfqE8Rc4gJT13/ejoc/ZWQjVKm6JpusdZTurV+Bs5H9ueXKBet+88EEradG9aku1dt6RCi5Ou36XmpkdY+hvPX25Vf1q4Hk6oQKeXNTrJbxlz4T5tM1tYrF9pyAV/JUT0LLH9m1gjK672e/eUeIfVn+abpfja/QshaY3qNUbJoJ51zz3pq62GAXnY/+lmSEoGx2ujVNe0ZmE42+fSnfoDDw31EAlubmzzz9IdwOP6L/9PfpZ5bgguMtgfM5guVdwnrkjLS99ukLFTQmpyzFusKhsOKqhxTr5bMZjP2dndZLOcYZ1ksliyO5ly8vMtLH/8o+wf7jDemLJoGYx0H8wXbl65SmMDg+IjD+/d5vHuR25Nlt04zE7gbhH/rcEIQg7s3Y/AwEC9d5vSX32D02ctMf+IFaE7ZaZaM64uUxQbt73wFeeUasw2VaAnRszKBxqWsw8Yk4ijYqMoYIuoAfBLyNCadwKj1EQxKHpGIS4FWDKk/yuno7Bg0m8pNyGU0VLEg0ibR01KpqDbgQkyBolWCTQnDOGCyKKlOPMMHLcXjY5rX77L/7e/S3jugbANDa7CXLjJ88QXKC5eRekW9f8Dh732V07MDFrMFfrmgXDW42FIglBFcGnAVVh5bWKVg66EEcUm1IyYmqQZbmqhLGnUjKoUkeSyDdMGkklQMTQw8Wi15uJxz0q7USYhwaVBxeVBxZTxkWpSUQDDayS4hIq1ngOXUCfONijAdU1zcZvcnXuaJn/80zd6U2lYMfEAKi92ZYp2lFs/1S89hklKlqnt5fFwRGlXPiFTdmZKYLVTe06nGlq1XPmii+WSGu9eD6Y5VuRa8619yIaN3UpJh75A/oa+tZgfX/Z3zwe6/7vW+nQspcu97RZJf1O68rpGqy0KgW5AcXRuTpK4NKkiYDM/5SLl32r2hO2+srS16o0syop0B7T8r987oe76nTpEE7PIG7a+T9HmpINM5LukykXwduhSKfdI9eNPh2cmUn7u27GoMvXZXfsf82V19hZwGZ8iqdx3r2d26M9D30QPUqwYkuiXrDi4Z47VelnWoLcdAGcLLdOyUJ0DnnPSurcky8FnLK2dnMT9M8kGxBoLkPpgI0nJl7xIXtnaxRbqWwvPpz36MT/7gNR7earl7cJ/hpMC4EcuToJGspKAH7WLP7KmcERoDPnhM9Ozu7LC1vUFY1izrBfNlRVN7xAc2NyY8/fRVdi5vYarI1t4WpnQs2prhcMKD/X2eeu45gm9ZLJdU0rL7tXt8YnzEL//ZLcDw8dNtfubOCwzMEEYlbfEYzzEiA+TeEfHmPoUfsrEcUxzXmMkW9eMa83rD8Klthq+dYj/yFOJW+HjG6ThwZBa0pWUgjtJD2RoGscSKxYlQpGJ5FI3gY4xE34ITPA1NUeBNS2stKwoihdZmDIi0GgBaR2Uil46EabnLwra0tlV9NONxAsXSUhRTjCtxyxq7aiiOPe7+Cdw6Ij46JSyXhHfuUjzch8owfvoag2tXkeGQxcExB2/fpF6c0fgV7WIGocW1LaMQibT46LFO5xFJQjmsGGITUx0zU+AlnalIYdQAhahkjkSG1iZT6fcnopyqR8slJ03D/dWSiLAMgQ1XsF1VbBcFFwYVA5OYqIUa0RA8XsD6iHOOM9OyuDJl6yc/wZWf/hTu2kXccEAxHVNH7XFpYiCWVsVs9eKxtiQElcYXQeHHTgne4gWK2KbzrZlLHqnQKXVLq+cp2z6RdIbTqZSszN6fX0SSdAu9ZU5BsZ7hlNnoZervpSZtOdcbSPee70VS/nWv9+9csvyEZOiH5CW1mUsZSyF/MUW7Zbq5TBtNhl7NgW6krsZgEvySYbVIbkBLWTDd4C0Deb5E1xuSswAynZC1hdaXpI0JGgnGqEV2rVnkhqFEYc11kdSVLHEtg5HEgulUWKNCBax595SF9OWkbFwjGV5TxkcP7RgizijGLTFDfsk5RX2PrDOWYa1eeiNlaNgue1KflyMX069FwtDVl/TZXkzRyfqGMiY/tyzLgwqUntt4qU8Ag6FA5270vQPJHUKuzSV2k6TeFWd13k9pCrrhW7Q4V/DcB6/Tzg45m58STUtZOValx4nQBoXHCH1PlaTNEmLERIUxPJGjkyMQYW9zQt3WtIullnFbz2Ix54MvfYDJ3gaLesl4NObk+ACHpRJLGSOP3n6b0XSTZjWnXM1wS8+f+l9/jRd/60U+8Fc/x5+7cZGpawgXJ7jGav9BvWT+z7+IvPEO/sKU8uiMst6Eh3NW/h5Hv/pl4umcvU99BHu/xtaPsE8/QfmV19j7M59iwz9CmhOkdRRSUjZDrBtgRgOCHeCKERQFwYBYg1nMse/eJQwMphgjV6eY8ZA2NNTlhHbzArN2xnJ5H2cPaSuDCwXb3jP65h2GLz7LcDqG0zPi6QlmsSSeHiONg7Im/P7rzE/mrJYrqsZC0zKNnuqlD+FGI1avvYvb22byxFVAOL5xi+XxmY5NkJbWK0PKScS3DcYIrYuI9yoimiA+tW9R4T6j9sN1xrbt9mYWnSXqHsoq4hghGuG4rpmHlnfncwThtG0pjWVaFAyd5eXNTSZVkZxA6gUyaJ+ZX4edIDiY7RUMPveDPPP5H2N0/RqhLLVnyhhaiRjrCNnevTdoTtNtXUIXjEBBVlUPKRA2el6zGC5qD41RFluU9YAunedkVjKJSY0/5BCrG4ujBjB9tdcdzIgL2QblQDbDOV1Q+L1JwB/3+j4yl/yB+jdZu5h1LD8jO5qSNpgkTLc+yrSHT3LknQHzmFchfV37LnIWkx1XvoY+3cuUWEuMvqvJ6PWkT0qGPktQhBDOpZFZtqJzfZoSddnB96xD+iOpgUo/p0rvl5yaoeub6dqC8vXn9zW94Y+yll0g/bNFtHaRHOl719O85zrfm8n0z6Vnh2mRv4/ySd+LIXad0flbQlR5iZz1iKpfx+4aI530C33tqh9prdCZHqB8jTlL0hpOptLmzCzGgFjHxatX+Gp9i2o4YBF1lHVhWlrSXBKluSDGENqgp6l0RItK76DyIJWAX55w3DaUtmLRrhgNLaMhSKz5+pe/yNaFi1y+fp2bxzfZ3tlmWGk5/vLWDvfu3Wbn8jXK2QpLwcnDx4yagv/sZ/9TxvMCt7yHH0ek9sTxCCuO0K7Y/8o3GJzNGb1zH/Pl1/G7G4STGTd+7Uscfen3aecnPH7723z4f/bvIm/dJU6HyNfvwPQi5qkNRscj4s4Opm6IxiKrOTIBtitimOmc9kGpahf3Dwm3DpHKYrc3YT6DKxsUTz3J8Ikr4IZsuUB9a4o5uMPpoGVhIsN392E+Is497nQODw7wDx9QLlZwusA+8ySts3DpOnJ8m/DdO/hVSx1WjD74LPKplwhvvM70A1doWuHgcJ/m5IS4XBFahc9DbBBRNV6d8qmF5tjGTm9PRBUqQszjdyO5L01nBele7hpCbTZ2KkB6FlrEwFuzM1qJHDcNQSKTouBiOeCF0YTKOraqKkHbMZ056c5bjBEb1BatbMBZoZlWyKdfYO/f/lG2PvYBvCtoE3lEB9hpNtE1ZifDnKGkXDORdP5N94np/OXjumZbvycwpp9EmssTa9/sEKPcJLtmrMhlAsnMz9wKke2s7TP9Pr+RLvtbpyvnz38/r/fvXNZntyQ/oBdmEiRm8yVphpO9vg1ddJ7Rkb5XJl+8RtE227N07bop285BZQ/fu5V+c+X3036HtUI/2dhKyiRy9CxkuQ39fpbyztmP5XuX0KRIIn+eftWShxqZlBS03f1n2q10IUbnZbrVyuOLc/9Cv9tIzoS+B4bc5Z8hqB4aey8BYp2fLqZ3wulOIHXddh+UnkNMWQodpJgcDK67/G5eT9cAmGFTl9Y30o1SoG/G099NmaMIKraRDmfeEyZneIHdyzscHe8zkQ0WtsGuNGOMoobAizZOlqL1g6wp56ylcpFJZRgYw4YdUDrHsvYMqsBkbHj60ibXr+4x3ZyyWkV+48tf5xv3brN15RIrv2J7a4PNzSFHpwc8M93l4eEBlzYqrm9c5F/8k3/OJ5/7KFProBzgnRDuPcA2kfDMEDMecfTOO9izJTu7e6zmZ5SLGeVTl7j929/knd/9Ers+UkbD8sYDDr72Ta7/D/48DHZZFgH7t/8B1Wc+jv/xT+IOlgQHhY341QxXFbhZRRxYimiIyzlxMsQbT7E9hMbjg8cFkPkSO9iCcoiYVme6j/dYnMLe7kU2xhYxR1STh5jHB8jJI8yNO7i7d5DDM+wT1zj94hc5e/NtisvX2fzkK5TGcPbd72IPV3B5VwOJ2w+Z3X/MwcEJNgZC20DQXjAfWozRs5y7vENosEb1vSSq4bMuE0Ho5H6AjnrsfYt1/Z5eBe1lu72ac9w2PKxXCDC0lo2y5CObG5QYLg2G2pcjmjxnMo2xGpy4wtG2baonCt7AxCrcWn/qaS7/1Z9i8zMfZWEdq2iS+oiSaIy1589ZdlSyZnfIhCGFt7JAZM8A7RU41s9ihvd7ktN7jfu6A8tfeQ+kTm9j9bNCkr/JBIEML/c2p0NGspU1Jl2jrP3541/fR0E/d9jlmQu5tpCK82jBr68LZBirE7Rau6hkeGPobsJEOlhmfeEy7Ka/FRNclKOYnJXkB9g3mK0b3C7ryVkA9PRhzNrf872aRN46T6c9v7CJ3999L9VcUncs+V46YwkminbLdoXwlK+JJIhonfKEblxrsiSXZl6YzgGrY1n7eaNwGN075ygnQ3F5jEDKYGLPGDMmH4wESaaoJsOPJo+a7SYhphXJ+Gv3sWn2eurVyU18WSE6KzNIZqp0MF92fuleBCBw/foFNp4Y4v7CKZsvn8IvlYz/fsHKR1ZOOF3VLDWeSDNnDEUbcRLZKyIf29tlY2BYzZYYJ5QXR+zt7jAeDhkNSjY2hkhhaMOSQWWp5w2niyVVDGxvb4JYYmxpQ6BuBHf1En/wa7+NbwIXh7vUN29Sfepl/M4mg7uPiQ8ew8aQOJ5ycPMm9eN9JrsFk2oLYyzHd27z2q/9OgOBYCytcXgLs5MTTCP4Avz+Ea4+Y3Z4l8nkB5Gbd3FX9pA6ZdShJfoV1hukcJgQ4cxj2gj3D8EIxY7AymGnDX53iJgkJimWam8btzchBljsH1MfPeaJ+QqJc/yD+7hH97EnR6zmc1x1BXnzAZtuj8N7x5ze+SVG0ykez0AEszkgPNqH2YLVUs9faJYY43SqpXgktgRiorTm/eaAkEgXhUo6ARJjGsOsQYjq+ylbzIsgIbDfrNhvG+6s5jTp5ytr+cjGJha4OhjqALi0LxXS7l8xJpkmQw+HkcKZEIhDy/6HL7L953+InZ94Bdmcctr4rgHTGqUwq+ZZUlMwev603yzVl3NNETqkIQewOcg2iYmXz+r6ecg2J2cU781YMjM3Z0DqrOx6fLlmC7o8Sa+7C8rzT7w33VFbnklT66/3C419n2yx3vgpxKRSzRniMalJq8MEpZ+vvp5hZByvq0+Q7CrvkZGQVBy2HmdM1whFt8jSrU+Ma5L2mVwgmg6GkCPjXHzOWVQqhIqmfvr53Q13MGBv/ISOqkxi2iRDrRsvuYwswNe9ma5J6u4hq0Trm+bxqj3e2T08yQ5AP8eYvE65EL7+87kw3z8LraOktyKuOcx0xCVHcTmjjGtaQn3UkyeI5o5dfWr5bvsoqo/bUo0mUbXzz3TfS1LvmYUWQ1QF5gx7CBQSkdgymQ64+jdL3vnRdxV5+3DNy/UHmP5BReuFe49PuPHwmP15YGEFiTBoA6MQ2ELYJnJpOKScVEhlKYclo+EAZypiYWmawGLRcu/hI1qBVhxFNNhW2JhsMZ8veWLvIssWJuWY00dn3PjSH3DpR3+S6lM/jL/ziPLDS8zWLvGZhnhwSnx0hFwrCHcf0vjA0eljtn7wY9inLnP7v/2nLB8dsFnt0foFTVhSRMvy0WNqBCNLymefpL71mFE5hnmNHBwj2xPMeItiJRg3JJyeIZsDOK5xRYlYkFGFfOJZ4rffhnqB2dpl/u59BrWnKCKxTJg+2jsVBXwb2AmO0DRQe8zRMfH4hPb0DJlOwUD1wSssHh9jjzyFCH52Aq5gNrS4d27hDk5ZPdpntayT3h5434BRJYaYgptMKukedIa6JHZZp0KiasWDgJdIHSN3V0se1EtOfEM++k8MR5TG8sRoxLQo0wlWned15CKsBUCd0kWIBGfwMahqgcDcBuKHLrL7l36UZ/7Up6mHFbWzFK1gygor2oSpII70Bjy3QJis+lFoxq7YOrlnL3++ntm4hmLkzIZzr3NsrwSV92mKZACmC5r1fRtyfx/GYMSR2xzymGmxiV6cGJZqVc8Tsqwh1cltsjemu74/AnX/I1/fv3MRg8oz9/M7VFY+QUpCiqYdJjX35FC7ox/LekaQYagcdSeDFukEFXXxU0+J5GhcF9ratdpDFl7LPqej6vZMp05OPKeZMf0cKhTY1Qik733JkbeIJEVjQcvvPdMq61ipuKZFxBM6p5RuI6cg/V4gI2XdfSF0OixC19zYeQnsubXLEGTOZHpmiCScMR1gswZNSaZWkDIR/XoX/UDKEHvcVwjd2vYbt8/A6D917eZs57A0qpIuG5T8PqlMYpJR0qKup7UBW1iqaopcit2SUMDi2cd84ObHkFbYGY24NKr49r1jbs1q5qIU7klREqThwbKhLUDqJUVh2dzcYDy2tM2MkzYQbGQymTDd2qG5d0LjA66p2ZiMaFcLKBzLNvCxH/kJXty7xm/+7/4TQlnSvPwyd3bHXBwPCacnFOMNZDjCXCsw2xvE01NqEYqyZFm0mE99iJrI4de/wcgqzXgeFhgjDM2AxYMHNO/eYvKpV+CnX0F+9Qv4jRHFwBFPj7H1DpzUyLYlnAhm5LCPT/GjEk7OYFxRrFpigOLpy8idfRZ3b3J265DxVz6IxJb41BO4p6/RGC0mz4OnXELx+Ah5dA852qc4PKZta+qjM4orF7n3ha+CK7nysY9QHpwwe+MGrYmYIIgPHN24SzB3iCFSGENo20T48KmxVc9NSL03WfhQiTuWQXsB3ILWLHJqDsZwZznnsKm5t5oTBRqJXCgHXB+M2C0HXKwGDNai6izxIsYomSIFWQp1Kb05hqhD2AwEGzGtgARWhRBeuMLOL/wwOz/5MrI7YRZBjE0TLW0i76SwWXK7RK4t5otI9QuB89lHOl1rGUVmUZ5rT+gCvuQ8ci2VbFvoSDD9+/bBpZrEnC0ZcvtIDgdz03unrZbro1meyuT2h4xISLKP54PeP3HnkuGlkOeTJKOeDXen7Cokg2ZhrSu8h7jWFrz7Ry/SBz11mZhF57Jj+N5r6psfTfeeWWDNpnkkOUvJTj8X//VBmO4zNZ/IS6LzI7TrV6MoSYXsLHopMRfy8sILPfXYYUwP83T03sTQEtK1r12bPvQ+Qsj3ZxMsmHHb/v4T1TetW74CQ7+5c6QKLhXY5VzEpLBcdzrI7JuYCn/Jj6SXRls5O9P7Xm8ezem19H8La1Fjfgtcmj0P3rfdB1jr8DFgHBTFELcsuPnt+4zOdjF/ySJlpNyHS/+3M+a3vsHZkzs8tpFmtWB3YDjzJYt5ZFUIh1YHbs1OFhwFT4XgjKOsl9SLIybjCU8/fYXtvU3aILx574CHJ3MkzeXZ2p7S+obhYMpgMuGTP/KT3P/C73LwnW9x6a/9BZZbE77rV+wu4QV0nkbz3VtU+0eYjz9P9DUiFgmRydNPYj/6Aievvku9f8DUltRxxUo8G3ZEEIM9XXL09a8zev4FmrfuEpdzSh+xxwuMM3DjLrJ3AV59iH3xBeTejDgdYe+fwnSEO1wi8xXy7BOERyfQtNz/2h/CZII5uEG4eYB841X2m4Y7p6csF575xoinLl5lUnoGjx/iHx6wfHjAYnlGbDzzu4+J8xXx8JAbD47Zevo6LRBadRw2RmLwqlNnUqFdNCrOhWVtmk3wa+rFUFUPuH76OfZWrxCN5+bkl/kOX+DdxSkiMAuekXVslxXPDCdMXMkAQ2FNd+b6c0X3vkKi5kiPagBdoGeTsbZt5HQI8oHLbH3+s2z81Kco9rZZmIh4VeIojUk6fTnocucyeg2mcgCcmo07O2XWov2E6nSMr9hdc3+Ws11Zz+70XrOtUQHWFISuwfjSMT37USLZSXWzFdeWw1Cm4WBeLzbZalU6j/2yZaQq9m0DWuh/f97l+3AuMS1gFnRN2lUxF50yVug66KefF2+6uzvn0RPMohe8XhuRpMGlqqoiKuGh/TS9I+lhp9yn0WcP+hx0kfsJkfk+QKJOXbSuzwQy5JZhNZMGGOVovJPXMLa75mxYdT+lWoaIzneh1HkLpqdN6gbKmLPB+6bTAeo6ptfw2fX61rnrT5GHfq0fxgVrDLVzaazTvgF6bSXI3b59gJA7+hWCtAkOg74e0u9Sk+pHXbe/9FRsK8oHyFMo+4JkdnrQjZ42RmtRURhTYmvL/I0DHr7xiN1mxF+6/yn+wa8e8ManHvLi689z8bKhuf0O06/fgoFj//oOsjtmo/AM4oL5sqWuSlbAzLeYOGBihJ2hY3Nrg8nVi2xMprjCcvvxMXcOZnz3/j6LqKw83wTu333I5NmnwMHZ6TF333ybd/7+f8OHPv/T8Ox17gdh7gz3QuCpVc3o2h7VB55QDa7C0bx1n3g4pxoU7H7yFexozMEffJ1V3bK9vcPJ7BHWWCpbYaPH1i0nt2/xRDBUb9/HTreIh0c09Snm6BQZOvzjU2ZHD9l87imGR6c0Dx4yqAY0+/tEifizBdXFbbh5n7oM7L/6Ftc//hFOfufLDC9coYkLjn/ra8j+Cffu36eaTIkf+SDmx15mdXzIo9deQxZzaD3RR1Zv3KIcVjAuEd8wu3kH4yxtqoPkRsVsgHNRIj/bEEKCxOC40UbFvJ/s8iIvLz5DyRCAzdMf4R3zmwwKx5XRmL1qQIXShnOkbbNhlb6uq/s7F6bPE2IEIYQasbZjNgYiKxsJL19j589+lu2ffIW4u0EboRGDFbU3YiI+BY+2C/I0whfJGoIx/T33v2WboOhOb+PSOSMTVtTG5Ki0z1tAsGR5pFxfzaWCLnBMfxBJDdHqFHqGbHq/LuBL8JZkm2EwOIXps4kWmwJbRwY4kjWBDFWSbRHv6/V9ZS75pWsek+HuaxWdAVxzJK67UKNUDTIs1WN8EnPfx5rXj1kJOGckGadfb+rRn+0jgHXIaU0ZoHMsuSPZgmhGZFw2nPmx9XhjPiR5Rgp5wFja4M6YZGv76Ek/hy6KsV2DYuwyv/yz1uqESrqsBXVQSUtrbfU7QcP+rlPFQ+La9afvGUevqJC3ZGLSrTVNpXfuoqbcq5O3sXMlih0nhemojrJbqWgwrncayqLRZxglwZG5IStEsGl+SvC0tZIbLCqz4YKw1RSUB3Nu/7dfxr/xmGdf/CBXPvkCr756kxe/MeTtXx3x1cl95s9c4Mkffwm5+Qj36h2efmef+aMhJzsVO9Mhw+kG87OVwinGsd9EFqXjZBG5uzxmXJYMijO8j+wva2arFh8jUZVbaNtA4QY0TeB04Tnb+Aj/1X/1Da588Zv8z//+/4Uvf+fbmOOAGRgeEHh8eMAzzz5BrAb4YYkbDTm9fY/BsqHcHLH5sY/S7B9x59VvsWUGnMzPWIaWi9NdttwGp4tDbBQW+ye0CH4xoyyGtMeHVK++zXI2p328pDGOR+/eYOMTZ8xnZ8jNe9STIe2iJpaW0/uPefJDz7F/5zaLRw8oZkucEfZ/72tc+dzPcP/bryOrhoenB6zignFw2HpJ+9Z9zg4f0h49xiXlA2mFWIiuS9KoqqMHL9j0zDEFQQLz0GizajL+q9jy7tlhF4wIwlFyLvn1nN1gzYKx5Qb8yNZVBoOmC9ysqBgj1tIxCdPZEZNQhHONv6RZPWmYoNGgK4jWSeZOaF64xM7nf4jtn/oksjelaSIhCNEqBBaNYAurorcZKUiK4lEy87UzMu+BtTLC08NTEvMaZOeSfobcgtGbrB7e74PUbDvFJLeQzrOWq5JtST+n+or5PPdwvTUW40q9DvFpfV1qOTXnAvu+zpNYbB1kpJmYxPO1on/T6307l5CMZbLGhKCLpvWFJCOevWCOYtaN/FotIIuidY4iU6HoC3G5wBQTJ1szGP3drhbC2uetRSyQYLq1iFoLhvoLzmoxM0dduRkye/7OwScue5pxSB4qZIwjhAytgU7fy2ue4o1Ungr5YRuj9RoMWepbOfH5+qT7XugiihTxZ4py57wSDdj02UJeF12UlA4nR573qBb1tWdFuu5g1ykPhEQZ7Q9HHwyAJ11Z70SRpKUpHUSnyrykOoseFBM9TVGwEQxliIzckLmvWTlPLIQRQ/w332WX6zi7yc13jnj3S9/gzlffZPKVb3B4cMDh7JgpcLuN/Pard9gcPKQqHXJ9i+2TJS8dLfjB2ysOJw2vXdjg7mhAi2EokWW94mTZAg4HFCZiWGl3dwi0IaSssaCw+jybpuZ0MeP1q/8b3pRfgB340Od/lP/wOYHvfJsmBAY20pZTHs9nPD1fEEtLIRBXK8ythxhTs3H1edy1Sxx8+VuYwxOqQcVRe8hgtEFVDljMj6nKkjJamsUSH8+I1y+weu27HN26y4XLOwQsj969g7eRelYzu3Ufv1qwunWPyjoaE/ESCPMVZ7fvMnvwGHd0wnhvytGN2yyOz4hf+DLxwRHVdIQRT7M4YxZa6qN9ZoVjfnKIa1UMtsBStyskRFYx4JMWnyCc+RV3FifZtBIk8GA56wKsfOIH7rxpeXFjl0FmfRrYKlYcLb7O7upjRAKPp19kMMiip+pcRDQg6YJm9ByFoJTkaEGM9jGpqTVJ+FMj/yZo8+ZiXMGHn2Lz8z/E9o99HLs5YRW9jn0odI8bSX1bIkRC6oHRni8jCeqmtzlq69L9iAo7dogK0jkBRediB4uFmBAYcqbQw3xdq0AyY1Gi9tGlgI5MSc4/0LHM3qvHaOhm3uckqsvqbIK1wjmIXe8rIwwRQxppTA+l9+///l7fV+YSRXTwlUkMny6EXRtStXYBNmdia8YnL2AIkmZH2A4qks6qm+5P7prtZnKH3JlucM51gpHO6Xx75cyHBJHp9UnUolyuCfUZ6VrjIopjro8HSE49/Z5Sa2OMGtVImtzYNQvqCeghwpS1JOw3DyrKKgJZ3tvkjEl3TzLurns/m+ap60Pus6sc3emY02zslQYcvcfallzu1AwsYb1GyIN/lHywlnqn98+QnY4+iGQ1Zmv7z8+L2+HK6QDEhMvGRBsPxjA2ht25sHHzMe2//A4bF59k7zPPEy9t0ixnHPzOH7D4h7/B0Yc+waW/+Bd4+pVXePzV16mPT7n1jW/xbdvyjoksnWVYCL507K8C7dkKMYYbGN7cm/BRa/jw8ZIfvrXP/mjIO3s73JuO8EHwfokEjyS4TzINPnV36xk32NYzLCq2T894fucl/qD8THdzN7Ze5rfufZf9h484qTe4sLMNGB7WNc3DI8rLW7A1YfX2bdpbDxibIRc++mGMCMs33mViHKH0rJrIxWoKi4bCpcFsJfjHj1h+8euMn30azxew3vPwnZtc+NhL+NWKGFtciBzeeIfJdETbrsj9RIV4RDyPfveLlEdLxEZmR0ec1Uv2pjvYwyOsbxnEilAvKSqn8v2rJUe3biAhYCTyxukBIUYV+hThcbNk7vuueGPoMnaMCmh+aGNXg7dkXEtruTKc9FkFKcSMvQuyznK7/CUOJl+jtTO8Oe3QjlyEFgN5PECO5HvjKypC6RwtHusMjW/xqNDnSjztzgR++OPs/OwPsvnxF2mmFW2IBGkRp5p8Lhn1/nyt2bA1G6Hzj2xCV5KjEbv2s7H7HeiqKunueyVwMaH7PBLa00FkQC/l0tvRvl1A4Sytf4Qeqlqz0dk26iOKZFirM4YkaC9dV/dQ0//nEP888pXsNhmdei969Ee/vg+2mDl38Xl36f2ZXgF4rTFSxKxVLKJG+Gm+Rp5O914V5Gz08+fkQUZCnhLJ2u9mxV79s47Jxph1reg2SUook8PQNDWG9zYgJlWANVhKNYZyT0ZIcvyuyyj6sZ8a+UnKOuL6BiHVq5zOmNAOZKvF8+ywEmadVaeNsYkmmTMQTadJ3cX6GUG7sw10/TOi44GxWWspM2ey8+oJGKp4mjBjo9fpg8e5Kq2RT2mz7dYi7+f1DCbX3zJd21iIPlIJBGco3j1lcs9y/Bs3WDRvUf+z32f4ox+l+IEX2ayexG8+SXjjHvH2A7Y/9iH2rl7nnfmckRnwePaYVwuYFg5XR6qqwEukzYGGhVBW3N8eEp/cZfvxjCv3jvnBO/c5Gg759uaYN6uS+uoe7dY2vPZGYqdFCoFJiDzXqBF70gcu7Z/pGb/zL9m99Bbza1cA2KgCn5je5v/6B19h9yM/rKrFBM4Ky2z/iN2rO3Bpl/rXv4g/O2bnxecZfPRZVicnlMeHTKsRt4/uU1uYDEbUJ3MG0xEWR5CaKngOfu9L7HzyFU4vbtGcPcaezjm7ebeT/bESWd68SbW1SRlbTAw0tMlxAo8fQTC0hWF+dooYWPkVzRzun53iZoaHp4d4Aw9Dy613vtPtXYvB55peioAvD0dcHY7V8AOb5YBrwym9HlWg6OqQJtVVcsAkHeTbNdVjcC6HPZ66vIeYLAGfrqQ7s7q3rBHEqPSpyTXeFNA4CZTG0IpHrLAiUD+5y+hzn2LjJz9Bcf0iwVqWxmC8J4vsprwhQfJ9BrBu73IU362H5GJ3hpDULnf1l840J+eRWabZsazbg5gRguwIskntoalMgOpwGUP3O+cypTX9xB6yS7ZY1A4rRKgjpvOgN8lrTd+sKUgnQ9zbLjrHqYyykvfzev+ZC3Q03HVYSi++vxASPqQUN9LESb2BnLnkh9XXUeg3ZHqT/GCDaLc13XfN2u8n+Cw/EAPGapocJc0CT/0hmRHVO8HzNMDcOZs3g6VI/S89e+K90UT/+5Gcu0bJzkET3xh8ys4spHRbXVxStE2jU1ufJFZcogSmjaLOVq8rJq0lSXWM7MDVQeQ6TV6lqPNYukgv9+Po+jkyJqzX0xMdJGG3OZrJPSuOHIn10CVkHaQ8CoHsxI3BWnCuorx/zJ1/9gWmWx9g85UPEu4+wtw74Pi/+TXKX/86o0+/zMa1pxg8fEw8POToxh3m9x5SSeTURuYiHBeORQzsLDzGW0wVGAwKfEjd0oUwjJ6touDxzoRXDVw8XfHh0xU/9vAQ+Zt/g9/9T/4jKErGv/iP+Ph/9B9zZVHzXBtwAoP0XB8VlndHBWfDAlM6/sxv/4f87qf/91z8sZ/gP/jYHYr5Q268dZfJi0GlTWMDEnl4eMC2fwYRS3z3DptNy+bHX8AOR8S7D9gsDbPBgDvtHDOsNNLGM8BTugK7alkROb57g9k771J+cpPifsVqvqK5dQOrGvk0weNnp/hSn39sPcvQ8nC5wBhL9C0xBE6C585qpsaqPkWAJp4nc2y7it3xOLUSGK6MNrk0GiK+ZblcUFQVpbOUxqlzSHONBEmtXALGpiw1QaapTmKdZkZBpPu6SbUT8l7PLQjGKt3X5FMekvmXNHk0BaQkOFhykGexITBvG07GED94le2f+zTTH32JuLNBiOr8rAje2SzbCZIarpMx72xXhtrTvtZzocGSTcGbznzJQWpmqmYDoVl+lkuSLnORzhZmgd+YdRhz2p+0B/P/hD4Q1PpMvrJ19m1/DrtG0Kh1Jv2nvm9Ik2Yly+gQ+nvOA9Vill7qnUmXBWGTKnsK8u2fcOaiMwZSYUoCuWMbE7toO3tUWYN6Yqx1cZPUSG6s032U+iY6naxccIqdkbKJsZXHecbO09ruM00qZBmTG6cMxhaaKZEeeN+yQU6x1+nLOTMgLWwIeh0d1TnN4daIITcWxV7sLl9zTIOL8n4hG29NSSX3c6BTKNcnAepwsghWNKshpo2SaiQ5xoqkjA4wJkFsHhtSdNGNa87vy1rrjP5e7tGRdFC7SMjoREFjQkeBzkoMMdVX8kudk15fsD4d3AhOp0AOjmoW336X9rdfZ/drd7l78Brj7W3MZMqFT3+IDYTZl7/N2T/5l9SjktOdMY/+yU3qOhDbFXVTEyvBIeAbZtZho2VcewaxJQ5LbOFYRCgjTKJlPPeUCEtreHNccXcy5NrWHq/+L/495OIlANq/8pd56b/8u2x9/evsO8uJhddGFUZgUTkYGp7wDT+wv+Lq+HX+xs98gyd/9gKbheetmw2HTcRIpfh5HWmtZb9teaFtkPkZ7f4hGxcu4sabNHWkePsRFAWPz/Y5I7CR9l5EWDUN5ahiCTS+YUsaiuP/nJ0nZmz/24Fbv3GZd76rNSHfeiQKD9s5Z6ePujMTorAI58aqMnaOQcrYK1cwLSo+MJyy8J7bC639PD3e5PJkE2k9tkzBjhNCdEQsA1ckiZ7Yw8Rp31hjNXAkQcNdpqJ1ESPgYtfKC0ZZVyYKTV3jJDBwlsFwiDeGNhXhYzKEEU+Z67tJbwyLDmKTiDdC44XVVgWvfJCdn/0Bxp94kXY6pKaFmBinVk9gEQ1YIdCsQT6ajRhyvXWt8bnb5on5mkw+Jlde1FZle0GulyTkQM9klpdKDLMuSE7AsYBBVa5zT5lZb4voOvyzk6M7rz2Rh46pu87czVAe5D6WHEDazk7qtfvkdJLtTs4XyZlVypjpzM25DO/f9Pq+hCsl1Q8MdDedC7wiOZo2XYStAog+wTnrKF6O9nPEsNbog02bLI3lNEVyQvo9xTZzWmi7hZe11NDZPETJYG2JMwXG5E74kAxiXFtg1deRuL54JicjiXHhwJaJfpiajmxOLs9r/3RJXUQzi5gKg4nC3a+nSmLkGpGmwKbLWkR0sqfQzw1XxgYp6ElOK/0Ro4XCzqFkKQgMHX8+31N+DCj9sH+t0YrXsqjcUWPS4cpYdMRQGMH6QCgKxqakuH3E/F99izu/9jXmb91jo7UsxVJJgT86IhSOs3dvsnHpGtf/vb/E/v/3X2G+/RYHZ0e8uzhgtLHLph3gokIZgxipfKQZVJwRWAGXg+EJZzmatwiCC0CosXaAlMmlR8PKWW4Ph5ytaVKZKDzyDa9OBzwoHXX0BKfPZ3dseOXyBa5/5x7DVvjsv/+XePFHPkLllgRbUK88wVpcYfFNJDjLtCh5HFcsj04Jv/UHhOMZ9k9/FvY2cW2kPT7h6PSY2/NjbHRUAQosWMOsXTEYjPBALZHp8ws2rh9igOoiyIdu8dWvRJq+7MHQWCZVRW56mw5Knh6MsclQBu9xznH/9IjoHJcm22wWJcEHXDmgEhhiGDqnQY5EJKQzKmBEOgjakKntOcMnGc4eDla6OakRPEO4Ie3EiIkqIFpWFV48rvBYrdXjTGqjliUxtGrUnMMZhzcxDQMTpA148bQm4rdH8MJlyh98kcuf/gg8f5mmMCyjoQ2hM4rZUZH6X3LWnv2GNkjn6zUpL1hHSM6jI/257RGWPigOa9+TteAu/b5dl38xWFMmxwAYHRnwx2UE5wvq51GU3OGfayN53LGIdMCKNoqrBFAetBfPIUeZQKS/67qCf86uUNtnvufS/sjX9+FcUqQsPfZuTAKNZK15KMFi0kFAefFNWlRNsZVWF/tiPhnwylxt0zkWiaYblpV1eTJGCJmD3t+xQZ2FNQ7nyo4vnhlU6/0h+Stqn/UzrLWdN88GXOsIjkQzS44gFedyotbhpfld9WDqnukzhBy7qEMM56/HqMPOUtmaeZG6nRWG6DZAAqdtl1VB7rTN6WxOWTJ+2zv5taxtbZOC6cgTmLwBMwySqeP9BkeSpKVAFQzyje9y9Hd/h9W3HrE92GSy9xSsGvxiRTmYMB6OaE2g9Q2Lh/dZvvYmF/7K53jtnbeRmceYgtPlGeVGiatK6mbGrjFs+cDSBJVsMbAsSn7q0y8zdIGj4yMkCJvRsDhdchhaTGgJEgje4vbvs/t3/p+c/Af/SwbjCZ/6e3+Pl199XaVZhiWr3THV5pi965s898QuowcrbqxucfnlZ9l6cpvV4oRiOCCMJ5zuHxBtQTUeIGIoqhEFhrdOjnjxa9+Bf/ErPPGBZ7HFkLN/+StMfuZzLB8/4taNGzRe2LYjhsFjY0SqkqP5nOP5MSehUQbTbMULa6eucIZP7F6inisMFHzLCOHSxgbDqlI4SrTxz/uge70omImWtg2Wwhpms1Mm4yk+eAZArFcUmyBRO+pN0KAMgdi2mOhVIkciNq7tGxFM1yul+7AsdIRwTLi8RB1zHiXoOXIGV+l4Z+NbhhaqNME2hFY1w9IIdVeUUBa6+YOnbltWwwLz/GXMh65hP/40my89zeDiNu3IsfBJUSOmrNkE8qlWe6n1v7RVO3vTnTmTz37oz046CxnGk9jblt7A95nEejafg0xnC2JM0DYWkwPc5ASsLVPgqQ2nuY6c3yPdwbkAOi0K2Qkk35jqp77LSGIMic1qOvsiqe9Qe7gz2xdyEN0zw9DgFtLwRr2Hwg4SesX7fn1fmUv/ygzpPvLPxkcXJ8E/km/QgOgCW1um2S9qNI3Vpp0YM2W2N7DGFprSOYMWsdNMka7g1QvEmfWHktleTp2fiGjtRfKIYYMxWQU5Pyitz+S+lCgeCbF7X81S+jpIJOjBtvogvG/XIg/d8Ko82m+9LCOuuJaOQRXTZ3Uh9BBWdtb9AB/XYZ6ZPcP6e7uCGNruAK0zOkyCynIktd6PA72D6dey39Axpfz5fbJT7H42RIKBwsPou48Jv/2QR3/4kOUq8szOJk9dvsTi0SH78wfYwQaD6ZTibIbMWoK13Pz132X78RGFFFSt5ZoZcKOZcfd4n4sb2wyi45kgPFsIRxJYiGAFjhaBr751i7/4I8/y7IVL+NmS+eN9ZqsVL2/uEIeWg3mLb2E6qHjiq7/Dtf/sBpd2dhm9+S3mH95l9d0jhsuGjabi2tVd4uQTfOv3tine+q/ZvjDiqZ9+jrNHt5lfu8R4tIHb2+Ho3m02NnYYjaYYq9mkd45b+wc8nO3zNCXjT3yQW//4n/L46CbXqzGLW3fwJ3O2qWis5dAv+drBHU58zQyPbT2VKxgVJZNbE2ZvLxk/0RAWDvnWJTbriNhCJ1UWFiue5XLBoHTE4JU15VVN2Kei9dI3RBEG1qhCcfRUJlJaYWAiK4HTxZzJ1hQRr8rDOVsl4oiUEhGr0i0WJdSEmAbhJl0unWrZAIl+bnMEHjEmUKQsROssEZcCycZqoBRixIcWGRbE6QD2NrAXt4nDEr89ptnbYOOlZxl//AOEcUFoWyRGXbcQsSnQCfhUi8yKFrlOAX12nnMT0v7O6EmqG5NYYWs9Yh0KITlz61sAztNyzzc5x455Kmhnf+ojswHpah46eTcHg/lA94iEHrqOMtyRBvLLkSfNYlPtdU0EUy84N37qdegN5RJAr7SyLhorXeal62RtkUBBk87+nzAs1rGVOu0uu8bayk15vTfEpBtPXd5i1Oh30ilCd4OQHIMhQWLp81Kx1llt7svibxjFcXNhORvB3Amu76epX5TYzW45VwhLD0D9VN/8p89Q2S36/okarL+g6b41xBAIwaubTe8RY+wcp7IusuNKgnERchNTrwyc1ov1zGeNccL3ptkm3Z+u19qarx2c/udJGaNmZv3LdLBYvxEhy9/EuF70UyhJkRwdcGSIiFHY8gIDlm/d4Y2//a+4vNzkgz/249x/67sc3HiHC5MxJ7MVs8Wc6eYGxMAieJYSaWOkWnmOv/kaWGjHI/xJzSYDlr7m4ZnKtExN5EoUShMJqcfHSsFX333Mp567yLO7I4JvibFmUASe2R7z7LPXmM+XeA+7k02qwnJ4dMDq4V3qwlG9cB13YZv6ncfM75zwT3/j83zb/B+J0XDR/GX+ex/4G6xODsFa6noJIeKXS779zde5/OSzlKMhwSqzcNHUPLj7iHm0bP7wp1isTnn06B3OGghf/AK3Q0MQz92wxKd9Yes5O+WQwsAIeG7nMi4ERjW88w9GbD8ZqA/H1OKwLPESCRIZDofMz46IBrxXp4JEbIwYCdBq7c9E1foaWkdoa0bO4WLAWcPuaMSj5YLlakU9qBjkLnKs0jaMsomcJQV6eh6D1zNJ4bT7PrZoQV+HeTkXEZt6ODxIjNSArRx15TC7W7idDdib0k7GmI0pZm+DwcUNzIUNzPYEtsaYyQBjC4J1DByIj8wlgm8ScCL9PiySccw117VzpH8vFQ5KWZbENbioO01yzraF1Idmc0DZ2UA19KarkawPJsxnJet59QGvdJB+Et+NiuykNKG7Vj2OOatKnyume68OmlpjbDpXdnZLg/RWIbbcvI1Nahv5mlJ7RDLKuW7TBfudXY7kZmwt6HPOfr6f1/cFi6lHS/hdSmuNoes3ybBJZoZIYizkaDzTAM8b+LWFJEX3Js9I0E79GL1GI10KGDsoLgu5neuUTdBcTJCSYsn6+HKaF6Oc3xQ5Us8ii2Rno5G7pAFk1iV4q+sX6QE93eTp3TpH0ae0HSMubSotnp1Pr3tGXSqs5I1l6EQ4cw1LoIs8DEYzvJSG52uyed7Ke56myU6R7GQTg41ibXNZLIZA1E58DD512o/MkPGqZHraMq0r3vzKPuW85PDOfcKdR3zk5Q+z+sCHsW/dZBoibQyILTAUjIZjZvMzPAECFJS4wjEYDlnVI8aLJWMTuR8WtCvHpCq53hY80a44MZFgB9Q0eB/4V197l7/+2ReYOEcdNPubHx/iTMAVFUVRMl+ccHt/n4ihHI0YVAOiibgrUzb3JpxeGfPul/77BKkA2Oez3OdP88zuN7n+0VeYbk3whfDo1g2+8LXXuP4jnyfgiVLQBs/J7Iyzk2PaomTyoaf51m/8GndGY95eHmDCMgWgho9cfIL5YsGeGbBHgbuwwVt3bzH3NQ+PjhmIcG1rCwlwdqPADgRX6F5ufYOrSuaLM2rfgAjVYs54oBJDVpSEEprA0A3YGU5oRKngJird3CaduqktmYmhCIFmsaKoLKUVxBYIKSCLWT6/6eCQSERKsNLirKN0JbNY4wtoBwPa6RaDi7v43Qlua4Pqwi726i6jq7sMLkwxWxNC6WhHBUMx+CgEIzQECJEoOpHUGYMVpcwqw8p0cA/ZZnR1WtIZUhZUHtzXnWEK+ppintOUhDRjPofZaPRnuXvrGBGT2yCSQSadsS6LSTWblGX0xXH9lXOZCF2btYaOXbaQe1IkBW9ZGHi9r0Q6e5TZbGpXkkCvmCT/n7MxSddr++J+dnaJMKS2OGdH2eGqfejKAum+zxO2/vjX99Xn0nv4/LB7uGQdq+zhl+63+/StW6OEMwodtAT9uuViG8kA5+yimw1Cvw0695ChmsQyiSF2w3x6wkF22ql+ALBWs5EEm2XKZRSNNZXakcXnNFrEqbhlHotsjOlqNar5Y3L+ktaujzgg4799OqqwUwTjU3pcYEyRiAY5i+qZZ100g6b0SjJw3df6qCog0XT/1lvOpIX1Q5HkudNnIzmS0ayrQEACk2DYeLTisp9SVFeQWPLhH/95Lkye4LW//4+IpzXf/cLXeO5PfZbtP//zTN+6y/Jf/CLlcgZVgY0BE1TtwLeepmmoqgqMMJ1OiBIo24DzBfPQgjVcGY/5+NxzB89BLClLnQD4h4+XPPP6XX7ig3tMNqfMfGS1WkI9YDAYMV8sOZvNwIBzBYPxiGo8oqhKjAhvfuNNwmyfwcYhnOV9G5hO32Fy6SqjnS3aeU28GPnNf/4r3D5Y8tLeDr6t9VE2DfXvf4mdezd543Cfu298g/nZKUUQrrmK7c0dPhhHhBC4euFJ2rJgsbvBGREeHWBKS+O15mBNgRfAFnhfUwaHK1LR20HdrMAaQgp2jFOYygChDZgYcc6ycpGTVY2JAUegKgsIgWAUBRgPB+w0AypXMqgKDG2CpNXADYYVxydHlI2jLAyegGkBIyxLkI0N/MVtwpMXKZ+/xvADVxhfukC8sAuTMcEIhXUYhFWomaMMSB8jLoL4QHBK3DGQ+lg0Qi5tkRqTPZjMeIrnIdxzNmn9lVGQnOlnlYn+56LowLLcpyOSSTnJlkj+rMTAkogRC2m8SMyU6/W3zZ8hlizqm8xK11vWGXtSIGgcNk3gtd1ETbWjMSikbnFIIjPla8q4hnbY9wbfGJeYeaK/16Ee551tnuqZhJfSddFBvJ2N6m4w2+1kc0xmov7xr+9PW0zWKceasWiROTcFZviFcwb33AQ2SGlalnaxSAid1VP+t6ZuOlwo4YIp4pc8h339ut7z0kVOjDCJGJc1d5TFoplUihhSs2WI0kUnMUpKvzX1V9ZaifYrqveLErqNqmmoI+ce1vTjSPMgodyw2Ov5JGNO5uzrb+eueIXVUMZGdoRrUyetzbNteoeRGy9zfcVam3DYjP3mlFoSDTJHVfn36Telel2CMZgoDFae6+0YV24QXr3B2W99BzavU1/Zo5xMMZsDJidHhBhYuogzDe/++q/zxFe/w+gDz3Ltox+mmlzEYTi9eYOyrJgt5xSFY7WqU/ezwVphOBmxU8NiHnkUWx63K3bKgqcGYz60mPGH1KxSULIsDL/23fvsbBR88qltTDHDL1uKlScUDaNihJsM8G1gOBkymA6pRiMWixX37uxzdlTz5OVLfObw/8wfnP2v8FvP8OGn/hHD6Tv4+AoHN98FM6B1Y375l7/AtKgY37oJr57Qfu0Pab1ncnjA89Zw9alneXq6yXMyYu4D85tvc3X7MmbW0i7nLPYfIcMBG5/8IE/8xZ9l+fpbvPuf/ReEVZOCksBpXTOelLgceIkamsbX4BzRCN4IRekoKqfzU3zUptA2YIcDDvA8Wi3ZdJaR1SmublCx9A0+BgZVye72VEkFNhID4ATrBGtasAXOWZpVA4Wjeeoi7hMfgA9dZfDCFdzlK4TtDaQqEYNOAzV5P6rSboi5Iz1JDiFavyksRpQAIkZUBTv1kVhLB22b7hRDjtB7COm8wewhrvWiuGYsEm3SPUwkGglrYq2mg4g6g5mQDiEZeLFdIKa1Ez3LpjO+JtVWbfceejmJHCABkUz1y/mKRaLTjMIasmZX7sVO/lQVD+R8ppAdg9ZZ8mfa7uvaHuJBfFJIyXXi7BByUOnIgxy1zq2ZqpiUFRqDTWtokv01qHrJn7i2WJ5VTs4qoKsxaKpEB0919Y20GDaPKY0hMUlS3UZixzDp3zMkY5o9dPpvpg6nG7Omp/atc9Qzy0MfROKTh1y81wg/14icteS+G0m0Wr2OJNRI0MOXob6U0GbZ7Nx5211XztqMAZP6XgT6OfKx10kytstsJTWhaV9NyLPGEIn40GC7TZgFQvNGVYUC61J21D30PsORc7Nz6PyGOtKc5UTy/BatGWVH5FUiQ2C4aCmPRoyevE57dkppLuKrIfHwjPbgCIYDZvcPGHkNGHyEg+WCsjpi8nbk8P5N6s0Nnrj+JEECdjzCr5aUZUkWxrR5kqQzbLuKYlKyWhxx6Jfcm59yZbTNDwx3ebB8zDsA0VL4wKFYfvXbj9gohlwfVZgmMCxL6vmCew/vs1zCaDxl88IGnMyIIXJ0eIZfeJ6+eoUL4wFm/1f5uU+8iXn+OSbuHmVRcHy0z43fv83G5at8/Re/wNU3H/JkEMwv/gPq0Qhz8TJNVfLGix/m8LU3+R//3M+ze9ow/8KXKUSIdoCvI4OqpPIWaWvsZMBwewPXOk7vHHLUeCIFhoZgLSsfaVOu64PHSokrC42YC1XljghN1H3pfYuLCvM4W1AVJbFudOwzMChLKmPx0VMWjnFZYYmY2Ki0irXY0mAKh5dIRUCMoRqUYCric0/x/N/8axx94iqzoXbAx6gNysaviIknYqMat+gSzJpIKZ2GnkBhHTEKTiwh0Yyt0e/lCaciniimC3L6rCIjIpCZUqTdm/+hvXfp81OQ1Y3h7s6L/qQxWofJowEyTJzRhxwg57puxgf6gn4vvpsvRO8Xcj+JwnkWnWqcfieLYZi+UG+SgyLD/Sb3uuT37VGjzOhU5EIL7cnvJrun8FhMy2K6MkI2AElyyzgQDYhtAmastWl8erbHBkNBHqsesyzC+3y9f1gsL4PNkEv+yhrbADohQ2OM9lwYnUYJatACohF/TDUVcslsbRN0BrjoU7IO03mv18x4YK8gEKRNGYOOUSVBRtL9vk6e6+fP6zXn+yBdk6Cy4kohbJInLzRKPDd7XjMRrRclzDSxwWJMUUuOyFJql51uplNnardmG5Es7klKzTMOm6OiXMc32amZ3jHqdWfhHaU79zTo9BxNSa5rWZvfQ6FEfVgOCYZoA+VZyxu/+jVY7HD9Z3ZxjXDv9TdZ4rFYDo4eMRgNscWAwlVIu8JLoEU4bAMXxmOaouThowf4xrM1GbOqV6zCCiMFRoQiRgrjtJ/GCjhhUhU8VUxpT1tu+prby2MqHB8zllUM3LJgAhgbeGcR+SffuMXnX77GBTdm1c4Zbe5yzV3i0d0ZsXac3l2AEQpn2Sqm7DxtuP4TC5Zv3OR4z7L5/Bbt4i7Be47eus9JuMXiwQmx+SZLowHNziufpHzpJZrBCLn2BMeP97n99a9T4aiip3m8z+L4lBka0s/mcwZbU1oD8vQ1LvyFP8Po+ReIdcvi/r0UsBgaNBturGXe1pSFQ3xLniIIEEXS2F+VafECZYyE1ARjB455aCjblp2iZKNylIl8MR6PCQ5Ww5LVwGA2R9iqwLaBcDpnh5Ji1RCN1hM39na58vO/gPuBjxKfn7AwM2ZRsOI0n8hIccLixSQFY+n3ZM4UQOuoaecREIhZ2sSkhmCTAqys6EEK2GIKuiS9L3T6f50hzo4nZzekYFE4p8eXz3ai2n9PM+AahNYxrKTPevpMis5WuDz1ds35iSR0JrbKKs0ZU8yClb1j6scsdzfdO4zuvOp79MF9hqecBp0p8NdeozzOOgXM3T3mXp6+odKkfge1gTmg1AC6c5qk9U69SyLhXNvHv+n1/jv0rXbrZoOUDWEnLS02MYz6ZsYsyNY1UQr9Rsj1g5iLSsl3ZKVferJA5mzrhuiblTRr0YWLElOnazLoxqUH3vZd9tF2zyyzqfoIKRXyJREB0mbpWIAiSUYhbfYO88ypuCjXvruHvJHX6kldbSVx/GOWgMhFO3XQ0oUt+enma8zRSV+ngXTI16iDRpL2EnqgsgSH/rt/bh1GnV1pyMrHYHxkJEI49Sx+5XVu/73fZXz1ScqTwMVPvMRhKdQ3HjAoHK5e0p7MKKohriiQ0lAOB9i2wXtV1h1sTGkXZ8xiYJxn/9jA8fKIoSuBBpFBjtFU+jw27FnLZHOXzcUp360XnOHZk4KP2IpFqNm3YKXE2IJ3VgX/+Ot3+cxTe7z4xIiBEaY7jspNCDOHNI7oI0UplMOGl/4Pt9n79CkIXPz/FHzzP73J8sa+PvrKqcF8ao/DFl7bn3M0mvALP/ZjVHt7hFVD2zYcz844Oznigl9S1JF6f59FXbMqC8QJtQTqtoEnr3Ltr/8Cg+c+AIMpTbPkytNPUgwsqzZCarato2fmDRtViUHwIVAOSjVAKbAAg4+R+XLFlgGJIdF9A15qptMBpRjaAdSjCvf8FeoPPoF78UlGH3iC0d42ZjqhqAYQGvzdx8QHx8zfvUfx4Jhwe5/ZyRn+yYpLH9nlqFyyGhSItIg1rDNRc40zInTh8jlDrP+OiRCz/tIgvC9Wy7pdEDo7wZrxOweFGauCtVG6jD9/dpd5SA9jnZdrycZ0LXA2mT2Vzr5J/gabzmXOcPr6bQfoSB8kZ4Sk64NDzl33ev26m/iYgjuDIGu9hNBfq95/7ANwfQJr2Vmyx3kUgXWYrO6RnWBMIb3onrMZcu/eT5JkVl+viol+3AfC7+/1fRX0LSYVjNWYOZN40yZ/YIOPPsFB2aPrgsauKJejg3WPqt+zbq14lBxRFJWoJneKp00aRVlkhbNrN53kEoxXaQ7R7nabmGrr60eiNHapLP3mtThVL00Opo9JQgdf9U1WSXomt8GSN1neoHYNusvKABYkZS1rBy7zXzItO6f8GWYQSerKvAdz7rKs9LWuayxtd6NjBhRW08gtnYDe4WEobEGkxUigdA77+mP879yn/dJNLsyE0cGM4699g6Nvvcb06h6tE5rVkspajT59QwwtMQpF4RhWgxRdCtPxhFEx4OjsjEqEvfEYC9SpYB9qldupnKOIoEOktRha2IIPTba5Woz51uqU277mQrR8ioqvSMNh1p6SwLum5fF393nlaMBnP3SFZ66MGAwEW0RsEzh594jVyZKtn4Ltj87I0PmVn/Z899IpxcaTLFY1JxMDVcWZGB4crDgzcOH6FUw1oAkaSc8WCw4Pj2jqmouFYbx3geO2xaNTDJu2RcoB9tlrXPpzP0npSpa/9RXczpj4wRcY/cxP8fLr7/Drv/TPURAr0IbIygdC4Si9o20ahuMJg+GARdCzUg2GrFaB2nu8MSqPY3UWiaks7fYQ8yMvYX/8w2x/4Brmyg7NcEA0BW0TccbQmkjtPK6o4PnruBefYvjjL2NDJPrAsFkQMdy1Z0ih+L4Lmi1IbuTt4J0EFZn1zEHXtZtgmIvF3f5ep8BnmxDWT0Efy6fvrw+10x2bZ7vr55sEMfcMzvWMJmVU74V1crbSBWOkzCJfX180735FuhwJnbprsudZQ0IyZN7/jl77eqd+vtZ8vvN1RLQekh1Jfw+do83H3EhG03Rd0jPpFalNQjWSres6Gt6bnXQASLpX19mumNTbTYL7zXvX8F/z+r4K+tYWnYyBJUmFhx5aikG0MGX7DZaN9nmBylwfOS+ZIFG69FnpzYopG4Ma/Kjd4Cp5r2yjQCALsWVG1HnIyusVSK+ThU2ZCplokDdvjkAMmJ5Jce4aJSR82ylNmpyJaAqft7S+t3TZkPS7S3FnC7ZYF4PM6X0qHuaHLGmD5A2dNk4ubMraxuvS3Jiit5Tg2k6mZp0dlg5Rjt2MZmaVt+zZbSbzknu//m3KNx+yePSAtvXYcsDUWR7fu0d89w5UhrKo9POsSzUCyAPWTIrKVr5Gomc8GPCoWTC3kW1rsEXFql4hVqGRom0wODwqJlmkXN+GlmhaNivDp6otLsznvFnPMcbxQRzfjIGFA4mWqi0w0cL9U+4sPaPL29g7+0iTdKCC7sM7/wJeOhKKiT4WvxxSXX+Rk4M5tx+eUDcFvhV8a6ARyrLk4lNP46oRbasQw3yx4vjghMVyxTPTbaqLF7BlQTSW5XKBnZRc/MzLXP3kRwk39rn31pfYf+N1mC8ZPfM81/4nf41n/srnGP/elzk+eIQFluIpo0Wsw5UVvmkxwHg8YX5yilhDUZXQpJ6xEHQ+kYX53ojB5z/J7s//EO1z14m24KxdaotFE7GmJTpDayxOHNYLOA/WsYxeg5bYgnXE4bALXqyoenif9feBDazR+tOMkPWREV1eYNYNmXmPIaOHt0S6LIFkGPtAbe2MZlgrZ8HdZ2VSy/oE2eymtG/jfKDHmrFfuz9yRB8hK1ak9+sK7PkcmnXyQZ+F0H+lu/7eluS1EHUiwhoqlJ1ZPsfp94FMMyavUcpoLRYyAWotQO/YXWlkiDW279SHcwPc+lvMQWm6r5xtmWyD3l/u8v5hMc0zVYMoSyqQi1uho+fm7lUVdAxogVZrBLErntPVPzoCQIQ0eAS6m9JhPxoIJPn5c+lxohsjOpwnkqTyhU5g0+RGKI8hkCVlDCQ2hWY4NjURdRWQEBNnPmcvkZ5OHcg9KoJ6dddRgHvpGBFD9CndT9piRiwYLdwrO8cl9oqy5HqmTHrOXfyWi/apUmrW8qOo9QCTmCEKL/SUSj1ESs82pOJdioCiiYAjSKSSmmHtOPvdb/D4925S3Jkh3lOfHhG9Z75csDXcZjgYsgxnEDweD1Jgk2Pv5u1Imq9uI227xGLYnI4oZwc0bUs0UA0rzDwp4qLjc10QxmUJqdZkvMEaIeLBWEZO+MB0yOag4tXZGUUQBhiOouEVadlCMLRMEMzRnHA055Y17G1N2BoUVNcHDKYjKgpu/K0FF3/2ATE47v7WM6yKLfzGCNda4vwUvIfg8EEwoyHb2xfxMVLHCE3g9PiExeoMt4w899xlytGQ6aWL1G++zeSFq7zw4z/MxI05+vXf4eDefZqmoUjZZ/3667z2//hbPPk//CtcfvpJ/Mkxs9YT8BhKmqal2NwiHhzRrGoMJdYWzJslEhoswrSqYLliNQA+/TRP/U9/gfYTL7AwYILgiUhRpqwiqRWj2ba1SlcVtMs9zZPV4K4LpDTQCSn46MZnrwU1kn4vZoja5NERITmblN1I7xi67D3tcMjBp/RfM3AO6rXqxGJsECyFHSBiCZ3xy7WaFLWfqwuY/n2M7bKVHgZLArexz8ZYl4ExKpwbYxpBsRaoSTa6ebBehsQlB+SpiVFydtCjGJlwg7gMJKT/T/eTrHnO5PpsIz8HDX5jOtf6fHySlsmOQ6815iyTdCEmvVPIzeh077veV2MMRCMEo/qGEIh/0jUXwXaZWZcd5EU1OT20iFgkejBtaurTxjvpmgLTn5wtpKwjy8VrT0ZICxKIUqvScIw4p6M5o5AYGLGb4WJE7a5NkUS3TXP9wugDVxaYqgaECDHToLvCYN6HfbYhKWqw1qr8RXetPVtNG7z6CEa1zVJ0lWRbJEYkiWlC6oJHN2xmrbFOO8zXn67HdAfiPZGDSSw71tJhSY2ukvt5tChnJHZDlmKMOGMZ+MBWa9gunuT2l77Ga//lf8fzF54gnM6phiMGGBbRc//+XabOMkj3lQt7ra9TwEB3OEWgLAskthqQWENhLSWWxaomYJmOJowHC5Y+EKtCYVaJ+GgpC6sOEMPS18xjBImsaHjQ1ESgioEnEZ5EjdNt4L4x1GL4clHqoABXMI/Cbgsvb5R8Io6YLMDYBfPf2+Tt/9cBTDfY+vwrDJ6o2FrVuI1dzh4/Zn58xOFqySo2bF65SDkYUK+WUJXMVnNOTo6o5wvG9TEf2fsYHJ4x8A3Pf/rjXHzlFWK7oP7K1zi5u4/CyLo/rBVMEagePGD+D/85zy8iLU6jT2dpQ4OrKiab2/izBb6tqcYDJnGMDzVl6TDDCQicXa64+O9+jvHPf5az7Q3aYHBeaJyysLKAYc4CJEUjMUefAr4bmJePZzKy2LX9ZpSEkx2H6UktgtAP3SvQjviQDFY25uvZh6T92bM89Qiu93v0/iFnKiq22GcRXTaxBlt1wZnJSt7n65P5POThXn19RZLB7bOL9WvM/5a17N8mFELyWe+yBdZ+tz8T7z275+8jOYL8WNJ5l3R/nXtccwLr31NoTDMmtSs5yE4PuavbrrNsHUVREvJQwLVr6tShu32hWZQ+0T/hPhfTCUymgVjk/o88fjh0LCcxStVtY1CGVa6FJHxSLzamYj2JEqlrEGLbOQftI2nQ6NtrvScXorPntWnzdv0qmpFoBJAojWnhFPLKnbBpEykBuRPZlC6tTmwX8iFTemCMmX2V5RFMD1F16WsaFJY+X/RppUOS5CG6jChnebkxtB8vnLMUiarkbC1kLv97HUzM0GRHRlBHn+UfTDAEI7RWt10VW6IRNn1gd14xdJeZffEGJ//462wuCuSspj45YWM4ZFQUHInHR6HxLePBEGcd3ntGwyFGloSm1SqJaBNXniuRqcXiA5MII1ew8C0L3zKtRlze2ebmw8dEhDboBEEbwATD/aUO7VqFQJ2MlzOGiSsoMJTWUCAci+FU4A0RvmOEM2MRHM6Iqg8by73W8vDhGV95eMzVsuBDl7b4yEcm2KefYfWH77Bx2DK4uguxJAyFZrhkyQxjWla0bO/uEKLHxgIJMDs7oz08Zud0yacn27x49Qk4PaH44NNcu/YEzM5YrlYcBw8DC75VCkkURBzBKRLQ3r3L1t4lPnj1Mub+XU59jUgktgoxbu3tcnpyhI+BqnRsb0yJEhhvTjmWFdf/43+H8qdepgk6y8UJSW5dz0WOlruw2EjXeJlONj1TKLGcUgAmKBqQqx+aCIv2raSIH0MnL5/NTkog3gMDrQVJXVd7/nzWjFcucOcAjjXDpwFTZlipgGZqa6AP9EynZ6i9GjlDo7uO9Pnrc03SDX4vdGW67/XnMw//Mt3Xc4NfL7WfnVJfI9J7+F4Hc47AkL6X3YnpPxqMyV0q3fp0NVYrpJlghG6EuZAn9QoagGvPYHbQ2bH2jN8MbwqyJsX/3kD3Tzhz0V0m3QWHGDHBI9Tk+QIA57SzYsTHFveeedom03VNic5BaCH0htYYNZZRWjIzStPisPYAXBeZmNRoicmCjno48qNZT7dFpGv4zIU/XcCYvH1OjYW+M3htw4mob2MtckoAch8n6P/aEM5tUiGNiHXrGzhHVgliTMSA8wfy3/xkugxLsgNbS4HJDlFZdI7IQCyDUHI5DhksSgrZ5OB3v8O9X/kS9cNDhggjH7Blga9bJApuUNAkhpQZjXC20DqJMUxGQxYhEmPvYnNNx1mQtuXK8RkXFjWXI/y6CPuzE4Z4HixnHMcFZlUTYqCOWhuxqCMCuFAN2SkGGAyVc0wLDVhWbcut1RHWB7aM409R8YT1fEFaHplk6kLEOcGagATDgXMce7j94Ij51pSPjMYUdQuzM8q4ByIs65pwOiOcLPBnLYWpmBZjtkzBaNBQ7p9w7eyMPzXd4rnPXOXFD3+QrSefRDy45QVWt25y7/Vv0Ny+D4sWMQFblsyj4dF8wWbh2I2GViJ+NmNmYHfvEh8fPs/h7IzFasEkBNqTY8qNMZOtCYvlktZEXGnxeOzuiK0/+8OMf+RjnGFoCw3wjKbYuJD193JUnY1JPhP9eT5vYJP8j/RnbT2MEUyCjyIh+D4oSoiBykJpBqrhVej2rwaYPdspZkNqDNqjEtf2cK5l9M5JR1e4LshTmCYhKsn+6F63KS5bH2+Rz1PonCQmOdZzhf5z5jw55/cIRmZ7ZxI5JgW/Gd5W1mzfqZ8HA64f5I7Bms/6+nnvrjd2vyMJN1tfl5w15d9LZqSzSyHqSGeT7JgOWbNgS2WURroexK65NOSMs890czBAWua4vl/+Da/37Vxi0M0WUCZWTDBFDDpe1CZ56tDNYrFpA0YkNSzlxse8SK0P3UYOsSFIq5WNhHfG6DGpdyULvulta/OVIc2vJ5DbW3tMs1dRlqhYcxdSrcG9OkVPv54fdAjrNEKScdLfV32vNKPFSecIFXrN6XMy6sGnmRIaXVhTEPE6SMkUnKO3p4gjU7j7ImPalJkVYvuNpGuUGi+jJxiN5Co3INrU8inq8AMRGzxbwbB5HNkcbuHmQ5pZy9tf+E2Of+8bbDQRTk6ZDAY4Z5lMp6xCQyMek9QXTmdzLmzs6DGNLd4XDIYVRVHQ1nUX4WToXgIMVyueOJ1jgCHCDwL/cLbP7dk+hdFoN3jPwBRcq7YonMVGz/XxlKErU9a2htmnTNlLwBnDxrDitG6obOAztuCqOL4qwlsucmYLnFgaAra0OANFYTHk/wABAABJREFUiLjYcvL6XYqtbQCu3jhg7yRCiDSLJcvTmuAHHIWWB6uG4t13GN9+xLRyfPrJ57i2t8vo4x9BJlOoIS6XNCeHHLz2JsfffQM5PKQ0BjZG1LHk9vEBj5cL6tKx5VtGo03sUqdGhuWS4uSE0XjKlcmYMBqqIKWLLJs5iFANBlANKaKlHoL50y8y/HM/zFlltCnVC9GEBH6iZ04yYzJFt1303MPPkp9XOhqKLkDP4gydETUZ4pJ1WDQVoTFYU2Ep0T6sfC7XIJbMGEvtA+uRtaWiz5GSeofNGFG2Qlm1IzEtE4yqNZ2MOwhQY2JF3+Wv50Ogn+IqWeY+Xfu5ng9LbpJUc5WCzHPOSLMUa9VJ+ZAkoZBuRooEhWVFcpOB1nWU7GVScNyzyrqeQXKGAzmzyHB57r8jPTOJvTOmu+50L0l3MaSMUBLrS11uUjqWQLRp5DtRlattobW5NSeTs8hsV9/P6307Fx+VvqqG1WpzohEVMkyz4I3pvanDYlPqFrwWY7X4Bnkmi/ZVSGLw5AvWyN1YS4wmyUJYhcs6+Mrgo6coKp1JH11XSC6Kkhj0wSuGa/FxhTFp1gX60DE6J8Y51z2EXFDXNbQpmhJCOrgGsKL1lBCFEFvKskz3nGHBNYYZQkyd+JbUXS06JS8L1Zl0+CTqREGD4NYciB4I+npSDAr1kCKTEAiS6ztCoMVEcBGisxAtu9ExWMB4VTJ8tODxV2/i9hYcvHWP5t4+/mAfd3SMDCtiU8OgJBqtzWAirnS4xoF1HM1OqMMFRsMBbb2kbRuqqqSqVECx8V6TamMIIdLEwIOTM15KhASDYYeCPTeiGg64PBwyCIaD+RkBw8CVFIU2cNZNw2gySMPfUqe3dWSvPBwMKFYzhgaCdcxDS4iBjxQVLxvL3Sj8YfTcBxbOUotOy7waLR8b7vDjGxNGdcvvAVdu3uGJh4eIs120XlYDZpM9wrQgOEuYTLn0iY8yvntAeXCCbOwRtytkecLBN97i8bdfxRyeQmyZDMc01nBrdsKj0xm2dOxtbrEMAb9Y4suKYd2qcOOyYRFOEB8oBwMODo6psIx3N6mXNVVZYqshw/FYTfL1DXZ/5gc4qQxNrHFR8MkYaatVxERPRIMbV2SZjzw9NSS0IQO/KeSNmeBhE6SZmZhorS5B0iJae5HUl5HE7xLSQJoHlAxajKmGSoqgfYIGC0WuUDJPNE06Mcm3iWBS31hHRUbFcHN9Mc+VCanZRNE1h5VBCkAW6b7zPWtfR3Y5OtLbpLOXBhMakNi+p2lZbZaEkOjW6XzGfumsqK3RUd8ZNdA6a4r5OyhKAyRDHqWelTHsGimBNH/FmLweqsYcE1qD6Wu6MfY2M8P5NtUZTBq3rk5BCUiI2h0hFfpjIgqk0QoSIx4VOe3qtlKke4gEad6Xz3jfzuXdt5YqRheNUj1dRVEMiKLy2BhwLhWp0xx2Sd7ax0Y9uM2FMI14UvVEFyels7rQhToRIxSmQAveqsxrTVTCAAZvnEqG2OSYBBoDZVEQpE2RmeDDgBA0qsOYjo8fg2p3OQPBZEguNxB9L00xE1ysNaxWK9rGs7FZYYxRiAA6QxhytGb0YRkxuKIgmKz7pQyYEsXwNXNSVVixtsvOu+YsA2I1KmzT5g4iOmwJnb9hKRHnaKUgiqFoa663E7bnhvLRKSEabnzpTW7+3te4vHGBjWKILBYc3L3JxnBAURaUFnVuJqTnEiiNOm8fImICB7N9rmzsUDiLD4oxO2epqkrrLiEw9y33Zic8rhdsGsdnyw2mrcZQ7zjw0XB5MGVaFpQuYN0GR2czYqiJrgSE2gdm9YrpaIzF4rLmkVVJjaEzXN3c5Wi5IIYFXlS4M4YWTOQFW/I0BTWGUauMnNIZ9soRl4qSEQMeplG1DseEQmsdTpsC/WpFcbZi8spLVEeB4c98mur128Rqk/iTH4ZFQ/3a69z/5rdYHRwgbc1wUNGaIe/MZjw+OcEMLNvbW2wPhkzLirO24e6qZh5aNra2cPMF9WLBbLFk0dRs7e1x7cknOL7/EF/XDEcDZosZ4eyErdF1issXmHzsZea7z7AMQaHpDkZyQE9+yQZYfF+DUIOTjFzMUkY9lGKSmGJo1RF0RXbJhl4LmtZCCA02CSxm6RExBWk7gwhtaLtarIp2CzE1GJp8TWLIAkmIaNe70F9bGp2RQa4QcnaRNLWy8K0YxHhVvLYlIg6RhqxdFkU75KPSK/ExEpctg6LElkUHbCCu6/7XbCldZmooUXukkZ+lUGgp2QlFKzKkpf+1xuKyXTGiyE8ISWE9QRBYrFVav/pqm6bA63NIWA7GkpAVSQhPHveeER3NtrwEjHMYl+yLsdpIKYEgKusUJaE4QQNsna21lj0RcemTLRkeTPJZ7+P1vp3L3/6//y1E1ENrFG5weRiWMUnzKJCIi9qXYk0KiARwYDPtzWkMKxmhSlxtY7HOYWyBjwGsMCwGSAxJNkYL8pakQxVTR3vqkndOi32F0zG0UYLy800g+rajUmbNn+BVHmY0HrJqNeoyKLNJ5WmyPpD+jrVOe1xSD05T1wwHA934Tp1K4YoErXn9vVRERcBZR5tYaNZp/FSu6QM5p2uWlQ1yjwxRkraa6gnZIo04IFJYi3HCsKzAOuraUwbPU4PIX/7Ej7BXFHAyp1lYHr75Djd++YsgDaO9i8TlnMP7d3h09Ih2b4+LTUlhLW3TUIYBMTRIjBQIVXreqyA8PD5iZ7KBqyztMrBazakGA1wBi2XLjdNj9usFRuDaaIMXdi7yZhvZblrmpeOobbEnpxwvFuyOdpCow7JKa1n4BnyHPHB0dkIdlEQwIh8C3TsuwGYxYGNjyLW4xe35EQ/rMwpTMHFjBsYxcWCtMMYyso6pcQxNgURPOW9xyYANjKMyA7BDQgjYKKzmZ4gT4u19Jn/h8xAgHs1wP/cDcLLi+Mtf5MHb72JWK0YWmsJx7+yUu8szvDVs72wyLAYqdpqg2nFZMBmPOJrNuHh1m9JYXFVhlyvq1YKHjx9wtlpw9dIVmtZTDCoubGwyPztCKLHjTY6bAV//3dvMbaKTx6yIDa4slLKfGVNdlN1j/MbkmSLSTXjN9QFrJPVwKTEgoxE9e0g0+0jGtCgKiqLCuZQVWJfeU4OANoQuKHPG6Lk1YKTUgnGnSpxqjcZgXDoDOJxNLLtsQxK8rfCxTq8s0sBBdZAjjClwzqgelkzVTMZIjC22yCMldH/Nz2aMBgPKobKmdC2UzanFb4hRiTm5CVPE6/1aQwgBH1SPzWAIUZKDUAfknMVZh5XU/5eJUTFgcn9LGjlsTMpIrEk9a6ZTIFGEJa1vqtGofSnoSFQGXCIM1W2a62ILheyQ3IeOIBTpHgtricZ3cJo+Z81gMFAU2rpRFuPOroXwJ5y5LJZp6Ba6iRQz1Mg6RFFqKwIxdJiiy7UDTMfi0n8p/ORjUkuNPqmCWgqDQlZGacpPXb9E3TQcHJ5oWmxU3NBmLFfAxIRREjsqckcEMArnkNNclOVR2ELrQ3hGE2E1qzHWdNCW1pNCOjAWY63S9oIObdI7TBAfHSeMjGtD9vTJYZkEHdpcGkw1InI9JRnN9D0lKqhjdkXRqUUbXOpRMTiJ2rQYtNBpqgLqGR9uAn/6Zz7HzugyZ7fuUZ3MOf3Om5y+e5NxveTB6RGr7R0ljBpPaSxDsbStp/Ue0EFoErXA5yQyKgpW0bNsLPNaOJrN2BuWuAJWqwVnvub2bMaD+QwDXBlNuTSYMDSOaTXGFnBctgiRoVgKY1i1DbUPDG2FNYa96RZycow3gi0KiOBj4Gh+yqqu2RqMqMRQpuHrImCDOt2hK/ngZJcnhmPK4YitYqwBwbCkLEqKIJQYyqLABkshgGmYn50wPNvnBKEcDRAfcNWQ9mTO1t4FgoPqiWtwcYq7e4j87A+xvH+Lh7/7RfzBEZUpdJT2oODm/kMeNStGkwlXRiOGownfefSYQ4HxYsGVasiFjSm7Wzvst5HTuubadJNga8pyyGSogcrp4oxbd26xu7PLcDRiNNlgsrtHO5hQD4f82m/9Jr9hHSvnUAUtS2lsUhjOKbZmMUakC3yyRc3MoCgg1iUCSN/fkmsRErWW2QnCmlQPFR0cZozBOqeS+Z3aeGJbJoXukCAbazWrx6iAUkhQtHO652PSGowaZaa9rhG/S+c2mNDrAVrNsgwK6yCCK1z6fJJjdUTR6ZxqND0Yh0twkknOzrqUBSX8OYjvnDAYJOj1W2sUgekYdAr5BYnglMzgfYLsbMqUXGaT5qJ66umLQh6aQRpKRuofNEbrH1ZgMBgkWAxIQWy2cc65jJmpiTOClb5nLKTRzeTkyIjaz6KgKqpE9RdMTOQo0Ywqs83KoqCqKp0XZHUwmUL4kZ/69F/9Y33G+2+iTIYOa/FRo2ld6JigCFG8N+l3OatS1zqbQQ1nRh8zVTI3JlpTEFJ3bzQ2jU6NbGwMuXBhl7sPHjGoxjQ+4tOGElERvcyQkO69tYCn0U2hAo9tSJGQJLggMt2acHZ6ikTD4myJTptUTJOYe0py66Lt8EeFhkgPQ39W0rpY2zsW1lgvkgYfqQ5TKsyLSdlfxvgzXEHKWvRQEiMRXZe8ycRYSlHtAW9FU34DsW14eSH8+5/6NE//8A+x+PqbvPtLv8R0W7OUqg7Mm5ZV09D6FmctO5MJ85MToniKwtAamM3nTHc2INV0hoMBq7pl5BztYMjct+yfnrEx2OUsem6enXDU1Ayc44nplAvVgBKH5AADg7EFrtD7H0bLxA048zXzJnBxYwIhYquK3all1qrabkvLYDAgNjALNbGFTVNiozB0Fa4TUY0UMeDEMKk2cWJxIeCKksIbXKOKwFiwtdf6XFFQ2ZLnxrvsVWO+NTvks3vPYKVFmoCtRrQ+YHd2KD77cdpygL+8xdGXv8Ls1dcx0VNUQ20QRiiqARuTLR6vluxOxozKgsVqySx6ZuWQoiiZ7uwycmqgTpqaOwf7bFYjNoZDnG+h0uLvcLxJ26xYnB7x8OyEzQuX2LhwkdHuJU6i8M58znxjG8R2ihZNFIQk00/G9tWwhYQ6a2Ta1zC0eVnS3zMybYkh6+yRlIETnCwGCYIVQxYzJHhS25cmFaJQm0310q6JWSLGaTFc6+mpBhf6IEt8TPWB3HsGmERywSoNnNxr47szT7IH0rRkmX1jPSIrdXDp+3hVc3ZWKAaFws8rq7NupOnqmirFtSaIuTZvKoMJxhhM7G1R7IhE6bMwuMIRRBIPVeEqZyzRa+3PGrRvzvXtBWK0+C8GTIyMR4HgPW3b5g/uqdgpFdGRHflZpoAVNBMj1XvzvRijihjSt0N04qPSX7vWYNK1mz6REKF3in/M6/2zxWJOm1Tbq01T4oyg0ILJEbpubWvSdLScknXIXdrIIXQNf5DS8oyni9Yk5vM5xsLWxpBx6Wii48HBoVIh4/pioO9rCzJXXvJDzoX6vAmCwnYnB8ddMcw5xVtjzjQSOcGaLKWgsMKqrtEOfIMpCn2oub6XP4rEJzcGSZsghIyFCkFIGHAiF8TzByT9JW2S5JxCDj00S7OoYymxBFoaZ5nWK356+xI/d2WPJ3wBbeTov/s1wpt38JfmuGFFVVY0UckVzaJhujElxIa9zSmnyzmtdwTrma1mLJZLRkUJKVOtyoKxeHyMLL2wv1zw8M6cpW/YGQx5aWeXzaqkKAu8D9R1o8QH8RzPD9mabHVD4CYbYy6EbZZHB5ytVpwMR+wMp9C0bEw2sXPHsl1RGEMwkVa0DuKA0WjMqCgZoIX9GBU/DkHxdB8aCjSTGTZQFAY7GadpghEpDMZGxfGj0ErG6yE4hxs7wmoJbQ0ff4Hicz8KJTQ373H2K1+Eo30mwxHtaMLAOkQ8bQzEENkcT7H7MFsu2Rns0swXXNrYom1aQvSsELwtuf/wMX48YGYNSyJbJnVfpbPjCoezU6rhkOXZKfWjQ1g2FNev8mjRcOwKVXqQzIVKtQlhbS/FzrkAXZCTs2I9c9nhrHXNR7pCercVDUntW2udJGn7XJMIac+bIIhL9R16Q5XrIToEKzU4J4PdD99K7CSBrH2XmwMySzRGT570mHtxyDYgrV2O0vVcZmWQVA/xAe9X+HaFW5UMxxtU1ZgoFkLSAw65kJ+yFonge9gwn8usAG0TbIihE9iNiSgQU/d7/rdE6RQFYspWAnn2E+TRxDE1jRss80Wrn2PLNBuntyGuKBAL3mdqdHIKkuDGRBIqrP5sHp6Y1VEymUPSveWsqG1UCDVrKIoxqoCSs7X351u+HypyjkJgOBhiXaRt2g63zYsqErUYF3UBO92D7gLTbcWoEvn075uNrQAY7ch98qlrXLnyQTZHFTuXn+Dv/L9/kZtvP0zOJclXpJpLlovPriz7YC3KRc2+QiD40NVnVM8sEQWFVPOUTk4cyRlbuu4ET0XvE8FADUNM123yZk8QWwz5ntP7R03+k/dbS79759LRqXX/ds5GXyqDL2IQ57Desbtq+Ek75H/0oY9y9OrrvPmt13nuMy8hz1xg/t3XET9j22/ShgA+YERYLha4rQ2iRKbjEVE8x4f7lIMR1bDCtw3BZn01oSwdfumZ+ZqjZkYrgQ035BOXr3N1OCb4FcumJjrRbANhsVjgQ8AXNWbpGZVDpIXCDDRDkMASy9uHj3lu13FpukFoWzamU6q2pAmtBhfDMSKRjclEK1QCeEmK7AoMGQuldVjnKAL4YsDwlY8RJyNsm+iXraoFDLCYIMQ2YL3HPHgTaZbQBpYEpAkMn7hO8YMv0TZLZr//KsffeYuJEcLFCzjrcMFjjKepA8FHgg8URcHmYMzKC/MAWzsXmI4q3NEpj2anFEXFzYeP2dreZlaviNWIx/MZl4djikEFIc0RMlqIdQY2R2P8fIGfLaGyHJ2sWLqKaKxCMqkmnods5VpI1vvKe0YNZQJkuz0nXRTeEVfWmid138b+XKbaUe7oX5/eagEjqkCRZAE6DTw9DjrzXv1arjmkrF1U+NWZfN7UreT6QNesaNQgRp96TDoPmBKndE9dFoZG6TH1TkUgeN139arBt4HROFKUlQZ/+XdIh9WktTPvabjM0yFJcjm5AxzIumMJDQQMNh3+7HaFJJOUHGK2UT6q1JVzLtXSNPuwKePMgV53j22LK0pG5ZC6XpGtvrYTaRIwHA9oWk8b1E5KNMnJkAswiSClpQ0dTx9U4LJrbFUUQr3g+/QsfF/ClbYzmovFskuVNHLxCevrwnfAEDxqQJNwoiV556gbyUifLQgofTXVYYqiwLctv/wr/5Kf/elP8cnP/Tj/9T/+RR48vIXEUhdJIoIn2pgio4TvmtylSwdNhVZhIBXZMOkAxi5Tyh31WfwxSNfff65RU+cgpGv2pCggZSo5LZUMfcUu0lIMW4iZUpwyo3WH0vHVU4ZFNgLSZ2IiEDGMDFw6XfCZjV1euX6Jj4gj3LmLeXzC43u3af7RP2N3tE0rLWHVsjA1lXWMnKO2iq/60GCsoW1bpuMpi9UKRBgOhszPZrR1w3Q8JgrcnZ/yztkBy+CpbMGGrRiIIYjQpAinjR5Zhi4Ddc4Rg0Kc89VC60QJdqnrOTG2rIKu8e2jRwycYToaYSxsjDYQdMxtDEErCLGHPq1LFMs08Kh0Gu1KYVmtGsbTgrmfY05WlMWQprK4UYmZTGgGA9xwhB2UeLHIG78FbYn9d36eajYjbBdEhP3X3qR9+x2GwN5YO+Nl2bAKS4Jv8V7wTUNRluQxBhe39rgzO8Ft7FCIwXrPpb1dNjc22SjGTHYuM9wYs3/3DnE44Mb8hI15ybMbu2qAnFJujYHCFdiioJpOqZ4ZEcXy7Qf3OdneQESnFKlhzmntenCSjUD+2nqWn+FarQOc07qyGbZKBXZS1C02FbZJtPzEbJTEkIwJhrN5z+r3Qsjvkx2SZow2w885s+ovPwWFdAwsm+pIXcbQqQ/Ezt7kOnBMEXau9batZzgZAUIdFwRb4tsGRGjqJTFGRsMJ1XAE3Wjv3i7o5zt6peW8Nvk8phpt18OXe/7o1rRLTUwPr8marVSybERSsV6hQnW8FpN02QTrVPlas70UPISsfmKS9mIKIpxmn01oU/Dl8CGog0lOe1AOWNUrgo/JFgplVWrm2OmspSw19SVJygjfz+v76NCnq1tE0SxE4a+8WsnDrWFzyryy/Y6xfZNibrrUcadGJ+GFPDJYC/KTjREvvngFEwLf+fbrRLG6OSV12VqHoeweV2ZdGfr6habesVMyNkax0Nxl2jkfE1JIYVPRUjeDJzlHiYRWr9uiTLXw3i5bSH0vOdoDV/TSCt4n2mtZqkMzmbmTGtLWIAyb1klyLUeiSntgubxq+cnBiD/z7PM8ffEay8cHNKeHtKs50CIxcvKH38ZsbzMaTdRZtQ0+OrYGY+bLU5zV/qPKOXyaZzYejZnPzxhtTjhczlnOV9xfnXF3PmPhW3YHQ56ablK3LYdtw1louXd8wMjuMHJKdfR1w2IRlT1mLa1piVEj8lVdMxkNIXi2N0csCTyar1iaikOZ8+DgHs9evorFUNeqpBxCq9RiiV0jq7Kh1hrJJKd4YJ3Swo/37yLf/Q6F6CTNLMJYWIfDUDrXwTHN6piA4cHf/ju4qqSmZbaagTOUG2P8cMjs9Bg/W2FD6OjiRVVSlANl1FgtHl8Yb9KUQxaxZBWFo0cPmW5vcWXvIrFyTEdj/Krm0niDxeKQYjhm6Q3WDbGxUVp5biL2AW/0wLcTHbV8VC+JZlN7LmwfkGRHkTOR/MpYe84gnMt6WGv9WDmoySlAdkTZsAftqdJCuu3GbijCQMo+EkJBLoxDHvDl0vmwCb2QGLugLL8F0NkO0ADC2dRXY0xq8MsXrOysmAQ3M1Eg30c8d62WttHeMhMthauww76XyRiLLSuCAVMYCJEimn4djElkGtPDduu1Vfoz3GWDsc9yhJ6hp2ZS16HIjjAZevLESBTm1F7N9NwSFJXrWeVwQNu2edit1oEFdPhCqusmNYSQiAtalC/X7CO0dY34NPxLGQuap5RWe9xS60A06uAMJjVHryMp//rX+9cWE0GSREthLUHSvA1Z0y4156MgNQL6tZgWx9D/TG5UMoC0nsKYbtMYY1gtG5qV4Q9fvctvfvFVWl8SwgChVqcV83yTlEo608FqZu2aMBZbFLjCJWeTfiI/sKidxGVZMRyMtNaDGjFTuESdNCl9zCy1foH/yOwjffj6vzXd7TOqvmhIH6Gl6zPWaqQCEJ2yT5pTPmpL/vrlD/ADgy2GoxGnb9+gnp8RfEvbzoltjTPC2WzGcDTEBp2xs7G1ST2rsU6HJSCRVVMTjEb9IjCsKlZLx+Fywa16yUm9UtisLPnozg5bVYn3kf2Vx0V9XidNw82TY57a2WFcDqjrhrpWYclBVVHESFu3OOtYNTVlWTAotGfl8vYWy6alqVeMBgU72xv4uCKsWpCQZsNoF7vClGtrnSjp+hwMhanIEIbNfUKlpUGLuCSoE2kxUXBRJyIW1tCKDm542DyCJu8fg5WCcByIxZyyqKhsSTEoKaoB1WAEVjVyo+TQRo1SVZTcXy0pNzfZ/tCH2CodRQtNjLzz6CHXL+xw/epVjt6dM9zd5fTufVbSMi6cqqkYg3HKasIo/XN4cY/HTeDYWGqJFNhzTqST/Ah5iJ3tsmZJXqBnjfX1ypzhZOPYz0xZF63sC9waNGV4LUFq3b816IprxjTDQOtnpQvI1r+u3+w+s+s5S18nZfsxISGGRGIRcy7Lee96aIE+duetKEusGaQeLlFBgrLQ90rnOpq14HntHK8lfucchq6PZg69qocy7tbrykBipCbGqDMd5A4Gm1vj0vvBmkahdN01iO9rvR33tLM16UikOMGkgBxEle27/aAvpRon6N8lNp8PStRKVyNZUmdtP7yf1/ehiiwp+bAJ60495knOu88T+te68VyPbvLGcc71xiJhxMaYFOmABMubb9xH2wTBkSQWEltFo9RewiJ/xnoRE+hgwpxppMRZC3f6g11U3DSNOs6QsPyE9zrrqMqqXw8RTILV8kbLziOEsBbJ9AdqvSiYH5Q2J6X/GDqGTUwYrTY1BsZ1zc9Nr/K50Tabp57ZaMbqYEbTLvH1Eu+XRGkQPOXAQhuofcvQWdq24fB4n+3NXUxrmYyGnJ0cY4wwqiqiK6jKirPQ8tbqjEfLOaW1XByOGQClge3xCJtqILvTMWVbsb9cchI9D5dLojE8s7OHqUqoA963FIVjNBqChVXTAIbFcoUbjyiNMCwM1zY3KE9OuLKzy8QY/HJB9C3Be2LwiZqZWXUanTmbMWC6UQcKIffSG6mnr4MZQ2IAShTtRLZZ2zWwIYF93zJzMLKVUtuj4FxJORjiypLBaEQ1GOKKAdaVqRcJXFSxzhCiJlNR2LYFp9bwuA3M/JxQFFwYjXn3/j0ehppqVFItG+pVwwW3y5kEjpZnjDd3KYPRvgervWMmRFpnqJ56gne/8Hvc351SmoKgDdNrBi5nL6lB10Bq4dMWgK5Zcm1/mZ6i3J/VXk/vjzLWIlq77Bxw6nc3Nhfa15hV6edy4HTOMHVBgmYHlvPBmVtnUGXLks9xisblPUb/ewxfgpXiusPC9JNZc09ZV6tQlfUsO5niz+95vbdOqn/Vu22aBucsxtmeVZUCoA6qT19LeR6lK4kSU3aR61DS31+2F/kCguTWQHJWGmOkbVtcUazZv5RFdqJA6X6y47W2Q1lyHx8mNaliu/NjuvrTv2ad/zWv9+1cmhgoUi+LQVNRPb/do2f9CrIx7SSvrenqEuu1Dl0e/b4ehRRFFQUiZk1ZOTcmJUw6PRznnGZFeSuvszqyUSdz6WNv4N1aJGbUUAUf8Fbfw1QmFRhTpPUeuCE/nPdmJTlby/ffF1j7Tuj168h1Kp1KmVbTKDvEIRRtzcdHU/7qkx/h6f0ZcrpkvHuR05ND6tbTNAtiu0SkIYYaYyPbGyP2T09Y1Uu2dvaQtmZ2dspsvmRne4ftnW3isXByfMyJATOoeBwaHi1nlBienmxwaTgBCewvF5zWSyarITuTEdYHBsYxrCI2BgojLI3lZLHiLidc254yspbVcqHjfUUbPINXwx/FUPvIaDTEibBRVYx3dnBeRU41A6ux1lGWQ6wtUmE4rXmO2K1Wz5xNTagmFSkR1gfR5cw4dlFe6rEwUGr1jedcxZ2jR8ztkJ1qpCXtGAnRs6xXlD7osLSqZjicUBQVZVlRljo8bzisuo7nEDzWC9ddxTyuOCES3JhqY8pT16/z+K3XufXuDUrvuTgdslsKp6VweHbM1a09bBCa2GILhxlYimrI4MIu7Ozw+M49wu42Llp8Ebqie7prpfq7FIGic3BUV0vY2t7m8uXLPHr0mNOTM4rCEkLsUIK8N/X/M7aejWGfFaR+YNZOWefApXuPVCswdHDvuuPINRlj9BbEkCSYetuR35MUuAZDqllIgqvARukNX/qcP9IZ5OvqbH2PEhijjDKbr1VEe4NSjedcprV2D+sGVm2SIMZpQ6zNfXrpIyX9R4wuqe2zXBC871UWOqcbtQdI1mxoYW0nVZVhv/WXcy6VKtZWwfRU5e5SOvJVtn+qftAxVzu+kXSBXeze7o9a4T/69f5rLqIPNcQAogV3fWgax0h6yN+j9ple2tWfOPA2Fcdj7LrRo7YEd8UwE7WJSA1uUJpfkkfRSZJKRzbGYY0S+bv0PBvufA35YJi1BU7/nwftZC5/EMU3rX4M1hXEGBmOhkQfiN6nVDXxaBKG6r3v7iPGqPpY+SCktdHCqEkdxdoUFtDN4IzqtRauwAVtkNwNgR+9cJ1/a+sSW3cPaeuajQsXOTt4RLOcpQ76lmC8yqbEBnygsIad6Yj9+YzjasjQWdygYrGqeXT4iN2tLTY2N2mc4c2jR5zVpxQYrg7HXCmHjGxBbFoaog4TisK942Nwls2qwoSIM8LFrU2mdc3BquFBEzhZ1VRnlivbGwxjwAePTyyqyWjIYrFUjNgHFosVk0Gl2QngfUOTZr+URYErSpwtKIuqYwMidJx8Y3O3cjZEjmD0AJZF312OGGVyYRG0ZqZF5lwTAJeMaOkKJuOJzjoxqLn2HmkCvm7wTUszW2BtgRSWIjWjVcMRFAWuGjIYDrBOmGKYzjxsjDmZneFCy8NHd3n28hWu7G1y//YtJrGlijWjsuDo5JS6afA+QmEZTCcMp2OCCO7555gfnnLbBBYWAi1OKhWstAqd6d5T6nUCVLBEqmrIix/+KD/+Ez/D088+w2/91u/wa7/yyzSLUz07hR6PkDSxVDle32H99Oam5C6M7AxbxgD6iDbrd70XGls30JlJRjpHNqFD6z+T3wuj0Iy1JrUJKK1ZBwXSZTnfkx3la8rG3RqK1HeXHVcurJu1QWEiuTdF/khj+l5HQ3YkzuJM2b2nUpR7eE+yu5HcLEHX05fvrbv+zvdIt4aZcZYjrfdmlkVx3pxLvu+1W4gSidZ2MjKZCJHSbpWAMYCxfRN5cp49TPk9S/JHvt63c6mKsvf474WdpE+TWYty1tkp1oBxjiDKxFJGlaQgKzkjo7iiMQZC7vR3SRdToyxXlETxlIX2LbQ+kJvH4lpEcv7zORc9raFQHVS3fhBsSgWV0aKFRWMMw9GQxUxVaqMIkrqUTZFUA4xgospRDMqBQjv4JHmRU9z0cMVgGWATDdO7yDgKhW/ZCpbrWH7+0rN8bDilfus+3hVU21vMDh4zPzmkDQ3Wavd19A1NW+OsvhcSmQ5KzpYt+8f77G1sYIGyKpjNF7x1+IiVRA4bnRD5xHCDoY9slyO2JxuI1xS9kIirLJUrOGlWvPN4n43hkL3RmJG1FIXDlo5wutLeJwwHyxWjquLCZMJqteT/x9p/BO2Snfmd2O8552Tmaz5zbXkPdBWAcqgqAEQ3mmyymz00IzG00GgxIS1GC4UmQguFFFpoOysppJgImYVW2mqlkOEoGEMOKXJo2pKN7oYrVKF81a3r72dek5nHaPGck5nve7+LrlJ0IgrffV2aYx77f/6P73ratmO5XLJYzLOCiZyenxPCnPlshvU58ZgSTVVRVTVaYZ3ZICS32BYpLgjaS8eqO2+VcsTVjtT1mbFA506QTIkydhJ1Tq1qyZvGFIvNVohtqIxC662zGq9vIv28V06sGJEu0EWFH6+3Z7Sb9ZAMbWYzrKtZXL7KM4eHfB56ji8dsrl7jwPnaAj8+S/+Atl6Hn/ySdre07uKXqCXxPzogNl8rmwBfSRePuTw+6/x5X/1z7lpLGJqoEOCIssGYzdBbbX2ylmton/iqRf427/7d/nu937A8eWrGGN56/u/yQcf/or3f/rn9H0mPcy5gaI6RmsdCh+ZEQ0vCdlbGPa/DHtowN9OlNC4/XbzjyXkUhoBRrLTVWJRk7DZcMQ4lBsUoT5ca6KQprJpUAQimdQzDfVExbsYhVjSdaePRSlGHKIXe0bzkF+OY6gQKXVDaTCiIXt8WamIiEaBkqJCY66BmCrkh+RXEU6MzzWNhoxDNL43nZ+pIozZOyufD8OdVMEG8nTmD4piYZCdf81hsekJbe5iuPPckwecTkBpexyCejzF9UpT658ROSE213fEPGlWKFQQiUQKmb/Le+p5Q0poIZxonDYkRafs2xs7CzulAfZYWL117JJ6QAEw2nVSFQt0my2prkerKulvywTFqFauy82MfNtlXqWxfFShmhZiQCRRB20gdSkJl43hGweX+N7lZ3n5938T88nnhD/6Cd29mxhjWB4ecfLgHqe3PgMTqZoKY4RtuyHmHvWap9HCwsoZjhYVq/MVZ+2G2XzG/U3LTb+m7yPX5ktePbpO3Ski6ZwtJ9s1zWzO8WxO6rRIsbE1c7Ng3rR0p/d5sG453XTMreXSwZLjmeWxoyPY9NzZbugQ7q22zKqaWaMKFjQWXVUO5yzbbUtMiXo5x9U13dlKa3aMYG2FtY0CGkT5qGIoUEkzECQWxuqUF71xllkzIyRRTw5wlT5DSpHKuiH8ODUkQCj9MRxG59QYolWrUpwCBZyAj167ZWZKnNh5Ugj40GONhh9SiLT9lq79kur4EqZvCX3Dc9evkLolp6sTDk3D8onHudNtWT24T9v2vPT4s1xdHlFjiZ3nvF3DfE7z5BOwWPDxe+9xZzbHR8A4kvhcT6KFbyEXKztnuXLpKm+99V1+63d+nyefeVbbVqAe3FNPPcnr332LLz7+kPOzB6R+NBCnCmDICZbQVd6tQkk2FxtTBi+mIMAuEj77gn+QEdkaj/k6Rhh4rab7digwNSOlzBDuukAGTQ/JBkoJCRGygZJyvmQSwhqY09OY8xiYBi7yivLfkivRSwimqrLiGPOyaVRXFG43Ycj8Toz1tPO7i5/nYSW0j5bb/+4Q5oIMbhnZAyQzH8QcukuC5v1i4VFheL6v6rp8dbTY3oNfFPqaHgNygTjUjkxScxqeyBaLemH5ibJVZJ0dizOloF8iy6Xh2eeuczBvAMevPvgMf+ax1tK27ZBLedS9lfsOuZFXWbjFGyvWhnOOLvcnkbwJ2s1mcE+NNUMSswQIYtT4pEQNyzRW8zbiN8x9pOmFA1txPcCLjz/Gi5eucnT5mCefeIxLVcOlS9eQV54l/uIjzv/Zj1nHHjk8wNSGs/t3Wd3+koBS3Hu/HfM7xpCipW23VJXJllDk0nzGabvli9Up56sTfIzUwJEY5kY4PDyg7iM+9GDhfLPi7ul9tvOWZbOgntVUCDYlTO14rOu5uVqxtY5T38OmpyGxdMLVRY2Ejjttx2lI2HPLU5eWzGYN2/VIzb9YzPF9y2y5xALtZoMRoapmGjKUHI4UhbyKcTgztUqHrTiuSxEk92FBhFRVdCny4OyMuVgWdZONl2xhl1qMDPl1TuHsyQlSKXrGRUudakIy2MUhdj7HLRaERki37+CSx9Q1MSa870jBQzaifO/pu5a+b1mmxJ3TFavFgoWxXL50lapacGe14vT0lKVYXn35ZY5sxemt2xwfHROsobl8iKtqbL1gc++En5/e4/zoKpJ6RbHl0KqIWqHOwqyueP277/B3/u7f49kXX6KZL4Z9GGPAYDAu8errb/Crn/+SP/sP/xbjbCZajEMEgsKELDLUssBotBWlUv7bR0nu/92XH/qPiYcEmDS2ZS4W+vDrlLJoSDkJn0M3A3XNbk6kXK94NCpQs4tXipqLMTkRnEUBDH5XKoWPj1YsF8mXIfQ3Sc4Ppni+rtbLmbwWzS4SskRYLvDEpq8f5eXsv7+jXGJRouQIQA6JkSgtFcTkMKmebIysFWW7l+t51PGVlUtBdhXNeJGVsx8Okxy7HpQMmQbcjDG8PASa/4gRJxlPnRd6ytaYWq0J62o+/NUX2WV3+KCWW/SB+WyGcY7tdjsM8oWLQsgoEQ2bSN5ECBm1VvpeRIL3OFvhrNZHeB8yRxYELWAnRa1BwTlEEjPfcRQSz8wP+cbhFV67+hhPXX+c5viAhRMW68Ds0gHu/Jy4bmGtFbHulet0P/uI9E//iHW/5ei5p+gj9CcnnNy/Tds+wDYV2+0GSEpxH7XaOAX9a0wNRvABbqxPeX+zoY2RpTieOb7E3Fm23ZY7q3M23ec83iw4rmc01jI7OGCbAvfacz45v08Sy5V6yeXZjOVixuVLh5z0HW0AI0ppvu4CtauoneXxS0fUbcenJ2c82KxYWnj86ICqVn6kruto6oqDxUxzbn1PJYbl/ACTe/JoKbLWP3kUrRcTNEaLJL0AKeLEaP1FJh40tcUH4X7XcfvsLo0YrswXem6fE5omU3wIWsNiKkyCWd5I1dVrXHv7b2CvXcIezDGzinSwIDUzTN3kldrS/ps/Y/Pjn5N8TwieutKOqhoitVRNw8w3WOeotltu3b7Hg01LXC5ZPzhj3W6g83zriee4upxz+9Ytbj04RWLg6PpVmsUcWzVsHBw9/xRffvYpn6eg7SQkh3PEYpLX3Io1vPzyt/nt3/nbvPHW96iXhwSUpbz0/BjRdvD4Y4/zzvd/wMefvM/dW7eUUdeibBIiGjUgMbYLBm1ypXtpLOQzYyHwnizYlQPykHAsVrBo8msM00y3a/YYCnQ3FY6vrCcsMoTB9xXLEMYpRmMqYdDxKOhRs4dMQyYKZ+85ipG8rywvEu7TcSnPUz63zpFI+N5PvJpRWe4jS6f/LpGgfYU+5ooYPLthrNM4ngWhGjQWltmjsyw0qMHRa93flEdszAdd7CHuH1/bcymtRuUCV3HqMRgjWaGMsNqkqlLdNmHU7PlzI8JsPkdiot22GiIzQtM0tNsWHxOnZxucqSeTqtAGI0Lo/UMQ4HJMkVtJQ5wUxEZKJSWpSieEkOkSBCsWk4N3PuO9nakVcIB2Qox9yzJFng0137l8ndeff56XnnyKx44vUzuLabfYNuHPV5gv7mEPGkJsYbXF3XxAvHqJ+Nsv0//k55iPPiccz7h8+BKpAv/FLe7f+oLV+X1i7DHbQD2rMwOrp+taDT0laBZzgkt8cXbGR6dnbELgSlPz8mxGu9E+DE3VILHiqJ5zHnput2uc0V70EgPWwHFTY43h1nbDB6v71FvH0XnFceNwM8GutohxnPk12BobhSfcEuk7npgp5fuNs3NubzeIEx47PiScn7PpWrquZV5pQ7Da1ro+gidk3irJiESbabS3XcvtzRlPXb6OzXDiRhy9CFWjOby71vHh6Sl3+y0zH3j58DJPHR7SINgIpsr1GymC1QJV5yNt1C6hl+sZjy8O+cWtz3gnvU28cQNSpF1tYKuhL/oezrecG0+3XsN6q8LOB9agdBtWCFGbc/kIdT3H2IorznHf99xdrXAh8tj8gEvXl9y8dYMPPnwf+p5nrl3jmaefoTlYYlzDpvcsvv865s2XOf0//2vOcXQmUFGRnKHKEOjHnniC3/6d3+N7P/xtLl29NsTUSYUheawpSWjiWgS++a3f4Nuvvskf3f+XtH2fk+MWkwSfSpg4kqvm1LjLEP1CqV/4wjAMwJyprNiXDVMZESdi3pawlGTFXwRkyqG2obUHQ2ipAABIaSiI3rfYi5U9UDPl+y6M49baCWpsNJZLfCVNzlV+Zy5QMBfJmimTtF6Ane+G3isqLX9UvEOYeoG7tSWjbDVD9OXhI4+h5G6e2TEpDuFUPhpbokel/xbYWou2Q69CsrDVT3NO+ymRRx1fvROl7yfaNAvoPa9gaqFITsiWSQ4pjVDRHGss0ORC422MxW87RY65HFtNwmbTDklaybFz0OsXOpGs7dTK2VFyE2qLfUXIqHQ0j+SHz6tkwYkSzWlcIcdmPb7tmTvHJSLPphlvXH+RN558mmeffZoryyW29cT7p9j3P4NuQ1qtkMUcJ4Hu9BT37DeRS4dwd0VYVMgPXyW99xHrf/9Tlt/6Bud37rL6/DbtgxNku+HBgxv0ocNWWgRWcjx93ytKLcF5DHx8do9NrhF5ZrHguKk4dBo9WIlwstlwHnpwFbUIx/WMs3bD7c2KJy9fwaVICj0pBBbW8nQz424K3GtbvDFsYyBa4fBoTugDyczw3nPab7FrOLQVzkSuHS1Ytxs2STg5X7NsKh3frkMJTXPLhV5J+WpXZUEIJG0qFY0jmZoPujv4KvGEE1zniUborGEd4L1ty89S5GZIXJHIb196jBcay6zvMecr7aOYjaGYonJflbm2FheVUaFGmInl3r27rP7tH+MkYqOlNISVPrIl4I1A8gpRN1abMdUNkNsy5IS6yeSCrlYj4Jm+JvZbbDOjNo717Zv8xXs/ZxM9lw+PeeapZ3jyymVN8obIantOfOY6V975Lm0fuP/Rpzw4aLQHUN9BEOYHR7zzzt/iR7/z+zz94gtDQZ7JZr2RC7yFsg9i4vjoMu9874d89Kv3+PTTDxT2GkUBKVnoFBch29MooWTOVxZG3hJfgR1helFEY3oP5TuPkh9ATvQr5LZAliUmTGTIjZXfPSrPM01wlz3vpp7KBV5WSLndBUWOMDQqK57T/u+nwjclhReHoEjJgoxl8jnpYSixglTKeXfHav8598euvK+4Pr3HJFrTg2gkoJRklMOYUv2ibBUphlxQLSh/WhrCoINyfUQe6KLjq3suOcteaFVK4emocceFMQr0sXoZUctfsscyuG5mHDBN+oNUiqQoVkSIQatLU4YviwyJN5vDVcVSmC6xaS3NtHAzTBbcMFApqoUqqBYXjQPPsNozT4QrseWJmHjj+CqvPfUMrzz3IlevXqO2Ftlu4ct78OEt0mqFXZ9DbZFLS2TriS9cIX7wOfPHrxOXl0jryPbkLu533yG99xnbX34IzvHlrz5g/ekNvPc0znD39DZdv8bUlbrvRv2ovuvouo6V7/hkfcbddsPMOp6czVk6R2MNB5UlZdDArBJsqnnQdrRd0AnMSLgT3xNO73NQN9SAyXQXwQpzHEtrOKngztExbdUo5BXDzDlqH0ibDavNluMUOK5qqiQsZgvmKSEp0q5X1Cga6GC50AZnumK0v8owT5MaiNrRRuHPJFEvlzw1n3Op3/JlCPxic86PjeFOXfGkT/yd+YzXbI1r15jTDSFZtj4M+HyDaPExkbpqcDFB11FVC0LUNgsFiu7cAuMMcdZg5wucq/GHMw6cI906pSNoHUntMLHDVfXAqKtwXvI6CmzaNT50GBO4lhK/+OUv2IbEojIcLee8fP0xrh5c4qBq8N2WRCC6SDNfEJ+4TpofIKfnfLFa0x46XOyxjeNb33mV3/rdv8drr7+Nreda35LJHkMIqoTSrrAf9nFZ8wIvvvQib77zfe7cuUm7Xim7sRaaDcAbsQV+WupYxr0dUhheawqkFFrLGPa6wNrdF8TlvennxdsAFe6R3BUxmYzMihc+30Ny64LPy708KumdH0Kr6TMSTMwobPeve5ECLaGtMURXniULbDPmhgtAamCm1rM+cnwu8hx2xq94bdnrgwL1Hs/nnGO2mHG+OiP6pEWfYunWHYjkssuEMVBVDmvdEIr7a/dcBgEgBS2VA125IlpKE688WD7fSEppQB8UTR1zyCkOHOFpWPDF80gUVoQyoTEn5UY8uxEh5phlzH1W0rBodaJS0uT7yCxQlBOkmPBJwQCSEk5ykWjKBXYpsghbnu+Ft688yTvfeomXnnqS49kMgyWsNsh7N4in9+nPTkjdFnwiJks1r7GV0qXIwhFv38aFLd22wv/pn7LpPRvjOPjwNqc//jGb0xWzTeLUnxHbnsNrl1mf3Gd9cg9TGeCIsP4R0nxMkPe5v1nx2epUlYpzfOvyNa7amvPtirN+S7OsaENPhVp5KQYaY1jWFbFt8QbmpsFGSz1v2LQtN9pzmhSpjSbUN5Xj/qUjbl465s5syYNmzpm6e7iI0tP0HY3vmQXP3MBB33EZw7Xa8NT6nNl2gw8Baw3NrEasKu/iF+gqgoIILBswJM955/lFEm4G+NXJA6re85lLnC9nPN8H/r6peHtZccV7xLdYHGl5GYzhuHKkTAWTQqSuKiKCN4buyiHNc09gnnmW6soxZr7A/h//D8gXXzD/X/xPqI6P1TCoHDQzrAORBOcbqtCR2o7w8eec/JN/iTt9ADHQbTZIUjJE77ekANHnWgeXOIk95/05T1x5gmuLA564dg16j/GBjV8hzuBmNWYxJ7iayjXQBtY3vuDLGEh2yUsvPM87v/O3ePvtH7K4/DgQCQQcYJJRfiyjhlmp1VLbb7TOjcltfoHZouGNN9/i/V/8jPff/SnavkCxQXYwunTvlZoiJUaWHPbW/GhMIwQZGCIS09qIadhJTzuGogeLfgdJSuYGy9GDlL2VQg4rsiPoH5Xr2VcghQlEx2H0HgYFITmikkWTNguUQaiWcdn3KKYeW7Hwd2n6GaHasqsgvPcXhhLL62lKYnqN4fsyeiSlxXVKSXvvWBk+17bWaUAXrtcrSGBtPl/U9aNGBEO/pLwIBm7Ev3bPRSkugjYKE6GWsYNdjGFUDAIx95NHRKtKgT7FgcAuGIUOUxRMGRxRzrLajD0fSEHhwlYyxT1qQYghJZ/zOhWusmOSSzWQEsAZjWOKUTeqVNOShIjeX0WC5BEaQmVp+g1Pdz1vXb7OD198kVeff4EDU2PXHenOCXJ2g9Cu2bYrQtthkhYw1fM5fddTiaVLgdh1bG7foT89R1LiyTdeIfpA13ac3r3HNgVu/+p9vO9Y1hUn3ZaexNHRMZvzU27e+gKfPI17gnT3/wLd9+jFc6/6L/hp/7+lsZZvXbnGEwcL+q7n9Oycdbvm6HhJ09R025YYE7Uo8m4btaPc3FnWAXxUCG0ddOHNxGqbBLH45SGfHy/56aUF9+aHuGquFCqiFk1sKlrfgW3Ymppz0Vh+tdB1MFv2vHPa8K07X7BsdS2YWpFJtsoIJVeMhREto4LMEVOiNQkC3Kos9yKkWcVTeP7e1vNby0OeE0v0rbbedlrJXwwJLS50WGvAZvqRxnH89qtU33gJMz9AVj3hbIucPEBaJTdMd+7Q371D6jtF/cVE/+CE7uyUdrumf3Aff+8BnJ0S19pvSIkRtcWsNTb33VCrv64d1XzGsqp46qnnlOk4JPz5mkSirhuquqJezIhWiM4RmoqDl18iXTti88c3SNcv8zt//+/z9m/9Ta4/83zWyP0gnCMMRpHkbRMpYcZxDw8CcIjrwFNPPctb7/yQm19+wun9E+2zJ4J1OSyVJU1MEe+z4Mo/NzlqUfIWQz4i/6a8nl67hCUDIfehGb0YJsrA5JBOCAGM0W6UcVSaZu/ZHlIiaZcJZPjcjDkoMWOr9DGCkYawYsGK7SgrdnMXY+Mueeg+dpRdiS9N5uJR+erxzYkALvc1AVaVryTGGr9pmUiJComo99H3YVI+QQZplNAiJKM9e5QJOWZ7QQl3fVK2+v3b+nXH12BFnvZYFkL2uEriqVB0TJlN9Vd6CGhBGqWCV7JSMuN5k2LKExFnc11LHCtlNYmei6EEkGJNRe2PkLJVJYIPMVcbJxoBnwRvtXjRJrWcrBWiREwXuBw8L5iKp92MV55/nu+9+hrXmhn23n3kl59DHzHHB6Rtx/bkFKJ24LNVQwyaUwp94OTkBFJktVoNhZYuwJVXv0FKwvr+A27fvQ1tT9y2CD0HB3NWJ6daRLhc0HZbvrz5OX3oiVbwqx+w7L6v05Uqmu4/5aXD/yfPHG8xMbBebTjbbti2HfPFnNlsTrfZ0uWY9SoGGue03UCMYC2N0X7ffQyYJMyNxRulg4yLIz5+/BJ/uTzk3nxONA2VsYSw1fBmCLk1go63IrryXEmFl57eWt49OOSZ9RHN+T0a60hB6JMntefYZKiMw2AUaly4vxJKR5EMlzB8B9j6jk1KfLtz/F59wItzodm0kDzeBsCSvPZ9F1HP2OXnTcFDDJl6JnHy0SeEtiV3qtHGWCGwWd3BR88H/5v/Eivgg+YYkzE5zCVEp76VzYojGLTvinHYOseqc6GjMWboMuq7QGwDYnqitdRNnWtoKkxTI5WjS1Gru5OhvnoJ99R1mM2YXX6a3/xf/s+59Mob2GqWievjjnVdjvTQK3noXZgK+shs5viNV9/gL3/255yd/CnGgQ9eQTsG6DXvOeQJ8lkHmzaV/CmqHNB6GLJXMwjVtJv/nNq++0n1cvsaudBmWrndXw4xpYcea5rfmYbd9s9bFM5AwTSx+qfnGhRUGq+5H7rb8UweEYK8yJu66O9+aG2QiVnJkjL9S5qAC6xlAE6b0vZgL4xWzjGpFSN7iWUe0uT+JRuJBTE73tK0AP2rqZevrFwCCbGWJhM87k9eHqF8GwxhKw01yuBOGmvpum6gflFK63ESlRpFe1M7I1rMmK8x8g8lYsykhtktVyrx3NBIDM6WhL7VDRkFF4RoEtGCdD1XN57XFof8rWde5luXr3D1xaeo5jPizTPCTz4grDf49ZZ1u0GaCr5MVFVN7z2t7zJbb8T3PX3XYww5wR4VkWQstnJIJWzun7B6/1O6dkNHIFnB0wGes7MNvus4Ojxm5Td8cvtLHqzPuOdbtW7jn/AWAUHZCpfNKYfHiZAi59s167Zl3W2pZxX1vOF8s8GkhLfC+balCz1NrLlaz6g6oQ6BPqm9Gw30unuxi5q7R8e8e3jER4slJ65BTIWNiS5scxX9bkIvwqQJnLCNPdYpTPW+qzg/uMRTJ1t8t0aqOdRabOhDzMJj7DMhxmjCNhn65JlZxz84usxv5U1wfbGg8T3Oa6zfJ4NEwYohiMFUShbo6XMbBwPGauFjDEim/nfVIocJtMYghYS0DxAfsMdz7ciXEq5yA9JGlZ560pIXuYglSuYqy8W2RiyIxTiHqypCDnnUOf5unQJSrHXgKpIRzeE4g7UOL4bq0jFmtqDzcOmtt7n+zLP0GDy5fXimr3lUKIVBPo/Fwjv7tLxGw6XXH7vO2+/8Fl9++gkP7t7EJPX6UwpKZph7hUzbeO8IwqzHJA/MYPyVfElmap7NZjjnODs7G0JtGtIeKeoHgZ1GKqgUSx1G9oz2ZNN+aOyinMijxgB2EVRS/DqR7CHJYCCXe9r3MoYq/L1zX5SLmd7Po4AOu7yLZE9x5F6cnjumTJ8jZoQTy1guUlIDIXehLOwopf0BiZ0WAvoMBbDF5IpjTu2vPSym9BugHkwiRY2Plxsql+u9pw9Bhapxg7tu0sQlTdmFzzzqKaowBpDcgCqliImJQ7fEAyvf5vhg7tKWPCUJbF2BG8Zc3JjdRKOx4+QjvaKama83PGMtf/PwKr/z1Es899ILuPsrTv/y53Qf3eDu6Ql+rcR+iEHmM6VBuHtGcYpTioTQZ7p1VYQ2JfpsTahVY4cwT4wBf+MGPRGPJ3qPCYnoex70LRvvubk5Y3X/c7a+Z+t7nAjLqqIylqfmd0jtfwntfx/sHdLB/45Ne8K6bznfaiLWVoKrDVu/1Q0tsOk62tgj1rANkTvthsOqoa5qYt+Dj5gI0Vo2R3PePzrk3ePL3GuW9JJISXA+EtBFHGLMPYjGMMjA7VW6kCLEaElYIpH71tEsFvjznu6sY36poarngKeyuao5TSCX2VIzESR5jkzg2DrwCbM9U6J9cXhRnjCHEESyB6znq+sZRRjZWvNpmAowVCFhnaXPdDOIIJJ4xTzOv/rsQz73Hd+YX9W1ai1Yq2tKDJXLHFbWYbORFENQWpIYCL0i91L2olNQC34QIUb7AxWPKNtpaqVbq15PXVFdv0IyNdZY/EFDKJxfJIi582rReNNj4qjs+ywXCYSMLaOxie9861Xe//ab/Om/+/+CSSjTg4xlAmbMiQ1RtZg0DJjUC8oNGof7GlChRsMs2+12CNOY/Lt9upJpuKfQwhjJ3RwTA5NH8T72j6nC3f/3NFdxUW5kpzg854yMMSyahs1mg7E2K8JdgVyu8VcBDB4Jrpj8fqq8JCu2wXaP47WG8FceT3IhLFlh73tepb10SMUlVMViB+dy9z6KZ2aNJcQwNCKTC57jUcfX6OdSXCmlLlGPPw4beqiAjoGYIXikNJJTIqQQCbHPFfHQC1Qp4cSwST21j1w9nvPcMy/xzFNP8tqrr/Kdb7/Oarvio48+4L2fvct773/Exzdvcr5Z64ITIQS16KxE3nj9BU7u3ODmnTOeuvo4987X3D1fcdR6XsbxHz31Et8xM65uetoPPyF4z3bT027POTk5QSRR1ZZAj7iK1K3o235gJI0p4otLmRJaPJey625y3NtkEs1E10f6pAKoD56TbkWIgQ9O79PHwGm3JaTEzDqcCEfW8tz8gNo6FlYwNiJ4qP5PxIP/O17usPVnrFZbuhjwRulwjLVo079EGwN9DLQpqPVtDMlYTuuGO/UMjGHRRg66LVXoOZkd8rNLl3j3+Jg2d92ztZ7PC4SYxvjm0AiqwBKzV1neGxLz0Ca452YkV7GY1ay6FnfWMb+6UO6srsOkhGTesJiFfZI40PIohNgTBUxyWCNKw1ICJVnYiCmbyww8ZYqWcegNa8gVl1sMGKiaina7JcXE0eyAmBI9BpxTdFJQHjFvAslCj2BtjTOizcJchdTKg2asWoIhac4lxogNiY3vFQId+tyDYzDrhxwJxlDZhr6CdOkA9/xz2pWQRBILudPqzpa+wCPR02fDbTJlFx1D0hwN+Vy+dMBbb7/N57/6GZ9/+Qnea5vlZD0pWkiGNFD05xCZUciAMYaIUfRY5gqMMTGYn3leI/uhovH+p8S35eFSGgVfIe8oYZuLBPkO6/lUdk2EOMW4nQjgchTBHqIWkJYwU0m4q+DNSj5Nvj/00BnPZ63dqUMpSmxfIU69oH2Yb0xpYINWtNfDYa/S9jiGSGXsTn3NjqJO2mencL8UcV3WojEG78PguWnbekWNxjCicId9+hWOrwFFLq5axojHAiMOOTaoC9U5h1inqJV8S8MCI/f2tiYPTCL6hMGwAH7nnTf4H/9P/0c8+dhjLJcLkoDtLVI9xhuvf4P4j/4hJ3cf8JM//wv+8T/+p/zkF++x7re4uOYxHNYHnlht+R/8J/8d7n7wLjf/4H02p55mfsx33ILXv/ca8/M1p//h56y6jth33NysqG3F+cmphiuaSq01a+i2G2Lw2muBRPSeUthUXP4SChiADRnODIk+BDZ9x6pv+fj0PiFF7mxXAMyssko/f3CJmXPMrQWvY2md5iJS8kQfsZUhSGITPmLbezZ9Ry8RcUpWiCSCUWp1HwJbmzC2RuyMc+c4W1TcrOfcThVnsyP6ak6TOh4LHTYEblaOe82CVFqaOqOWZfAaDpWcdLdFMKaBiRZg2mZAmaLHJnH3reF0PuMJv2E2A79pOX9wzvJwQW2NhpkKDVCmCdLRI1uoNsffBTCEqPcy2ObZ9Y8xZGsrE1lOWCSMKRkWDVuJOExliKaibiwSEq5TEEpVVSznh/gIKQWSiUjbQt+z3W6JacOGqPkWHBYU0FFZYg2SDJWbgVFyQlM5rGlI0alxgiWlUpVdDLRIBwR3wOKt10hPPoYEMAF8YzNCSnI+cxidiy3IPD+D4vp1lnT+WxCV3/yNb/KtN97m5t0vSaHV0GXmJStWsxitA1ErVtdDyvtbhinJVeapzGeOZeXv7rMXx1yop/soE7Ckh+tkpiGZacL+oUQ4u6Gn6TiVmpMROGBA2BXagx7Sf3g/FmdLpsvfP+c4/PrZ4eEhp6eng+LZD5E9yrO66BkkjjUq5QyDkipehkyeL40UXQUVB2CzciSvjZL7RgpsOuQrlKsk3QNkZO7wDH/NykVvPCcty4OrRCA7JjmhqpsqDO7YiJM3zg6WQ+m5EUUIvuela0f8R3/jLdoPP+b9d9/jqaef4uj4WP0267DzJW5xwJXLR/zo93+P1958h7/8f/83fPZP/hXHEvnmt77B4XzG5WvXqO+ukSu/Qfvf+wGsWs7+239H9/4Nmlu3OX33U7a+J6QOLwEXYHVyQgiJ+XKhoYvgiT7Qbs7VEksx1w4kIA4TZE1FSuqRlHBBHwO3NyvubVac9x33tmuMCE4UmfbN46sY4EozR7LVF1Jg6zuCJIwz2iaVgJGIWGHrO/qU2MSeLkYkBkylLQySU+EYEmwNbKuadllzr55zt15wxx3woJrTSk3rPaa2OJNYM+NBnNNXCmGtWk/M2OBKxuSgFC86W5Y7cW1TGi9NrLhsXVmrm/5egi/mMx7fzlgsDed9T+w92/Mtdt5QOTOs9lIEaEob3cEKK/GWgNpvWuujvV0MIWqTJWstk2DxuIFLyMHZwSDqu4DxQfuviMnIJZg9cZ2D738X99h1Utuy+fFfYrYtzhraEIjbFt9uICr1S2sdq5g46+GzO1/y0mzGQeVJbZ8FlSjLM0I9m+XwF/iuw9Q1xlW0nYfHD1i+813ku6+QTtbES1dAhN7mPZRUcf/abV3CJ+SkrL4YjjT5zlQgl38vFkteffsHvPuLn/DJBz8HMaSg41dQmkOXVGSUQ1JC2iWkw8MCtVwvpYEQckeYZgGfCsHko6zj0aLbbSg2CSkNpywe4o63NK6PwfOd/C0C2TmnueE9T2FfQcBejiT/PT09fYgmq3y+DwyYhuumh0DuGlumTdXL9Hn3730f0JDy52PjMgYYd1FW0Y9lI2o3p8FDVQ9Xv1320n53zUcdX4MVWTd6VVXMZjPOz88n2lyhpeOCyKivPF4R5a6xuQAqBI3hxRSxznBQG77/2re5d+8uZ6cPmFWOk9NTLl2+zPHxkjr39lgcHrK4dBl3dIUDG/jNN36D9OV95BefYL/xIv2XX9D/5Oecti3bs3M8hs0vP6K/fYNYG1Z/ulL6k2SUt8pYYtfTpw6pKjq/JXptK6s5nYAVly23pEIs9xaJMeJjwEfPuW+5tdnQxcCN89NhzA6qmheOjmis5dpsnifQknKyNKZI10PA4wl4KQg6bXylHTE119EGn4k8lUfLGkMUy0oqTmZw/6DhdrPgpDpg4+asjLC2CSNO975RT0dIBMnWjFGalRQ93uWmapOFPjAOixBzuEMX8CTUEJQpoHYud4VkjM2S2IrhY4E3moYqtBweLjm9f4LpHedhS11blvOalD0OwtimWmVX0vomFIVUWLYTep/OoMonarssMZog3oGgSmbyTgmSR5Ii3nqBWTNTjrP8zGfvvse9G/fxVUXIz2GdpZrNsE1DU8+pjg94QOD903t8ECJ/7k+4YSuaS3P+Z48/zUEAs+lUWSYdh3XbI3Wtm9bl3MpiiV0ukFlN/Q9+yPLFF0gf30ZmS5hbpDLUXUCqqA3xHmHZQlEcMqifElKaei4pJ2p3k92FOlaNheeffYa33vlNbt/8nPX5OWCIRJKU2UgT+KowUPIP452vOyGVLGviUeGosqYS5RxjYnoqtBMTwXiBsC/nuoiKfrzOKJgFHa+pEirnHIqyJ2GuRxUPXuQlTZmJf53iu+gYrlXuK+V5Mo/+zf79lLzMlJR3uH6a+CcClB435V0hl3FkW614rVlJfbW7+DposQxPDEHhtinFoftiIXssCi0W64XJQ1i1UMvirioNPzXJ8w9/9AP+xuvf4fBgTt9tsAjdtmWzPsd7LU6r65rZ+gGX/Bnmkw+oPj7ly//mDwl/+FMuffM5rpyvuPP/+hfc6861NwSGePJA8fRzS+U97factt/gmoba1Nq3pPf4vsdatYBFwCdP33U6uLkhUUqKykgCd9ZrzruOB+2au+0GUPaBa/M5Ty4PuDJrOKxcnseYu292pKT1PhqzjfTRk8TQ4wnK808ApWBJECXiUxYsVSYJNJa1m3HW1NycNXxZN5xKw7aesRbR/AUCBqqoCzMYCEEQtMI/xAAhEq2QrNH3RZAwLqwQc7vcYcPoYk0xDnUOA+uByRXhOVYt2cq1xoCz3DVbfNMgq0RdOZaHB6xOWw4ODjnfrMD3LK8cg7UDa20p9JMMoEjFY6S8b3VT6I0MFEKWMe5cVVUOmeXd4QOxStSXjqiSpVouOHjsCmIF57fw/p/hnnoCs7yKazusMxB6+uhp6VmtAx/cvcnP2xXvxsCdesb5bElbNyQczxjPfLZgmUTrggTNhznLIQZbVfTtBrtotH2xE2LytKdb+IuPMA86Zl6Ir14hth1YR90K1RLawXrUp9+37qdWOGXflZBtHschDPYI/0di5KBxvPHmW7z7i5/w3k9/nA2MPKa5x1EhuCwhsDTJBYzF1VmmiQxXLNYy7AryXes+/5d271JkgBNc6G1cFBobxmLyfedcLl0ID4fDGBVQ13VjGC49XJV+kQdz0Xlg9Gz2FWJ5HeLIHH9ReIxJuHjfE5q+V3gfyeHF6T1b53ZCaUVZM/Fq9L1Mx0XOdyqXdjYr0ijUv8Lx1YsooybxRzZOk9f2zhIY/r+EVZKMC6Mk7JxYHEIMHb/7/Tf4229+ixdeepZmOeeTjz/l9q1bQzVsGwRrhHW7ZdZv6dqW0199xuJPP8K/+xFzOrap5/P/9o9ZbU5psNp0LGy1YjkZZsZBYyBFvO9J1uBz75DgRysmRk8XPD4qi6+rLSH13NtsiCnxydkpbfC0eQyuzOZcns145mBJZSoqU0KE2gTIR1UkMUVlLBDoRZsD2aDKKhDpJZBiIIrHG+1QmaxFnAWpQSq2dcMDsdyvHffrhgd1xX3X0Jo5KWWvIxXceiSlvECGDZQy5YRSe/gUsThizN1Bo1r/0zYCKcMXizU6WsJ54xiBmLDOYUvhayyMDQJoLuSBMdwyliNXE31PPWvYrrTB2dGlY85u36ZLkavXrw6IHIUAT1iMJ5tOnydbzdmKKeH9ksiPWYAI4KxwcHSIN4m5q5GDA9y1a7iuR7oeTKI6W3E8X7KqhPnhIVvO6AUeYPhp8Pzpg9t8FBOfOk/nIiEarcR/cIa3hhiFK6tzzlzDrb7H9EEVpdiB06xY3CKCaxq6SohHC5avvUL9ynPUTz5B98lN6mZG1czonSH2mQl6RzSX7TZRGPvhmyG8NAWT7gn6iRc6dDlEePyJx3nz7e/zxacfc356D8HgxOFTr3DkXJynZ9qlUinRMmRXAU7l5UVhnGKGCrthpumcX9RpcicBPkF77X8+eC0Tj2J6XPSeXPD5cJ7hoXaFc8mxXHRclBdShmsZvE4jgo9xKIq8KA8zDaXte12aB0tTuwNrLbOmoeu6nZbKQ2PFnOC3riJGryhHo/nJ6BW4JNbQzBuN2HSer3J8Lcr9kkArHstUM16E1Bg0akkAppJQU76wy/Oa568fc/Pzj7l581NcU0Oq2Kw3GamAJpGBpqpZLhbcu3dG+Pwm9SdfcNAFojWcvPchxlaICYgzitppO4SIqSqwucDTR6rKkqJXuKvR+0hA17aE5NmGnpO+pQuez+6fkVJi1asVc1hV1Mbw9GLJQV2zdBViUqbuhpi8FislLaqMWaj4FOmSJwRVtp5AlEgnZG4WcHWDdxVra+mrmvOq4oFxrK1lVTVsjWMVYFPVtJXVUFAAh9PancwtlSRRIh1TZSCT1Va8DV2kUApZKdZmGuGiZeOnNCbuJyYwIUbN0ZSwRfkoJS3gSrCWml8Zz7PzGYvTlqqyHBwuOD09x6Qlh8fHnD54wN0vbnF0+ZimrpUCPhdxxTQ9s96A3rthtObzdWNUmG9ee85ZvO9Zr9ZcfeIJ/HbL9rNbVF2POzpgfec+B9cuc3R8xHNPPsnPf/4z3vzWkjhr+Bef/op/7gwfuJq2nmEDNNLzVNvxrAivXrrGL1cP+Kf3v0RMxSv1jMshYWPStgy1paqaIskznYkaIH1d465d5dp/9+9QX70CyyPEq3coxuC9x0ShkxovZuD0+//nyHb7kIO50IMRMmJLUXCvv/YmH/zyXX78J3+I+ICPOd+VdsNOFwm7Ut2tXuNuTchD+Y/pfT4UKtv93vTzi5BX0+T+mEOQh84xfX/KMLz/W5NlVrlKMVgwygiRRBVLzAr8Qq+DXcU0fb7p5ymhShuGkOD0TPue2f5zDO/vYATTgFrbbDYXK7eUi5elyHDh8PAS56sVXZ+b44n6vW3b6Zh9xcDY16LcL+RqF7l5F8U39cM48N2YpEWT2ERMPVevXMZZx9m2ow+Jqu6ojRI0xuz5aFvTRNf2rNdbEuDWG0z0hL4lJu1x0YctTbK0dIiPmcVZFBrdp9ypsVe+r6hx95gCa9/Tec+d7YobqxP6FDjvOwzCQV0jAq9duY4hMa9USfVB6dU9PiOAUk56R0LUAsUoqkh6Ij4FIglPJKCFnGIMVBV9XbGezbhnK+6I4349Z2NndMbRYgnGKfWCUar4mL0FkUzDYjI6rTRBSpBx4tkiKpbpOC9DqwPGugFdNZL51xJTWTYooTzXxYtQ77J02RtjuMLuuuirik/xrHzDwlb43jObV/iu4ez+CceXjzk8OmZ9fsb5gzM4PqButBd5KqGSyWbSe8jccUVEpslz5ZBYimpJVnVF37acnNzn0nPP4JsKf3ZO17YsnnqM4CNp0xG6HgF8JTTO0TrLHSfUleGFEBRxePwEL7iayylgXOCf3P6SP3Q1G+d4bnbIom70HnPnKy+JWTUnm+RYZ4kGTNNw9YffxTxxHdqEdIF0tlJmihAxIWKwdPMKk3McXzEaoXNWZkFKuEN/X0oc8pCN87TzXuLq9Wu8+c73+eTDD7n15eeI5L5Jk/a98QIvYLSk9TzGjN5R2p/D/Xu+QIbsC9RpshpyH/jBUHq4Sn/624vk1P55izdRhql8e6pAk5aXKDikEHk+5Fnvnnv6PDv3UfaWyQCdLOxl7zwXjcmjGIpLpMKYh7tSPqpLJfl5fAqcrVcEnxUL2SwpkdD48Dw96vgaOZcCN90dsL/KxZQBTZaRRREcnqcOD/gbr34H5wSTKpJJQ1+HWCbYCCn4XJmvVlBlKypXsQ0dNrQYbwlWaHLRo0uB1vds3QwjhqZfEX2EFHC1ZRt72r7js/NT1kHrTNZe61ga45g7xwuHl7FGuDxr6PsOSaJ9U4K2lvUpkELIybIipDUmHVLU5HxKub+bhqCSGGLtaGc166bitGp4YGfccQseVJaVsbRYkphMgF3c3JDdXCGhePdhfES02FC0KrooZONyCrzIZUYupsEyG+ZnTAJnjzp7DIKtMvWGKT1CdudXEK35SApl9SEM1drDWsiIsgcSaG2FcQ1+s0KcY76Y4VsV8rODJeIc3ek5m5Mz3OGBeq1GMNZo+9V8A2IERIOKJURnTYXAUAFfDJoQIiKOelazfXDKZnafxeNXkaph9eAu/a27HD75GKc3H9CdrwF1JmsRXq0PEAfPHF/l5cUBV8ViUwSJdFtPlBrvA31T44LQmApfWVynSlqrbyG4Ul2tqDdPwj33ONU3niDdP8vfEwge5jVkz7QT4XxWkdKuIhg24kXH/naUhz+W6ddSGs5VDJYkCcHw8rde4ZXXX+POvVuk4Om7kHNdPMQs/nASXYbTwwUhq/xnijz6dd7KTvhn8JLG+pGLchAXWvYXWP/TsUkkcBYrhugzpJ7Ry6nrmtB7gveY3BzQGHno+hc9846Qz57RMECT5x3Lbkfj8NeNR0wl5DqebrwdUX49RvjyPrhgep6UlP6n1D9pfVFQUthiwPLVjq/luYwW7JiwEykPXVAnxbJEtXFxL8VgjRBi5LnHr/D7b7/Jk1evkFJktd4QfK81EimQfMyUMBEjI42Mum9RWyBj8Clh0xblzdTamt57/t3Vt/i/feM/wxnDf/re/5U3vvwD7mw23F1tuLE9w8eAM2qJXW0WPH94icNqzrX5kkSkC4Het/iuI0li6/WvRKVY6EIgSsJZrfT2KbK1CcFiTCRIwBuLNxWhqjizjpPZgvuu4r6tObOGla3pTIXkfIkK/Bza0hVFyW2R1DMqQAmsye0LdLwNJhcM5urhsmkKvQ4JWxKtZS7JFiVZcsnoAKVM/DhanGTFFDVGTIZB5hxNysleSbuLXkQyVUnkBMupEaQ2uM5ptX9TsTycsT3bEuqGqm6wB7A5uU+7aZkfLPGSiCnseEOQPYMMllCpYHPItRSu5bVnVFkeH1+hq9aEu/c571sWl46o5gvoPA9+9TFtt6WY7yYl4nbLK5ev8q2qUvrx8zUxRIIF11Q0roZmzvLSFQ6cIaQVy8UxdVUhlSf1GtuOJiHeExCquqHtt4RvPMvVv/WbuOoQnNAfLbBXrhBvnWaDwSDOEpzQ5W6ZAU2uTsTOQ/tz/0j5/6bivvSqF0ouRkajoXwpARI5WC55850f8OEv3+PGFx+DA/FamwQjUa2NoyU9zM8gvPLOFaFcOaWktDeJsZMlo7A3OX+37+WIiFIFmSHLsaNIpucYPHR2BfL0nOVaZex8RmTFqGwDuu8eRpQpeacQjWjNXmInojOdk4tCYsWLHO47e4SlhqbkXgpQQkSYNTPavlM6oWGuxj2dIWXaEl5vPe/1X79GRGSIVKQEMQnic9iRUpCrcncYu19bnjseX7vN8YDWMWnidscciZlCEkdBpotL+YsXJvG9bzzDlUVgs7pJiJYYwEQdzIBocjszHodMKzIsmGSpU6/Fjb4nRA8SFemFYe2W/O/f+i/45PBFAN5tHuc//+n3qcOGlODZg2MqMTy+OKSpKjZdq6it0HNnc4o1QoWlthYv4DNxZjLQop5LEosPnl4CbUpKA2MrVg2cO8eDZsl9t+RMGlrn2BqhNY6AEn4mUYSWiYZU2GFFsmIZk3Ep6YIxExikCozdhNxFVppkM0aCKpAQ45CDEZGBuJE0IrNiifmaQvehN1JgimXTx5iyMkk7dOEXxeATgk2GbVXznt/yzdmCeecRr8i8+eEhvk9sz1ccHx3BrMLJMeenpxhnaZYLRa8RVBDFiBBJSRtzlc5IMSfvETCiHGwhhMwG23N+fsbi+JhQdcTzDaFpmD//NHff+5Cw3gJx5OFSzhEdm7bNtTx5PFNNwoEovdHzh1d4wq9Y19dYNEccHh9j3JoYeoVFC4hElvWc6uCQB0SOf+/3kNdfwxvAe+z5Bj68hY2CXD/ES8RZGTqxpjjo/1977IdSdr6fBdHOexNjIGXrt9iFJGW9eOnFF3nz7Xe4d+82/fk5SXIEIxUjZRRgu9bwNCRVvjOGgsr3tVvirrBP2esfO0wyrD9jMvN0CDm3uGvwxhg1JJpGOPE05LXjAU2HYnrvKRF9yBD4hz0cYy3WCMmUQlIdq+m5QghDjqau6yGMGGOkmc+1MDuEQQFElPIIGAw4yroToc+54UEh5uLImDQ6QI5cQJq0jB7RufsyYuf5J2vLIGCzQSmjkrKMYbi/9n4u+xqZzONV3NP97w4Lbxp/t0LsI5999hlX6w19aInRQHJYW1M3M3Az1YwpUJqhaqwv4EMAn9j6DT2eWbYWfEq5yjvyy6OXuN9cHu5lu3yCxQu/zW+e/xKDFjOC1pD0vmfbt2yjpxN9rWiDhKsrtcqMQURx9z5Bh2HrhK5p8EY4m8+5YSz+sWvcjoazzuONJYglJEM0Ci8mqYWXbLY+kwrJssEHqN+eCNkPOQzUC6KlBE6ymniEdSZFoGTjYESIMMRIiiWkrroZwiOF721QLjmBbjL0uFhX+7m3/Y0dE2AcH1jhpnW8MK+RlQcCQSzzowXbkxXtZkM9r6lmM5YIq7MTMMJsuaAvXE9ZAkYfhvUlCDH1WnSaN521DkFRe9YI2/UajOX600/hktAaOL95B+kD1axBKgMZqDI/ukwlFmftMDbWZfYCY4gp0NQ1wTlevHyNxz+9xy+bGZ/7NengaWZUxNBhjNbTmJTwKdCf3qfebEn/6g9o/+RnsO2oo8CbryBvvEw/c7hVh52XNQISx1DHX6Vd0t6/p18vCmPfmp2us4R6M8O8xchyPuc7b77JL9/9Be/97KdaaBuzkCvXnMZjLrzRKSIsz18qRbAXC30ZtJwKTxGNeszmc5bzBWcPTnQPmSKb0uBVwG5Ian9P7NzZZN8Io0Iz+T81VnY9kuGZJy5C2j9X/s85t2NsdV2nnHVZK6eMr7ZitBSgeGMwKK4QlM5JJuMzIMVKOIvs+aRJNGHU6g8980VhRFJB5DEYo2Z4Fn3yosC+yvG1ci7TNsejY51omoa+6/ExYK3DWSWwVMoYGFaJD/TVjJ9+cZ8rB5bLM8GYKlebRzw9wWtfeiNCCkoIWASIFUNIntYl1k1i5rRXiQQhJGVJ/taDv+S7t/+Yf/3U7wPwvTt/xN9qPyYaQx88PrvW29jRxUBLoJdAkIiRSBQNcQU6Oizruuasqlk7x6aq2dqKbVWzEcPWRjZAxJF6tZZwC82vhERhd7Zo06NkwsDiS8rtVIfNVIT8BEJqlLZ9pF0YrVMVqHlRDQskDpYNk5kqAkVMbgmdSogxv1+oNxivUc4ZwqQ3BNrBDhH6vqOEO5xT7wAugoMmooM6COd1zZeh59mqwZo1KXYkIsY5Dq8d8+D2A0xviYCrK46PLrHZrNhEmC+XxOgHFlhi7oKYPWdBa7Ek5nWZtB10iclXdUVsV9z9/HMuPfcs/bZnc+OGrjFnMdFxpZ7zcUrcOb3L1WZByMhGY0xmNzYQlDWhJUFdUS8WXPWekODTs9us7l/Bbjtit0WiUmdUCaLv6ELAu4r4yw+wl64xe/Ul5HuvEZ5+nFTVuLOe2DjcrFEC1ASSWxFcVBS9LyijKSOeJuEwFQzF85GkM11g6/lEwznGBG9GQsXI4089xVvvfJ87Nz7n/tkDIiP6UNgln7zo/nZCQllp2Fx4fVF4ariXhIapJtq1bVu2bZsL+lKmxsnFtWpfD+fbT15P72FfmQ3fM1lB9Sp39vcTqOCNxQmDyf4bQ3PWWq2pSbuGX1VVg05C9HpGDKH3VJP2voVnj5ipXLK3UnJv5b4NDEzHOmA2Fz1mhCxjQedDaN5HzBGAKwo57RoGFxkmjzq+hudShJTkPi7kC2c4r9HKXd/3441KygWEKMW4UaqX+eGcJ5/+BlW/wgcPxhCt0vrju6H3Rgiert/S90r65yqn1qREtnM7COiYq7NJYHzP//qP/1f83Sd/hxgCf+POv6ULG0IMWqPiI+vU09Gr6y2R3kZCtPh5w7mbcVrPuTVr2C4WrKzjftfjjSG6TP9Pse5DnkQleSTpYhcJaNvZQranVlpMVj2jodK25DV01iSzHJTaIB+1NsYWyylbi7FsDHJIK1scxUoqXEjDIhIFAizmc9brdYYta0jLWqshz8lcawhIe90U+p4pZDOvCJKAM26XKiOfSBkA8iKLWn3vo+PLFAiuIllL8IKLgSSBkODw+IDtyZo6RZKz2Lpm7iyb1YbVg1NmTYVxDkyFsugHJBUepTTQv4gB71uF/YojBWjXLUEM27Nzzu/dQ5LV0K4wbKKnq5o/CYGff/Irvnt4TWmMQq8jnWPQlakgCamyuKbm9PyEu3dvk05v83K9oJrdZrXZUlkwcQtVxSYmbITwzDMc//aPkG+/iCxmaq3OjoEaPr9Fahxy/XFSEpIxGC/YlPAG0l5cbN/6TCgQIUrKmmT0g0cvRl8NHkfZ2Dv7PFBEZolQzGcLXnntTd599yec/PhPSGGUBSXHNQrXUgNXmk3lltbT2ovEQPeua0ayQMx51jyPVkxOKKchaT0ozWwxFeWPKLN6EvVanXNsu069m2xhaVazhHwZwm9D2IhE5WrEWbrc4dZgdrzwgsC0wNCOQR6GDbtctDj1AgutTMrPk4wqm/l8zsm9B8Nvy94dvKi8R+uqYrNe53vIvk0yg6EYUP6w0i5ZIz46bjbXq6XS9CgfJZ89XU8pJpxVtKbvO8SWmqWvDkOGr6FcnLNakFcmiGxlp5RrO1QLS14kQ6KohMjyQmyIvP4b3+RgcYR0lhBaIpGu32hVfOzxfU8IfbbAYoYd97TbQJ8szOZs5kI7M7iVJrn64MnhSVzY8qOP/x+ZKdizDj3b6DmLHR2RkALJWVor3K0WfD475MGspm0cG1NxbhzGzbSCP0QiFSUBXhwx9TSUjCsEtWRsDlKmxIDv7/s+WysyeCMpjZbeRTHM4oYXWu+Cwbdul2l1VOI6+T6TNybZRYRo21ltYJZvn5hy29Ly3exWp6D8YAogyISkeWNL3mgqonQ82tjT9jpXpfVt9F67Q2LJKFoNQ8bIgxQRoyEnbQmtIc2UEq5qWBzOWZ2c05g5ofM461gsD+m3G7zvtXbGGJw1VFYLZk1mEC7joOOcidKSbk4BhfhafV9zNyW8p8IphSyCjaFZLlXAJa3yN0Y3eLA6gi4Z7oeW//qTj/hJ2PC9+ojfvfYUod3Q2JpAwFc1the2dUQWFQd1hd1uMesODq+SmgXChvDz96lvbZDfep3YA3XMewggDnDXvyoaMYTSYKiLkbw+ym/382PTtaQCdxQeMa+d6AOPXX+cN9/6Pp99+jF3v7yJc7kWx7qRMZ0wGEuFMb0YvakoErI+m9DDlFYcPuTcY0pD3qFELGKuYi9ypZynNAQsuV1QS73v+8H7QlTppjzvg5bOzzwWHwuh60ldP6DYYjYSkYx2zYYghe5q4qVPPQPv/Q6h6/TvSC6Z6FvtBbUfvis5k6IIYgj0k3PEPL5RVHlatGfW0Lo5n7/siTi5bRn2SdrpD1PuUdGhmfjSCiVIl0h5HL/a8bWIK8kTEPPNlKS9mfTysDlmp6Ebx8glGJEUeeLKIa889ySSIb7Be9p2Td9t6H2r1OnBqwA2BSEl2KpCXb7EOm5JB3Br1nP0YIUPSmtfFnXKVooY6FJiK9oQKxihnc84t4Y7bs5nBwvuz+a01tEGTdTbqGyuMUpmd44ggZTRU6VxT8obQ62L3Ft74haPE2VyYs/nGgE7LBAYQwr7IY5pPLUoTcj9GGDnHNOEXSpUKExqUyj5FBleJ8BkOn5fwnODC6+oE5MhjCF4UtCwkORYWoLBiisIoQiaG+t7DELlElSOaEBSpEe4mSI3g/BSU+N8og2BCm2U1fqO2lqOLl3i5ORMG7OFHldVuKaBaEkpEEIkdD3RKmqvJHCBgftNhv4uOSEOYBwYizVaeCpWr1vXdbbSWhCoZg3V4VI3U1JLXBC6voeuxxPpAtwIG/5i0eCuXuO7h4dcuv4k9vQ+tpnTxMg2dPTPP8Pld14jtj3L1GCffwKefILkHGF1n/TpTSoT8U8cYaua4AxV9Ihx2Rr96pt5WA9FwXyN34zrL6+RIoCyELXW8u3vvM677/6Ck3t38Vkghlz3Qbb8R4LXck41RWUIo++GVkq+McTcL6QI9awlDSo4DaKEByKDwqJY5iI7eZEYQw47jes9ioYN1aEea0nKfQ7KNaahsWFMCg4I2RuIKUKctHUuCe508QwZY+j7fig832EeSNpZUkO8aQjBTedjfw7jlMI/Nwcjs4sUDaJeXRqfe1LYSt6vWXoNOZmSZ9tF143KfzB0BMTaAQD0Vx1fg/7FazjGlBBKEaYlUp83M8UC0ictMXuFrsKVgxlNPCd1a9brNb3vSMlD1A6OMSSsWMRa+ugz/UhSyzIqJC4Quec6toeey/e2VOvcyS4mtKC/IkSPJ7E1hljXnMwaPlkccKM54MQ6Ns7gM2V63cAygccStlpXIwmC18ZSyVmF/mZURgiRkIW4eiiQwhRRxw6TQcoCyjnJFt0uRLFU0U6rhJUqOytJGZPk5Tc7YZFioVEM1AvAgs4QGSuRlRK+ynObK6pRqyXlhG0mQtZC+wTGRGxmeBrDCeOVCnWFs1onYIxVmHQ+ZxThlqv4ifc8UdUsrMcE5UtzVUUyhrDRpnDHx0c8eHCi1wsJ11RZcEFd5fsOASEz9abMBGFGFojce5eyJ62VjHTzeZ2q9+Y75X3rojb7ajcbzu7do7IWGxh6iRhjoXI0xtEcH3I9HXP8+YbPDw44d5HFwWXtfyJOG4fND7nyox/QPPEsLOakWU1XC2a1Jv7Bn2PON5i/+SahD9T3V/iZoQqQnPZPiUlAlENNhp118TFlYBhiYbpYHvmb8r1piKyEfsp7EcE6IaXA8fER77z9fT791ft8+fknuRhaQ2eSjS4xGVabvZYYufCus+NCjIG6diyqhhgTbdfjfUSs2V3z+VnGduj6ubNGGbgRet8pfFZsttInYS/GaELxulMcQ0RF0EoxItPYSEzzlNp3KiZFb+LDzh4u1DTTHBJojnKKstrxTmDwwkqkfLrXp8jbabfLwvNWNzUhRYLP7Al5Povys2UCyJEGph5qvpcYhzEKIXDp0iX6vmOzKY3dcolE9qaslaGo9686vrrnkutCBqt1sHYpo6JuZUrZzigFeMWlj6TKsO56PvnkfWZ+jUhFEksUTxKoba3hJaPx/tRFrXrP0iEEj9+2bLsNG99yr2pZXRGeSIZq22N8YovBW0h2xnZxwBeN4bPlgjt1w5kIwdRIsqrErIbd2o2hOaqY1zPub840bFM5EG0MZqxVGi2m+HkVTqYwh6aRV2jaUwE0zBIzFUqhXYHRawk5R7Lfm0KthZHGvFiGMSp5pDY0UpxqSWqTvauUoS663hKVcerq5oRZmqD8yj3FEHLSMA0hI0RzPgiKdc8LuNTfpFysWKylyrohfFGeQTe05nlasXzmIm01Z77eUugIQ95AUlf0G4/fBq4cH3NyesZmu6FJEeME1zit+DBqzBT0nxFL6L3yePlIMmngRitK0GcQgBQmX4CUCBh6H9iGHlBsv41C53usdVRVzcFiiasqTDNTS7o2PIFwyQiyOWGziqzn97Bn94iVozs+4PgHb1N9+1sEN9Makbv34cfvIz/5CPfS48RvvwCzGeazz/GXFqQ6h5hQbRaM9vGRVLzNh73WXQhtiYDJ2BFyIgB3wmD5v0jxxsnMDrvRN8ngFASMFb75zZf59utvcufuTbrtNi84DR3ZoXI/ZRmRPeY930u9yMk6N5YQI01V03W9glgKrDYLbtn5tQzPFqMavkMtnIxCeHhQdXFydCGOXovI4BlOrzG0FY7aPbMwP5R7Cb0f6F6GkPaEJWA6P4+qtSnvDVGHiaIr37sIIKFhRA1jG+dyZ8wAaDOwlHLkIkf/CkS6oO/Uv8wJfrEZbRuHyNPJyYkymxQzNa+HkJFsKYZdQ+bXHF9duYgybqZsNWjr1UmPiTLnZALkjL+NeSOrnLR8cvsBDYar85aZJFwEpCEYYTFvqKoZ0TlQYA6+7/G+p21b+r7T/vX9hpBa3MJyOj8mLRPmZkeINQ+aiqdffYW/+OIGd2zDebIqVIwo9QoKAnC2KL+KlDyLgyVnJyuMNeoh5aKm3gcku5RJAD8uetIUprcbntoJfalW0fqRZB5SQqHkHCa/BwavTUkpoW4ajDGs1isGitiyCJNk6z33y85okRxypnGVEnIGRWgF78Ho4qqrCmsM27Adn2MgMpwQ6Il6ICEoDF05DE2uDymGhnZlJLvdkYLo0ftwGM4ksRUl5rS2om+3g2I1zuJmhvXJOcknjo6OWW22tNs1NlqCjxhnsJXNrMuaJIUK6xqclLYFpixJpBRb5l5IRe5CRCxUVc2yntGkgNz/lHpxwOWnnyUlVKHkcQwh0K/P2W639Cby39y+wR/ev413M773wrfp1isW8yX1wZyDZkn1zReJMwcffkL69+/BR3eIrz2H+c/+AfHxY6qVJ67OSLfuYGdPQQdUkJyus2hNDimS0V5/RaBr8nG64O0iMsZy57wzs/FSfiTTXwma0M0CcL6Y8fp33+bn7/6EGx9/hGQUaYyRGMZi2nIuK5OOoXv3pDLc0Lc9AaV4KhEZm9fbYKnDIOCHcwz/zglyxjEqUOmQxgkXJHvek3FKKTNZmGFtTC4wMZLGUbF771+056cGZGGL2FcW07kpCm56TPkaCwINcqI/JjabrSqknFBJSamoQn52mz0tyece5sDmsoJpeKMs8jTaJENYUwTJPZRSEoS/bs9FwhD+Kh6JtRZCoA8+xzJRlzXXJCRBCwZFsMZiMXRS8/PbLcdN5NohHJtAnbZYKzh3QMoCOKEJw65r2eTwWd93tH2HGI81CXENK3PAh3PD6TXB0xBF+MubZ3RpSQgKyytCWuskLJQCUEAk4aywWW/YbltitBgxdF03TGyBYZeJstbmGPBuiKsoi30CPRHJhUlK+V1VFdvtliH57uxOdfvUsjHGZASaTqnP95UYXepYWtuKZKSF5NwOkC2VzXaDEaPtmkU02pKv53tPkNykSzP5mZFEvTFDppBIpRdP9lrtrtteNkBVKVLGe5+rfLWviUmCN4lz3yuFvLE4G+k1PqCWrgiudjSLhvP7K7Ztz5Xr11geLtiuN7TbDaHTmLrH01s9vzUWSZr8FWvBaIjPGoMzVik6rBvyUcaYIT9gM8rukmt4+cpjnPmWvm2RTv+GGPC+117iKTBrHGfzhj9LAf/CS7zlDvnW00+wxCF9wMZId7ai/1d/Qrh7xuI8It9/GfnP/yH1pWOk7eGkxy9mGALpyhHm6GjIZZY6Em+V0igW5f1XbdGyFrPATFkxSXYjhjOYUcHk6PUECl/OpX9TEezlNfDciy/y5lvf496XXxLX59ljyMW1e/c67rOp5hs9quE7SUkxldJntPinOcl9j218PXrJ+wS6hUrJ5o6mqkun11ZDamjrax7mTdxvBravWKav9z3EnXnJRwhhJ4Rennd6zan8KO8NtS1ljkMJAWYFjhnCa3Ey3zsgAVD5MOnAWXI2Mpmn8VmGhygkAIpI/ArHV1cuMZMEpoCxDDkJpLTKLN9Tuo9iNYMKQU16hVxtPefepuGs7zmoA5dmWx5rLCKW1m/xfU/vvZJA+o6uU8WiVfiJytR4mXGybbi7Fe7FhaJWAC8BIZCckJInSsRm5NJgGaSMqCAn7Yxjs+6J0Q6BpLJAp6R4IsXimsQvH+EGawJwhE+q1ZyIub/6FBEytKTN1mH57PDoWL2UbE70fa9eT6E8TxHjNAeWJI+xUSUxnsfoxiVqe9psqY4KMK/VqN0j1XCM+RrlHsuGLN6WjlGMu8g1jdt6Bs8OBmqbiCp5ITGzjsbUmLgGo6E0UxYuga73uMpyfOWQ0wdn3Lr5BQeHB1rpLA2973OvCUgh1/qEnth3dEGtRFs5rHWEBF50M6my0TkewgJiqayl71vVy+s1H23OuIWiu0KGYRrnqOY1c3cIB3OqxZJltCwvLzErj28s/YMNsu3ZtFvWVUV13nL0e9/HfutlJRn94Ev4o/cwLiKPX8X9xvNwcAgvv0RwVl1+AYO2c/aMIbF9zrbpuO8Ls6kFXwRI2vs8L7e/0gbV9aMh3UJqOZvVvPbGd/nVz3/Be7/8KbFXj2PoGDpss/TQve0fo2FWbnc3jPSo7xdvfTowD3kPJXxWnjiH6Xbynfm/Yt0P5967//1w1v739q8/zY/uK52pItnPo5Zjp9ld/lw9lpi9pzIvmeMQwZGr9HNbBFf6L03PKzknpidVg5AcgSr7tIxflnnFixkALl/B0IGvQ/8iVYahRmyJ3OWYdjaWB4tQPcyU+wJo/kW1osXEHiNaY9KFwP2VcLpdcrLdsHhemAu0vmPTrun6Dh89CfCSCMYSk6HrZ5y0M1ZxThcFKxDpFRLsE7Z2qtGTjM2jTByVYFJamRJs7juFfsYsYAdzL4392HWJ5sxBjFTW7iFU4s5i09hoHg8kLwrZKUYtPWuKy1/6Wcf82dnZGals7DT2sVYrQ4aKeXKwXQtOtWAzEojRDJswmbHadgrlLGiblMiw6xL7VeU1FRRFsdrcKjhOXPVpnmjfeiyflfzBAstBVWExJKvNiEo/EUGhzJ6AGMvl68esTlds1+ek0OBqB5KonKNyFTEmnFHDInlP7HsgEgkUWEPCKDuEDiwuN1QKZPoNErbWNWqygHfLBrGW2laIsYhx6kUYg8GRWk/rN5ysA2f3W05mFfPe0s8awpvf4crf/D7zZ18g3F/BH/wl7osTzKKGw5qAQ+6eEcIHxJeexoSE1FWmb9f5VcvSjJqASZ3I5HhUqKXMFwzLfIdCpth+Q/w8y+pBDqc0ESyT6yTtovrUU8/wzg9+ky+++JTzk7tIUkMmxXKSIvTTYIhNj3GN6Ocx9eo5l5xTKsaclMD7w8pquK9d4T5WrzPxuIr3L2M0SDSUPEQlJobi1Nq/KEeyryy0piXqGktpz/PaVYD7ifpphOMir6XMc5ETpPw8Od1gFI+dgS1lomUIV5eSEX00oZRV7LAY6CTr/g3luwpI8MHveJpfUbd8PfqXAd5JQWwMt541YSSZAGJJUTC4ncWhfGF2SN6SKhBPL3B/bbl9nnju2oKwPqPzPVsf6EXwOM77hnU/p/OVFizmwS7JQkmGFBRCa7F5LCYhqWKlxzj8LZNWxmtIbOdNUT4LaP6lYMSjD0NSeX8R7ngzOXQUw1jouI8KG9AsRvu+gAy01pLSKPyNIrH0WfWGRWQQyrqBx3oIY12GJo7PJ0jGvucfZIs2lN2WlZh1I+tsSuQisVEJiaS8AEdk27BOUIDBPv1QqWexKDjC2jgIEWNzBTwaynK1w+d2xyEmDo+PCCFwenpKu+5ZLBZIMmzWW/re45xj5ix1XbNYXBqsLFD6l+CDFoySIZwZ/RNF0LrW7DFGzX+RoO966lqpXsQEUuoRHE4ssRdu+1Nu3voUUzm+6eZcbp4mOMvsh2+x/N0fEjZb4r/+Y9h02O98g/C33yRWDSaPg8kgDHt/Tfj4JvEbj6kBkmsXjFYJ4SVpV9W9+Pt0X+7/u8jUOMq08f0kU5kL0xBHmv4g7SgVleH6eQyJpq545Tuv8Yt3/5Kf/Ps/oifgQy5JKAK67M2JIB482qnVL5AMBIkIFqIguW/MSO8yegFjceLuGrsoTJVSGpP22UoXJLN1x0FATwX9vlLZvabsXK8olfHtXBtGHMLxJWek5QFmLJEZ5kUQsWid0O41dBzJXGsRIyMyrXC2VjEjJ+0InjJitbg9FU42JjJHdhQLoo3C+pD7XNnRs2pmc8JmjaSgfIRpNE7/quNr1LmME6aEa1oJW2CIkq3ulBTymkSFxoWDldLwkAaDi5FkK355Y816G1iI0PWOde84jRV9mNH2DZEqQ4A1zi4ZGRHSiAxyk0Ux3voE1ZHGhbQ/gSK64BKMJIlTi93mIiWr15TJefatkJQUUp18GLDxJTxRrOVCqTJAgXMIajpOwxHHhV5CTZI9Mcleh8tFluW8iizLgmEyBymlATE1WHhJCJm/KISItRn1k9IQNoDiJqehAnn3PlXdMzzTWNcwLuTcWjoAVjA9pMoRQ8SSUW9JiySTCCkIre8wRji6dEToAqvVmhSEZV2zWDa5kLPlfHOOsxVWLM1sTlXVzOeL7OFpGE+7gmrozra5BXXIM1LmDuj7gI89Jvks/CyV0/F0oWd7/oDfkjmvXHmG165cYRErTBT4+DPW//zfYM488uLjuNdeIc2WpNZTUREqS7QRs+pI5xskJOTyIVI1+M2a2jXIss61I9mDmXoOXOytXGjlDnMyrq2p51KMi/F4+LwxG4+DRkoJh9alXLlylTff+j6ffvQBd2/fwUav3HlpFzZ/0TF460brNZJRxGFKUUuTRShBmqmgv4jG/qKx2XlvYk/FshcU/qkSaA+luT+WOxX6e3938hKTMQwhDDBgMYWqaeIxZuaLkr9MaezuuKOIJ/IW2Q3rkXs7FaqY0YuTh2TRGIbb9ZhAjceqqTFS0bcd0Yehi+vq/Dw/lX7XGtlbM48+vhbl/qAUogaIjJnUsCDZXcuiWJQWftC0JTE4ORciuR7B0Cdo45z370Vccliu4KMWt2myD8RkRtwcmHPW5c8Vj13CQ+WehgrZDLHc36TlXmKMJJsLmsriEQY6bRnM+wyytpbQh6GCHhjQIGGCnhkVQJ6QQZDnxVDccStj0jUvmHIMIAGRYYNASeDrG2XB9JmyQhJUTiHBXdAQJAmsNVTO0fWdTlf5oCycjPJSRtc03L/GwUdFMlpDu8aDyK5gKY88PaLAmbE82EauBfBozNvYDFyIuob0nBpiJTli9ITYY43l6uVLeB9p1xu27ZZkhLqZMZsvdZ4SeN/Rtlvu3btN0zRY52iaGc18zmJ5oILtyOTuqDoX1jjmn3lku+Las89zPJsrrbo4Df9aS5+gFscb8Ul+WM+UnbfvSNHj257u5AGzgxdpvv8NFS4bD/OAW21JJ2tcZUmtJ9YV6WgOiznEQLpzillF0mO15p9cRmamC8JBXCy093MA+uZDX/s1vyvv7F4rytTTyRD8mKiM5eWXv823Xvsuf/iv/xXJh+Ec05zCRcbc9D4LWaK261Y7XY29X3+/RdE8qm/KsFYn8gbRurKqrlhvN+rh7eUlLjrH9L1hXHbABsXILN+T3QJPydaCCgJyn5DhGS/K4yjt/Tgb5dw274+Y5Z1+1w6yoTQJAwZgz3SMjBmvofvVs9msSVbLEZx1KscSmQQz5XKKMBjCX+X4etxiRWEai2T0RcHBizD0jJcyaCLDw5dYv0weTANQgs+Fag5DioYtmUmUoNw5NmYrQHm8MEqFX+6LpJbAELPOx5APIAtDJFtH44IpysA4DV+JCM46nn/+eT7++GNCJmQUFO1kK4dB6GI3ID5SGonqNpvNcO0EDC2eywJPDwuBmAfXZgX9UHKvKKeycWGS1C9MpaN3kFLSIr7iDTE+s/eZ+y3XEew7eQUFmJIyD/s+0tQNzo20NeXzR1ml+v5oSU2f10XDXVfx477l+VlDFRLBb7DG7IQLDS6juYz2V8FhTSL4ln67xTjL8soRRiqkj4Rc7yAmkZLHRUO0kfmsGRqIdV2PT8JqtSH5gE2JJheSuqbWorRea13a9UoL+mIk9OoZJ+9xIdLP58zmR/jZht5vMW3PeQwsvvsax//wR3BwBEGIslWjZ91jDg4JM8H7DnO0IC1nmKbRcO7ZmnT/DPfsNfoUqKK2SCalbDHKjqV5US7g4fGfbFwp4ac9z5hd3aNeaVlhk/3F+EVBtOdH0mLUy8dHvP7m2/zq3V9w49OPJ+fIXnap8WJ33Uu5INnyDpIr58vzFU9l9CofOsdFUYr9tZgNwihKQWTREGzIoVFBMuP1bvuI/bGeXnN3hB7eryq7ZKjlSYmxlkhSpsjSfEYI8aGkfrmOz0qv9MpKKEch2YCTLGOMzWgxKfnQsVkeE5kyell7Y5YUqJW8yppm1uh1c7G4zbkxyQjMKZDn1x1fIyyWNWKpocBMVmZExA6d1YrlX7ZGKhrW7ioaM7inaqHFnO1Q6z2Hiop3YOzQW8UMXtKuotAZygsya+qhAAooxV77mxNAYqKqjMbnY8+XN27kbpOlcZHmTULvlVRwD57Y9z193w/Pp5OfQztT17QoAmPGvtVihj70IjIkF4dizOl9girYvLxj9KrQrebDpglaIAMGtCXz6DuqAWAwI8oMhUQXq6t4V9ZlaGDGIRaPcAqlnFqP5XW5Tnk9znvAG3jgA20UqqhrhxhJwWOcUbh4EqVAiZHkVelEUTixSCD4SL9aU1UNlWu01iU5fN+TkgU6rBVl6247gtfkvYuaQ3POkAz04rFi6PyWtj3nKZ/4RYJ//8n7fHd5maqqcbbGuYpm2YAk+uA539whbvRZ5DsvU3/jN5h7SH/2C0zTwHKOWSyQxZJ0KZK6GnN0jDlY6sgYg4mJcOML5NYp8uTjpMUB1fmWFNfgmiEEIXmtT4XcRUJ1X+GbMgMT4Tb8ZTLN6P6bLhzJQkz7NmUBNfxScg8RDZl984UXefX1t7l1+wu6TQeiIB8VmtlynyirGNLQM6gYhzYX/e7vZV07ObkvxZiCabHkNDT9UPiKka1CiXZjfubMTs7ouZSQVUy5u2Tm2ILs4VJk1DigKV/XWjfsA1A+u2RNZuqO2JhlotE7kiT0fe7cWvy1XKeSUDaAwkhcEHSSn0EBVDqmmexoMveGlMK4DvI5pwCDh4xXMnuB1efdtmsCEVPqm8qqkBLe+2uucwkxKFZc8sSmMV5bwiGuWPIkmvmctlNSySKvJI2x+OIK52offXASNqGd92IEMYhJw0MZyAWHu6inqXVRiBWvXLlCjJGTk5NJncv43bIFi5Bczhsef+I6H3/yCSFENusVpUhyummnccxy7IaG9qz5bOJIpokpPmXxPIzJRYiiDKkxJZIf46/TzbPvvotMuuKlEcZcjoG+IupiTqnAIFVZlpiuFDRc2ZxlcTiXDYmHn7UkmPdpzXfju2MSevoMJkQqV2E7D0Hh4kPYLSixpRoQQohF8GUL3AAYjCOTma7paLFVRVPVzJpGLTl7MNT8aN5LrTARSwhaJ5VyZlUAZyzJCtXREeb8LtQ1R1evQQZgBCIPTk9xMeJchW0aUu1YfufbXP1Hv4957DGSc7Bek0KLrFtSH/A+4dZA0+JXDzDtDLNYKCvFyTnprMM8+RimqfD3z9UzTijle8MYSbngeJTnOB7jXOYRHAoy2Xv/AlWlAh3Zmf/yfUQoPd/nywXffest3n33L/jkV79S5vCCGo19pkkq62OXD2bcu9MEfYYIxd21XrzgmLkM95GK5XvFct9P0FuTm9Fkj90abb+hTEEyCs+UEGM5unTE2dlZNkykOFq5eZ+unRFtuZffyOvKWqsozum5S5hxCImprCsRjuIVleZhBRNaitiJady7g0ekqYc4RA3GkZzSz0xr8VJmlAeG2jlrMlNHdnRLWqOqKtq+Hbj2vsrxlZVLH3qQlDEsDwubXWELbdsqSiM/cOi1Pac1o3WcZHTNNVeQOyYO54tADtGU8JXIIKCnsdypwLfW6vVzziWlNOC4hYex/dZatuuOjz74FEQwyQ2W3XiMscoSvplu7ukiLueksIvCsFFLKequINfvhdydjukiZdyA41iPNda6AAySlFgvTb47TUQ60ZCiMZYYPX1KA83FuEgH81Q9xiRZuGi+JoQ0eC0DRxm7oYphtPbeGz4T7Ux5TqCzlrrvkVrvq08gURtsOSSXV6RBOafSqMgqusahGy34SN9uCO2W1lhiSjSzGhGoXI1JGuqs6gYx4KLBilZvq7et6DDaHt9r6wDfdWxPz4rvpZ5L00BT4YwlVI5w+RLH33gW88UN/P272INj0uER2EYr8xsQH+jbc8zZisrWxIMlqe+R01Owgnv+SWIXiH2nydmjOQaD+EBssiX90Fq84EhpRwXEsuaKcQMDMGykk5n8vMy7jN8b9mZRcBfcQ4lSPP3sM3zvez/iy89vsN0oLYw1WkKQintCEWQ5dDthqsiPUM56wQULek2b9w3X3vPg0t7egdHIKV4QqLC0VtdKyDVpA4JNlI7o3r0HIDnvmPdLnNyosmUP9uPOWg8xEruQ6YdyqDlkePy+Es10LoO8KCH8iaQtOVkdwEErjcbqBUawjvXD8lHHROkqRDSnVoxNEaU+CjEyX8zpt8ou7X0YmBemueZfd3yNhH6i/K/Usww5g4lCGBZSyr0ZhlagMrib49BSZiXzWZEtolGThmk8Mn8+xOX3qlq998N9ldwHZK1fNlTMAnivmj4UDW4tVVPTtx1TanxgR6AO93SBBzNaL9n6yBvlUUpZko5q53v9TdpVKOX70+tS6F3YWzSpYPDYu5YaRzGFbEkxcXN1TjUuD8Wv04IsvffSsrUcUyK96VqYPts03j58Ry0MbqQt90zFwjRI34FzGFspis0H+q7H1oKtnXodXolNE5HQhhycUFQb1uKMwbfdADXfrHqcFfq0Bq+9QeysoZo3uNkca2fURhGBxljm8yXJgvU9cvND6sWC4yefRFBlF7zmzqocKmgPljz2ox9QPXaV2HnEA5/dJbWfQ61zI00NyznV9cdIV45hNiOtzzH3zzBHB7RXD7QfSfT0D05pnnmS3hqcq4kewo4VtLvuHnUMYrzEeJLw62RB2v9bjKQJZY9MvyOy9wv97nw+59XX3+InP/kz3v3ZX6iR0CuxqHJfmbzuDBc/S9nHFyuOoliAXA+zW1v2qLHZiWgUz0Cg7/sBJTjIkHwfaeeV0Z41pbOeFVxdYzC0m1aHOAv5/ZyJJEghKCNCIXuMaUjEm6K9S2QlpwJcAcaIwoJTyB1VsXnd51DlRGnuj8V0f5Z5HaIY2btRecbAvG4ECIXFJN9Ttm6i9xir9Dm+/2vOuVSVY6CHlcG5HNw4YICvacfDCKJkDiKaEzCTiShuXFFa5SypJPzJnFrF/EppsBo0ERYGC2G4j4zuKlZEof+3otZBTEpEWW54Otgiqs0TQte1g/eQUhGgCrMeXcpdVNT+hBb2VoGxQGuwcQa/Y7h2uVaRJ4PhlhcCkg0XXc1AzK/zAhDRBF/GHpdmXUWxki3FlBLOWRazmTKfRvUoi6xIg0eZsqJPg1U8KPNhk8rOOEHZg4aqqrTJ22TDqaeWiNZyv6r4ojc8s5wT7m71uY32XVHeo6D9fbxnPpvjajPcf0rdiNSJGr8nRl2jee5j7rEeQlTDwnf4zYbuTKhmc6pqhq0rnKsUVm2EJBpiLItI2y4od1ldS04MaNfJq2+8TP3cY4S2wxzWpC4Sn5yRwgHG1aTDJXE+Jx7Mcc2SmHrky9uwWhGffhapZ7hthCYhqw1VFAgeR6OQcOswJIKogVI8uEGk7yuYsg+L0VI8vul39qz8nQ/3dcbeRxe8Pe7ZpHv/scev8/3f/BGfffIh2/MzHcPpngmlEdn4DBcrkdHDmN6BUHIguypPZFRc+xDc6VjtGoYZoJKmSMxCr1r2Zi50zszeoILfGUcMJXyWkVvFO8xG8E7+JyZtdy2aP3FmYsjlPWTRcJ8xqnRSzHEbyX20jBRqPB2JNCJUBwdGoDR7G9g1eDh6EDMDh6RMzVV6IiXtyVNYrftWUxqFDNOHQNwLa/6646sn9FNOdCVFXeg19FFLaEFEhmS7oLw+pcGYyXmaMqAlN1N+N9pBedGafB6jm7tt2+xhaCOgkNTiJHtGItq6K4U4eD5a8Z5yLnoymXvehw68TqgkjTna0jEuQ3ILK+jOJO1BIEt9yPAddcUmlqQqZxWyky2brXztzpeGcTK5B0TfdYPVViq4CyW4KuqcjxkQdBMoMCnXj+gkqqK0dG2XCxeHWyAhY+GdCBi0WVBuLZByN8FEynVGMlhuBa9vCgV6HpOHUU4Kmmid44PoeftoQXW6IrYBYxSgYGdz7NzB1tBvtqz6M+rFjHo2QwSqVClJYorEFNRbyQ3DlCEXMAowcVURzDFvYE+QhO83xO05IFTOYcVoxX8GgITgCaHFRINOfY5PR4s89xiH8yXcO8ugA0N1+Zg0mxEPFsj8gJAr/uvznnT7U9KnN7FXL+Gfe5xER50AW8E60bYRd/WIVFcQohphFlwYjbc4WBYM62tfwQzjzM7SevgzRg/n4hzhJIk7+e7wak/TFCOtriyvfvtV3nvtu/zJH/07lAZKMrWLaHGkTBXIbgir5GNL2HVUOglSNnQACMXeAqZotFGoj+vtYWt+57yQ4zF5HacILudqktIXFaUBKh+6TTtQ7yspagl9q7Cv63qgahoHUHOJurXHRHlR+IVRWh8vDkZCGLyEDDCIuTmYMZM8Ym5rkVXjlABzPxxGlseDQZhUiYVQOgjn/i4xMeRbRTLISgEY+0b1o46vHhYz+qBd2yO2wjTaXVFzpjrTJWdSHsKJzaGtkB9cj1Eoj00zi1IxSRXSUCxkBFM5Ut8RYsSHgB2UBINXU34fZYzhhhQ1QTXpyDbdSlMl8czTTyMifPbZZ8Pi3v1OthkmC3aasJ6690POIyUVfuXzNE78/qaOUelpTOkux6R3xaAcGJTx8LukbLQleT+llyGR+6rsAgKmqLbdpHyx2iXntrKiEuUmK7F/AwMksnhw3vsMANBq4bZYajI2lwNIxmiCHctHBs5mM64v5/jb93X9EIhhi60qFss5fV2xPVvRn65IbU9dVaQUaX03JHSNmNyLXNAWyAZxMii7GDUp75gIEoxCl1PSEFCItNsNfabbCV1Ld+8epq6RqmLuZmwtxCeWXPvhd7DXHkOqhnD1Km65xNcVpm4QYwhdizs5I3z+Jd2Ne5jjJfLNxwGH7QIy11i2oyfMHe5AqV+k8zCvSFY5aG2M2DhRBNP9uK9YmPBC7XsoO9/bVxa7nz3qNxd7NrpWCqopxcjlS5d4+50f8Mt33+X0wT1i6lHGZDV0UmJX2DEqyrIex/CVPnVRRiJkfrxiPZtMOqlhSO0dtauw9nOhIuNGKgK+VLprLsEoKjHfo9kb60HpGS30rasaATabDT72OFvRd91DYzkJwOxEP0D35W7YTgZgUpoAZzQHOoawS661KIrieQ13Oxnn4fkzJVWBXZfxi0Hbh8QYwdp8v2mQewVRqmCsv+aE/sAjZdNOD/ciNIFB+w89Q1CFY8UQRWPX0zqKIVYJO+SNeq68YINCUQc1lCISDcaVOhsGTwlRAVOErJCZ/6VM7gQjPg3tAHfu3BlyKiPtBDuLcmpxAXsbYYLcmIzLQy552rMmRK0hSYpXNzkPUCY+lnBIjEyD57I3B0XRlf4N+pkoxDf36u77PiuSMlvsKFFr7YRyZhL+CzlYkK25IRQq473Y7LGkYl2hxaYiMqDfCuzaVppPu28sn/uW67OG6uiAsF0T20h/dq6dKddr7KyhOVpqjw/R9rHOWKo295hIic4Hgm/BB0QynNNYhYciVLVCmmMCU1kQi3U1tm40DIfBihCiZ24Nr6TAL05uc69tmScwAVYmUb/8HI//5vdxTz6JXL9OWNRIbYnbFlZnbD/7jPj5TcKHn+A+/ZLKCPLKc1A/g/nyhNRrmEGuHsOlA1I1R2YHmNP7pLiBRYWPHmsqMAozlZSIMoCKf80hpJxYnHouF3xtUC6PFBGDtzNRLJN9vv/dmOe2eODffPll3nrne/zrf/nP1fJOkFLYoS3aVwDl9WjoTL2LMcyXCnVBlAywGsErU3jyvgLbDxGV90wOtWlIyOQWEWPL8v3QnUgOGwv0MeBb7e2SjBrZnoCNDKM7/q4k0UfwQgHH7MuI6XjseP6MLQyAoSOkzUzChbRSmcjHdMU0v5viBOhTDOFJHkYynFBRZiVfpm3um6qh7fuhAeRfdXytNscJ7X5m65qu90N8P4QwCPZyk0XRTENA+7UR04Ekk64JkKwoDXoeCN/3mGxZ164aqBP0dxNCxqysyjnthKIExu8VS6EoB2utJm1D2PFGyuw464bfAANdflXVFJ+reCxQcjEZwpnDDMWsHOpmhtPLMEZq4YWpiaMbZiLEfSF4lHIO3SDOWYw1WYGk7CWNv5vPF7TtA8ibSQk1pwuvLH7JiliGPAhRXf8CNCBbSUVMTav1U1KFaESpdArEctq0KEjA4IhJaKMaK/VyhtRQ9RE5WOD7QLtp6U9XdOmMum6YzWYk71n7DmqHdTWHx0daOb/uWZ+cEfqOuqlwTYWrHFYss2ZGu9mSUsRWSmpqXaNooRBwkyIxsYbDdkX/4BbHzz3N1UMt1PTGMX/lG8ilY/xqjfnVn+Hv36O7f594vqI/OyGtVxxGoe491gldAPPxTXz1Y/prV2i+8QL1K88hywWui6SPP0HMx7Tvf467dhn76m8gj18i9YFYa36KmFRp7Pgt7IaUNdYyIIzKHD4EAklpRJ6lch52PP80/bissd1L71jyg42UTfOYEgeHh7zzzvd49+c/58YXn0PqwTKABMpv9hXA7nuTXVK2AwVKqx6MJN3TBwcHtO2WLncUnQrrh/Mve9ej7Cc9bwpRO+GaXRlVPAkxEw6BAok2xZ03Q2fHqeIuXlhK4/WnXtrUk9kPdw6yrORTc3TIWsvR0RHr9Rrvc2g4/6zw+E0fdcomULybVO5tcq2RPDTTYBWEbOwhaJ3aVz2+Rpvj3Ayo0gvHqBbJQC1fPJXM0CkBjZHm8IqJmRXXyMOLHrVIJOVwWI4nWhRCG4cYJFhX4LSTwcoTsE9TPUV3TWG5D/GK5e9PlV/MuyplOoTd2K0dlFJRVvosZCCDTl2xCsYOfWOYa3j+sqHHVfewt0MaPLRCvJd3AinlmqEQ6eOIWxcYPMw+BK33kWwB5r8pb04lq8tWXFaMKWUwRo4ZGEoh3EQykUObU6swj2/xHgsarVQMh+A1kYjBpZ5DO6M2ieDPCaEjdD2VCFI7Fs0hFZon6bqezvfEnFQM51vW4Zyz+/dwdcVsecDyaI6kOVvfcbZ6ADHQNAs6P2PWzJAgNLPZsKGME0ztlLYkRJJPEB2+U09re+8+27MVKUTituPsL36MTwGJkSoaYmWpqxpTVzRVhQj42iFW6DH4ywfIc0/hvv0NDl5/HXPtCoSW+PFt+rsPqBcN8Yvb2BRJh3NiZUmdRzY94eoMUsBKwg+eOcMcjkbbsEQmHQLTzjqafGVn1aW9D4foAUC2xIvpNCzwvaPAVOLurfDc8y/w9vd+wD/9r/8rulWnRdKT0AqMIJB9T0NEFIhRBHlM6hmgyW4rk7beKdFue7re78iFcp6dexWF8aditGnYQEOnXtlAbC5LhJzML3Va2WgOMRKH9LGAaBhNT6X1ZE6Ua+AioAKMym763I/KEw0G2x4iN8aooTjvB26xkojnEecvBkDhJkxJwUAGheXrmprWpRUAho523wXNcX+1qNjXKKLMGxBbD/G6cvMD1YkMNjyQ6LoOa0wmuCzafhScg1CCoaIfK2S6ZWX2zXUf2vVSWXJTChwdHbHZbIZQz9QSqOuazWazI/ink/UoN3QcVB1Txb6bIUdRFJhzTnuGWDvAn8v5bEaylWMKly7XGnJChftssmh2xkXNygu/r4J9dKm99zr+kzkZQnPZq/JBE6EFPFAUy+Urlzk7O5vQIzOMXYl7l2fZH6uy0Af3PaXBs9xJoBpD0zRsNxqCwMI8JQ6sQM59VNaSxNMOFDqOXjJTclPTLGbZis0hrgTRB/q2ZbM+4+T+HcQKi2bG1UtXtMulD6zWZ5w8uIfvOqLoGFoxzKyjso66amiqmto1uLqB2CPAzM5wZkZMPdVBw9yqKHWzGTFBtdAq/M2ipj+cYw8PMbM5bYjY65eZv/wS9vFrmKqCrcf84iPaP/8p9ZOPUV06JF05JC3m2MUSuXykkOqTDckpGEFDujvQj/G48M1x7h55JEYtUhRS2nlrqD/7akfayamRf980M9787hu898uf8qtf/DznKsr3Smj24Xue/i3rt4yFKpocCsoKSkTo+w7YNSb39xT795j3Voyj8WOMWupl+Iq3UIasFAANYb0MJiofGSk8Xgz3Nn0+vb6Z3EPa+fdubujiupVi1ILCqdXDzL+ZcIplh293plLaYYMvhoP6iHkcUuFiY1A0KWrnWeu0TGPdtXyV4ysrF+fqsX1tHGmfBzhvhvomkVxsFBFnNZ5tzEBBMPU4yu9FNBGvy071ZIoJn/qBbysBmIxAizF3p/Q7gx5jZLFY7NBSTyfpok23P8HlXMO/TaZoZxSmxTJ3tbYOjmQCvTT2rJ7CnGNKpEnh5X7OZnqMr8dFPvWsdBNI3qjj0tC2w8psbK3NjbnyPYdIH/ywCIuXGGLAGMvZyQnFW3nI2t0Zw1y/IQpbLMeUa2x4vozNTCkH0GJkvV5rGC8pYeelkDgMEUkaivAhqiHSzAh9i5GUu0Am+rYFbB4zzeMFIyQMpqm5vDjgitHz+q7j7v1bpBCp3JymmfHYU88TUiKKp207+t6zOT3jbLshrs8IoddcR4IHGYRx99bnzBYHzOs59WyJmBpjHFYaBWv0lhAts2bJ7Po1zDefQ557msPFIYjRdtprT7x3l/jnf0G4/4DqW9+gf/oxzMESO1tgpCJZ7S/T371PfXiAzGZDdXoha98X91OvZT8nsL+WH17zu4KnKJQsy8cPR9fioXNMf1vWYMnHKR+V4/Enn+atd37AjU8/4+z0wUPCttznRfmXxCQcJTIStaJ5u4gylqvRrrDikTxyd98/HCkZQ9G6VAtAIBGi15YOonUsNs9jYRovHv90jE1OcqeUof7GEdN++EjJY1IeYJHdeduXPWUvTfPDF7IzM9ljJVpShrk81p7cKQqpjG+p+5uGx+q6GhS3eo0K7++7HvnrzrlYGfs3i+wK5UHoZmsg6JsZs53DUvuaOGuMoYgxBPVa8sIvjbHKoOlD62c2w1mN0YnX3hh67lI8KUxCYWaXBmJKkLgb7prkDVJSXq293gXFte37fkAsOee0LfJEuIegMxtK7Dijhm3aL+iaMpiaYfGPVtiYzE15M6niKnOgz1BZi3GObbvV+Sm/KXj8Kb8TQBbMiUTpDzZ90ovCCyVcUYRQCTNMGQsGdZcVzDT4UjwYSYkYeo4xXLYW5yqSS/iQsJVlvjhkfXaClaSV+nnNRZ8I2VPFgMPhjCNFUa+k65WJwAhXDx8b8kqkwN1bN9h2La6xLBdLrh5ewV69jqsU9Riieub92Tlndz6Dky2zZ5/FLI6hC6Q+IDm0GyzExy9hX34G89KLmGuXkYM5dn5ArGdEC/Qd5tYtwn/4BfGTL7HvfJv4o+/D5ctUPiKVVdizCKbr8V/epKpMbk2c152UxlZpd1xld15+3VG+vruKx1qOJLKzLqTE3y78Rb5uuYHJVyT/VlChkkKkqWe8/J03+Nlf/pSf/+W/V+96CLvu3+eucTLlBDR5z0l2rwIanrFpV8mWUFsZlyn9y7R4sIzL8J2oZq1kedV1LSXcO/UM9J/Z2I2ZpijfZ+W0mVzf9kOivTzXKFd2x+8hg4xRrnrvd+htphGDch9FqUjOGVLGY9jL5ZoTBS4y9IVJE/cmZk+scgqHnybtbS4s3663pM5j9tbGo46vrFy0g1u2RvOD2b0ahkFoZrSY5F7ssQhFJhXhOfRVwkplAmyuPFdUhFb5R1GPpiIz5CaFy/mJG7zDvgqkqORvQXQC9pNnZdJCGkwiVVzlmWIcFMu+y67X0VoP33bKsGu1ADCShqInMSUBprTylatIfvTchrEdwl4xJ9CK0iuAA4P3Ghgo5KEhx1dj0iJRsdlzBHz0iBHc0DQNCvGkZvllNBLIAqyMXd4sY8e+0XrUQrU05NjipDFUeaZpE7WUSqKYsdgsRoyraXxkGXusjxpyTSkXQWq6sbJzRFSgCHrfyUWoKlLw2YXXKGtVVdTH2rdFYmK7WiMmEX1H8prEPz66xDHCnbu3+PLeZ9xxN3BiaYxlVtXMF4dU8znNbMYTl65Snd5l8/LzHL72Fq6aY+s5iCXWNfGwpj6cYxczQjNHDmbakM539KenmI9uwM8+JH10A3f7FHEGwi+Q0w3y9rfg2lVCpXVYabPB/+RDzNUl1s5pI1RW56M1hiQGCRCdjBJx+POwpxlTyqUBeV9k22YUOHteTxrVxnCqfcG/o1pGx6bMbdl1Y5glI6pS5LFrj/Hm937AJ59+yNndW+opiEUJJHcvNLXMSZNwq9FzIRFxgomS83a7AlokUVUV3scBki+MuZ6E5m9kGIGUgURpeBiTGx2WltxQyCVtjtBo91hPys3HdFr8tmXsfMrk3kYZqQI95nqusndS3nq7kZUpQexF4b6dec/3L5J5wWJBcxYW4zh4KkVZxlTyVmpcCCoilJgYbSmfl9zM1SyaBf22J6SA/esmrkxpXGT7yaXysFOhLflHw3fLSaJaCDaZnX4Eg4bvA03V6IBmeZiMWsgxD7oa2yXJPd0cJRaa2X5l3EjlszE/QFkCuTJWN9eU/jo8IpRVLApN0E8nOAvuDMWNvrjJKrB93+cmXaNCOTw85Pz8nBgjzjn6TPE/BR04p9PkcxgwZcUcs0cUiBBkiLMKqlhM3uRxmqmN+4CCYfCGMTXGEH3uiphj0WUtp0Rmd9V5dhMWxFH5psHtfyhMY4SYPKSArazClHNDNfVsIASvxZBG62skN0BT5LFgbKNpuYzB733P5sEDnHMs5nPmBwtmiwWCIQaIKAN1e3rKtStPcuXwGqvVGX59Al1P13XE7RaJ4EzFVVNRI/zFP/7/cP2f/4GmeK0hOouxDXFWYWZzUlVhmwNkeUA0jpl1kCINluXzTyK//zdIj1/BLg+I87nSvzih9y31/VPCux+S3n2f6twTf/ga4fCICgWRUDVsXaU0KoZRseyN9XRsxxVdxEUOMwtjTrMIWmGnCSWw0xiP4fdpLKydXE+mC2LyccqWfczwSOcs3/nOd/jVL1/nj//Nv8xklgWhJQ/JkqkQHYyuGHJxclI0l7HIADBJjJ0gx15Eo5Wexp4oKSewZaIuB8RXLm0wRjvPDucu2ln3QKlT0/D3WAJQBlWEAT1bREJKaciHDkqH/X2zK6dgNwx/kTE6GG8iA/ktec9aO6qAgerKWsQa2q7Ljz4qPcn3G3Lutq61Kix0ntV6zXa7HRsefgWPGb6OchGGYsTBQpl4LUxeM3kde681KcbgMw0MRuhJO+iUUt/R9/2QjBbDgNe2RqvE+1Co+HVyS+w/pSm9iRtkvhXNv1wUrwy5mn+Y0AHF8nBy/aFnZHR5p58NbnNSz6fUKohklIbITkHm6enpEOoqAIHxOnqttu0IweeKfRkReTJ6bNpdUUbFkspCyBZuGlFmimXJzm2REdkrLRTjVV0RvSpdiLjKEkMkJoGdwtDdDTEKCBnYCsY8GyjSEJIkWqM6sRqdRxDBh35k+ad4nQaxlphKUaxFbIIUMERmMdJve87WrbK42vtY53DNnGq+oGpmHBwcYOQQSXAtPsFmc07oPH7b4jdb6DcE7zkz2VO2jqODS8RGcy1OLFvT4q1DmgUcLGG5JFy/in3+aezTT9Bcv4a7coVwUCMhIq2nX52SPvsc8+Vt4pdfkD6/RXd3Q/Xcs/DC00TnoGkgRGJl9Tmrhq5SAEMsinRvTz8qLDYojaxUBtKVQQCpvbrjzeTlJkzmIv8mG9iTf+xdb1xGgwGqAi1CChxfOuK773yPD957l5tffIY1OTAQR8/34ep5hrVjcsW8FQFrCT7nXXKi2ZhSiFh+OyaiC2VUeXxElFlbFyOF+3CQC6l0Xs3ectJCRRFyOYQ+l+79fZmQVfOEWHMMreV9OFEiw95Lu4plPwc1fL+M8fS9mIaxF8g9XXa5BadGt7WWpmmGMP6QzpByT6LGqDVIRgKrgzdGIqZhv193fPU6l1y9mp/uwgcfiiOlIK10cE2SzNJaHNIMpyxxwkE4CdZVdN5jMyUHecKNqEWhFrt2WvQD/HDCflzw3Xlj7Vt8owJMaNeesiAKtcLDk7n/7/3nHtBiKP6+rhu1AEpGbTeaMVj15ZnLfWknybEpV3nfl4SigI+BxmpnxBAjzlraECBDkkeDTN2+MuIZeKn2WB6XlMeewmKQRutMw2KBlMlHY2CIw0rWw8Wt340X5znPhZvaDGm0/EqCOhjh3nbLCkOVtOeFpFzThAMRTe4LimIrTAOpxN7VWktRwxfJWKpGa3LwkeRbfGgJ6xX9bc2fmVprW+rZHGMs86bCHB4SrdM1W1vc09c5+fw25g//GT4kTs/WVKsNi4M5yVmWzVXq774K33mRcPkAjhbIconBYbtEOt0gX7yPPzuhvX2H7Wc3aW/cwj04owLclSPMY0fMf/Qa/rvfwrpj/MLhHODB5oLajTUEqfDiM/NAaZWwa9xcdAijYi6Spyjr6bciulfLfpG9dUpeN0M0buL1FOt7ao0Pq3YIBak1bKzlxZe+yetvfpd7d27RbjcYU+2sm32BOo2GeO85Oj4kxJ7tZgNGQQMHBwd439H3LUMbjqkXJ4LNlnYRjgnJ0YM8ngRMZUlhkpvJRqCrnIbhczShCJViDBqTc5CU/EyphTP4pHu5ZEy1o6hOREILpsuzlvDT+HpXyUzzRtPwftm7Zc726agGWYCOgVbiR0LuKAky5iUZAVUCdNt2MEBmi7m2P87Xj5OWIL/u+OqU+zHqc5RGXCbHjHPcElFLYejTgrKxproaXNKhU2RKY5q6CCjQDWRloPMoPUqMCJIiTgQfOv7RP/qP6UPgn/6zf0GKZhhHlzsOljcKbcqYBJXiOeaF4bWhF9ojRiVvUT7j5FAmcWIlqPWnr4ZJtWqKG2OIYkgEXch7Cmm6aKbvjedSRFRZYNZkSzCPU4i5BYEYuq4fxrtUL6QSCymomh0nvNx83ozZgrLOMvBnJej6flCCg1WZx3Dw1rJ3VYIIoxuaLSA1T0fLSiCJxXrdkA6nXSJtXkmFSytB8pG+32ri3jqImaI9Q9uD90PwR+Hp+XtGe71ItMNmjyGogmq3IELft/pMraJ8RBxGHPb6dU3iv/Um5i//LfWTT3LlP/kfwue3Cb/8kHTjFtuzmzz4F58S/qmnlgpcQ3I1FsNMKhZVQ+8gxR45XNB8+wUWb79BunpIf+2Q6vFr2KuXMK6mXuUGZk2tsXXpwThiVdFWDUEgFQOLsn53Begjj6w0iv0ynf+B/HFnYjR8qh5O2lsvo3dSqtPHcDAD55eWC2QXKKUs+JTvbbFY8Ppb3+eX777LJ796N4fEDTH5fG77kCFYDmss52crxKrcCT5gTUXbbrXmiYKQ0n1eWkNnsxEYaZcKpFmGh5Dhjwz/1ocMfcje125EA4SmmVFVtUYeCGMdWP69Ea2Nc84piWpIgxKeMgtM/b6LoiVTJVv+rUabRmnqpqZtJ9DgNEkT5Dkul+lzrrLsIzOMjo6dMQaiAldKQ0KVJ0kRjWkagvyrj6+OFpvebG4almAYtIKusNnDmHZEnHr0Q+7j/0fcfwbtlmX3fdhv7X3Ok954c+cwnXPuSQCIGYAASIpgJg3JFs2SaaksV8nlkly2y+GbLZetUqn8waoyP4giLUoyaNIgSITJwCTMTE9CT+fp6dx9833jE87Ze/nD2nuf8zz3vd23AZg8XW/fe9/nPCfssMJ/rfVfqokPKkJu46lQ9Zht0xdMaKaai0/ccQePPPIw//U/+kfJWkhpx84l6MiC3FnlKJYquGgWhTXXPCwL3kUl4bBpUjOEUzZnEukp2yq/V+dzJAspeW1OhPnhlEKcaS9TxnHVGrHfZTc60+j3AuViXlvUmFgLjF9NoqJStjIQiLn/iusWrKQllJs02XsLqj2lERMrQIrH5Fz4fI1cX5OLtUrP82jPIamoNKqpmRitpiEAoh7FlCURnIuEStiaB54crbNFRXRTo54XAUn9e7B0Y9VAO58hODTX7riQenp3nEzemWHhslcmDuc89aCyVGegnS0QNehVmzmLeaR2jso5KlcTfrZLfP1NpB7D3gEy2GXyyvvIyVPIX7yHsD2mDTBpG9z0EDk4oNndJ1zYoTq/S9jZZW9vyiBGvBsyHp6gkW1k6xh680lGN53GbW7BwIEXwiDAvMGleCKVS3VgnkVV0Uhq8ka3FrPwuVY238pyy3qjwJ6a1kBeXj7/Is13F63JykQ6oZkWfi8cnvaJiahO5qR75b2DWfq33n47Tzz9NGffe5v5bEbuPGvCLxZkYzlIn9ZgDKhaUolL8HVoc3q9dEmVyZiTxKocUypkLvY2SnkpXr7mou6U2SjZ+uy9YB/2MifSM5vNmc3mFn/VfLIJjVTmUgwbM267Wpo8fzYPqauvvdGK8WAzZ+fnuJOUZIXBYFDgfoAqlSosxTdznU7KrM2Lou+lmlwjlVxcbWDEtu0QAxSprk+7XH+dSxrkmOaycI1hlkLuU56xyJyZkNuDItJzBJJgk1SxLmlJizIejwghMpvN7Np5KSdv5r2z5/m//Wf/d+sOGPMLw/r6OoezQxZNY1xm/X7slaemKovVO2NZzrBQKMWCaVDTIi9ZT/SUXe9YdeP7nkgfT85H/rwjxuwslzwmuY6lU8KZRqXnwiZq7n52HK6rvE1PVxYviLVXVS2Qhi+KxZSOQS9dUegqxpvhD/AYCpkrqAMxGATgve+Cfum7kZAMBBBRqhjBOR5yQx6NijRNeVZVweFRB9XQEZrGWk3jWLQtYbFINQWC1JUxJ2DZc9E1JdlDYzTKHsA5CK3iq5p6w+IgsWnQtkVCIDRzQhNoYgsxshBYHF4kxpb2ykUu/t5vIbGirsf4wYDBcAgnTtGePMXg+Cbj7WNw5w3EZzeJGxOG6yODPMKMsLfP4Nwe4WCK/vQt9J330btvhxvOwLF1pKrwi0jcOwQNuM0NFEesB8wrT4tSk+V6F1/sr73eakznHG39Z+tVy9UotSM9Oy590jOGyGHzDlrNZ0SSYaa6/K180aJ4zBAZDQY8+NAjvPDHP+bVl16g9tC2Qmt05GZArBhik8nE6tpmM1uHmokTk9ed7lCYzxP6kFsjl5iL9Gx0oTQPRCmJIwb0LWdCHbUP+nu7BOelb5R1MZdscMZk8fenzbl+J82rYbBRYgE/PDy0qyZUI8eX25U6v6MSkPJ7hx5tSzY2c0DfFyWu3VpJzNPg0CgMvGO8tsbu/m6PgvjDj+unf0nrpQgO53Dem5ZPJJFlAFJRR+V9R+t+lCCWJIjVWYBeHPv7B5ZXnYgWNVtTTlAnLOaLNDEZmrFXPTg4oA1t6uGixZvYPrZF5T1nbjjDG2+8ye7OHjF2tRnOOSvU7LX7hGyld4oipkUbciZUgqn6kykiTCYTDg4Oyjvmz3OVv/c1qn2GA0kKoHsmG+cEXWguLCVlm3Wp3TbOFBcqw2N2X8uRsSxEB65TbpbG28/wM2tnNBpZO9P5rPfstpENr7XmTzFtBkHAOypxxSR2UFhmbfzSxskWtDg2m4ZPrp9k/dIui3aOtMYdF0KLeW1mUlSjAbTevDTX4mMgNi3aBpqmJSZPxjlHXVWEZkFIFdaKEWcSUnZcEgLiPPWoSrTikdgsiKEhNoFG1WCBpuLkYsxOM+Pi9IBRaHFYCqZ3A9w7rxv7beWhHuCjtzqw4Qi/ucH8zAnCzaeRW2+geuQuhnfeRrsxxs1bdNHQDhz1fAH7hyxefx8u7OHvugn8AIaetnYEl8yqxM8mIh/KRqu9MddsSWdZS5cxlgX/aqZYWRfp71nUZOHp0vf6HjtkoU4qIux543RIhxls5pXfeONNPPXsZ3jvvfc43D2LuIquLYYlezjnWJusWYZgCMYZlqlNgNz3hN6zZqWSDa08bpl2Jo9f61LtWXoR2/sCOEM/VFNL8qOt86MUjJUcZIoje2eNqdN82qv9RBfI4qajjcreYV/BzGazlNxkY2d7+eoYTJY1SySX2ThNey+oJSrkRJ88J44O1s/s0kXRSG6tIoSgzGdz8wh7XvOHHddP/yIUwZcnMYQWR86lTsI6wSPeOUajEbPDQ3PNSiZH7+X7GlbNHU3OEE3TFEs+xsSsHCOu8ohm3LGlbc3yJQbj9EmWuCRzZnd3B42R8xcu2HhJ5yW4rCDTtsqLNLvzlhUCmc10adsUeKib6BiTx6Xd4o+9hepTf5bSiwWLF7jemNT1wCCl0KYJ7iWG9oRFDuaXVsUY3u3IHo5ZYnl8Q9TynXyvmLJpvLcFNE1BPPNSTJE6Z4qnBDpVS1ooktK+o/XeFqwhlCT4wJ60Z505IYhnKAtu8B4i6GyOEli0DaoNIopXoWkUqWoqPGv1BO9qYgwsmCH1gJEzDHjezGljJBxOE2SpeCc0YrEZ5zx+kIpaXcRXDnEeX9VIVaHeoXFAM4zENhIr44q6bTTgD99/hfb0nWxunEDWhsjGGF0bMhwPcaMJsnUMP57gm0DYO4DZnLiYo7ogXtmnevdHtM/9CPfAXdTPPEKTznUXL9G8ex65vI/bWsPdcwcyGdPM5gzWN8zKjSwJ0KzQr3mIFMgrhxMyJJZOIBsE2YMV+kIvzxG9mIoU5KGvbLSHQpS9TLc2M4Ih5b4k4RgYDAfc9+CDvPjC/fzoB+fTfrO4hobunacza5XcGWldijuIpcrnOKTmhl/aeUDmwholCx3/oacH04vVn2WlmezJqxCJfOS9JlAq2ovvJLl+zjapd52stC4OUhRA7pOSmT3EpUZq0kGgGSkI+T3Tvqvr2rJDewhD31MpjCd9eEysN21WGk7FYOP0Xn4FToOECGlGWWws5vOFff/Pus6lcy1tUkRTal4qcrRxtb+45F4eHBzYC4ultdmEG7SWhXo/1Gzkf9LVcxSNLJZFlCZPJdESZF/fxiMZ+jaAZoRGVF1pZ5oLFPMk9P9sQ0zpzfauXlPjMxFo6SywXDUbI9qDjwo2HEJn3UmXq94plq6I077nyuZR1cTb1mGrhjm6ku0T0vP7yqcYR3pfbGdEwGfwQ0gTAxoDuVGW9V1J1p03w4GiVLDsvtjBmzYk2XLshJymjUMEXyVoIMUI8oYlZbpl0zoRAbF3sM/6Yge3OKRS4xWLOJrZjMvTQ+azKQtRKipOVBtU0dLRh+MJg/GIuh5SV54NNvGVYyFVMkKU2DaExQJdtDSLBdVCaGODjqwHh/M1SkU78LSjdeTkCfyZG1g7fYrBraeo1sec/8bX4f/xCtv/3l9n++77cCGg8zkcHhIuXyGcvQTvvk+zP2ceFdZGVGdO4m6/kdHJE8Tj62g7o37vHPGHPyH+P/+5CRwcnDpJ/dhd8Ni9sLlBrCvc7hQ3GUDti1chcnW8stuOS+K92wdl7fVFe84eTMs44TNX2eaSsfh+UJil9byssDqFU4xGZOk5KfBMen5VTp88yeNPP8s777zOuQ/eofIDI3wFiDnr0aDg5cyp3hv10oCLoVo+Tc0JU32TJiHZpsJolxSxqKaiys48yzKi38kxvycpYzMKRqufCoAkVaq69HwKBTpyIuAdLpU9qMZEJ2NKRmPq+4QUT2dJzpa/SjHycjsRm9JuNmKMDAYDnHMsFgtTKpqHUgri4VRLu/esjJZlUvfeVVUDLW3boSrX8upWj+tvFpYWBtC1IlYbEJcXXbKGjGGzR8rYq+sA8N7SaE32dRjiUt976QJ6xeUTE8arDbeWaPXzIEkn/DLM1FE62KJoGxs0lzKlzNJ1tG1jJJkki6hKEEUqdCyNdsqiz2mFNg7Xsh6Wg3X5Pc3TyhXzIVEz2IKLZeFnZeHUGmBpNHaBrFosEEmy3nuCJsWzxAmV2PuNx2OzQrSzZE1xVsS2TWy4Paw9e2HJtItqAUUTWIaBhxSH6TzTTtAU1mxV2tBAaInSMqg90QvNbEZsAPH4esDxwYhmPTBvG9qmYW2yyfpwQuWq0hrhyqVLeCfUztMuGjQ0qbGSUA8rhmtr1JMR69sbOF8T28jAGfQxnmzQPHYn9SMPw3gAXpAotDsHuLM78Mpb+Bdet3f+ra/C6AeEwyksFoS5tWR2Z7aJJ7dxayPi4RQ9e47m5TeQgwUD74mTkXnZQVEPsjXC3X6K9ok7kQfuJa5tI0HQ6QHu7Q/Myj5xO7Hy5PifDffRG7kPjxhTw3Lc76q92/93+rMvx/LvBYhHnJ1VB9p/Il1SNEclFJTvJ8EWoyWm3HvffTzw0KOcP3fOklQyIpLWom3RzohZvn5nVJV30xy3TXET6TJFyzlZeWbFKpI5cst1Y4rj9vd12eshQmbeSHu2qnyvvsbkE73aO0myoI09eZWeV+iez1QhRe6oCE61wJH5WGodnow/6Q16Rnz6a6F0Cqa71lEKpW9I5mM2mxWUp88LeT3H9SuXqF1WFV3eOGhhqM2YrYmYVGyUsoCqlN3gvWd/emiZDdqDXEQK3UF+kezuOhE2NjfZO9jvFFzvBfvcPd67JbqEVQwSKCSa6+vrzGYz0+bO4kNt3rDJSyrZSJU3Qeo9GlKhY16WknBgSfZPqfhftjRzbnn/yLxJedxEtGRnOe8gLfSYFpGL5vUFIsPBAFWrUO89SoIQ7F4Z4uoXqVn8p6uMNgUDGkx5qloAMBuKmsYvQ5/2O+0ZDiQryxRbnotlmZbmo41IUIaDisV0TpjO8c4lLBckQD0asn58wzzgEJju7bO3t4dPcNZ4POLk6VOWuu6MnZoY0GAxmenBIYeHB8SLF6hbS+CoB0PYXCf4isFhQ/2coi+9hyd50etj4qimOgiEdkZ883176gvnkMmcSKSajNC7bkXvvw1/2y0MTp+hHY4YDitiDISmRcRT1QMzasTSWd10Zq0qzmzhJiOiVMjOIeHSedzZC2gl4Ae4QUVUJfRjK9dhJC55DtdjVUrfZFn1htL+6nki9lnvq0VIydIc9/fk1cks9meutdje3uaRJ57m5Zde4uw7b1GJFK+8LxxXA/zL1elSPH4tz5oC/XkNJ4M0JuRELPhod4paqs0746+Lg+SklbTBk/ITCKY08JkJPK7Im0yv0hfyvZT9fL88C1lBJI+yn9kXU+ymxIJT1lu/OBQoBnc+p4xR77lckmuryUaryqIfK+7L56OM+Q87rh8WE0nV5t3CcmUglGpY40WYzueouBJryKmNMT2kQsegXBZI9+AlAy1pfJ+sj73d3c4CprOEswY2hUKZzL5Wtse3hZMhqkVo0VmOBeXgfDewXZ8agGRxq9Ak2CrGSF1ZQ6rpdArpOz7Rbufn6CcOdAHy3oRKSknsFUcpMY1DTtnuUiPzmvCpWr9tQ7fonRQK9dV370Ncmf4cm0WLZyWvZDQcM5vPcI7SGxy6CmjnTBFnuDIXihrnWI/qp2z3bI/Z3XxVGdOxCOONDdSbktm5dAkXYGt7nZEf0Exbmv0D4mzKbL5PM5+yaFpI3sfA19SuYlwPGVYDKqkYDkdIVbG+vkk9OIkfj1gQ0b0pcuWAYfSMBxMiDnfYwDQgGgixQUcef8vN6G034rbWkWPAGz9EH7iPeOZGqptP0d5wHD8eWGyladFzF5C1NWRQ42KqaXIeaa5A2xKvHCKXDgnjIX57jDt3hfbEOv6gJfzwZeL5y1S/+knCnTcg7YJ2AD4qBmzmMfywLdl5z8lV7D7LyqO3T4qhRVpHV60TyAEXn4R0ibOm2MZSoeUReuxayq3bo3Z9p8Idd9zF408+w1cvnKOZzRBdbom9+p79a+eC2j58R4pnLmdmKRnOc0gqLk1K0aU27Vfdr4uVGsljis/mc3vQocZoKfN9eKrItasLorOhZpfQ4j4qCfERyu9yQkTBEGL33bKfe48uutzbqiiHPHY9ZX2Uolidu1UG+497fKyYi/NdM54uYyK5gkFpack6Opu8Vt5gD7aIgdgsirAU7UE6JKtGY4fbquJ8xdpkwtnz5/B1bcU/0mVrmADPgi/z6nQUDX3BHoKWxe2dxSwGdW256D0LPb1wercE68S8KQtjDzFaVX1OOFCxNr8aOnYCUu8KVYoyzkCDGkd/ipgmQZGp1lMmSF5XklqPBkDamDJpmrJ4K9/Vh0CCuZwYxxrm0udue+ZXugxr2zinAN7h1GjxrT9Fn81VUuwEJBo84FK9UIwpsI8QEm4tCZyOziw+g6gjXiA4mAHiPW44ZH00ZvvkCdr53IRXq0yvXOby5fNoaCC2VG7IsFpDa0+IgdFowmhtwvT8u0jwTEXQ0RjwzKW2rLxhxfqp09Qb61Qnt/ABGhlT334L7c4+9Rvv0wbwwzFh0eDPHxBuDVRq3TARQR+9B3/f/bbe5gtYBNxsbsSYs6RQhwPibI7UDpqW8LPz6GSAP3GMcPsJOHWSeGId5g3hx6/jXngP3Rrgn76PuHuI25/hNkbEVmFgQj04n0o3uvX4YW5M9mqL0JcjrNu8J/Pvs2Drexw206V+JQun7oSeha5HeShXZ1r1g83d40U2J+s88sjjvPziT3jn9ddAWmhtn6q1Pe34scD2hnQe06oiihpT3UN//SeZYumBCKmVty4bn6ohOXTmOcbkoSlQxZ6x2hP8mmpuMpQtaus/uGjZncnYdJjx2JJIdzH4T2JnOGrKei3wdkzKMCEXLmWhxWRIdmScWkoQ+llfhWy271lmFKMA3itxpSOU+upx1Pxe67j+IspemhvkYTeLVcjWcHKf0sBkaudOCYRe4V43ECV2kayR/svFGDg8OKCu6lLdj1jlaz+vu0jhlUHp/304HNK2LSFV/ZfOdWIWuHMObZNQz0JeLWtMvFG7u9KtMhI1QMCCxOIsl1xzs50k6L1LXEVWT2Pl9hRZoTGWzJNskaA5G80IOIt1UqzG3u+SMssKPI+COik1SeYS++KKQxnGYt1JhtLy4lYLapqwMkXv07gUzFsVLwbRaWJMdkkhZy6s4mk6weMtNdQ5FtLinBkGqg3twtZM7T06qTm2cQObp46ze/kycdFSqacVxa+PaXfnbB4/wY233MGV42doLu8iUdD5jGpYoSLU0Yyh6ZUdNtvA/PKCQVUxcHOa284gn32E+KvPEncP8T/9gMG7l9Dzl+A7r6GnNnno8U/wzVOn+cYX/iW3PPAAbpHqIOaBMKiIu/vGCLB/iOwfIm+ctQLegynO17RP3Es4mOFrT6tT4suXiLOW+rbT6NP34NqAHw8IB3NkYBlA4qxUufWZjaH4H0cenRXanSRSDOurdFHJIus2x9UX7RlXuRZkVQBdr3A56ll7N0I1cuutt/L4k0+xd/ki+/tXCDS0CZL15LopCiN7RhOiLl8zw7+ZJE3SGsYl5CSC9LpMruB85Rqdes33shQUKe9t+6Mvyzpoywwwh8nLEGOCtEzWhMaa0GX5UMbFgaZUf6JSO59ipzEZ9FruW2ppYicHcjdJnyHtpaaCdMwaJCO1V7QNugSTLceSl7PQrhcOy8f1ey69I8bYUb9k70PFSAUTambwydV9oavU1/6o4JGNgSvum2rKDGsXNkG+WoKtcqBJRGiaDhfs92tZxR2BLmAeQ+qbbvUQCkbhAqDJG3CWvYbmfPFeFa3mYBqoGLNqTCmFpNx3+6y4RQZdwRL/Ws7cIAniQlURrMIldcjpNrVI15ZUzMoMeeLTKX0suZM4kEnyLCkmprlKzACu8/gq74sXJZIXKOWagnUn9eKpvEtV+R27bIYJVS1oWqVMwDhvmapymUBbCZ6A6oIYrCanmRtk4qsavGP9+DGcrxipx21N+OO33+Vf7rzHXz22zq0hcuMtn6C5Q5HGcfDuWVjMaGeHRG2QQc3QeevwGAewgBgPiF//Dv7bPySsr+POnIDH70Of+SSKx736Pouf/BT3jZeQgzmLK7vIzj5UlgXpvCMeNvgoxN1d5PI++rOzxP0pi/Ux1d234I8dwx8/RTg2gekU+doPcSdP4B6+i5A8PtbHoA43HBl23zbJY6/M2sbimJIEw4c4LeUoc7QifJeUA5rqpq59wc5Mu9p67Quhpe9ch9Lpf57372g05MFHHuWV559n9/IFXBsYuFQ4rD2+spV79wVf+dzkcbLWO9jKTLtEpU+xlVaerfPSjTkkBeYTxBRiLKzRKGxubrJYLIwA0uWOrJqy0UBDLF5XLsWonLOsttgR5kYSnZNEqxcjeaFJvhZ2jKhlb2ZFkeG9bJg751g0TVGYZrCkNPH+OxcbPRv4XfO/1bEtIYKV5KTrOT4G5X4H12Qry6xaR+61HdPCRVLQXJaVi6oW1t/VFyj/liUpRkCpBoNOY0uHv4YQ2N7eZn9/v0zwUuA+fSd/1l8IaFImOTfdpdoXFasKTxlSGWO2mIQWeEucwRCCBYS9c/jK4i89Hwqz0JInkq+T7FEj5kz4aVbWyWb1rgLxqTnX8obux56ym72auNBvkEbvfe0dpLyHzW0K/jsLfoc2JNYCU0rZgnWZniZbaUSUgMassHxiD3ClLiMGLR6iAMRAW9W8NW/Z88LocNdYZ51P3pAVsmmI1seknaOqNIMBcb/lt8++w7fHQx5rZjwa9tn0E3zwxKFj6+YbaQ8PadsZzWzG0FVohIWP1Dccx99zG3Eh+Av7uBCI+1eQy4fMv/Jd6h+9DM8+jDx7N/Un70dffhue/32rRfn9H6CjKjGzJBizCUSncDCzVsVrm1S//BRh2uDiAnfuLPLceeIr78FdJ9H77qDZPaTaPSQezqhuOYMOBtC2cHkfvzmGtbF5hgmWuqbLctTR2zZ5D17r+yaD9UgFkw26IyXwxzj6QeH8b+itT3OVUe84deYMTz77ad556w32myuJ0aMixmQ0JaMsx18LVN27VoHpEu1L3n9GPZRkFr6s9aWhK8+Ynj2mDP5ihHayh/TtXDXff7eseVyavOxwaHIljZVEEqxmR0bxKgzhiJhCDPk9S5wqIyaa0KKEdqTQRIyRELt6njxGLqaaUpdLAyAnQogIla/Ts/bidyvz1Z/Hpff9iONjpSJrgkRipn0nBfuSYaxq05mx+djThnnsYyJNW4WucopvG0KB4EQsT7tOEFjuZJcp+auq4sqVK118gm7xqYCkTpIuTeiqWydAbBMtgoPNzS3atuVwf982oGpanhZsw1kcIgcG8yuoRtrENmqTb9aJx5RQJBbs06WCquyl2Ch2MSjE+nb7yiCSbLnkdwNHt5Yz5UvaMCIlp12S16Ehlme0grJ0o6Lk7LoxWWjeOdzAp4rjZMlhlpRLaFxWHl1Vdm9QtdtMaYRBrINkwirwzrHXtjSLgMznVN7Ya52rcJ4S/3JpLJwTtHZ8cGWHl0PDfHCMy40ym88J584ypMbVnuAcVV1Tj8YMxyNaL1R1TaVKPHWM5sxxRnfdjhw/g4YWt9jHv3sFeeMd2h+/RPX955HZFO6/m3jfjTAZwmiN9pl7iS+8g3//rK3f9QnxxAaurgj330p1ehudbFDfeweL3/82w9/8Ou3hAe6eG3GP3kIcDGF3it/cQPenxFffQm+8gN5+A+qB81fQ7Q2462bw0IovY70MjK0qg2RspM9LfEK733XrhpR5uQw9F0WUBZ729FJPMXyYrSo9mLTMfO+7qwKrwDBpn6wNR9z/0EO8+MJD/Oi576CtEY0mZ9pgKcmyppMlfSFdfqkp3pc5xkjGZbp/jIr3y/UzS0eWZ6n+xeMsjpgVmMvGVj9DzP6X69PM2MvyqIPt+/MQEtefAFXyPnDCoKpYzOdlT1nBck6J7lKjl4oek9Lty0AnRr1PUrqaNN2q0sjtmPuyMRvfuR+UomYIZDl/nVbP9dO/JCkjlU+assvTdpoyoYrCOcId71kAqws1V5zGGAvn1WAwYG1tjStXrtAsFqWCoiQDyHLgKjfUatJ1JNXF2G5Z9mr6C7+k8DnH5cuXS7wlE/aFEI3YUKRsdsnvzrIl1n8/J1ks2D1Cb1qyV5F3c8zFON2uNiskBc5tnNPkZ8sj3cjZ/1CEmJ1l6ZIjLGHCUbi0Lcp7pGsbgmXFVVUXnzErqRdYPcJqzGM5HA5SgkOXTJHbY+exjommfAFIVTNc26DCPBWDJMwLzDTmhg3ZmL2/t8sFlF2Us/MZQSEc7tNGoQqBGCJ1XVtTJEldaypv1clnLxFf+Cny9APwc08jkzX8aB198ATh7psYnj6G/uBVmlbxiwXyg3fgYErwA+Ltp6gfugeZBWJzgMxBNscEmVOvb6B7M3RrnaZtqU6u05xco77vQeLPP2xtIT64iIyGBATZWsO9cZbwwjtU1ZD27lNUJ7cI4xGuqoiDmnnqalo84OtCIZJUTALgyP2vPcGgSl9Q5PsVYKY42MuKZXVvZ8VT0vDLur7aW+n/rntia6p34vhJnn7207z9xs+4dP6sNUnLMkcl0al0FvQqLLZkrKaCu5L0kyy7jH5kgOTIxAOxNd834PJ3c6JS1EjlndW4NNG6N0pX4mCJNhlu7jIl8x4okLpmnMKOGCOxMQO1wF89hdFHgVZRmf44aN5/5Z2ke4/80/v8WgkYloSjVu/XlQ/+2cNiMQaTT7lniwbDEJOTnS3qPACrPDd5IPrWUF/gl9qOdM0QIwcHBx3mJ6nuI0My0mVIAB3cBl2MQ03o5oLNHNBfjfnke9RVTbtY4L3H1zXzxcKq2TNjaioGNSujyzsvXtbKQigQHmbdWefI3D61N0nJ4lK6+hDrZkcHa6Wj9NXTBOGlf4uzgKalhqdCy5AWJPldOVJQ5C1kSQdKaCODQY06TewG0IdJVq2+PN/9eFeJ49DVQogILkYqrAfPaGOTzeAI8ykaU9tsSV4WKYAoMfW3b3l3b59pNWSugXfnLdMY2RoOcBFLAQ7RegGlZkcDPLFpYTBA53N0MkEvXSD+0fdwd9yGziJsbVDddhq9707aw4CLLUw8cnLNcOydXar/9veIuzPknlvQB29HH7wHPbYNiwXNt3+CW8yRe2+3TLLtY/j/4a+hx9aReUAHDm45g9eKsDbEb60TT25ZZtGZLTNCvMf5CsEzRwi+y+fJy2P1OMrghuUCyFXl388cErcsnPtrAclrlqJkcmbWqjCSZHSFsqaPeNiVY1U45cLKT9x1N488+jjf+OqXWGREIWZW8LQHr6GoVt959Qc6Qbxq9Ca92A10n8cspVRmxSAFdYi0wbgPxeeSANsjrsfl18nALpkgUyllczV7MfRYn7uaubj0Tv05WIXLi6wpXqiW5zZvaSVskD7rJ0ZJeUeTo5ZQJMU2Neftz1i5iOkPwFg0mxCMBiGTgWnndhWXK6fDZZcrW0H9F1wp0BHMYlGNJaYBOY1SU2V6R7VeemVnVzEPdkhFTy61U45xqe/Bqua3tF8rIhQR6rpivphTbIsiY+Uqt7/EQlZyxvveVZlgl/nEJCmczpLKylmyK5rHM1uc2llSmWJHiXS61LSHaiQ2WrwmkI4Fln6dzcoiUSO3UzqliWoJQuYxHo/HOOc4PDxc2qiHh4eFpwis2ZedP2E+n9M0DbVzeBVrGTwZ0x5MUXV4Z4WqgYhEo0BxzpSdp6IROE/gQIZElPe1ZT80bEqFF4+vBohXpB4iUfF1RV1XLA5mNDEgJzaYPPQJdHefem9KXFtHX3sF/dJ3kePbyGP3IZMaf2EPebelefh23MYEFoH4qSeRL30Pff415I9fQ47/EL37dvynH2Px6jvIS2/gpgviX/gkfmNInDYQAzJvqCpH4yrcZIIf11B7/Pa6wYS7h+jmhOiF6BweR+uN2+x6j84D7hEykj2eZSWw6m2uWv8AUdLaXF4W+YpLe7X/DAXy6Qnwo6CnoyxlESG2C7a2tnjkyad55ZWXee+tN3EYFC6Fmv/64JjV+/S/1zcAjacrEGMwY1GwWF8ymNVw8OUxBCTt35jYL9oQS+dW67Nkw9X3PvL+LrUjaVwjWM8eQOiUGvQNNX/kOH7oeyfDoD9uQsp+tROTV4K1Yacvi5PXghaPMV3dYlDXuTzdR59ih/eeKrGMCkI1GICItdcVSWmU3eKL0QR1wTvTTz0YUA8GCUbrcXNh19XYuY7WDztmqWsWBT3LmdTkasUKsxoNKYPr6Pqt9CehnC9isExqSBVD4GD/gIwjd1Y42Z8uwtoUQ9/sWXZhLZ4Rk1fSWXfZS+l+xKybNH5VoqIxbLq3QJwj97fLuTSqasJftdBnqCZPK69iIMMieamtQgN5YYmYt9em5kLZ16rrAZPJhKZpSnJEfyxzYVvGx3PnyoODAxaLpqSaLzSyGxa8t3eFVg0KI8VxJEEyIcFkMUQQz8Es8AEt84Gtp8soF3d3IVoTO1cPkNEYv76BjifEqmJeOdzxdTi2xvjph5B77iCOx7TjIfHECeTJh9GTx+D512n/m9/BfeG7NK+8hf74DeTcAZ/6W/8273/wHm9dfJ/w7/4ScuNJWF+nbWa477/G4uU38Q98gigD9IV3cXsHhEHEDQU/qIiba8jWJsPNdeL6AK29pZzaRMLWGGnaVHzpUBVmdUVYMqM7iGb5yN5x57X01xy9dXCUtb66B7rPkpdT1u5yskhfYZSf9JmTxIHH8jmr9z1KuThvyMftd97JI08+hR8OcT793rAMVEOSCVqgn+4e+dp2fu49lIVp+ek9U1NQjJQunPeaJM8uMXQrmlL7c8dWS9LRKNYCwDkmkzXES4lLgEdS+r8hLN2YF+RFzGuJakhNG5UQLW06ZpEXdcloJcFvZgCabMkF6XkuQkzdJtWQG03X1yQfcsOvHJfR/F/uO5/pvVL2W5ErSEqrvj7tct3KxXKppbdgY4FgxDlGo3EnDNOCyZkWzmVKfUlNfzSlEXcKRlVpQ0sTLddbYm9x50lZcQsRAe/L5uptn5RinIVlt4jzNXIacz6yxZ09E402y6Z0OhgttG3S5i4tSrd053wf0jMbkaUkFzOnJ9tP0ADExG9kY5qx4uw6xwxziS1WNHsW9l27l+slGvQsDSn5XKaIUkFlp3O6hdb9WIJATMzN4n2y5oydYLFolpIrVvmG2hiXNnLMCiKll0aBoSqnWxg0kYGvUG/ut6oa2WgMoDF1IXUEp1xuA++rEFSQKOw5eGtxyH4M7FzZZefsBQ4v77KYzhmtr1NN1nBa0y4iwxtuwD3yIPG226nuuhMfK/ylHRY3HSP80uPw2YcJZ04SxxP8ZN162v/sHPVwQIiB2U9exY3XCH/vLyCffRx3863oZB09v4+/+zba3/g8evwY4eIhFUNkOEQHFdVkiJsMzSOqvKVpHzToxQPEecIiEEcVcWAwiFY1TVWjrkuZ7a0qVv8lRZBRjJJr/Vy1nz9E0Oe1GrC0XnWy+jBXPQtQ+LGKWlxRXv39lz8vf4/2MuPhiEcefZxb7rgddYp4h3jAa+kg61KWZUYGCgmtWBzEVx7xUuK02YuTnjGUs6tUHW1UmhBLOn/QyNaxYwyGQ/NEEgFmq12DL1VTLETLyNrb2SW0C5SQjLn8jp2CKMzidLJNsAaLBqXluRLbo+IM7i1yz9gxIrEwVVhJQ9p3vY2sYmUhEeMg7No8LxvxQko4whRSG1uCmsTwiVoplu+lFOleb5gPOz5WnUsUSjDaJUEpIoRFC3XCzHvCJmtUK95JllSItE1qRJPTgJOwM5gtZUNl9623MPsbwgRRC1GKdU/2WI6wyCeTCdPptLQHXcUrs5Bchbb61lEXV7Hfe5/dyW4xHXUYx1oHk9m75ap+klJJSi3RTYRgAtZ512HACtY6ucsMiWWiXe9+plzN5SYlh+X3BUQTt16nsJfI7sQGs64H4IS2XZSxEbcsrJY8QGcCSRypZXEXd8t5/S4EHgyOz88cN2gwynkamsNpYhGQZLol4SPGdPzy3hXecwOIFbEKzHG80cz4c6MhVZNITYMyvbyLE8fa8S20qvEzo3JvPciJbXTtEdz2CRaq1GFAuPU29PSN1Lsz2F/gmkDrApU64vuvAjC483aqd3bRJ28n/vovUDVKOHcZubxPrCtGj94NN5ykmXir3XEVMh6kFtoKbUDbQJwt0GaB35rA2oBq5FMvdQfimdUVrfMrxJFXj/PSPC9bT9c8f1WZfBTE9OGffvh3rue7Vym33GIZ4eabbuapp57l/XffYbq3Z8aX89bhNpp3lNt1dK+skILn3gnOVbRNLBBj8e7T8+U6sEhEKtc1HlSTY5cuXSIGpapqM3JMQ/WYN1Y8CiIGPBgLu5Nge9aEpskAw9SS8llOo1a1NZ97t1yFrBSFTDIwjY7BWilFcpHTsqeY0pjTnk6vgIgZcRGTyy5xpOWkqKyExqMR8/kckV6MuofAfNRx/TEXBHXgKkdsG0sV1ARViuMw1ZqgOSifYI2s8iSl7yYrOEpK9c0CLVvJScuWBk+9xdH/e6eF09+lC2IJUtKgwYLje3t7S0kGfXLM/nGURde3sLqF1UFi19q43bV75/QWufSEQmaUtsXZpTmGPM6ynJ+fv9o9fgdHiSSeoqS70S4LKEMW4iBnZOXYFSQF4u33i8WciHUhlZ7yWS2OLfMRLXU717jkhei8o1WlinBioXx+ss2Z119j467bzXubLaANhdaH3ptmusEX9/c5qMfgDZ6YacX708YsqUGFqz11NWCsDm0Ds51d3HBAdBE9f47Bj1/CV0I4dQM8fBf1tCF4R4UQ1cOJIe6E0B7OrFDSQfX2yzayt5wgPnwD2jTI+bNoEKg87oZNqFrC4hA5NWGgpAEX8IJWzopyvSe6BpxQrY2Iatxd7doImbdmgbbCQeVpXW4o3nns3ZxfrTySrUC+czkXPlJJHeXR5AC2ZGROj/7uUUeBhFaMwKOOvI+6dZxRDs+grnngoUd54YWf8NIPv29Wdfb2o5HTe9ffawlVSHCQWeSWIemkI32NSU7kfZvRFdsHpPXbGXngiJEEvab7cfX4Ffg7Zalm6EpQMl1NFuyaAv05riVJSWnMDA0dpJdh5Lw3De6MiNPe+kjX81IUlBksOUlAu/RpegtFKGNFL/4MXbzVZOaKEoyxW3AfcXws4koRa2KlMXSZJPbWqTLbtL4pjeVFH10KQgeSP68JAuqlKOccfLVJ6OfkH4Ud2+LMFj2GFcZlzWoDZYs219jkgexfs59YsJSEsHJkpZZe+yriu4w9Z/ivi2O4bgMlxRliWKKDqQcDxuMx+7t7VN4zLzxsyzahOEcb2iVqnc6yiMkwslRcERKHkZQ6JZdgjhgM+jp58iSXLl2y4GmKkXUCggLVkdahGRRXpyKjUImRU0JSjN42rldwbcsNgyG3+Zr1Eyfx4wnN+fdwocWpJhLMVKTonHU4rTxvHezxUmyY+3WCtgyDIzjPm/GQS3HB6Qj1YaCpAgvnjXG7EYYh4AaWgbN48XUmgzFyR4NWFRqESpQwmxpt6WJOXCSw2znCdIr+7E0bgx++iN+bocGg3dbbO7q1ijCskfEaTNaI62PCqKaerMGgQmsPlbfQcBvRprX2ALU3skuE4AWmDeIq2qpK1PNHC+b+JreTYFkDrGiD3to8SpGsHpInvNg8snq5Dz0+nrezbIAJ2WgxI+rMmRt4/MlnePu1VzjY26FJMBbaWfalNXmO8WBePyJFs4rk5WTx4pAyP6NGvKsKi3r+jqKoT3t7Bd0QSRlXSdHl5++8/QSXFc/D5ig37rPnzGZXKn6G8ndBSo1fqzHJ2J7Mk973clsAevC+JNmUDXrtzBShU2yr85RlX864JQ2fWBfBAqGVS1/HWoKP04kSY/8kpIF1rgj2PMgIDCdjDg8P00LQon0ldTNrEwwkzllMI2P+qonuQopmpzcQq56Gcy4Fmopx3m2+rIl9ynIiLUSXJssJMRrhZF+x5KO/ifsLq8RjspCXXuZYVqZJkZmln4vZ7H2Mzn91YI0/SMXSqfd2dqkkp+FK2fAZJ42iREIpVGXlGcEX6gwbvxTPSgvE55ofukVy4cIF6xPhXKmrAYuRZI44j5Tx6hd29o+iYLxn3swL+SFprs6cOsYzDz/B4KfnqaZz5js7aDtHK08KP5lHpdA6GASY1Z4fnb/IG4MBwXkkNjQoHvhA4NzhgltG6wgLcIojQgvSKvM64IOjjQuG22NCM0Nef5dQOWRnn1h7aGdwOEd3prBo8TtT9MS6sRO/95692DvvIQtf1kM1qIiTIbo+wq1PaDfn+DagsynV9jphOoNBhR/UltRweEictchgCKMaOXUcFOYHe9RvX4FTx4kTZeGHxr2G0eaUY0VnLCeQ9Kzn5frIq4yxZYWVDJ9URVmETko9pQ/NfITWUOgQiOz1XOM5tCjFvh9OlzGV3J9KhHvvf5h7HnmcH37zq3hxBMmdHO2IBdpN9yAZTWm/Z+ELFqsQcWjT2L6Q1LY7UcJkORG1TWNvWWBOIpvr6zjn2NnZscQgs2HtHj1F7LChw4k1R8yGnObOlJ1BkI1hye/spHhjscg1zZy2RkCbIPDc7joUNCOhPGCxFjTV9tj1LVSQg/IUAyIz3JtsSTLOJURGFQimzJdmW9Cj7e6rjo9VoZ/jFVYolDIOiiiyB93f3bNB8z5Z150Hk/HhjD/ahHRFkUBxWUuWWM8ydimmkxVJjImPR6zWzjZIB90UlxtSfxIr4KvEI04YDAY0TVPecdUDuVZsIXeyy8/Rd3PzHfveRJfunLNX7O/GTByTJYV5XTGR6PTvrx1ttiRFA9lF7dKESZkf+UmycJekVOHovPmS545ZKeqygtY8s0XRHeVBdqngZgEuZk3iOmoY4Bn5AQ89+jif+/znefjuu3nrH/0m7mfvMlzMoJJUpCVp0QtBA7V42pHnvb0Dvrk4YHdtA4kNwRsBZhRhIcqF2S5srEHsUYwTmYYGh6NuHLEN+JkS3z+H3wuwOUIu7BKHzoTFZEjjheFkRBRBJkPUCSeqW9n4ySZvTHe4+85P0caASzQaVW2B93ZQM6gGZkzFSHj/HI6AnzaEy3tmN6pDjm/ByW1E1vDzxt759Q+Q4ZC4MYaDKVXb0gyGNvZuec0hLK2w/tGt+6sVyup5Sxc88qT0P736vGt5QU4phYual1r+9sq5S3rnyOe0NachcurECR5/+mnefO1lLn7wQTISO2i3K+alrF+E3j6x3RCjsmha+kS1+dkKpKsG91irblJBeCRqy+HswO5VCUFb+jVpOUasZOQjQ+/pGdTkZj0wj2qxWJR4aB4IywCVogjzWAukeiRjfc/vZu8eC9QmvZEzAClzEfo0lZ0RLMm4B5MPKuRWtIAVo3cNwqRAhSXhSeWaS2f1uH7PpVccF2NI9S3SwVApIOdSyl7QuNRru7+odGXB5g2RCyjzIogxFvLIbF1lSE1V7d5Eiy30ss66gP/yZpDMM6TKZDRG8GUgV4++MM8voPZBsjZS10jnStYF2im9/jvFGBkOhzShTRQxFItHVyxEjWoQoiRUNaa/Owr1/3A8xOGYHR7SxmidNKEXZ9LeA3fxKY0BL11G36qwyME/wQS+FAuGorSvFZMCsw4ztYx3DhHPrXfcyS/9uV/h0aeeZby1Ses944ce5PLvfI0bWCAaIdH0aJs3SEXQiKfmW2cv8MPRCNwA11qMxaf5ic6zr4GYKGXa1qiD8MkKVEVObDH5xC2449tIG3DjBbEWZDjEhZb25hP49XXqJhAnY6ttcQZnHYuR4Xt/wE/CeT7/5H1UQZF2gTYt2rSE6Qy5vEN8/R3AoV7wbSDOprQIsj4ibo7NUzm2STMZI64mXr6C25tSndxGbz1lY3vpEnGyTXP8FOKP2L267DF/2Oe6unaPPHRJCXRzufzvzr7RlZOE3tYoJma68ofcd8Wtufqx6IyayL333s8Djz3Fty9+obAlq1o9jvgUn3Sd91RIxDOSUDKquqB33hP5BYX8ec8rVMUnmqsQQ09GLHt/JWtW82cmX7y3fZ/lSJO61xYiyTy4SXgXg3Fpj9l75iFzdLFPtBv/3KbEUIx+xm4kRklNHpNSyTQw6dq564cmSLAeDmhCU0hrFYPnQsiGQ7xmyGD1+BgV+sbxZA5FV1GZrQnALF4wdxMrzsk4Pz75OAmuQRM7a1YEvTTg0pegKBJSKrSRwuUAXaay76jls8cnJUaw7I4LXqxr4P7+Pk6qzkvyLlkrdItFlje0ahe7APBIUTbkBUOnMM39XvYW0mULb1lfWfYXX+b6ygurWKRqBJzeJSy/Sjh1svpJs9LBhfYcspIy3VcSfQsu38MXZd7d+yihdZRlWg1gc2Odz37qF/jUL3yOG268mehMEHjgsJkzPzlm+v6CQYigLZV4IK0X73DDAc+dO8vvtzOujNeoQ6B1Hq+CukCtnqoa0KgjtsJoMi4tAYIam0QUGN15I/Vj9xG2t5GqJojiK0tfl1qoq4H1+cm489AzUDvvX9z82/z2r7xFRDl14av8D376N4zwMramqBYL9MQGenEXf/GQ2LaEYzVu7UZkex22NvCjIdEJr62t8U/uuI0bpwv+6ksvc+K984Rbj+E0Il6Y/+wtDmONP3GaEBv6Fd2r83VkkLxYpcswab//Uv/PYrGvYFTX8o76XnSKUS/HdfPeOUJ3XAWLcfXnS/dCUOcgtmytbfHYE5/kpy8+z3tvv0EMEGJr8sBbr5SYvey0B6IGSqvjFIA2aCgaV5lqIl/vBGgaQmIM1L4yryQlKCXbuWSFSjL8stdkHoylDLehxbsj3i3tm9FwxKJtaNtg8Ut1BfWISTGVp8pDjsFqIoZ05D5a2ru+uOyG5DUSDTZ0kOsyC5KeZRomvzMCIiLs7++BgE+Fm5I0deYgQ8BX11fBcv39XJK71emGYB6GWs1HFkLdkS1nKQLSYDGzMHLNR0jLu1i/2WJPizGGYIVKqZ4lZqmZoKkQU58NlUKJLQKVODQE8/gkV7mmgXWOiorcOVHEvK3uvj0IKG+inuJStEBqGiOSuKBKA5/8vV6Hx+l0ajxXK3u3i390VbySlGKfeygrZoPQlNA2SOVKOvhVGzoPu2IwZTaAtLewXAdJ5ufQfJ800X3lk+M8+dykvQFNNQjK9voGDz3yOD/35z7PHXfdg68GtGIWUyUCMXDl/GW2J+uWRTVtEBeYS0Mda+rBEK0cV/an/PML53htuGHBfi8GFUXQFDhtY+SgmXLYNOyswVc/Z4H0X/2DhuO7wGBIvbUBw4pKhRhAvOAWsHP5IlcuXUQbhUmNDCoaTGC988Mf8pN3/oh/8Q9fY+8mS8P+r4f/DVf+N99h8oYNrNUrpbhiVO5+/Aluf+QRWicQG6rZAbq/CyGyP6r4jb//P+YnJ44B8JUzx/h/Db9va7ANqAvMh8pbX/kiJ+69h9HaZGl99Oe2E9SrSl3KHlwO/F+93pb+TV4kaeOIJmbhaxxFsNKJKCnOTBF4q0ZLXmfFQl99lqseVU0qxpZP3HkHjz79ac6efQ/mTSKTzHVi9lWXCCK1l7afjcP+/ihGHxTtmFP/RVyCoTrFXFWJNThm/jC7o68s2B3bUBSyVecnkR2Nc4xskCpoiMzms+LNVLVPdXR5KfWMzTQv4rp/x1T7lV9akxzECb6urAYvUz5p/khKo0FJiQpCMkhViU1bILCsOEu5SZpv510qiE6tzo9Aeo46Pgblfkf/oZr4apJwyQyiLjXW6S8OTS7lEkZKigykTCinGbdPMJcYrGEpxX3hZhPgfUeH4BL9TExB5sobNbrGWAZffApyk5RDTJlaQsexFFJ7VO8L3i0pxlO2hGpXx0MS4L5HJ5+tu1zoRb6OR6UrLiywXYxpQVsktpCDSrdRVHWJgqK/6HKRavbg+iKhnJfd5fT7zoIsE5vGhaTMIrF/hvZ44rS7RsRSjCOR2sO4HnHf3Q/wqZ//OR557CmGkzUUy/8onl1UiC3V2x+weeEKLgaoheCG1KrooCIOh8TW84UPXuM7gwGhUiSY6zqeC4ta8U2gdTVN5VGpQIT/xf9hky/+8hoAv/j5in/wn+zz/qVzvPmvXiF+dZQETq7Cdlx6/10uvvfOkWt9sr2Nf/KUGTL52UWZ6Qw/l+LdJQkJCN/5/d/jq//v//7I6734V/4yL/9H/0H59x/ecJqf3HsHDzYNMQaq4YiN++/i/d/8HWY/eZ47n34afE5VXZm3rDzyOiJl9vTIFvvHUdDYcmxxZS1kb33lWt11eucUt7r7KJ9bvIK+16I5oUX6NmdvDfY84mSYKpHJeMjjTzzFqy/+Ma+8+AKucrShsdoUdUWx5ku5XKUfuzVs67szTCm7MRt0vT0mkttKWR2MZoOxm/sc5/T53RIHWpu6XkaFEuFPXkVULcagcw7vHW0IlvmFuUdmZPY3TU8ZsrwOuiK2VKjcm7OcQpznwdcVEAmhSTHY5flamme17F8nQts0RseVP3NVkaUfdXysgH4/hlAEvvYmNBgUVUnSstL1bs/uufeeuqoJ5N912KGquYI586T0jxcLKG1tb3Lp0qVucMGsB7UgdFRz3ypJHlXyFKz4V8pESVpczjvW1tbYTTQiReymdNjSbS5o5+V4U6CzZg5JKRqEZZ6TueWaVyxFQqSAtaRbdNYdjEZD4z1TesrbFe+i9KbXrn1yTNlfLlXQ9zWLYs9V1zWL2byrsE1KoS9MDCwzZZgD8qQgImqeoQ85SyfdWyPeC16g9p5TZ07x83/ul/jkJ3+B9WPHixFS3pUu+28xXzC6tMNk7xChQgYVSGUBQx9xjeN7Z9/ld+KM6XAbCRWVC7RAK8KCyMg5qjjl9EJZV8/374489/SovP+37xf+T/Ic97yyy3BtAnVFGSARJCq33XgHn/2FX2H++nvUr57DH9+iXRsgm47jP/8kN33ykxzf+af85uY/hcrzlw9/nb/3f/yf4nUAEtFoySqZr+O9l17h/GuvWwuHNqR6JosB/fLahG8uGt4ejwF4dP+ABw/naOWoqwGL/Sl++zjHJuv8+Hd/mzMP3M9kayvL+iNhyJX0kbK+PzzO0l1jNXmlf60i9I/+du9T7f3u6uNIL6n8TT7kHqlORCjG0Y033MhTz/4cb739FoeHV8yiz/JUU1amdtmf+egnFOU7Z6/JF5g/JZRg+yp7CYC1AEnN2/IwmdHbGWX5T+8Nqj2YHXbF1qyclwwSJbJIDOI5+SjLpXjEyPQVsyamAEhMISihbVMbEFmKIef49Wg0pGkamrZXM4Oxzx85V0n+mly1DNgQkpEqf+aey4p7W0baUooLHqXRMO8UPLL6ks5VL10i00CZLEstPpFCCuejCfH1zQ329/eJMZoSSEdxuXPeenbpciBNcjaFENuc9F7+Z4swRPb29uyzFBPKVauqBn3FEIFQlEjBRFMg34kkaI7cQsIWe14MujJxPWsKQFKeff8cVcVXJszNM3EluQG1NgDOe0ob6V5xaH7DGCOL+YKSRZPGooPsckzFIARfefygYtYsusQAMZjItl2CMzRSe4cQ2Vxb4+lnP8Mv/tKvcvqmm5HKmnOF2KbN6jrGBLUc/nbvkHj5Cq1OWXOVpRWL0V1UCD+6eI5/sneRV8cTs+iqhrVmzokmcu/JU+ztzvhxXLDt4H93+6M81IK85bj5ouPytj32DZfgb165jbt/9V5u/MxT1HfdDtXYsrvWh1QHESpHdXqd+Nwr8P030MfvYv7iK8z+8W8SX3iJc//4n/G5G47x8N2fpb75Ju5eu5f5LT+lOnWSanMNGQ0tfXYQiaKceepRbnj8YWgjzBqkSUaC2tr6J6+8zn/81s84s2j5z268Hde2MBqgzprhUQmnbjvN7AfP8fr3nuOhn/8Fy0grPsKyAI/dUu55UB/vWPYoekpLepde2fe2BjpBa8JOl6531LGkjlS7HjDX+Ip0lgkQGQ0G3PfAg9xz/338+IffJSxa80aT96Cx20P2Pmaeh9hLxwVCYm4zPrAR09nMGI3T+i737b1/oCtVsH2uqVAxxaKTsTeqa0vySe6gdBeh/6JFbiVUBLKDI4WmpRhoS/CijYX26mZiVkVJ9hw7doydnZ2itIIaQrO7t1vQlDYnF/Rgy6W5S0Yo6fkq5xnUAw4PZyWt+XqOj+G52BtYFSpW5FbcRRPvebJjMPvHJ+vbFKmnrgeE0OIrK2iMqS1uIVVDykYJiXJg/2DfChKjEqOUCti8qEVI3dYSQWZIKYXOFFfuZW0Cny7wiP278t7I8EQ7QZw8seFwyHw6tWp3uvWR+8REzWwECebTfsYWR5p/OVCuaWOpRovdpAn2Jc07pVzmmp3099w2oM21QkrJZlkOllpio3lAsUB6llzRc+/VuIcIIWG/y95kViyDwYDQtjTtHOeFRx95ks/90p/nrgceYjTYMK+nDeatSnLXknLN/ThEYHr+IqP5DF9DDMqCBtQxrMa8dfE8/+zCezw/OcYgtGy0Ux72nl88djv3uYpbTx/jVXeB//PFnzFjSO2U9WObjNyY/8v/dc7/+hfe554bb+c//KcVTxy7g+HWMVzTUCkshg63CEz2Z+iggvEAgiJ33IA+fAesTxieGDF7/ifMX36J9fNTmv1d7rn/53HHb+Pwv//vWLz6CvNjY/zpU+jttzK45y4mt91GdfMZqhPHqOshMhygw4F54AE0CkECT82n/M3/5f+K07ffxp3/6X9qmyK2lg1YWfzvvs99lldfeYnnf+93uf3BB9g+fSMZg18yjPLS6nkgV3sby2sBOiXSF8Ll7CXjZFniLwmeFNtMHyzf8UOUjJTztTxa2jVXnbv6ChmuvfH0KZ755Kd5/fXX2Lt0mZzIkpuDaTRjqXTAJQXBUUJRwEkoq7KYNymjtJMJtidN+Gd6pxzwpnAkajHeE1MR4hzT2bRH9Lk6Gx3SkiFv15sXla6KvsRe0kNJNtzLSEpBEUq2abrGweFhMYCLXM37Mc2NoqWAuiAkZQ5zFmynfDbXNxmPRizmiw6qv47j+pWLStGWXSMsm/TM6UN2y8ShKfPHJsGazTgnLBZhCZoxSu2OGSsPmE9CP2OZUcw1U0Cj8eC0mjNe0gTlmUh70eIzzuhHQoYqTO87p6yvjWnbFl1AbvNJbwNODw9tMNPkuqTRM89QXhhOlqE96JhDpZyrK3CYlMXUWTgJQnJSrAucYzgY0LYtIQTrkZ0mN2pIDZQoizJfO7+/xFQA6ZJhkJ4vX5uY6TFM+zqV8r5k5ZYWWoiROz9xN7/4+c/z5FPPsrl1IinptnhD6TXK/TPerZKyBxcLqmAN5hTPeFDjRdg9nPNb77/HD53ndHPA49WQX7/lHu4brVN5YaSeBji9vsbps8pLdcUPLpzj0eEacRi45dvn+Sv/1bf4W0+tcdfwFDIY4BCq8Rh1nmEQmsMZcTKG7XVbC5d3TSkPK9RF/D23svUf/11Gr7yBf+cyWzecRJ94gPbiJfxwQHVym+pgjr72Hu1LbzL//a8zrQa0a2sMb76J6o7bqD5xGxs33czohpOE42Pc+hg3nNBWA3zT4DSiwxqpq5T1pHgieGHrnnv5zOd+gVf/2b/kJ9/7Ns/88l/CDwf4nouSaxayB9Bt0GWg7EP3ch8W6xZu99WltXy1slhVZEclD1zbi7m2t7J6D3rrCbXY4n33PsCjjz7Fc9/6OtPFNJGcCiLm7ec6FtPHCd7Ne1Fc6cgIkfm8TTRInfDPsFIIgc3NTSsIX+Quqo7KV7RtQ24vTkzthF32aihycGlsssLQ5KU4wfJczMtyYhlabez4wMR1LPQxCTUzOGV5vrIScY7FfE5WPnkgc7w0KyInDjx0C8kulJWQw+R9TKzmh9Mph4dJcfaMnI86rj8VOeU5p/vhXN8FTdBMJAmT3H6XUgcTYqRtp6Bdim2xysUV2oM8If1r59/1e1m3bUvJWsrWXdp4RhQHsW1Z0FKlNsk5EcD5isnGmLqOTHcOaDX3byeFZRKZmz0clvWFteItG8ncVEt7TMkHLs9g2qNK6Z6Xr2tC3QS1c9Y3m94CtDiTpDHukgLyT4EV0zgqXVJDblFggUZb7dmB7sNhIKyvrTObz1jM5924OCPX1+SVmVFgcOBoMubP/4Vf4zOf/QVuOHNL4jKyTD4zHKXLrKNvCXcJHBojzeEhLjSWIonF0qazGT++8A7vhgV/7fgtfH7zGGfGI4YCoTlktmgQPwK/waQecrN6Xqg8PznYYy7CGlbTVM0j7C0IdcTVlfVcjzZH7O7jY4DJGBcF3dlFm4jceBy8x0tFGAK3nGF8bBt3y2XCiU105KkutHDbTTg89cEevgm4VpktGhBHE2bED87SIlT7DT7WxNtuhPcv037xd9FYc3jXceJshoZIcGr0MY2tBSpBgnUtOfXJJ7n7977Mc1/4Anc+9Bg33HEXXeJ/Glu5WrlcDzT1oUfve0fh7+U0svW78vvenr0KZvkzOWx/bG1s8tSTT/OzV17h3Ll3aHMBsWYkoWOSgJyplVr0RiMVBUo5QSddpcR4civ13d29UqidDevJZMz0YJkPrDBWZAN3Zey6senGUKXLKLWKQcdwMESaBa2EXvlCkkPZOO0GPCnP5TKBrpanuxeIVfj392TIsKRDXJZnaWHFFMMSb/IpKsPRiMVisWREftTxMWAxiwFoyUqxyYs9BRExWMdlTvckUMyyd70+BEkAplcf1DXD4ZC9vb0i5PJR4CLvu26T0i0AS1W2x1kaVzG4QURYtE0qpLIFajQrB8lwr1LV6XL6ZPZ+SEIzC34nufmP3SyoZVcZlX2y/kU6YroVCyYK5Rp1XbNoEx1Fz6PoKxVbxAn+S++brVQBNre22N/fv6qbXEYAsqFmVlVXN7O3t2sKUAw2zIH6HODPytMMB+HTP/dz/OW/+tcYDNeIIXXP63lv2aq6at2gidDbWW3ObI5vzWIPTlkcHLB3cEBzZY+/fupmnrzpFmoEbSOyiFTq0dDSxJaBbxgPa447hw8tZ1V4+/CAbTdk0SzKszQhEOct6raZTMbJSwxUWxuotsQPLkIb8Ge2aWqhqsyM80FhtsBdOiAcX0MGHt9CuPUMa//e32b+7nnmP3mdxfvn0f1ddOipJlsMttYZ3nQCf//t1BcOaYc1ur0Fd94A75/j8L/4L2n+2RX0cJfp8y/z3v/+P2PtiYcYPn4fw9tvAxlS+RqRwNqpG3n4nnv58XPf5ftf/hK//LdOM9rcLEkdPYO0E4vFuOr9srcPjt7Pfc+6O64GdK6eUfv+suO0eny4J/MnVYDgcNx773089uTTfOUL74NG6/2TnkdYQRGiGW+p4wSp6QRmqdMphGSRayfKk0BJhqX3hBhS8o9S19USM3MWiQWuylBaQiO6WkjtDNgESdlzq8Fq6XuF7qpYqnaDVSWex7Yvk9Lbp/t0TOYhtwzIY5k8OY257YahU5K9HWcx8rhQQ0yEJdn8UcfHirlkzWgDZEojC/hSb1ISl1yawI6GZbXVZp6ExWJR4g65Mr9vTefBdJKLLEMamC6+0RfOveElRAUH9XBIu2iS52RWt4YqBdEakK4ORpJyIFo8yaA6gVyAhUE8plg6CjrBBHHuq1IWWlrAeQHmAk9XeSS0ZSxcyRFctngsv91SsFPzF3IWze7Obnnmbhw6FzgvoqjWwdPezR4kf55/zNHMwVbSIrc5+9nrP2N394Dt46O0KdOXnFld/cW+unA0qvXXiIHDnR2OaQQPcRGY7u8Tp/s8dsvdrE+GDBjQzmbWz0cUdYHKD9BWoZ3jRp5x5SE2XGHA282U+wReOv8WJyebnJpsgod6UDHY3kDrGp03MBgQvCDTfXRvCidPoW2knivqInFYEfbn6P4cPxoiazWuDYgHNxgiJyfUZ06y/vBdhNkcbQLODRAPzeGCKghtnKOXL+BuOYGLgbgIuJ9/An35c9Tf/CHutUsMZwu2vv4dDr/xHLPbb2f07BMce+Ypwv13gm+RySY3fuYpznz3j3j5u9/hgaee5RMPP0ysEkdfQur7iiV7Ek6XVUM/YfSouZG8S3sfqTvaSMj3WjWErnVctR77nlX/UT6GnjFr2jEcT3j0iSd55aUf8uYbrwOa0v9zvZbtkWKdxw4o0mQKGlzfF9bdc6tLTbhCppyCVlvb/9EyJdUlw6wJiUFEU/Alv1bKwNRsHKbYrJGSFQb5kOC+zOqelUqOieQeMFlRdV19+89Mrxlilq9HGABpyxq0ppbc4ITYhpQanROkgMqcAe/F+O7Se+VEges5PpZyyYvKJxqVguFVHkVST3e3JESdeBNWyWIX5yyAnA4nrkyO974MaJ8ev5zrKPUpJOoCl2CmLBAN/ulWrHib4NAmLLNYFUrUhVkPSYO79HkO4EuaxKjRiqbSpJDgqZiUi7iOWayLO5jirZx5XKEXu8iZbdPZrNcfgmSl9IRDTkvuFTt2L5a8yfS+bciUPOVj83A0F6YabUpePEuKO13bKZaGHHOKMtZjxcFrL7/Ej577Hj/3i5/H14O0Ti3JOD/bUdZqBCoqWoCozK7sEOZT9vYvogcLhpMJ2zfebEVwQQjtAidGnS7eAalS2AlNgBrPlvcoLYcaOb+zR7u14NLhDhvDCZPRkFag3lyjSsWIuohUizm6P0Obqa3Tg33i1KVeIWtEbYz5WBXGtWV9DQfgHT5BhARF8fhqhGIdJHXRUk8jrI+o3zyH1kK1uYl6b9X8o5rNv/1vsXfsGPpfPo8OxlQPPc7wxhNMPvsE7tRJZLxtFP2vnaXd+Slbx7e5cW2Dn+7v8J0v/z4nb72ZybETVjFezPKyYjpjYHn0cWVyIVONLs2RSNmr/Tm7VqC//M4+uGquP/woO4r+Lfvw2odeQ8xwtV5EkVtvvYUnPvkLvPv+WUQOaJrEyKGmgELs8eXlsXIxEVU6yLB+z+jrv68JbPO78YLzKf04KYIQczKCyZNsaxXoqgdhF0hf7CQRSn2daC+GxvKezwWR+E5pajGO0/NGQ5Og6/yb+RJz4Wf2mKR4Zqm0QQxlCjGWVGvVXHAuSKrZocgQk9HHj5/4iLm247p9HMkVnM6ewhgXemYv3SAlVMm0abIqyM2rWE5/y3BSf4D7iywmRaDalkFZ+ry3HvN1YwimQKKWLooiFNeU7EJLWmhLVtjy9c26EyajcYHKsmUUE9xHcseLRk8vEoJlgoUevYJTwUXLGss57+VeIsaFlN8jF2zmsUoLL3sYGZJTtaKnyvvUn8HccBexMWhDKd7KP/2WA/k76WZdNlA3IjQh8KUvf5FLF85nNUq/u3Z+/v5Pvl7MuKVzbN50A3Mcg3rMxsmTTE6dwNdjRGq8q9DQls2Hkupj0kykS9bOU8XIwivvTndpJaeKJiNm4BhsrRvtvXeGN7ct0QtSV1DXqIIfDpHoDIK7cEiMSrVuPe39aACVK2s3vSBkY8a5bvdMBoTFDLl0AMe3iFtjgxiDUs0i/tQZ1v7GryAbE6o7bmHwv/37bP8Hv8Hw00/jHribcMdJKiL1Q7cy/PSDyEN38Mlf+zXuOgy8+aPv8cYLLxLaiKZYosaYuj6aQSARa2nd2wd9gCsbD6t7B812PB20m9fYEZ7oNb3TlTWweu5RSqMol4+43srFy/nj4YhHHn6U++57kKZNLkOwuo9c1mDLv9tDquZB45O8UmX19ksxErpstuyJ5DTjAlknRVCQjpQFJr0i6gIbJ0kfkmcSQ7efQ+w4u/r3zynP2e/K67wgJdJ5bIPBoGv4hVqBJhbLswQrEHXE6FD1tp5E8Kmleh4TK/aMpW1KKf5UYyS4cO78dU3XdSuXoC3qQiqL0PQg9tokWCSmBZChm6BJGbnUw1l6/Dll0KUEsONKvQdYgM7aIduQCZatpW3K1ijnufLjxaXWoSmzTYGghDas0MVnxZj+tQKpFTpt4HD/AG1DwahjwiSLahWu3rwYwtuPBZVueAaI2gJRU8TOuwTbuaIAjoo/9S5fLBonwtpkzRRdsthIFm0u0irJFz1Y0jufgv9pPpbcaCnxI1Xlg/fe5Y++8XXCfN7N90ccPgUkRa1L5cZtt1CfPMlofZPhcA0fPV7Mw4up+yaAT/EyTQsdVrtlwqLyXIgNi8R15MQR2kA9HJjAHVqBmJu3MPaEwwNYJBijaVFvtpx1iGypRkNaIlQeqTyZJKoIW7sJ6p2RbbrUdqJyhIs7iPO449toVUGMBFHCsKapIr6qbe7GQ+oTx5HBEJ3OkcM5zBe0zZywMNbngR9y+1/7FX755z7DbXtTvvWl3+Xw0kVTIMn7X56olXnrfpt49472CEz99P+7+lg1GK7187GO4nxdv2LJ3mv+usbIDafO8ORTT7N9/GTZOyZSLGU4J6+s7uuc9Jvl1KqnVmBq1/ENFkWSareyoZq9if5Ydf/O/n8nZ/rjlRWX3bPbTZK8hMIzmJIH8nDF5DX1Wxc755lOp0ynU7uGc9SD2mRuz2DI8HtOYEK1N1b5me3I+z4/c0aWrtcguP7oTMrtzhGGGJUc8JLMjuak5GsH1ZTVYlEJYxe1F6mqqmhYgWJpVz0FkV9oMBiyvX08Paq5ik6t4M5f4/GLRZ6vlZ7S0pJ9t+i4eqDKMsxWqnSKb3Njo1BPF72qmW6/t6h6tTTLIsDGJJgGWFrYxWJgGSboK5R+EDZjyJkJlhDZu7KTZiOxFaw8yxIOntZWXrg+w2JFyXTPpZkRW1u+/rUv8+4bb1iBVXr/AjAcsegKHKAKzjNtI5UbIm6A+goJgoSGMJ+hoTVrOj2DTwWc2aoq/XxEDN5oLZ358sEB87bhsTN3moNUOeLmkHZtgNYeVzk4nFFdOcBNTZFIE9AQiIcz2DnArQ3Ag1TOznc9b7cIknQ4gSoJsKoihoZ654C4PUbWJhAivonQWGywrmvCeGCWtxOrs0kIl8YWYsS14GYNsndInE7x0XHP3/k1HpkcY+eVF3j+e98izmcp+7Kricji8ig6sDwbWQB9DB/hT6Y0rnFcc499zHuV66iR1lZVzf0PPMTd995n+7D2KS4jZd7yuuwUYb7n8n1XvaxV7y3vCU0JNjFGK5UIoWTE5sdbQj6KknJFYeR4SzEyRQqzeXcvG6k+fJ0/6/pP6ZFjJyIlbVhFjNIKM2CPbW8bBK1qpKmqhUtOMC8mUSibTEgyMBunq8/zYcd1KxcnNVEdbTQ4SJ3VThTNSaJJaVvLmCIzeSZKhcT+mNlDc78WE4JaFEiZy0cAAQAASURBVIBzjsFoyGA4RIA2RpqmJbRqtSjeoZWDgUdTu88oFhgLJCLMnibOC6sE6sWhCXfN2Wd9GGrVus/Yra+qRNHS8yxiCsIbTmUGZOxt9gypuB6UkizPvAnMm06LNQvPrDAKUpX+HbusE4/BxlUmQUqLivz9xPcWUBq61sWiy5CcJliS/sZIc1sUjQheHVBx6fIV/uAPvsxsum8B5HSd9KRXrZvS1AyAiI/BmImjM7JRyQrZWQdLSbUJWGaLc5WtjBCNT2rRMDdzxa4o8O7lc0ybOZPRGPWORhR/+hgyHiOJ6UGu7ENVoUNv5JUemLa0szmu9mjloa7xvurGsdXeu3VWsCn1ND4C8XBq62p7g1gJzBrivEHPXYIX3oAX30LeOmd5/CJo5ZHNNWRtRD0eUQ2G6OaYuLkOwwkiEKdzxsNN7nv2MU61yg//4Guc/+AdgjNoQ3tYfe7LkeEtFfMSr5oNvdoA+Ljeh6h1FV3qRHvUeVddtye003MuIRjXcZTzEipCbDl27ASffPaznDp9BmPSMKFYiTeZlPjkvLP1lhOG8uBlM7NvwC0plHRcK4O1pOCLlKLLvlmpxTLRJWNS+nCrGuyUW3ikXxVoKqMR5btISWYq70IHnUftfQ9FkmMQNXLl8uU8+nb7nIxQlFkEjWxsTojSpJ3WzdPHma+PAYtpYu5Mk9ALBpcB77laGpXYRlStA4cG24y5PqVwciXNjgh1XZsQXyxo29bqN2Jg58oVvK+M9kQ8qo6oAmJ2usbll84YZF9R0HvOPLnmdmr3LsmiXz7PFTy6CaEoQy0rwM7PAjrTdB+1WbvF0W0+pwk3T5u2j+nmBAgp1kNvg5Z+C931SpxGBPFmMXvvCzGmZEhl9fm0Z6mRt4aWkFpWurkNwHe++x1eeeklQtN0zAgYRPRhcImqMpyMCUNr9uW9N2EL4Byu8iYE0pbPvTKyp+nEUYmjct5gL8l9g7o1KoOK8Q0niGsTvBtAG3Dndy32NqhtYy7MQ9L5nGo8hNGgpIXmMS0ChuzBloFOYx0Nxm0Dfn9uhZHH1o0NdzozA0gEPX8Jefdt5O13jQUBDDLTSFgbEiYDYuXQ6Qz92g9of/Mr6MtvwMghdc3tv/wZ7gw1Bx+c5blvfoPm8AC0rMDyXEWcScps7Hnd5LV6xHGUwPhoRfOn92g+DiT2YVcRhbvuupeHH3mSSgbJqFKMwT0mBZMMrhQLKb3iQ45F9q541DitfL70Q2eY5pbq+e/ZO4raddBd/X6Bfnufr6+vLz2HZliMZW8rk192NmWudUljwzL0JsX9ViaTsXnUGYUxM53hZICIyfrMJG/fJxGBXr8h8jEC+lboWCeB0D9WMUcguY3mQoY2JIvfF88lD07ube1E8IOawWCQFI95NpUTBoPa2iynjK1u0LW8hChI7PUhyc8ty/8uXgpWB5PbgiI5yN29b84PJ7mXOe3YvA+bNp81fxI8lKC+mDcTuwQDIT2+y8HBjnrBQlNdsL/DOzsIrLyT9m4BPWECuQ95BJrYizHFrnAq1bra2ImkuFbadIlgE6VwqZUxsNfhYDrli7/3uxzs7lGaLCGWuXKkzMgbKDJYnxCHRnHfJXc4/GCAVDXivMUupN/dMsEL+bnaUFgigpbcd8QJg7UJsrmJH20QnYPdfWvqVdVI5W3TRFs7EgIqWCZbSAq79/yqWqDeMsblw7T+mkDcn8OxTXQ8SHPpwXvr6XLjCbjxZvTWm8B73GyOXthBXz9H9cfvwI/fJL7yHnowIzql+uk7yD/8PeT/81XCzkUmp49x98Y6w2bBD771Ld577adGG9NnytYPdyOu19L81338SaG3LuAN4mBzc4snnvgkp2+4FecrogaCJihXOpg+e8V9oZ7Jc1evv+q9lBq94nmZp2GGkZR1kuM45c+VqblWwkNGLEKI7O3tXwWt5cQhW5MutdTQ5Pkro+GQY9vbveuT/sxoSH6O5XeXZIiKt3fY3NpEgb29fZpFwPoKdc+chOF1zdN1K5d6UDMZj4sLubpcj7J+nO9iGqkG/qpBBbP2FePFOUgklYVF2ZHcuu6eq5hfsURiZFXRtW27FNBaum9P0dFbTEUBpQUJOY26v3DM1fZVRek9Xx4ru60pEJaFJZ2AygpH81hly7k8Y8+C7LnTxTpJykwForOfIN2fWnqIm1aQtHiLN5feqa/kgOKtlI2fLOE89pmG4pWXX+JHP3iOtl0YjKNx1eZYOmxBW71R9FIUsa9r6rqG5CGSxitGLZagbQhMcTthoYHGKTHVNrx3/gNObRxjbXsT3Z7gt7dsDi5cht09ZDzADUemQASDpRScKBKUWiorsIudpyTZgMjwRdpT/ep4AXS+QCZDOLVFXLTo4dwMkVFNXBvCxoS4PkFHYxAhXjlAnn8L985F4t4hsXL4M1tww3HqX/oU/N0/T4gL9IvfpvnP/xH+j55HR9Bow3R/h29+7ctM9/a6+foIvbEqJP/EQfiPcfSt8WsptlXh+Se5R9cSQ7njE5/g6U9/Fjc0aFScBd5VItFFoo+ojwXSBq6SB/2jH/ftAue29ovRCcVz6V8v7+lSE5fkTEErenHl8i4i9NmG03btHbokH4DSKXZY14SmYW9nN8VNfEc/RTJy8/6PliI9m88KxVTUlrQheP/9s1bfIwaDh3bFYyoezEcf161cFrMFh7N5EfJ5OlYHzFw1bznXIqXPSl8x9Os2cmFkuRaS4jVQ14K4ipCsSlWlruvy/dUJ8r7zjPJnOcOh/5xZgFR11W2AnsDNMZrSCTIJ8b7lgpBqaNKCy1Z4iiVloVgshLTQvHdU/Syk3thkD8gWbB5kKc+Xn9GeyVEQm6JsTPhJpg9PlpX0xj1DfyJC7oGX40Sdg5yUYkm9TII0Kx5sHP/gD77CxQtnETWPMT/G8iHJsMuKqkKjT28bjDhQFYJ5dq12wVIzMozaRZ3FV9q4YK9tab3HERn4isu7V1gfjDh2/CTjW29ksTGmuXwF+eAi6hxuMDBjZZGIVJQU/8DINntUQtnYzMovx7sku21q3wkptsh8gTu1BYMKmbfIZITbHFvMfxFo5w1M5+gi1dBsrhEfvA15/E7aJ26Du0+jY4+7tA9vXqC98SThl54mXj6gfuVtFj94DTdbECpjG3/5+T/mjVdeITYtWekKpPjVtYX0qkDt4/c5CcRJl5hyLcWg0IsjHH2vPhz9YYrsT6vkilcRA8NRzWNPPM5d99yLiLP26Gkv5X3Sj6vm7NVshOf5z+zJ/fFahdXtOikzLf2nsYsf5z0csRhw7I2jkOKekpMLkmyLXWrxcgF5fkAbcCeum6uUoDSeTJZjvElm5WNJNjuPE7/sTaUM4Bhikt0GpXtvxlXfaF8i5v2I4/qLKFM9SNCuentp8SUBnBdnVKVyHue1wAvSUwp50vq96svCz4SXAk0wAZMriXMlf3/gVFcaiPVSVvN1+4sltAGJylxsMiR2k25Ed10+e7+gMysds3IhSMxmSkchboPV5Ztrl0iQ/FpblMUVToudvNGkK05VyQiVua1KKlQ1PHQwrDmcTk2J50reNDROxARrz6VeSlhAGNQDQgxJZiZhU9xpTcWtVqQVUuKxqC24NgbeeOsN/ujb3+LXfu3XGY0mFIqfpQ2ZBLIkKNJ7xNdp8avVS8VgMZH0nfaIFgQBZThY4yBOebdpaEZjKiJbVWWUQ6MB9Y1nCBtrDM/tEM7vwfEN4mRsJJnTBYyHBjciqFPr8xIDxhqdWuOaBVFadptS6da4qFpdTBshRtgYI2sji72MB1B7816cqfVqPEI04mtvrzwcoFtryHRB9cfvEF97n/jWefhghwal/uR96OeeRO+8lfgvv0Lc3efS5Slxa4gPQjs94Gtf+yI333sPm8ePoxpxPT67tPyW9mUew/54dkcSamTFwYchbCDdcKwqn1VFsRpP+ChF8mFxn2vBSb0vc/rMGZ546mneeetnHOztmv0lHqeJUj+vfWdFx+JTlXwMZe+U5oHFUjrKy+kZUpr3TCKrzTKQnPUIxB5lU88AM+XUGdqS9nHbtnjfkzkZQCkGgf0/K62dRJsl0qVQV96zWCzKpCUbsRi0pD+tINOuaG3CM+JiZq/LNWrl9tlw/ujj+mMuK8qk7xGAbUKvlsHkESpSV7ZUMxAl1bj0IK+jYjXqBbxDnWe26DD/PmFj3zPpK5Sr+XWO3gD9ug+gxFey9k/LB0l8WDkQCCYcnXMl46qv0bO1Xe5tN7TnFNvGMWjqHwEiDpeqf51PNRPp7s55RHIMyIpWY5Fztgjns4X9PcQOr9FuEZXgnmpRfrnplwpoSr2NTo+EUWOGApJF5KTzfrJX9M2vf4P333kHtKPBOWrcVe0ervLESUX0lWXtOTqIQ0GDScm+Rxo0lsK0Dw73ebNS1Du8BrbrChHwgwH1qRNIC+2VHRhWzNeHVE2EgzniPVrbNYNGYiImzU2pNAbreBm7TLuc5m3QoxjkSPKyFFvX62PUOYKH4BR2D9DdA1zEAvWbQ9qTGzAZ29xOp+gfPM/+f/s14pvn0QduQ/7qZ3C/8AjVnTfjqxESID58D+4/+nfZ+9Q97MeAC44gSmwXvPrqS/zkBz+gXSxQzcWsfzIPQHs/Ua+et491raPm/E9xvY+6Vx/ujjEyHI546JHHue/BR/FVTZ0SRMza73n5aX1Zsz2Dtr33VL6icpUFsqOiuML20V+POY5h+8yMFUMCbBas6DDtb+dwzi89e9Rel8xksPaN4b5cy8gIWTaVWFvCeFR6+yV9Ny6PDUrnHYn1sclF8Z1XIkXOmaJ1BZrLMgigrmsGw+F1zdF1ey75KNZlj0QSsBcMkTZYEqSIQ+rMdgwhtEuWQd+67VemZrewTXQtx7aPcfnyZTINdqY4WXbzU7pz+rtq59Hkc/LfnXPUlcFhpQwza/VsqcTkSqf7FBqHLJBixLWxF7wzjDfmPtySaRYkXa5P0y9lUZqF0+/DoktuehHIGTpMbrjJt1gUUIZHoEsCyB5WUQaJQBTJFo8wm84sLhbVyBt1RSBkRyx5NprGzzwps/ounT/PN/7wq9x4000M1zayI1eObPfYJo1UowFsruEGI6pmwWy6i9fUCyhiNSJpM5bnSHBUFOHiwZwLlSMI1CEw3b1MHVoe/eQnibUjnLtEFQS94RhDhLi7jxsMoR6iMRAdOKlAJTU1q8sGNA8qPXBLGUuy56lKaFKCQW3QQQ1oE5DYoIczi6O0Ab+1Bs4qseQQmoMdiw9c2kNiYPxXPg3bExMQgwq97SRNbMzTnDdUFy6huw3bjz7Op3/tIm/+7pf54+Nj8DWxafjml7/AvQ/ez7EzNxFzm1xd3Rfdnj3Ka9By3io8+6c7jnqGjzqOUkzXA/MtHSFw4thxHnviGV568QXme5dTwSFl/2gSqLheN8l0wnAwoqo8i9AwT0SoISUW9cewc8oVIRuFMXccpoxkcjlErCYvy6cMm+X9qhhcblT6aSySQrGGgNb62NAJV1CW4m1JTgAyJCVqTGIpFyYnWWIVteQutiI+xUo7eFxykSgAnpwbm8skjJ6rva45vX7K/SycpaO0zsuhyGQv0GvU4xQ0RAt8+6oUH2b+MOiEVfH9otKGpvicWbHkeEpfYXQu4/Ji7p+XXcL+kZWI9YnJrqbFKBBKLCLT4udU6XSTwtcVkjdQvKmk+Po9D5a9q/y8naWpmn6XnZYVl1/IUFgO0Jur3/nW3ULNLrm9S+hUlnbtkUtSgZAComoGQMyLN4+NpEVJmffc8dKJpLRwu+b3vvMtHn/qKe575LGOlyh5hgWel+RxO4/bWKdVQQ8PQBtUDTd3aqmVBuHlZk0JbtCAOriwt8ussqp+nDAZDdFd5fSpGwmXr1BrQE8fxy2UsLcHG0MYeCqNaBsIFdTUxHljVfK6LFazgFhaMwKEQGxapGmhSnh+UGhbZH+Ku7yH1I6wmOLm1nJWF4EwnREuXIDvvoQczODOO5HPPGxmRRss4HzxCrx7Hv/Ts/grB8SLB6jUyGyP6tYbuPNXPsvP/fgl3r7yAZfrdZTIu2+/xXe/+U0+95f+MvVoZASrdFDK0nq/xu/y8WEgx7WgqutRHP//SBq41nuICE6VgfM8cP9DPP7YU3z3W18zpR97XnuC5xfNIikHMxa9SqpjGzAcDJin+LKkxdAVLtrhnBRlQG+Ni2bovGcySqcIkvsE0tWP+ISQNJn/MEsHKQCb7cN0f0euWXMls7bEaZNX5MhKJoUrEpytiiEeKc5S6vQyPCqgqRFhZ6x3hvlR2XXXOq5fuWAPmi+uisUBRIyWIk0UqX5F80JQSS1uhdYt4+nWqhekkLotu5958fQpW1bhObLQFUvBFRHqukrNtSyDqTCNxpjYjfMmpEv5VahdVa6X+Zu6wFpn/TjEUg/V2g2XBZ7+y5YCSQFLj1obrLGQpNYFol0mXMZFy/sHUtaHdl4LimpYCvZZLVHP6lGoXEWUXPdSlmtRUJktIb9vhg/yORley94bEpMSMhfba3KdHewfHvCFL/wet919N2trG8k1B3GdAQBqNDPO4SebtAoutBDynFoTOVTxJEqaaB6SKmg1IBJ4Ky6YugpplE1XsTWs2QfCbGoV+ye27Pn39whEquGAsDbEBdCDBbLh0dm81LZoBNqIVF1LBYQu2CsJ/mwDNC3ifJp7RUKE+Zw4nePWx8wPdqnOX0A3NmgrgYuX4NW3cD99n3jPTeh4YGvjYA+ZzQnvnaf98evw8jvIIuDuvY0wmeAevRv32F0IgcUrb1HNlIf/8i9xxz/4BxxU6zROUCq++Yd/yIOPPMnNd96BeEkKZlngHhWj+DiexZIB+a/x+DBleC2lpQny2trc5KlnnuGNN17l/XfexmvefzFBu55FHpOY1mVSCrP5nPligUtcXFHFuMhctz6yQahq9EbGiCHk1CWvkvaUycegqQo+w9TpMKPJjGtDgvqyLfWkIsWqo6a+LyZPu/0ckywxWRe7wUC02885USGmAmW7Rjeu2QCpxKNOOH3mFJcuXWKxaAmR0m+rSrRM13Nct3KpU1MoCrZnlq81t3JoCIXG0DSilAZiQSMhdLESsID3eDRmMZvRFpfLeiaUAelBW9DBZxkaO2pziAhN09Lls2fsMF0f7QRmEdYk97VLs8s1Lzm4nrFahxBaSyqo6rooP9+r/7HHMus/JLfcJdqY3IKg0O4jHTwhsqRgikto9hUkuLH/rkeNQ651ETXG6rquaeeL8plzjpCCffl6MVf/955BMl4AaBTa2Ka5z/MsqDoq53jlxRd54Qff5+nPfBZXDcHlsddlweQcMqhR5xDxiBjGLdomCCAZLklJC4IXaGphb7Hgp7ElVBNwcMdcODYYMvMV7tIu1SdOowFEF6CR4WRCiJHqsDVCwe0tWm+Ofj2yTeS8SwkavSLgaOaoK0vE4DCngnhrSezalri/T9w/xI1GLA4Pqc6fg5+9Sbz/Tnj7HZo//DH1qEKefQC2hrY+Lu3g//k3WJy/jLt8YAbOrTdRPfQJwmN3IGeOEcYG4dEKg2NbNBfOs3XffTx08gyv77c01YCFC+xdvsg3v/41/spNNzJcm9CXXP0klLxWjvJgjhITS95AByotf+/P2Cu52mi89nEtRSNq8A3ec+fd9/Hw48/wwbvvmTtasg8DzWxmsG5IbMCOxIreAwRUS81aN25JNhTrQ+ka4iSXNwnymOOlvWBmDthDNnhDMdi9WOw1hCzso7WJ1wQX59v3CQ/pjLdCz9+D70zBech9XDK8K907iginTp3iypUrNIsFOQxw8cJFM45VLfNOA2tra4xGIw4ODq5rnq4/5pKFDp01NJmMOJxOqesa8TXNfNYFoPLXSsYRJR23qioUODw4wJOahqUMpLzI+plN1zry57nAKfPzFGyTLoZTVebNEI1sJruWSFpD2tWl2Ov2N1WyE7KHljeCYtavgNFMpMwPYlkMVf68XLPnZmaoSvPprhQN2ueu973OM8vP1L0rR/zdLCOfYcqs0BBC2yI4S2Jx2YLqK/OsaFP/F9c985JnlRRxUCU0DV/7ype4+/77OXHyDJSxOOIQMY/V16nTXUTEvJXKeVS9ZY8lyysE22gHl/a55GuCeGoabtuY8O6br3H/LXeyfetNtGsenbb4ADIeEkeVeT4hUKlLClTxo4ERnw7TGOZ6mpwxEWGpskdJzAFKKwnO2pui+4cWvwkB/+5Z3I9fpXnjHfwfvEJ7YpP6049R3XMvjZsSX3kPFg3UnvDMfbgbT+C3NvD1wLLxQoPMA7p/SBUjrhoQEcLGENUtJouKe+69n+rr30AHx4hBqAcDvv+db/LYU09y30OPWCKMKn3YeXWvAEuffRiEltdmHo1/U17M9R4R8JXROq2N13jiiad55SfP8+Zrr6bMfZcEubf96qwnk0albSPeO+pe7DEboeaxGDQeY8RFTfAaJTsyQ80ackwnMwOUnbqkok1MpnYfGlJNjO21GDNaIGgIxqdYdck+HWarbGxsMJ1OCaErfch+jZDCwk46aqklW8HOWiwWtIuGyuXW8pHYxmRjpXf2junhjMODaS+p4MOP66d/8SR6+y47azqdJgjIWuyqmCVY1XWBDsAybEK0h3aK5ei3wQRLelfxBpnkhb25uXlVsWSOu9jk9KYqKZgQY8lwyho8e0vDnOEgGbxK//V3Te97WYqmnAwjvkzP5r1nMBgaVXUSiDnDJOeg59qBPMnl0BS4I/FDxRzX8Iimb/UWT+8Vl8ajj4MiqdBRMs24JqUihNZqLfIGCIl6pFTeq7V+retBus+y0jLPbLk4tXsom13T0J7X33iT7z/3PULblO8u2aLJ0JOoxhaQq/GdZak4V4NWiU3b0c+MiXXNCweX+MCQSwaLwO3rm0Z4Oh4StzdxV/ZxswMLqs8DOmuMoLJpiWs1UdvUcM1DNTAjJq8jGzgzgCJoiGjTmpKLagGjGPH7U+TsFfTSHq6qiSMPB1don/s+8fsv0L7zAc3tx/B/7Rfxd99E+/5b+H/+deJXfgRNAF/jqBhcnqGXDwnTBcwjOhggkxEyGaWhUpQFnoAfj2hDy82PPsIdMeKbQ6KraWNgsZjyh1/5Ivu7V2x/9Wq6Vo+lZI3rOLKA7VVbfOT5qz/X+v3HeY5rHVe/o3me3oEnctutt/DE088wXF8Db51ycxJM3v9OPM5XRtgIpSvrkkckxm9nMRYH4oEE/4u1lAgkSp9eG4z08omHrlPcnZcmKbboOwgTcN7OCU6QqqLyFmMsskENGo8xcHh4UArFhY4RHjWo2wL6AStEtxIP7yq6TDPhyqXLho3EWGSWquJICUOJDsYMY6w27TqO6/ZcfEthPLbFEQvut2jmyVW0Acv00Jqw9u2tbfb3d4mJm0usy1exhroOct2kHBwcLNWr9BdTtsSzMC0wl5IaClEIJzMNzeHhzCYyESnaH126XoaSimdCHsxleK6DG6DzVzuDwKwcUq1Ezysu7xfLQjPVXhf3WvJ5KUW381RWVFQylMoCli6ImAyolGXWMReYZyKl7bRmxeuF8WjIYj43eCiluptKjeVdO5gsGWTZWEvjIFjB7Ne+/CUefuBhbrrtTmLKZMsIgkMhbZwMBaimmqYIkFplJ77rnJTgaocuWl6e7bI3WUciDFW5eTBgB4W1MXLuChKFuDZEhgP8yS3C0OMOW2RYoVWFVyXW3mITlY2FdxY3Uo0QAqG1tFXbRUDlaWnhcEF1MCMeHCAedHPbrOHDS8x//ArV8z9jJlD/xc/jH7mb9t0POPzn38PPIsMzD+JvThT98xb54DxxuA5n58h4n0YapPYEF5HJCL31BFIPgBFosMym7RFRI0PvED9G45xIhTh48SfP88pPnufJT32GmIwp0Qz3XntPXw+0FejVb/0bPK4Phsv0TKAxUHvPE088xSsvvcDzP/oBlaMHO9mfPsFTtRdiBvZNKJWaH5cpjkTIeyJixrZLnkKuCctJTHkjWkxXkELTnDK7cvWAWPKT+MpysxKyIk6QxMCMdCwBuRwgx9UXTbD6lLS3YjTQoBp42tCCy3UtFPmiKZssG5glvhgVN6jYXD/GzpUdorYIcPrkaa7s7NImo/HPPOZSROiKxVFIIlOcpV9gZYOg7O7smJdoX7DU3phrLjqhHHKWxZLVHBgMBoRgPFm5al66JyoBf7cqhEmZID6NLlqkvYqWZj35XunCGToFOsWSqSaUTqravXMqX2IMICnYjMXm4K8a6uIgBfAd1oogE96lcU7Whpflmp1cuJThOs3uak4N7sFX2QqaTCaoKtPpFFWXNkgfajNqisV8bp4nymA0QuctbdP2niEr0xw3yyOf0qjTxhMRzp09x7e//U3+rdM3UA3HZA6snIwQU5q3xpYY5qALgmZlRrEoVXMnQYf4IZd2z/NWK0Rng7jpPItmBgqbfkDcuYiur+HdOrq9RQyKHCxo5w3+5BBpA+p9F5RtA25QF+dQsDqtmKrviwcwa6mmc8J0SquKjEbIxgQ3GBLm++jP3sH/4BWaO25j+MwjRJ1x8Dtfh/054089gRw/iWsjOp8ilaO5cpnZV75lkN9wRH3LGeSOG9BbTlKNJ8QW+PrruCqinzhOuOMOSxcf1uydvciuzhBvfUU0xTKh5Q//4Kvccc+9nDxzAzGSvOxlqPd6vIXV2EyBUq7aWX/2x0dB4B/13aOe+dTJUzz7qc/w1htvcLhzBQhLsYlIJIoxKZuY6HMIUrxtloy5DlPQHMPNKzw/h3Rwu3lIGXU1Oeddpq6xB3VIF9NOwl7jcrwyG72FGDOhOFkOtG0LIlTiGI1H7O/vlXdo25Y6N8lzHWSdPRSSQpsvgrFbSBcLvnLlCk2bS0xymcVHHx+vziVr8lSECD34hFRglgZ6OW2tC5ormJZPfy8BbVJBW6L+6Lv3TdP0FkNnjhUXuyyWzsPIC83qY9re4syd1lJSQn6p8h5JkWjXx1pRq5HoXTdo6Cro1WIGebJM90gvzTkvxs5aatqG9c11nIP9/QOz/KMW9lObyKt702sKNtOD/TrNJEvsqdPpdCWG1FdO9pWQsveygbBYNFa9LDltOs+OrDyLFM+qr9REhG9/65s89vgT3HXPAyhd9ML0kLVOFQ0pXz4irkI0B48pXnEpKpWKt/Z2eLcaoihVCDw2WWNxZQdQHjh1E359Ezcc0dQRkTkEqFtBh7WRSMYWravi1rle1ou1uY5WiyVWJEsM0ATC/hRdNFQbE+LmCK1rNDqiLJDnXyf+4CX0njsYjAfE7/2YxU/eYviJm/Ebm4TvvkT1xH1w6x3o9jbqPdWiYfDeORZXrlDPG5rnalibMFhbY3F8g+reO5FPP0Rbb8KXXqWaPod++m7kwXs59enHuPOLX+KdtuHQjyyNOQWO33rjDZ7/wQ/47Oc+TzUYWUuCDxHWHybIlyGhP71K+bMO/l/v/VQVX3nuu/8BHnz4UZ779jeQEDGiVp88kK7mxWlGRZLwzdtK0w5Iwt/kVlLdvXNKE5lcuVDcoOSdqBnjbTS+M7BsM9BUtNnJtiwz+u/iUhynoCnp8yJ3nBmsbWjZ29vFeaGuBszni2Lo59hRm+pftjc2OZzOWISWKCAuJR7RGRhN4iBTtZiWu86Yy8dQLhkW6lvTy4I8u9A+v2waYc3ZCqmGIXeI1KStu+C4bYhsWZSAfVwWaOVImr3yVRl0Tb1jVuMTZXLy73r1LTm9L3MRqajRf4gQxHK+YwzFmzEhnvrM58WhAWsHIJZDnscm6wK1uznMc/POWXfL/Hxk+ElLcE8EqromND3lmISjDXmPVK8n3FffO8/fcrc7s1ZKcDcZe6FpiwHhMlxkg93DivM17PcZMouxRcRx6dJF/uCrX+bGm25lvL5RrLGiiGIwt7+qbEGHtLokpTCnAbNl4RACrx4ccLk2j2+rbXl2cpxqcQUQqoEj1EPa9TGDwQCZNsRhDUQYG6mfz/dKqcTU1mlS8zulVGwJSpwviIvGWiGMB8j2Gro+Qmuf6GA885dehN/5KvW7l9HomF28TGhn1BvrcHmX9oaT1I8/SZgq/pvfQ69M4WCGVBO8TJDNyjZ7aAgSWRwc4mZT9IPz6Pefxz/5CPpLnyW89i7NP/wicvcfM/yNn+PxT3+KF37/X7GzUVldmZq328wX/OHXvswDjzzMyRtv6jzBIwT79XgI/bn+160crnUc5b18qFemZrJubh/nyWc+yeuvvMyFs++VUoC8ukrCTXIvBDNi+w3HBDH27KIw0vWl57XkPSxgHZdSnUnyhERIqc8pwwshtxQ3MMBQmRAjhF4ykx6h8HvvnT8xoyirJaufGY/GhBATSaUjhGi9flxXL3PzzTfxxjtvJW/JEhsyGpRl8fb2Nju7V+y6/vrUxnUrl75e7TSq5Hc3YRG6JmAiKZOqUHeAxARdSUf4mAen9pVpzzxI6QiJTE3VKK6XBznDcl2RZ2Ys7W8OlzFJ8iJMKb2aivdyeq/a9zMbcu5VkjRfynZLUji5ud5hNMSYUPQu0TuUmJR2fF1RrduhdoozxJxeHJOADmXxZFrvKHRUMyKlx0vu3ZIXQExWTJfhAtmx6Wd7mRudnPleKmVOXlBgc2Odw8N92jZS1/USTYRqN/cZ6spGR4yBqnY899z3ePqZT/PAI48j3hd6HY2R6c4ek0WAqsZFj/dq8IFCDlR6FKhxkxG7uzv8uFkwHw3w4rmphrtPnuLtd6/YymyUqlkgh55Q10bMJ56mNjbvat4SBx0DtqZCOhVB6grJ3UWb1ggtm9bW63iEbqzRjiqcBFwUYtsSLlziyj/9fTZffJ3Dg33ibEE8dZLhXQ9TP3gP/tgxePt9+NoPqLY24PF78XfciHzvt9Cbbyf+J/8+o0GFeiWEBV6V6QdnCS+8irz4OuOdKXznR7hX30H/7b9A9R/+NQ7/u3/F4D//J9zz13+FZ3/0HO8f7NDqmDnR9pVTLpz7gG9/6xv86l/6dUaTyRKCfRXUVfbQ0YpjOfPw2krmTxuY/zCF8VH3uJbi7D9v1EhVee66524ee+YZvvKF30Hnc4OrQ+wkWPLoyTUjSTnH3rhJ2sua4HPnJfWWl+Sfx2QcpX9HUHHEUgGTIDTt0oEzc7J5IClNOUnakAhllxRJfr9kEOVJtrKH2CMwtfjNzs4Ox44f5/LlKwU+C2rXVRF2Dve5sr9HqykhC6tFzJmsWfZevnIJ56Qoqus5PlYqshdndQOJZr5pGhNsLqWQSve7/FBC6kiJdJ0isR4a3lvRTmja1ETs6k6QWYjmQc7CX8Qm2VcVbWvQjktQVHYTbUI667tcKwe2nSMHg7LXIisu8RLWqp37KUhKD7ReEb6fSi09GKyfEZqEfWE40P6fHaRWMjai0qphnU6zMjBoKQcJA5GmbairusyTBSKzR5MUDMlAUC3p4SIeNDAaDxkOB+zs7OZLsLu7Y4aB65iuM8wWYyq4lEygk4u47LqhDczCIV/64u9x+yfuZm1rKw+elRxM5/gYDT7QTq21bbBgviYPtXK4SvjO+Xf4SQ2Nr/AxcF894sxog3frmpOTbfxgg8XuIfVgQFwskLV1WCyo1teJbcQTES/mtXhnFfbp/Y3aB9CIwxusOPDI2gjWx4CnDgJtgJ1D4kA4969+h+lXv4hrA/7Ou9j+5F/En7oJaIjvv4+8/DphUOM+/yTcfRtxPCTGpNRokXYXXaS6pRDQkWdyz43oUw/AxUscfPFb+O+9yOjSBdw//hdUv/Yp1v79v83it76C/PZX+LlnPsXr/9/f4rmtAdNhjS4aYu2pBL7/ne/w2BNPcesddyKuz657bSH9YcrmT6o8rtfbWfWGP+yeH3XNqyBkDFnQEFlfW+fhx5/ihed/xAdvvpl4BC3xIafc2jq2P3uZxGRN4BLCQdqDolgMuY1Yx1RSQowWY5xilCeDLNXPZaWWYa2j3iUbzoWOSszAjZKNTMu61FQASjJqUaOTETUo7sLZ85w6dZqdnR3aEFMpiFpBe1LAziX+NRLy0oPXs3fWR0Gu57juVGRHIkhML56DQiYwtATcC0SWuu7livhMPZ3T7cqImvtRijEhx3Qyxm+Vp3VdGaSSpiukgWzaQNM2lo5Hd40OIurBRULK6ugtYGdKLwfTurah+cgWeRbUNaLeGmNFUtFnotd2JuwzjYyi9FeOE5fSmKsiuK1PtZYe9pkLoCQ2qCm8PpHlatC1HuSxsfEyCC/PVVokvudyC53nppZqvFhYunKMkfX1dba2tqzPSppL760YczAYJjw5F3Wupr1arESc4+WXX+BHP/yuBe/TuMa2haY1qyYpU0RTTxmHRofiETcAUeaHU769s8PFgQd1TNo5j6ytE/Z3ePGVFzi2sWUFot4RQwtBIXGmiQhu0aIDo8tRn+I/KcZS4BBN6RUOdFjj1sYwqIkhmtXZLFhc3CO2c5q3f8bhb3+Z7XaDY0/9Ksef+kXc7iHxlR/BCz9B3r+I3nMT/Oqn4ZabCfsz5IU3cd9+AZk36HxBe2UHaVpctMy4alFRvbePf/NdZDJh4zd+neH//O/QfPpRFvM57de+g/vZO9R/+1fwjz3A5uU5nzxzE+vzGS4Ghq4yyKNVLl+4wDe/9jWa2fwqD/56jg87d1V4Q7fPVn/65x/1c733+1MfPfaK2265jaeeeBZXG+1PIBKdIqKWJOFsL/bbTGSeLQc4taJGUXCRRHQaDa2IIbUGgZSqWfa+GZwh/bSoBKKGHhqQ39cRYzb8pEedZHV5PdKodI3W/CWBRYy0ub7G2XViMIYBqQecv3yZRQjgrObPCHnT80GB7600opPz6Xbk4gp7n+tTG9ftuYQE0YhatflsPjcl41NvgOIpdJZSTIqnSZ/VPhUppJcIGoz+vgxuNxndgNtiDCERBvZeusBOzuE9FqS7xvNboC53m1zpWCkUbyvXOlhflAQ/kTM/UgW/aiKa06IcS5wnKhLSJvJdXCkf88W8KIgQ2xJ/gpwIAFm7ueRRxdAbI7rU0LW1NQ6mhzTBvL6MvzsxC8sJtG3qhJle1PusuG0BVZXFVqrKMx6PqKqKw8MDxuNxGbe2bWmahqqqegV4uTlYH6YUK6w9PIQoLGLDV7/0+9x//wMcO3UTakEquvhN8nbUmZJWmwPrf+OpR0O+88bPeKWqSQgxt0XHwyeOM7t0yTIJvWNYKXjB1TVu3lgWzaJFNy0VeSHG0u2cMxqjRPppPctzLr8gwwHRiyHlUY31eLFALx1S+yHtpOXyf/X7TC7tsHnyDO7iBYIX6tNnaJqAWx+gT96GO3nShNp756l2DwjjinjLMag9srnB4ImHULVAqXee6IR2UOECyGKGNnP07jsZ3nUbi2/9iPA7fwTP/zHujhupf+VXqH/0I+5gzulvvs/lEJijaJtg3NDyxz94jieffoZ7Hnp4iZ7oT3r8SWCx6/EyVv+9uu+P+v313HfZewmpGFfZWJvw+NPP8vzLP+GNl1/EJyGtuX6BtPPEJ2GUvA7pcsLMmDZmCnFw8vgWO3s7NG3ElnCXwJKRG9NVqe2xZgPHotNFEWMefEzxyFw2UN5DMiSdHi12ciWmZopOXMeFptG8Lwe+rgBhNp/jtCVM207x5f/37GDpy+El5ddDZK7juG7PJRMbzhYLE2ht24kVVavr6GOCUGpZupRZE8ZBDR7T/JjSpb0deW+1LKoYYinEzAOZn8H5TqH1ryXp/tlryoGqHDjP2WEClp4qwng0ospEm3k2NU8/qblO18fcemSn9EDtnhnNZ9l/AYufqBPrj+J68ZJed7fsZQGJksU42EJUSrwKZTo9tGp7ya2KpfNccl5dDryIjVGBKwUgMhoN2Nra4NixLWIMVhiL1RmFNo+VjWTbBubzeVGAIXRekibOoqaZAdnrgnfffovvfOtbxGaRrCxBq0yVY0Vs4m38fSUoLY6A08iF6S5fuXSWNya1tWyQhvvG62y6RFwp4IcDKgT2Do2perag3d0HEt9TVPxg1AXys2IVSuaMeg/1wDyuxGcm3hObBi7tE4aedntE8/yrzP7oxxzfOs3Ab6AaqM5sgG+ojo3Qe2+F9U1UBL97YBT/t5/Cf+IO4rEtMzS8EL1BGm46Ra7sUV2ZUl/cR+OcsD1BhhsMVJDBkOpXPon/O79Ee+kQ98YHVL7FPfUgpz77DHeO1xjFFueVOkEZXoSDvT2++uUvs7+3l9gHevtoxXvo/7n696O8jI/6rP/vj3Ot3m7neoXX9R2K1ZApMbScOXOGp579FJPxBq7ICGv/EKMkiIlS5xIl2h5O0f1cMJnhrYuXr7BYtKnpXcpuTPJKcwfISPJ4PKIVoj6l/1LQgozSkBRRjMHgKbGMtqixSBzzIjwey37MMV5NrSA0WAAiiu1JDQGnyvbGOiyVNNi9LCEKqqpO5jrZyr16JvT6PeHrVi4+Wdg+uWsk4ZyZdLOglXTe2toatU+NnJxjMBigSorNmGeQCy8796t76H5XyfKTz5WcU04ihcuYYIoBpL4HBYJTc3WHVZ14cuw+HjF8P1XW58lu2rZY+rnqP2t3JKY6D7VU0LIZugQAcS4JzN4zY+/rEqYriOGlJKgq/Rl745phLlIGHFUvo01JXp+UFVAWhcvxrUgUoRoOGNY1a5M1Y24WwTml8rBoZtSDAY8/+QxPP/spi1vEzjuKyXvKY5OhRsoZ3WHwWki62N5h0bZ87Wtf5oP33kRDi6sq3OYaDUBdESufPEqPBnu3VoTolQ92L/OarwleEKnYbOc8duw4a7FiZ7aHIPhZy8503xp/qbI4vYFTsX4toUFHDrynCU2qQPZmPaY4nlbeegg5gRAL7qzzBt09hLUxfmMdN9tl53e+xA2DdUabx2gGkerGG5BqRDi2hbvlVoQKqoiuDYi330Q8fZy4vgY1cHgIie+NCFw6gN0D0ECsoR1ZN8rqjfM0zWFKZzVAxn/yEfzTD9K88Q46nxIQJvffw6OfuJtjixmSlLH3QlUNcM7z4vM/5sU//hGxbQv9x4dBV/+mjtXn6X7Pkb8/6nur11j+XZ+fUKmrioceepR773uETHZrxbqaWC464W6B/Z6SxCA0dRGVFpEI0damxk7+SEoTzizoIXcw1SQnNXshXZggSQLE5RM1PUNPIec+LZhBG1PRt1fwmpNxsnz0VqgZIDaRxWxunGDOFcXhHaCBzc0NRGBra7PIByWFi6XzxK4XDsvHxzrbiVCnnufe+2QV2cv0GXWjKs1iYTxeSSDNZjM0BJrZ3AZJIPYnTnVpUeQgcv4sez+ZhkVDqqftFxolJRM00qLWS94JVJ6IwRCxDR2W2bt3P/3ZGJXzxGpZWNkjyp9l8ZoXdbFAElWIfS+lOgfDaIv94YQosbAeGD1Fp2Tz86Fq8Q0XgUAuLsxtf3GpTlFZ8uRiX8mKPffh/i6EOZWLeFHW19f41Kd/nr/7P/mf8et/49/hz//Fv8ntd9+LSqpcLgvfDiElZ6iaoFzJd1fNsbCesBLHuXPn+OqXv8x8eoATZXxsizgcYDUl3sYq5d2jUHlgWPH9C5d5ZwC1VqiDG4D7JxvodMZLl96ndp4HztxG7QfMd/eJbUtNZWmc4zF+ODZFsmgYOG8up/fWqKweoLW32EwbiYumPIM2LTEE3KiGtRHtqGL63R8zfulthuMJNC3u5Al0c53gnNUGtC1x7wB97R38K28juzvws/fRs5cJzlNvbpv3FCK6CMigwk1nxLMXcBd3qOYNnNyCjTH1IqSMUsVHReqK6rOPUW1uouesctqFhrs+9xlunUZjHIgCztMGy7aLTcNXvvB77Fy6iIaOreKjYiarHsVRAvzDFNJRv7+WMjtSceRycT1aqfxpjmz03HDqFE89+wybx04gdE0G7dnAGmUZfVInUDthX7JLe/teHKVtRrLvIIlo6xDpSpwWUqqvaFJsiReMpDySh2TGopLp8S0JoV/EmPahpHs7Iwk25dMlqhBDYvbGOPUSjpLn9+LF8yiB8xfO0rRz+jGXpTq4j2mEXLdyscGwkSsZBK7rJ5Ctb1UL9jdNkwgSu8WVYageglmOZfdQaZqGpmnwzjGo61LNb+OVMsJi7CxQzam9IQWlTNIGzVX1PahMFaKmDo5aijD7x1JL4GwROUkcaJKSEFYr/CmemMZ8L1Ib5eWNV2JJWanFSO16Cpv+5uuul8c7KxbzzJbHUrDiLA0WhwltYBYX5nXFyHo14oH7HuZ/9Hf/Pr/x7/w97rzrXiLC6TM38vCjTzKarHU8VckDzKnjIUbaGK6CMUu/C5eqkKMleDSt8Xl973vf4c3XXwUNVOMRVANqKrQNaBsK5KmqVL7mrSsX+Wqz4GA8ZOqhblseH69z83hM7g6ICE0ItIuG4fFNFodTXBvg5Bq6MUDWLJVZJiPaYY3UFaFy6GiAjqzlcZwt0PkCotI6CM4yy6X2uOEAV3n03FnC732DzTDAyQA3GKBaA8bYTNuic2OUrU4eh5PHjQUchw+CTGdGt5+CvBpaGlp0bOs6Ng16eR+5sEdIXpxzDvXJo4sR2dhEHr8btzfHLwJ6YZftB+7jnvUNthYtUYx+J2hLJNK0c959+2f88Lnv0DaLD/UC+uvxqONa3sW1vvORCmTlvGzEdWZMktJ/1ocYzFQJ3Pvggzzw6JN4NzSIyfmkBLJX3vPQ06OUkoYkx6KDWCRoNkKtZTYa0dCaoagxwdcW28yoRBKn5A1cko6gQHFKkkUJschKox5Y/NpQJFMYuTusEjl+7Jg9Z8iwu3lj9g6hyFuQqxCiuq6SotTEc/Yn83CvW7nkB+yGUkpNSVEaWdCSMqNy974MM2W+HixYnbPPVhdgTmfWaDUWW1tbRUlBJ8hEpLTrhE5BZcs/HxFSr/ijCw2XYhwrn+XxvGpz6XJWW/pCEfTOOSpxeDMjunslxUa03ucZpnMIx48do/LLLVHT3YuXUKwKtGNkTT+5IEvIuR12//r/x9p/BVuSpPmd2O9zj4ijrsqbOrOyKrO0zKzMLNW6Z3oamMEMgAGhdgAaloYlQWBpSzM80MgXmpF8WD6RZqTZ0hbcJbHgglyjcRfAQPbMtO6eai1La5FVlVpcdUREuDsfPveIOOferMoaIMpu3ZvnhPBw//wT/0+JMBRL3xhO3n2Sv/jX/jp/5+/9A8489Ry9/kiv9SW9XHjyzFPcd98jjane+KYahVIIRqJwuw2ziYpHVL5x3jPe3uGbX/86G5u3MEsDfK8gGEMVXINNJ7h1iuEHVy7w3qBPpeWcWStrPr/vKGY6i2X19Zl5MPS8hsnn/YLKz9j44AKTX7/A7KWXcW++BR9+hLl5C1dOY0tpEAn4aYmpFI82mdV2t8Y2a1CXFWFaMvvBzylefx+X9QmjZVzpMaMlDQudTdUJ28/x60uEQ6u4zGA2tzFrPVw/IDdu4j68ojk0RY7dt6SJxle3cRtTQm5gOdZEQyMrxQecldhoCsQJ7vg64e4DiAc3rTE+565D+ylcSU6ItalqqnpKEIXKvvfdb3H1yiUtYMje6/Vx1kx3Xy12jO3e58967LpXclqzuA/38PckzYoWdpr7Ya9xKa0tr67w1NPPcejwERUkUXNV360H8XNdb+fmI9oaVXBU3qmVEQUXovtSiNB+rExujICEKBS8loPZpdSGqMAr4tIo4taQF7lWExBipJmbQ1/SOJMVNJtNo3/YasSYkWjZVA0016A2zlNXCmfXtaPo9Rr/LcDq2urcvC9W3L7dceehyNFKIb2MU1PL+VSkTeaYvyeo4zrE3wlrDJAhsQzD/OOTGZb+9iEwnU65cuWKhszGnJoEmwFzPgeAXCzJQe5SuKn3Gjq4IHRshNkkWjHN5tEBNJpFd1LVaWoai6exUEwXm9S5qH3rVG/qCAUVrIQQtfzYRhTPtZs3YgnwaFEJ+OT878wRPmiDK89c1JsWLNT3NEEj+fr9nEwq9q+s8qXf+HP8T/7ef8Zv/tbvsm/fQX3PBiM0SPAcOrDOk898lqV963hioU8rYFGLRTpCFdWwmgJ4RCvNQ3ApiMI3+O2vX3iBF174JcVwSNnrUaPrEoKnosaGCjGWq7e2+OF0wjjL0MQ1x5n+kIeW1qg9lHXJRjnm4HAVrGFcloTKMfWezdfe4dbLb+E/uA5XN5E64K/eINzcxL/3EfUb7xB+9QJcuwGVa7VMEytEGAgmQn7BUo/HuB/+CtNbQfavEm5swWhIqCvYmYKxyGhEEItMSsxrlzEvvYv/ox8TNiZINoTrY+Sd96AsCWVJFTz1/hX8kf2ES9cxf/gD3Hd+hbt4mVDOwCq9ZI3GA9igyaHrS9ilHubAChIcB588w1pdR+d0TVTt1KojcPXyRX7y/PcoZ9MGP298kXdw7CV8upDZp7m+ZdDR7N5lb7eWenI8f/pjFyay8I0mG+MdJ0+d4vGzz5LZQgtQGvUnB4kZecmHGysKt/eJpYpCsjBYELwxyCcG+HSV7/F4HJWv9l1FiBwgCUpVPlNuSQiBuqog+oe8900l5CZ203t8FFoQ2N7ZbqwfH++dWnAgoikb0tJXEkrWWra2NinLCu8NPgjbOzv6jkGtsjtZd/g0sBg0OSRWZLfE7FgtXtRcdInp+NBEZqSCbBDLwJi2B0W6T0MeoWVcxOfVMToqCaHWN0IzFhsFBk6tg24RSB9CzFDV0GpEGkGYWnvOP7MVeklbSpCZ8SooLKIukQjX6TP0HJciqaKm38xZJJzUoAsjOAlNommI48K07944/zqCrmt5pQoGaiw5xE/Zt7rCk+c/w9/6n/59/tLf/AMO33MPITOxI11nK8Y/xBqeOH2a+x85TZblBOfJBIJv671lYugVRZrwjs8rNKHV3dbUyeqdlTO+8bU/InhHtjqisIU6872jIGeWWWSU85Pr7/PyYEiVeUyw7HeeL6wcYBRpZ3s25vpkixOrByiMZVQUbF66QnZrwuzqBgZL/5F7KU6fguPLjGdjwvIS+QN3Iw+cgH4BMQvZi1rQ4jwaCaNhpsFa7MqQsp4ynII9dQy7OcUUBbbfgxubyGiIsxnWZPjNMcZmhLsOUh1ehsuXCW+9h13tE849TnjoQchzePcj5F9/B/P2FezF68gjp5j9td/EzErsL17DX74Ms0qFs0usQ2J4apvDZVaGhH0D1s88zCG7TO41IqrRrYMmBwaEH//oR3x44X2tnRbXbNG6T/fd7Vj/ZEZyu+v2goHnrHzC3OctPMYcjH2bp7LLElv8WUAdUrBR8NpGYWkw4MzZcxw9cRKMxm+ZCF1pi+15vpKOFtaSpoL2ok8p7fL2l8zdxwffIDnaAqNjyUhqyWw4cPBgu++b90zz1UFe0rM77zvPF2kUYiFV92jPbSvQx26daEoDXtsi13XdwG53KlzuvCpySkoLWuBNjPYR77YgTpMOtFAHogmXnRdPq94NEU6MK7XTxGiTreD0hVLIbRIst3vBtLipp4okyyJpbZJmOvkS2lbFas5GE3uRWMJ85r+NOS2GNuNefGgw2ECr4aeNLOy98DaGabv4aBctPxF18pvOu4pEqETU2ZjeC1EhBxqRZ4qCUyfu4otf/gqPnj7Pytp6RApiPaVF3TUEPIKxlv1rKzz17Od4581XuXnlUiy9Ha1Wr8ESjQbcme/dBJ2c/7o1xAhvvv46r//kRzxmaihrvKtjEqNgbc6VWxt8e7rFeLSOrWsq43hYhM+uH4TplFD5ubXxVc3m1Rv0Dq4iBFYOrrP14RUyb6g+vEG5vckVKo6+f5VBv4ccXENia1mxBmxAykod7TaVhBG8tQQL9oW3seMaP62oV5fwSwXFrTEhM+pXmTr89gw7KwlLFezv4cuCwhjcL99AKsH8+WeQU0cgz5BpQL72C+T77+KuX8IWFvsP/ibh97+Me/VN7KTC70wJRYYJvVb5SEQl8TeCyTN6+w9SPXiK2XsXVPtOvWdiawmH49bGDf70O9/kyNFjDJdXAEjtvf8sro0uM+v+Tn/v5ZvZBf8kxEEWPouWQndgi3QFHzPsBj5Iwqv1mcxZUEZr4d11/ARnn32Oy1c+wE23o8WR0Ij0ruk6moK8XZ7QpDYu0L5+RidBvBWcQvLZtu9nrWV1bZXNra3GMrl27VqjnKV7moScxH3XfqdKpicoTyNEgCQ+KyqrTVSbqI/aynwlh8bfbAzGZG0FexFkkW98zHHHlot3runHkvCiRDTK4KLGH8AGyJw2rEpMxxPI+z16g76SUZg3JdMRBMgsJrdIpjkQDf4YFy/1cU4LsuuYR8raMQpzlQLSd2liVcDEcXQIKkn2bpHIABSx5la3xSgA1jThiCl0MHRM3KQhgBJklmXkJsP60EBmCXK73QItLy8zGAwabUx8IDMWG2Df8iq/89t/kf/k7/9DnvvSV1leW49Ig2+01u4EJaEfRKhdhQ0lDz/0EE+ee4Ys75Hi94u81ySZ1lU1XyJi4ehqoilgIsRw2Qs//jH9jVtQlxhXIliqLGDzjB9fusSb+RAnU0woOOAqvrp2iKHRsuFFbF6Uxo0RBsMBS/tWKfIc6VuKviVYB6sDhseOseIs1YEedrWvfTiGha53kakSMqnwPuBzQ8gNkmVgBVdOkV++SdickI2WNV9mXFGKw7pAqBy2CrCvD6t9RAJ+kFMc2E/9wD0YL8gLb1D/q2/Cm2+Dd/hTRwn/6f8I/vaXCX/zK/g8w/yTf4b59g9grU99bL+GVZeOUNaEOtY7C+28AgSbYaYBN1rmxPnziNhG2dHzYuF4CRjjeemFX/LWq69CDKBwIYXR77Vmex9pr9yJj+Vjz2kEQHvfVmrO74/bjeP2903Q0h7XdaydhEQMBz0efeJx7n3gQcRkeCNNtG5XsISgMLtzKbO+kV9N3b+usE1QWBMRGzlKW6Wk+46t7/rmrVtNdROi4EhRm3NCPVlhCxOQxuBDgvnTk9OTAqlVWrpPd9yq2AMWgnF4qTUaMT2743v7pOPOHfpJ6IZA5Z3mUHQd/F4TdnTwGiEhThmLq7WimKtqylmpFkkXcu0QomnKn7cJjCmPJR29Xm9Oyu4mtRh+Gx3Pjc8kLioyTwxpASVG86RrUqizCnyZ0yJ9XWvGq7WtnyhaRcGHNoEKGgiua80k3FZEKGezpllXygtK8yKhtTJUmAcyY5iMJ0xnM1zQmVnqF6z0LJ/7zGf5u3/vP+V3fvcvs//QUZxvCVp9PiH2nIjQXFzT4BX7tdaAsSyP+jx57ikOHr07Rox5tsfjZhzJAkqdN9v5bBaVFO7oxSERHw6+ZDQrMeNtXDXFOO2pYTPL9a0tfrSzwUae4Y0l5HAay+fWD8GsJBON1Hvr5iUGWcE9q/tBAnmvoAgeV06oqprxbEx19Sb1r97AbWywtLbKaHlAffE6sr1BwBJ2KvDgZiV1NUbymNhZZIQcMAW2niJXbiL9ZfwgR6oZtq7h4D448wCMekivR9iZ4aqSUBTYrSkUBebpxzVxMjjs65cI/+J5GM8IQFWXhMvX4a5juD/4KmFrC/cvvgn/6J+Tf/8XyHSiRXUnFcEBVVDLykjzI1bhlClw5qGHeWhtjb6P4fnGtVGKXnCVZ+vWLb77ra+zeeuGVvlOGnNn1ywymUVB0qxvLH+UojwSPAO3Z/xz9+pisUE67pVoB0hjnLKXlEjMeeHTlkk1/pxF2CyqeR3YNnjH8cNHOX/+M4yW15ouqV1hrnkv8bPU054EgEjjd+kMOqIcxEofuy0bbdrXlqYJTq3OBKU3lkmCq7zmtWh9s6icRyurWbeUB9OxQhDBZm2nS2VwnVSJ4DuWVXv0+31EYruRWMVAbEBsK3A/6bjzDH2JeSIRB/ZoOfiDERM0kooZRrbZ6UWSGHpdxwKVusRzsE7jp0gOc+e1LWxk0l2fzHg8nosYSz6IFNWUPtOSIq0A6Zqw+lJxEozW3WoSGDvak0RAqLuI6ldQa+XEiRMMR6M54rIR3jPJ1yNtYGOzCSNUaKLg0jkNGGO1TXTCiaERQunHW/XPeBwYhyky7n/0Mf7m3/17/LW/8x/z4BNPYLNcS9vPaS00/vuUMCadeUgWjUcIwXHq3lM8/cxn6fVGZAb6mdVe8ooPNE4+FwJYo2OStn5ZO8e64h5PUdYcNAVS1rrm1pJhEWf45ZUrvNLLCUawtWVftc1fWj3IsrWEUhshBYGbkx1ym7GU9RiOhmRFgbcGejlZ3scXlsvb25h7FIrqHTuMrQ0+WOq6pNrYweUQrCCVI5vMqKmR3OIjQwaDf/8S9ZWbmKUlpSmrcGOxE+CDm8iNHcJ0irl0g/zWDn57i+rKFbi5gTuwTPalM4ThEDEO88YFwmSG+eg6/a//DPv1H2P+398gO7Af9zufw4+W8Dsl1Zvvw69fgVu3CMYRXE0oS3xVITVkFJAVWq/PCnUO9544zt/4jd/knnGN9Z6sgiwWV02JdMZkvPH6a/z6V7+knE3b2oC0jP/jsPT57xqQd067797vk4+wcF0rVFpav5N7pOiyztDm/7iNkFRyFyNYY3nk4Ud58JHH8JoWr/vAJ96RKo/QwEVNAEu8XzfHrBtV1ii1e1h8XaGcLAhVgGXuDYQYUJWUOFpEJEF1ydJJvG9paakRMEtLS3PISl1pM7xGwCVJ2K4EVVnFd0+SNMQUiEAtd7K+n6YqctTsvfOMhkOCwGw8aTHBtMISozFoS+TXdUVmtbgeUWOqqjomSXYitKKp573GhWexim3XHGyc/l1tuQN7JdhHpJXwDRwZ7yMxI98T/Uci1L6ljgaTDdFJGpl84y/ySgTGGN6NFVZjGxcVhhpnqHNi48MTBh5Cc6+AKqh4bWpUx/ppQGuZOd9YDhpmLWSZVqE2AkcOHeQLX/pNzj37eZbXD8bS22XjIyGkNM723WAP3SO+l+koBf1+wZPnzvHqyy/wxqs/Q4xXS4iYwAkMR0NmpTr8UkBESM3D0IRXPd9gCewXw9H+ANmcYMXiXYWzgelszJ9uX+faaAkvGSKBp8l49tBh6kkZhZpp9kAg4HygN+hrwyxvcCtDsnFN6QPV5hYr4xVGa2vM3ryA2bdCfvQ48u5V1RIPB9ysxM5KZu98RHZwjbB/Hxl5LDzqqX7wCnkdCD2N2womx0nQMjP1DAY51eoS0u8hKz3Yt0y2NSVc36CoV+DwQeovnIV3P8DlGfLRj5FRn/r0g8hsqgzDBezvfQ6cI7sxxd17FN8zmM0Jwd/C3nVYa9Q5qHNLPlqmnk4xvgZjWJKMYRAefuwhHjQ5HxqhLC1TW6N5G1oB2jlNwv3WN/6EBx9+mANHjmFtTgiupe2P3f5zNk7z80kWS/fY+5yOtRv20nW7FknLA/SGnXHtxe9Ce157TkcKEMneO/Yf2M+Zc0/x+ptvcOPSh00RWXUDRLrTbl+6Dz0xgVlaRTo+63Y+qbl+UnTnNELnabgJBoMGyk68JwR1N+izOhZWR1iLCLdu3Wrm6vq16xpYA5r3YrW6vTE25vpFpEZSNBlxP8vudxGJqf2ffHyKfi76AGsMWzvb2MySGdNgl92JS1EFxlrKcqo6ax0YDkfMZqXWe2pqXLVSWjqlpbXIoOL7zTmd312zPQmWkBYDGjMv+LRQ0YJI8FBavBDmLOhkBSVrJqoXyqBFWmsnLriLMFOIcFiqqKpjkLYZFaoBGWs6z5RoJWjCVZZljEZL7Gxvt/4oG/05IWCDRsJltWd5ZZVzTz/Dl7/8FY7edYJgNKnPO4c1tnk/GuE6Z7Ppu0alM71+F9VKrYCPHz/Ik+fO8/67r1GOt2jaUUdNs5yVESaLmhrRlI/Qgj5D4UkbAgeznKWA9pJHAI8Mc158/zKvFhl1UP/e8VDzu4dOYJ1a8QGliTpazibo3HoR8sxiiwJjMqY9yBEODNcwRY4f5uz8+i1WV0awf4SfjDUa6+omWbGMTEr8ZIps7CC3tnCSYzMI9ZjwzkXM8rKW7c/UhrWlI1igdsgM8ms3cAZs/xhutU/Yv4IZDQmDIWHQo3ffPQTnqSUg3/4XsL6K/fxZLSuztUFVz8iyIe70fVQ/eRVbG+ToKqGn/rMwqTBBcIMCsz5ElkewMyZUFZkIWR2QHvTvOsh999/Dz998lVtZry1jEzXtxEQvffgBP/zB9/lzv/OX6A3sHDPctef3EhyhI1jm+km0x5wP9bZWTOgqy7HHye0EVJg7f5eVleqBhdb6CYnTp8tJDBjmHwyZaoU88MCDPHH6HH964wpSe6qqjrkr8wnTzWOj9TCHrhjTCKA2AqsVMi08FXYx7igtVcEObdfI9A5pbyVh0FgjnX0LHf7p/RzEHqLyb61lMBiwvb3d9oGJ/MvFQp/p3ynFIo3d7OIitz/uHBYjvSyNMlE3RRPblsQNDCQKhGRZTpbl9Ho9VlaWNdbamhgWGYVDCI1zLMFoklltT7sgSLo/cwEBOgMNlNudg6YfTKItSbHnzcs1GxFaDSNZMNFBEVcu/Zam9k7y1Yg1rZCLC9IQcrTmGkdfhN+86BY1Vi2X7Z0t3bRCzC/RqKC8yMkMLPX7nH7yLH/3f/4P+Kt/8D/m0D334m2hz8ehzT5TkAUNcaYaZ93/CAmy1HdMmwGSJgPWBJ48+yQPPnIGH4m9mR8f8LWLMfmtIA++FcYubQiBzHmOZ32WAlhjCcbi+jnTacm3rl3lcjHAZ5a+wGes5fTqOrI9QyRgYxXjKzu3uLxzi2dOPUbR6+sz6gpEC2myVNCrIVtewl3eYeflD1j+4nncvjWqF96hyPr4UYEZ9Ki9p7p6g2J1RDDgXnoXeeNDyvevQs8iJw/hrcHaTAWZFXyRKZxAwK8vwROPIr/1RfznniPc9xDcex9yz12Yu44gh9ZhbRmWBkgNz/ze7/PeC7/k8gu/wNYlYXVEtn8Vl2WYw4cIywX+2kV46Q24cInaVPgeVK5S63biqD+4itmZYGY1VNqnhp7FjoY88Ztf4kQNhYGBWJaHg1hdNyk9utR/+t3vcPnSxZgqoGVO2nIrrQZMp8j7XofC2nfGQrrCYE6GdPh12i7tT3J877obdPZrs5MTRNFl1nNXJatdg7aVx7dFV1eWVzh3/imOHr+H2mnwieawtBGxKa2gy2hT+L2YFIWWytU2Q43XdgXNwsvH00xCWxb8tsS1WlpaIrX0aKJR43gaf3Cnykdd1xHaN/R7Pfat7cM7z3hnpxnT/L2EXlFQZBkxSV9TLVAkCK++9Ds57jwUOS1MoCleGeKLGGOacuzz9YvUdjSSUdeeK1dv6GCtxpJLhxCaiAtpF146kFc6kpWU/Dfd0gVdxSSFFKcFVRO3zQOR2CLWx5h3brNJmg6XCW6DTsOyWJ0gmZqERg4ljNZKJ3emCUJoFzS1WdVFjlaTtL0WCAEbSgZFj2P33McXv/LneOLMUyyvrpH8Qll8xiIjSP4nHzQnh47g2+u8BFkmLcXjCV44cHA/zz73WS5eeJcrVz5SSCo4kgGW8OJEKUqUAWJwggSPiKFwjsOZwXhPyC3eOXq9Ib94521eEJhagxPH+sTzeycfoHAKteEcIZa9CbF+kvRyhRonFdkoJ7MGnxU4VyOVR0xg9cETzMbblB9eJj+4n+zuI9Tr6wx+9SL+vrsR7zCXbhIOr8LyMuaEWin5wXXcUoE8cDfy/GtQLGnl5FmFKTKqk4fh5GHqo+vYzS147UXCv/sQbm5R+oqdkaE6eZTe6cfoPfQAdn2N4vgBBncdoZrNqDfHhI0tZNSDwmILBwf2Yb7yOexHV+DCZdgeY968gqwfxA2H+F7OzID1WibIB8HUHsnyGJ4dOPDcWZ755sO88847XC0ktsdW+COEQO09RgLbmzf43jf/hL/yB0ewg6XYVMx3mL6gfVAMRkHNhlGGRETN70/jq0kacNKm57Vy5oREo212b0bCj1pyU8IWaW7UOT/sInaJ1dRD1OSTAqbdVOHkPac489RnuHrlEuV4U8HzDg9I9K5ddaOSZYQQo8jESMdn2yYXGyNzY5kXtnNmh/KnpsJFiIKlbZGefDmtVdJaP83ebRLCJUZ4BUrvqWZl5IWd9YgtQ1KDTBec8iXno29O8xQ9aDkk7uy4Y+FiY1RUN4IhDc7HEL307xYHDYTgsJn2E0jAiYs1bfBgJQoZlMG7tDDSsQgXzOC6k/OSxtJlilrDTRqHvu1AZNjWuQ4hFoxMWfO7N8PtNo4STWgXesE0TUerfSWTNsybqrSEYY3mWXivprqJEXmHDxzkM5/7Es9+7susH7lLF9p5LboY2vE04+oI7BaXVs9LWxwzXdf+3d1EKUijDmqVPPLIw7z26JNcv3YV5ydaPBSrQQVRCTDR5LYI1WymmhimqY3UC3BwuKQFPF1NPijYujXmD7ducXFpRL83ophs8VfW9nNvv089GWNMppYDYIJt5m66sYn015hubSODVWQ8QYbLeGMoY4dQJo7++mHqPJDtWyMcPIBEUM/3h8jLb8Kwj3/oFNmhdfzqsvqLxEORYe46BL2MelbhBkOKBw/jDy+R9QeE2Q7h332L6q33KH3J5ngDE6Dc2kDChPqnhut/+IeEQwexJ+9n9PTjTDZvAeDWh/ilHqYGnMF5jdLLllfhgSWqE0cw0xnsaOUBu5JB3ieMlqh7NZlGTTRwJ5GhyeoBHvhzX+De/8ubXCsyKl9pZJinoTvtoCj84ic/4Yknz/P4mbPkJra+9fPwdsw/14jFDp3M0Tfz+yZBPmpJLwqW+d97HY3vNAqRlpD3eG6kaqQVNou2SseuWfy4te5pHfb9fp8nz57njVde5M1Xf4WpZhHaloYjC6lMXMcJH/mBc/Wcf+TjjsX9BuyCs7r3cN6ztbWlnSQ7wmvxfnOvKuq3tdaqouxDV6brvmoZLYhQVlW0xMyccm1NCmK4M2jszn0ut5mI9F1ZanE8OwdlCQGHcxXWZJ0XaTlb0tq7ce3JSd99Xjc6rEm4tHaemUrr2G+c+0lzkJRNS2spkIhxAf/tQHGLGsbctIo0gss71/p5OpSemLlBtCJzEojpvSUmK5GINoA4DJ6i1+fJs8/xm1/9i5y6+xR5nuPqEpMpHOF8tFoiNpqenawYner4Dp2AhfTe0tmQe2xBgtecIuc8aysrPP3sZ3j9zVe5+MGbiEE773XeVQUABDQxdXl5mfF4Qg2I96wgHBoOkbHXfAIX+No7b/NCf8AUIfMzzmH4nYNHKKYVgkbFEYgV8R1VWWJEKIzFE+ivr5INB7jMkOUZ2ZWbFJWw+eqb7By4it2/H3vsEOPcMhoMCVmAolANczwjHFuGegovvIE5tB+59xj0e/gqYFeWqfetYYdrZKtDZObxb2/Avltsff/bjC++zc4oo64cfWsxeYY5OAK7hDWBtTrAZIx76cdMXvoZV2ul8Wu/foH1g+sM9h8itz2yAF4crm+xtSGv1SqTQU7Zi34RHCHUFIfXqLMC8VZD/uPahrqEK7c4eOYsp1b+kF8zYdxYI6q4JXp2AcaTHb77nW9w98lT7Fs/0IG4urCSLmxYtAjmvk1QVCIa/VOildM1QuZwogQXNVKig2LQuRYhYeap9YVIMko6EVvpZh1rGphD+7rv0dUZQxI0Qe947PARnn7ms3x44T12Nq5hRZvuNQpcukcU6qkrbghtearkIFceJ21S+R5IzMcJir1Qm6TId5X8xXOba6IkTI0ed53T4YWJPyyW5ZLQtlxOJbju5LjzTpTxhRKDTa+UzK/ui84xfNoX8i7EwnBR0xCDNxKz8EMTnttCPLJrkhfNP1ATMkRC9CSCUo4kEHM4ZM7EFGOaIpIpg7V1Xi28QxI2HahNRDQclxCDSMyu/dfCdTHKo9NLRuIG8039Iu0cmWEo8ox77r2XL/3WX+DxJ87TH/TxXhNAg20huYT5di287u8EdTWJdel/0gpVSf1l5q32do1jWRHvHffcd5KzTz3D1csfUdUTjXt30ilRo/k/aUBbW1skINk44dBgwP5+D7O1Q7F/jVfeeIuvVRvcWFnC1I79ZcXfOHiU/SFQu0COVmXOrGUymxCc58LmVdb6S5xaOUQ26DPbGJMdWKPwmhxorOXAF8/iR6uwNILlDD8pcdd3kOmHiGQEk+NNwJx/CPPe+8iPXtSs+H1LUHjsyVMYkxH6fbJTd8O1CdycUA9yGBrGz3+TrQ9eohz1McMhw2EfU2QEtPmZF6eU6ANeBOOFFVezeuMmADv/+t/y9veeJzt2F0unH2XlicdYOXkKu7yEFBlhSc28ejzVaMJJCYUj3zCE8ZQiHyFi8NVU6dIp3IUrGZg+h+89ysqrL7HV7zGL/NRGJct59dOIEV58+QVeevEFPvPZz2Pz3u0tgBTFJUkJ2zsLvyEvkfYOjdC5rXRq6W0OHupSYdyXqH82LDDodhC3+SAkEUQjxDosOeqg2tuF4MmN8Mijj/P660/ysx99D+/KRmsnRL9uVHib4rFCAz924bD0/G7CY/ecvYKUGv8HnWz5znmLwQKNUt0VUg3fifzRK3Tf8q/m7QGa0OTEc5MvJ/FOF5+5srzMODYU/KTjzkORF45FSZva06YJSYdI1ggKG6NWVPrWWCv4us1IShWNtXZZqn/TTlzDEsO8sDBWk8KQiHdGZ5iNqbZdDFJvACblrcTbmghHabR0Ct+dF2g6zlh+wbfOxkRcNrHxVEMsntNdfEtM0gQkiHZUNIFMArkX7jp6N89+/os8/dnPsbJvv97fu+iQbbt/hkjkzbwsWF671shYUthpV2jfbm11mkKjcQYCw37BE+ee4Y03Xuetl3+m7xdQ2Duuu/OePMswxlA5hyHggiULNUdqyCY1tp9x9cYN/vD993lrWBCCpWcNX7DC6eEK9axSQZ8X5GKY7Iyx1mByy9XxZiM0bYDaxEoHxYBgHXU54fKP3oHVEUtHD5OfPEpx4gj5QyehDoTVVWSnJBuXuA8+Iny4gV8aYU4cgv6AUGVacXY2weUZfmeCvXUdu3pQ3+/Wdcbvv83syDp+tExR9JB+gc+MwpTWNt3Go/5EwFNXgVA54ENGq0vsywT/zjtMXn2d6//9v8Lcc4KVc2fYf/4sS/fejYxG2KUeoapjuJwn1FOoK8LmlhYurRTnxxpMnhF6kPX7PPjZZzj20gtcEYf3hlrQ7oQxitB7VMB4+N53v8nDjzzKgYOHI/HomscsirZ3SbJtpVWMGkMg0UtEDITWJ6t0viCxGpptaTC0SHFLmws0amiVOZIC2TlNOmNq9nazKbrPnrtcLaAOT/HAvn37OP/UM7z1zhtsXvyAWmqcN5FPuRZZUXCMlLOX9kHz2ABZ9PO4zhyGoGhHV5AkSEzfZX5M6bPmu2jJOR/IxKh+F62UBPHtJdATlN+UrIq8tsnjiwFM1hjtRCvJB6TnTicTfKpR9wnHpxIuobOKt5O+6ej6QhbvsegjgfkIB5i3eNK909fdBWkWBg0fEIS6rtvS9Y0V1B4Cc+X+jQh15WIl3DYirnu+zrs0gkS6DroUtuy0BIuIOt58tEjSc0RUmARXY2wy97W45vJghc989ot89otf4ujxu6LpqUxFhUFbP6iBC5o53Xu95ue+c1J3U6c3DCAL+QTpd9KmvPecOH6U02fO8NF7b7Czs0XX4WmtdpUsioIAzOoaL1AAmas5PljH2Iy6rPiT117j632hzAqsBE5UU/76gQdYCYIzUBQZvnZMZ2NtS8A8s6rxmOmY5RNHkMmE+tASuRPMygjZHGOzHrk33Pr5awyu3WJ49xFkeQm5dg331geEQ/uxkxnywFF8lkEFLPehV2hAQM8igxx/9xq9dy4R9jkyqRm/9zKz5Rw/WsL0erA8ApshmcJitii0SZ0YMAbJDJKJVmfeUY3Prq5hDq7jgqMvFjsrmU5Krj7/I9790U9Zevhejp07z9FHHyI/sB9nM3xVkYVAwBGySsk0N1hsnBQNvnAzx+FHH+ax1XXeHW9yI8txQGWjwIjuTusDeWa5eOFdfvHTH/Kl3/xzFIMRyegIISIHzENIhCRAaKDdrtXbRBV16Cyt2xwZ3oZo23DhPb9u93Lch5F6F+7xZzxC5DNek5lP3X8/j51+kh9dvYqJNe00qEQaC4DYbTJ0YPt2rHpOnufKD1y0utA57cLoXX64aIWkn7mKKCFaFV57riS/SXApmo3mWcDc2Hbx5SiINMBKCNHXm4RY4jshBEUmzOKM733csXDpZngmZpLMs1TjajKZNIxocaLSxHSZVRdvDMlUtbGffJgv2KjPX+ifsnAYaCS2c47M2rb18MJ13RDKxuEdceemW2Qglmig9S2mOegQdqNJeE8qRqPvKI1DLF1rjaGuNMzRExgMhjz28ON8+Utf5YFHH9dGVPhOSZY0zkVhsqiWNarZnsI7JJVpN3g3t6Y6D0mAtQLYR7OulwlnnjzHKy+/xMu//CmgdGGtZTgcsrGxwWQ6jdCjEKzBOc9KCOwfDDFFzouvv8U3Z2PGIw1NH4YJf2FplWP9HDedkfcLXF1TTmZNpnnXsvWi4aHW9JhducXg7iNYbZ8JqyMO/5Uvg7GYrRn5qUPkeY65dBO5tUNVebIJhAOHkGMFwYK5cQvGW5APCcOeaqOxtp35zMPUL7xNCDvI9iYbtz5gZ/8yxWgZlntk/SEmzxGTIXlGiKHLtihUaBU5dewGGIaXAagOrOOPHSXv93HLI4rVVUx/yKASlm9tM9sZc/Hdi2zd2uH4A6dYPrgfWV3SttABjO9j6pqUIRysgUzXLTMZYbDOI6cf4fnvPc/1HlpxICi8mZT+xkLwnh9+/3s88cSTHLrrnqgnJdO6oahFcmmtA+YjKndZDItHlwSlpdl5qOrjj9ayib9kUX1sz9sTPqOVTbueGdJuCqwur3D23FO899rrXHjndWxMIk/v2IXJF5/b9VvUdd1UYE+Q2pyyyt732AWZRQsp8cVUgNZEQeOjotoYhcnKTC/cDW2ee+VUky7eTwxrq6tsbm7GsYeIzEgbWXoHx52HIn+M8yiVY+mGBS8Kk3TNbmtk/rtgRaOC/fykdyV46ikgC4uTQputtSqcugxZ2mQgjSaLGyztIjGEZO7rE1upTxyPSNMRLoTWepFYcDIYjXbT8aLCqbMbvXNMq1ILegbh5L338pu/8VUeP3OOpZV9BAPBO81GD2l8OgJjkoU3pwe2czn/Px1fx9pLY5qnLZn7u4vFtp8lHhAVhuA4ePAQTz/3eS69/w43b1zBRfN+Mpm06x83kNQeLOzHsr6ywrUrV/hnH77LG0tLBOOw3vB4FfjqXXeR1Z5iOGA6nlCXNUVWYDONUpQQuDLZ5NZ0h8+deJil3pDRPcexWR/uPkwINb6sMFkPh8WsDJHSkd3cweYF9YfXMacfwNx3CpcDm9swm2LyHG8sWdFDgiDDAdIrcBZMDfbgOv7Ro/jnX+LmxbfYHGWwtgr9vnaXLArEWmym9zG9gqwoCFmO9Hr4PFNlgYAZDgAollfp33uK4v57GD14H2Z9P2a4jJDha4+rS6Sc4YyQZT1C6Rl/8AHVBx+wfHgNWVrSVs2107YS3iNeO1diZ1hTcPzZc5z8xvN84B2lF7AWE9rCrV4C3imz+ujiR3z/+9/ld3//r9Hr9xCxJGt2L5a/GC3aMPfE7G+z30PCCtP+aWSL7H6O7EHlfm9h8XGs7uMEzNwNusLGCDiHlYyTJ05x5vwzXLr4PtVkqrUEax9hok7iuJ8PWU6V2xslrzse33lu+nNB+Z3L5k+KeuRPqWpzOk8FSdA22pL8zG3lk1axbOd5jg9HhTwJJQG2NjdVoU9J3z6mzMreNLHXcefCJTIuI63+E0JoXsJHTV3EKKhLq/EuWjNpwnyIDv6gSYQ++KY1rzqY2pfQiY95JAtmY3pWcp5bazs1tFrBmK5N/wV8U+5EzVSJdbHaEvJAmxwY3zvKmSZKy/ugjZ3mLDtpnudCDNMV7Y2yb98Bnv7sl/j8l36TQwcPx25xGiKq7zBfDiIx+c5qLK7Onp8nAdP+W3ads7i+7fj3vo8ES2aEhx96hBcffoybP7pGBngHdZghdMIXAWMCpnacWFtltDTgD3/wEj8ZGeq8wIQZd0+m/MGRE+w3GVnumY6nUGkHUvUTCZnJCc4xm5XUwXPk1ClW772fsirJfUn98luYpSFhc4ycPIxxAVOoNeFP7IP1VeTkEeTAGn7rJlI77Nsf4HHIXUcJ1hL6PeiPtCBgXSJVBkbIbI/yq59hsjPh4s13KPsrjIbLhCLD5j1MlmPyHJv3yPIcKQy+n0PRJy/6lAJZzO43/SEA/cfv5+BvfQazfx0ZLhPyAVIsQVYofg8IjsKBiCWIYbR/jSvP/5if/3f/jCN3H2L/o48xWNuPKXrKnH0gUOukW1h98AHuPrjGaGuTzX6umL84pNnDQCzdLgI//tEPOH32HCfvfZA8t0rtEqKfo1XediMAySqSZs0TLwsRFm6oM9FRQDPfk3WUNOyO9dIVVg0dLvydUIO9ju4YW+bcJfjOTZIW13kXMQbvPINej8eeOMeLL/2c915/GV8HRCzJPe87qMztxjH3/CiwdeyL6ElHyV7QCn2H54oR8JEPajVY9RMm5CVVSBGjteUWBGyzlztT0TZf1DE2bQXaBepE3v0HFi5JsjcWSWTGaYJMnGSJ9XZSXkz3WIRqpCHyVivXhZWY5a3fKZHGSYsmfjcWXCL0ksVYbmutVv28jaYDgSzPtYhmMmGNULs6lp2ZQwXiJSFCZAaRJsOlOTHEcxolwYhmtPtALg4JjtHSiEdPn+MrX/nznDh5PybrkfwuQjJZo5BK2tTC8O/EJN3Lz7XXdx/n1F88Pwl3TaLzrK4t88xzX+DD997l8odv6zxKpgy7S7zBUtSO4B0/eeNtnjeOyWgZP/H06gl/af0QTx4+Rm8yYzze1grAojXLqlIdh+ID0i/orS/DBdi5eIXtiTBYWaZe62NGA+TYQWTd4faNyILBOSgGyvz91JM5Q9iZYqZTbJEz3bnF9rsfsH5kH+INvhgoM60qjRTwHlPkBGMoltYwf/t3WD/c5/1vfIdez1L3cmyuP0V/gO31wRqyYUHdy3C2gKKHtQaxGS7PKNb3ATA6vA+7PNAqFMaqb8a0c6bzlyE2fiLg84z9z5zl2ku/4IV/9N9w12iJ1ZN3s/Tgg6w8/jjZ0aPY5WWFZyXA+goPnTvL8re+znVTYILDBTBWqCLE7F2t9aVC4Nb1G/zpd77NkSPHyVcLUHHYaKkpw38XzYQQFbmWWKXZswnOaelNRFoLZI/mU4vUvRdctEjHd0K7SQme8xdIe14XYUljVvhLOHrkIM8+8zmuffAhW5sbgEZEmshnnA8N503v2C20u9f+W0R0un8vtiIJ3jfjTlZRw4uS7zcq5YIwGIyYpIiuJLjnnj+feoFoYnI7+y33U/+T8nnP/Lg+6fgUlsv85C2yJUEIsU+3WMUFU++DvRz+pOGHNgnJdvwwaZOlsMMUOZasmiayQtpoBptZRksjrZlD64zq9ftMJ5NGMwFhOBwwHo9jfo4KFLEWE0Nfq9msecfUWVFDDbVxWSpalzaQD6lPAo18CKGmJ5BJ4MTJB/mNP/+7nD73LP1eT1G/1MgohSM3s9KJ0Alp/u90pT55Df897qC/QsAiPPjAg5x+8ln++NIFhBLxMqfdKmQScLlHqpLvX77G9ZVVBvkANi7xF2XA7x05zsjDdDLBVZ4iy5Fcc3hs9LfUvoK6ZmtjEyOG5axgeHQdvGDygiAWP9H2B1kA3880ZNuAo8aIw/sK6S/j6orgHdV0ir++BTe3tETK8hCTgVZ7E81qdjWh10NqjzM5Jz7/JTbe+4jq0gWC0Y6c1lqyIidYIesVBDHkRR+KHrXNsEtD7NGDjA6t0rtxSafPlTG81aj1IAbf0SnU6g3RulaazZ3BD/rc9Ruf59q//dcMX32P3lsf4P7187y/b4nsvlOMnjnH8pfOMbjnHoIZcewLz3Lf1/6Y6tgqV8Zb7JQu7glIJYZq78jEIibwq5/9hNNnznLm3DOYrBcFgZ8PXgkt42npap42Oh82x5xSSRsa3YWMoGNMpL87jHcu/NZIm2a+cCxaLXNjaLS/eZJeHGP3s35uefiRJ3jtwVf41c9+gDFVRCUimtIRwnsdi8Jj8bu9Qotb31W8b0RPmuKS0YrR62JJplgYOL2U917LLHV6Ry2+Z3JndCHxBI01dwrJCr3tK+55/JmSKCH6Enzn5Wkn0dU1XZtlL/9IkxSJNI3D5jDKjtQ2xmA75p5L1oY11M6RoW1JtcGWRjp4l+5PA7XRPANu3brV+Ij0LXQxtctbut5gjcFmmZbYB3yt/SpNFAoSDeRUU0yfGZDoxD105Bif+eyXeO7zv8HagUM4r1EjOi9E6O/2lsZ/yGPxvp/WiknErea4ZzTscfapp3jjzRd55/VfN1hyN5jD47HA5qzi9brklgd36yO+mhX8rfseZhhg68pVjDVah65QJ3twTi2K2MOC2vPipfc4dvgI6yfvYjrqQz9nuDrCOIPffwBvrTaas5Zs2EO80/40eR8wWmplbRVXznB5xiwXyqs3YVSQGUFyIBe8NWpVCFinkERvEnDDEXc9+wzv/psP6WWZ1l/KlO7y2CYh6/WobIZdWaF/6jhy4gCSZWSbm9jJTOfdWC0u6rQevtik+CpbTQ71Rt0QwWUGXMno+HGWnzzD5P1rHKxq6s2r7Ls8xVy+xewnL3Pln/8x2e99lrW/9DusnLybU/ec4Ec3PqK0I3JS9e92DTOTmtoFqrrkO9/6Y+4+dYoDh+6C4LSYd5IXdNCGloo6/1YGFJIlsweMlujIdYTQ4rddcbMXzTb8I8x/lv7uXruIlMwx7OY8dl0rraQneDhw6BCnz5/nrTdeZvPWDJ/q6gXNN/MLjHdOwVqAvLrP6lo5yTI0sdRRSuEwxuC8o1cU1K7Gh5rl5WWCC+yMJ9ESVMXXBxjvjFH2GHN3mmcpv7EIxF4tqUBwCkFOMCch8qbQrooqzXcuYe5YuGQpd6GqGrNscSKTaa/afEqu7GiyhM7LpgnXiU0+m6T2ezoYbzduPD4v9YDXhj+hKR29tbWF855QO/I8J3jPdKr9K1J2qbY2Nk3ZfHVId9o2Bz/X4bKq66idxI1j1F8jaEhzllmF9GKmvQ2BUW/EI4+f5jf//O9y6t4HVIOoa6xR53y7Z+Z0hGjx7LYLP94x2eh5C/ds16c5cw+t7o4hhtDZsDF/48SJ45w7/1kuffA+9c4GzqfN76KG7DgQCi7OxmzkBWHm+Jwr+AcnH+PgpGK2PabICw3hTuPyqKM6MkM76JPdtQ/ey7C9HsMTx9jZ3MJNJtzYvsl0a4x741U8gSpzWOcpc6EQqOuSwWBA5gKDw0fJV1eY9QzT8VWq6x+y/UfvUvUM9U/WKe69m9VHH2LtoUcYHD+BDAY44xBv1R/mHSsP3MvK/kP47S21Zq0lyzJsEJy1uH1LFPffQ3biCCHPMM7D9jZhaxPKaVytqOcGr/5Jp0EPQVIOx25BbxPnGPRZeeRhbn37x+xcv0ImhuWVVVztsc5jPrxE9V//My796Bcc/l//Zzxw9gxHv3aBm8MMn9VQ695bWV5hPB7H/kqh8aW+8cZrvPTir/jM5/fTK3qNfzFRVdOJdo42mt28J2y2eIT0eXMbaUAFPT0x1sVbhc5vaSj+Yy2VOcVWiOVmOxZSRDhuq+AFwCICjzz2CG+cOc+Pvv8NjKtwIRbIiTyhaw2kd9kzAKEzpmZfRwsu8SNdbrUmUnRYnudUlVZCmU4mTb8ZEs9oEqIVjtcClzrPmseXJlhRpm7twV2+HpGmHlpr7bY86k6OOxYu3eiFpL0kDSLLsqZHdAidhRHV/tt/d3QS0zbcEhGKPGc4HLK5tQXQNrOKtJyckKK3af6dhFqyHlLmvURhGEKgVxRYa5lMJpoAZbRUvoQ0serYzKzV/vWh2S2qrUc4rHn3WIhRjAJY4hWmF1+SCZw5c57nvvBbPPTYaQaDYXOf0OCwt5/nsGi2z313GwHTvV+yY29zj73M/jsVMq1KACEosfbynEcfP82LL7zA2y/+kBS+bIwl4ClcIBfP1WpGjeMpB3/n/kc4LDmVm7K0vELW61FOZ4S6JnNoSfsio+r3WDpxFJcZrl29QuVqbm3d4ptv/4LZqMCuLcPqCE4dIBQ5tp9jc4MVoZxOqXc22Ll+kWrrA6qNDfqXfoqdlhTG0rtWsu/CDqvOYCRg3gxMfvATyt6Aa0ePsu83Ps/hr3yJ/oP3wmhAFSpsVWGHI1ZP3s/ll3/BKkGDBzJLyIT82AHsgycw+/dpaRw3A++Q6YzgSpqWi2IQ57Qgp3OI0xDrFnFqbJZGj/exfIcRYeWug2wd2kf51iXyLMeVjlmpnUxzMWQYNn76C974z//PHP6t32C/D2R4Jq7CkwPELOuWsUDM1QyBb/7Jn3Df/Q9x1933kWRJCFptoBEMC/TXDdVvhWf7Hq01FuauS3+0vPwOoru4HXUvnDNniUTlsNPnaDEPZDHgKI0c0WoLK0srnD3/FG+9/jKXPnq/EQoK0buYwhAZcOzB1O/3qapa24KH0BT4bd68eQ6sra1RVRU7Ozs4FyGtqJCLwPb2NpAy5tsSMCmgI+37EGnJuYDJtAq9d76B8ZuK8EngmnnB4mNVjgT3BXyEbBVlCreBIxePOxYudV3PhdeJCHXtqesKCGRZPnd+iNw+TbIxGoGizvqUGNgSQFVVbG1ttS1D44QTBYeLGaRNLa89GOJcKRqgDr5tfhMbcRmxsZCigI9jMEHDOn1oQn1DiE6sWC5DI9tSAc6UCKUZ9yKQGcuJ4/fw+S98kTPnn2H5wFFCMARf7zKFdX7aBfr394V0a/2Ezs/t7/tngt4SdBPVMmPAh4ojRw5y/plnuXjhLepbV2OJcg2AyLBUwbDjHXdPpvxHh+7jdNanV3sk7yNk7OyMyYOQFTm+sFhgNh2zOdnm9fffYLw8ZDPzTINj37334754HkuN2Iy8XxAQbcuaxQgvEfJyTDnqYYbqvK/2reIn25Tbm9iNKfmVCUNy8rh5LELfG0Yz8O9cZOeD/4EL33qetb/82+z7vd8iP3iAKu9hndA7fJDslQIX/W5eAsX6EvnRdWoDjGdIDy3rubONjHcQ7zTZFjBZBjaLvcmDQmPJ7xYZtRCFfmQE2kBKodalo4eYHV6hHuT0JKPaLgkhVskwMJlNGPSGZC+/hT91kuACM1dBZhv5VtexWkOkg6SIWYErlz7iRz98nv2HjtLvD3DO35ZGw4Ils2ekIZ28q08isV1W0e1zQfbaT7uEw9z9EjJCZ2s05tKe906+j5Tjce9993H2qWf41tdvUk53mppbNsuwWcZ0NmvaDasCahLcEhWI3ZFbCb7f3Nyccxn44CIvk/hZ2nqd8UqsFtCULVAEyDmPscK+tVU2Njej5REiqoTCYKkPDvNVBdLkhJAqTptmjkK4fZ7h4vFnSqJsK3cKeZ7PQUh6tMQUOmvng2A8SFCcz+ObicjzHOddpxldlJJx8cUHNLpEMEZDARXOYhfzbir/oht/Gp32RHNRMcw2Oi1EoaLCkziZBhE1hzVwgGhSRy9L8Ni4oEurq3zh81/iuc/+FgcPHyUzBlwg+AqT2V3+pDTWj4e69j72vubPICg6x52OoRueH2ccHzyFNTz62OO89sppfvXj7yDOU7uazPYY9DPszW0OlBV/ff8JPnvoENzawVeK93vrGPb7iHimruT6xiaXCsf2sSWqU4dhZYl8OGLnJ7+mHk/Y//knyUd98J6l4ZDhcMhoacjS2gr9pRWKwYCtjZt89MF7bJYz6C+pM98F6iCYOtDbhOEOFD4ZCoIJhsL0CWRk1jCqK/KLV6n+m3/OlZ+/zr7/+C9QPHmOYDN6Rw+TF0OcmxB6hl6/wA5yXDnDVAMoPBIczGbIzg5sb2ufiQgl+ywjFBlkRuuQhRrx0fyd43wqcCR4VVJCha8dxfp+hvedoh6+RLW1Te0qMuUVbM8m1N5T2D71KOfmtVtc7vWojaWOEZhB0GAFaDRvki8j7ocfP/+nnDl7llP3PYxgaRnOfC6U+ia6dfUSfSdYqKvidG3f9G+9JqTglnjOPKQ0f91e1vdef+/176QbNXcNyjD13L32QbRORBXa4WjEmfPP8Nabb/L2ay+oEus9RVY0c5iSHXu9IqIlCvFKp+JxF8FIAkPTa1yTu9I4+ZPlsCCUUgQn0ARd6D1DhN49O9s7TSXklFDR3Kdjbe66bzO2FHSEGgsie0KWex2fLlpM2gSdrgWTIh660r4Zv3STrtIERAmeZ3jRni918B0qlAZLTdmjglcIAQ3xnY9ai+adtJhwolPnnWYth4irNtLfK7QTtPeHMak2msI9AR87tKGLG8AEhfK0Z5ZhNBjx8GOP85Wv/g733v8g1maKl6pE0iCDEBofy8dpXt3j0wudBLek/90BrNBZqy7O2tymO56FsQGtxoYhOMf6+j7OPvU0H779Kpcuvk9mDVlmOJAVrLDJ/f0VvrTvENzYwJgeflQAgeAqLm/e4kJ9i1sHevgnDiNHD5GPhvR6BT765CSa4uV0zGxnkzwvyLIhRc8yXB2yvLzCcHUfdjBktLZCXljemU3ZuDHG2pzKCBRCZg3F2FGMFdeugbw3IJecajrFGo9zgognOFjxBbOfvsi7H73O3f+r/yXD809jjh+m/8BJ6hd+jYn0TWGRXo5YG4uLeqSaQVlinNeItu78BzRcvq4R49G6ca0VEKLlIl57suBK8CUmQDZaYfnYca44x+qsxLkKY1VrLmP747oO9JdWeGG8wUeFIMaTeahT8cnI6BKe7gWC0ZyszBo2bt7g+e9paPLS8r45JXGePmXBSE501aWX5I8Ic9/tFh7tv9NXXQY8T78fL1Tm79+h4lTPP/LPeSd7OjN0LlGIKPlUfQgcu+senjz3FJc/eIeNrZtYayirUu9nUm96YdDrU85mKliUkTQQlHedjP00jYmndeYuQWIB5lseN2+V5l+iApzmWPmxi3XAQgiINXqa77zjbebOGFG3gU/qtNKjJoX/h66KHP0L3cz59JLOuSacretE6x4i2vo2pBxLY1qSMqE1+YS29ImVuFi6aMZqyGaIlkRb8j8uQNNvITSEo34d1xCTFYN3juA1Mkw7QXpa2RbApByWVoOKYFlsbRo4dd99/M7v/j6PnX6SwWAYQ1d9jDaL5me8X7t288Q+v/E++eiGKc5d8+8Jq+2lS97unHnRFT81goltYh898zRXr1/DVGNm5RTGNXdPPV88cYIlZ5BBnxmBa9s3eX/nOtfzivLQCvbB+1laX2cwGOKxBANlrSGf3nmqqgSgnsyYbE8Y+x3qyZT6QMVwMERWDbZXEIw20dp/8ACzyRE2b3yIeC3sl4VAPnYM3r1FXoIRr4740oPE8FIMeQzfDLFNwWA4YvjBZS79yz/m1IMPUayus//ME1x+7wOcm+IM5KIBId4GxNVQzZCq0u6VwwEsLWP6mqHfBL4kxhAC+JpI6C39hgBOLRZcTXBVLOluyE8c4Uo1YTSd0TMB72sqaq1rlgvZ6ogPC+G7mztcWV9hkOWIqwnO4zqMFZhLGRARSqd92n/1819w9uxTPPrEOUxWRObS+hUaGugyya6VEVqKahnYovXSudNtlKq9QmhbSpxXjJrcGRLq0T0tNNBky8H1XqmSetKB46fpLo1VYhB6WcYjjz7BKy+/wMsv/AzvanxTVbhVHG7euEHbxiDeMzYpTNG2IWV7g47NR/ZBEi76ceJDmrYR6yt2hESIVd2b+RKitRIV6lj9PfGvBnuYUwzSNYBVr4uvYrRmmifQCtx3cHyqUGSXIKrQ1sVJoXRd6dfNxm9rggV8qDHBqAM0aB6MzURNLxImG2jq5nuj7T5DwKMwVYpCk9amRbxHMhv9NaL1dbxveqX41DJUpIHwRCKjjln2LtQaupceDZFpohPrtcmZXm94+KGHOPfUM4jNtVdCPHd31Ek3dzl+dpve4+n4OGGz1wbcrQm2537ifT+tYNrThNZNuLy0zKNnn+KV137NjfffJMeQ1TVnjt3D8aLPpUsX+YgpNwYF4+ND/Oq99PYvsTzo4QYFSEZts2bTeO9xVU09m7H91gWK/asUK0NGoz5Fket35Yzp9ha1d1riJLMEp9cPBj28ryPdqQUgN8bkN6f0nIAo+VuUhgyKj+s8Cc4HJtMJYezpe8PVV97G39giZCP6Bw8xuvck8s7b2KzQvVHXmFlJqEvMpETqWkvxLw+RpREUebMuwWv9OCVjhb+0F06rJeI1+Tb4UqEx8dr62xr6+1bYtrATPLnJ2alKHDU2M9CzlGtDfgC8MRpgSmFc15oEF7vwNRboQn6FTy2Rge3tLb777W9z96kHGC2va1h3x5Jo6GlOOwm7PrsTjP6TaDeNdfHoyqwkBOYe37FGmv0ubbXnOQ0emqKcKpcif+nUNAwBjK84dPgIp89/hls3r3Pxg3eoa9eiACHEQtbtXDdKWepe0FhyyX/bOtpbWaOhxCn7vovWaJ09OmWhfLN2bdgwzfgTTOYjopKUWgkpgXJ+3m2eUZalNlN0Pla2bp91J8edw2K+Jb7UiCuVae5q012rpa23oxCU0obHOxBjIxEnx367qdOkh+Srgo7wj/2qEdUYnIshc3oTYwzifJNgaWxMxLRaPbbNK4mFJoNqaWJ8s8A+BNWAOxqPMQKG2Mcw8NOf/YwvfeV32H/4SEMgi3p/AwU2ZqTeUGs3+bnzbxex1RUmc6GCexx/Fh/Ov8/R1SitVU3qgXtOcfbJp/n+Rx/hxps8NRqxVO/wzbffQB44gTz4ADIaUUQt0IlHMkNfDMahZfFt1LYCuDoQKsf0/YsceOgkp589x9r6Pvr9HtWsZGtrR7sohhi5aAwhJjdWZakCqi5xwZFVDnnjKv2ZpRoUDHt9/Pa2WilOLVkjqvgYm1PXMzIjVAYyn5NNxgQ31TbNtWHp4YcYX7+sOQ5VBZMJVGqByM6Yqqox+9fUYulCGTEkNDgXS9yETkfeROUAHgk1wc0Ivo79TjJlRkVOKULIc7arGSF4rAiFKQjL67w8q/nBasZ2llHFsvxSCyG+o/MVDXOb27MtYxKBV195kVde/BXnn/0CJuu3TLczyjnavTOl9ra01NznU5w/93kHCZh3fEuLHsVxJg2/NW+6lhDagZMYTbrwFGMtDz/6OG+8+hIffXgB7yu6vor0sDQWm5h+Z/yNZZWsmIV5bYaOtP2nACdtmLI6FWK+IPOK5rzbgAjRx1pkhLkcO0npEUGbn02npSrghFjOv/3+TnnMnYFnoLH4Ltb8TXklC0dibs45nGsjt1QwaEOjzBqyqOWn+mGqkeiCS7AYLLG7PO1m05c0nWdBLMFgTWNKJvKoXK1d4pqeCYEQNIopEZiYVKpaBYwKfC17YUKyWqIbLO02K2ANly5f5Fvf+mNcNW1ani5OecJMA46u8y0qRC3xf4yWtyhQFiNk9orOmaPxuXP22pCh83Obj7vXp5uHloAlWnYSAsv9nCfOP8ORkw+QG8PNyYQXqm3sV59FzjxMvm8/RX+J3mCJzObkoqGUzgfqTAi5jeul9JHZjEG/j4hGhK0fWMMWhmANawcPcPf993H47hPYLMM7F4kfwLCzPaacVUqrLiBvXWNlI9BbW6dY24cXDT3HB3JjyK3SXr83IMtz+v0hyZcdXCDf2Ob6r1/A5IDNKA4cJt+/ht8eY29uYq7fgsvX4eJV3NUb+I1NwtZYi3c6H6PoWsad/IDGtOpyswohxNjgWsOYXYlBfY7BO3xVxZJLDi/gjBBGI+rVNV5fGvK1fsG1wZDgtYUxlccbS+09Pji1liJtWGvbLO2GOet+8XXJt7/1da5fu4xzdWMBwHyxxi6tdX+6dLv4czuaXzx/r/vf7jAiDR/Y6ycps8nyktAaW3NqYHy2MU21zeZwQSGw/WsrnH3qWVYOHNk1NnXCh+jPjeG+c+hFu9bBK321186/a4K7up1/kw88xHQK5Z2qkaX96GOI++K8Nm+b4Ezp+oQFG/+TYNEu5vPjvtPjjoVLMjmFaFI2ZnGEtcRG2Eo/S/VoQiCW8TAUNmP/vmXyXCcheLBikWDixMQIsY4V1ETY+AgdWBPvrU54Y3Kih51oJGHEakXd2KSn6X0tApJaknaqBHhpilMaEUwAcYGUdpsEJPH+BA09/O53vsH7776tmele31URjmR2dhRW8S0V6wwh2OZcYq3mvSIxNFonft+cnw6/x4aTVK1MNwiJWey9tkKKa19c8zZUUZrzoAlhjPCOYroegqf0nruOHubcs18gjFZ4qR4zeu4s9uABsv4AW/SQIiOPZbVSyQoTxyk+Psl7XKVMMIuOSGMteX9AZgtcNeXG1atsb22ztLzGYLikikJVqc/OwGzqoA5IXWE2Z3Bhg+FwBclzqp0tDUsWIcsKsqxHnvVxRqiNdmysgqOSgBQZ9DL6E8+V/+v/k1f+d/97bv6Tf0r5q5fprx6lrCvCzgR/c4y7cZNqc4NqZ1vHL9o0zVel5rYAOKfVIvCq8ITQvHfquKU5BQHqCuOilREMDofUNePN62RbE5z1GBswgyH0l/nw0AG+lk94a21AFfJ2nVAHbcrIFms1go0uI4sr3dCJpXI17737Nr/++c+YzSbadlpoaOtOIK9PeyQLYJ5Zd75LNNkVVh31LkTtu1tUKd2kyxy7CF4jfJKw8SnStSOWOhs69T669777eOyJc0hWIDiNEt3Vsj0QJBBMaJa4yx8klWlP9cKaOdDIWGIgUV4UiNGqISpEgra69gbNwtVCo03dsdCGHXfVR50zfVnVl5NQinwoCZsYUetqp3X3YmRuuEOxccewmC3ymDkaaz6FxHh1QMm30k5qas/Z1aYF7xPuqcxqzlcTG9UATQa+SIxo6Zjv1hq8Txmn7WYMRIEgKuxaSe90vJF7JjmRLBgl4rgQ0RyWEOWBkcaGku7GE9je2eEbX/8Tjh09wWhptakqQDoXfeYn7782Oq7RJtI8dv+QVqtpP+6GcHZ/x30QFq6P2umcKLoNnJH8YHP2dvdmtPPVwA4Ecpvx+OknefFXj3D03mMsHz1EVU1j9WctP5GUFZPWANXUU/l6V5aaoV/XlNMxBHj0936T/miZ2XTGzavXme5MEHOLte0xh4/fTdbz+NkMYwMhCzCdUs22sdWU8O51VnZ65KWn2rlJXjsKMUiRE4IwywzjUJNlhh1fquALWtfMeIlZ9IblHc/2n/yQD7/+I6oDqxz97a+wul5QWkOoLSY4ghUqHzBZRiWG4B1Zp3tfEsRC1jbcas3BdsOg5WGC08KFYnWtg6/YvvAhWemwWYEnY3z4btb/o7/KO4x593vfooxZ3kFiFQu08GCzlNLuPe/1c8XrY0hyUAYqkiEC3/72H3H/ww9z4uQDmIy5PdnQUJdCklC4A+GzF4zVOKpbYmxosvuMxYiwBhbqXDY/shRaO++8T/f7JGg5hfOC+pNHwyFnz57ljdde4O3XXoh5b10u0PqTW8HmGwbuQ0w5gUbR8gsloZz3YEyTruGqqrHQkvDQcOMUMRtnTkSzL5xvInyPHDnC9evXmc1mShed/jTtbHWUcWNUVQ0BkxCYOzRJ7jxazLvGRAviiaCROpGSRAudyUuDozXvqtqzsblD7eKLS6stSZpUM0+ojZQNaiEZYyh6PWbTKcYK3oEJpl1AH/AxVLhBojotSBV3jO/kXDPmhmgb4oxl8mP4oY0lXtI9QhCsZPzsJz/m/LmnOP/0Z6IqPn+0iJKwQMvtsxc26O32YyDK0iZIIG3AKMpC6zxMjr7EBtoj2h8NAdKsQafGf+faOXHV3jF0LZtWuITgESwHDx3gvoceYWnjAxyBzOaxLpk6HX2jgZnmDbx3jJb6rOzbz+UPZ0w3dgiuYvNXr1GPpxx54H6W1g+yZDP6o31c/egjLl64wOyjiwQMR04cp9/LFSoyQqBCQom/dovBuzfp3Swp6yl5MNjeCJdZCltQ4jChIhcFZGsDYxs13xC0rAyCtxmFFzL6lH3D4N7jmGHQGmWFRiVmAULltBKyMQQcGZps7KoKiHvTOTAuOvZbiCqFC4WQPlcBAzmI1WRxajbffIuBMdRmyPjME9z1v/j7LD19noOvvs7BC5e49e4vVXil/SWi0KAkZUIDCEAtdaWbbr6K7t3ku71+/QrPf+/b/JVDx7HLS63iAR/LjO/ke9hbCC1+0qYSdITQXpul847dmyUrrvloQbDcbqy7niEdJ70Ip06e4tz557j04QdU0x2tOUaC6iOsFbdXJ+4U75NfRJrkbRObZHeFkckynPds7WyT/HOaL2PjfDhGy0vMyhlVWXXGqfmBAk17k0tXLhOcb8rMNG0QbjPrRmL4cnAcPHiAz33+M/zRH39t95zvcdx5EqWTmCXcYoBpodvEoKR0CU00Vkcb8ATKulbGH3NJCAETK/dZpGm21cwPtqnVY63BBYcLHpNbylkVTUnwUfhpf5ZoRQViclEbcJCiw5JzC5IJ6mMDsTTemMhkrRb4yzRXpqpqFSxGs/VdXfOtb36DU/c/xPr+gwuzphu02bQLZnk6FrWlXX4XaJudJYGyQBQhxhBKNMkkGXXpwdBF5dp70Fp0ex3JokqbQKvpBkLqFB9ozPxmdA6ywnHP3SeYvbNBcFvqbM8L8jz2QSfDG9eY3qC+uiOH9nPygQe4deV9NtyMXn/AYDgEgd5giLcZ0h/SP1hw98oKR0+c4Ma1y1RVzcUPP+DIgXWKvo0l8KGYVkxeuUR2YRtTA/kyLB1guv8wrK+wsdQndzX1R+8RJtfY2bjJZj+jPL4Pb4VqPKHcGiv0lVvy4YA8K1hdWuau+47C0CDe0auELHjNgww1RZbjqhlMp2Rb2+RCI1yoHVQqXExsDdFB4OMvFSwhxsiLNQRjoPbU5ZRrr32IDO6i+P0/z4n/2d9g5+ARbrmKu0/dzeNPPc3lj95kMilxTUqxaJfMSPsqNNQdnDTxVhAlkogKoFe295Mf/ZAnn3yKBx47TZ7nc1bEIu1+GsjsE8+T+fM+9vzkA+xeqFdBZMxIctS3CuedCkAVEAm1USEw6A84e+4ZXn35ZV554UfaqiDFDzOv3qXKH43FQdJ/TRNM1FpdMXRYHdSxmCUtn3MultESZrNpbHES75kqNhuhrmpsnmkxYeewdPpsNeW52mi4XcImYnfXb9ziT/7kG4zH5SfOFXwaWCyYGNZbR2kmjR9EQ9ySjttxbJkUailkeU7RyxmPJwiq5UkUSJIIW9jFZL1md2kIeIzRno6nMSwyoNGRHbPa0BbVlG7YXAzxjLZk8hclodTkGDQ4rmLTLmKv5XSmC29s48sJcXO+8sqrvPTrX/PZL35Z4bjOM1oDoWW+aeN2Rc0clpw0tHhGA2MkvUdoWzqn84mx+l0DLLT/aDZSo/1FBtDoCaG5dzRoOuNs1K52LkPQ0Nj0SVOo1Kip7YW15RE3ix7MxmQWDdg30ZcQw83VaRr9LUbIi5wsE5aXlyjXJmAsMtT6bDIcQH+E6Q2RnlNLwhgO55bpdMKlSxe4fvEDjtx1hFBmWPGUF69Tv7uBpc/m4YNkn/8Mh778FfIH76PeN2KQFxQ7Y37+j/9fyPe+ztVbF7mxNmL0wBpT5+CWwQ9ByppMDH4wwvf7TIoBt2ygJlCIJsUNrNITErS9MwG/vY1FGBaFwhtAqGuoK8XCbUawtYYchxpCjAaLwkWcCiRv0H+HmunmFubYQxz/P/19Rk+eYWIMUoG3ll4v5/EzZ3np1Rd596VfIi40uH3tXANd694KGIlRlZFRuqgRSzT7Q4C69gRj2NnZ4Xvf/SbHTt7D2up+IlrDXP3ADj03Sski8w6f4BbuJF+0kM08Hc+dflvB0F7b+HGVfKMSvFdO3m57qfvnIiwHELzj2OEjPP3MZ7jw3pvMNjao8IQ0L0ErgxMFSoh035TCj0FNKTgaUm6LChYfeaohRN5mmmvFA9KJco3KtgSlSSeBvChaFcMIoW7pIDUeI/HvOQRCmmcYa3HOs709Rcx8qa/bHZ+izXH74q2Ua0Pb2gz9jnlpRDOrxVJW2kfadbKCrbWNBBWjDb+kmfh0n5bBduPUXa2lWooiV+Lfg5Cb+0gnokKkqT6bCMu5ipAWLnFXpGk3TBdaaCwBTdz0cSG+8fWv8fCjj7D/0DH1vUiqf5byX/TvVlf5ZG0t0K458bq2XXPnnvF9fRR3KaxVl0xhD5JwSa/QhN2lXxIdfwtCLsIl+m8lOA9R2AWCMRFeIZrfxKRYq/1O4j2sFWyMmAk+IMFjDfT7A3q9Aktg59Yt6qpke2ub5ZU1fFnjZhXXPrjMgftOUuxbww6GkGn0mJiedpusK/K8Ym1tH9feep3J6oDRYBmZlZSvXGVYHGXylWc5/rd+n+H5J6jzPjOvm38WPAyXOPzbX+XDt94mu3EFu9bH2IzMClL08ANHyGp6NiMvehRZDxmM8LbPLORopozH154c3RNV8tRWATetyKYlVa1+l6oqqcsZ1gjUOWQl1KUmUvpU7LWO/66VhiQH56iZEeyQR//gb1OPDjCJZdGNIYY4ew4f2s+5s09x5b232Ny8RfAJpgnUdd1GZzYEkLB6RSCKPItWlnZdDVGRNAIvv/gCr734a84/8zmyrAfMd2Jc9J/c1irv0nXLNiLdt+fv8qkkTbpz6V5H1O+aZ4bm3q3AuZ1QanPpotLWaHF7W/khBDIjPPHEGV5++df88offA6eMO1V770Z0qQBP7xP5hKdpiR53sQYBNFMVE8Jrh4kVR0wMY0/ITLJurLEIJhaqTCHHMX+0w3ZStG6Yexd9Tw10apXi1MIkBPaMFN7ruPNOlERpFgVIU1ytKS/dYUpxAbrniICrvSZRxuiFsqo0RC8o40owW5cg98RiQwrrFKbT2RwRpedCJ+lKB9hOYgAXITmRAFZwtWqKmWTaepnupW146y7HJR7Ec+HCu/zg+e/zu3/xr4DNW8gpEZC0bvRdEO7i+yXNKm6zLjacEu80mmjOOOmMiabNc/Pv+Ltx0DejoWPJLQiWhTdtajBBzLnoPEPaTUDQhmqTzVuEqsSEQGYMeZGBc0iWYzLLsL/EaNQnL7RJ204/p5rN+OjCR1y5dIVyMsWWNRd/+TJn/vJvszQYEqZTwihDbB8pYtRMXRHqKUur+9kajJiOtxlScv3dK/i7P8/6P/gqB577Im40YILB1JorIGjY5cTB6mOPcfmzX2D83pvYART9JVy9Db0cKQucEXwweJtBnpMPBzhrKYNXWFeMhgaL0RL8JieIVcY8mxG2dyhn2s+lqirKsqSXZRoJVmeIKwl1hdgaMBA0ZNjExdMS6QFcTV332F5aI8RKBimDOtFmURQ89thjvPHKo/zsJz/UXJlQk6zQlJGv0Iz6Ej0hlvoIWKtO/KqsqFxNEKMohBiq2Yzvf/0bnLzvAQ4cOkYhGS5asIsQa0hyYIGU5gROUnbSbon0uQiv7WllhC7FdpW39hktvXdO6zw3WTJz92v2h5n/vrsPdynAWtX43NPP8s4br7Nx/YqWjwq+aXgIse5herZYQoh5eklwQhMxC4HUzlji+NTiaAV3WOBtGvnlcU4/t2JiZGK7Pj4qGimX20eBnVAEVEdpXjnVRAvpPnsks+51fIoMfZ0M1djjRHmNkc+yjNms7DiR9TCk7E8T2xZrZWG1XiCEmBBpAsF5RLKYjdrep1uJWU151wgvETNXsdUY09HMWuGm2GLX5Iu1gkSFg7UCZAQvOt4YICANkTdLo9BBTFjr9/tU3uFcjUF4/k+/z9nzT3PsrnuSqadzxx4bKhKmXdx50i282e6FbuBB1Keac9L5jZaThHs7dOZgr/ZRrQBrOEH7nW6sFOmSNEDZdY+GQSRMG6GaTZlu38L6klEv48iRdZaWlsA7qqrCV1OKLAZAaMkHRktLjMdjbl67wc72TP14SaA5B2VN2NnRPVfU2KIHVjC9HJtZTDagvzZiNt2i3DEMHn6Wp/7cU9QH1nGzHlVWY52PTCPTRmYSNEfHZpz86pd59UfPE+oLjArBSg9ngUz7F/lKtcaiV5DlVjektZBr6Zc6QhPeGO2U7LQSchCod3aYTrSfy2w2oypnZJnF5Dkmq8FVGF+Dr3RFXIX4GpHkhZzqhi8d06qH2EIrURhP7b3mezUwjefAgQOcPv8c7777LjevfAR47Y0jEttZSLPevkMsAZjMpkjM5lYoWBmVV+cLb7/9Ji/+4ud84TcPUBUR2pYuRbZMumugNDTTObeh6xTeLrJb++I2VkZSrJp7RNh517mdvTwnIGgsit037u6OZrBd2TT/bDEYC48+9gSvnDnPD779R/i6wopoAFOclTS+FgWJSuecXF5Q7QLgPS6EBu1RBCBZVnpn7xy92LSu9k7bPkTtVExofHtJ+fQ+CWylUR8Cxvk5xTTxqjRmrQywe332Ou44z0Wdtxriq7k5LU6rEWMpF6OVqC1eGqJG1JZvIX7vvdOkLkLHMpo/Fk3s5BBbhMD27JPQsYBSp0qRCHm1+wtrNJHMxNj/pNm1Qi3GvXeekZ4XvEatXb50mW9/6xuU5XSX+a6z0BKZSPokLJyTLJdOqGgjWDpKVEhn66/uHpHufeJP9x6NoEjzKvPPlKQNhXYeWyhhfhOE9OyQVlm3487WFuV4hyIL7Nu3zMED66yuDFlfW2J9bUS/ZzESqOuK8fYOO1s71LUDMVSzKjo49UmjJfAIzmrSrFQVMhnjxluEcgKhxuY52EAtjqoObIc+q49+kcnqMUpXUNsSU1scQmUC4DAoFBRMoA6O4bH9rD79LNuhD4UlSI7YApv3yK3CYb0ip9/rkWWaT5BlBcYUGNsH08OR4UTDR70P1MFTese0LJmV6gidTMbMJlPqqsKVFcHVhLoi+Eoz8V0FodLKygJ4pwUu68B4ZtnI+ngs3gZciJXBFxZfEB546DEeP/0kxmbK/CQ12YvKVocZKznGqM6qpqrrpk1FWvzmfULND773Xa5c/Ig6liZJ99hDBMzRfru/W9pPkVEJ/u4y4C6dpnPn7tv9buFZjY+1I4Tm6L7z7/mfzne+/dzvcW7aFMrcPaPREs999nMcvusEmbUQHLlYzZ0LaPRWQJMc65gX43xTmDVZLCFaDwkB0dRuG/lQiP67zk4UDXi66+gRDu7bh0WaEl0IzTuJSBORptXlpUnixGl0WQJNJe6P1tLtjvGTj08BizmssRhrKGvt36JM1ytTIOW0hBi1oJaEvqD+27k0uCjpuzZn8oV4mRMIyQqZD9MVrM3mXjJJ9HaypRlf9xCIlTNjtYHQka8h5di0MFESMPGEZjzOe2azbtifIMHzw+e/y1NPn+eBh55Q51qz/kn765r3Yc5KSafpRy2kZ+beP8Tr6Gz8aM/4ltjn7gdNIlW6Z8OLJIF38d8hDVV3Q9f8Xyxg56VjLSVBKIEsOLZuXMPMJlhqlpeGWIFQ11QxTyrLewDUbkLjvCpyRv0RS2sHyAZ9JpdfYv/Ff8nT/0lNdWCKNYI3gmSaw+RdpXXI6hqPAV9SlxBCwXa+ykwywGmNOjJi6TANvRVomr6BRgAbw8nTZ3jt599CvCHknpAZyHOsN2TGaRO6rADTQ7KMYAPeBIKBgAGTIz1D6hA7dTV1CBAcZQwTnWxvs7W5BcYytDnDXh9xnuBmmDpHQvS54AELrlKt0ju2qgGBnkJdHojQW9eXkFZ3bXXE42fO8torr3D5w3cwqIXjY529gCY4p1JJiamrdW4I4lQ7jn5IVcYyxAofXrzAj3/4fX7n0CGCyWjCTTpRUuloey/Nj2+e7Lt+Dub23e0g8sVor27hxu58LJ7fvWbRJ7Qrym3BSt/rHqDRqhZDqD333H03p8+cZ+PiJXbKSi3jeL6RiI6I0T5RLkXMouueIP1gmoAJAGwnOCkkuC7BhRFRwlG7kvF0R4NtJDRlZ0LkNSrcbMNHEhSWKqr47kLFtw4SeVesrfgfXLg07Td1VhsBkiZZBcGCJhFSSG9oNjJI09lRzWMPKYGR3eZm9+9FHDYdiwIkSVnbyUDuHq1PqM15SffQyTa7CDr1sGnvIc116TuRwHhnh2994xscP36S5ZX9jUWWFnKv8dzJMX+NLGye3ffrksfit3vlAMwbWSmqbX6e02fd87rms/GqmdWuZPvGRbJ6zKCfkRlLWc6o6xqbWfJYdjzLMlyhgR5Z1iPPe+RFTm84YPXAPnrX/xGSvY4chSDfhp13oH8asE0GP1aZipgM8SW18/j+QSRbwpu8EfqCxwfTwA+Jkab5ECPU3rNy6BCu16dCc3N8XkPpwXiMyciKHJPnGgKaW2yRY7Ic28tZWl5mtDwiCMxmJZubW8x2tjERXvLRvLi1scnlK1eovNN75JZ+kSNVAbYkNEH5amEFKqxzTMslpn6IM1m35+Hei07A+Jp7Tt7H6fPP8a0rH1G5irxXUFfJKhF8/C8dmc30u+TUjgUPNbXANPvVGsvPfvojTp87x8n7HsLaXGG3ZP3ehpH/+xy7/J0fY8V0n9v99yIP2RUw0BFqjd9jj2Ovd0qQcX8w4MlnnuO9197gzdd/RYW2QbDYCMOFJKnaVAmAiNz42jcQQQMc+C7PaVEhVVSjdeKFCxcvQSDWyFOBknhQenZ6Y2utXh+0CWOI3wXnYpMz3e3WWIV42c1rP+74VP1clpeX2d7eJmHwSRqnIyUZSkdjb0wxkwHqNNTw3+hwb2+k9wihgdv2MovTC7b3VUFQ13WsDNoKiVbomTmiEqFJDks+lb0I8XbP7H4/1yhNBBM8L/7yl7z53KucPvsUEt8b5jW29v6fFAo5f3577u0AiD2vXlQm2zskK6WzqZLBrdpoy42DgGkEfXPnuDHinjGGrVs7lDubjIya6nVdMp2Cc54eRaNhSrRAfZjhAmQCZV1SbpaE6XUObrzbEmhwhOsvwb7HwDvAYxIkkxmCBC1/J31k/SSlKXDYSF4d+DG+x+LchgCGwOr+VZYPHSbIBtZ6Qu4VehLIiiI2+AKbac0usYb1g+usrK8xWB7FnBzLZDrFX7rMuKqoyxlVXaoFA1TecWtjg+lsSuVKDjmHzQuyog+5I5gUMquZ9VqXzLJR9RgzUAd7SMrd/Nou0tJoNOLxJ87w1qu/5q3XX6SONffqWDHAu0UNXBv41Z2iswmR8DFHLAUA3LxxnZ/96HmOHjlKb7QKJo9RZbJAb9LAO62ZnPYExD4bu6n2DoVRy+Rl4RktH2+eswspSBZb+jx0mH1CVdoxt0NqzwlRcXQxfDe4wPFjd/HE08/y0Yfvsr11kzq04xQbq6+HuL+MrqdWNYlMPQrz5BcJIfqQu4Zh3LteWkXfGxCiL5pkleo72WS6wxxPBK3O4KIF20ycTq4KJBG6vuw7Oe7Y51KWJWVZRrhkb8bW9C5AY7lBWikbD2tjlnayckLCamM9nI420PgAOoJiETNNTH9uojplxNM58z9daKpjNXX9MwvPSkdXeKXf6W/nAsFDVU755jf+iI2NG02xQmjN0N04Mp152/38Rethr3HtNe7mvEBToK/5WVw7Ig3GsaReEKn7Q/LbOOJ96Y5BIREh4P2U6x99SL8cY0ONC47JbEJVlmRisZHgrbX44JmMx3gvLC+vsLZvH0vLS9paN1tlvP4lLReE4If3UO97BnEluCmC11Ir1Qx8TTA1Ve0JMqQarlNLhKZCiICB+dh5hYALIIM+Z77wG0zsMrUUiAFjDTa3SGYRoyXvg4jCgiEwnc2ovSPvZfRGPYb7llk7fID1I4cwudWqzR1nlXOO0lXs7Gxz6eJFbt24Tl2W2joCQWxOMAVITvAWKs/ORNiSAaW1gGvK4i8Klq7S4sUiwXP38WOcfvJpisFSbFdeN++8iBD4oII7wSUhRL+FiaGxIeAqT1lpAuzPf/Jj3nz9VbyrYvW7GM6/x4+2vkh8Iv40qMVunvJx+7A9Z34OSD6ERLSxskfrfJEuPteVc517yvy4mmu15fCuz0NUHOMeMUDPWB49e5Z7HnwEI7laJJ21IYSmmrEJxJYggQ6ZoIiH7kA/FzLc8q+uBSaSkYccGyzW5Op6SMpvNMJMql0W/c9p8hbnuatsdHnsbmvv9sedO/SNYVrOmoSe7oAgVSNNgqJJv6F1wAv9/pAQAlluyDIbtf7WckjEvigoFh31Xam7uDlUunpuawEQmaTr9F9IGjqtsOhOaPf5XetocUEU3xSQjFdeepkXfvFzXOXU+YqWzO4W+aRxnbGwsKYjvELzLs07J5pu9svHL/aeTNXT4OkSQ2ldIyI0DDOZ+WkEIvpvJ8m5mTZxHJuxbGxsMLvyPlldgdc71pVGruRFpv1WgKr2jKc129OayXTKbDZlMOizsrZGf2kJY3O+8f+7yj/+LzJuHP67bDzyf2BGD1fNtOlVpX3jqUtCNQGBGzeu8MJ7H7EVMrwRasJcnlB6ty7TaSqsBEHIqOuaR8+dZ//Jx6nzfSAFeTZAstgPPRdcFnBGQ4XLcsrWzRuMb27ga41gk94Au7zM6pEjLK2uEcTE+k4dpahyhNrTywqWl5bVaikGBNsHk6s26w3BBLa2a675ZcrQi3i54AJReCZCMHPrDTT+s7xX8PDjp7n/gSdATIz6EmUw8VxFHQzeBerKx3nRvZu2Ujcq04dA7Ry3Nrf4/ne+w/atDU38lPmdlxQR2mVo+pakQ2FagWAIXuIPnb9l4XMg/t0QZ0iCag+li8QROtZroxelzwQt/jhfwmnufgv7rbmvtMp0w+yBQwcPc+bpZxmurMQk4dD4L6BVep0LhGAIsfitx6sV1DhAPTZaT961NJQ2YPKneBzeKDLk61rzm3xAC9/qeF3wHT6j79Hv9xveORfuvcdcdi2YTzruWLjMWQjppboWRNBQRZ9etvm+tQy0dEqY6yNgTBtOvMi0u1K5C3G5Dv7XtUzSPZzzc9d0J7PRQZrSLz5GrM1bN90J3HWPjoWThJT3Hudd1F6gdo5/++/+DdevXdJFDgC7a4+1sFjaekmra7/vanWh3R9x4xLXgl3npDEujjtdn37r2s1fE5LAiFrZvNCPSgMBEzyGgAXcdML1994hTDYhzBCpqWrH9s6EsnY41OFfBc+sdtzc2GRzZ0zlAtNZyc54itic4WjE9qUrvPa173H8N/465v6/Cr11AoG6Lgl1TfA1xF4nbjbGu5Lvfe/7/LOvfZ3LFy7gXCxPg7Zqbdlb+yONpdiZM2Mg6/PkZ75Mse8eQm8Zl5WQZfhcsJnVItzRF1GWJdNZycbWJhub25TTGeAQaxjsX+fQvScplpYwRS9Cw6qlWoF9qyvcdfw4K8sr5HmujcB6PUKW42KDveBh2w+YZCMqsoZZd2kmrdWiotVW5/UcOXKIM+efYmllDUssLYONQoaWcdNGSiqjiyl9xmJs1giGAEhmwQgvv/wSL/76l1SzWQONLx6q7CemPM8/dp0bWt/HnIaOKggNJDW3nouQIK1W3vlImiK3gpdEB5Gmw7z91FoQHRQkKcHNO8X36vAWFTqOLATOPH6Gh8+cw2Q5hJi8HTTyCx8gwogdmRMRHFXIU0HdVnh1FNL0Y0Qz+SXWgEzfhBbZ6U5XEhDdn+5a3E6B7vLHOznuWLi0r7Lw6R5m1e2sirIsAUNVecqyok79IVI/i87Kthn/6dntkWUanZJK4Rurjch8cNSuIixIZx/aIoTdieqOb968lLnP25BrFTqpztheEWkhRNM4s1y+fJEfPP9d6tkEzWzfDc10IcRkyXSZXfs70Fo6XWGTSosna0MtjuadSQwj7N74CzDg/JyE+eekVeiMS2EywXmtsXbpwrtUVy6xVhiKmI0/nVaMJ1NmZakdP53Decd0NuXWxiZlVWOsMq6qrplOZoDw8v/w78h6BWf+2u/SG2h/FcTgaod3M80LCTWhnlLPprz565f57vd+yodXrvHdb/9bxtNJ90XZXZRzjyPBVh6KlQMcvvc0rtincFijvRuFxiTi5hi8McycZ3Nrm8l4gp/NoHYEX3P05N08cvZJDp64myy2OTYok7NitURH0LAgiVa3JK+XaM5Vla1Smj5Ospi8upcgST/pfeOvoJpvnhkefuRRHn3sHFYyFS5BGmbddGvtKHYAPkgTpu59yhyPQid4fNCinN/59je5fu3KXFJ1M0bVhBrn8u4ad2HPvxfXJrH1vd69e22ylVoFLGn36UaxhEqs+efnrulaBIvj1N8tWBUaZXqv8VJXrC4t8eTTz7F28Agiljz1sUcj9VJIuCCIM+AE8UajFV0cSlNJfh4KC0F5pzGmaZjX7s/oJxHBxt9dtVWVcEdd12xubjb3bBCdeI/uNXcGhrXHHQuXEIvoheDiz/wCN7Vt+BgCgWjKthWGXXBkRYbJDFmezfky9EVdDADQH0zA5IJYweHwOPJeQdYrMJltzL6uEhOM4uOO+R4Pi6GOe/l2uptKHWWBqkoFF/2uc513OhdRI/nT732XD957VzOsY0Jp92ev580xiWZ8HUGwCzLYvUET5JOeo1Bb99myy+ztRsnFO7XrGQKL+LWIiVaL48ZH7zG58h6njox44NQRTtx1iIPr6wwHOcN+wdJwwGgwZHlpyIH1NUaDHsHVSAjkeU6WZeBjnFRZce2Nt3n893+b5WNHNETdqpbtvaMsJ/hqSjkbc2tzg5//8lf8l//0v+fVG4aZWH72y5/z9qsv4n0VrcbdCtBeh/PaBSczhtp7jj/wEL1DJ/HZKmQxWkoyMBleDJgMU/QIJqMGNrZ3uHLlKps3Nqi2dmAyw/iaIyfv4vSzz3Dsnnt0Pb0gXhiPZ4x3ZiAZIeZE+PE2MtnG1LM4bos3JhXLJ2US7XqDqN02sBEGhXgULvJ1YP/+fZx/6jkOHLkHaw02qLNXG1t5ff6CD1MZlEYLuaomuFZzrZ3TfB6EDy68z89/+mPKcronF0pMfBGwXlROWfiuux8agcEu0m2UrLTHPZ1Iqc51XohRe1GUSPwMwYEqS+m8ON7G0p1DGNr32JuatKoBBh544EGeOPMUWdEDI+Q9i0kwa+q10snSD1Fwhzj/Tf8Pn6poK9O30eJZGo7oZ0UnZUF28bbdSnCcbxEtvRXnT+v/mWa+0rmNWhtCk3bwScenihbrwlVKzTSRISLEBK1G78ImfSFOAkSJHxmnoPVyjDFNsIBpnPrgvMZ/a1BACo00VFQaxBD7C7hQUWQF3gmFzSBIbOXqWx9KHLuJkyUwpwWkY2lJnZ7T6TROLMpUIzNWfHh3SHIzLyEyAFU6uXH9uhb7u+sueksr8T0ikXZNgXivrsXWFhlMm0knuqtZ6glxPNFkThBCc0ZI1Qg6llADLEQ1Kr5fGk0zX3OMIgptUUEbvEPEcfPiB5RXL3D3CtxzbB8941lf61P0h0ynE3a2trACgzyj6GVkRcaoN2JrY4vtrW36ecbyaMhoaUjRy3n7+z9h69IVzvzV30OylHgbqKoZwZcEHHkmzGYl77z3Dv/mT57nFxe22PIDRKC6ucWffvubnDhxktUDhyJxOuaqJixskETTEgVYEKE3WuLAqYe48P4rDNw2IpnSgQgmz8jzPmItkmVIVlA5uHr9JrXzHJeMZWsxzlL6KSKWtX0rzfOMCNWspKxqvFi9b1kSQqXtAjIh2J6OOcSET/zc+kXDNzKgec09QTy6vppTFkLg5L338/i5z3D50kWyMFFLKKRCtLXu6ehTAWUmKQCm0YpjRYDgPYPhCFfW+LrmB3/6PR58+BHuuf8hjMmUCUkiW2nqUXZp705DlJUWO1FnexwSQqcMUYe2u1ul+baz73b9Eb9d3KKhc6W01wgtszZoNKpGwGmxx5XhgGee+QxvvvoCly68qVwxQVjek1oEik0pDcni6j67tQK7uXHee3Y2t2LRynY86TuBXeVa0nwbYzT6L56bgmy8D82YALVoDfM85w6OT+HQ17yEri9CUmJeZ3WMVUxarY0YRS+eOjhqX+PifyGG2rnaMd6ZUNeu0cDVEkp6B82GThaBq1xjJobgKWcaydYv+uQ2j3HZGnljFC/DBNWKtaRbO8ldwrbWsrW1xc7OTsekj5u40bBafWgvGFBEmigMRTuEX/z8x7z11uu4uo5OVNVCDG3Measptk61RmPr1vTqjKsjdZrPBJpIkDkctQMVBpLgihCcp2kalDaKd17H2zwi5iSJZoV7XyPBs3PtCmHzKgcGGQdXB+QCvnYM+31Gox6rq0OWl/tYK/jYP0JrRY44efIEx44cZH3fMsPRgF5/gMHwg3/037J0cD8rdx0meM1U91VJOd2mmo0pJ2NmswnjcsLNGze5tDVjVufgK3ztsNbw0Qfv8+orL1JXlVrJnfYKezGzxJBDiBprCAQXWD9wCPorQK42X2a11EwqgZ9lkGeqNTvPzs6Emzc3uXXrFjtbW8x2JoRJSTne1hL8QJ5lmmNgrZaMQXClw5cVJsFiXjtOqmyQDg0ox2uER6LNyBAImvkdgo9xCzHaKO6kpaURjz5xmuMnTgIR63chMs55H0dDZz40vgojpimgKEHY3txmVpb4EPjo4oc8//z3GI93ItOKzzWtsiMhwW8tXbVQ8O2h9VQ1orMT9lzHVM05EW7wQSsHL5o9C1tHCI1Wnv6m0dLbHwWf4/zHuWmlQFSCY124xMOc85w4eYqz554hz/vUpQZz6PsoEzfSplXsacXFHx+L/7pYDiZubp2XyB990MwliVZJOrIsI8/zuVYjrlZemrL5JQnHjmBNingzlju0XO7c52KEvJdTBxdNyUCwoq07M/BGk8R8qAnBa2SEUSnrvPZgCUbU/JKAx1NWFa4ONJEeUWCoSHJqmYiHGGURJEJRmiwTg+oUGhKs4vkRv/ZBGURdu3iuYpyqfe8uQJmi0vacuGiWppiMrn9ikRC6oXu6EFBOS7777W8x3tkiSIYPWm9IiQVAM2Q1S7YDMaaf5JFOe6YjdufH21GnEqQWwLuOI65jaXXNfTGtsElCOb1nY1FhqJ1oxrurqDauUmxd5VBecmgpo1fkzCZjqnKK2Pjw4NB2vp6yUud3GtvyygrHT5xg//o6w+Vl8uGQd57/KRdfepVn/+4fUFczqtkOk51NqtkYX83w1YzcQNYbcujkPVy+usGFWztUcY0Nukmu3bzOt775x9y6cQW8w7sWFmjWvmmgrkzBeU8dS13oZvX0ihyTD7H5iCLrkecFwRgkyyCzSKGOeGykRg9VWTObzRS+MDFKLgSqmZZ/CWIIxuKtoYzPDXXdgU7BOKCqIbgIzSRMvVUu0io3q50YW4wWkuBbhhkZKsFz8sRdPHn+KYrRKtoWV/EGzTuybb+mzrEYPJNoqEEZohD52U9/wttvvMZsNlHha2yEWyT6GtQHoLTddQ7vFixd7i/m4yDkjmmBJnLOuf9DwKryPX9NaP0lEiKKlbQt9ZDqNcrFmp+0EcXHhmvBE5KyKPpeWmEhxD2lVcGfPP8Ux08+QAhWozXjuFP0asrV685580MbmaZh4QqQpo6UhFjVPQYXhAjruU6wUwjq956PlI0oU6cCvNAiTQhtxGhS/P+D57nUFZs72yBQB21S48VHoeKQzGNyjy0Em8UM7F5O3suT/yw63js1b2gx3xAXOkiItca0N7iYJLNp4a000QlblPgmmUEyHVcwutDGCHluG2JLkVFd/1DjM4qL12XsGnuuPwmBTYx50cHWPZJQCEGj5H7585/z0q9/EetGeS0sJ2hoYnxnH3zchF39jJYJNuNIwjbNT6uahYijN0Qe9daqquagEzpPaBmGXlv7Gh8cYsD5GsRr109QAp5OYOMqS7NbrGYlK31hZalgWFh6maU/6MUuoTU4H2twZVp63Hu8i4EXAnm/T29lnWxlH/QGPP9f/VOOPPog9zx3Vq2V2ZTZdMx0uhMdoNpsbLB/P5icty5eZTP2LvK1Kh7Oe8q65p133uYnP/4hVT0hMB+vr0oKczkRgQTBJm1U6UE7klpsniOZjfi8IHmGWEte5AwGAwajEUurK4yWR0hmmZQl2+MJs6rEu8B4e6z3tDn0+hoZJoZZXBsJgVA6QlkRyhJfzsBpVJcGFrVjd9Eh2+yHEGJUnPrCqtqpQ9iFxJUaO3k4HPLYmfMcP/kQgRj+GlKinFrbEver8jKZY/Tz0G2CnT11XbK9cYs//c632NnaiHPcKkipcOJiyaO9lDqFu5P/Ybe/YPHvxk+pThX9SXCT7OGj6myBEEKbjkPHzxJSekX6UpCQlFDXKJ1zllBkzgQ7d70Ex+Fjxzn77OdZWtmn94jjXkQvWqYfEZu4vi54bf6mpo4q0fGVAypIgvca9t6UlZFmjheTzJs1pLWAVXHvzKmerGMVmSt4+knHnXeijIlVNYq7+zipPmhCl7VC8BUuGLwaCxS20MzPWYWrPYUpdNA6WwRShIwSUGYtNlPtOESHFhLQJHdD8Fq23/lAEO1b4APkhcUWGTbP6EmfuqyZzaZ4nzLK2xDOyIIbYkuCwYYIb0cNTIu6tb6eQJzTEDdwIgyj2p5zKdxYPzcmtl722nCs9jO+9m/+FUv9ApsVYAx5r0cQ2/icrM3oF/2FjdAK10ByKitUYqO/KhYVRhCc7/pFaMY2nk1ZWlpW4o++hxSkl+ZDYpj3dDZjMByoY7uqozar3/UkMHIlI7ZZzkocNUWRkxUZuTgk65EVChs5VzdwTZ5nMYFWy1LUdYWxObbow2CE9Ie8+i+/xsUXXuF3//P/DZWvKGcTalciwVPVNc6AL0tWltcplpZ469XXefPSVaa1IbjUSEk3mbYVd3zvO9/ioUce4sTJeyHkWstJVEhWqTBjaPHlJswdh8mE6XiMlGPwMyh6BBHEGlzw5KLMt8hzhqPhXC296WzGzY0NekXBtCyZTiZUB9/l9P8Rctkh7w3o9QuWl1e1LHrcs6IvoBqy09YFtbMayCKRoXi1roy1rSWKQIQeTZbhqpLSe0yKToryQX2jcOjoXTz02Gk+ePc1xttbyiytaSLAGqXJQYLPiMiCNSlXBvI8i+0qiL2YAi/9+pe8+uILPPXc55GiiJq1jtMlxYw2mknTYxoW2zDU1j+icFDqd9LgNvHPZr8EGh8GDSOMO0honpsEQMsPoh+jEUKGFMLTnNs8pF2o1j6ioT0foSWDiQmjrZVks5zHTp/lpV//ihd+fhO8+pmTb9jsYtqtUq2Pje8V0n5V80QSooPu7RA7UjYQ94IyQEj+8fYpKnRSEqc0gs+nOY/KR6pSfyfHndcWy0MTzhoC5DHCxESgOgTbavlZwFc1IevR7/fZnnh8XeKyoO2BQyo8qS9mTUbwNWIgywOzmdMKxbklZkdob/MyEpwokXqnmn/lKkyldXLKqqKuZtS+iuM0OI9aSN5F33crfVMl5uA9SytLTGcTylmJacqMd53nyhybboNGkAyyInYCjPCTSYsTI8pMhEzef+89/u//6P8GVkOVq6qKjLdQRhG1zCQARbR0tjVaciTERDeb2U6fhrhJggZDeK9MUZP+EiEFsn5B8J66rLEm126aXiEU5xwYyPJeI3azPEeM0O/18U7zOY6vrfHbnz3HkZPHKDKoqxoR1ZI0MMNiTMDGUvqhcgTnyYwlz3JMrhnuiApuYzKkKAj9AoLnykuvcuSxB7nrqdNMJptMJ2PqukR8TekcRgLLwyWW9u3DVSU/+sFP+OiWI7hMNWOTGJc02vK1Kxf5p//4v+LosaNI7NXTVE0IxAxmrQ9hjcVHiWu9hVBztKhZ276mhdPid2IMNtOyPs4HyqpEJkKeZfR6A4wtcDEHxntP5Uqma89z9z/8BpKBn32djX93lGzzQUZLQ2xmCV7p2VhPEI+fTXDBslM7fvr8r7gVlnFBIrSssEuWakOJhkarZerJMktdlWotWhu196hEiAGxZFnObOciQWqtLRaSlUojJOvY3CxFFTWKWYjaDEoDRMFlYnj2rJzwrW/8O0ajnJW1/UqzViNBgygD9CFgjfolq0rpJ89zjGivdy/aqMwE5nwEKVctwU2CKoXGqMU2q0rdH8ZGphsIIe13QQscRDoxppkfH+rIeDVaSq1Cj7UZEOk7Bl4kAUy0EhNEaW2LYKSAiCSIA4KxwtIw46HHHuOVl39FPa5wJioGcXyphpcR9em10GN0tEfFKMQmYCEIwThsJmRYSqduCyMKtdvoI+seTU5h5GtJYCQFWqRNKg8R9tSgkk+RucKnEC5FTzXgqnKEoNqzyYSiyLExcse7aIpGRl66KcNiQAonNllObNHWSE4jlqKXMZvVQI0pciTzBOMphhmz0tPv9RAPZTnBeWUIPjgtae1Va63KGSKOlFCscIcjZOCoEGuo5wq+Re3dRD3DGMbjnSaXpXYuKbUKVUHsAgexRZs2FTMBydTnI+IpbEFdO3XaqSxotCdE2JpOyXoWCTWurqF2mHqmlpKIOmOjUmFtpn6YQNu3xoCYTAVYCrON2mAEucgKQ9bvUZclrq6xxlKUCuFUVU1wkcBqTygVLxYr5P2eMqc8pygybe1sLbm19L3jqWdPc++hVaab1/GZVd9HZshMhoSCTLKI3YZomju1KIzBZBm210ey2Hu9DgRr8b0Cawq2Ll7mZ//t/5ff+d/+Q4pRweX3rzMZb1PXNeOdWxgP6/vWWTl+Ahn0+OjDC/z0V28wcwbroTYRcGlaI4TGj/buu+9y4f33QVxkokn7Mpg8wwWnEKoYbKykUM0qesHz5QePsf/AELFamcDGvAKb2ahFesq6wk1q+n2FxoajkfobnYbuzmbbhOPPI5kya9ObMnzoBapfPBCjcKAqS4Qo1AXK7SluqeC1l17mv/v//BOuuxznkk8sJR+7aI3YCGHOyIuc4GuMETKbUVW6Z02sXNxAShKwuaWq1eHtAkjItCwTQWuLdbRuT0BijpcyJrTyQpCoKGhCZR1qbGZ45/23+Ef/5X+BMbm+l2khoBACy8tLmAzGkwll6ZFgsDb6f0QtiSzLyG2Bq5U5NwU2Q1CBghbSNNaQZblW941NBJOGD+rLNKKCQIyJJWrQSD+JiEVwsX27aZUOk3yPrSJqrcHYjIBWLU6S1YjuUyMx/84qA9ecOJ1T50ps1ufmzS18tdPAlCT/ZnQzaCkYmsRLROHNUAdCbPmu/iJPakiXcgXFawBV6iAaWcb8IZ0qJwn6gqZ3khbuUIWigddF0SsfPFb2SgbffdyxcKndjCxT7ci7AAY8dWR2Vh1YAbyIWg22xuQ5mzvXCbbG9gXTUympuJ6j3+9hxNMfWiauBCsE6yB3FP0cO3C4qsQWhZrnRgu3qWSNpazFqH/AZtSUZFb7XGCtMjAB28swxlLWMxUUsdhcglJ90HwZEwxiVeC4aQ3BINZodzeBkAueGueqSKha5M8WPSQ3TLYdRZFjcsEFR1071dQjMRBhtGhOqICwGVhLLaqVOIJqxZE4AmgkXR0xEws2B0STF7UJm2kgD7GWWe3wlVfLzutmKStHZgXbswQXGv+VQysk4B22p0yidg7jM7L+gMl0Ri84fuu5Z3jonruoZmNmkwm9omCQJ5jLaLkJY/FBmo2VIlGyvEfW70Heg6xHsAYJBrEZ0lMY8Cf/j39Ktb3DkcfuxxgtEdTrFYS6ZrKzQ89Y1tbWKJaWCF740+88z7ub29S+ZpZHq6P2sR2rrlvtvJbpDwGxqkR4H7TmVqy7FGyEW2Nmsw3aPM5bx7LN2b++RpAJNhtgU4HAyAF9ZHKEQOVqmMJ43KMYDunlPZzAtByzdWuMe/kQB4+/glhdk9lHDzYQ56yqqDY3GfZ7DJaXKPp93CCn2tnh337t62xYy7SuCJIhWtufDIPNc6q6Vj8hAW97gFGXc+3IJeBFcCbDZtpcTAJRK3e4KjHfEpupnywvssYHUlUuQsOOPFPLY9DvUbqa6WymvMDH5lJxX/Z6BTYXJuMx08oR/Cx26lQY19W1hmEHhy2EqtZxuNJTFAUiNInQRgy5LahrjTYNRiDm20FAvPpXjVWrWeuiqXLhXYjoiIb2auklj3jbCDgwBCuYjAb+9jHyKu8V5HlOVeted66iLGdYKyrIsEwnFTilB8lpSq6IiFaJrmOljyAxGrMmBMP+A4eQoMFBYk0T+df4ogTt7mnafD2RaMWlttbxnWvXtrBOflIJCd6PcJmobR4zyWOwjSgfgKaFfUgPJ65rtAY14jAeJhDsPHD/7y1cTBYo+pa6hrL05JnF+YDzJdQZri6xRugN+lSFZTqrsZkQJDDc16Oc1bEJlGAyoa5q+st9BqMBN67fwGWOIJZpNaEYWAZLBZWfkvWEOlS42oENhBxq0Q59LniKfKDGQaY2tBSW4GZNM62QCdkgJ8uEsvaIM/g6msXRPAwEjBVqavI8AzGYgcXVMbksMktjAlkWEBcxy7h5MY68yKldj+3xmF4vQwpPZoXcZhrF5lwsgKgbQsTG+1TkPUsV1DlLoZBgOS3xXrB5hpEajUrNNSHUlCrQnVqBoUOotjBYI+Q2UNYabZeCFLx4FdqqBWCN9pAXqw7crFcRgmhtKTKyYUFezXj85D2ceeAkxpXUrkZDZWsMlv8/a38aa/m65/dBn2f+D2utPdV45ntvj+lu24F27LYVJ3YcFEwcGwERhgwSDpAQQA4SRiJISEhIwBsIIpAAdjCJnQGLNsaOHQ9xB7eHdrfdbbfdbfd4+5577zl1qmrX3nut9R+ekRe/f1X3y7w4Vzqqc+vsc2rvtf7reX6/76i12yZ5h1LCDbxjibbLsm1iC5yD0NN8oGkjF4xSPHz+OX/zj/wxfuC/+k+xf+8RJa08fvqYsiZOD0dCsBzGHfubG8zY8/P/4Bf4kz/yE7w6wqQaFoNxmrX92rRtJXJhtimNtwbgX/20KisTmjFyMQlJBzUo6rLwvZ98wE3fsCXRGNA2iBTZ2HcsmCjt5HnKNXOeJvTdPcN+JHhHzoUXf/tn+bn/6Y/x1f+e4iv/wg3li9+E+uIHCL6T9xGBP2OJ+LrlQ7XMn/3z/wl/6e//fRb3iFongZ3tNgw0aUAtb6UtysjkWRtWaZH9p4RzjlIjummcd6wxgWNrSCwCCDrQuiJpLqLofIvxZzLaadIWNnuO8zuo9e0RI0m8op467C8YdgMvXr5gXSOpFnGIm80XZeQQjXX7LFaZynNV6CqCn7opgGrVVKMpFNaUYdtsrJFn/q1nrr79rKsN4kFMsMJTvfVJCaeRVds64GUqlz4b+VkEAitU1VhLpqi3xmIN1aCMF9WaUWjrUGumpS1sVBm0kfDaX5vHVvPGLSHROSjFq5dfgG50fS/Kw1bJWVS2pcmFJAOtQLHWKEwRIVVNkqygsbAhLl3Xk3OktEwr6h382GgUJT1cTovAQCBwubjfiixQ9d37qZT5NZDYlgCA2s5fLc+m/pIvFzd4tFVYC9VWrq523D8kYl4xCmwAqPidwzRLmxXaC/5dc0UFIwSjQl401/A78H1jLAF1TqQo2PrV1R4XFOmU8DtH6BRpzmAgRsjlLWEO2uZ3GKQ2Bu8t81pwvQXfyC1ju0boLVk5dFbkmCilklZIOcu20hms0YBEkoduICbx6xor8EAuiXAYiBFSLOicBVYxGeszts84CiFYbN6yrZrgntN5RWlLGDYlD41mwFuF7zQURU4JOxi0KlASrYLtFOS6tX9mXGdwHRgNyzmhkU0EpdChYbrKuO9wxnK6K5S4Jd22Sr9zJDVjrIPa6EZLOGhOd4WcK9UlnOvQWWF0JrjKxx+8x2/8/h9A1YKpZsNzG7RM2xgfq4xg0kZT1eaPKXXDvX8Vami2g/ExKgTZOtMKcebH/83/G2Vd+Uf+xd8LacGrgukGamgcDjuqfkatATv03E8P/Ik//af4+jyRlcVuz0FTFW3qFpDZ0LpuRK3Cd55cIiUVrLLk3LBe4/eBumbivBVzqQa24W3lax8/4Xs+vMKUBeMC1suGrrVFbdumcHUbNLVlNNVWmNeJSmWxhvPdPd/8i3+d9Xbl4W//Y3zxZ38DVo8cLhVu6ASCrRHTFHGtzHGlTYq/+mN/jT/053+UW+UI7YTWirQZSKUoTSbvUhrOapwTgYIyWj5vbeMajKLZSiGhqwJV8J2lqs1rUSGlRlGZVhbWFGX421IpUAqljWx2WQaUX+XVxVIgohvhru6ORx7mE7lktNWSPWfkuHpbD04rNCubvHziFKjGsp4wVhOCwEHOWawz5HmFJHJqY/WmRjXUnMlFUTUYDzUnkVyXX42IatsFpGDjAqUATSmFMo2iEgpDFVcjIArTtxCzVDwLmiGcSkFvF4kJhqXKEK1NJtcEpsp22rZzzsrPJmo6OZS1U2gD2jcRzFhFI1MAZWTb1nULrnRQtGwk+q2qNJvt4hForKhEoaFMRemCqpWxH1jmzLpWlK7gkpwhSpCb2gpNy/unmkKbhrZvA3vNJojZxkSVaSrTqsI6K3/2l3m5dIOj1ohVkHVlvOm5nV+jjGB+wXtUq7ggRkXne5k2asNajTOaw0WH0op5mrF2pOpKsxXXNVxq1KJxvtENltoizhvczuI6yJ1mNhnOFZXlAdBaY4za3mxRZ2lVsRZCkCRapw3dzqB0Zjxs6+y5SSumzqSa8X3gcNkLjlwzuRWKWmg644MnBEdOGZ09djDQKdSi0VFSa11n8J2jVvF3+CAyUWpDG4c2jqpXIbc7S0sbadkU1hmct1g0KSmUqXhveWuv6jqN1gPHN5Ng0WrBO4F4egMgke/GWbrBs7vo2F8MWK24fhJ49fI1tTnO8xG3d+Tt8Bj7EVpjNw7oIbIuDZqRDy6KtK50tucHvutr7IcAm3SXjddSG6H4LnutyvT1tl1PhBoabwzKOtAWjEd3OzCBllcgcvfpN/mpP/bD/Prf/Tu5vNqh8krZCsC8cTQqSVm63SVxPvGf/Md/gb/y2acwGjwWlrxh7RWjRL+vvWbYGVKNoGB/4UlJsZ4bRjVybmhTGfaa5DRvQ0drBa8a3/X4Mb/xk/cZYhSPyq9mX2xwhIQevlXqlbZJP7d8sFor8zxR18jP/5Ef5u5nfpGPfvc/wZPf9oPk2FBO7jFR0An53qzGNY1LlR//Bz/FH/7//ElmH/BrQQUwQWOawvtAnCM5VVIpWGdpKtPvAiyNnDPWazIb3KvMtnkXcl3BKpSTa9dIgSHaO2putFRIcUFrgQu1k+2ypgxF4Ddl5edv28ZhlN74GFC6UYi0CsYK9CSKuio8n5ZnyBiN94aUVhFHuE0xpkGZQrfrCd4znRcur68xJ8hloqTEW0+W0oLFWWdoWm1QsSEWUWDZjWOqqqKtCE2UBZOEOzbWUGvGaEutUEom9B21bWpDrfDBUlpG1YxxitB7cskYI/SA6wzVWKyzEo9TZfuxRpz51mrKW6gOTdr+PLERiPfqXa0BSb7Kgg0Ks8GDxm1bd5Qb0gbNWjNNg3GW2mCOJ1TTOA9GV8qaeDg/ENciEJ63YCotF5QxlCQXqUZhlZKBxTb6ITDNK85a4cgbGNOgSIo3gHf+y1eLOW9YlgZG4Z2jqBUfoCVQVIx2eCddHDFFQu+oxwfKKgYhq8GPo7T70RiGwDzPOC+ZSnGBmjW+b2jbiClje8v+0hEGw3SqlFypRaOTvNDGObQSXNX5jViumpgtlYgfHc45Qh9IJRGCQSkLrqOVjPUNPwSc9zgvsJLTFtf1LMvKsjRc7wmdR6+VADSbcEqmDpMNtMowaJpKuCA+m/GyQ9GYzgtdF1AoCp5aKtoWrq53UtrU3nJGkd5bfHPMy0LThcOjgZQSofPUVOgvHVoblrjihiDTWJMDvNODcAi6MVwYbFfoOsN7T5/x6FlPTI0vXn/OMA7c3YHVnq4zxJjo9x3f9+EP8PKLV9zdvqaBYN+143suPuS9R9eolGi2UbRGa5mojBKnurUbif/2gWuCN4OQosZomvWoMEIYt54Si1IZVOP1L/w8UPnBf+534TpD2yL56xZw2ZRC9wOZwo/85b/En/3Zn2IaNN6LYbK7CNCqmHEJrEumloTZGbRy+KDQJmFDw+56QLMuBYUBm6k24XaaZgxpXnm23/PrPnqfocih0rQU3TnnN6WOXOjvtKmbeqfyqxEpbzmLu5/9RV7++N9heO8pT//RH0Q5y9h54SWMCECsdRJSaDQ+eF7cv+I/+pE/yxcW8lpwB4tyhcOVcFNaGfLieLhN1KXR9RrrNDpkgmuUaUFbRzcKQVep5EWUhJ03VF1RLrPrA7TGuqZN3NFYz4vAuNvDZTsZfNI5klsFp7GdInSeuKyUtWKUI6WM8hljwTjFzfUVx+MDMSXZLJvauAhDq8hn2xust8zzQmka5eV11a5hh4p1DZMr1892PDZ7fvZnf0HOiJrBKblsi3qXdWaNTN+1AUFjlBD5OSuw0sdTWqbZjXxXCbNxOEoLausHRcqVHCPNaExwMsEn4S9spzCIlF4UdJW+l4O4xbL9c5ECNzL9ECi1iJCoFHyr1BpFTGE1zVT0FqtircTpaAtVCzyva0GZgkGRt4DTcTfSvChorRWDeo6yVShxOKBbJVfxHFpXMaFsCSsyVGCgpQq5QpMt2HdO3oOlEjr5eXMq7Pd7uv6Ch4fz1ksE8V0f0Jd0ufSD5ur6EbGsnNYH1vxA6CUQkta4vtlzdXODN4Fvf/4thr0hN8sxzXJgBy14b9D0o+dw4Rj3mf0YWCbL+fRAGDXjvufqUcdpWbm5uULpmaYKCsvDm0mMfEahrMJ6ufFRlYubkZYry2ml6ytYGPYBrTxpjVxdjPRD4NWbe9nqM4SdJgyWrvMkCikldv3Ak8c3vHx9y8krbDD0odEHKbRqRtb983Hi+DCxC55xMFg/8PploqZG2FvGoUPfZh5d7Ugpk5io2qAbdGNDW482iv3uwO3tS3KKGGVp2nK5P6BM5f74gPWNtBSCFYipRkcYO4K3LPOZm+u9EI8xU2ph2HuW9UzoBnK+5fH1wFc++i5+8u8KP/Pkao82huN5IiVDyQ9c7p8y+ht+pT5AUzy5foypmu99/DVsrOgKVIG7sAK1aA3OalHs/ZpJ5p0aSW/x9MbSXE9zO1R3QVEGTaG1RDre89f+zT/MD/ye38nV196n6rZdkmZT/BWUdlTd+Nmf/gn+3N/7Me4G2GEJoeN8njHa0PcDWhvWZWGeE7ko+tEzjD3GZoHEcqViyAWiTgyhJ1iNz5p1SvhesSs9v/njr/FIaXSqGGuxTmOchU3y/TbxXEhbswUltneO61ZlSHn4B7/ML/yRH6Z//oTv+u/+s5jOY41h6EeCc1ivJICzJbrQY60hUfnLv/IzHPcGvXiMzhwOPTpkDo86Ys6oqtHFkfIZZQp+lzlcjShbmU4zQ2j4AKEPcgFU0NFQYub9956xv9zz5nQv72WtqGnDjAqEfqCiWOdIiol+VHivmbVGdQFlZEs/XHao7Hj9xRuc9qgM1jas2yKCfGK89jCld0OHNgZjLa1q9NQYekdtlaTX7d+3ArO1gg4N5QudNtwvn/H0+TVPP+54c7vVBGgtk3hTtFUCNbVtGKNxo6MpTYkZkwtqlS3VWE8rGe0afbAbPK+JS9m4BoUZssREZQ0aTEhC9mfZyvqdQEWpFNJSMarh3VbhXaIMe5tYxWpDGEAZy7pE4poZgkCyemPnreedGstqi6lKZO2InL8W+d611hgazjjCqElO1JCtLBjVaDqL0s+KHNop8aXVUrG+bkpfGc6VBusbuipaUuim0Ap21x1xnXAhY0Jmf9Hx5u4BExKXjw4oXzhOZ5rRImL4Mi+XYYDri8CHn3wHf/+Xf47TfOTJo0uoldP5jHUK5VbGfcdzfYUJlfN8otuLkfLqak8sBWPhMHQ8eTQyhGt00wTfs98pYlFUEsNeYyfLxaVjTUf6YGAfmI4TOUXAok3myeOdfJgd3DwaOD6cwVr6NrI/OEkNRXF/f+b995/z8Udf4e/8zE9zXleontPDgrFw/eiAUoW4VObTwsfvvc/1Yc8vfvOXCYPn4jAwnx74+KNr+lFUSN/67BVXe8d7z59ScuPxzft849PP+MZn38SHyPXjkf1uxyfvfUhcEv2uclozvR9pVGqboCkeP3ZY7Xg4ZlIB5xQffXgFVNo3T5TWcJ1g2n0faK2n1ozVlsE6nj0KPH58RU6ah9OZMHq+/dmRcajsD3B+84paPmDsDblJ9EPnBp7ffMjt/StyjZyO3+Tp06dY+5SH+5nOKD65+pAuW3JcxZRmxZtgMXjn8cFJGrU1m6Nbpve2mTi1sjRtwDqa8zTfY1wAGuRESyvf+Gt/g6//6N/gB/4r/xOMdaI43GJ+sBpipuaFb3z9V/jRf/C3OLrCzsPj/Y7d4YJf+da3cL7n8nJHSivnk+PZs5HKQmuVYbD0/cDxeEfKhVw8c6xYU+k8HPqB0xJJwXDt93zsb3haHPp0JFiLdxbttqkSJONLbzJN/WvdyptMXCmRlabCr/y//zx5Wvjq7/tnGJ8/pRYJW805y/3s3CZvTyQLS678ysMLZj/z7INrcIVjXLi63BNGS+g0b+4fqAWeXt9ween59os7ci0MF5Xdrud0goeHCdc5nNeoaDC6w5wTaVE8eXbNJx9/wtc//zqvbl+QVoVrBasdSms6H1DKcn/3gLM7QudY1wTG0imPNqBUouvgKx99zLf2mvNpJSW9waCKoirVrCJnx27DgkJ7GIaeFBu4xO4QiOtKtQMpN7pgGcbAuk4YLduw8RnjEheXnm58RDMvUcaxxESlkXMl2YwuDWM83lqMlaT1PBfGsGcYL7dK6ZmgNF5pnj17SgiBF69eMp1XckoysDrhIIK1At1tsFjJFU3lcGUwJnB7eyStcXv+xVCea8MHj9UCA6Jhd/DsDh2ff/s1VctgQdM0MrnM+FG8geuSt/oQQzsnrDLvooNkucoorwmjo5mGV7It0eRyUMoCBmUkrqhTgVJhXc90weBtx3SatsdT4TpN6ALzNNOiJhjNcG1Z7xLeKq5uep4/f4r9lsL7juYS739yw3Hy3N4/EIv7ci+X3/ADH1BS5P1nHt9/wKtXd1ij6HtFqjvu7s8cH16z6wee3VyzpjtKNIQPbgDwxhJLZppPfPd3fUJvHY+uDqzrPes8873f+RgbRnKKzMtELj37w54lWQ5jh1GKR4een//lX6EUzeXhCTfXOzEJGcP+sOPlK7i/z6Acj24Ciow1lnm2vLn9lJTg6dPIfnfNw6tIfrzDd2C7SmBE6Y43b+748P2Bw/5jrm4cD9NLHj+6wOsn9N7Sd401Jfb+MZcXzyktMs0nOr/wG37de1xdV5Z8z5Oniho7vvPja+7v7vBh5OGc6PyFZAg1sK7ShZWbYU/XfcLXv/FNYlwYzMrTR095PDpQls9ff0FpK7t9Rz/0xCWSlhXFwMXB8t6TkdevZw67R+S2oJ9dsd8HgoPRHxhHw0cfDKTmAEunA9eH9/jm55kwWulZyY19d8nHH7xPmRS7eYdexa/0NnbF6E1J0sA5h3P+nV9IbakGvCMB1fb7GrWpxNBWpJTriXp+yV/9P/yfefS1D/m+3/XbNsDdklOkxgVtDbU1Xp3v+eXTa8J7T7go9xzqme//zu/EB8fVvnJ9/T5xnbifXuDsjZg4TU8rlbG7YOyv+PzlZyxp5s1DQhnFedaoZvi+r3w3L27f0BZ43z9CvThipjOdt2gjSj3rPfA20PCt4W0z3xnJydrs3ADkGPn0j/85zp9+xld+9z/B+z/0g5SShMzWCtUq67pSqXjTyUHo4JvTF9z7B67e7zg8/4SvfnzNFw9f0HTCbGblwcsm/vzmQHu258MP9sSoWefIxd5yzjs+/+I1ynlqbZSioTnGXSBOC02duLo2YEaU1jycC2EIWOuJ6wrMoBTDodF3jqvLkWk+8ub1zG44bCq5jLOK957uGPsbbu/uOR7PGN3R8Cw5i0KxKeywY1mky8hY8J2QPGGw7PaWxSVqg14Zcj1z9aijFMfdmxNaBy4uesbe4l3akBMRbITkOU0Tpa30O02tFqXA+4ztNOuaML5x2Hm+8vFHfOPTb/Di5URTcDE4bh57nj99ivYzn708bW+e5uE8obRA4eOuJ+cFbw1GOXovcGZcE84K3GRNwgeHTY5+7ym1kFJk7HtQFe0zYTcQxhPGR64ud+z3B1xwvLz9jG6wnKaZVM9opQhOZM4S4QIqGawxpBQpFGwnyQ2dtxjtxB5RGy5UUioiUjEaY8A6j7OBPjjOD4uQ9NpRSuXqpmN/NfLFF5G0Gpz12L6wV4Grcc8Hz58xDD21nfBdx/F0ZHd5oNvtML5xWtYv93L5/u9+j1bF13JxuOZ7v/Ihd28+R7FQVcZ99YrzqTB2B3a7gc9fTDy+eM7ja4nd0Mpynic+++JTnlwFDvuRmiNdF+gf77i7e4MyCusO0C5ZlogPnqZ7rNEYrbm8dDx73FFzz4fvfQ/T6YQPhlQWKgu7YLnbnbFe0XlN7/cc9k84n2fW92bm+Z7D8xse3XyA++QCbRx3x2/T1IJtnlwU1xeFXL/FfnfFb/i+T3g4jYz9nsPumnU+glppqvK8gFE7YoqUw46YMj4orv6hT3h1+028T+idotXPORwyxleesaPTO5kKQ2CaZaKmQd/t2feSQ/bh8+/Gm8A8nQjdyGevfokl3svDMgwoZZnmM87q7RA98OiTD3lzf8dpmdk9GTA2sxs6aIbdkDh079H1e46niVKPWD3z4fMD2omMuSaFUTuCH1idJp4dNSaCMXTOSn1Cq7Sm3wXstbYZ3TaSr2y/Z7ZMqoakGGADOowiUqiJlmc+/Wt/jW/89b/J7/nf/kG0gaqamNPWlfl4ZMors6qce4267vnq04GuF4Pee88/IqUJZxNXl4+Z55nHyTP0V6zrilaVUhOXh0cEd03nevqd49XLF8zplsaezt1wc3jC88dPePVLX9C+ecafEx3CI+ENxgW0c5ScUE3UbxjJGGtbrhNNSNy3mU2v/ubf4cWP/gRX3/UVvvuf/d3iQ2ka7T26Sl3t28kcoJnGZGbiIVH0yrMnT3F1xxe3M/vdDWXLovNuhxFJJsYkoLAbZ4y+wLQLUEeMhadXHUuqLGvEW8uyrrx+eODRR49wTdH5ex5fVXJ1hGOh8zd471mmM/d399wfV3YXFzy6fsRuZynV8d6TC7wZubl8xHk6EtPM40cdz54+5faN53ja4/2OUjVvjkdiTiwxMS+Z0jJD39F5CL5SOkO3WoadpCGMytI5h/OBq5uelBRxnQgm8MkHz+lC5ep6JJYFra6IURNT4/WbExXDYX9Nzo15vmfYG5a0Mk8NjcUwcZ6+RdetPHoUaDic0jiX0Oqer368IwxXaDOyzAvudaQpxX6/R5uENobdbodFM4SBLvS8en2Hd+DdwmG/ow8HhvGCJU3cnV7xxRcvGHYD49CxpJVaV3Z7z353YOgGDpcjt/e37C81485jQ2NZJoJz9MFTm0cZxek0scwrXe/QUQr1nj29RLXG3d2JcRzErwSc9cyoHftdj1Hy3xsHy+ObG4zWfKYzygTee/YeJWf6vnJ1s6PzIiLq+8C0PuDdyFc++ICbiz3BOa72cFrONH1H45ZnT99j6BW3d/df7uXy9OaG129e0PUdrVhC2DG4K1pLlNY4TW949PwZzliMVXTua3jX8ejqK7x5c0QbMfxd7j1hrGhVMGog+B0xZupO0ZQoJrruwOXBiDFNrZS6YrRmHJ5yc5HQLXBzccXJB4L3nOJnrPnM5eGGq8tArYXeXtH5kcvLx5zOJ+I6UcpjSpvp+o7Bd6AtXb+j4nFqj7M9MV+zrBO7UZNXTX/5hP34WGTEToyYOa0ondFmxenKMBxYkziDtbEM3qFVRFGxwTEtdxh7YNc/g2TpuxEfLjmf96zlzDS/QusTz58esHbg6rDj9vYLnr5/Q0qO990TSu0Zu0eyQjtLa4qUIpCx2mFNR9/B/XHdvDoFbRpdGHCmZ10iu+7Aob/ivP7KpvUfGXcX3N19ge6gdxc4deDNORNTxKLRSkjIXN+m2oooQmkpd9POii7amE3hUmibI19bDzqgwo6m/Radf4ay8M2f+Ns8+o6P+e7f9VtRTtRhNSem+YFPv/gmL+OR3Xs3JDRaLQTl+drHH1F0JeYF5SNXlyOd13gbQF3SmoNWGIY9tRpC2BFMz6Orx2hbcE8Tc5THPujHtKYYSuD1qxU3R4JWOOUx3mHGYfNICBGNUtQtL47N6d0U0ihpLNYqzt/4Nt/+0z9CuLrgO/7bvwdlDAbB62vKaAXBCUxkO0/Slckn1qHRdyO6ZFpaSKWyGwJPbz5C4VjTiVY01gVKXcntDkgYc4Gze4ZhzxoVVhXGwRJTYZ4W9rsLlmXmzfmOx9c3WCVpCNoG9oeO5/MCaLpg0e2G08ORF69f0/cjj28uhFdzjylZYZTEtb98eSJlS+8L4zhw6D2lBYHWVOO8HjlPE9/67CXHqfHs+glD7+i7xhhGnNtxXhdyhtd3hlY11/seHxLjXrMshZvdgcE95/Hlc5b1NYfBYtye9x9dMS+zcJ7nAe8UJYsBMmWPDx1aD2h6lmWmtgwYHo4d2jwhhAs6P+B0gnrGdyNXlzB2T3D2wHleePn6nqKOrPE142jpQ5DgVdPh7MiT6x0pVlL8EO8GdLNoa4h1x+2Dorczzio+ePoBx9OZNZ754Hu/D+d64noilTMPdy/5+PkVrRYu+8DBHbDW0vVip1/WFehx5hGlVN483KMafPXDp1ztr3j1+hXTchazOpp45fBW8ezxI3bjwJs3R6xz7EZHLplhcHz++S2XBwiuR+nE937tq3zn+9/Jt178Cv3omZceYyyXB8/YRa72F3zw7Pt49eYl1izkPPH0WvPhk+covvblXi45J7puIIQeqwes8rR6QtuRssVHeOswRkjP3XBBLRaFF5NPXWgY3n/2EbmeqCWiMDg7EqxmP95QauR8fo1WntCNoBRxXcj1iLWG4Aa0UZTsWJZE3x04jI9Qx4zDYl2H349UKpe7DwR+KCt9GNmFx7RaKBxpJAwBazwtXFNawhmLtwNaHVj8hDEBG8R41/cSb2OVwbiRWDV950EFvA3EdUY7cRC3Vgg7TysL1sgqOthLlnXlev8BKRdinrDWSpIuA7swUEtlv3tCzgqV5aA3qsf6A9SZlKVV0TugVTq/o9jAkt5QmVCm0MrC5eGaPlxhTaC2TOc7UIY1nPD2Em8Gco5oF1E60NkDqau0Nm8BAD2nV6+psaBKpuq6JfJuoWdUBjao6G0nDLwLHnXbWq+0oRmL8j3KdzRloCRUPnP81qf81B/9Yf7xf+1fxAWJ2ai5Mp3ueXX7grt2pnvvkrXLKAe9CXTDgTkttDJDnRn6xzh/g1E9y3pmrbdo3bPbyZBgtKeWjCISXCPmiHWWnb2glsDl7jm3L0/80t/4WdybSo/CWHHy+9GLZLeJhPTtX2yO5XcYGLxTDtna+Af/1/+A9faOH/yf/w959N3fQdd1OGNY1jORFadlc7NWksOjbbQLx80HT5nizPGhoO1CtZFR79h1V5SWSdxtTZgNby269ng3crP7iFwyRc20YjYBBexHCxcXWD0yvtfz5uEIbWXfXRFzI6vM0Pdc7hpLPKNVwZrGo8NzPnrvI2pN1FYwJmxKJsWyzNgA1vYYc8DaDqUUYb+joqEqNIbHZiSVxJPLC07TQt+PItXNK2M3oJTjNJ+4u3/J5XDF0O/YdwbrNMoWGlfUZ47OPUE1TyqephZynfEOme4rPLn8kP3wiLgmatNYq0n1AaWsDIlxIqYZZzUpy1HXWkctkbgecfbA/nDB8WHPYXxCzAv7IfL00VPWuGNaNMZE+tCjtMHqA7lotAl07oA3ouac5zuWdCb0O549CnzwdIfRiY+efj9rLBznX+Lx1Se0uiflM8t6y/tPAr6zqGaYlkzbInT64FG6Mi8naq2M/Z6G5sXLFwTXEcyeR9eP+e6P3+PVm2+RykxTlnWdUBR2fc/hcM1Hz56KqKGcKK3w6Lrx/PGAM5arwxW1ZR5dHdh1T3ly48htJecDyzpTyfTBYA08vnxK73s6X5nWV3Te07mey8PzL/dyCeECY/doZXH2wLK+QZtACB0xRfbDJVApNeN0EBTTNOb1NWucsTZsOL2FaCkqYYzB2x0NxZoe5FCwgVwjVc14v6cURysOay4weo9SjXF/4Hy+pTVxqnfdI2rryeVM5/cYY4lrwbvu7XeP1Z55OW9d7SvYsqUK9IzdFWs648OAd1egH1AU+osDd3evtv53S/DjZu7SMr1jsX5gLSdULXT+ihQXjGloZ0n5REPj7AXWWmJRKG1RDORYpe5WGZzZ02ylqkyqC62KQmmabrkYHbplxnCNNTuMkSiKlCLGGEzrsLqj8xd0ni1PC1pbsdawpIUudBgg5Tes8TVKV/r+Gk3Hmma6rgdGStIcXy+0SaGTkO7Nvu3nBqU0doO73safbEkcQhYaDUpv8SpNCEojLnSR72ZoiZ/+43+K6faO60+e87bZe40ztRX8buD60YHW95zzEd9bcsnkHDE0lLY0a6n1yNoMxqw0CySEE9ISNNj5bosSmSlN8u80oIxn3z3j+CLyjb/1DfTdSq/8FquvsCGgdNiCFiVjy7xN826/KjeW6CWFthpK5pf+v3+J+eUtX/2nfjvPvv978V3PYbfDGkXwkILAa3EuYKu4pC81eZg5Ty9lS/AGpQPSsKo4ry9I+Y6+u6A1xbLc0bTl5uITUtIEHzhNLwEYx0dS4KbPqGZwviOtCzEVLnfPOU6fseQkhkDE72Btw/kDikouR7zZE9wNOc+UFvE+CAdWF9zuAms6OjNS6grIxqa1hIZar7B6pLaKcx3BBa5jkYnfe1qzm8l0xdqGd4XeXwDClwzDSCNynl/SfKULhs5dMS0NpfYigHkb31Mjne+xrtEoGD1I8GSzWN2zphnrC8EPpHJG6Yr3PdeHr/JwvGVNThRkxnN57WktonWiMx373Q0xD6TkacQtQkZRikW/DdNUmeDF7Gm9Z4/byPIdj6+uaaxYs2JsZRjew1sHJHY6UNtjdoNI9y/2T1hiJNcsXKHaIqdUZZrvCH6P1pqLnZWzrB24unwmZu5O/CkxZ3IRcZBWYbOE+HeIEg3WdeFibFgTuLi4JMYV5yrjzuH8U07zG0rqudiJ6Vwbh8ESy4w1iic3T1jWcRsoLancfrmXi9U7rImkXDEWVJJvvNS8ZY45WkHeBLzop1tiTa8oZBxPxOyWK113hWpXEndQCqf5NbG8wfsB5ywtz9SaKEmC31L27IZHaNWJi117QgjkfGKJtzh3Qd8CufQEP6DQzOVEqxHnOmrRpDxjbBHYZituMNrjTE/wPTGdielMrYo1Hsn1iDIJ56xk9qitjKxMWGcxuscoh8ZtcRMzzluCu6LmRm0zzUrSrTGdZEjF6V0wn0JTWqLW82YGDeIHcp6SG9YGYmys64JzwoVYO1JLIheJ0bFGM9hrxvEKmsKaQEqZeX0A3Nb+KNUD3h5QQEwrbPloqSbxgtgn7PdPefP6li/efJMUxfBp3sbjNCkKM6a9+/7f9qC87UVRSuIxMFaC7VpF+YHmRyQKuEBOnF98wY//4f+A7/ydv5nnv+47Yevy6V0gBMcxSMTJ5fVz9OkN6Eg6v2KNJzGEGYeiorE0BcEPlCwqNe/ECLuukdokey7nlVozzmhyhkzj1bdf8Y0f+wbuTcURMM7KkDKMoDU+9CgjEk1V4rsY/rdR5yEEQt9TtrKrr//Jv8inf+Y/44Pf8oP8+n/p96Gc27xTDmfAuo7sNNM5U4OhUdFXlrxfQE/EdkdLGq1HarWgFd6P1NwI7hKaZM1dH76bu+O3ub37Nn24Jud5+wwZfJBK5BhfSghqFpFFKRGjZ7wL0IoYeosmtyj+MBu28FbQdHR2z9oM5AmNRdHQquF8EO7UB1JaNsd6wNkd6zrL1uqclIS1hbJ99qwJ8h6zknIDMkpXhr7nsLtEqwFJGoiSXFE12gBUYn6gthND94Sad1jrOJ4/o7VI3LaRSqS1W87ThALhHXSgYSg1YfW45QPuUPQM3TXaVFI+4qyjqAZYjPGkfCLVB5rS9N01xkgES6oTMZ4Z/GPimoDK0HWklMF3lBIpNaNVxXlHKYbcJpzr2fffQa2RFI/U2nDWsOuvpM1UN7w19LYjl5VpuaPz1wz9BdoMdN6TUmQ/NkrLdN6RywM5R7wzaDVgdAQ6WtMoLMH125k5UYoipokQHIMOKNUo5Z55nUBdcjy9oLYZrTMuHLDmQFONUhdSWmXzV1r4K+0Zumt24xNSXL7cy4W2ENMDYlSrdGGgVEOMC86rzaFrpJFNeelfUHY73AXbNU5RSsOYgT5ckPPKy9uvk3kDZsHaK6zuNlOUx/uBlE6M/QFFY12PeO+YlzucC6iiUdUSfCcJwTRqXUSpspmySl1wTnq+Wy104QLvB6b5xNDt3jXAeXslxjGzY+w7ltVSiqLUmVo0xo3v3PRxTeyHKwmmw9OFKzHDbYdA1w2kZLF02N7wcLyjmUhtE0730rdRJd+nqgamYqzG2T00i+4sORc6vyOnhSIhDaQSyWViSROD30ErOOPRzbGmGaPlgqp1pXMjqIwmU8sK5lrWewPGeeblQVJgjSGVWTipaJnuKy2WTQqpJdkXCb1UW66T0YYtW+Udsa+1la1CK9CGhqW5DuU6kefmCGnmJ//d/4j5zR2/9V/5fXJJbTlVxjuWOLE4WNoD86sHSlnILQEK771EXeS8fYAGYpyotWGdw9oduUhhVa1v3c/Cb8S8UFKBmplfLnz6t15i7wxDs3S7wNPnz/nou7+H0uDli5esa6TVSlpXatzK5aoY0bzruLi4xIdATJEXP/eLfP6jP0F3eeBrv/ufBLPxNAhXVRW4oKWnp64s6YztLKUXM5sqCmUcvjsw9k9ZU+J4fEWrYq6VYlXJxarFMnbPKXWVA7hqduMTpvWOUk+kvMjGajr5VY/UmljjHdb0VFVkaNu8NbUpUpoF8tUdxjpSOuOMwZg9WgeMSpT6VlElhW+u3xFcT9laqqqVQS2tMyUrvN8J76a3WoKSaVSc6WjNUg1A2cysM6GTg73Vxthf0Zr0ELXW5FmrFqN6allESdUyZIVxPYZAZaULinVZaRX67oqcFpbyGm0Cu/4pp/OJ8/w5ImhUaHZoAqmeRICCwZkdRjtqKwTfb/H3lc4OtGyhSgVFLgljFTlXgh+gDcR8Iibpxck5YczALnxl6+NZKEXc7rXNAgEqRUwrSjlCGDA5kPKCNpZ1XfGulwTzqgnukiUeWeKRzu/oOi/mVxReWVqz+OAla65NpGxppVGTweoOZwTO9d6Sy8p+52lVsaY7lK4onKjitKKpKiHFRgQqj28+xijF/fELCRwuieC+ZClyq5qSGzfXT2hV1uGYJ1q6x1JYlol+3GG02cIBG7SKMxdk7WUCyAWjHWs8cTq/oe89znk6+xHn+RatOoweudhdkJO8eDlVnJEAwJwnlAp0YaAmGLpL1nTi7v6XJFaBimpOoqGr2qa6jLMXHMYnPJxfkHOkCzu871jXjDUip1XIm261I9ZKFw4oPNrDw/EFud1Ts/RglBZZ8wMlKp4/ecKrNydq9TgXmKcjKa104UCtmpQWyQ0qlcP4FG8C65rwVia983Im1Um4mHSPt7JJGa1Y1hPz8gVNNcb+GmtGgWKMojWBmpwVnqcPHqMtysPx9EBrR1mVtdsOBUMInajFYkJWXEerMsXePXzBq88jujgo4qjOVNlA1Nby19o7KXLJhRRls9Paoo3jbQtE1Qqsgy7QrMhPW03k0x0/8Yf+fb73d/3jPPnur0Ld4jyUpjrPcb4nqkStlc4bSgFdHMp0KCopzwIBoOjCQHOFGGesLTiz5bgZRfCO0tZ30eXB71HKcnp95sXf/oLwxrHvPR+8/4yPvvYxQ7ejf/KMag1P3n9GKvBwe8u3vv4rzMe2wWENHxzj7oJhHNFac/72C/7e/+nfpZwXfuhf/x9z/T1fk3K4vKJaJtgCRUlEEpBLJAwefdnzWh0xthNOzIDXO1qT7cLaQKsVw56u74nljpxWUJ/Tqsa7PdYGci6UeiZneXYNl3T+QC0a7z2gmRfZ/ozuMNqQy0yKZ/EvFI81BW8DqvUEv0M1iR3RxuKsZlmRg9EirvKWqRVCuGFdI9PyitIWVNuRy4Rzjv34lGm+F/FBXsjlDCiC76FZdn7Au5F1SQLtxAfe1l5IdtrbJ8kS3IGhO9CFHQ+nz/BuoDOWHAt9v0erQCoTKh0JbkQhqIJ2nlzuUSqzxDu0UXi3Z45v6MIFCkdMR0ERVEGZREmNYAbimlnme0oRzsXqA6N7RlULxniW9ZaH4wtJz2gOo3aSvl3nzfPlcC5sSEektESpWWTO1lGKRqkO7zSpLCzpBE3j7Z7WCkZ7Ov+YrCac01jTY863nJdvk3PZLAGSpWjCXn7PG0qaMM3hbKCWgnWa0lbZ4reYKGc9xiimeI8iYVrA2kZMdzjrpYK7VXKZ6Xxgnu4FHSgLS3yFTsJpfamXS99dCVcBOBuI65maV1nPjMbqEcuBrt9RSmZND4K7A103AhWjAzTDOFyS0izyWqdZ40qwe4ySldu5ATBoZdn1z2hVozT0vWOej2g9o+hIpRLjgjbiPM0xk5psSc72hHDJeXogrxOH7oK8VHzXWKaJphoxFmzvtkKnBbIntwfW9YxSEhcffMd+3LHEmVIWnHXs+hvW5QyqcPfwdXKeqCUxnR7QWjGvJ0mZtQO9v+b+4ZZcztjd+7Tq0PqINSNNN2JamOMdSmeCu2RejuR05PLwnNo8U1Q461AajueX0FaRAlvp6Mg5cXU58vBwptY3KB1Z4wOxLAR3BVgUilhm1lMmlyPWNowaMUi/TlMKqmc9TaQlSo5YK2hdJBl1MwqybRmlbHWqOULzmw8DKTfSW/y56VGup+kKVWNy4hs//rfIceW3/A9+32aDEaJc+UBSkaQya1vIbSJXJxuoC/IwN00tBm8Ny3rirF4JB2Rk3c+lUolobdBYtCrUEkktUZKhPcCnP/UtzLHno/cu+ejDp/hOBAjdYY9qBRMTaIsKlifvP6XvLC+/+YK7N7eUEtFaEbw0atLgJ//tP8r58y/4+Lf/Vp79uu+V3LxlobbK+XRCq5Vx6In3EgfSamO4HLk3C9oHjOsoJVFTIelEzpk1TljToZVFq8BuHDmeMyUeGdwVtVnW9QGjD3i7p7QJWKE5vBsJ7oaUZ6yVUquUJrT2MmQoCUz05oKryw958+YVSo1Y26G1CDFynaWXJa8s8QxNks+VCVAq8/pAyg80NWHUQMlHSd1WBa0DKT1wPH6blFbhBLWmEnjb9plrpJEJocd54bZiuafkBe8GStGUsmCso/M9JSdKnlm3kj4fHA1Jq8g5olQkl5laT5SaMHrPznYMw4Hps1tyecPb0r3zvGBMRyoTJSdoReBCZSTGSp1I5RUhXJOzDMRNQ64T3l2S0kDJiS4Ekc+3Skorqckw6p2Q9q0lasvkek/DSOWAkUEnF4GvhMTM1LagssKZQCUR1wk/WtnSSiJhMKYK5GVvqGqi1oRzYRMCSARUyQWNxdqANY5cpSNKN0dMlUyU19UYSomCRDBIW7AVL03MCWc72nYZpTwTzZG8rKT8gLEaq3eUOn+5l0tpE95rlvWM1pVaMlpbgt/jXE9rD5SaMXbrFeewdY1IDHspK7lMrOuK0lIelvOK0oqcCl3Xbf0Eafvhe7wdSTGT2oyRK4Ohu5aY/62HRGuJei95oR9G4pqZlzvG7glWHaDdg1pZ0j3a1q2vodEPV4y9I+YzKd2jdCLGQhdGQhhoJbGkRQg9Bd53xLR1p1RwdkTpwsPxNU2dgErvH6NVJ0RizsT0mmW9x1lH8O9xc/kVvvnZT3Oav03f7VCmo+v2lJpY4xk/HOjCwOn4gjXe05ql89eUsnCeH0h5pnMSXaF0IdcFlOOL17/I/d2bzS1f8cFi7TXeHgQOqeIqH3cjd/f35LIy9Jp13gqSgOl4pCyFVjKydW7Pvxbsqm2tnG8bMo3WWGMFtuBtK6ASfkV5sB0YLx+kEomnO378D/17fOfv+M3cfOV9NiemJAx7T5zOpK0OqrVCTJLQbLTDmkCMKyF06NyYlyPT/Iahu8a5Pa1pun7HvL4gprOosYx/t/mur1c+/zuf42fLh88f8+F7N1hn0MbS9SPGeZqx4mdRSl6TXOic5eKip+SeZRYJcggBawx/9z/8U7z8ez/HJ7/9t/Kb/rXfT7/ryTlTqqYocVnE6cy+97QqETSHy0eoIWCtobaFFJOkN7fEmlas8ZS6ABkbRhSRh9MZ1Pahx7wL0FziiaHrNj5tT62KWGe0Emgm5UqMiVoNXdhRW6Y1NtGLyGmVlkTnUvNWpQBGj9QaKZwxptF3B87TSTam7hKjRpY1iDu+nnDGUZumtSLxJPYKVCHGgrMjzu/QcSbliTWeUUrTqifGBZqmVOlFamolpoazI8YEYlpIesZqCbi0pkcrR60FZzVY9S740WAozaGUxllHzEdOr26lHkNdEMLAsh63VthKTGe8tcI7rotcrhiCvSKEQEqNvg/kIqZe47vtGa8CPRLxeodqns6rDU73smEYt/EvljVOOOvReqDv98j2MFFb3BKaLUZZNJbOX6BVkgK2kqGdyHWlJohpodaCMR6rHak8UJuUM5Z6plWLswHF20rrRkozpc5Yq+nCyBwlFcLqAdUczhxkMGsSsWTCSi2FXCZRCBqD1oVcEs6MKLMHNaONx7rhy71cen9FlaBfGhmlMrVpStME0+NsI5X5XYWstZ4YTwQ/YIwnxkhpM6DeEeRDN5LiSr+/ohapFDVbQ6CsdltPidqMakUT/I5lPaG2idqaAa0hrhNxXbFmJ/ruOtFaI/g9tWXmZRYFkDEoNCFYajXkuW3Y8gWppQ1qiBjV6PtOILaSRJ5ZKokMHOnCiHeXqFaZ44JWmhgj1hq87wD50J2nB4Z+j9GOL159ndbA6o5h6DnPScjN0NFKxCpNSdJJn/IEqsdox7zco02jD3us6ghbjLfSeYNJBoITwvPh/p7L/Q3eXRHTWf47FIK7plaNtQdqm1nXxLC7IbiR+1e3lLlCbmKWVAXtxBj4rlX8bfsiYpZMJZNyppatB8KIwRDtwPUb12IlAj2vfPvH/wa/+J/+KL/jD/5LcmFrBc6zBSwxx0gxGouHtpGwOuDtjnVeSHlh3B+Y5jMh7OSCNztR7+iCUgslz1il6eyI8R3rulAeCi9+4dsMaeCjp0949vRCspYUGB9A263NT8slg0TMtxhJ88wyncnrikLR9QPOe77xV36Cn/p//nFs3/F9/43fRbcbsFaCKJUKJJVR2nG8P3E6n+iHgadPP6DfX/BFvKN6i20dylSokaIQmb0OOBdEEVUgBEPLmVoN1g5IfY9G6Z5aGmuM1JrIZcYYhzWOVM6SpxcTxjQMRgYqLc+1JpDymXk+48yeWldazVtZWsW7DCis9axr5uHhljWdGMaL7VDu6LsrYjqSyoy2PSiBZmkVrXsaDWuTyKTXIyiFD51wYU1hdRCILss2p+kwXG3yZkNtK42FmBaMGykbtGa1xVoZxnKOBLeXIMsGwXY424mysKykfELrhDeXKHqszmAr1hwwrdJUYk4ncjzS+Y4QDpTqKNlRy4LywhkbKy2Wklq8bhuL2eTuEuU0zXe0liRJ2V1K4jqFzl8Q00wuD9R1RWFx1lGrI7hALivOjDjbU7LbsufkdYYZrT3BDhjlmOKJ1mSQSGkh5W0jbRprHL3vyaVQykoqC8psPKiyGNPhbMM5Ry0ehcdoR85gDaCVlLhptvPUkzeVnTWWvuvpVceyvqE1hXPjl3u5rGkBJbWjjcKaz9Qi9bBv1iPO7hi6Pef5taS9un6bQGf8ppV3as8pZSETa8M7IYyD7zeJYUWCpTyqGdb4gLUWax3eD8zTQs4zMZ2oLeJdz9iJWkhtEdsxzXRhj1KV4Pe00ouMT6+8uX9BU/VdQ13Osyg2vExLO6ulu33NaC093E1XDNIjdXXxAUN3w8vXX2dZZrzboZVnPzyjVSWRGzWLOsn16ObovKRC53Ik5zc8vv4Ozud+8/mImz3lTPAeY0TN5WzAmAuZgttKHy5QWstk6IS4qzVSmsL5EWsGapMWzptHB3IULLwhEkxFICcpCXKuY15njqc78Z60RsmN6T6Rl4hqEVQCfjXp2Gyd6rXWLc25YowhdAEXxMXe9BbtbhTaWpT1wr2VRDrd8WP/1r/D4fkTvv+/9l/e4urdlpDs5YAoGt116DjjTY/xI8Z6zqc3GF2xzjLPM1oZlAlY32N0h9KNNd4T4x1ayUaZU8VYRT3CZ3/nBePa8cHjR9xcDViv0CZgLPS7YSuui1gjk2+j0Uoll8L5dGI5r7QCdkt4Pr94xU//sT+B7Tr+sX/9f8TzH/jebfgR2MYaQ27Sp9KNPTfPn3H16D2sN6xpIZpEbFGMsLVttbyGWh2qOYwN0s2SF9YoB78kVXfENWN1R9jkwzEtGCPVw1oZcpKpehiu6b0WCb1aKCWS44RzBm06cloJXlIzvBYvy7JM1JaptRHcQAgdqlnmeEsIA9Z0ApWlCd3cdggJxD0tJ9hk9Y2KJmCNTLdqK9PLaUWhccZCq8T1REW2G4tHeUfnxT+zLGesG1FNM4YOo+5QSiDkLuwExm0Zo/1W9azpuwMlZ6b5DSmvDP0Bq3vRnZQGzcN2gQY/UGrFq0Q3Xm4Jx45gdwR3IOqJnGbYIK2yIStYhbOBVFagisxZiYDHKEdWWZIXWpWQTAVeO9AHlK08nF4xr5ld/4hWLbWk7VJGkhvocUajkM+4xhHMCE2aR3NbCf6Gmq+YY0Yj/IeisawzkGRIaKCNXCrBjpRSqXWibgnSWlka8tx5vyOWE7VmmhLOyJoDSknFSmuKabkFJVt2qSvH6eHLvVxO8y1dt0cpgzWBZbmlVlFVgGOeV1ZdiXEi5ZVlXfDW44MlxiPrOvP4+gPGYQRkQ6jFyBpZKtbKZaRtJtiRGFfs2+6MskWkK0MuKzSDdwMpn5jWQrADtRTmeeLy8hEowzQ/oAjUlkjlgeBFphzTJAVJa5aQuiCuZ0pjjXJZdt1O3jjniHlBmw6zFY3P0xFnPENviekNrXmGcMW6zDKJqibTZI5yaDRJTPXuwDgMvHz9SzjnoSZqnanVo5UnUzHa4qwFIjkVvO+xWILZUcks8cSynhj6vUALOZFSIcYzIWzGRiRsLuZKI0p3OFIu1FpmjQtxjXg3YrXnPJ2lgG0tqFKg5a2v460jX2DE2tS7y0Yp6VNX1kr+lnVbUq1BO09zvXQxlwx54ds/8Tf5hb/wo/yT/8t/leEwoIyWdjnTSy9HikRkLW+18LZP4OH0BZqEcyMx1u0QLczLJBEsbYVi6HzHGqH3A9YEcknMp4Vv/Myn9JPn6X7HfmeFTNeO1qSeQesAzUoT4dZWqABKYp3OTMeziBa8Q1nLcj7zI/+rf4PXP/fLfPc//Tv56j/2QyJxbgVjLb1WqFLQKWL7nu4wsHv8BOU6So3MceJUJ1TXYTXk1sil4L2n8zvAC3y0TpQaRd5uLTlVItLlbs0oOWysmzw+SYLuVmgFRuSnfkQphzON4+lEro39+Jh5fbNxgjeiDMplI3k7gnGU2qgVcm44N9AarOlBKg0qxDIR/EDwB5ZYOC+3qKYptRL8W2imEfTIms7kshBsD8YId6M1qUxY1cnmWUFrhzdO4uNzpFYJolRKkQugA6kskuemLRThG2Oacc6Ql8qynuSy6y+pTfjaVtM7L5y1PdrAMp8lwSNcMw5Pha9pEtiom2U3XjEtgTWLV0ubkXWeyEXh7AFjHNOyCHKgssj9K/T9Hu+CKBzzG1prnE6voDpolq73XO8+Yo0L67pAm1G6UpnJJdMPF1gr24RWllgT3stm0nLmMF5xmu85Hd+AkYvcGDBKs8Yza75j6C6xttvgzww1YzuPauB1JacZ5xq5ysZYW+Y8J4zRYjomC91hFNaOpCTlatY65kWaUBv1HTr1pV0ufbii1iJudufx9opuZyhlpZREaw1nenbDlZDrKZJLpFWHdx1GdczTCa01pTauDk9Yl5WYj3jXkVIlpgwqUlKj6zpKc6Q842y3NdA14royjnuUgtpWjPGMu0tKUxz2A5cX7/Hq9lOcDe8O1ClOUisaRL4aQhBSujW0cuSWqTURbE9rFe9H4rqSUyHnQu86lG1M050oOfqeUldSAmPeXqgR5xxGe3KCYTdSS2WJGnSW0h0M1iq86/H+muPxHu86FFlUaKVi9QbNbHLNkuX17YdnKHoejr8sskknJGzKcnkZq/BWtgBrHUYFjO1kwwoibZzXRKsZ6+SQ6sKOUz6R00pJAi9ordhyTSSAcMvMUltkujVymRhj31X0vo0sV9J0xKb3RNVISyf+xr/973DxwVN+3X/9vyQOd+u2r7O0FlnTmSUfWUms6SiXZFHkfEIrSFlKmgR3Bmcdzu/JWcIkc6k4LRXQsWTSqfHpz36GPisu+8AQFMPgMUq6V7BbmCbSkvkuaeBtj3qOnO8fWOZFNoum0aXyS3/hr/Dml7/BBz/0X+A3/iv/PFobrLM4FeTfNxXjDf6wwxuFs4bWNOSFss6c6yIlXikKR2E7gh8pZWFe7zBm4GJ8RrAHbh9+jtM0o5Vm119QciW1Myk/kLNUc0vn/FY4lhNKi9eltEwsM0o7+Qwg8TLLMpNzpQ8XdGFHjDMNCXpVSsmdTiPlBaOlLthZQ8xIlJHtNmOyIubzJrnu0KrRVJatUmnxvhkrGWqmYXSg6wemSRRkDaA5hv4xpSSWVZCIWgspTRj7ayTMzW6p1E4KEKvBaoPe4Nq8Zowy1FJwtsfZgZykDCymWbrrq3BwcVmoGXSzPHr6MTFGbu9/kVYyJWuaipzOL0V6nldyLXgnfEkpaXudNN474WvKTKVhlBcfljb4MLKuM6GXiKAcFc5BqQveX9OHZ9ydXtCYMMrRKFQK96cXtAzBd1jnN0WmQlUNuWCLxSipftdNY3VAU9HGUDbbgLEBpXsZDpczMc+cp3uGcNjOGSVRTiUKR2TZeKitGVYVVIWcJ7SKNCQbTZWBEPaSudfU1lD5JV4uh8MNp9MtuUQpmeoGUj6KD6QqyXFyPXNesGprh9OW/XjNNJ3IdaJQAI9Rhvk8bQ1wUIultUwqE7SIt6IayalIm15NrHFmmo/kvDD0vRzEpidnOJ4n/CZvNMa9g9lERbS8e1BTFkWO/H3EeRER9OECVQvOWx6OrwFJX+2HkTUtiIVG0w3DxjvV7fvWKJ15ON9iTcDhsBsmvSxnSo10/pJWDzhnSWmi7/eoFjDaE0JHrYr97hHztKC0eA2tA0hM0yRNe7JCEEJPnx/ReS8bX2v0HZu/Ada4YrQhzhNGN1oWyeD59IZmjpurX/qwvdPETSuvgFbeEWrb/972XMj/EyWy2l7fDu/9BlmKzFkZ864IjFYhL5DOPPzKL/DF3/85fst//7+J8x3NOJSjvHmlAAEAAElEQVTtwXayUZVILYUlTywtYa0nF/EKWNXjXNjk6L1sSCCSY7VDmYyxDWKjrFHW/6j5+t/5FH80dEXjQiL4QNvgv2qKbI5bRYBG3Pa0tvW8V2oulFyxzqGsVBv/4p////FT//f/EBM8P/QHfj/D1SV932GMxVuP1oakKmYnyQDEiCqRlldanIg5EjuDYwAtUS2twrzekfNCF3q8G5jjG5blNa0WwtbWGOyBpg2Prj8hpkztzuS8CD9RK1pburBt/rqhjSLGSEOaKcdxDwgEPQwHlBJXvTZGfn71a/5qDaslBWJdJnzXo7Uj50To/SaB36JhyCKLbWW7qC2lihjD+xFLR21WBsf8hpSSbOOqw6qOlsNm/puppVKywtpezMB5BiSKXiuHd26rLZDk4LhCFxxrmki5Yo3bBsJIqwmPDCTOBmqVC0FrTfMQV7h/eClm6XInkLO9wNqRaZ5I6SRKN+vebbRvYb7zdBTpvdK0utCaSIxri6RyR54Vuc6kRcmwfeE4z7eMu57j8QVaO3bDnpjaxgv1OGuJ7YGlzHhlWNck/AqVuEZUrWBF/u6Up7bGbtzRaibmJOdd06Rc8aGyxgj6bYBsYlnvtkZci1Yd2npSzFhnsRaWZaHvHTG3zQPUSHnCGIXRA614jAlb3YkMK1/q5XKeXooxUgtclPOKMQ5j9pRccdZznt+Q8oQyI60ajLGsy5mUz6RyEjKraeZ1IThZXYf+Au8OlPoAFKb5RDh05FwYxwuWVQthScQ5S9dfUVol5kzfHSR2Ac0aT6zxgXl9JYSV0qQ00za5odqqkEtNoEStUqjsdzesa6aUwvnuSFUTJRW06lhWeShjjKKs0BrnzRahntCuidxPe5zrqc2hm2WNC6lElKqM/SWlQipH8aEg63xlpdSEUoFlWd75Mfpwweu7b4nnxgeZZCrUGnk4HgUr1z1asbl8LTqKJNlYBOvVDpRj6G9YY2YYHhHzA3frLWEYcbZhjJMY+Qanh5m0ZHSrqO1+easK01qj0FSMvIZafpV/JoorjBbORVsh9FtDFblcfuaH/2NqTHz/P/M7BXJyDtxAsz3UgsqVabrnvB4xhx1duCKmRCkzY3/Aup6cE1S2C3plHDsUmjUvzNO8XQyO9dz44uc/w9wVOM+kutLsSGmK0oykJQCmavHQ6CLcmlLUnFFKIJcc02ZKG1lTZLm94xf+zI+greG3/IH/Docnj2jb1+E11SlMH3C07aKSVINWIuSZJa/cqsRUG3OKhC5g8GKO1IrCRKWj1gMpz7RyxmhLKRtEq4XzUzhqKaylYI3EybQqhk2joeRMXCLaGFLM+NBhlEU18ZBkXbbpNVPKQqkNo5HcPuuJURIsQhiI60JDk3KRg1eLh2iNMynPeHOJ973ASuXtJWBBG5zTxFRoCMzcVBZ+wmgaiXWJaFZ2Oxl+3sbFTLOoM7XSaC8BjqUkUWgi8LjWDWU0vusR9VVEGwVbuKhSAhPnOmN9vw2YE6fzhHNBelp6Q2xvaDZuIbwjNEdKBaU0xvqtoligr2WtHHaPWNYHSp3xfsfQPcKve3I9bheQ2d4nOW8aUgl8Or9BKyUQk2nUdqIUqVt/qzIT02fCugYq4ILfonIEvnLGklWmVkkSMEpRatuaNjPed5TakTZIcV0z3jmMNlijWNdF6oxrxfsBowfCKD66XFas3awH9Az9Fdb2PJy+EDl4uGCaZkkhKZFcll8d8r6sy2VeHujCBbVIGY7C4u0O7y2vbz8XA5FtGIOshf4CYzQxnWgtUrMhNXnBamkUU7C+I0ZR+tAKJTW8c7QmURs5i0PZWss0PeD9Hpphmo4iS1WKUiOt6W2ljhL4NkgLXy4r2khNbS2C1UtPdhUFi/Wcpjv6bmBJC7meUTpRiuSS5bLgfbf1dUfWGJnnKo7iJMJZ14kZSusO70ZqXUl5AaUIfk9MkVzPxHhmt7uh5IQ2sqpbPQB58/v0rFHSYvtxBBVJ5UwsK7XAOFzjXSWlI33oWOPKmmdCGPC2p/cXnKaXlIKUHJXGHGVbqTEy9o/Zjz3ONdZ2ksieqjYDqUGj0SqDAtX0Rs4KlKeUSCaNcSik5c5ai/cOYyR4EmMl/mVLEiZHHj79lJ/8Y3+C93799+KCQ1knfIzdgiybiB+WfKaqhKEQY5Zu8KI2ae8ijuwKlUhKK8t6YhwumOcjkOT9b47Xv3xi+uYRc5qoaRHFW1PMa6OqIj3oRvgBAfMzsEXf17rBJpmUkrj+fWG6fcOP/m/+Lzx8+hm/+Q/8fj76bb8JaKQloqqh2wIttdcC1aRCa5mWEzWdyW3hlFfWvaPrA3Vp5DIDBZrB6J4hPBfTXZ1RKpFypRt7FI60RnQQAcW8vmTNZ4wZ0HhKSxgtps1lPoo4xY141xOcxlpHyoVlmbdKXxGPQNkgLUXOBaUiOoQNIrHU1gjdiHWOeZ7kQNOGXM7kLBB4zGeZfM1AU6LEBLtJWOWwyjVRkkzheVXUNvMQXxLjyhD2KKXp+wMpVUoSMjplkVIbK/FRWotHpVbFsiw452kKrFHbENCLeKMg0uwSySYTgiNVmbAl3mkmpjPB7DYFZUW1gHfvydBZZkpb2e/3TDPbwZ7ldVKKeT4xLUeUbpynE0a/Ve951viGNd0JElHYlGQ967Jgtca7EW2C5LCV7ZlTDaXEaLmsE1prrO1lu2+y2ZZUMa6jaTE8d24kxiSUm1YyBJu3ek4jqSUorg6Xm8AkCpznpFFVispkQKwtEdNEaxHnLQ2J8wn+sA1egVwT03JPaQmyFL/thmta+893bfznvly86yUiwhlSKrRWiXmiFEPXOcGM6Ri7D6gVlnRkWh6w25ux2x826epKLgWTPVcXz1nmwrpOcrCjGccrWY+NoTTJ0XJKsPnW6uZe3Ql2mFa0aWKeMnLAGBOIUaam2goty1TTkD4OYztSXNntxVNynh6YF9GQOycR1Y2G9ZaH4y0uXLCsM8ZWFAbrAjknduMBxQgUHqbX9L2h7zyn83nDpwPO9cxx5emj7+HV62/zcP9KOrCbxtpAFw7c3n8hG4eqotpID9giev5SkhhXlUiyU6oY4zjPE43CNJ2YzmesHnnv2ScsRqCJnBemaWK/v5aJNVVyPdF1I/Mi05dllI3Lb4KJraKXJk2SRon6TmuH4q2HwGKskV+dYOHaWrB+u1iAlqBEWpn5mT/5Zzm+eMU//b/7n6Gchm5EuQNoLxhvS6S0kK1hF55Ija9D8ptUkAtLKWpqxJiw1aKNeD1iqugt/XiNmZdff8Ppl0/o45lWZ6wyWOeoSojwUhEuyQgcZhVoLT+DdY6SEqfTiXUV859zDqPgW3/9J/nip/8+z/+LP8BXf/tvxlgHzbBOMzUZ+qGX/LFzktC/zYdCiuSycmwzRxuZ0yIf2CxkdK2VmCb24zVW78hlodaVvh+pxeDMAFWGpbeKKGvkAKgti4u/KKCwrieULljz1iOSNh7JUGrdxA9Qi0DPwfe0ZkQx1DRGCQQtXpdNkIIhlwi6kPID57htJ9pvMS6aEHrOZ+GFvO+Jq1xcSmmULhgFTSm08VwennH38JqSFYer59SWUMriXA9qlVy545E1nWkt4xH0wjrDPJ82iMbRimyHVhtMgGWp2wafaVUyr4wLpJJIeSG4Jzy6/piXrz6jVFGB1TJTSsFoRfCVZTmT04RzHaUIh2eNwRkvyIiWcM1xuEQbzcPD3XZBqc2I2cvXKSVxKkouj9ImSluggG1vk7TFlLrGBZRmGHYSd2U9pZ6Y5zco5YlJ5N1aKWKaKSWx3z1G6WGDsgW2y6WyxHkzrSq6cIE2cJ7OpHTCWoBMXhvW7GkonG4iBDEOt3FoUoEsBvC3fH0tldyERiBJVlzKko/2pV4uaS2UeGQc9hilmNMMylCa+FCc7QDD3cMLul7wS6UV3ni67hHGymFtXcAHiZJ5ffeCcbjE2h01KkLoBRZRkb7vWJaFi4PlPN3TdZacoPMjtTRqqxILrizLssVLhBFjBhoZrT1WqY2UFymrtpqYZ6b5AbMKtIcSZVRRIqJUJtAFT6kItpsS43Ahiq4SxWhmLaVUnFXUahmGHY2V8/k16zLLRVgrS1uZ14lXr1dSnsWXggbtxR+gPcFfkPI9tWZiTAzjwOl0h/eBoT8wTR7jK/cPr/A+0MpAzIlHV88Yh0uOdy9orLy+/QaoLfqmCY+jsdRNkr0uE6qzlLqyrGe67oDRkmfUKvJhQ/G2JF4bK5yEspuySmMNMgEpNrUJNC2Blc0YgdTyDGXm/OLb/MT/44/z1X/0B3n/H/5equ1R3QU4kYeqtkJdyXmiGUWtMjVp4zhPd1xeiETUeUWMK30/CKyo5aF3pqezipQXHl6+4fzNCTXN6DxhjcZajw0dyhiqUhI95L38bFqmvH7oMcHJlFgLMUZyTNjO0Erl5//cX+bH/q1/j2e//h/it/3Bf1n4oCWxxkLNmv1VoNUF1SSOhBppRtRStUSWMrPaymwzCU2gbf04iPwaia/ZDwfWWJjOL4nribG/ISWBTa0VUr6UFaVHTAvE9UjKr9GmENeZIdxIrlydUSqjTKJmTd0gTGcFJs55IdiBsb8gzoVSM37nyVkOnj54pvUlkESJVhslFzlAtzgZmkDBrTbO5wf5PaUlwWJTSTrr0FU22MbKst5TlcSg+M7iuwDs0WrLtcsza2zEGJEmUfGDgNkyAzXeBbwJhNBTSmRd7gTC665IKaPUSkkrzneEML5Tnd3df4FWjmV9wAcRigR/SUoV7x21LZxOt/Qh4I2XzLQiZmGjPbkkYlwIXrLXGmCN8Ddv30PnPLI56I3rkvdXa4VqA2P3PlobCceN4idRuhG6gVIU1nimeUFrtwlWRmoVyFbRo1Tl4fSCeV4kRNR2pFS28N6KcGAKpYXHiXGiNYlkctZtAb8zfmdlG87LxqkYjOpoiAiELSOwZInRssaCUhSdURr0ZpiW8Nsv8XIZ+8eczq+3TumIkOQV7xxWB+ZloesCyaxYY7fws4HdcEWMieP0gHN7gg+kVFHbjZgilDLzcHrF4TAKb7I8sERDyfIgaL2ntYVWJx4eXqKUZhwvOZ5fUWvF+7B9GCMULZcG0HcDWon3pJQsiQCqEUJPToV5EWUSrBjdUVvG2S3VGc3F7oLT+Yjze2gB6zPT/ABU5mWh79mC7lZaa6xlBhrGhHfTAzRu7z/F+5HdcENpyIRXhVfQWuPcyDKv9P2BZb6Xw8/uqFUOh1Ycj68/4Xg80vUdOolmPaUV6wMgPoKrq8ecpnuZLm0gpYhzAY2ob0R40RGTF9zbj5SoaEVIU62kXbEBpSmU/jXdJa2gmpR6KSOVAKIY0+82DGpG1QRp4ev/2V/n+PlLfu+/8b+Qh7K/pIULlPGoIttNzTNznMnKSnK2NqxxpeuEjKUpypLIeZXqYd02AluEGlfjMz67Xfn8Z1/A/YIt4luyzuGCByfGTrUR6GwE926/o+s6rPeY8HZLLOQkkA/A+faOH/9D/z6tFH7DP/976S925CWRpszt7ZHrR1fCu22JDa0Kx0YtlFaZ44mzzkzOUV2g7wZM06AiWknfzTRPxHrijGVdz8R0wrkAJB5OAvldXz3jPD0Q0wmt1fYZGpnnRQ7HjcerNVFrYY2V2iI5wn6/Qykn/hgjraGVSowzFbMpAyGnws3hGlQgpntKZavWUNSiJR2gKkotvE3Edi6wrlLrkFKktozRCu8DGvFEweb/SeL0blXRqkEpv4XbFlLMaOVpKgspv10KWlVKSXRhh9Y9wQUMihQj5+V2u4Q6Sl2EB7YjVTlyKTjn0Crg3YHLvWNeTnKgI2kPXRjZ9Y5pPlNbZL+7wW6wlHBFsn1obTGtbJFUlhIrzntCZ1mWEz44kY0X6bA/HiNd1+O95+H4AsikvMqA0Hq0sigl9cTGdKQofjU7jAzDjpQKxmicDixpZprfsBsDfXeQiKo0bZ4ciXvxvsfZHW/uPoONZ1YU1rQwDtc4fUMfLri9/5RxCCIFV/JnKNXRWiPljHcdl5dXHI8PlCyc27rKOepDkNI8JYHEALV9yVLkec24MGLtBaWsOCcHsWqNnCyX+yec5wdQkqtTWyOvM9H11CZqipIzCtlAlLbS3Ww7Wlvo+z21aB7mOxoL3veMww2laPa7G968eQGANgnFjs5fS5hlWUlp2apB7+j6PRrhDOZp5bATTNf5Dmsc5+kBVKHmB4GW5gcUib4Tk5wxFrXFdadkmM4zUKnFcHFxQcoTx/OJEMShezrfglo2PiLQhZ1ANelEVY3gR/r+McOw53i8B9XwrtvUS5F5eUMpjd34WNRCyz37/TXeisrOOU2OhYvxQ9ZzYz7dikvYRxrSrT34AyXfsywzrSWmaabrZ46nh02euRNVi6oiuFBqy2MKhM7DFlDZ2ttCLIAml4kgSVgN3mm8s1jv8N7LRay1xMJsHhlVZupy5mf/9F/ka7/jh3j+D/8AShnwe6ruUXISQ10pOZJapVlFyROn6Y6m9Oap2fG2rEprad0UWEhi940dYBn59s+/or2ZMXnCqEwYerQJ+L5DOfeuMTJ0nRjFWkEhPSBseHVaIst5QqNoSjHfH/lP/9f/R86v3vBD/+q/wLPv/y4pQGualBqPHl9z9eiA7SWrC1XJNWOUmCJziUx5pVz1pMHhtMcQyLEQuo4YZ/J2UIiCULi3HEW9tkyR/e6a83SLVn4rsTPQFPNyxHkvoYSl0YU9tMo0i5erCxfQGklnWjG40FFNQqlMa45ljRjTUFU8XikWlEq8uvv6Fl1SCN2Aap6lLHgvQYatVYx5G1y5ofzGb8GvYkoeB4mhccYS40wpcZPtyteEfsSYxrIklBNVntWOy8MTTtOJrEVlphRiqtYr4FBIgoDWDmsD+91jSi5yubRGTBNG9xKdND2wxjNUTx8uWOeJlB7wwdH5axqKeZ45HALOeTEqFy3bIYW4LCga3g/bRg+Hw4UEvBapdliWk0iqmyYlqZw2xtDItOaZ50nUpd0FtZ6Yl4lh8LJt+J6cZCsahpH7hy9Y1xVnZZOrNVFJQMbbjuAcy/RA24QN2pp3Mu/7+3u0clsquCWlROd7VDPUrLBhz8X+OXfH17Qm6sBaK/O0bBBgpDYRTcQoSrzaqphOt6FSK0kziPHEMFxJ+nX6ki+X/XhDjJHri/e5P74ixiPW7NGmUkvkMDynViF9NIFhDFAryyIH3NX4PqVJT0Upb6fhSsqRpj27q8esccY7wXBLbYzdU/ruglzg4uCY11uclbiTWhu9v5KNIS9YazgMnsvDE2JMTPMRyFAqvTdoE0S6bB0xnxg6qUN2+jHn+RXGWFKslAgXFwdSPKOsYr+7xugO1/WUlImLElVRM5ynE8FfoPXAss5CBGuJEVEt4IxB4yi5cf/wBmcNXXfBfM4Y51nTGaN3WA2n0y3OK7w7EFdFzXL4qNZDjUznhf34mODfZ04TWsPL48+R8sJw84QQPLlMdP1ALbN0zahhk5hq0Zm2xjhcSlR9izKR1IFSPE1H2vZAldowyOailDh5FSIBDT4QtktFW1EHoQyqNtq60tLCN3787/LLf/kn+G/90f89ukTacI3yo2DwWap8WzyT1xNRFTCGq8unxDgzL2cJ3isFpzWqaXq/J3Rhy6byHPoPeHX7Gb/4iz9F+tYXuJKwRqGdhPA5a1BN0eLm3r7oCCHQqqFzHqukrrgUgS7W85m0xu2AgL/9w3+GT//63+Irv+038z2/63cKPOWMcCGjIgwebBafTZEPX4mRohq5zSw5koY9bneJrivOGk7He/rwGKc7gRKtIaZELkceToKz3zz5YMu+8xjXUVXj4fyCPtyw7y9JcaKlmZoagz8wDlfEVfg06VgxaCU/p3dVhroq2r+YJJro+vCEEHqmadpg4Yp3g5TZxYw2sK4T3mnEQKdZ14jzPSULJOZML+GgRuT+xkvF8bLI9laKBl0opRJLpe/3iFpZ/6pcmoALe0qKLEui8yMPxzuU8YzjyDIfablsfTAwDDviPJNLxbs9XT+gleW0vBQPXqmcy7wlO3dcXD3nPM2UcmIYRqw+SCxOWtFNk1bhrVT2BLfnPD2glZKNSG+iDx3xtjGtk4gkguF4esmynum7C3QbUS1zOt1hTMP7fpNbd6QoOYzKKFAeowPKWPruglN5Tc4rOWW8C6ScMVoM3+u60kwBJa2fy/o2UmtLxQh7llXSkoeho5SMtQcJVnWBkhvBG9Z4Zlq/yaefv8Z6RWsD1ni01Rg1b2pfQ1wK3jeck7O7lEYpkc47TimxriJJDnbAKkfNhbiev9zL5ebya0BjjSs5Ory/lhTTNhHzic9ffwPnOq6vPqE2h7NaYJZ6y9XhKTlJXWHoLKfTPeO4Z10SY68xViTCwa44M+C95zzfc9hf0qriPJ+5vnjOslyCzqS1MPQdw01Hy4o1RkrJMk27nuITu77gvON0/yChmEZznk8MvWenH28+GN5ND9Z6rA1422+Xh2VdF/peuhOkNrji9A1NSyFSLiIwUAp0S4Rh5LB7RBcCL19/k6Qih4sDKSViWkR1Vjref/qcXCtv7l+gO83QD6zxBMDF9UjOC8t6xmi4PDzFOYnfiGsmhI4xR87TiZsLgbsO+0c0Ct/+/OfRynC5e1/aCA8r0/KGw7inNcUaJ4wG7UdqrXT2gjA8QtuXNL2i2eqMt2tGKyTrrVThXLQRAtyKgbIiUS96M701CjUlfvKP/TDjk2sOz55IDIzvhWtqbdsaZ0gr0xJZjYbqmE6ZEA7sB8mO0iozDpcs0wmshJwuy8zYD8QUOd8uHD//AhNnVIloK6pCYxxKCYGtNEDFOSsNqE2/+36VgvU8kbRmmcUMh1Z8+ld/kp/+f/0prr/jE/6Rf/mfk+rqqmja0ncjNqw0lSk1yTRIIdcV1RK5FpZaSNbTXT9FdRfYeWFd3pBSZTdogj8AgcE+5uLiA16/+Qbn5TW73QGtelKJGLuVxJkOqz3UwGlKEuVPY+gO7IdnKDVigiKlkWgaRmdqDhz2j5mnBWMNuSWqPtI4Mi8njvkebweG4YJh94gYI9P0gM4VtniWUtfNYwXn80TwFwzhinM50mrE2IEn1+/z8vW3WeMbjDfEOGGVpakCKKkIaNIrAprgelLOuCCiGfAM3Q3VZaBysXtKXDWYlXk+czzds9/tKSmRUyQiwZedv5Etfik0NZGzou97Wi3UBMbvMAx4c8WqLdaN7MYdKRqp9yYwdA6U5frihuPxKHXjYSGlhXWdpbCQzLw8SOhuXSlNk6OkcF/uL7F24HyauDg8YSwDa5xQStOFnpTTJgTwSPlzoKSCUo6cGt5eENdblDaU7HDOgZJswar7zdAYaVR5ZpVUrWrtcHqQgrOykmKUUMlmyOX/z9qfx+ya5vld2Ofa7v3Z3uWs1VXV3bO0PZ6xcaIEbDRGXgCBEyKCQ2IYgxCRQowh/EMUyZD8k0SRQSxCMiCRIFYnOAq2UQDHEDxxkGVjzMzQ7Znp6e7azznv9mz3eq3543qqZuwEMon6lUqnVHWkeuuc59zXff1+3+/nMyJllrqlBNYfqeoRIdIlzp9HwoVpaJtdVi7bM2WZO3NtfcuyeFw4kbAXhmJCigyAFbpgnB1SCMqq++EeLtM0YQqDs3mB5cOZMWaMi9ZZpKW0xBQ5QRJjNhciItPSIxAYU3LqD1jXc3z3Bq3KXGKsa46nI1VZoyqTY726Roma/fmB2e4RbOjaDf2wz2yt5BiGhbroLgyzEecnpDgxW0ddtUgFPuZ4b6FyD8d7R1U2OGfZXe0uJbMNy5zn1FVREHy4RGAXZjtz7s9c7Z4xDT2ISFPdsiw9TQ3H0xPr1RVdWyJiXpgJFGXRokKFpKUqBd4dMFrncVh0zLNlt80PgcLkG4a1FklNW28ozESMESXyW9/sZoLP+yWtSoxx1PUrfPAokX8dt+v32W52KNEiUmS2M1ebDwjJIgRU5YyUQFLECG25JkVD01xjxQmwX3VbpBAYrSmNQCZJVUjKuqSuKpq6oaprZFWRdC4kisu46e13fonv/kd/jt/+j/79rF69IJUNomhzWCJ6CBYZAosDqxrabk1ZbXP8uyiY5sxImuYRmUpK02CXge12i4hPrLtr+kPk7Q/eIc4jhoAyCqUFXLwyKJVLgkJQ1xXWLhSloa5rTFEgjcqEBh9Y/PIVraG/e+Rn/3d/lLBYfsf/4g/SvbzNSS2Rx2fDdEZcaAveRxA5shoJFxGYY0wdr7/xW1DXz8C0XG8LzsMj8spxOD7m+HnRIoRGyERTO4qyJQRLaa65Wt3SD3ticpi6oDYrCrNCmZJhOqBEpK2uLkIw0DqHMrrmJVprUhRUVYMWR1JyLH5BihqjtoS4IIRks7pmWbLwL1WwavLupO97ykvHQgiD0Zo37z7i2fUHWBfQ3URhDPM8cDjvEVKzXX/IMB1RQrPucidCiqxrKM2O3eZrOOcQMvC4v0ehuN5U2EWy7p4zzxNSCJbZsl3fMtmRurxCiU3Wojcmj29cTvhdbV9RlS0iDcxWse2aPCYtDWVZXw58SWFq6jqi9Ae0VQeVwroFLTUgCRGUqNmuO+Z5otQlhV7R1Bn+qJREyxVaSsY5IFJFXbZIaRiHEaJm1VU57Whr1s0tMYWLfiSyXX2IdwvOZr99WT3LacHgWK1qJAYta3QtkcozjCdcsDx/9gGnQy6L113NPOdOk/MTwVnWV6+pi8g4nimqhs3qisfTG47ziaIQ1E2H94qmqlAqW2KDy36WrHMWFGaHEFkEh8owYCXWFDqjgDLySVIojzYGaxeEgt1qd5nQ/JCR+7/yyc/StSsExQX33hMT1OWGFBPTOJLQPO4/xocZo1tAYe3E1e6K4+mRpt7gXEAbcWEonXHeIoUhRMFue8MwvcO+jVR1QTnU9Oee0/AZShXsds9wNkcY9/2Mcz1GVTif8/tNnTPvJM0SCj7+4hHnznRdl2PBs6VpOh6Pn2Ndz3kxOBsxRl6KQmXmdl1MeMN4JqWMzkANfPHme8Q0cnP1YW7onyyzfSJyIkWF8w6iySyfSqON4e7NdylM/nCk5Kjqki/uTiAM11cfMPR7vrifEcJjredq+5LCdChlLnuGU26r63xVP/bZFY/0OLdg3URdrSiLDVWZse+zPSGIBHwWHy17Fjey6q4wukKIHH1c3MA49Egx5bZHykRqKfMoRWuN1AmZBMoYijK38gWCKARRSqTJauO0eIKz/IV/7d+hud7xU7/vb8sjs6ID2SAiedlvR5Ib0W2JcDmsoHWZ4Yohx6+besOqvWWcF6rOYGdPW29RHOnaFfeffR93WqhdyMw3pS8PxEw4RiSUklRlxWq1IpDQSlGWJaYqMUUBMeKczwEBYB4m/sK/+K/jxonf8vf997n68D2+AndqBSkQcYjoLgvfHN2E3Ntalp7JCzZf+xqhXWWUTgx4HGVVo9WWSL5lSyUxRtD3e7RKRFQ+eHaSp4OnaxtCqC7opHVumSeoijVVVRKCv9QAoNUm95BklR8KMpeT191VVnt7d0l6iUtwwWOMYZ4eCSHkUqTz3N48x2xXLPMMwuO95XB8y2JHFjcxjAeqqqCqd9R1l1vgKXfIyvKKYThQVzs2XcP5fMAUkqpcUZdrgvGXMc8VkFvgbZ1fAArTUFdbkr8gks5HTFmwbi/L5rLG+YUQEk3RXIqSiapWmXUoFYudcnBFaKwdqYqKGCVts8Us/uLiiVRld+HsCWTwjNNAXZZIFCJCWVaEGAiiyLfeGNlub0G1aC0py4p5XhBxoKo0UuaUpTF5d5VFYbDMM9vumpASi51YXE/X3CJFvhXGGOnqLmNxqgbnZgq14OOEFA3Pn71ACkMSiV4fMUahdcE4zFTlFUZB28YMokyw2Xwtc+AyA5OqNBRrwTCcWG+uGKczp/MdSgmaJr9QalEhdEfTNBjVUpgO62akSizzhJYSs8qfm5QSs1soTUuhQu7x/TAPF1N6FnumrlsOxzeYIgPulPLsn/aURUnXXLEsR2Z7ZN2+4ubqQ+4ePuf+6XtYf8YYzzg5tNcImb/Jtl0RvMh+lJQTJG2n+eyzX2KzXuc3cxnw/sDT/oT3eeE4zUeG6UBpNqy6GyKRYR4oS0PwkePdA1JCVdVMy8I05/hyP1jKIjd1paqY3ZGHw4HFnlk1711O5Ygx5rJElFgfuXs4EDkjtWNc3uGcoywLXDgxW3Mp9w08u/46/XBk//hI03achyOCQMKhlOI4wGJ7NqsXzMsd1p+RSuK8RyjPm/tfoCpbrq+esz8eqKuW0/HIenudZ8jujBItddOwLBYJeN/zYH9AYTquNi/w3n6V4BFSME49Mc1oazkN+d+19Q7nHKfDnqk/Ii/fXyRBjOgkMUJghMYoSWNKalNRloaiNGhT5Gu/UHChCU/ngV/+03+Wn/7H/kFWz65y/0XXebSEhzCDm5iXnn6xnPyMRzDZB572jxRNQOmKY/9l2qdlVHlp6uIeaxfm6ZG3H30bphOkcFE05IdcSiBF9pJXVUW3WmEKg0ZQluXFUJpps7PNhcxwQb38hX/p3+T7//F/ym/4O/5mfurv+r05kRPjJayQvelSJkTK6cM83vOEFCB4rPOEpqG4Lbg//QBjKnyQLO5E2zTMswXcpRAakCqxP75FyNxEP5zu6KcvEBi29gWFWlFXa06jY1zOl4SmpShb7GIxWmJMyb43kGReaguNFhV13SFVyTLPxJSBj6YoCTHv0xKexQ0chgXrjizLiXG5pW12EALH/oAxhsPpHSlF7h7n7BuaDIfzp0gpaMwz1t0tw/BEWWUH0jjOFJsmO3KUxDrPOL2hKHRmYQmBDZZxOlFUiuPhQF2tEELgrAfh2J/f0sbsRZFS8bR/B0JgTM0QM/LG+5yMK4oKrSX9eGCa90iVLY7b9XOWJVKWF9NqcAzjgfVqxzCdL4esxbqRuioYxwUhfZ580PDi+Yc83mciiYsDYLja3jD1c1ad6xKjm8uN64gUOWlYmJJ5cqSo8D6iVE1VFESv8BbqxuBc7pekSxIza8kju90Nw3BinB44nN5yvXuFd/B0+Jy6rqiKDSFGxnmPD8slBp2pAFpVNHV+fkqROJ2OVN0W3eUDV4vIbvMeIVqCz1DQzfYFd+8e8VYiC0lUmcghZCaWm6LN/RYyfSDGyDjNIBa0+SH3XArTsCwj43Sg1B1C5vjlNM2UZXlZmhlUU2H9ntk+8eZ+IMRISAtlsWIcZlwcmK1ht92x2HdUtcklxlbydLyjMAXTXOS5szt9lSnfrjbs9w9YP2dsvqipK09KlmG8p6w6liVAKjmc7ihLg6Bis77ldHpiXs6EODPPI1WZr6VrqVmWCakttVphdIlEEmN+WFk3Yp2nErnMZoxhnE84H1ivNozT4wWTEhnGPYjA0+ELEAun4TNGW1CWa0RSuUPhwYeZuspwu76/x4dAXVckHG23ZrEnHg8f5Wj2aocPClNoVl1L9AknLcfz54xWUpYthaqY5oTQudT60aefIKS9kJgb7ALX18+JSIbhiBBZN2vtkXkes+/Da5Io8LK4MOEkRVGhqrwg10ajypJUaLxSBKnQwmTNgSoutFTBL/y7/1e62yt+6+//O8ivqmXWpkLmT/mFaAfO457PhjtCkXBuxroeIRXCXzPMB9pmxThOGFOgdYGSBfZ0T1u3fPrJHefHT1BpQcqLbyZBCvkmURaKui5puo66aVAXf48QeYHvR8cyLzmN5PMB8dl/9gv84Gf/PNsPXvOt/+7vRmpNiJEE2RtS6DwCi7nZHkI2S/pwQfgQWVRCrko+e/geLlpWq12OBbMwPuW31dzgjjg/5DZ0tWK9ugE011cD5+EBWFiWmaRgcSNNPbK4Mz4MTNOEP1icc9xev4BFMs4LUmhiXNh0O+wSMFNJQtHUK2KaOe57iqKgrhpigv3xHUKFHGCJWZF8GhZO/acs04ANM4VpaZpVZonJhcU/MCxnhMwjQp0qmkOG1CrdUtcdMShG+xnBg9EFzltCnC4P3yVbTaXGu4TUgpQcNtQM0xeXiK3jdH5k9g3jdMT7jKDRskRrk3sgsrwcZD1SgXXnTD73M+O4xxQV6m1NYWqapsXolvO5x/mRp1NN3bTcP3xBUeQk5OwN8zLnmkVYWHXXvPnOXyL4wO7qls/vR9brLeepwc4zuhBM8wBJ0tQb1usbHh/OGR57UYqTBGdbXxJYUJiKslQ8nmYWO1OY4iu8kveWZZlomg0gmOYnQpw5jR8xzQcQltGtMKrFeYuzGSAagmez3jGOGcciBGxWL1CyxGN5PA1IkfAx6zOmqc8TI5sL42UlGO3nzE5T1zXn0RHTzDgveSzvapzNlBMhNGXZIRWc+weCD7za/sYf3uFyPH9GWXSUurqkTBIu9CA8yzIRwhXPrq45no4XHH6miBZFRUwlgoLT9A5dKGJcCHGma3c4m98Iv3j3XUwB8ILd5orz6Z5heuR6+x5aa969+xytJTdXz5iWESE9hi7/RvanHDPF8bh/zLFbBDdXtyyTpKlvcC5Q1TXl5WosRYFdJNPokToiReC87PMbcBQMU2ScD5RFiZQ7YkxUleFwvMe6hRhfgZzRWvLFuz1FKQje4S/oF60runZFDCWrbsfxpDBGYXTDeficGPZ4rWmb5xyOb/Fp4HB8oCwadpvXOJs1y+fzASEM9/dvEGhCijlfP+fegDJFzq2T6cxF5TMIUdW5oKXVV+4XdWk7Iy3T6AhBYcQa03Vstzu2uxu6zZqmaaiqjDyXSqKEyGmwGBHRIeIMMuYeiQBCYHj3jv/i3/jj/NTv+9upNg1JZqcLSmUwll/AjYzTkT4M9P6MMZrSaIy54fr6Aw6nJ8oip7BimjkPe1btFUVdcj4NJJ84PjwhrEOngEj5ACBFEpeOhRDUTZX7QOpCFDDmAiL88pD3xCiIPvLFf/5t/uz/5l9Aac3v+l/+o6y/9uqr8mi2pMZ8S4kOJUXmTcl0eXB6kojMRKpnNyyVYgkjQi4MU2Z8pQRGN8zzwOn0cHkbTNS15NmzDzPTyufOSmGL3KhXBdrUaK2Z5yMx5eXu1fZrjPOB0/kBKRTn4UjdtAQPUil8mglpQUSP9Zbj+BnOO1bdjv35nrunM4UyCCXxc6IoW5QMxJDw4ZhxPoWlFI6hf8yk7hQxVWS2Z4bp4SL70lSmyiSKosDO7zgN6kJNrklJU8QSiIzTkYy6SbiwIGXmVU3WojW4cY/WLVLk7kgSM4f+LeO0BxKFXjGHnEqrqhaRapS5AjlzHg6ch7dIkxfpiz8jjSemCe8My0llsVUSBGbO84Hj6FmWEaFqjK7zNCCNSGWpqpIkJqI4ocuC0/CW1XrH4/GX8NayahuizQeZ1iXDyTD6LeNgKcsGkmCeXX5Jldk2qlTJvPe0zTVFIenHR8pSEUImsk/LAcTIfoKmvCIRmOYT2pCxULokyQHUisV7lgUasbtMVAZCHBEpR6bPoyf4hDYCH0aOp0eKoiB4QQiRslL5xiPgOPyAw/FzrrbvsfiSSH7J07phnD8nF2kzl6xrV4xLjkpbP9HUq1/XmfHrPlxSspA8/XAgphFT6kuqxV7wBwq4vOGrBq0WhuURG3Icd5l72nZNUWUM/P5wn2e3S9aptm2Zr2O6yHFALdCYS4Y+oTQUleTcHwhxvFzNOmLMCPsQcrM3a1Q13aplnA5c716x2Jm6rumHA4XJqPkQHc46tusbEiticqTY4Gyg3ZaM44laFPnZGXNKYpo8V9v3GMZHlsWxWm05nt/mJv0wUpYVZdmgZI0Ul7etssS5vLRMUSHIzonz+R6ZCoxsSMkQfRZSdc2KaQrUVUM/Hliv13g/8fT0OcYUTHZEKX35/4WTH4he8Ozma4TgmOa8k0JoXjx/xcPjA/vjG7rVDX7OpTjCikK2rNbX7DYvqH+so63anKji0nMR5BuB4EJKvcAsyeRcoofgIDpSEnznT/zfOL+54/2/4b9FkgKhKlAaosspMT8R/MjZHniyBxyW2rQ4J2jaLQ+Pe6blgRA9TbUheJhHB3FCq0jbbFjGmek4Ia1A5Y7eBXkuKLSi0BnsZ3SD1hXaGJQSF3Jz7ssodSk9hoSfLf/pv/CvMp96furv/r1sXr8ihISpslbA2iX/QfVTfnmRmkRG8XD5cY4OX9WoqiZpMAJiLElkOKS1MS/QxUJZtBhTZfikO3M8vCFh8HHA++Xy0MqjjskNFJRYd4KUKJuWfnigrjfstnAe7lnsiA39ZQwUOJ7v0DISUsvie6x/gKSYFpcxScsZzBVVvWK/f8gTAJlx9UpDVXQYs+Hx8I6ykJRlwWnYM00gyDHabFs1dO0zdutb+ukEzmZYagLnHMPwiFKGum5zNUFlFD9eYJ3lNDwghMDobfa7uAkhFNoozv2CdQMhJDabLfOcSd8IifcOScE4jiy2pygMK3mTa9B+pqrWFKb4KkqtLoj8GCWgSdHmKUvdMg4DwY+0bc15GPN/X63z7bcMmVogK+Y5d/PapskpMpFleUZ3GLViHHqcny+JVE1RaNq2zrfPEEkxW2+VGXHRYUpLiGQoaFhIaUGqQKkLpuWEFAZrHUk4umaXX4KSZbE9MdZcX9/w9HCk7dakKLFuIF74gIfzJwgRiFNkmedcHo8VZdFRGBiXe6Ypaw+65jlKRw79Dwhhoq4brJ+QvkIKyTxnXBRC8XS6JyWRPT5lwbF/+OEeLqXa4u2CVoq2e8npfMwe8lTR1dfMy8TD/nO0LkgYYsxXsd1uSwoS5y0CyeH4BUataeotPpyZlyfquqAubzCqw8eJ0zmTY4t0g9Y1Ic4sbiakPKesG0MMOiP740xZbkgxg/lurzumsce5kRgnno453XY4PrJabSlNSz8MGCOY7RlTkM2PYsfV1XMeHh7yfkiX1HVJ8FnuI02Zr4ZS5yumLLhef53Dfo/RLV27vVzZ84PM6JLCrBjngX7YU5aKsijphydurp5DLDKrrBCIBNe7rxGC52l/d/l5ORJprWOZPbvth4TgaZpIjBnBP88TmeKaGOYzq27N6Xx/6WV43rz5COtnVAE+BexYotIV2+2P8943fvTiA7koky/X9PwlLoyxC47/8uOXiLzERWmMIqEZ9u/4y//WH+fD3/W7ePXbfpokJ4TMjfgUHckHWEb6fs/9+MQQB5SB4/nAanXLYi2zHShMLqkKsq5hu7nFaIM2gfPpiXHf44aBwuWbRyb+ekypLs4PKMqMFM/0ZnFpIee3MOHFBWciic7z5//ov8bxk8/5ib/rb+c3/8zfSUwJpTN1IHtxQCbJYiMJj3UWkEQ83gdmZ1lqg95saK+e0fdn8LDaXDP0T7jg0UpxOj+itKCu1pRmR98/IKVkXs4oWaENuJixIHaZiSHR1B1V0aAFjMPMMAwQa653a754846qrmjrHVLpfEDXa8oio1G0KjKTLkqMauiqHcPU0zXXTJMjMaJ0IqQBaFmtNlh7QsmCFGTudWlJiMvl8yxpu4ZpmRmnkaJYZ+K5dYgkWNUvqKqacTqSRKRbdQgKtCpZ7JzHT8t0CUBIYrK5SCsD3nqiF1ndkbIu/Hr3mnP/lDseTIBEi5YYHGUlaJusTi+LBm1P9NMj3k0XwkJBPzyx0TeYss1wUCWICaydEDS06zWxdBzOnzNZC8IjaGkqhV2yCAwiphDMtkfrTE6uy+KrcEGKhmmJFKbLUsElqzmUKpinE8Nyh5YVhc4mx6fzE8Enbm9e4VymW6TksxZAGaYp0FS7jGRyM0qKi1XVM9kRowUEzfH4hNKaxAjCoEzAudyFcb5HaZOTXkWJkitCyoh85ycWe0KolAnslWEeJUItSOWIQSLTBi01Kc05NSj0BWSZjba5gBkuxI8f4uGSEzgGoxtS0FTFGikF65sdPngWdyClwLR4tus1db3Nzc6pR0no2mtIJYYd7738cR6fDsQQudk1JBxSFJmPQ0PAYb3LKalioh8PFHWJljVd+4z9/h5T5Ibr4XhPP72j0BXJK1Ks2G1ecTi/ZZgPlKVkmgeGcWK1esa09ARxYF2/R1W2vHv4Lq9ffJ0UJZ989svUtUGISEyew+HMql3TNS1KwWzHPF4rFHXVsD98RFEk5mnAmG1eAPpICBNCToh0gclVef7atR1dk9/Wrfcs7g6XRoqipS1fkOTCYie2m1uOhxPrzYrjaU9ZVazW19w/fIqfe4ypKIoN11c3DMOBoshK02UJNO0NVWWYx5Gu3RFF4nCaMfElm80rXr/8kM16jRL5YZwJ1PkhLMndEMFF7vFrvtKFlgxf9jFzW1nYwC/9yT/F8ZNP+Jv/2X+GYvca3AjBEXzMf3DjQgw9T+Mjk1Bst+8zDHuqokCmiof9p2jVcHP9HqezIoQZqQq8t9w9vGF3dc1u85zlMCO9JIV44Zvl5JzWWcyky5KiqVEmM5FSyoppyBbLGPM/I0W+8yf/NL/07/1HNNdXfOv3/q7cDyDrkbUC5x0puUufJZFiICVHlALvZvplJJQac7UllImn4wPR50MoR5U9SqzZbV/zdPyEeXnMgMJVTRKJslxlcq8POSKrM8QxllklrbXhdDpkQV6YCcKiRcG5f8f1VYdzjrpesVjL4fQR2ggKdU3dZNuqlhqRqkvcH+bpkbraUlcVLljaZoV1CzYEzsMRkmfT5Ta+KSRKFZAUPrqsQMZinaOuuuxjWvJinAiqNJAc/fSYX0xEQMuOrlsxLfvcNBclJLBO0FY1s+25f/iMwkia6oaq7DgPWbglBBhTMM4HEB6tNpmaESLTeCREj3WR957/VvaHO879269870ImqmpFXexYNS85nh6ZljtSIo/1lcEtC845NutbnB+xNiJSwem0p6oaiJoULNlYPBKDY5nzMr40BSm0+cblxzxClQnvLEVRE3yuPqRUs9t9jbv77+HiiapYoesaKWqaOh/MRueY/LKMhLQgF4ESNUJ6tFxdCowFhekypifYyxi0pB/fEuKSD0zpkEpQyu4SRXaZv6cN56EnmRmpoCqu0Mbg4kLdrLHuDqU0dskFz023I0RHP0yZtxcsVg0kLHV1myP1Sl78PT/Ew0WLlqIqqKs1fX+iLIpsNxMrYpwusLdAXeWkSAgB5yK6NMgkqMrVBStdsljLefwMbTw+tqQkKIzKBTKZHdrOWwrTsSwTXJhNSxgx9oQQE+f+nmnMHJ+QJCk5trsrkm/zgyTlq/5iz8zTRNsahBwQseBm+/VsjtMKo7YoWXB/+D5VVdI0Kx4eP8O5/KB/dvOa4Txi/YGyMtRVhV0c83ymqlY01TNSqjLp2djL/0sHImR5kRekKNEql65265fsj2+oixUvrr/F53ffwcszqAVnQYgOKRuKQjDNHucTu3bF4bCnra8pVq95fPqcoHIef14W6qpmHgdWqw7nYJktVbVFFxvmCa5XV9zsfpTVaptxHiLmKHEUXFxI+QGa7ySX+4lEJvHV4vFL+dyXt4H8vpGIg+Pbf+z/xPs//dN8/ad/B0lJUFsIAeEmUjgjvOM8HLjrj8S2YJ56nLd0dc08jcQY0GW6zInvEdLTVNcgJJvtlq69QiSNHQLE3MFRpAzxKwzKFEijKdsGU+bEoXV55APkZODlJhMj3H3nu/z8//FP0tzs+J3/5D/G9r0XJPIB4mOA+GUv4FIku/ya5D6MYJotY4zoNiub57mnSJCSotAl03nG2ZH16oaq3FCZ52QnSY4/IzKG5niaqC6joyjEV8O23CwXhOgoUoNUNc4GKDzH/g2l6WjKGwQdSs54L2jaBpk0/bmnqmvadktR7ohx4nB4oqiyKqEsW0zKSvC27fDDAyEOKNZY3xNCLlNq2VJVG/zpHlHMjHPekWYieWQeZ6qqIbiMoz+cM45+vb7F2gGtc7HySz+L9zPTPFJXNSl41m2O3J/7B8CgpMGoBiFysqvrNiCuCWFGiS437ws4D48M0xNNW/Jw/AV8yGEhF/ck4VCio6gLEnA4vb2EewRF0RHDZUfkRkKM6FQDkturV4zjmWG+p2nWHI53F6BtoqlanI/UxQ6ja7wfUTKwWV9x/3BHW9WEENCFJ6QzPi4Y3eBs5HjMKJqu21GazUXZ4SgKgV8iHpv3pVIggkQpxTKf8w5YSfrhjEgldZN3y8ZoXIg01Yrz9BbrxqxFF4HCtKzal0zzQkgj83xkEdn6ubgjJpXUxTOkBhN3aLHC+3cso+Dm6gMW1xN8IsSEs4FxGihMxWyPSO2Z5hkhcqo1RffDPVyOw6esxBapIrM70Ha3TNMJrQS77TOe9p9RVLmbsV/eXtDwj6Qx8OzmdbZKCktZ7JjnCecXIpH1umaZPVJmEdTs7rF+oSgaujYXCBdnGOZ7SAvOnUFE6nLNZn0LInA8fUFVafrxHdEbqurr1E2N9TOr1YYUI1W1yk4KcWD2EyGUCFFiSsfd43dRUuHCmcPpiHUzdd1cEi2Cqumw/dPlLTnvULTMM3chBSHM2TNuLV1zS2GqXCaTBSlGmjqXNqUUDMtbkohIbXg8foxPE3FJWBsZxjzbr6qM/j6dHzJpdZGX1NOK2+2P0JS3PBw/ZrE9V7sbBJokZvanJ3zIIMCuvWE4BmRxRffsJ/h8rLkaE7dCUilFuHz/UkRUuqSuRIQvuUJSgzB5LJZ+dWT21cEiBEkpvvj5n+fxB9/nb/tf/etfEYETEqE0UlakBRY7cX8OJNOyXuXbmDE5aqu1R6qIdROH01us39O1W7QWSNUwz/mwTEIwHmdkEFlqJhLGKIrSILVBlSXyQq1NgJLygoiXl1RORAjF8PDEn/4n/gjndw/8lp/5O7n58W9k1LyEJNJljGaBLOGK0eOjxYUla2P9wON4pHp2jdmUqKLEuIwhHyfP1fYFEsHjYQK1sO9/kCnAskQqxTidWJYzZVlforSGeemZpnOmViyeGL5E6wfqesM4jHgPWoMQmmme2G4LHg+fMdl76qakrV9xPD5dMO2GprolDAOmtaSoiXHIHTUh8M4RgqUfPN5airKCaHKRucoLcNPW9MN4wYEkRJLsn55o6sT11UuK9TVVWdH7E0IJ3Ozo2i0hCJYl33aMaVh1O5ybCHiS8IzLGSkNS58ZfabQ+aYWI0pmffhiz6g5UZia3jqMFrT1LfPcU9dXODdiZ0/kmMvTbiZFgSlqyqpmWXqeHj7DmIpEotC3mWoeDxzOQ95Zpsjh9ETX5cnJYj2CkqfDgdGeMsliyR6onAAbGPoJpQIpwTj1WUOiOowO9OO7DN1MJUVxjfOPLPZMUXYsiyelIb+ASoO3iVV3RQiOcQr4YKirLWWxIYY7Qho4D/e5sK5h6HsKs2LVbvNncDpf1g8eF/zlxU8wTpbFerTJhk8ESKEIvkOZBuc8bhooqhVv3z6AjKxWGwpTY61lmR2zXS5KlYKr2w849z02PDDNfY71K4ONP2QqclFk0FsMgqrqOPczUibG5RHODoTNSzsZc+Tx4q3erG7YrF8z9jOzuwNhSQKquqYut1TmhvPxMzarlj5EkmipVus8057P6AsR1fo683CkQeiCpl7hg+Xc3xHjSAjtxSQX+ezdf0FRaVQJw2yJwjLNHqUrfDxyPMO2e48QPHV1RYgLddnxuM9vXE29QkhDWRR0qxseH+4IaWFYLElohGggRvr+hJCa9fo5QhjO/T0pefaHBzbrG7yPmKpkmnq6Vcc8LZzHI127YVoG+umBulrhheN4fqCuW54Oex6eCtpmjZCeaToRdMD7E/N0R2UMIWXeT1VcMw0WqfKtIxJY7ExpGmr9gpvX7/HRueDPfVIgNPzEM8ENuVUuEhhAuAXshEyBnJVOECXClPiqQRYGYfTlkf3XjMqk4C/+H/4lqhev2P31v4OIRKdf/VlJGqg0MimknZF94nzeE1OkKivGccAFS4wu472TpuuuEQTOwxvq6jozwPzE074nTAvCe6SImR5QliitUYXJYFJTXPYtAqUUWql8I0sgpcTNCz/3x/4kw/0T3/q9v5uf/H3/HULwJBHQKgMBkVlAJ5B4u+B93veNy8DoJvoENz/+G9HrdXYDuRmlwbqBzfaKw/kN3p3QZbYker8QPdxcfUhdrViWj1DagVA4H1hsjodXVQfJoGXB7ctnOdUWJoZhD8LRNAYlWyAxzY+8efcRAvDBIZVhmocctw8LIQS6esvj4ftIY1FCURYZyGrdjLj4gZQ0rNvnFGVHSlnOVpa50Pm4/5x5Xui6NSJK5sVdIJ0z83Kira94ePwC589f4eF9iBwe3iCFRxtQyjAvA+N0YpoGpCZTd4sc8il0zTyPaLUQwpEUAy4cCWkgpor98YiUmlX3AcvSczjfYe1E3RqQgWU+XyLrDdfXN+z3DwzDicWeKMuCzeo5PkSGYU9punyouTPWZqXE7HtiHxgHC+SXRp/OuNRf8PcNbb1iGJ6w/sjV5j3srPBhYrE93nl8POc0Wgz5MxN6Ho89MSaUgK65YZzOTHPuppQmEpJjHMGYhra5Qi2WumwYpnuUiZTyhhQ1IweG4UhMnq7dkEgsy4BWOZUaYqaeK1khVcFkzwzDcNnl5D1M06wwcsdu9Yr94S0vnn2N/eFIVYGUDQJJP57QumK1umF/eEdZFJhCoVWFVguncUJLWJYl08R/2CbKqrpFm5J5siThiNFRly3RO8b5kMF+MWJ0dfEbwG7zDKUU49hTFR2FecGw3DHOe5SsUSLP1QWJoT8QvaCqWs7DE1XZoHWG01k3UpUrFtRlTKM49w+0XYXSJdv6Gq0aVFtxHh+Z7PcRrsqlwJQX+oUpCUGw6d5nWRaWZcH5gc3qChkN5+EdUls26/dxNnEanlivd/TDI0t8AiGJQWYQYr1CJIFRBS4EmnJDDCN1aQkOtusVKUjG6Q0ilTTNlnmZWdyIUonFjfiwwAUh75xHyYXDqefYv6Os8xhBSEgpMrt9nhdHweT63K5fAs9uX6DFwmJPWLunNBUjIyGssOqKX/xC8PF5oV2ViGHBhAK/OLxdqPBIkZCEvBdRgpgSwkfCkMGSKpwQ2xXxaoVoc/LmyxGZEPDFX/wLfO/P/Id86x/6x5mSZIkRJcVXt5wcBgiYuua95z9CTJH7vaOsFLM/kcKcfR0CqnKT45kJnBuRRUQXJXbO5ATXnxBLQn35fRuFrqocMy4KirKmMCVaKZTMN5d8sOSbVgiB//xf++P83B/7E/zo7/lp/vo/+AeIIhF9nlfHmJA6XUILuclug8P67OQ5jidO0vLsm9+A2mT4JAbne4Q0JLEwzQdC9JiyoCpXnPszw3SmLW7p6vWliHZmcSPGZNV22zYYU9HUHc47pnFAyEA/3iOEyGPfILBupixkZuelzFpTVFTlFh9mBIGm6iiKa6Z54N3Td0E5tuuvEbykKBT7w12mFBQCpSqkqPFhph9PpAhtmxfKxgyM85HFWkpXYExOWDnnUdoT08h5cEQxIrRFxgSxQYmadac5nt6yWb1P21xz7D/h1N9Tl1do3bLabtCq5mb7mnePH9EPR8pSoqRhWs4kqanUNUZt2a13zLNFigrrHzCFZL1+xeH8CSl5qvpS4o0l1jqKouHFzTd5c/+dTDgXNTG5bMkUiZgkq/oWIwXj3DPMKRsvg2XVXPHwdGC9umG2FVVZo3WT6dUsDOMDIOjq10iV5XMhpYzMlzVNvUUpGMYzzs1UK0NhVlh3vogFMynd+4WiEIz2kVUBWm5o2xXD+IjzE6VquN58i/3xc4ryTFE8Q4oSKQucH9htnzPPIy7kkISUBiFKTv1EiDPBToxTz6pboVVFCJFxeqCpW6b5CWevcydHS3wcIUWEcPgQGOd9fqllhQsHjqd3+OCpyxYlV0hpCH6Gy+71h3a4xJSR3VJHpmUPwmL9gg8gUz7JYozUdckwZGBaBkBKyrpls3rO4+ETvtQXR5EYOTKMJ0KaSdYz9CO1L7K2t9oyjhOJkZQCiOwT7/sjdV1QVVvGcWDd3iJJ2Dmy3rSkeKYtX1MVm/zQSBP98IBjpmuuGPuFqqoRBphnTueni8s+t6af9ne0zZayVPTjA3bJ6tO+D5hSQ0pIBM5FXJTAwrzco5Vkvbpit/mQT9/8ZWLwFLrBGMNuu2V/fKBpKqyNF5nYQl3UXO9ecXf/OVJGtCmoq44UuaRSLFVVgGiITrNZXbFZvYfRBXd3b9kf35Ci5DQ8IWQiWEdbfshu99v5zz4TPNnEj73oaFTglz878dE44VaKZ5uWelUhCo0sFckIggJiAJ9Qm0ScPeIccD7gTxNGK1T1qymy6AN/6V/6lym213z99/0PsCKySEEhsqdeChBJfPURKwvD+y9/BEXB5/e/xByeaDrBbC2F0cQ0sdiFROI8POX0nSgoNMxHjztY1GjRMeZxWGFQWqPLBl3VlGU2iUopsg3y0n7+ciz2+P2P+e6f/lmaqx2/8b/3t2CqrK/2Ps+sfcx64xQ8KdoLxHBksGeO88AkEzcffh2vYJp7SiJRZwVzsB7rFspKZdqtVxi1wnsgSVyc+e6n/wnB5/+m0or1+iqXGMOCtQuQLYYhTfTjHdN8pLrE9pumJm9jHM5nn5Ig/xpkXE8W38UUUaq5lCc90e4594e8OA4eId2F3JDZWlVZM4/ZKYRIDOMDs8wBj7rasNusKIqKcRypyhyTn+0xR9STIAQwxhCFo+1W1MVr+uEe73OjXusSo7tc7tMF3gVcOGFtz31YGOa7S4KsRQpoyoJ+lNTFmsKs0FrTVBKtZS4ZN5sL6sbgvMMuEIIFYQmpZru9xdqYg0OmZFoO+GAvDLOexfdEKamaNS5Ybq6eo3WBszN1U9Hamq7r2MjXl1+ze97dvct+IFPj3MTIEyRYtbesmmvO/T3eT9SVYpzPJLIFV4iWwqxyolXkUV9dVYTYEIXHLQP9+EBTZ3zQMD2SkkKrmnePv4i1E0UJMSVMURADjOOCkpksICUYkxODghVWDkQ3IItEqxu0qdh0zzieHqnqrGyvyoZT/5SrEVpdaMsp65jFBmVygfdm8yPE+Jqh/y/RxYwIHWXRQqpQ1SoDPX+Yh8s4nhjGJ2IMKOMw2uBcxmMcDycKk5lNw3hi3b1k1b7kB5/8PGUpsa7n3eOvIGXm/Ah5EfEogcfjrSOJSJKBGD0hepzzeaY7HlHKXPSnOTsPeQ7vFk+5qbDWE1N+c3T+zGZ9hVYrrM3tYCE0wecHZdt1eO9ZZofAZKSHhK69wbmZs+059Xc47y7BBI932XzoraeuJNbO1NUKE0uGPiM9vAvsrra8ufs2D48fc3vzinm5R6gth+Pbi2umZrd+RT+eKMocmXRuIiaPVIa+71mtMogzpbykK4uaeV6IcaSfPmGc36Go2G5q8IIYJ5bpHdfb90j6CtX8BN/5xDMmwU99sOJZkfjF798zPtzx6hsf8v6rHYUUBA2jEGghUJdOi5IaaUAYgWog7BI6RrDZG4OXSJlTyG9/7uf45T/1p/ipP/SPsP3RD/AiL4K/jAP8VV8iIoiUpuS9599AS8Gn9zPzeIfSDcF7QjgTRUbkN9WGptrhrEcLzfHuhDsHiiTQhcaUCmGKjNDQAqFzWVQphZKClCIxRgQ5sHD8/A1/5p/8p3HjxN/yv/6f895v/UlSjLm9LHMyMMaFGBxumXB2YnYjox3ZzyfUdsWHP/qjHL0F7al1hfeO/WGfi4NFQ1O3hGgv9kDDNFuuds8YpyP7wzvW3YbdzddZ3Ilzf88wPFGX2Udu7REZIn7JI7wvSdvjcodWNcreMI9nrnY3mKJDiw0Ah/4LrBvZrJ7nbpWyjFNerPs4Mc1ThklO+casdMLZnMSTSjBOB4KPlE1NSpb7x8+R0qJkh5Qt/blnvd7iQ4aSalXjrQYtqaoqN+yXmRAEtak5LW9JYuL65hqkx6eeSC7tGW1omw3BJ7rVDYUqWfyEDzMpBU79W6To6OpXzMuJmJ4wqaEw6+zgSebSpRN09UukEggR6ccHhEhAjnxrNaC0JXgFRIRckBJudj/Gw+F7hLBwOO+JKeVdqrXE9CVHbU8/WQRHRKoIaaCpV78q+ouO4A3b1S3TvOfx8IOcInU9y/7Ipnuf7dWOu/tPUEozjgNtu+JwnC5UDJ9jxFGwWd0QQ4RUUBZVLiy6I6aA0/kNVVUxTZEYJKt2g40OrVOmtFuBUpqyFGijsUuPXQ5Y3/Pq+W/geH5invY8HT/Ohy+aeTlRlS3QE5IDm3l+zgYEBd/48Fu8vfsBT093BPsDrAu46Hh1+5K+H/FhpqlL5mmgLH7IVGSjG1zINrxVc0M/PCFEXsJ97fVrHh7uCD6/rU+T5Xz+leyUFhLvLd6ODOMTSWZHfdU2WBuwYaIuS1KMmKqhKFvm+YwPPSnlxnJRFIT5mBvYsrgoRAMky+FwhxAGJTUxQF2tORzfYszhglVoUNJk02RIF37PgNElpdmyWe0YxgMPj2+zSdOPVGVDWTaklEuHy2xp6hWrtmK/f5MxIBfHfV2vSGImqcRpfIv1E9vtDVp1zPMdRi0ZnXKRZOkiYWzJ7GasW3g6fgGIXNrSOkcqpUKIgFCOhKYwMlsDpSBaT9eVxLQwzmdiCnTrClM9x6f3+fYvWxZK/rofe85VEzk9OObPHvjJ19e8ulrhARdBhywAy6MxMtbjwtn/crEtEaAFWpWEKDgeJ1brChR88v/8f2BWK771M38vuki0SGqR8s7lywIm6bKpkV8dPEYJVtWKRt0QQ+L57ZZlWRjmtzh/mXXXFUZ3hLlmPMC6+U3oDzyF9NjpRBrP+dep0Hn3ok0efaSMd08po11yIVTwy//Bf8Lh48/5sb/1b+LZb/rxHFEmu+ITHucm3DKxLGP+y82clzNDXChutjz/xodYmWi7BuemC/on//yizDpY7yNNvWYYjySyd94FyWJnNqtrKtNg7SPn/oBQDhcGsInN6pZpkZl8LHM7OxEoCoMPW6qyzT0pXRKDZJ48s80PZedn1quXNNUVD/uPLg+AVf7e7ERZGZxLOSFmFMtypKm3SAXTMmBMjZGSrt2wP7yhLMF7lVEuSdEPe3woSCn7leZJsmqfE0JkGB5wfmLV3eQyn13QqiZ4z+JPhGAZJvBxAiz9eCaeFcbUkATr9iqnKHXJOD2RhEXKQBSO2U7MC9S1ZJpG5nlEXuyMZWmIIWGnKds5VaJpMtVcSokPI9PyQFXe0DYtMa5IRPrpHaTshJeCDPiUGmdn2lXHw8MeIRLTNBLiiapsqIub/GJre7Q2xJCx+ePUs1jL1e59QNJ/8cu0dYuShnmylEXD2J8ojGEaAyIa5vmEDzOtvmJd3YKIF95iw7rbsT8qfHAgEmWxgiRpqxqtayQlWgkWMfP49I7d7hmHY34OOTvn/QojddExzRNKJDbrFf1pTwiO1XqNsxNal9hwyMV1WaJkTbvuCD7y6Rc/x2Z9y3b14/iU+XKb9gatt0T6ix59j/WWTfPsh3u4xOiozBVdt+Z0fshCKSmYJ0fXZERz21yhVMXheEdRSqp6RUge62esm/Ep0JQdKSqsDQzjgNIKJwJlIZnGM0Jmh/Q8LUh9YrO+wdrAYs+ktFAWKScXjMZUFdYtGJUySsIf8HFBqcgwvSUlifUS6yKFIdshY2B/OPLyxdfxcebN23um5YDREbtIYpKURuJcTl1tVi8IwTOOe6LPsd8QE7MbCH4hCZchhXbBu7wfqMoaIRLvv/5J3rz9DKUiZdngg+WzL75NWeSEF1GzjI7t9hkpSYbxxKpsKQz04wGxaKb0gFAghKSu1rTbLtN0pSTEGVMU+FRzmCRv7mamE/yWn/gaz5rItDjeffY56uGOm9uK5ALR6MwPS7nPEvlSDpa7LEFkVL1E5iu+kKQET49HfExsZY0/9/zlf+V/z7d+5meoPvwAg6AVAp0uurFfs/v/armfcsIMpehMw+v2GZ/Ggf58RAiNpsBFTQDmYUCEmhfXH/L66gVNsUFJgTYJUmAeeg7v3nJ6eIezAw0iAyxlDjXkUk4+WH7+3/6T/Bf/9r/LN3/3b+ev/0N/gJjipSjnc98hZGrttAxMw5llGejdxDFZdl97xbMP3seUTR71qIrZjnzx7mO0LvDeEUJECE9ZafaHHOgwRcbOjMOBlDxlcc08HTgNX9C2W6z1jNORphY87RNde0VdrZmmnoTndHqHEhWr9paEQktLTDDOM0XJ5Xs+EELKb8RuwPmBpumyGtxs2K5f0PcDAoEUkhTT5aHS5gKiXiEwDMseF4/4uJCSYJz2SCVIKasfEiIv/rtVVnE3BafTkabpgAbvAJGj23V5jZSKyT0yzE/5ZSlKXIiYsgQKZCpwbuDpMEIUxDRAstTVGh8c/XSPNBVNeUVV1EzTkRgF6/WKoe95ejrw+vlvomstn7/7DmVV45zN0fZ2w+n0hNEbjKoZzyNJWkSVi7RG79ist5z6O+Z5wQjPqr0hBkdTe+YZiqJGCIlWiqrseHi8o21q7NIDgZQsy3LA6Jq26Tj3A9oUmLIkiYXj+Y6yKvDW8er5jzCNic2q4Iu777LubpjnkSf3MUYbjJEcz3vO/T1ayws9ImN06jIjVnKRt6YtO06nNyhZoqWgKlvGOSFkJKaZsnJIYJnvSMkihKaqC9bFhmla0KpEqcyEqytBURic9ZcyasHxfGCczgQjcX5gmQeIKU8V3IJdFgrdUJpV/j3/YR4uUmpi8szL+ZI2ynRSxMJ5+D7KhK8YTIVRFLrB2pgX1yLfVtr6msKU9EOfkS9NQ1VWeG9RIrspklfsrm6Zl5FxWRinQza16ZxYq6sGQfaR7DY37A+PjPM9PhV0qw47JogFzkJZFczLRIgBN0eMLphmz/X1K6pqxeH4BZGZtu0gCrp2TUqGlBTWZXrwPI15hp8SXXuDSB2r1ZYv7r4L6Z6q2DEtB6RMlOYlUhkent7w/PmGL774FBcGlEus1xuWOVAUW5q6Yx49m9VLgnOkEBAqN8JJAhE3GKHw4pGikEzLxZ2dCoKrGKeR3bYGkQhBUepXtOIVbw89P/H++9xuCqJILIcD+vM33D7u6YYdaRpZivy2GBDYlDJVVWSXulD5xxgvh4JQCB8ZDyfCsvDs5S1aws/9m/8Gh+99n5/6mT+AiQkNuQArfu1x8qtf4surzOXvTdew9htWZ8n98Z5YzAiRiAmUrDGqYbf5cVbNhzR1SV1J1OXXJgbBqrxic3uDm75J//TAsH/A9gfKFBHJEskLy+Nnd/zcH/sT6KriN/89fye6ri/fQ2Re+rysn3qG6YBdFha3sJ96Qqe5+dr7XL94Rj/sWWuFUEWOS58fCN6x2dyyWm3x3kKqaKodkgIhsz3SGIlkxWwPkApiWKjLa0hZOmaXSIqZICyInPtMhhAi0DY3uakdHKf+HikDWhZILbA+Fy5TWoOOHM6fEFyiqTfEIPFeUBblRaLVcjo/Mo0L7733DeZpQknB6fyUb/QXRMt5yLw8IQTr1UuqsiYmSde1XNxxWH9idifmh3ukLDCpw5gCIXPZcJjOzO4N8zJBjNRFizYFINEBirKm759AGUJQWJ8rBSHlAzCGksKYS2nVEcKCd4oQsx3zeHqiMIauWVFUnqenJ7ar2/zzucT9rUOI7FJq6y2m0zhvedh/gjYhe2Do6KrXEO+JcWFxOVDinKNpOqQQxJBTXikoNqst5/6Jqi6AnEAcpkeMEQzDEaRjsy2JzrBdv09VnuiHd9RdwdPxDSEITpPDxSMxSRY3EIXFB4UQLQJFU7dYl2VoWstLqVbilpyKlMpiTzMpSrr1hv3+CV1I9CWNF0We9BhRMNsZIQTaNITkqVTLapX308vSo5ThevtNQox4f0c/3VEXG0qzpWlWuXwpaq62uVRsbU+IA6tVg/dD5h0Ob364h4uQCa0d5+EJY8r8dqYK+tM+28pEzoSHcMIHh44JISWbbsvd/WfMy4HrzXPqusD7RNOsWJaZGPKyGBEpK0OME/30FmOqTFZNPYmFoswmRSl7YkosbuF4duyPDxSlQCjN8XggBp31taogRp0X5AmMyW8kpRkZpwzhE3JBKkVpdqzXG4bziBQmU5PljFWRaX6iP+cdSVV21MWKYTxyHu9pWmi7DUsYSKGkrW+ZlnzbqooNz58VTMsRKWN+A0uOrnyOc5ZpXtiunzG4PXYZcGnOD3gUL5/9Rk7nR+4PR5bZZpRKMtTmNa+e/wY++ezbFDpyGO+py2sK/T5vfjBw3da8erZCCkeYAnqZqPs9lT1RuSHzvWINPmaTpBS5hSwSQmUXhYgij8pEBCGIpxF7Hnj28halYXx64C/+0X+RD3/n7+Tm5UuQipjy0OvLK8uvYmT+P32QElFDubnm9fzjzHee+/m7oCx10yFFQ1n+CIV8lkdAo8VoRVFmOVNdZ/ZcihHdlFy177N58Qp72NPfvSGd9xRCc3zzKX/mn/ynSDHxO//wP8zmg5ckUp7xe8s4nxnGE/PUM4494zLTpxl1XdO9usLqyGD7y/5ixk4jRVGjhKRqt1TFNo8lkqdrrzmdRsb5kaIw2FlQaMNofzUC2612xLBCFZJ+zIK5lAzH8xNSLrlg6Weaaoegy4DLlLJraD6jVJlb4fNCWZYURYMUhmE8XDzoEecsAsFiHUoVhDhTlIJV1+J9n7sVcWKxFusWbq/XVOU68/hwWJdTnVKJzK3rj7nhL6q8r2x32GVisSNVsc3LcD+RUg4H2PCEkFCbmiQCKUVC9MzLmEVaoqDvj1ifuyZNuUOJLcN8T4oDZcoivMK0eCfwwV0Ms9muWFcV1gbuHz6iqdckFMl5zsOJsqqzYqPOO7en/RNNWVFWDUpqRDLU1YbD4S0+eNbtc8a553T6gsV61qsrhEhYNyKQeaReb5ltyi6l4KnKIlPUJUiVKEo49idCGvE+oVTCuVy+7YcBrd0lpeaZ54F5HjJuXwia2uD9TFPnEas2Ae8nUtyw6jY87d9SFR1Nc8Unn/2XtG2HSFucE0gV2B8/ywnCsrz8/lVEeUYbTVm0FEXDMJ45ng4YVTGNE0JGitKzP37Gdv0cJTJdeZzvqcst/fiQ3UEhTy2UNMzLiC4SSXB5Zt1QFlc/3MNFknCLoy7aPK9Ukhg8m/U1UiiKskYrw+dvPmJxfZ7fp4tyFserF9+kq1tO5zsQM8viqaoOZxNlXTMv80UkVjC7GRc9WpUIV5Augh0pEuP0iDK5kGbKkpubl9jZssw5W16XLYPvgXgZNfUYrYlB0NQd/XmPTydmm5BCcb17QQye8/lMCB4lLOfHB2Y7U5YarRTX1xfhTn+HryZS0mzWO5yzHM53eBe52r3MMVM/oGTF8ThQFHkZdzi+ZRz3zPaIdwGt6tx2rg2n80zd1giXQ7Dn4cQw3fG4f0eIeSSRpGIYZxb9wK988meRYuHcC2IwNNVrzk+S4Dzvff0aVZGtj1gijqIS0EVc5VEykmIiiICMgiRkvqmITPslXMZlEoSCMPaEc8/25gpZ5o/Kd/6d/zOHH/yA3/NH/ghFWxP5kj32/96D+avOlEuzP5HNlkLXlLfvcR0t86NHVPtcAOMZbf0aY64Bg9EQQ8B7wdOTpSwtq1VW1YpLlFsbg3r2jHK3Y3p6ZHrzGf/Zv/FHefjuD/jJv/v38sFv+60ZVx4W5jn3LsbxzDgOzMvI4CcWFdl88AyzqbAp0FYtShQIo/Au41ysH2jbW7SsKM0GUyQQNu8z3BP742fcXr+mrTu89bR1DbHiYf8GJSSb1RXzMnA+H3DOsl7fUDeGZZnomh3LEojRMsxvmZeZdXtNW13hY8LFwHy6R0tBZGQcelbdLTFlx4bS5aUMOFMWDaRE22qMqjmfH0C8oypXlEXFbrvFWY+1lmk+0q1alCyZliMx5KXzYmdSdCxhxiiHC4FT31NVFT44ZnsgJMO5f2K9WeU39P5A3VRIUZAIhJBwdiGEmYCmMB1lu2acI03TMI0zVblGUmYL5+6K02nPPM25dyNkFlMFyarbMIxHikIjUmJxPc45+uGJaT6zlrvL4bDkCUlpSIzsjw+YQlCXG5729wjhcc6y6p4zDv7C7xqxy0iKuU5R1hVJWhY/sjjHevWcU/8mcwwrjTZXWcU8PCGEolAbjNR89Mm3sXbg6uqW6+1rYorZCRQSlbnBhlMOCSWRn1fB0bU31FVJP95RVR2lyfDN7fo5KWiO+4Gy3KFNzTw5+vFAjAt9f6IwBdFLlKwp9A6lHeM4YqTExYiMLQ9PX7BeR7RuMkPxUg1ZSktdbEkBnPf0/R1dc02hKhyOeQ7U3QZfLARGlK6pK00MBXW5++EeLtXl2rnudnnuvQxI3SCVZJzOPD09Yb3lcHpCqcR6C0RFXV6x27xkmY94l2NvgRGjI2VsMcUFxqay5TL5knWXHc9CxvzQ9wqlS7RRTNOJWinsHEl1SV22uOWBFA1d0yGkYWNaxukELEgdUdLhFssiLSnNFxxNi5YddlkYxzNXu2+SkmKeT0zLibpoWTU7TFExTEdCAqMy1VVLye3uNXcP9yzLE0JITufHy0PI0q0qhuGJYbQUusiaYNPi3QBk/4t1I3f3nxCF5TSMCKFp2+zD3p8+o64L0tSRkqWuDZvVC7zP5kOjN+DBmJaUWux54mbX0W5qkszsLUdEVQV6V6NDRdooRB1BOVLSeMi3y3wM4wGIaCRJRmK0JD9QtpJk8sNNJsGnf/7P88Hv+B28/zf+jZC185cXiS+ZZP/VnyGRoWRk4CWIQrO7fs7d/gs+f/s9VutruvX7lOYZSQik8oQoswkSIBW4EHk6WKbSs15XGKMQl11P1Jr65pZv/9t/jO/+B3+ar/22v4H/5t//M4QoCSJxPD4xLWf64ZR/3+eZ43RCbUte/vjXKdYti12otaEoSmLKDwZnPav1Jr+NqgLvPPvjFwjpiZzyITWPWZew/oBhOJHUiXfv9sz2exi9YrPeMS1HPn3zXaqqZLO6RYjAPFlIHVru8GJicWfOwx0hCppqRRKBoT/Trqp8cy8Lgp1JOELqWdwR50bAI6WCJPE2sll3pJijx0IkfLSczm8oy5LFBgrdIORC3RpO57uLE2WkUIbT0x3a6FyOFC11fcV0+IKmLfLnVy640DMvObLRn3MXJSXDPC8UK0FTXrHMGU8ixQ7nFqb5SKFbmmLD2I/M9gElFNeb1xhdM/ZznjpIkVUdEWKKFwrHHVIkEBrvQCuBjyMpLqxXa7TWnPsTWmucX2hqQ38aQDr6oc96cJMhlgjFof8lZn9mvdoihUGpRJIeGRPz7AhhzDfKlKWBIUBIDruMsGQSe2kapnliWRxlUXB1tWUYFctiScHz/PkL+n5mtd7ysM+N+2pdI4LjvIxs1jcYXXE4HFl3L3l8esfYP9B1KwgrXt7+BG/vv4cyNVKBbAam8YzRFd/44Dfx8PDIYheatkVpSWGuMF0usB6OT5Sm42b3TYxu2a3fY7O+4tTfs+kyTFTIxLG/o62eEWKfgwSxQMsCoxXDcEIqSLHCO0OMM56eefkh91zun97RNWuElEzjhPcBrRXnPkcfXQhsNltMobNDJATKsib4HCNcZktZJaQquNl9jWE4oU3FMO5Z7MBud8Pnn79hvbqmbbacT/0lzaOQqqPrtjkBUxRsuh2HcEeMZ46nEz4uxHhxKohMTF61msSE91maQxHxMfLq5Y9hZziPj0QiImma9gbnPHWzIaX8JlyanGYLTAzzESEVu93XOZ3fMMzv+OTTA3W3ZjzPbDbXeXxFNrnNk8WYguATNzevSClxd6fYrmuur77GYkdO5z1FYRgniNGw294yDTN10xCjp643rNpXmWbqcjdACol1FqVLCBpJh59yAmtzswWtSEISRSQi8FLCVYmkJGhPwYIMEz5pktJ5ipXEZbGai4dZgzWDH9HzmWmJmLYkeMH9L32X7/37/z6/91/5V1BV/RXcUuaT49f7Ubq0K3Nhsig6Xjz/kN7eURZbjFmDyLdKkWSGZCJyDFVc+jOAdY6Hp5GuLegak9NjAt79wrf5v//hP0yxWvN7/tl/HhEG0vLAdN6zzCPjNDFME9M8MIWZFz/6mmc/8jWmEBjnA7M9Mi+KZ/U3mYeZlHqUrjif95ku63KqJ7Hg3YJ1Z4yG7W7HMjt8cBxPR5RO1HW2B67X14QA0zwgpaRr1xhdZTRQVRFjyk38JLjevcSojD8/93u0qSh0wdAP1GXN1fYV03Smj58zTg9o1VAWN3gfWLUbluBomw4lE0iD8wuLdUiZo9rOz7TNCmczJViGmJXQesMwCmya8Iwo0RGipG1vWHevGacJ5MDp/ITWIpMlrGG9ukarluPpLSmtiRG66hla1/TnCesCN7sXuOURoxxtUzKOPc6eeHb9ihhKhIiM8xvAMY0TdXNNYVZMs2O7uWYcDmhRXhr2PWWtCG5ACkNd5bKg81AUW6KPnM8nnO9ZtVcss0GIkWmaaavneH/Ex5GYNKZQxGS5vnoBwL7/Li4OrFevCV5wHh7Zbp6TmNjtrhjGI3WVU6dGt5RFx/l8YrE9UiaMWSGQNI3h3J/46JNfpGm2SCHROiBEACzenShLmanRi6dtN7T1FWnTMi33FLqmKF7Q1jdY+4sI7fEXV9Q8j1AKHp8eSQna5opXz3+Mt3cfIZWkbW5Y7IQSI3W1Rso8NovJ8tkXv8xs99RVTt36OCOkZ/EH7JLyi3u9IFT2HiEibg7c3r6gHwfmecmf36v6h3u4NG2DVLA/Hll1O4qq4e7+E0KySFmgtcE7wbp7jrMWj2OeBtqrHf34hE+W/cM7BApTTLmbwgKywEXPm7cfowtFEp5Pv/hFNpsNbg6XPD2czo+E4NCqIIZ4WQB7YoSmbphFQKrAMCys19ccjyecO+X5rlQIoWi7LeeT5/Xzn2Scf47T+BFd8ypTAMLEcpjRJs/YT0971us11nlccmjkpe1bU1S/RpNat1TFGrf0jPOertlwe/M+X3zxMUJqTucxA+aKmkTFOGd2T91kqnSNxC6CqtygRc0058DEfv/Iy+cd05JRJNYuSFFekjANomyp5HPOj566a74aURHjhXQMToDerolyzv+sH/Iy2BSkyhCiIEaJlgKtJD5Ekjuj5xPpdOTw/c/Y/Og3sMESA/z5f/qfQhnDh7/jb/qKqPwlIfm/ds/yX/OllGK13rGqP0TrHYXOBFwhZE46yS+DApf/xpftf1UQpeY4LCwusu409ume//Af+58hteZv/mf+GV785p/i9O6OL75zYBkcIXp8CMzRMUnL1Yfv8bWf/CaPw8CLZx8yjQP9dMc892gTqeoIrEgxoSp9gVfma5qS5VeZayULlmUhxMDT4TO222fUVcebd9+jKtc4F2naliQS2+1z2rqDFOjaFzi3cDx/yqq7JSVF9JG23lKEjsUfWDUvme3IbJ8whaQ0W4JLGaoZoVuvEKKiHyzeSUyR+x5N3SFlxsp0zZbD6R4hFqqyZJocbbMjBpHpw+OC1AVajYz9jCnWeJt1uIt75PN3h9zDmE8s9oiUG6xziJj3kE/HdygtMb5ksRPn80jTCc7DnrZdUTcGo2542ltCcCgJ667CiA1RB1Aenar8cBYzAbh7/OKiCn6RBWNVxWJnjv0jYvTUtaZSayTZ16Okpn96g5SCtm1pmpp58IRoAYVIDXV5y3EYAQepoK23xGixdiExEsJEVeYmvKAmRcXxeMBoiRCKrrmirlumqScmx7l/YLXeIPqM/ymLCqUMzuXyo1SCwuTQhB8G6qrIFJLiCiUz5HaZPNvtNdPokKJmWSZK9RxVnjgOv8Kr11seHye0qpkWlZ0yzCiVaFY7Cr1mnE6URUlTrTgcnvILstacz0e67hplPPf775JiYr1usXPPZn3NbCU+KLxTaJOrAtOycHV1RQghV0XsxOl8xzQFqnINwjNM+1/Xn+1fP3I/apKAtmsQUmQYm0iUpkXpBojYxZNQFGWDDFklO/QTSUQme0KobKE8nD/He82L9hXjNCBVyjIjl/3eZa2pqobz+R7rBqQUl4VeQ4qBaXlinPZMs+TF82/Qj2eEkHmWHSxPT2MubMYJJRVVWXM4DYR4guh4d/99jqdHkhTcXL3k3J+Y3JmUEloKDsdHpCropx6tCtbNS9rqhkJ3vD1+SuDEen1FoQ0xCma70HYbyrJmnha0KmjqNcoErJtJKVK3DctsGacjdd1RVw3H04HD4UCMGTlSlw3TNNF1DdO08PFnf4WULF13g7XZwrks4K1EiIJ5CZAURdvlvUfiqwKhcw4XIqKoSN0aTyJODpV6ZFvhTYWXmiRyPEyJgDwfEId3iOXM21/6Ps++8TVSWWBD5PGvfIdf+ZN/ir/uH/5HCMqgLyKxX40a//92wIiLkUyI7Dm52r5PCE0ejYoMwFQStE4YLdFK/lXwTB8iLkWUKvE+8uZ7X/Cf/EN/H5/+7M/ye/7IH+Gnfv/fTSSxfvGCw+Gb3O3fkfwTQxiZ5MTtj75m8/IFU4goWRAAGy3GNHTtM/p+f5HPlehCYX3EmAqtI7af6NornvbvCEEjjETLgrqtGIYjPszEWNG0BcN4RIiScZgQUlOVNc47YlwwasCYEq3r3CUJIX9mlaY0HSFkfxApUZgmX/hivOwM3qMs2vyGiaQyRU5xCkXb7pBCMc17ICu7q7LCWdCquyBxBCEu+GXAFBXeZ0X4i2cvmZeJYbqnqOB4vMNax83V+2i5piztZVIxsF21nIY3TPM9m9UrztazhDN1UfOwf4eLPSEpPn3zbbr6lpDg3f1nPLt9TVHkA6qqGqZ5ZL15xjRZtte3vLn/CKEd0c2chzsKnUd5s92TWKjLhhgWXDqhMISgSdFjihwf1loRk2MYnyirAkHJdvM8J89kAldnG+YYKKsO5y39eE/bbBFhQ9NuePPuY1yYaKsSuyS8d6y6W+Z5QcjI0B+oq4KUCoyp6McTwR8RoqDr1rTtOt8GxgjpQD8eQVqqsqCudtjTHh/sRWxXcD6/yylHpXn57Ft8/ubnGdXn+DDnP+PFiqbZ8XR4m59N/QklJqKPPLt5iXeS/txzPN+zWe8I3iOVxJQwTEeEyp+Nw/HAuuuQyoDwhAC7zS39kCGgSiUOx8OFNj9T1ILz+cyr578hhymePkZI++v6M/7rPlxurl7y5u3HEI8IMVBVNW27oqm3xKByO5mAViXjNOGs5/ntj5AS9OM9UhmKskIJiZQlq9WW03GPEKCVZhxnuvYGKRXJCw77Prsp7ITRVf5D06wvOP4eRLZTvrv/BCmhLldYC1Ib2qYDEilJVs11HnmVZQa9FZLZ37Hdlgx5BfJVB2C12mLnhZfPv0WKoI3Ee0/wF8mRz9TbYdIQCmShcH7idOypyx1fe/2jPMZ7+uFEURp8DDR1w+nUX/hAgUKv8Bacyq3nZ7dfw9oMoYspeyyGcaBrN5c4tGCzfolS7cWotxB8nZEQEXRRIJTJFFTI5c4YGJ3FJoHQBbpeZSaLS/jTTPBHMC2qzmRjlTz27R3zdz9mZWc+/ui7XG9v8M2KBYn3kp/7o/8yuuv40f/h7yfJjN4uTX6b/7UP/V/X3uXLnyvy25JAcrW7ZX+wCKHyS0uhqQpFWSSUzJpbKbhclTIIPySF8+Cs5K/8u/8XPv3ZP8t7P/038RN/z99LSDJHq0ncvnrFpx/vuN//CqmEV19/H7Wu6d2JbRBoIbl//PSCK3KXBJRAiIKUAsO0UFcZez5PFucd47gABdtNR4oRqQzztJBSxPkzzpeUxRpBgERGrStDUzSElJhmx8PxY/SFvF3WHUophtOcb3NNzWb1LBd0WSAJqrJjXo4oDT4WOA9aVZTGZCS/NKQos/djXWPdjAsLy9BTVy1F01LXLc67jKkJuczp/RPWeoQU2HhAKcVknziPFpKmKhvmOSOdrLUXBHxkf7wjeMl2nXlVRa2RxYZhOgGBzeqapmkBRdfc0E+/iK4CdXOFDY7T/DE+3lCYgnP/BmcjMVQEO2AKw3ZzQ/ARY7KbfhgDr56/zzCc8X5hWXpWzS1tfcXn735AvTYXpL8mJc2qbVncgVVzRYpw6j8lMdI1z5nGwDRaxtGijcLOGqMThInF5ULnqr1GyxLTeHywOBcIIaIUtPUNMS48PNyxu7rOwQSp8D5wPh+xfqQurlhsIETLarPD+iMuzLx7/DiXQb2kqjVPT29IeKblBDh+6eM/RVVU2HkixURV7hjHgbpuKfSKlApWXbaiIjxfvPk+dd3Qj0fW64zscS5+Fb5wfqYqsh03K9GhHyZikrTNJttzecZmfcu7h19hCfe4MFz6OpIXz15gZ48uCoxq2e6e/3APl74faJqKeTlRFiukbBj7DD7TqqEoVszzAesiZVlSVQUuZH3pvExsVy+Z5iPLMpJS9r8nFCEY6vIlbVWw3dwyjTPL0tMPR4zOMDyjaxY74VyOYc6z5fWLH2ccLNPSZ7JxcJRl/o0UyaBVi5YGxRVoj5Izzi8XJlNBDI5V1xJiyKrQGJGxRIvE85tXfPLZ9xCywlpL264IacYFx7z0SBUpCoVU2YW9Xjcsy8h5eCSknrcPT7Rtm1EX7RZjKsbpjHMj87LQNCvGcSSly6EVwbtEqdVF/pNlTTIGSrnhcDhh7ZAPLB8pig5DjQ05Shyjy1wpIYkp4+WDT2gKUoqkSuILweQSYYbzOFEMA+s6ITGc3nzG/s/9PFei5gdvPuVZJUk3a+bNhiVqnn7h2/zKv/en+E3/kz9I+977+BAxRebJZYf9r0Hyczlg/r98/aojRqBkotAaoz0JQVEoqlKhVUIrkOJXDyzx1QGTMBK0THzvj/9b/MX/7T/B9W/8CX73v/yvItZXCBERMX8n9aolVWviZsPrH3svF0V1wJ+P9IOnLFuiz2/kZdnQD/c4N7PRt4iU9dM+eOpaIcOCigmhI6uqxQiJczMxZmqwFgpvA6HIGuxSNazrr+Nd5M3DLzDMR26u30erhraZvxKjZXfRSIgz626LkIFxfEAqBwgK0yJl1hcIkagKDUgKUzKOQwYYJlivNxxPDyxL4ub6x3j3+B3a7oqu2WVPyTJjigoZA0KA0RuqwkATISl8mJHSU+oNpYpo0fDeq29xOp84j29o6w5tGkTUX930hTA0zZbFWpwfme3AquuIIeCcvbxwPmT3SrnicH5LXW5oqiuqsuF8PmaxqXA8Hu8oigaRVLZpkhgmlxfo5YppXLDWc7X7gOAT3s8c+yNNs6EtM/JpWU7s1l/Hz4ZCJ4qipSy2bNeK0/Geptzx8Hhit72lqlY8HT/PkNug0UazzFCZa0pTELzHFB3xQpuISZAQaN2SUsNu12ZjoykQMiLwRJl3b1rnw6YoG5YlMc4OoSLhYjyVFIzTmcPxC8pigzGKYTpxtX2GdQtKS0q9pik3HM8H7h/vMLphtVpfdrYlSm65vsmBiXFSGF0ipUBrgXMeP0/My0gKicIoQsi64hBHVt0zTqd7Hud71is4j47F7fExj/+VFCgjKYuWuqwZxiPPb18TmX+4h8s4HpEmZ9zb+oZxHGnaBoD9/hGpjnTriuPhyO31e/hgedx/hCkUXfeMuqp52n9KWZWQFF3XURQNy+Ivb3Y97+4+Y9Vdsd3ussirMFjrqasdWpec+3sAYpDYJTHPllW3g5QjwyE42mbF6fxAU+VT+dy/o6k7yqJks97ifS6CSqFZb6542j+BXKjLmuv1BxgF5+MJYyLeTxnJkDoKo+iHe5R2X7mylSxYtYrz+UTX1szzHkSgbStIESU1RivmKWNCrPUUpaKuS5zLEnhrlzwaUSVNvc6jCyMBj1KCzfqW/mRRtcDaOeP6Z8fkBwQNMSRU4lKyvPxmpYRMKfdXkMikCEkSjMI1cJ4HGAbKTnF8euDn/+O/yHtqy2d3n/PBJifL+NbXWeoWmwSnjz+h2mz5TX/vH8hNeZ2X6/lgybeD/39WLl+mx1LKP5ZGoAtFUeSujYCMvSGfJ7927Pbl34/39/yZf/wfJ3rPf/sP/U958fXXjIPHS4M2MceVSTTbluerD2l2kXN/IKRIUXXc7D4kRsXj4dOLhW9mXka2my1KFcQwZ888kWE8ExmRCJqqY5oOROkQIuI9FKbB2hyTlVYwPRxpqxVqlfFJUjukEVlrfD5TlhVte03fD6y6Dc4vF8TRxfhaTgzTiaq6Zrd9wZu3PyCJBWstRhc0zYqn/QNCeFarLQLBF29/iYSlKlfcDXnkut5dcTgcqKqszLB2QMkLMVrkNJaSBSEEYpC0zS2FdsTgmMeAMS2kM0qWRBwESV3dkGIkeIddFqrSU1fZrtkPihTzDrSsCrQsOfcHyqJFSkM/vMu7v5jBnKSC3eaWd/cf5dtsEiitCd4zzSNlUVPVBbvda87nI5vNBu8ki12QskWoia68YZrPhGSpqy3n4S1F2VIXO47HPdGXrNcblBp5eDxmA6hdcD5QlIrFFrT1DUo2XLcblCw49/cIdUAKzePTW66uc7pLiqwfd26kbVfMY0AoifcuJ8+MRmDQumG1arHWA5Hbq9eEONGfe1RYsb264fHxzcWDk2P1bX2NFBXLPKKUZN02RCLTckLISFV2GLWlUAmRPKSSxeWSatduSUIiVeJ0fmC3u6KqW3zwNHULGKpiTddseTr+gPuHj0BEbm/e53S+R0qFLgN+kjT1NsNz08zj4WOqqiMJTz+ccfaH7HNJYsZbRVvdgkgcTl+w7l7w4vmHOPd9xumJ88lSlS1FoRkOWdEa44T3R97dfYFzM3VdMy+OYThjbWC3veHh6Q3j8oALA3EY8aElOk+IWYuqVUMMAWPA2jPGtIQQaNqSceoJ0VJVJd5lCGFC0LQdY2+ROv/hqesqz0sFGFNytX3O0/7A1dUVp7Njt34fKRTGJMRUUJdbZjuy3bRUVUMKOQEXk6cQNefTQNPITIKu2kuEUiKE5nweKYqKrmsYpxNFqTKMkoj3gXE6Z++2XbDOIl1B1+4Yp5GuW+P8gg8Tsx3h9ICWHVJIiqLCLp51u8MvBTbnh4n5KU9M+S8Elz1VHj1JqRBeIMsC0wn0Ag+Hns/+8sjP/6Wf5ye/+XXeDE/cvrolypnVf+MnSOsNThYkF/j2v/DP883f9z+ief0eUily60kQUt7zfHkAfPVZ+VJb+dccBP/VH658eDRNgdISKTOC5sudzJfBgb/2a3564k/8A/8Aw90df+s/98/xW//B/zFCQdUq5sVTaomMkn7uifqIUif2hzMxeHarG5yJPDx9jC40Ukm0bhGC7HhJBiHIOPoUKcoGU2gqs4XgqYoN/flMkiNGGyB7ZgSa7e4aqSTnU8/+dM95+tPsulfoYmHxgeglbbuj75/wYWacBtJjzN971SJERUwLRSEZ54DWcP/wKUIGJIb1ak30gmc3HyB5yzDd0Q975vkdWinW3TNEKonhEV0YUnQUZeJ4OlCaLUIIVJmQUvHu/nPK0qBkg9IpTwkWR0oW50ZWm2ve3eX9g48zgoqrzdfQsmFa9lmPoALO9dTlFYtLbDfPUCqP57zzhBQoTIWpVtxcv+buoWPxJ5TM5AXvFvrhRL6JNZfx0kJdVxRlbqRLCd5aYlp4eLxHyYbCZMdJTIFIQIqSqizRuiTGgHUjkx3QGqLseXg649xC23Y0qkAKQVkVOO+5uXrJ0C9I4yhKyTIFdrtrPvr0M9oWrq52jGPP4Tjw/NkLhvHEsozEFFm1NxxPZ4pS4l3g/8Xan8f6uuV5edizpnf+jXs64723xh4Keioa0jRgOYgogUiWAyJg2SHKgJQERTIy/wCxY2FLjpEVK7JijGLFMhFgSMuWADcQEDRGEHfowd1dQ9+uqjucYZ89/aZ3fte71sofa1c1k3FbqiOVqnSq7r119v7td73r+/18nsdIg/cTfp5JswwbPFKknOoHBJrLsw+omwNt01CVC/L8grppcN6SpRlv330MeIQoORwPWDsglSTLSpJEMtuZL3zuB3j15puPY/6WfX1iuVixqLbcP9xwfv6E2XokJdtVzv74CpNEDJAW0NQ1SguULmi7KKubnUMpzzA1mCQgSHBhYpj3tMdblDBM08TTq8/+ms6MX/PhsiiecHf/FpEpul0kH4cgaNoDaVJgpwFtQErH6XRD3dxGv4au6LqGNCnxXuC94uL8jIfdPdokHE93NE1MlZTVU97dvIGkRKsEIWEWjrKo2O12DP2Ap0dKTQiWpj1QFmdcnH+G3eEapRXD1HN5/gFKlFSLnuALjvUOhGUOEyJELavzsVNgTzEKWrc7VJlzc3cXsSphftz5NNzc7Hh69XnK/DLCN3188LRtjTEp34YlzvOIUpokTdBKMo4tIjiSNI++CZ0wux7nJvphjwsDbvZkyRrnC9I0x/sJJSWjdSjtcP5AYnJmO5NlC8YhMM8SozNmFXBzfPg652Mr+pEELKVCSoFJVHSfBMGMRyWSrEj46s/f85Vfuud//M99mSIM5E8SRLvn8vu+hK2WaBWp13d/9a+y+8ov8T/4t/4vIBQuCIILWO8RPpBIQZJonAcp/+nrlm/vYkIsw3xnbPadQ0h4pAzRHvmdQ+VXs/TfvrX844fW3/13/h2+8ZM/yZMf/EG+7/f87kgd8CBUYPAD4xB3UL/yjZ9hDq/Jc0XfWoScsW7Eh9i3mefAannGZGdWyy1JUuF8/GHXOn/888XE0DBYrB85tQ8EYbFzQKuUEBzW9ihZIDARjunjDScvM/q+YbN6xjj37A5vyPKE3eEtRRHHvsvlgut3rxHCYirN7vCONKkeTZgtARl7CqcTh8Mdaab56OOaqlo8PsgFQcSR6XpxydD3zLOIi+3+FusiUmV1Hvlbx+Mdy+UF2/UznB+oyjP2x3fMdmR1sWKyNdPUA/GFyroWIQRpktP1R8bhBju3hBBQ2jPPI6lZ4b3DMxCFeobwmOg8W79P23bsdm/wTiBIQFjGyaGSDusmsiwjTdMIzJwdq+U51lqqYhuVCjplsjEiO00tWi1QUpLqFeNQsygv0Cqlnw4UxYpu2CGCxtk4Ou7GI0ol9GNDcJqzzTOMShnHEaETkC3v7j/i2LyhzC/p58gMiwT3NKKtEsX9w5sIy1X6UUg3kySaeR5I0pLgYRxPVNucw+GO1eKKJEk51AlaK5yYkUozzy11e6RpNQjwXtD1R3yYWC2e8uTyBfe7T7DzQJ5foGWJEIF2escvf/OOYajZbJ5hgyWvUnyYeHj4FCnDY1y6iLudMOPCiAoSQYWUnjxb4BhJU0Pb7klMQlksGO0JpVOcdyRGcjzdM4wPXG3fi70jb7HTd1lzfHv4JGajZ4c2Os4SE03fd2RJQVWuOZzuqaoU94iQL/Its1UgFcasCGT0w5G6OTDPI0PfkecLinxJ0xw51ju0MiidIsiZxofYEbn7BISg6VqU9mjTMwwji+IMKSV1e0fwHmUSjDZIobl7+Ih+vI9jLS9YrVaUyZosK7i1DW23R0jwoaYfGrTqmMaJqqi4vv6E5WrFerPgcOjJ85zj8ZYiX0XshlSM7UiWViwWS5r2QNPtoihNRa1pmupHKvOCbppwfsJhycs1CsPh9JbFYs3o4+it7R84NZZE54gQcSHHuiHNA+PYoVTKOE4U1SZGLLF4WYDWOB9VtMjHh7eI+wilJEbGSC/SI4WBaeYXfuWBr3/ryO/5F3+MynQs8iukGzjbfoCTYLKM0Vo08Ev/wb/PxZd/lPUP/BDdEEkJWseHcqY1KtGPD/2Af8Rdfmfn8o+U9sM/+Vs8SolDtPYJ+e3/8h8uaf3Tm/8f/uW/zM/+x/8xT37wB/m9P/ETlJfnBA9eBPrJ0k8zw7Rjt/uIMXzKML6jnwOLcknfj7x7eE1ZnCOCAS+5u3uNlLA7fIoxOYky2LFhu73Czp5TfaIb7rFzbMOPtmV2E5nZsFpecnv/CYNtGYYDy+UagkFpzzCfkKNFqoKb+9f04w6lBf2oSbOELMuj0rq5x7qBIl/S255De2ItE7ROabsTUqTUDYDg7OycpmnIi4y2fwA8RXbG1fnnaPsdD7tP4vLdDZFVNTmcl2y3V5y6T2LIw0SG3np9zt3da9puT5GXKJXhaZHSkyUVeVbS9TFU04+RTI6PZlIhBMaoiIiRBucD/XDC+Y4sCcwu8rKW1VMQIY5eVEApQQgzZbFmd7ima/akyZqqWGBt9NssF2f0ffS2p+mj+GoeAMOivGAeA9PcI3Ukg3iVIETkB45TzmQbnPMYU5Cqin66Jc9z5hmKfBUP7uAZppZh7On6E8N0oKyWpHpNkuQM4yESD7I8/uxladxxWocy0PQnBB4NketlOxIjSEzK06vPMU49WkvSTDMMI5dnn6Fu33L97kM2y2ekSYnWsZg6jA25SVgstgzDjE71Ix7Ls1yeI0Ucx81uYJp78qwiU4a2v8aFgXHIWC3XTHYEEei6njQpH5f+jiw1SJFg9ILdcY+XI0lasG9umMeB7eo5F2cvuL1/i04q2u6I9wqtZ9b5FoHAmIDSOUJ+l8diUmouNp+jqRvmcCD4EbzEGEXfHbjfv6VcrFlUVxwPRzKlMXrJPB8YB4/WjnmOVjhrZ6x1rFcVAokLEba2WT6FILDWURaCYz0yjj3L5TZm5/OKJDU415OmGQGPD5ZUL1AiY549YdZM1tJ29SPlXRGCYBoSMhMf0NvVS4apJeAZxgGZbrg8/zx9f6Jpb4GZaZyxNlBVZ+RZxWG/Y5xOJElO28Q3Cykd+8M1XrTxzVtlXGw/y437GBjJ8xUIwTDuGMYRrUuyUjDaBiUXBBe9DOvlE6Qw7A5vmeY+olSCpsye0HUngmtZLJLY/fCCxGTMzuBE7O8IKeJYIDy+9ROTdEpGMGUsi4LtG/72Nxr+3q/s+F3/kx/n+YUgU4Y0zTAyj8VFYHYerQ0f/8Rf4PD1r/Ib/oM/TTNZhJ0xRiNISEx8axNS4kOIVOIYHfvV4+AfOhPCt3/zEcX/nVHZt28j8tunyz/+65/cs9x97Wv8F3/gDzA1DT/6h/4Q6898NmL2paUZLcd2YHd4w+ubv4+UO4qsYL8/IKWnSBcEP6ONom7vCd6hpGa1OmMaXCyrSsfoMrxzHI89RV7hfU/wgipbsVycEbDc3d9QlSV9bxGUCNljXc00lRiVI4XDBUvfWZ5crTBGILVFkFEWS5r2yDjMpGkegxomxQfL2J/iniFboFXK7vCKeR5YlJqqXFM3B8apZbJdDKd4R9M9UDcPTHYgSww+eKRQUe88T+ArMrNmtpFVJ0R0wU/jTFWtsTbucZJE0tZHNutNHOdQoHVA6AlPAT5judjQtjVKV/jgmGePVpJhbGI4IqSMU0vbtjGKL97wsPuEaVQomXJxeYGbAnWzB2aWi2d4G/mEff+Ancd40zeGw2FHnpekiSMxgqbu0CrlfPOctzffYmZEPmo9xmlgGOfY8ykrNsvPcjjeUK4Uba+wbk/fN4gwM9uJaXIkpmAOkTN3efEegkCWFjSnAUjYrK6YQ88wthACZ9sXuNlxbO5YLdd0bc/l2XOmvWUcJ6QYyVYlhIQiJ04o/ERVLui6Y0xvjfG5lmcpZb4BJMvqkq4+UiaX5KngzcNXud99xLOLH2KY9tj5BsUapaP33o6Ks82zx3LvSNM0nOqas/Vz+m7iyeVT+qFhnOpHMKegyHOc9wxjzxRqRF+j5IwScRJzqncRP9R0KBM5fLMdSZMlEB1DwTnG0f+azoxf8+GiWJInl7g0p59GBJAlS5RK479Oe5J0TfBxOV2VKbMLTHagKJco7fF4/BTwQVBVS+rmQJJkpMkKZ094N5ElOUIm7Pd7tFxydvUBSZowz+/IsviWrNSSYehws0dqOB53lOWGzXZLWzuGfiBNMsrFkrbpKYuCqrhAyQQ7WSQZ3o2s1+csipTZKna7T5nskdVqSW42rNbntN2RLMtpm9NjgU5CCDx/+gF9F6jKMw6HA+iJIt+ipCaEaKmU0lBkW5x3PLnYUrf3UQ7m4rjl5dPvedwXjVg70PU7vIvE4vX6nK5tMSpFhoS8KCAYQGFUSpYu6HoZ9wLoyDByLs7SlUI+clmE8LjgcEEyjhM/9Xrip95OfOnXfz/VJmVmRuokYvcfH+Tf3tM0+wNf/9P/Iesf/jLrL/8oiCgmSpIEKSRSxH3TNAtmAomWmEcF5eNk67GIHw+S8I/cYMR3bjuPgTGi8+WfPEj+8V/j6cTf+RN/Att1/PN/4k/wg3/gDzz+fQLt5Lg/9Ly7+zpS3pCYhnmeH2+uFUr5mPxSilyvWRQFJnEcjrvY9s4rhAwUWc40CnofuLp8n5ub1xxPt7gZ3h5a8uwW50eSVMbDVrYoJRlOjudPfj1+1tg58piMOif4mf3+EG2b40yazuyPt0ipKPM1UiQMw6ONEofRFVIO9ENLmSX4YFkuzwhOYq19vDFohIiQwsm2jGPParmFcIZQM+PYoylIdE6qHUJl2HmiHwaMVqwWT5im+dF4aKLmWcrHntWCyY4M04Q08rFkqUn1guAFdbOn62uqqsRaS103LJcl82wRTmPdjPUn8jJFWcGpviEzKy4unpKYeMvxbkbrijLbMAwjrauxbc3sBvKsRISUqlzTNPUjOHJgVx9Jc8Ns4+hYiYyr8y+CT+nsjrq9I89NTGr6nuubr6FVzvEY6Ps9ykSyepYVsUCZx59V4T2rRQ4hcHP/KUYVaC3J8wrnoR9rpnlAy/i4LMoFdbtHCYmSjt3xnruHd2zPVuwfDiRJTH+en71gvXxO0z7QtvFZIkTgxfMvxufENCOV4HQ6sFpuorjMe07dibq+J0kj42x2njw/Q4Sc9arieHzAh4m2PQCeLF2TZ8vHg2REqhk7e2bX4rylLNeMwwQIZjdSFBW5zCFEH0xRlXRdixCaeZ7QKsHaAWMUi8Uao0oW+SXjOJBkknlyv6Yz47+H5tiyrz/Bu5Fj/Y7V8hmjm5jHNr5Ry4SuPTFPFu89/eQZhp7l4oKiyDnWe4axfhxbKbTWzPMcM9fNCW0EXd+QmpTTvqeoKsTjm9e7d29IMsGpfiBNU7ABKTRam3idLAqsHbi/f8tqeYGSS4ScOR3vSZKcqrridNpBGKLXwRiSrKAfRvqhxXnHHI4INTIMilyfEXx86k3jRJ4vWFQZiKi4vbl7BUEj5YTRgjy/oMhXnJoTs+vJ0pQsj6MThGLuJtpmjAsyF1hVF/GLryLD6lTfsd1ckOiK4+kQZ8AioJViffkCSGi7mEzpx4kwtCgVZ+1CSET41R3FP5Iae5R+Nf3Az93N/L2jwV6+4ChmPtwPDGXKk+BYpoIgBEHaOFmTkvHulv7Na778J/+vLM7OUFIhVRzBBeFx1saQgJAoqYgVv+h0ifwmvnMrmYPHC5AI1D/10/Xfdmv5R3+FEPir/+q/yi/9uT/Hb/3jf5wf/yN/JN6UQmCwluv7Oz5594s4+zGpHlkUJX3vEKJjWa3QWpGojP3hHd4r8koyWRvNpbIiMRnT2JPIFTM9EHh3+02E9KyqK/p2QG7iy9MwQZZH7lRqDFplXF4scC46Qdq2I0EyDbG5HYKL/SeTxY7SONG2NVql5GnOcrnlWN8y2Zkyf06SCk6nu0jsLi1aaybn8T7g/YwQkrIoeXi4j/N0oeIYSOUoPTJMPVLB2eYzPByuOdavYnu9yOiHPVXxGW7bW/IiBktCmBhGS54smSbH/nRPXiTs6hoZNKtyy9jHwI4PMRF5PN4jpWa5WCBJ0IYIrJxO8Og8apuG50++yLp8ST82POw+IjEFyiSMkwViIKbIK7q+42yzZZom7Chp64EiW2KnkSzLWC0v6cfjI/X4BiElt/cfsVmf4R+7Q8oY6nZP199TlUuKR/vlk8vPM44tp/YtdvY03SlabaWnyi64uXvFODWcb9+j6444anaHE2W5QGsBZKRJSt08oI1GK0OeJKwWG+q+QepAYiTLZYmQFqEt1h2Z5xljEpQygEM98t/sNGJMibUjw3SPaEZGX/P69gGpDGWeIMQqOmm8QgTHML7lcNiQ5RXN7jVt98CqekamFxzqa2bXM9kHhJCoObLeElPR9yMujLRdhHBKEUecZZFTmC06CZEUcdqzKFcR4Ksk49TgQodXAjftqaoSYxKmqf41nRm/9rGYSJldgw9jjKyZwP3DHefnF+R5LGwJOaOkIM8XzPPE+fY9sqzi409/kcmfSFSKEHHZnJiM2QoW1Ya37z6mrNaP/vGY0jicbuiGljwvmHzL0EzxjcTFotrQz1yev6QsVgRmrB6ZRotUgr47EHCP3uuRh4c3+NCBsBAEoxUIFd3cw3jC08Xf7xWzGhHlAT8MNM2e1fIJqVkz2vaxp9NGS+DccXN/z2Z7gZEpZb6laQdmN8ZbmgsIYlnNaM1quWAaLQGBnRROdQzTkbOzpyj1jKZp6djFW5qNLKjVck1qlrTDRJ5XGJOR5gmn08Q0xwe4Eh5QeALCx2Lmt3ces/U0duZN4/jUZfRSsjs2TDjaSjGOAVsJLgvYmIARM7lO8Dg++k//H6y+7/s5/00/RvwnBPw8EwSMPjDPLkaFhSIxKd9Z0+sIAJOPB5wHGgsTnlwpChXhmDweiOLbUTH+2amyEAKf/NRP8eFf+ktcfOn7+aH/xb8CCLwH62deXb/j1e3Pcay/ymYZDZDH+galPVJKUlOAkMx2IMuWbFZPud9/CmiK7IymOdI1Hd7H719RpMxBgBjI8ooiq9huEqa5Y5wGquV77Ha3seBI9H/cP7yh6W/YLJ+yXm1pm4lFERM3QijyrERpjRCCrm+5ungKQYEP9H2NDx0hzFycXzB0M5IDiV7Q+hMiaDarFbMfSDNF2+25vXsTuwvWIXWCtYGyFNzt3mBMhvOK2/0v8/b2V1gsKoxZRnKDtVzffIMsrbDjHMfDQ49SgSTJ8T5EnNPsWK23tPUpjnRmyXKxiW/XdU9VngGBaXBcXTzjzbuv4UIfS5zFgjxdsCoEMhimacA/isy01kipMEpiXU3T7h5J42fYcQACVxcvmJ3l3c3HeOfYri+x1rMoopnTuhk7j/GvsQ4ZNE8u3+PYPqCNYJOe4+f4uYyGzhc0p5ZTfaIsLgle8rB7R5rmbNcXLMoFPuSkZkHtD5hkQbaUEGz8jKuMsffYOY7+AmNMIbaxzLtcbjnVMTadJjkmTFEclqQkZkGRbTnV9yAk7RBDOotqSz8caJqWzfoKY8pYZwCK7AnjCJfrz9K2PTNvcGHApFFt7p1gtbhgVW5QakaJGW0SHAIfImgzz3KGMTb1tVEIIbjfvSY1CUppQijwYcLbSFtOdMEwtgjpouYDcM7i5oa0LOj6GWMzxrH97h4uJtF0wxGtIiFZKsGzp88QUtK2NVlaIhUoGa/YTXNksj1ZWqA0ZKFgUa3ph4auP1GWBUoq0jTn2dP3OJ2OWOvoteXQvaHt70HOKD+yWl8wdi7OylVUpRaZom6OJInBO4nUNjanhyPH0x3GlOT5Bj1Lxin+f9FaISURe+AT/BiXlibZcDhec3Z2Sdfvmf0ENiDUhPM11iV0Q4xdpnmKm2NJKi0yuq5HKctoZ4qyoO8t3XgiNbGz0DYnNpsz7u9v415pc0XbNhitUDJjngJ5VnE8xZKZUsvYc1CK/eEeKXqW6wsEMo5OpEeqlLafEUqTGhmb649RZB7HG85HHI91AkxOgUfUHcN+ZAgz45BRH+C+UHyQwzPRc2kkfQr+dMsnf+HP89n/+e9DG0GYB6xU2HnGB0HbD5H/FUT8/qoE70PEi4fHAyMIrIfWea57ySDhXAtMFvXKsYMTWWH/Xa1+gDc//dP8xO///SRVxe/9f/8E689+joBjnC0fvX7Dze4rtP2HrJee2fYkWRa1DLrA6ByY4t6E+OB82N0DAmV05IK5kTStkMry9u5jwGPtyNnmBV03MI4PFMXycfG9YRpCfNFSnn58IMtSlAajMsap5njaoZShKDY09ZEsiy8gy8WKu/0btEzQcoEdR5arRVQszDNCBu53nyBJQA7c7r+GUCNl+gIhA81pz+xrpJTk2QIjUxZVVFAgJP3QIoRCyRwhYhHx22mrcRioqop5zh4RQY4siw9DSWRWjcNIPzZs1itCUDDHonCSCoSH+/0tbnZURRl/DuyASUsOx5iyvNi8jxAp1nUoqSmXS5r2hDb5Y2Ag4vgvz19yOOxJ8pccjjc07cOjeE1i9IphGHjY36J0TGI2bUtiktgzkZphGlA6oelOJGbk6uIlD7sD3tnY/RKSzXrFzd2nmMTw5vqXydKK9Sq+DHvH48vDyN39x5TlkqbpefXma2R5dMrYecIkKXYc2CwvMXLJw/Eb2Hni3f0rTOpYLS4p8zWH/YmyWDOOPdBytn1JlqzivgvB8KiYtq5lGloW6y1JmjJOmvVqixCCYTiRpiV93+ODIMskb29/kfPzDYfdDdoY6lNHUWq22w3LakPXDNSngdlPmDRBkJDqlKRIadoT3jvyomKaJEoJskyhZEDJmLjLswWH4zH2rCZJlhWM9kCeLuh6wXqxZLaRdpLnC9zsMEn63T1cxrmLOk8lUVLStS1z4jjVO5zzvPfyC8yWmC+fJrbbTSydeUdVrvEOtMqZ5yNSBk6nPevVJU17oj4dKYoyyoGCIxATXllSMnYzPvP0Y8M0W/I8ZfYzeENmzrnYvuTh+AnH0w1SCo6nPdM8c3/4Jtv1M55ffRHvN9zefxOE5XTqefbsZfwm5YYsWzBbH0uNwnI83aJNPPDevbsHsefY7DnbnnFqujhukBopJaOdqcqSaRwospKhrx8BfgVKRB200J798Y6iKphGS90cMYnEBcd68QQ7Wpyr405DJTGNpSR2dhitSUx8YDjrSdOSJDX0oyfImXGK1OgsEXxHGSii2GiaZ7Q2LLKUpnFQ16Rdz3JWdNbzUNfU08Cdt7waar6gZj5TOF5kjvu//ucQIfDyt/w25lefIBcVbQiEJGVynoAieIkx6XfAkoHorIco8pqDoHaBu07wjSbQJYJWBwolSBMR90LCA98OAPy3ny7zMPAz/9F/RHNzw2/9o3+U7Re/SABGO/Ppu29yd/wQldxQBodWGuECeE2WpBT5GUomNO0ts3N472LnKMQoebUUWHdECM9oa0bbo4xkHEe2Z5cRuXK8ZbQtcoyxa6kcs+ti50nHVvup/QSjFggpaPpbpDSUZUrTjXHH4BWJ1ljb0fcHlssNq+U5h8M1TXtPIOqyu/GEdQ1FeoayGVkq6XpB0zYM4z1Ne4uQM2lSUeRrqmJLkqS4MPLwcBdLmKKg60aU0Lx88T7D0FK3d48z9kCWnJElS9qu5nSqWS0zvFMok+Fmh04EXV+TJRuMzuLf31nWq0v6fqBxB7SWeAtapWiTMNkGk0iESKP9NURc+3Ss6YeBPB2oqpjOKsslt3evafp7luGccWrIivKRejySJgvmEHsjSmZURRITmmPDMHZILchVgZQR29SNB37pwxtSvWC7uUQEh9EK7w1KJSiZUFXnFPmCfFwixMz17cfkecZ6taZtG/qH5hGX07POF9w+vMakKcvkHCkruqEGPxJCgjYFl09e0LY7EJqmPzLYexa6RNuCZ1ef5Xi6Y5wseR75cuPUsVx4rO3QeqZu3jLaiWkY8Vj2hzc4P+Oo0CbD2pnJGc7ONrx59y2qakFAkldruv6BJNG8vX7F+fY5Smxo+4DUnrZpyZI0RqOdY7XaME2ONClQJiBlRPjM80yRa7p2hw0HNtVn0HIZU63tiHWe1epprDj4kabdoVSUn01z/909XGzf8uL5e/R9x2h7pPYkqebF6iV1XUd0QXtiGAauLp8xDC2pLgCJs57l4ox5htSseXK1ZLfb41xMHWijyfM8fqBNAs5ysXrGxcVT9vs9zrU4P7JYrMmyFW3TsF2v0OT4eUYrzaLakKYZ/djgGVGq4NnTz/Hu7adsNxdsVk8YphOLqxdU+Zrm9BGn5h2JPmKSlKzIqYolEk21WFA3R0ARvGKaWuq64eryPZyz1E0NBEwS57B9VzNNHUZXDENHmX7Ak/Mv8Qtf/2ugp1iuRMXYpjZ03YmiKNkf7tBKoZVhu35JCI5xqqOfPMDN7TsuzkuCn/HMtN2E9QPd4OlGifNnKJ0g8HFpTmD2DmttnPMazTT2SDvzYiEJouTNbuRtDW/ue3wzcH9omZ3Ddnsa25C/uuX2q3+H7ff+MMevvUbVA2GZkFxsCFVFmudMQuOMQaiZ2ffYGbzP8QFmr1BC03nB3Sj5eu346jHgcyANPE09SyVJxONu5r/jyjIPA3/tD/9hfuHP/Bl+87/2r/Fb/tgfIxDop4G3N2/phreY5JoQZs7WLxnHAZFGNeb+cEeSZtTNPVkmaIcI3FuvV9zf31OU+XcKsAKBC3XE0g+WNE3RKmEaavKkxKg4ahOk2HkizVKykCJk9JUDjFONlAl5XiKlZxwdhoRFuWCeQ1TSji2TbXGh4u3NJ0zznnGybM8u6doRgsfNI114x9t3b3j/xfciEEilWK0qkA3T5FCywOiEYajjA8HHgm6RJxwPTbQO5oam6SKHa3DRNz8JrjafQ0jF7nDLYmnwoaEoMkDTuTpGup3DTg11c4f1Nc45mvpEVuQkmWGaGlACZQzOD5RlxjQJ+vHbsExDqhdk6QJr3+JCTPBJqZiswJiCi+o93DzHsIy3MZziZ/anVwgxx1BMviVLM/a7h0hNf4ztrjdnNM0Jz4wQgc1qEcMRQHV2hvcRyrhaXdE0Ddok7A53bNaX3Ny9Ji8KLi+e0tY1WpmYqgyw2VR471hWS0ySMk8TkgkfJEYrJt/gHEifRV1yCGSpwIgM5yaqRcmbt685224pi038DJqcpjsxzjVDP9ANR5armTDmKKki7SQvWC6WvLp+zWq9wU+SLE041p6zswvGsQMRkFJwOB4oCkuR5dSnAxfbl8yhZKbHTo7E2EhhUIK6jpDdebZ0bTSrlostdrSM00SeGUq9jS/l0zs2qxcU2TnT3LDf70hTw83dK7bbC5z3UQn/a8A7/fc6XM43a4auZrIzLtioQT0eMfoKN3vu7q5pu5ary2eM4xhxGGkSDyZr6dqOanHOUl3irCPPVvgwEYKjKku64YSdJ3RISfOC1JT0Q4cylkSVaFOQ5inH046qWJCaFdPY0dubyBN7PJG1SkmTBS+enzOOXVywiYEwS84WH9D1HbuHe7RcAUVMRJRLDvUB7wVPLt9HJCHOS7M0Isn7BikMbtZoY8gzzzxPZCah7zpWi3X0qp8tqeYFN7eveH17YrnWKHOJmz2zdVRVRduecJ44F/UD0xSRD0aVgGccG6ZxIgRI05T73R2r6ow0NRyPJ07dPXmxRKuEbjhiZ40WJUViEELEfY2QKCGw0wR4qkzzPo5lJlilhqwI6CxndwdTmdEdGxZI/uW/UfFDt1fsxR/jby5O3H5zh6t7isscxhZ1toWqRFYlVhkwGVISZVxOY+eYKFbSUI+eT2vPzx4n3g4JF0qjE/CziDRn6chSHcdi/4zP6vXP/Rw//5/8JyyePeM3/qE/hEpTTm3Lx2+/juMGk3T41iKNijH3eSbLDMf6xDSNtH1UD3sgTRPStMQ5EX3hvsO5wDDEZnI3HqiKLUYLhHS07QOZKajKC9pWoLME60fK8hyTJHTdHqU1myriju4ePqEsFZKSbryPS/dF/OdV5QqpFPvjQFVt6YeRsijjG2oYOdT3CA9udmSLktkJtptLrBVM80iS5dTNkbo+8rnP/BBjH2/zUsw0reXi/An7/Q6BYVGtqdsbVsuSrmsYxpbVesWpvqNtBp5uNafTHpMKXBiBHqMNq+o59ZsaIVKMgbvba6pqQ5VdIUURv9dMdP0OYTRe9DSnA3IuqMpz0qRidpaiKBAUKBEp31lWkpiEw+GBoio5HVvKQpBlS079Ea0ThuFEUqQo7aNv3qdkaY5zluNhZLs941ifokDOTewP8etrjMI7ola6i52fphd0w4mqiCgVpQL9uCPInsEmSOXxXnI6HRmHmsQoZg9SRpCqtZYQBKtFxdAPSG2omzuSJGEcO0Qu0SJnvXlC2x7op0e9c7ZGipyz84TT6eYRkRQgxJFsoi+pLs653yVoWaF1RlOfuLp8GW/XzQltUpybcLNgErCoLlhWZ3z08DXa4QG7CCRpoO+PGO3AOfrxhDaKoQ+sVhuUscy2IzEpQhrmeSYxGVmWMkw9ziuQkKQKO8cO3tX59/LwsKNpasoyNvmzXNL29xTlI7NMxLGb/E5i6Lt0uAzWgRhJkpJgYRqax7exDiEERbkgSaqYdJId/dCiRUK5qLDW88F738/+eCTQ87B7xWq1JNWG2SaAx7mOxaKIJUqVxLHT2CIkHA4nksRwPNxxvnnK5fbzfPL2WyBPFMWaoqwYhiPTZMF5VJhJVfr4BY6cr35sQEmkUTB7vLO89/KLfOtbX0MExTT0uKpD6gTBTGbWnG2fsNtdU2QrVoungGHoj8xuRhtN2x05X71kUVwQhOTdu1foxEeHjLExWWUNWhXY0HI43LFcLvE+Os4XVck4jmR5jnU149hTFgu887H8lOdobRFAfWqY54ngJmTwlFpyMx44NIrBOp5uVygmkILMxJmokhCCJpOgjUCOAYVmlUieVzP325TdaaAZU37j3zzx267j93rJ53j/buKvfdBQHBrekwbTdmwOkmzVkZ63uDzBrDbIRMWD12kGC0orhJ95dxz5hb3kq3tHoh1PVpIXecAIQTdMFFXE/Yt/Bqr/zU//ND/x+34f5eUlv+c/+/NUz59yaA989PpX6MePSPKa065mmGpSobh/8wZQZFPUQmgz0/cdQpa4yTGO8QYshEapx1FVklMVzziebtmsMgSwWVXU9ZE8L+i6mt3pmtXiCc7GjkLfdYzDRJ5ckiYFVXnGw+4N52fPmKYR5wJ5umUY98wutvQ98O72U4SEsihIE0XwkOglwzhR1z2fe+/X0bXt40PTkKVnkW8lA3X3Fq0VZZXG8Wq7oyyXpMkWISRt25FnacQp3d9gtKTt9pT5FqWhbU8x3p4q7k/fxIcukgOGPUWZYP2JZrjHGKiqc25uP2ZRnXOxfZ/bu29wtllRFluk2PJp9wsoHei7nkV+yaJ4xn5/h1I+FvVUQd95zq7OqZtDDLrIgSTViCBZVEsCM91ww2q5pK5hc/6U2U8kbqDINkzTgJ1bHnZv2ayvmOeKNDXsDneEoCjSJVobXGg4dLcEMUdrpQ+kyZY8jVDWVKXfiWunesVsPVWxwgeBMYKu3xEkpDoe9P1wYnaes80VdrY4Bsp0TZWv8QHa7h5rLTpfcjrdIaRHiZigssYy+T31o5kzFm4jtqkqtzTNPblbkqgEaxt8aBjnlvudYBgmPvPe9+C9ZLEsaZqOzeqSaeq5vXnD2fopl/o9hLR89OoNi+KSrnOkWeDUnaiqJUYpgp+xdkDJBavqinY44VwcWYugWFdb9qd7yjzK6mYk7Tzw6euv4oMnTVKWi6ccTyNt25JnFcYknE47kiSnebhDyeS7e7holSJVin90QmuTg5yxzuIJtF1NYiIp1wdPYjRZntJ2R5yDun+HMorZjsBEXT+wXDxhu7mg6W+Z25FEafqhRsrAZn1FXdso1MpTfIi+hiQVHOu3IAa0UbTdkX4M2NFzefmCh4drvBe0XYNSmmmakRDRHLPgtB85O3uCdzV3d6+4OH+O1AJtJIfj4TFjr1lWFwy9jXPTrIho82SJUoGb+z1lkqFNip1nrJupm56mP6KsZbGIPYHJNgBxhKc39INkngNFsSDLCqbRk2UxTpwmGTe3b1FKIIVCadBOU5ZbnPcsFhua9sip3rFdb7CzJjV76v6AKVLytqfQjrIs4vcoOBAivo0JhcSRJ5ApwXkhebnQjEhGlzJ4yff8ggd+NWJ4cbbCfr7iaHu+ctyxGg37d5azXlB2NeXVkiSdEaVHhNhXmYmjhZtjx399GPi7bxX3reCHLj3fvxS8v0zATuhHKOW325b/OFkZ4jjsb/+b/yanN2/4Hf/uv8vTH/0RTk3HR69/mdP4FbTo6PoRbRKYPLOX6DTKmozO2O3fURQGk+TM1kPQnG8/Sz/sqZtb1utLMrkhuIR2umOxKJFSc6rv2e13zNZFL4qcyE3KqblHa4WdLUkiY2pumNE65fb+I+zckecrJCnKBJwfSEyFEJpp7mi6GpMYDoc982R4cvWEcZpYFIsYL0490zQ+YkDizbZYJLy7PWHSWPrM0xVDmEG4qPO1lnE4slpeUJUbhJh52N2ik4RSXGGMRMi4gzudjiwX56SZgaBphx5GT5E/wbmRttvTqzfUp4ayWFPmZwQ/4cIJnfXsjh8zDI6iiDiadmgwJmNZvMDNnu3qir6f8N7R9R1aF+wP94+0Y8/xdKTIoxa9H1oQY9zBuomiKJlsz/54zfasQosUyJEyUBYlWVqgVUnTHzBGR9yOmxlmjzEJebpCyvifg9Ocbz7D6fiWLI3CryTPoPNIqfHBRVOj9tRtx3pzzjjOFIstTd2Q4Kl0Enl2GIyMo722bZFSk2drlOqwtqXvW5arLYtqweHYcLl5n+bUIhKHdRMr85R+vCFNE7wrcc4SvKcsljhvH4kHCW3TkZgcSRqTqBNcbN9jmE7YeUaIBJNkNP0DWSZYFs/53Gd/kOvrt+RFyji2eG8xOmUcYb18j3EQFEXFqdmRpOnjnyfq1fPUYHRK37c417NeXeK9ZxhrQoB+GNgdrjnbnmN0xas3v4w2Ats+hlzOzr+7hwsCEl3SDy3LxYambVFywIeRsiwZhp798Z6rixfRQf3t2b8CPzfc7b+Gd4Y006SpIXhDalKc62jqA+PkkXqOng4rGTuH0iZ+4cLIPI+Uj+iOIjckqaLvh4h+F7HljFecbZ5wbK4JwQOaqlziZsdkPeMQyPMFwStSs2BZFby7e8vgWtbVBYIE72eUUkxzTVP3rFcbjDL0XUsIMUlTlBXT5Oi7nlHf0PT3BDEj5MxkR5rWkyQps3OkSUnbnrCzo6wygv/2tXtEy4h/6LoOQUOR54BAaUPTnHhy8Zyhd49YfY9z8QE8jj370wh+YL264tA2JN5Tni8I3jG5GR8iZ0zK+IBRIhZAkWCMJDM62ikJ9E7y1bd/nuc840p9wPy84Pi/POO3fEZhbcBO7zO2I8rP2LFjEoLgE6Y6ITWKwTtM0pOWEFzCP3g38F9d93z61vJMSH7081d8oRAsVOBUN9SHI6vzM0KVIRLzTyz053Hkb/8b/wbf+ut/nS//wT/Ib/jf/++YZnh784Z+uiFLZ7qmjdFiRgQGO8S45Tz3CDFSFAlG55HBJkL8gbYJRWYYxhNN3fHs8nsBx8PhHu1murojSRWK2A/qujo6XbxnskfaaWbqe/SYsN2cM/uBECq6/ggCLqtLBuVRynGsb8nTNUopDvUdcxhRviBNE1bLLUbnaJXRdEeuzl7ivON0OiBEoLcWYzTH44HVaoOdG5QoHx8GMYK7XDxhf3jLqd6xWV8wjS7aIVGUWVx2AyiVIITh8uxFXKTfv+XsbMPhZNE6xc3h8cYfXwqzZPHYWxNMc0136knNmqzKWVYrDqd3aAVaFYSgsHONDClCGLQW9EODG2P4xJPiJ+j6FoFAaej6O+YwELxgu71gv79HqxQXOuZwy9vb13hvOFu/T1ksH8VrkCRJDCMUOcE5lITN8pJpmmKdwMM0BrIMmu6Bfhw4375P19ePX7eRyY4kSUGSFBxOb2JQwQucD48vCnnkFs6QpAEjK7L8CYkWtOKI1Jam6XHekqY5mYg7ZR8UeXbFYXcLwrNv3pKla6TMUSqjaQe0Srg4f87p1OK9IODJM8M09VxeXJKaJeM4AjOLxRnT2HN3/5b1eo1UM4iJeR44nI4U5SW73R1lUVJ3e0IYmH2AIMlMBRhg4mH3hmE8Ya1hvbmg6xpgRniw04gPDqEVfRc1DJEur5mmlqIwtF1NVRiWyw3n2xe4OdD2OybbfXcPl36oydMFIOi6kYuzJ9zdv2LojzjbEgIx5uhmhjEuFIviEjeNCG8oqwu6rgVcfFPPDKfmBl9b0qxirS/wwmKD5Gr7gr6bmOYT2kSuU5alsaYnLfvjK7JiRZGvkTI2mK1tGOw9+8M1gYnErMjTimEYaLqGarEiz0rq4wE31+TJljK7QIg35EVJkqSkpqTtH+i6A8vlkrI4o28tVg+sVxv6rkMIGaN5CEySPNKYO4TwSCMizVWtGMaJNM1QStIPDyilOJ0a8mzF4bBju31CmuWAQsqRfqjROiZb3OzJsjX7U0vT1rhppKoWzC5CAE/NAec1i0xyHEa63jMZA97jphECeATee2Zif0Sox1SWEGipsI/0ZCVm2l/8kLd/9y/yZ5+v+M3/8r9N9rs/QCWSKyHwM4QgmCnwNn6ABRD8o7TLKEYPdgyMYuaXb2/5ydeWX7kJFG9u+dEvVPzI+pxtGvB+ZKp32N0BqgJRJfjgkOh/aD4NH/+tv8Xf+/f+Pc6+8AV+x5/8k6hEs3s4crf7Frq4Q6FZllsG23Jq90hpsLbF+UcAZpIRhCR4aJuICjrVdwghyFmTp2sSs2acah72r2JhVQdO3Q2JzUh0AUHSTxG4GpzH0WN9nF1X5Rl9G7Exw9hSVAl2cjRtjRSGpj7QNHu0lpGILSbqds/Fds3sZoTquNt/zKJaMI5HGjGiVILzHVIFTFKQJhpBRpoteHjwSCliByQoDqdrbO4YxpYnV+/hvefh8JrNZk3XTjw83DDZlmqxxlrLoqro2oG2PeEZsHOHSVQ8qMYjIUzkacI4SELwtN0OEI+kb8Vm+Vna/o798RopFUVWYf0eo1OGfsC52HswxuBFNPBN1iPsiFYZMGFdR9v1sWTpo6217WqsOzLagJslVXmBnV0MPuKo2/vHA2vP9V1NmuexDqBLjCw47B+Y/UA33UbvvKmomx2Lq3OU0Twcr/F2xItAllaUxQWn9pY0MZRlgdEpDw8Hsszg5riv9d6hjCI4TTc0nOzXmX3UI4xHjzHgmdF6hZIF8zyjcsOpPqCVwDNgUoNUFi9q8mxLUVS8uf6YbtAEFDMTMNA1DUmiGceOafQx9uxH6uZE2x3wfmS3e0OaJY9w2hlQbNaXHE8PON+SZoqujR4hpWCaW66vjxRVgvcDSgvs6JjGgbquWS6X5MWSutmjdIGdZ0a7Z7E4Q5AQgqVtD6TZAi9tLL6biKYq802kShSr7+7h4r3j7uET8nyFQHJ//4oiywghpxsakjSl6yY8M9bPlGqDtJpT2+ICbFSJlQH8yGKxoR9aQhhI0/IRShff5pVQmKziYfcJmQl4FHm2YLt+ihCG+nSiKM85HO8py4gPU0qwPxxBpjjnSFKDUoJp6nFek6aSV2++wpMnn3lkfdVYO9H2R6xrSFyBdzNSwTi10YEwKc43T+lUx7H5lE/ffJM01eTZkiJLud/fxJuBgMSAJOqU++6ID5aq2rI/vkXricAMOFSqeDjeUGQFwQnsIFEIdBAgU47tiX6I4YFYNk0osgU+yemGHYlJWS23SKEYho5uGlkvZrrGkSsf+zlz9N0IEXsn4ZH1JS0gBEoKZuHxxC6Ankc+/D//68y7Hes/8UfY/fYPWKsJawNSRFyKkopESGSaAPEmFBCxeU9ABsXsNDbMvG4mXu8tfPU13zsf+A0//r1cljOEHjc6hrs95vYWfV4yhzxqakW8t4gQ2H34IX/tD/9hivNzfuef+lOoIseHwO54zxxqZOi53+/I8wyhkojIsBajFUJHeOlq8ZxhaGm7ju32iro/cDjdI6SltTdk5oxFWXFz/4BUGfv6gclbFvkVHo+dLQJJ8IJpPERAoozqauFnvAsQFNv1U+73HyGDfXyIdnTdiJAaL0CnFYQE3ExhKry1pFnGqbmJgYGhJoiMIDzt8MCh+Rg7j5yvv4cqX/BwuMU3M24ekF6xWT1hHFtud3uKcsaYkrbraPueLC9JTEETenaHt+SPD2KpOm4erglBoERBUeS8uf4aaVKw3Z5TtzcM455t8oKyKPABykpxOh1RZubU7NifPkJgEHIGAkWW0PaB4AZeXH0P9w/XeFoG27KoniLQsck9DvTjCetOGFOgVYFRM5Bx7I9c33+KUo5ULh4Rpho3g3UdQ39iu7xEyhStA017YGMMxghG29O7CSUjX7BvB3RlQAcW5Zpx6umHEwKJYGR2HQu9Yeh7mmbPNDckmWd/eEsgQZtnjz+3E+M4oZXG6PSxD5w8HgIx3OOlYxwt2yTn7vYWgmXoD4Qg8bPGpLE/17gTkxGMxjG7ETsPhJDEHiCSNMuRamKeJZvFlvPNSx5Od7Tdkba5piqXHJsDSs8YseDTt28pskvS/Izbw477+494evaMJ2efA3eH944yz7jfv0YYgfOC2c/Ms2WeYHp4Q5YsSM2autkzjgOb/AVCdjTNgdOxZbO+xIeB2U4YI+n6kaqKwSohI117muD87Ol393CZpg6TGMYxjoqmyaOzDN8nlNUFUmSsqw1CwtRNLJdbUr3G+wOH+jVd947L7Qcslxfc798wu8CTy88xTy2Heh+vdPmSw/Ge3eGb6GzGqAXu0VpprcNOljwv0NpQlVuMyRiHR1BdUTKNM1m6jsiIuaOfGrKsouvaCKCbHdpItKyw40AI8e0vlrIOrJZnVOU6YiG84O3tL8aiWW7wdHSTY/YeIRKETJAIlosNEk+Rldzcf8wwWPLMcjxcc7a5ou1OuNDiwoSbZkySs1peIVxBXmS8vfkIlQwRnri8IjU5dXvE+4l5tmw3CfvDLU2342xzSZoZ3t18RGIMRisSMXO5STCyxc8KKwWzjweH9+CFxM0B78OjFyXEIqZ0HNNPmP7vf53+k1cUv/N3ob7wPUx9x/SIxg9aR9qy9wQhcWKKe5wQsTwqSIxM8WbCJDP1Dr7y9oHDLz/wwUdf4cs/suGDFylKO3CK8XREDQcyOYL2OBmQBHzwiHnm+Jd/kr/4r/9x7r/2Nf5nf/bP8v5v+62P0GRBVa0JuwW70yek6YidPYk2zC7+EE32RK4L+s4xJAN13eCxXN9+k2GwPH/xPje3r2LJTgamcebJ+VNevf6EgOHYNMgqjThx6UjTaBrVasnhVLNaLzkcDqQq5WybR4f7PKFUGhlRicDOE7vdju/73h/l1ETr6vtXP8Bud08j/htc2BPsEq0Lun7P0J2oSsM8DxhdkKgr3PzAqdlTFZccmgec70jTjFxG1fA4DUgpoxp3NiwX52itUSIy9prumiRJSJKUujmSF4auj1rgzfqSUzMxTDV5njGODUanCLFkmGqSZMR7x/3OYRKHkI4iO4tpNeMQCGbnqHvPZvMBt3dveX33SUTC2DVnm4q6ucMYInZHOmY3oE2GFFHTLZQmy1YcGkuqFRfbD7BTT9Me6fsB7z1GlRSLS4ZxgjlieDbri0d/SkA+Ssva9h2JKVhWT9A63p7RJfvugcQkpJlkdziR5wm9PXA6HXF+jv6ckLKoIi+r706x91FkgKQdBlQiOXWeD55/P7P4Fi5IpNAID6nJOB33WBu/XgFHcJr33/sePv7kQ4S0JFkKMuDFxP64Z7u+YJ5BS0NRFtT1iUVxxv39nurqPe52Dd3QIcKCq/MzEJb94UCZa5SemGzLopqYpgf6sWPoGsrn5xwPHT5YXBiZ5oBJFc45pPIMXY2dYL2+jLbUMNI0D+TZllSvOJw+RcqSp5dfpK5P2LmlH04EMdD3M8bkzBaUzCBIJmeRQnA8Hb+7h4s2kixPEUHTDS2T65jbiTmMBG9wU6DM1/RdE7P2zTVN2OPDQFlWbNbn2GHk4XCLDRN2im6N65tvUS0TsnQV7XpZRVVe4PzA4XjHOExx5+AmjE7xj/NRKVPSpCD4nixLAIXRBmstm9UF97uPabtdFCxJyLIFTT9A0KR6hTQNTXcXuUFiJvgc8aiNBUc3HDk/P8O6nn6omU+Gy8sPsNaRJAmnJqbT9vs9z65eMo0eO3vOtldIIdEq4KxDeDAyw4WMabKkaRbBcPPI3f4bSDXjga5teXb1vXTtgA9DPIz8wNt3H2LnkTSF2Q+MU02go+0jxiOQsyg22FExW40XGutC7L5IzTwH7DSDiN5752bIJn7mB/4Mn57/NPIPH/hSu+Lsf/jbGIeGrlfkicYYgQgBhCYQeVYRbijwUkV+UQCnXUz2nTR/6yt7vv61e15+9Rf44eSOH/71389yaZj9SBgcbmyQvmFxljGawGAnUmHQP/tLpP/HP0rxsz/Pb557Xv1L/xKf/52/E4hjPBkcl+fndP7X88kbS+AVs3+gP+5ZLs+4vr2hSBRSZCRGczztyNKc2SqCElTbLX4yrBbPcHPHdvUcrVYYkfP08n2+/ulXSfNIO06UYbe/x1tPCIKiqrjYvMdoR6p8FRlY7Uhe5LE/oQtQikTnkVy8zPjok3+A1tH38fHbv4OUAqUKXAhk2RIlSkgzqnIR5/+HG3ywfPDyR3h7/S10Irm++5TRtiSJpiq2rKtz5nnmYXeH1AGtFeP8SPWexKOwzDPPHYmpmOeZ1XJN33dolZBmhmE6oqThbPOEItsCitPpjtnPlFUaP0/CIqTEOouSJVV+QRCWfjiihMHODoTj5v413dSQy0fltm94d39DmmQkosLOkV4gZYaSmqp4QpmtqNtrdoc7+r5nvTwjlx+wXRdM088xzm84O9swDoqmG0gzQ9PsWC0q+v7Eob6jKFZIJZhdXMp3/YmqXCAxrFfPSM05vb2JSKi5RelAYnKOx7gXMzrjbFPi/UxTn1Bao2RUPmtZMNFiXUfdzrHjcfgqymi0KVA+I0tzhulE2+8ZxoHN9pJ3N69YVGecmp68XGBdhwgZ1gpm6zGmwofA8bRjtVxzOA4sq3MCI3nZ8vruQ7phT6pKlotLxtFTt7dcXjyh7zumYebq/IsU+YKmObFdlLy8+BJn6/c51A/U7YBOPF3fcmoOLJdb2mYmNedUecGyWrM/vKMsMu5u95htgdAuFr51wM5tpJh8W0utJXlekmU5n376LRbLJevFFSF0nOp7bP/w3T1cumGk7trHuaQnKwwm0Vg7MA49eM03vnnDZrlluarYn3aUuaHIK5zPmMZIvZ1ny2b9AdsnLzCy4Hg4kCaOfmjYH+7Yrq5wNtD2I107URQFSol4LX+kdkppWC/X7Ha3jFPH7CYuL7acTrH93vYPmESxKNcUxYKHh5a+r6mKSz64+kFmG/jk7c9hR4syHjd35EnJu9tvkCXVd4xv4HDOs9vfk2ULirSgnmu6rsY7y3azibl3vq3+FfTjkWVxzqJc0XT3rFYF1nrqtkEnM6f2DfiBVbXFMLMoChyKw/ETbh6+QXAwTkeUkjE+LA1T3URopBuZpprULHD+SDvekWcSFzocHoFgnDSTjVygqDaYUVJHPEgA72euF7/A117+f0AE+DK8+VPPefGXW/rbNyTKschWSGWisUDA7ALexaKmkAaJjG1vIRFuwsicn/rqNX/vF9+y/ugTfqz9Gj/y5S9SvFgweI+bLDAxjQ1eOYZMcGxqnKkojOPsT/7fkD/9M5TAD5Lwpd/9e/GLMr6lRlMYGs9nr56TKsXXvhVlU4k64ifFqrpCERNhWabZ73aURcayvGScPHmpedjdkCQZ3ZhQFluOhxqReqq84mr7jKz0hMlikpJVccVqeR5DGXbgcDpR5TBOB1JtePoyInwWRUT1DMPAZn1O0x7oB43VnidPP8fDwzVH94blsmR/OLIoPmBRXdIPe1arNYnJaduB1fKMeZbsHu5jECUYsjTn/PyLTFOHGyd2D28Y7BxdSUHjpoREZ5R5gVQwzzN5llGkF/gwfOeGn6YZUmV0/YE8W1MWa+wYLZRCxrd1KRc4HzjbvEfb7aJzRixZV885nPY43wCOICTjVPPs6gtYqwjugcxIhv7AZFukVOTlAqOiG94Hj1YJWVZRljn3d2+w88B6+R6L6pJpaHHzjv3xAaUDQ1dzczuwXj5jUaaM04QSmpvbd+R5PDzt3JKIuPcbhoEyP6PIl4xD1D8rdeJwuse63SNxvWJ/2OP9DMGwXCwggNZx5CykBjFjlKTKLyiyM5TMMYmiaU+U2RatU+bJcXn1nPu7W6yPL0aTdawX59THPVVRst+9Y7HMcbPg6dMniBDDOn3fcKxvUanHiQ7rA6feMYwNWgkQnkW1BReimG4OlGX6uO/IGHtHKtb0/UxZbtGiINEV725fsV4vIooJzf5wx3J5iRIZgi5ql2XLsZ4iS8xnvPf8GUNfMzuLkRvW1Yrd4e4x3DDGm6ZOOZ2aaAVVEudHuq4hL0q8X7I7Nt/dw0Wi8WFm6I+s11tAYyeLd4KLzXOkyOmHB9wcwY7Prr7I/rAnz1fc3L2iWi6RCJp2BJcwjiMjIy9evM/u8IaheyDLE5TUHJu3aJ3z8tlnuH24oR8aFoszsiyn72LZqakb8mwNQuD6gbv7N1TlhrrZsVmeMU4deb55LEa+ZL+/ITewyCs6P+GdZ3Y9aZnSdQNCveP+eM16ccHlxQ/wsHtg9ge0VqSJZrTHx2ukYlEsEWGB9QOpgd3xNWVukLKlMAlKiSh/mmsm27JcbtHG4mxNllgQNaOV8cY3e5K0REnLqXlNkS3Jcom1M0kS0d921oy2Jc/gVA8sykuWJkcqgQxrfFAkJtB3DdOQMIwSF6KXJfo8Imw0SSK8blAHfhWdDJM7MT1cM9yWjGXFsMzIM03AM4UxLi0RaC2ZHQQfG+3Bp6SJ5O9/41v8jb//Medva370/kM+/3nD6oe/yFgp5NxhyXA+/vmVchzcxOHjTzj+9C9y82f+Ar/lb/40n/+HeMnu4Q7vLYgIeRTI+GYZBC/On5HoH+Oj668zDJ9S5oLz7Iqx7wjS8+b2Q0wiHkcDhrJMEGpEypmurSmLC7z3kZrd3IKYyTNHV0c+3jxbnjx5zjjEZWaRl1T5iqvLSz7+9BcR2tP3PYkpKIqMujmRpIHZNzg3sVhuub9/eFwQKy43L2n6hqfnX6DK3+N+/y1Gu2e/r1FGUxYrrIt7x1k2IHqsa1AqZxoGvB8ZppY8S/C9Zbu+oD42XJy/pG5OlEWBEBI7x1vxenUOcqBtO/r+GAOCTiGFZlFcRACtaAm09P2JTC9RyiFlRqIUu6nF6IRpsgzTgbo5kGVQ5IvIGisFwRnev/oh3vBNTuNriqxCK8Vkew6HWxblFh9mtFjStT3GTBxON+hEkCYXrJfP2Z8+pW6PVNWO2c8oBUpWBEBpE/XZ3rNabBEycLY943hsECIGDcpizYk4Zdgd3pEnFdvNmiAUWy542A1sV1cRFNn2ZJnGO0833aFFiZYlqa4YpplqUdJ3HcPY4pxAS0NiHMsqQ0uNlhoXAof9A93U0k0tWmesNwVdX/P82XvcPrxlc7ZCKYFWS7quZ+xv2a6eMs0nzs82kT4t3XfcVHPjyPMlSikeHh7YVk8Yxpau7wl+pCwzhjGmSNNE0Q2WEKDu9hSXCzbZmrq+I0tTEI6yyADFOE1IbfHO4+bAqTnw4uVL7u7fMpX7aJl1PePg6IYbjF7hPXFk2B3Znn1AcDmHU41JUrwTdC7e1iYbjaHf1cNlUWZ4F0t/2+UTPHOMw2UV4pFomiWatrsDLxntEJuvs+Vi+xkCE914T5qkTPMe7w/YyWHnHiEUF+fPqKqSQ/2Oh9O3WC2uGHc13fDAZHuKIuHN9WvOt+ccjy3ex9N+tD2p2ZBlKYEZKTRvb75BEANeTEzWk6icMtmS5Ypf/MZfYpgaHAOLVUWe54xTTTdI1ts1fXvgVD9QVikP+3uSNCVJErQ22LklTZcoLanynFO3Y7QTOjEc6humqcXLNYkGO4+YJGN2HU27Y7U441gHEA19P2G0Z7Zx9DXOI4uqIASL0tG5MPuJMDiKIifLUpr2niLP0TraNpU2HA6K9559QD+ODHMs37mQM2MZm47ZW3jsJSUmYXYBESTPbr/Ek+vv4+78G6gHy7N/q0G7Pf04IVcHFtuCvIp+Fk+kWCMV3oJKLWOQKG9QsuOrb3v+yl/5Csv9wI/UH/H5zynOf/xLzE+3yKAZ7QjTxDQPDIc9RdPw4U/8RT76K3+Lqe7I3ntB/Uf/D4z/z/8cc6yxP/zrsL/lx1HtiDWe0cQDJlMaJQQqwOX6Ahfgo1czg73h1L7mbHmFSTLKbEOSOqappbdvaU4NSapJkqh6EMJTVQWn04HFYh0VvrbHJRB8YBwj1Xf2PW1fM7kOvOD6tmGaWxJjGG3LMI70Y80wnaIkK6kIQWKDZJgaDscDwUmyZYroO/phYLV0pFmKDyWLhcS6+Nn3LjDYA8tFhRCLWL5TCXVzwNqaIi8gJDx/9hyB4Wz5Ofp+4unTC3aHN4zTgeVihWdA65xhcOAN3o2kaco4TLGYqVNu7j+kKBXOpgSvsa7Dess876mbGiEV68ULOgaG4UhV5hSP1HMpRTxghORu95ogR5QWOOcjtNT7x+i7p20mPvfe5wmrwLH7Bm1/TaIKri7OeXP9IYtFhdYlaVpxPL7m7OKz7PdHlO65u7umKgvGoWObXzCNE+/e3bBen2PtGEvJsyVJNHlecTxOeAZu7r+JVDlSKZbLcwgpQnqECDRtw9n2glNTI6QjNZLgFWWexQW2zhmnBm0kSRadNcZouv4aJSuuLp7Stg3O9cy2QQlDXhaM044QMpzrGQZJniU4D7ku6b1lGBtOzS1lVTBbQZZnbDcpi6pithNjP5BlBatlxXvPPsfN/S2r1RJvLXX/rTiOngJ2nknMEu9nqirqDvK04ljfk6aR8SeFQqqJ1fKS40GAmOLL8GKFmyXj6EmSGTtPkYItc1arNfXp8SYiPGdnTxAhrhdm21KWBcvqjLo+cHP3MZeXlzj/Xfa5nG+eslo8Yb/fP858JVW6elQSm7jcmmfKbIsgoaxShqkFEUhMwc39KxwNZf6EYbphHAbON+9jkghpEwLs5AheU1YV/dBTpNmjplUigmFZbdgfbtFGY8eO3emIMQVF+RwwONdB0Lx89qPsjzecho8oC4WfYZp77h7uSHOBMSO5yjBqSQiBs81L+mFEKIEqRx6O76iKMxK9IEsMTttHS2Og7zxWzbT+CEKiVU7wCamR5NmGNFlFR0dWxtLc8R2TbTkcj+RZFVM7uSNNCwgON/axWyME8+yx08A893jvWK3XEeEiHJvVOUYvWa6e42ZBPzasVivudh+S6gsSfUG+XJMVGfkq8ObNK47Ht3g3kagUSWCeRrROSV3Fj//d/xXvil+k+Pf/v4S/9SHTl79Of/aSLq3ILyqSHBaL6MwJIeADj9C6gHaBoGZ+5a7hP/uLf4+zTvIj/o7PfCFQ/tBn6d/7Hr5yd8WPPu2RfmZ++5pX/8VPsv/5rzD88rfwHvJ/4V+g/L7v4+L3/ItcLwqm//Uf5OoXP8T/th9DFQmJUhgk+lEjNseMAQqQBK42Z8AP8Pb+qyA6hrnB+pHLs5fYeWToPuaw27NerbHWU2VPEHnCMAy8u3kVl7BBMtvIfltUS6apQ0rJze0nCAmzG7BB4P2InTzeeaTZPPrdzxgHy2q1YbwbMaYgMQltv0NrzdnZBUqkNN0dSksQIx99+vNobRinIwTBen1O30d193Kx4rC/pShyEFHWtCoXOJeRJiWjHTiebrCTZbV4RsDwsLuhKFPS9Bxre/q2Z7UG644Rv+5NdLwkhlN9xE4erQqcjYqAae6Zpo4sz+n7E1pJyuyCrqsxOsOT4EPAO40SGf3QsFxe0LaWfDNxvLljcg2p0aRZhhKaJC1QQvP8+YJhvuXi7BnX9y3SOISaONbXrDZLCCOr5YIQBCZNGPoHqmyB1itCHg+tRXmJFAlZ0rJYpdTNjn6s2S4/Qzcc4s9jPyOlQxuBMRYEnOqWRXlOlhYMU4fzE95Hr8pqecHYOxKTkJhljHbXr0gSw5Or92nbhpu7b6E0gETJwHp1yTw/FiOXFWmqKfKK4KCbD7h55vLsOUrkdN2JZVmxP9yjVUKeLxneOtJkZrN+EoVgYcIOnifnL2naE0or5nnA09EPR5JccDzdopRgvXzJMB5RMme9fE4/HCIexo94IagWBWlqGAbLdntBmmwYpgYhHGVpCD6QphWJSXj29CXj2LE/3JJmhrPtBfXpxDCeWK/PEKTMbkYKQ928JUkl02Rp6oEkLR53XZZxmL+7h8swWopiRmri24Os4ptZueT63TtWq4q2P3FxfkXwGUol9MMBO/fUzWseDp9weXmOUC314YGr889Ek15a0g93iHlESon3E3iFURl+nlkUlywKjyBjvVhGc1qZ4dzMMEZC8eH0luVyAwSkDoxDw+7hjnKxxNqJ8+0VfVuzuXyKkDn3h4LgIgzSOct7z7+X/e4BJ0Z8NtJ3LUW2JM+X0biXLwk+QvmU9iB7Zh/QJmOcWrQybNZP6PoOYwqUVpxOHbMTVMUlbbdHqoj7X1bnPDw8EJyMRbDVBdYOj2XKI0oCOsEI6NqB/FGxqxKNswGtDHXzBqln5smiZMp2+R7dUOLlBhKFdROy2hK6Gj94CIHgLSFYZuvZ7Y9I5XjSfg/id13S3/znjD/zS+gPBt6KCv3sjLw0KJOQp0TMhreMYQKrCdLw0aev+S//y/8fn/OaD4o9731uQfL+C37W/DD/4d/4HRynjM9uGv43d/823X/6p5nrluzXfYmzP/p/Iv/n/nnEdotKEwSBKQiORcn4Y7+JxAeSzsUWv3ckSpIaTZEochSpECgRqcqXmy0hfI6bg8BOn6DVjHeOZXVOInOyNI7j+qFFUZAkGZO9oR9O5HnBMJ3QyhCCoO9HvJ/RRpDlCVFnEefNkwVTZHE8qPV3bpdSKvApqanwbsYi0TJDpYqu3ZMkOc4PsdlvLdrMrNeRwj3PktVizTA0JCYGWaY8EsOrcsHh4GKZbhpIdEHXt0hhMUnAJCPH+pa2nSirZxR5AukGpTT9cEDrNLbaZfL4kIRpGLCD4Xvf/x9xffsJTf2OzWZLopexHyFnxmHi6mzD6fgtjFKPGoWJ7foFIQQmaymyJUN34nB8YLVcE0JKCI+68TxDyYSARClF199zfXegWhhcKJDEPaK1XTzIypxhavEhPDrrGwbbsVk9jRqHEEkE2giGocPohBBSYGC7fIKdY1rLO4ERKd5KxnnAmIRxHAhVTDpV5SXjcM3p2LFdb8GMOOcpVhW7/R2n7pql2hJE7PCtV8+QemAce4RKSNOctjvEYE1iSHVOagpmORMGRZ4XSGEwumK5yFFK8d7zNU3X4Jl5+fIDxql9lAAqXjz9DLOVzK5HSh+TXFh2+xu2ZzEePo4dX/jMlyEoHgsLGKN42DVst0umSYOXeGdxzkYPkSoYbcOpviZPC9arK+r6Ib4czXFvut1sGYaW1brCz46qiqQVrRV2is+XaRqZ3Uhp1hTZlr63pCKhzDfYyT8W1L+Lh4tUguPpJvoBsjX92KN1ig+OvEhjnFSl3NzfUFUbCrWkKHJO9URZZazW34edBx527yiLLcvqCdfX12y3W7I0jw3bKeBdSpU+p0iuwAuCOtINO46ndwg5oLREyYLUWJxVbJZPORzf0Q87kmRFlie8vfkFpHIsis9SNz2n/YHN8gm4JPqss/XjXH4ghInT8chsLSYtKKozFLdo4xiGPVpleJfx5OID7u6uUYVjnDqKrGB2HqskWbYgM1uaumPf31EUKU17jODCvMToiqpcgXBYO/Ds6gX90NOOLcVqSe0Ci8Wavm8xRiOdZhgHqmrF0Fu8dyRpAOm4ufuQJFk9KqFTpj7jUDuCSejnQM3Myc2EtCCtLhlnz9jfM0wd49TjA6hEsagq8iTFOov+jd/P9OEn5G9e02/f4/X1nmKRoPMFSifMfvxVPP7s+KmvfYOv//w3+ZEi4cmio3pxBueX3KiSn/zk13PTVQB89W7N3/jZhN/+W38T5b/y++HZZ2F1Qas0HgddE5ezSsdUnw9oKSiMfry1BIpEsywzZp1iJeRBkkiJCQoDXG0uQQlu7xR2vsZoyzT2cV80xU6KlhkCyTS2TFOLlDHs4JyPkEqRkhiNMYvYFygq+r7DpAVddyQ1CUYvEQS64YgQj36LYkWYNU/On3B7/zGb7YrmFMjKNXX7gElERCJ5WJ+vOR5vGfqWRGdIYdkd3qKkZrO6YLe7JU01XTuyTlK266cYY3B+xvqe9XqDnQ1FtmKaAu89e/YYHW0jQyvT9IPngxdf5vrdp1i3pyxiyS9JEjbvXzG0htOxRXhBmVVo1lh/Yg4j1gbaruPjT36FMl9grcQ7zzQ39MOe2UJZ5pxOOxaLjHEaEcIyjSPn55e0fY0QIUJXpSeEkjzdMtkjkx2YbMeiqrC2R4qUMntCP5wY7USaauzcI6VCKsNga0zIUTKnaSaeP/le6vpANzygBRiTUBVPqJsDbd+yzK/YrC6o6wPPny94d/Mxp/qEUgnGxJ95JRK0UTgrOduu2e0f6Pu434KAkhm3dx9j54HPPvshvvHxf02aSaTKGYc4Wm2HjlPdsVk/4dTeRRZXpmj7HevlimkWhACJSJmnkjwv2Z+uUdqTJIY0KXGzp+8H9vsjTX9NXkRd9WhP+PmGrf4sEHjx/H2Cl/jQYhLBNPb048Sxfo1Qa4za8uzqC9zcfAulLM55hn5EJ5CYkiw543A8kqYAkcY+TR2ztSyXOd7NEKJEL888dnJcXDxlHHoSo1ByRgiNd47FIicEUDKPyo/+u2yi3Kze42EXnQNpZgiMCAHT2JEagzElcwpCTZxOB4xJSJMMIY7IoCjTBWSL2DwOKQKB9wFjEgiCtm/ZbjaEcMbsBjKV0Z5apNFk6Qq1TpFKkGcqWuMsPLn4IBJurww39x8jpaNaXLIqr6jre/IsRQlJ28WG7ezi9TlNK8Yptoq1SSEI8iLGn/v+QJqWkSycBLKs5HTsuX94RZrEJrkFhrHDEwg4+v7INPQkiUGZjGGYWC8v8c5RFGU0ydmIE5GP8iPQVNXmcWGtOR1PCKHJkhVSagh7lNIkuWD38I4gUlJTxPn3PKFVRXAVi9V7dHZBS0LnBV0QOGGYhUNkFSLNsXXAdy1KOpaLJVmVoxKND4FZStz7V7gf/xLmv/olPvv1n+WXLs9586SkrEtS2VAW4ITk0/uBn/6lV+i24bd/sWKdtPhFwVhW7NyEkiWZGf+Rz03W3CJ+8AWHuyPuuSB9bPw6PKk2GGkQ/9CbkA5JLKQJSUBiXWx7jzogHn0UIXgQEgkYoXmyuiBPCj59kzOHBwgP1PUNqclQouDJ1Rdp6hEnTszWcHX1grbtqMc7mrlltczjrc71dM0BOxzYbJ/ggseHiaGfePnk83EBGmpm10dz6diQKMk4BrxztM3h8YZfIkRsVCdJyv3umsPpBmMUxsBgR4bBPY5PM47HQ2xp25myWHI43jEMPXlWkWYp09RRVQukrOiHkSAGbu9OZIWmnzomN9ENKd7D7pgTsCSp5lTv2azP2e/iv6eFoR/vSEqwY065WDEdJ7qhRsoMqdq4p5OCQ/2G9eqSm7sTs43aiqaxKKHpA7y9fcVylVOk0Qszu55x6smzBZAQQuRYeS/I0xVj30Up29yTZxJjNHU7RjdNFsu0i8WaujnhXPzfPr16gnMC7y1+nllWT2jaPfWpZbUIbLcXdO3I86vvRamEh/09+/0BrRZcnK0wJuV42mPnAZMkpEkJ88TNzTuqakGeZ5jkKT7MLMolbobGqYhn8Tr6aXwaeyRj4GH3CUlakfbnSGVYlgu0ljhrGfuZJLXUpx7EjBCWPN2wXGx5c/1NitIwnHqCE4TFhBcnvGgYx5LL85fAOcf6DoElMyrSR4gqi2mu0UaB15TZksxUaJnRtz1VvmGa78jMkvOzZ7y+/hijC862z6nba+r2HVlWcaoPVOUqomuSKvplViVDb3Fupng0hw6njiCgTFcELMe2JisUeMHF2QUIyfnm6rt7uAihWC2vaPsDu8MtQjgW5ZY8S7m+fsfV5YI0zZnsDMIzTiea1lMscoZek6YblIrohHGY6Yee5WJBfTqSZtkjXqUmTfLIvdE7ZO4ROB7u70iSnPVmQ57ldH0Xl4p395RVhlaBIl+SJIZEGUJIsbNjtBN5tiLLKqapp1osONZ7lJb0fUMIDmMMbdOzWARM4uPNSBhAYe0Qi1fO0/czZDlJqr7DMmu6FikFWbogUdH9wKzIkwXLasswDqRpwmw9Ini0lihjCAGMTuKIBcWiUIx2RCmNdxIl46LS+YnUCBZlRZlvYhkyaObZ4VgxuTNaFkwiZUJjEbHU5R0+OCbn6L2ilxUhdMipwZ8arB0wmUFrA8IzZwnj97yP+JW3rF/fsfzKL/Dh5QqTFvRuRfdgefVwIHQnvv9FyfP1Eu9rOueQpqQZA9ZZzkvL//SDn+Gu2/Cm3fDFiwe+9Pye01/9b+BP/78Qv+FHKP63f4Dyvafw7IzUzBSpYB4sBIVAEeYQj2zlCUh8kIQuxqHz1DBnhkxJZhEIUpIS0Ci2xZL05Ze4P97w5v6XWK0SVLBIBQ/7jwlBkeQGZTS73ZE0NShl0Drh5u5bBK948ex9um5H0x5Isoo8X7PIn5Cbnt3+DcF79KPdsRs7fDqhy9gVUcbwcPiUy/OXtP09UkX45DAMLBZnKJFhjOF0uiXRKdvLLbf3bwlYTs076uaB1fKCNNmSmZRavYmjpe5EYGKyAoRCJQl116N0xmB7kJ5p7jE6IITibvcRWVbQHU9ok2BdPDxUA+M44X0MNMxu4vp2ByElS0qUkjjX8uTic7RNE/tYMuMz7/26yL4LKW6aWa6XCCG5uniOTgXOwjg6JhtLd24WSGE4P3/Kfv+AF57z9VP8lDDM92jlSZOSzp7wOIq0RPkU7yUyzfBzg50D6/WWU12TZwXBWaQMXF58gAgZhHv2h4d4K00Eb+6+hhSCwe3pOonwmrPVJYddh9CPeotpZLaWKoudu3n21HUDSFJTUdc1ebYgSaLBcbt+Sd3dodRIWSQ07Ym8WJIkK/J8xbIqOZ12KKnRWuN8w37X8f6LL/ONj/8BRRG5a3XTsV6tsNZS5hsEmiw1GJWSJkuc9+wOb1lUK87WT2naE2mqmMYWiLSH4+meLCtITUWRLijTc5TICG5CScfce5QSHPbvyBJFmZe8efN11uslWbKBEEM53nucnyFkaJlzPJ5wbsQ5h1Uddb3DzhGSqpTk7uGBzXYLSLI853Q6MY4Wgfn/s/ZnP7tm6X0edq3pmZ93+KY91K7qru4maVIiRYmiLDJxHIWW4iGxggiRAwdBgMBAEBj5H3KQBAFyEJ8YQSbACSAHCQLYQBJbsS1KoiRrIqOJ4tjs6uqqPX3DOz3zs6YcrI/tgxyogXSfFNBd3b1r7/d711r3/ftdF3z+I5wZMV2j/5n/+ru//ZfSDz8rh9M7nJtoqj15XiOQlFXNPI8M40hV1SACjw/3DPPIfnvLZ598O3GIwiW18fM9yzwlBExZsK6RYTymwlfZ4Nycbu5Ss8wrLniUERRFjrULRteMg2OYnpAykOWG1V0osg1SKbruESVLNs0rBBFnB6KI5GXBMJ6QqOeFfJ7mjHbBB0tVlTiXCLUhOLTKqKotWmqkCPRDl2yR2iQHhAoIDJnOOR/vyUtDkW8wJqcfz4xzR6ZKqmKXfDW5RArFNE7ECGVeU5UV3dCx2BkfJlyYnz8QEikl0SeInjSSYY5Ic8cq91yWiigrkIIgBD5GFjuzzhPz2DNMK0/HkfcfnohDTxZPtNqiw4TJAmWpyTKJWxbGhxMff+cHXP/q36fsR/72H/9lxl/4eVRZk+WOn3uz4SfuJEqO+DAQfSTEgnnxWOepqpyrbYs2NV5u+O3hU+7uBKPOccOA/NW/hv9L/xc4nVFFRvOv/wrVv/4rqJsbTN2gQ4YmR0SJEOngjVIidZa0zzqBEQujKY2hVCqNzLSmkQoTIeBZg+fxfOHSPWDtA8gLh8OX3N5eMU0+KaGDZF1HkB6lFVJaIGmnvRsp8ow8b+n6HikiznpiVJRFQzd0RGbKomBaBjbthmE4J620PVPkLTFoiqJBGs3lciLLk6FRYsizghAi51NPUSlCmBnHEYTFGIOWLVql9nzTFFg3MU0dxqQewjhZ2vaKurzl3YfvPo9uDHaNIFdETOVNpYGgUdKw2h4lQZBR5jfst5/QDQ9E0RNC6lL140ciC7vNp6yrx/uFqnjxTO/2QOTtu+9T1QpJZLO/oRvO5FnBtrlDiMg8z4DCmPQ6X5aJdfVc716nBXex0A9HjDZkWZrt57oiM6kcKGTOZlfx+PQ1Sili0NxcvWCeBpQWnC9TatI3RZoETB1lZei6I957tKmQoqIuW7bNDTEKbBiZ5kf65++W680ryrql70byPCcSuX/6CqKlKJJ63ZgM7z3DdML6jturz3AucP/4lixruLv5hMv5yLIekdoRXKSq9tgpEZS/fvg77HcNRX5FZtr08ooOQkkMEMNEFJ4oBHmeMwzJ2ilERMaWssjp+wNldc20nPDesmmvWSZLZkryvKDvE3tsHHv2+yuG8QmdSfJsy+PxA7vtjjJ7zbKsPJ6+y257w+lyT1tf411AKkHb1jw8fqSpGsZ5QKuKprqGGFjXDqks87yQlxu0SqP6sthg9Iaf/vRf+fEdLn/zH/0fUEqjtcK5hXE+o1WJQLPd7jg8HamaCu8gEjidHinLjH7s2bRbjMwps4ZpOaFVybZ5hQ+Wr97+FpttS1HuOHUfMSZl/u8fvs/11Y62aCnyDfPqeTw80LYl3s805Su27Ru+9+U/wauU9+/G9wg0manT+CRoYhB4t+Bcz2pXTFayLD0iGLabVMByzrO45fnmknHpH1mWkbIqsXbFWkdTbVCiwFnLsswp/00g4mmbLcs0EUOgKErKasM4TShFuu2qDC0LjFGsdsYHj/eWaRqpiw15UTItM9an6CIikGeGGD3DMLBpXtGUG07jgTW0jP41AyWLyIgxlQxX7xnnhXmZCG5Fh8Rc+uoHH/nBDx5pmoIiX/HLgF1HNDPbAoos6RHWfuHdx3vsr/82P/P/+Sd8bPb86i/8i+w/veOnf3LHN29gVzoyHdASUDrRdGNEak2ebZG6YdQbbLZnUQ2qqFLREohuBTeif/AF8T/4f7L+tf8c5gnzx/8I9V/4V6l+6meoNrdkJkdHSSAiihxRVERl0FmOVBqJINMaEQWFUVxXBddZTqMl+g9x9URO88Thcqa/vGWdjuQGlII6LxGADwPd9DGxm0yFtSvKRNxqyUzOss5E6SCIVHCLiuA1q5+pqiYhWE5vcXYgN1uyPMPImn56QulA8IJh7ghxJsuyZInM91TFLYSI8xPTeqIsisSvmo4s65K8QVFj3QjCoVTgfDlRli2ZyZmnlWF4QquKze4FRrXp8+qe8C5yffXm2Vb4QJmXCeHuBvrhyG7zAkH+fJDmxBjppiNllXHp3+Gco61fkGct03xini1te0NbvwYUj4fv4/wRrXJu797QX854Z6nqHfOU4KreJ5Fe33cUpUFJjbUCKUFr6IYDZZkRbEQpSSDtLHNdcOlmTCawvmeeOqRQvH75OUM/pfGx1hxP9yCSbFCS0bYNj4/v0dKgTcayLs+YqjX18tae3a5lnlfyrEVGByJND0J0KJX2xVombIrWcL6caZoaFyYeD9+nKSqkTHDbeVmoijuCl0zrPVJOCBREQ4iJ4l42ikyWrEvBpr3mcHqH1At1eYuiosiztCNZDgzjhZcvP+Xt+98lEHn98pssk4OYs2n3vP/wNZudYlksTfmG1a4s7sQwfUyAXrVnt7mhGz8S4oLJyjSCVRuMKTidP5CbNHFJ4jSDtStSBkKE3NQoITheHjCmQdFiMgnMLPMpWXqLhn46EWNEiZabq2/wnVf/tX/mmfEjj8W6MRJ84vwURYbzNdOaEkhBwNfvvuL1J5+zaa54/+Ed05QKZafzA8O0YrTgaveC+6cn5vFMU35gs3nJaFf6h7dc3wq+vH/PaldeX73h9uYTvvjqD9i2R6QwOA+Ls/RW0c8XnHvLm7sL09xxuLzl7vaacbTE4Kgqw26zBwXf/eoPQKUdiSJytVVst3cJg51vCDEnRg9O0tY3vP34JabQjDaw9gvLYilLw2UYGS4dnpRS+/bn30I4zzAtLPMDZVZgredymfns05ZpHJGKpMTNCqLvIAqUylFKPitLFaMdGWyHQCKFSAkZlT1nzx3X13d0ly59kSvoFs1Fa5xQBBQ+RKzzTGFm9aml7N2MGmbchxO78wV915BdVXxZPHE8SIr7Eh0FNgpMCGQrSJMhrgzHn834Jxj+2G/8Br/yj/8Gv/n6z7IOirnRzCY1iNFAhKxoiapgtIYubpnXgtMQkMWKUB3ZZSRrSmL0BO9Bgfz0G+h/639A9Rf/m/i/+jdx/+mvcfqf/q85C0n9Z3+Fuz//5ylurzF5RhxHZLlQXO0Y+glMgdIG7xRKZ6xhBREJCGYUtTEUAjSCfVFQZTnz/gbvHFiL8p6SCMrysf+AWQXtRnI+v0cbQYwSIdKuoB8vFEVBDCn5ZJeI8xeUUjhriXiKvGRwS3KtFBtW67FOpIJlnWKdOs8ZxxEpBfPaIQCTVfTziciKiwolHON8TqY/IchMTeQZq2N7irxgHM80N58/L3m3FPmGIqtYl4WyyNFhR1nUBA/95cD19jVRCux6RilDXW9Z1omqTMbS1Y7PX7ALD08fKfKMTBmG/gm9CWhZ0FSaYXxPZOFy6clznZwoYuXp6WsyXWPDxDQpsizjdL6nKEq8dygNUqaekxQkHbdUtM0eowtUZRjGM+vSoXWBXR3188I/MyV1sce7mdP5PiWxTEI85bkhBP1Dd9S6OkyWU1fpS7yuGqRUWDtSGENd3KClwYo/PLAMSjvyvGCdEwo/2IDXkuDBRovWCiUlw9hT5IZIYJ4fca4kz6/JdE5R7xg+PiJV6prU9Y7ttmV5GlhX2OxvCGFFq5q2uWVcPyQR2drx8uZzFBnIMy6MXLonmuoah2WeV7yHIossS8e0PJHbHc5PzMuBeYkIJYCAEIYYVrr+PavtEdKAWCAYhA54/4zGioEsq/EO8qxknuckAZMldVNxOB7Zba+RsqLICx7u33N3+wmTNqzrgJYFhSlY1pmm2nPpHuFHYFf+yIfL/+uv/zX22x0vbm95eHxASJmwGHWFCI4iz/jqsWNZfLqR1wW/9/U7+qEjL1LkVMp3dMOZN1efU5kNf/0//3uUO5nKS18+cbw8cjpf+NabBXykG8+0bcE8JVChyTLmZcbjEULz9n5gmUbmuef+nEpey7LSlCPT+CUvX7ziy7dHhnWiHweur3Y8drD+wXu0Ury4XdFS03Ud3/zs23zxD3+Tp9MDWWEICJz1LEtKs6zLggySyU0EHO+ezuyLkvy5h6HyjGleuZwuxCCQKrK6FUtEiAktDdO4kKs88Z7y1B9RWlBVGcGlOGBkpSoFTV1xOj9x/3CPkx7lCsbRYlVOpwZkKYkSvJR4HWCJWClZlaA4TYTf+x3suw+Un/0E9ZsNf/lP/C6//vkXhBD51t++4o/83ZdYIlErqk3Jtsp5pTXf+qmA/IVfpFkXXv3mb5LZA1effsr1vkilSgE+b3F6g1Mb5lDxtCxcngaUd0S10H14BKMoqxLOGmMMuVZpyU0kykhhCvJf+lPoz79BferQf+8f0f9Hf5nxP/urmNcvef0X/wL7X/4vEeaF99/7kup6T9COYDS6yFHRg+B5HOXpi5xdGWm0ppQKjSBXEi0kK5GoBK3Ofigo+7Ta86B3nLuvMWqDVCNKCjAZ0ygo8jq54ueZrjvTNlcIZ1jtCn6lrAzTHMmznBhHjt0FYzbkWZ74cwZCEFgriFFQFCXBx2e6xNMzUNKjZXpd7zavqaqSdXEItaBkZHULwaeUXlPvWNeFrj+xaXfU1ZZx6pjtQFlWiFiwzEuS69XJj6LFFiVyfIgoaViWM9AiRI51Pc4tyGAQKBa3Ppc1BbNb0gsx15go8X5CyJh4csog+EMIqsKtkW1bEYKjbWus9UigrWq8iJwOR6721xiTUFEhaNqm4XxJRkOtMh6fPvDi7nUqD/sliQG1YZxn6qZmnmam9cy2vkUEgSJg1x7rYLEfEGrChQGpLePcpbBOzNhvfhJrBUVecO4uHE/vePPqW3hvIa7UeUOWJw3yfvOCh/t3COGp8pynw/ep6pymfom3ntFfUgAjK3Gu5zid2LQ5VfECEQ0+LnSXjiLPmOcFrQzSPHDojjT1FWF27Hdbnh4f+PrDP6EoShZ/IeLohyNX+1vsMKIVZErRD0fAI+TKOB0ZLgOfvUlmyrwwTHPGfveCh4c/YJNtkkpDK3wIaK2RMgkI1zV15lJwqKDMXnIOI9M8oivN6XikqXZMy2PC8awrZVGjRNIaZ7nHZDmzzVncgdC/o8ibH+nM+JEPl9Mys5xPHIeRbhywbsE5Sz7kGCnIjaYoa96/u2e/v+bw8IRUGq0UVoTneSwINM619L0iYPhwf0CayHR4IASHlwVfPxzx1hFl5DBMSQgWBWFOKR2iIss0XT8w9CNOCMYPJ4zWSTMbDyyz4/ffPhKFQESIQXK5eLpLTwwRpSNPl6/ZbjZM08wXH3+dGHUag62W3e6a4D3OWrRyKCmT7S3PkEimYWUrcqLUTMsCViCkRGclx3OP0snoNq4WkHgPQipA4EOgn6Yk8UKnEpjSlGWO8yPj8AXf+fa3+PhwYFkCUlVsWsXp3EN5Ys5Kyk3ElDXolK4iiDRq8DO1OKPbA8UbzXmf84V45De+8X2WIpWfvvpTZ/7YX7c0v3ciK3Ju/uy/yO2LO3ZVy7ap2TcFV//Sv8Cv/ff/h4j/x1/l9T//x7n5pZ8nXjq++HDEckPPht4KpNG4fZXQPh/eEk5Tip5iOepAUVYUWU4SEnq0FlgVmRFoIciahoaM4k//IuV3vkX+D/8R88d7vve/+F+Rv/g/0fzSL9H81/8cH6aBrK0pdld4AkY7pNbMIeBCYPCO8zLTZBltnnP8XsbnPyXZGkmdZeA91nqUTooGowQvbl5SVwXduOF4fovIU8qnKGuwqTBm8iSQ82FlmAbapsQ7z+H4iDaSEDyQVAzLmgIEVVGz2oWqatBGcVgt8+gpygqtC+pKEOKalN5Sp8+BVs9YkNSD6YeO/dWGYYj84T6oKjdIKVkXS5nfcDlZ6lLRjxeqas9+8ywwE4Hz5YCJJ4JPhsKi2GLdkuyXzQ3GWIJfaZo9azcjjSe9DEqW2SWdhdDUxUusDdzeKM6XhxTsaV7gnMW7hU9efkqUgsPxgjEKrQpiAKVl8rFXSYg3zwveO4q8xa6WYThTFhuUVoBjnI7p5RUTDfx4HlJ030WyvIQ1BR+UlAgZ02Jaedx6BBfIzRalDNM0I/WCFJFh+sjpdOHq6haTezbbimk+Utctw3ggzza4EXxc+fh4ZpoWiqJI8M9MpPHlLCiriuA9q12Zl4662rGuHV33yDScGZYDJm+Q5ASf9Mynyzu0Nmw3W95/+H20zhn61MGJ9KAWyqx8fhlY5uWMlDDNPZk2hDDjg0MIQTc8kueKx9N3yfU1wRnyPOP+6ffQSiWtdtHQTwNSZWidPdMoDEpWVGVOZho8BinTvksay7Q84axju7nhcnFkpqRptjyd3nOZPhLjyv3Tl1zt77B+woZHlvUjQv6YTZR5rvFuZVjX57FAQGkNQlIUBfM8EcVEWZcgIC+rRONFMM9pZBOEQImM777/h9iwkJU1QUSCCyxuIdMFmojzLjGG1HNqyzmSlUShjcIugXmxQI8PEpVJ1tWxWodzM1KJRNOViigU67yglWRdPUoptNZMq8W5lXlNYEdEpMgqMlMwy/mZDirQRkBMoDqlFSZESqnJZCRfwUlHXtU4IVP8umj4cH8gysh+f4UWmqquCDGwrCvjMtONIz4K7LqilSCGFREc45wUrFoWfPHlkWFy2CAIoU+I8mLPw+OFnkA99OxvbqjqHUJorPQYs7IpFsp2xrWv6McN9JHNh3co+1+0arPHA5/9b/99mvvnA//X/gp9XjBJyeXFHe3/5H/MSQXan/lJ/qM/+Sf5O//av0n9jdf8S9/9HT797m9w6gaGLLCajNk7srqkqHPKN5/Sf3jH+YsHwtBh/cxUGKTRCci3LOy3O6QSxLgySsFFKJ6EpK0C+XVJ+Od/nk1R0z48svytv8Pwn/4nHP6zv0L5X/5l1j/1C7if+znaTz5jCQG3zgitCAIKk6d2/Zzxq//Ll/zOX1Xcfgr/9r8T+IVfjGyUIpOS4BaiB5RGqYxte0dVbimLHe+O32UYv0bKPrHM1HNjWYJ1E87NWFtQ1w3ItFuIUbDaga5/BDLKIkNIqKqCaV7o+4mq3KKVIYREoaiKPfPSUeY5xuQpOOBUUhLHpKjOK8mpe8I7T5ZVlFl6Yazrigsjx/Nbmk2JdZa6bogxsCxnprUHpXCxJ9ebVDgVqYSY5wXTFJjmCaMzJiT9NKB0+nWHZ27cfpfSZFLkTPOEkoJ5WZEyQ0rNMF6I0UKc+PrdI1leppLtAne3O0Y3MEwjSiq8F0SX9OZZ1rLb3PF0/Iosy0AkZ32WZQgpnonjJTFotk3L8fSOabyg5EQIkaa5Y1lHFnfk3H1NXV0hJRjdkucVw/hA0zT0gyMGxzgfKSpJP77FPt/eo4wIWeL8mUwsOOcRSKpqgxKSeUnI+RDSpGRdZqZZ4r2gLGs8kdUveALa1BhVUsoCbWrWxZNlDUWenDLzPJKbFikKECGN23SZiOcRyqzC+5UQoSrvOF4+Uuc5wziQZ4apOxCiBrGy2d7RdU+YzLPYiRgkWiY2XZXvOJ8f0cpgsrQ/XFdHU9cUeUxKBqVYlhPjamk3Fc5Lpn5GCs/90xdphGcyTpePzPaM9ZaIo92k2HKIllxXRGExUv3/nA//fx0u+6pByfTh9iGwWEueV4lMmldkKgms2iojRo+3DqES1kDgqfOMTCsulwmUoG5qQhTpQ7lahJJEEcCFdHApjSIiJMyrf+41BNxqWaxFSIV0oKVgnlLyygWfNLFdR9tsU/N4sWSZoswMTd1inScKyAhsmx3OBaTQiTpsE4oiSIfRMqmdq4K6qJjHFRct2jt2ZUEcJ3IjEFmOVekJGoFXL14jpWQaOwzQtg0mz5jsxLpG2rzACI0yGe/ev2fXZNT1DmMMTd3w4f4dJjMIBPvNFqNrDuMj8zQTgmVZFe9PHzF9xxwC+z0UTY5Sgm2z0hQTy5RzcntEoXiVP/HK7/hXf0vwV372gbA4PvnVO7765b/IZ5++5M2ra9b/8P9O7HoEMH71FX/jv/1vAHB5/Ypf+3t/i+6TT3gC/sNv/hT/1j/4DZYPX/ChH/BZRpa1DLpCVi2ojIyVEC1Lf2Y4PSAISKOJOiXslqcjxgg+/eyaQGRYHfengV4aNkVOXiimZeCrqkT8a3+O4avf59MvvuKzf/yPUP/v/wT3kz/J+//qn6H9uT+C+qlv4wQoJSm0JJDx9tdv+dv/fgUIju/h3/ufz7T/+4GXVw27TFOaHGU9MfB8W0/MrevdJxTlhu+/zVjDD5iXR9ZlwZgcqXIWl5alUSpOl4RvlzIDQKoMSUCgnvlOJqUKI+w2r5mGkcz457SkQ6rkQJrnnnXxFGZLllWM04hE4lygrK7p+rcURUlmWlzwzMuZqmo4nS/M6wPzSvrCc4ppOVPlJXnWYLKcZb3gVoeWGdZNKGWYl7SfyIucS3dGqEiUA313ZLP7FCkK3DKjZI5zDucckpKyKDl270G4tDRfOkKYsXZGipy23nIZnqjrVEKdlmRYXO1KZmrqquViHdaOdON7rJspyoLD4YHNZodWFcuSuHrrGgDJ8fRAU74gMBOCo6i2FOU18/weLRuUbNCqYZp7FInP1pSviARwE217g109XozEaIkBTJ5QVUbX7Lef8fD0fcoiI88q1mUmBI9zC1f7V3T9BUVJkYHRORQ1s+sJ3uGXJYWGVJuwLU7jo6dtb/Hesa49RmeUxQYhNC/uvsnp8hHrJ/JMU5YlUihWuyJFRVXtiMJQ1zc4txBjuhjfXH0z8Qndyrou7DYVl+6IUhNKGuw6E4sWKSXaaBY7ovUWEQuEmHFuQUiSqXf1EB3O9nRLejVneY4LE8uS9M+rs8RgqfI9WhvGaUCJnDVMyGBQOsfSs9ofM1usKEuEFBR1gdb6GefuaduCKtdczjNXu0T+zLOc4OF0mbi6e8nlfARmXr+8oi4zFufJ85rLqafKGqxK3ZjdrmWaJqZpYNtuyUzOoeuAyLo66jJn127wPvLVxw8IVeB8eI6vJiRIliUb5eocYV6pipIs19SVRitHjIJl8eDTniTGdLhomSGUgxgo8hzvLT44mmpHmZUor2iKW7AjoT+zrRqiCDjnqZsaJwX7/Q4hHS/udhyfHE3dpiXvOrPMHXVVUZdbLv2MySuMLvj8k1eI6CmrAu9XKhMQMjnDE1KiRL+7MBnB998e+PKLI09rwU/97M8Theb3vvwDtps9L+9abq5Ampz+SRO0Zr8fqa5g3Fzx88c3fOevDNjvvmN5Zyn/zDf49Dvf4OWLK+r/1r+Cljrhx4eO5e/8LcLS8/CT38K8vPvhZyBowctv7tmNP8D3H9PLUnzk3Fme3jna7Sukl7in76HDiW9+Q/Pw4R1aGXbXO0KwrNOFXHp+5ht3HM4Htrsb/uFvvsWYlkxafvbn/gjBBc7dI7Od+fWDZfiVP0X2J/8Up7/5d1n+418j+0v/HtP/0RF+6RcR/40/w+2b1xQv95xGy+V7AD/5w1/zeFz4+P5LjrOh3dyyr1r2WlExU0eNQCOEIXhBYTa8uP4m7x7P3Fw1eBtY/QysBD8zzwvOkfYaVYlA4YMjky2Z2eDDAnKlHw+M08Km3WGMpGfl4fCE0QWbdoeLkWk4cjp/RCmo8hZjcqZxJN/tyTOdyABZngq18GwmdengKXb4OJE9ky2W9YwSabQ2zvfkbHFuQmlLrq6wa+Dm5pp4yJ5p1o6qLBnHgJIlb+52DF2P1gA+hXRCxMeFbbshAkYZlDHPre4cpQzjmC5V3qUDYZpG5mnCujSeicLST2OK+dtIXggu3UhVNazrTF4olmUgGMc4X/jGzR/lfD5z7t6xba9o6ys+PP5TtDIIsef+8fvE6Ikx0tYvAEGe17gVIhmrjTg/JvcOW7a7ay79R5Z1THZZCyIqhmHEmNRzksowryttXeNt5OrqJXZ1KTqMYNPecj4dcLFP4jwhaZt92qXh8X6iqraM84JzI/Noaetdsk1mOcuystnsKdaWeU2yMikUQkKR56yrZxhPCNFxtf+UdVkRQeHcSIwr8zKSZSVaa8Yx0jaJmeZ8YLWp/2PdgjEZ2mxxbiEzZZKFzQMhOiKRvN5j8pJpGXDuQl3uqauW0+WBuq7Sf0cqjod7Ns0tzgY2t685XU7ktWdbv+DUfcCYESl/tDPjRz5cNpkmhEBdVyzLTPAWnSuIjjxTbOqMq12NteYZQukodc03P/uUDw+aeT2iheebn93y9v1X7LeaRjX8zE/8DLvdji9+8PvpyWVy+n6gzAuurvZ8uH9gcZ55XqjLiirPGYYB6TuGecWJSNW2CAHDOPHq1Qu+/Hphs2nQIvDybo+UkfP5xDyP7DY3KNUwjANdd+L1q0+QSjFdVryW7HY7uvPAGiO7piUTirnvUUIjgoOQCIrny4n99R6pJNM0oIucD+/fI5Ccjo8opTC65XLxDNNEFCCRjHHh67cf8F6y2+15eLqwaStO94/E6KmqjMwokJGHh3eEELi7vWOcJ673G8oq4x99cWQ+fM3TwwNvPz6gc8X0E5/h7TWbTXqq32wm6vrMNEm6bA+l4jvDGRVW7HdeU/3UT1JuW4qyQCuZvr2EwNQVr/78vwz2wndk5L/rB/7P1EDkz93/Y/5YecD90Rf8zHeuEFpyPL8jyzPGwbDbvqLvO7pvKbIcrJ/ohhe8uH3Bfr8jz0qmceXSPfLi9op5bnnz5jP+6Kc3WC+JUVJnLdIoyvIlzq/84s99xvv3H7najcQ/ccvLX/kfkXUD66/9Ax7/w7+L+/u/zvDihs1/58/w4k98h5e/FHj8qZ/nu7/bUDQL/5W/8LfZF0fmyXDo3nHJ9nzUhptGcddAcJF5cmkvkWVcxntcPON9Tttc8eHhhPU9WhvqeoNAIxWs64pWMdkeixpQSBUJwTLNlu3mDrs6lmWiH45UdcHT4YF56dhuXnI4fWRenpLeWVgOP/iK3e6acVkJUeCcI0aI1iNYUejngMnEbn9HNwYe3r/nZv+GXftNDse3fLj/CiEkxIpLf0+raoJV5HrD4XCmLFsulyciE84pXt99xvnyiFGKrK0JXiCNZBxHmuoKa5fnEZhIB0gUZJkh+sCyTCgyjMqp6xJlDMP0hPMTJtNoXSTelx+AQFWVaC24dBdijHjvnv1Aiohnu73i0j+QFzl6yuinA8s6Yf1IWd/wdHqLVIEYI3V9xTh65jWBHq/2LyhKzdNTiuNmucGHgPMeZyUhpIDGaRzYb2+QUgKWpknjRCmftcBeIpxgnM/JvukD66pQpkDEnpvrV3x4/z6NBEWgqVqsVfhgyUyNlpJdu0VSIzLF0/Et4FjWDqEUVVVyePpI09QYXaBVS1SOGAeEDBzP3yfTLUpLIgbnkzRQBg1RUbd71mXGuoC1gZubV6kWYTTWpulNdIp2c83hfE9RVPTDGWM03icupJKCm+tPGcczbz++pan2KFFg14B1E5kpnlFPgWVZUx/JDTyev8QYRV3umabpRzozfuSey6/++r/L5dKhdZZGYwo+PHzAWsvN1Q12XQlhIcsVWWYY+5E8q3Au4rzn9nZP153ICo1zI221o8r21PkGosCz0k8nhBDcXN/SdwPe25QJD+mZ6KxlmUe8tyx2YpgmhEz/+TSPOBfIsorZPX/AVcD7jrrKCU6R5VuKLKMoDO/v7xmHlbJOtyiJphtgmiR29mw3Fd/65iecjo+MY09VlXjnEkTOO4yIwEpEsFqfmF26Yl09D48fuLq6IcYC6zOUzJjmjnbTAo5+WpA6SyIvLZNq4Hzk7i49i42WtE2FEA6lJGVWczgfaIp0y/6dH7znb/767/O9ry+Apt2VfPMnv8McFdcvbvn0m9d841VEK8vHY4UPDbeMXA8PhA7C9U8T2z2RiBQSKUHKgBGCTaHZFhE7HzAqMNqFP8gUcT1w132JnyaMrtntX9K0W95+/XsUZc7tzbcZx5lS7ZmWI+P6xOoSyrssaopc040XtC4JPqBEimkLpdDoNMqxM3ZN2HZv0w99XkrO53uKvEKZmlzl+HVF54rh3PHu7/5T3v3f/ibn3/iCCPzxX/zfkf2Nf5Pfd5Jv/Im3bP7d/wDTOFwUzLMlz69omi39cEJJT/1cqNNK0VQts+2w4QxRU2c3zPaCyTSSghDSuLbvL1i3JmeMFIjnvSMxMk4DZbGjyHdJVe0nrJ9p2w0f779GKcNuc8c4dUjpEEBRFHR9T9tsmOf5GVvvkSJHa0PXH9KXl1acuxNRBOapJzOGm6vPWSa4jF+CmKjzTyjrguP5B7SblugMeEXT3GFdZF6OTNOZptqx395x6Z5QMqOuEpZ9XEZWO2BMQVGmUYsSWWJLCZnGMW6mKiuctVy6M2VVkedXPBy+IMSBcVq4vnr9rIBeMTrDuRWlFNPUoXTEhwUpNU11Qwq8BISwz0TeAeSIdTNSrWi5ff699lhnUaIi7WInnJ9o6i0hyCRwa5tk5YwC0ISgsDaJrvq+4+bqG3g/M86n5/5R2q2KmLFtbzmenhiXC5nJCCHn7vqbLPOJy/iRvND0/ZgQKkaklKE0WLdQZnuWJfVjPt6f2N/ccf/0XeraMAyOzTOEVEnYbFrGfmLXvMJay2l4h9KS1XZoVRKCZFkWqqrCuZkib5AyfRamqUObdPnohyMmi6zLgoiRutxz1f5zKLnl4+MXyHygaatEIGk2dJcnEJ4s3+LDwrQcaOu7FG8PaeozDRO77Y5hvLDfX3HqTng/oWTyBhl5RYyen/nmv/zPPDN+5JdLCAO7TUleNPT9yMPhI7uqZL9/zesXnxKC4u3H7/H+/iuudm/Yt3vmeSEGqMqGsqzJlUYoqKuXRKupq2T7U0IRZUBIST88JOtZ3mLthPOWptk//8MXCce/nFFjoG5qMlNgdM68jBR5hVCKc/fEui4JGe0UWgqUqFjWALHHzpaXuwx2Dc4G1kwz2IVlkUxB8OJmj5KWeTpSFB4XZspKcng803UrZV6ihCeEge1mS5nlBJtu/sMwsN2WVLXCZBnDEvHOUZnk/b5/eMB5uH3xKrG9/MLTYWaeLb//3e+jlPxhhr+tSjKj8e6RxVpMriibBrtaXl63rNOKXRY+uduwnj+yhMj3Du84P17RfX7FbnuFRfHypWFvLD67Iu4+YQolw5A82FoKtIwo6Smip1UbnEjtalUAfuHzYWSePuICZPmWq901wXkuxyfadoOQmnGamNYLF/cxjQtC6gtEJyiLKiUL85am3iFDwpo4F9Ot2eTMy4RWEZFJ3Oq52m8YhxG3Ctr2BasbEUQWtxCIEBXFdsvnf/aXef2nf5alG/n6f/MP4f/6xzFIfgaI//gl7h+8wf3ydzGqZrvbkisDcaDKItLkLMtAURikEJS1ZrmszFNPYfYURY31y3OiT3M8vkeIlFQ0WnBzfYdzcDg+AZKm2SNFRdPWEDPO3QUh0tKUAHc3bxAx3XSVMOy3d6xrUseCY1nGFCCIHrcGNnWdXCnes4gD5yHFdJX2KONQqubcfcTkmmZTMI+ezbbmMjykvckqCd6T6Yppcs8U8v3zBXHgMj48R4vTQW90QZu3DEOkqbbcP/4AqSVVmUbNTb1HSkNcAx8+vqfIGqpqx7IOtE3xHC0WOJ+EXiIaynzDNI8Yk2b/dVOxrD1j37HfvUw7LZnRdQ+U+S1aaxbjKItbQpg49d8jz3PWEFnc5dkgWTPPSXMwzSvLNNE0e8qrG2IMeGcpipquH9A6RwpDlTc/JIJ03QGEJ28a5vFCfxlo2w2ny5pG4U3J0AcykzNOF2JI3ZN+vFA1G7pLh1YVVXmDdyBEx+Vy5NWLlxwvj6Bs6rLFmBiErqTQe6bhI7vra+ySvFNKGvplZlks180dRhU4P0OAVy++yTxN5FmO86lXVZY7QohM04W6rjEmY5hONNWGQu+o808xKn0HNpsNj8ePZJlM6oHZsd2/4HS+RyhPsBmSDdZ6nOspikR+F0IxLy4hhIaedVmRSia2GaBVpB9+zODKq12LtWCdpWkrmuZb1OWWdRkYugPT7Ni1DcNQ05QppVJlLdvtNbnZEKJjqfZolXHu7kGuXPp7rq7u0LpmnQNtfYtdU7qmLT9hWjpWd8J7UrtWRqb5jA8LRZ1jdIO1DqQgL0ryvKLrj+SZoS4bQkhKWJNlz66U5KIp6vSEXW1ARkWbX6OXgVxDnXs2tYYoyfKMaVkxWtJ1HYv3OAKH7sjVrqUsNkSl+Xg64b2mKUHmhmleGe3EdHlku7nm3cMjeVlhtMZU8PbLr9GVQknFvM48PR6RIkPnOfM8411kWVfKvGDbbEAIqrJiOU903/+Y2r3zSlNkjN7x/u1bpaVxRAAAcWhJREFUMDnN9Q3D+czvfv8POH21Y7tvefONG66KV9wXBcu8YbUXVj8w25W4DGwzi597ussT21IiX7+k1wKpFSI2WHchMDEtlv3VjnWZn5W2km7uUVo+FwhHnFvxYcWYDKM18zSTm5JLd0gOHhchniiyKo1DgiAGwbIuSEl6+RQNJtOEmJI1++2Oh4e3KJljzDZxx+yKQDCNA9vNnvw6Z21nXv7P/g0ev/cC+/fTZ1bISLw+49fI3YsbnItEwnP01xCCS1HzPEMgefv2S1zsCdGiCkkUqdDqrKMsFPvNi+RuVwprJ4ILGFNxd/eCx8cHrvcFUuTM85nL5f0zkmiGGJiXnrJsWKYepEcIiRCaYZxQKkPFjO3mDu8j03zgfH5LkdVYG9i01xwv90gVMVIluoXXaN0wjA94C5vNnnlY0q7QghYZRhSgJLm6om2u6KZD0iTLDKkn5uVMrnPsKqnJUqDk4T1VlRA1ddnggmN4Hq0cTw94JxnmCyEMlEVLnpUM4/GHu42b6xtELChMRtddUI0ky1KwxzmHKmryrCYzK219y+VyRkmJ1jnWLc90ZMO2fsHl8oidKnS5ZbPb0M+PVFXLMluMuvD49CVSWZSo0TKVVZXy2NWSZy3eA9LSVAVSemJc+Pjxu2RZTl03fPjwJU1dsd1eUeQF83rB+RkZItvtDZlpOXcHpjEVSL3VGFlSmBVt6sQGlCsP79+x3W3phgOX7okoA33/kBKD05nXLz6hKXecLh9Y7cq6rNil53qn2O3uULlCYRimt7TNLSqvMCpHlAXH03vyUuH8yjRffvhSDjHifWDTXHE6nLh7dYtbCsryitkNjKOjKq5QaLbtjuPpyPF0xIfAOPTPxPYNkoxluiByCARUBjYMhDUSfKQsDIud6LonNu0VUVg2m82P93DphzXRM+ukNJVBkCuDqfaMa482liqv+fzNT2BtoK1qlCzIdUtV7Lh/+BqhFO32mnHqsWFisWfmJWOeJ7QqQWjausVITQwz83hhXEaurl4kY19IlNlhkgxdR2Ysq3UUZZ7MaWFhsRP73Z7j4fKMd7lmniakDnzj0xdM8/BsmBt59/67bJtrrl9+wuH0W9gYUCZy6ZNhU5uG88OBosyAgDaS29tb+m5KmPGhY/Hw9ukjw7ySZx1KCtqm5vh4wS4zQZc8DCfWy3MvwgkO3YHhi+mHEMtMG+w6YPuAc5AXJWWjefFiQ2Fy1sVzeLrn3A1ok5zty+pwdqUwICUcLgce7t/RVopf+ulv0ruZS/eWxw9n1vUDT+cjn7/8WfbNpwyLY5gWGmUJauT2usV1j7glYTtmIdlsrrl/eouzkavrPUWh085q2zD2F7KsIs9ylI503SExtaJHyoCS4blImBGePTLWBkAxzWcu5wfKYo9SBW3TMs0Tdp3I8+Y5Lp4kR8YY7JpGJUqp5H0XEolECEuWKw6n90jl0apA5gL9b/89/L/zC3Aq2P/3Hpl/2uC4xtuAdR4pI/lzd6UqG7IsY+xG8kyQ5yXX7U26mUWFcytCSoSEZbFc7V/SDY+JdpynyLwPI9PSkWWaZQq01TXjcCYvkr/He0VZV89ffGCMYphmymJHDJGm3iMIGJNjHThnmUZHVW0YpjPWeoqiJDcbfIRp6vCFSQyt/Iq+P6KFRkRNVaVpgRaGpr5hU9+wriMi1uS64rDcY0qB9SF1uFzArSNX+5cEny57WSbxYaAfjyzzSl5kKKUx8prd5g3H0yO7/ZbT+T1VnSXr5NBxPL2jqDb0fUdwEQvkmcGuI8bkgE4QV+dB2KREvhwIzmOKnLJoOV8OWD+R6YrHw9cM/YGiyCmKEmMMNVcoCrJKMQ4X9rsXz5/LFa0lZaU4X04JECkkUge0eSZbz4rMNEgJzrnnl1iDkjllcYN3Hikszk2slx5XZMxqYln6tLMICXV0PB7QCo6nBy7yyDyd2e82OBuw8YLJAlIXZJlinCP77S3zdHmOUldIIWiqms4v9MMBawM6F7gwP49fK4SUjPMjham53t7wdPpAVeVEv9IPM5v2mnkZyPMMrRqE6Hg4fR8XIk9dznZzTVlAnt3g3Ex0AiMNeW3oB/DeojUIApnWtPVdGg9mqRA+TD3eLWw3Cb7rw4L3K+fLA1WZsFXf/hHAyD/y4ZJlW0JY0DJDhoymahjGM4sPSJlzddUQXMRITVtm+JBRFDWH4wPH0xGEp8gMx9N7lI5En3F99YoQRCrWuY7VemTMaJsWKQV1XTKuR/rxiabeYN3Euoxsmz1VXhLCSmEENniMFtRlk5bmw0xdN/gQgMh+d51i1NaxiIhbI015x81+QiBp6g1KlQQsSsoEiRtWTJZx7i/U7Wuu6mtOpzPTuPLpq8+4vb7le1/9Lh/u7/nmm88S22vq2W42lHlGdz7hYs3bhwe8EESj8CKw227wqyMEiTCKuK5867M3PD0cKMqCuqn5+PCOuom8upO8ut2zLgt/8P0zd3cpVXQ6ad59uMdqy6/8C3+at+++4vF8wrqVzz95zbe/8ZIPj99Fqg1Z0SBEzlvh+MVvv0KEmW6e8EHy5sUdWkSCkHzj5RWrnRCsGKW5ffGarjsT8SzzzPXVHfO64Cxk2QajcpxbmIYLVVE/o36OED3BB6KL1G3LPPVIVRJJX97OreRacr1/Q/CC1U5EHyiKGiUVopREwLsFqWJK+hQlw3Ti2L+nqa/Z1He8v39HXkh0rljWmSwr019/6R79838Z0+/QbzxlKBL3KXh2u+1zByD1GJyLSRt89Yp57rDB4axkv/mUYbxwOh3JspSOhMDT4S02JKmddRPXVy84HB/wwVNmDUWWVA1aGZQuCDFSbMpnGZxhtZYgIlVRIYDT8Ym6rogiAoGiqBA0hJjMrIs9YTYKSYbWjlzesKk/gQh5lmgDRqUvE+s8u3aHwHI+32PXmaN/wmQaJTzdckKZgJKKYVrQqqDMK7yPqXPlJ6K7oGQLIcnlttsNAYmfBiIDw/wVUlumcaVtKh4O79jv7sgyyXb7koggioiQDuddGsfNC9qkl5CUIIXChRShrosG7xwhRJRKPDXnHWUhaZsUfZ3miW54Yl3PhKiIscfokqKsMHqT2ujihHUDZdFwOp3ITIZShkw3SGGQwqeLjwpIKqqsILhAmWVkRcVqE/9OiYL95iX9cKEqKha7QowIGYghoo1BCYNWCmVWpIS6ukZEmb4/wkpVN1iXdNCZzp5dOzWDHdFSk+sMJXVqxU89JpNM44DSkbq+YZ3PBN/jseADVdlSVzusnTC5QgiBMRlCRAIzl+Edm23FOjvKoiDTe9bF0jYlj09vQQSMieS5JsaAkiJFsqOmKrfM04pWBVmW83R4ICs0BPfMfRMIZHqhq0QUcXZGqx+zLKxtrvB+ojv33F7fEnzG7J6wsSMExbLIhMAWEYSmrm9Z1o6iljiXYpyIFmUiwa1EH55fIxad5yAURhdIIbB+SHl7JWjaAlCs65SsfibxcYgQvKDMG6oq+Vn6bqTMNqDCc4pCph9CBFqVOGt5dXfH5XzBuZnr3UuqKmeaLuybK4SGLC/ZNy8wSvNweM8f/cmfJs9ytu0d3/lmwfH0RFPnDN2BN2/2fP6NFyhhMMowTD1SCsbpwr4M3L54xdv3BzwSpSQ/+PIP+M63v0Mm0j/TZRo4Pt3z+ac/yfImUlSSqjU8nu5wfsBoQZODFZHPP7miKBqmceanv/2Kr963XLqO1y8LbtrXbPc/zdPpibvbV4minL95vpXs2La33L+64fbqhr57pKpqtpubFC0vWtzsCMEizR6tJf1w5vHxPXXdkGU1Tf0sjlrTYbyt96zWJsVBtsXahXWdKIsCrRrsOlFUGhHVc+s6jWKUlHigyJNHQkhBP5yAtOyNQuCcJ8tzFj8Sef6SygzzMqFECVHS9Y9UVQN4mnqH0T2ZLjC6RArNamb0zmKyAu8DIcA0W4wu6S4jWV4iRcDbKXnfUYm3VOcJ1ljnGF1QlAlRH0IkYpPl0Ri8h3Ec2bRXCcK62YCXWH+hGz4glUcgQJCQ+VEhRBI2ZapkXSeyTCGE43D4wG6foq0h5Bhdgy9TD8wHvF1AiWem0wUlBNt2zzQtRCOp6w1df8IYxWhniqxM3LGi4OHpIxudOG3OjUjpyPOcrdyyritEj5ALAoFWBus8WhuMLp5lYTJpuaVAqhUbHMPYobSmnxa0ic+a5Iy6esHqLkjpiFQoaQgesqJO+BmVE3xgs72m648UWYkkIy9rlFLM64iQgm19xbI8Hziypi7LFLEeT7jgKMsqtfazitV2KKURZEQPbq347M0f4Xw6YHROmeecu3t0XZKpDZk0HLsHyryi2bScj2eenk7Ubc26XHB2Yrfdp9BJgO3mihgjWW6QKIwpUTJjnju0SDSQMm9wzrGuK2VZIlTA+0DbXNN1C6Cpqw1Tt+C9gCjTz11ZY3TONA+UxTXOrRAqdu0NH59+F8+CKRcO54EsL4kqMM5DIh8MqTCJjGRmm8qNckQEzzTfo4RhmibatqAfL9gwEK3AmJy23TFMkbLcMc8D0sDYnyjL6pkZOVHX6VKQLv4lzq4YbZiWkTorsH7+8R4uApUSHSpjdZbd9pqnIT7bFR3b7U1ynyjPNK5k+TXjeEmHT1zQKjDN7pnK6anrmr4fKPI6+QFimrn74CjLnGU50tQpIaPljt3mEx4PP2BaPnK4fERKgVEG5yeOx5G23SX6Lg4iaJWRmRLnLA5HiBGd5RwOJ17efU43PKHXDOsGhJI0+126ZQuH9zNSlAgiWmqqeoc2FcPUoXPBtE6sYaHICvKixK4WG3uatqEqbpmXA+N0oG2u2bQzmcmpyx2vb3aUxYar9hOU0Hx8+AL92WcoVXK9/Ran7j3SWJo2+dHz3FAUJUoZ2k2Hc567mxturz/n29+wWNcnfPfVgnOB7ac/gZTJe77b7ZiXESkVedlwe/1t6qolAHa1tO1LrJ3Sl18gORxMQZ63nPuRvKgJRJZ1SKGMasN2c835dGT1K3XZUmQV/XxgcROr6yBqQqiQMqfMN8QIXf+A1jlC8LzojyixcrrcI4RB69RRstGnJ7gHdGRxjrbcIA3JuplveP3yJ5imntUdiCLF4AuzIdMZq3VoU2GtZZx7iswk+Vq5ZVpHTOn5+PAFhS5YxmRwzDON1hUxWqRJGl/rR75691tcX73C6NR3SrK5nKa5fiaCH8kLw/nyCCIiRpGSZCahfTKpiUFi8hzrIvvmJomzgCK/Zpy/T7Aj7faaq+sabxU+esTz5zZEx9PxaxAzUinybAMY6iqgZMal73BhYFo7mmZLngVCXJiWM9bNCeHiLFlRYF0kxuNznNrx8f5A29w+6xzArwLrFv4QuqaNBBaGceT6+iXn8xFtItYnH5EXjtWt5GWLkTneToAiEMnNC+bxwOIXmjrHuxn9HLjp+hNEjYgZStRc7z7leH7POJ2QSvB0ekTIJF2riwa7ruRFyenyyDINaFVQN3umaUgoFr+ghCPP9+lw1A3LbJPaogxpNyYTWTghelqa4jWXbiQSGKcLPo7sdzUhSMr2mtPlLcfuLTfX3+bpcI/QCy5M5BiinzBZnlxWKiIElEWbCuVupG0/YZrP5FqhdUY33GPyGi0y+vFItJa6KnHPjfwYNNe7T7l0v8/sjkzTyie3t3x8+h5RLSgKlKoo60iRb+mHJ9bQU5ctZV5R5nvmdUj4nmX+4es4TBFnHVEHorVpSY8kCMvhfOHq6sWzYuTC7HrqrCEzSRuhlEzkbCEJ7hEFEA2b3Q0xrJz7Cy5GED/mhv7D01tub+4oi4xx6vn6w+/g45oy2WLC2imVnaTAxRkhE2BN2Ix5tSiVUDFEiVaCcRwJYQFS3lspy7xccM6xzIEir5AUTPOZTCt8uKIqK+bVYNcl6XDzmnmeiT4iRUwdHL/SVPvEIgsOLy3LujJNA2UZWdaFS/fIsg6YPBJFZJpHIlDVGc4uWJ/SJ0JqlEwx5ss00rQ7fHQ8nr+PVJameYVSAu8n5qknYrja5QxjSqfJoNk3G6xNgiQpYZoWxEbQjxdkBt10QumR+TEi1Ux0DikjVVUnAjFAFFRlWuwP/UDwMA4TTVsmfe+axip5XhHJUUpxOH3Fuk7UTc3x+MhqB5zboXVOVbX0fZfmy+6SDmKxZ5lTdFsqiVEt8zJQFOnF4axNVsGyRQjJYjum+ZQOK+sJPqHrTaFSyKJQ2HXC+cBmUzFNI1M/UTcNx/MjwzBwe/MKbRTjlGbXIQTa+o7gQQiJteszhgRMJng6/CDRkNeVIB0qSnrXEYJDaHD+kdXNRCLzEpAiJ84jQkn6biD4hcnPSJFGAlJqlI5My5l6U3M6nnDekmUlQmimaUCqVNobh5GqSmywMt8ghMIYk0RU1lFkJT5C1VT05yNNuyUikKIgCp92TlKz2hklBatNkMbz6UiWpdh5jAv9dEHqlUwpoKEsSs7njrpuWZeVLBcI6VFC4v3M8dxRVw3rbDG6oCxr1jXtDrruAWMqqnJHKiJblDRIJen6E1qlEqJSgmEcEOikKY6BptkQQwJtzvP4PBp0Ca0UFSKSPElO0NY3zPPKi5s7NJrzx+9TFuGZrtFDzJ5/v+Hh8AOkjMxLiRQ5mYF+fKQsy/TnGmLSE1SGZV4o8hKBx3uFWzOsPVPVCdK5+pmPD99HKYG1AbeC1ulnxU0T5+4jWZnCBOfLI7O7p2xA4AhBoHRkXnq8D4yTp8hrut4yTueky4hQZFU6aLAIJYjSM4wHyrKkGxbKogHSTtB7Qd9bdtst47mjH9+TacOu+YQyvyHEmXF6Is8KirxlWi4YXZCbCmMOXOYvGe2EiopNvSH4VJAsC0+ma3StEzlinlmKhRgyiB1SWtalx645v/1bv82nn37K7d0NkZxpnBFRo6Vk2xbM44zUK4fDI0pprnavEX5kWUaKPNEUPj68BeHx65TgsFESw8JmsyHGwDCOP97DxRiY5xltHMN8IsaZskyYcUFkGE5U5Y7MbGjKa6bRUTclWnnK52aoUhIpFcQEaKurDc46uu4t2801u+bFc7SuwbqF4DLa4g4pBYend4CnrTa0Vcs4dngfKYoElfM+UXKJkWnqybM8nWXBUWQtedvwcPgKGyacKPHR0R1PFIXGOZvw6f2E1pKsLtNNrCxZ3Mxm07LOks9e/TQPxye4CizrMX0xTR3ee8p8h5CKr97/NnmW0OmI8Ox/sbx+2XDuLasauYz3jNPAZA+M8xFi5HqniURElLTthnwtkAoulxNKrYTgE6xPWB4Ov8k0L6CukGi0loRomZYRKfwz+qbg9u5ZZEUAofBhZZ0WfFgJbk0Hk50ZB8dP/9Qbno4PCA/LOiAwhLAiZWSZU2/Iu0Db7umHgSJXiOhZV/tMBs6p6y3TNFOWFS5YJtuDjBwvx1TyIlKxo66uads93i/cP35FVbZobbB2RkhPFGnxLhWs04xdLSZTKJXQ/UIJiqzGzamcF3xkWgemZQARyEyDVhlRCN69/wGffPIGu6xkhSQ4y253R1u/5ouv/il5GbFuwB0GIprM5HgnaH74GVtomgZrV8b5gtEZWZZj1BYtk4cnhNSTuRyPdOcTu3YPMeBdpCwrfHBM68KmTTfXMm+RyjMMPcqkm671SYTn1pUQV6axY7d9gYya691LvLescSZGx2pXivy59ChiiuXqkqJIOHVrV9TziPdy7qirG4KXKWJdlKzrgl0tqswJIaZ9iMjYbDaM/ZpuwD5io2IcZhY78PLlC8ZxIviAkIZlXgnGIcnYNS/46sPvcf/0JUoolLIpOJMVGFUgSP74YTwjpCXLc07dA9vtNR8+3JPlkmXpyEwGGOp2z7v3D7y4e8UyBfLsmqxq0gt3PbFOSbdcNXu6/syyjCiZkVclx+6BgGC1Nhk6wwYlS8oSxulARYFEomRJbgqEjEzzwLomVE2RK7SsCGpgWRaUUuRFwTAOHM4P5HlNPyRD5jCdiDia6pZ+vEdr9SxfAykLrrZXPB6+xlYLq1vZba4RQvN0/ArESlNfIRXsNq+4f1zJCoHJAnlWss4zh/M9dVPw5Ve/zaa9Zbd5ifcLi124XI4IkSGExvuFSzeRacGLFy//C5mhC1jXcekXyqJGq5pN03LpDxR5xrQOWNdz7k/c3txxunS8f0iKhUwrFjuzaTdAjpQN/XTGZAVVkf14D5fd5oZpWRjnA1GueDeR6ZdELxFlZF0sCR0hAJLrevjApq6ehUEzxrSJ00NEyAoJ2HWirCqcW/BO4eyKdSvzNLHfNgiZ0fVHhFDU1RWI+MMPkxKCuqyQUrMujmk8Iw34sOC8QHiFtQERV2IYiTFisvRrmeaB1Y7kxYY8K5+Vx5p5mZiWCTCE6GjakuP5I1rmfLj/Lj5CXkayYo+1I957nHNsN3uCc6zCobOMefJcpo41OPJSJzRIXFnWkaqsyQrF6KEub5Ay4dmnoaMsaoZ+YlksbVtT5DVaSy7PLvBLnxS6dd0yzmeudy+eUe4GpQ1CSB6ePnAZPmJ9QwyKzGwS3JCOEBa2mzuG4USZbwHPQX3k2N0jFHiXdLmRAAKUNCgZkEKQZRXBpZvzMPYQYyqsoanrNkWo7UDEI2KiwwphqKuWZZF471EyAy2Zl4EYBXlWURZ7tMqZ5jPrOrPaM0Ko5xFpSwwDSsqkgQ4hyd7Eliwv6PonTGaIwlEUGfOyYHSyCYYY0Bk8PCWKwH53hVsXxnHk6em3me2ENiVVeYUS0I+pPKik4nB4eo5rviDGQFQzxBGlBFoVKNlSZldY+0SeR4ahQ4uc2aWm9DB06MxAgEs3gHAcjo9U1ZYm3+B86lyYzBBi6nCFmFrSQNJaB8e6HFmXwG77gtvrTzj1HwGf7KcmKbFXNzGM5+R6dykNNy8j3iWAppIqzehjicnyFJyRaWwMkOc5sKaDyVn0c89qs2k4d5FcGYahZ5omnF+4vbmlH0aCn8hVzrn7QMoX2Oeod0wuHCLn8z3rstJs9oksHmcul5nNZgtyIi8lxqSJh5CJfPDw9DUqy5FGsw4T0Q9c+nuM0ZRVhrOSS3dBZzvyvCDEBSkyirzBhzPjfKHIS4oyZ1qOCDJ22xuWUwcxpC/IfEfwkafT1ygDMQa6/phGVnMkiuTr8T6Qq4ZZdkQCfXfievuSbfOC/vJ79JcnMtkwLCc2zS1CpjLnNPeUzwoDrSoWO/Hu/feBwDBeEkLLSKSCh8N3MaYkhAVrLesYyAx4t7IuGTFGYly4f/iKqmgI3lEVL0CuzHagqbdUdsM8jVzdXCGVwsWI0DlX158wTh0Bh/UjYXQ4u7AsE1I7vnr7m+RZy1dve5pmz+nykXaT0/UrVZEzzR2bpmWeF5ZlgaiBH43/8iMfLpGIUgB5apx7TwiW/faOYdAE98Q0d8gqw/oZIWcKkzMvK0p4FBI3WxSaeZ0JwlFVOXlZJpikSpC1YX5gWi801Y5+6IkkB3YMjhAD4zhQFAXSekKYuHQXfEh+F6kNbnHUdZ2edc5TlXVSlo4n8jzHOY0UiqooMUZRFDUIQfCJBXW+PKCVJDcFy9QzLx15XnN9/ZLLZWCcLmyfW+bWzoCgLBvs4qiLLarWLG5iUzeAwAjB6lbG9ci4nInRsSwr19d36Yk5deRFTgiWsi5Y5hGj0zO76y+0bcM49mR5AUJwc9UQowMR0z7JOuzqEFKxrVLvZxSWPEuNc7umfYmRDcPckRuNRoEPODdRFluq8pqyqAhRpp1NWHj/8Qc0dQVCUVYtw3CiblqMyZjXLs3mo8Bah5CadXUIFLkpgIhUgVzmxJAlu6TMmceZ4AI+pNGF9+mWbGQGMaLI8ITkTY+CGCTeRTabK6ZpRomcvBDp9RJkih+Xiigs67wCjiIvk1NEBoSIEC1ttcMHiV0tAkGeZzTthsMpLVuX9YTKNVVVPUMMV6Z5Zr/9BnWx5+Phe4xj8lz0Q0+eCbRZOVy+h9E5AkWW1RRtw/39e37w9e9T1TVV3bLJC7bbhnn29MMHlC6pc4FAP3dHLjTNhiwrcG5BaYF3giLfcDi9xboFKQqGoacscsIaMKogz3KG4cjilh+mkPpuwGSauDiMztJrZ7Us9gBRM80TfkhQ17ZtGIaOqsiQsUjiMO8p85qmarl0F96++xKESDwy6dFZ5Px0ZrNM6c9LlWRlxjRfMKZkWWbuDx/Ic4NQAyZTidenJwIFSpW4dcFFxzAPrPaE1hXL4jDKME0XpI40bcFwmejP71jtgfunR0xWcGVe0g1nhiFFe+UUkCpg/Yh3AyGmeG9Z1PS9JM80ed4yrxOXS4+IGiEKApJj94FlXRByZZ08m+YWrTKsXZnsRJZppmklBkXTFOglQylFpsC5wMPDR+ryistwYfEdfX9CUeCcJy9rpIKn4zsClstwJlM5ix0p8pym2mGd43B+pDQ1V5tbzuceHz3rJHl99x2kWCmyax6e3rHZXNP1B2KQtE2D9ZYmi0zLzLk7Yu3K6fIWIQNlNBhR0F962nbPuMwgPZfuiNGKS3fE24m8KBFRE4NGioLFjQQGvJ9ZJk2epapA8CsfH77C2pGoAkoXtHXx4z1cVrsyzwNZbiDGZ7TLTDfcUxQ5askYhw7nnijLlqrcYXSO83OSCwVDkSf0vA+BINJyd5pmtJap16ALrvdvGOcehEqNYAX9eMa6hcvwyLpaAj6NgnxIml0hMXmBQFPlGm2yZ7yHeUaiW6q6RGnD5Zwii/PYJcBmDHjn042vLsl1SVXWaKXYtBsiKxHoxw4fF5qmwFmfZu4qx8v05Rm9ICDJ8g1ZVoNIM+7t5prLcHq+FTrqckuR1xAVuakZpwGJxlmbUiFastvecOnOICxd1yXlql9RShJjQIiaGB1TGBBSUxYN+90t51OHNIYYZUKHqBKZpwV+3gbCBM55VnckCg94hvHINA+4MFKXO5alRwpJlW/ITYEWmqIon29MC/04opVmtZLt5iXLMhGjQglDxKN1Rgj+GW6XntbjmHO1fYliImDRmSZGj7ULSqaijnMLm92W88UiBD8cczjnfljazDKD956q3FGYFq0zxqVjmgekKNJBZQrG8cQ4H/B+wceJZcnI8w12nZESuqHHhch++wJjNKfzRF40TPNK9EkMp1QabZ4vjziXUBxSBm6udsQYmab070U862Kpq4qh75AKirLi6uoaKTXzPFOVLVkWuN7eUVUbYrBkecHcj+x3qZuyzCn67sSI1IGsLFCDxgaLNhmbbc7T4T1XV9dchgljckJQFFnDbrvnfHpkdYKr3Q2Pjw/pZypK8rxhmlaqsmDTXiUuVBRELIEJa6EqUxRmWRcWFmzomZcBz4rWmnlOYYlpvlC3JT7OCKXohp5hOhN84Pb6E8rKsK5lKmkKnQ6lKNhs94zjgjY53qcXsBIQY9qrlWWTfo7XiNE5UuSY3LKGkSxrMGolNxlKa4LLyPIdImZs6ptkv8xqrJgQcqFt9snkWViInhhXgofNdsc0HVGqwDvHubvg3JrMlSqn6wc2reHSTehc0XVD+k7IGqY+pHSjmBFBUZVXLOuCVpr97oa3H7/AqIIy3yErwf3je1AWYlJ/KJkxznPSK5NoxJdLj0CyKVvuPx6Q2rP6FSQ8HL5ASsiLgpubO7rpxDgu5HnBpeuIQnDuz/T9iTw3iQZAJM8LDscTbb1n214z9BMBz/HykbJIoReQyUdjHU21ZRWBZQ7UVYuzjqbZs9+8RkSNtQtttaOtAg/Hr3EhUmQ1y/qjscV+5MNFm4JSqmdlq2Kz3fP48A7nzuRzhSDj9avPOJweyPOMOt+gdMH7j0eMFlRFiw8JIrffveR4fkyUUpFSaFEISlVhnQMWQghEBMuycHh6QmVQNw1SRXywrHYlhAmjMqpix+o8QiYelZ0WltkiRFKBKp0SV96vSB0ZpksqnkmZ/t5lTRHHZwsbEU7nj6mFLXwqNY0ntMwIKIyukFJR6poArM6lBMoyIsmpSkNwI+uysN3uye3CNHvubl8CSafadY8oJSjzKt0yraCpNpztgcPpHUJItE7e6xhFUgo4j7UrRVGhdYZWnhgV1gf6fsDkin46//BFME0T3jvs6lFao3UNuqHr01IxeMFiU+RbiMgwPqWbcyx4efcp8ziDWOkuT6mfUmhMVrN6j8LjfNpRzbPjMo8I6QBPWVYJ/UMSUClZYC1keca82FTswj8flBr7jFmfRksMCdqptGEYJhCeaeqp65ZlHZINsGxYlynt8bRhmSK77YYsS2kx7wOLnZ5LkGDjQpjONPWeEC1aS5Z5xnvLpRsRQjMOa8LejxNVUVGUW0Jc8XHCGIVSAilzqiqBW4ehJ8aMZRkTTaHICWGmKBVleZUYWDJisorL5YyQCxl3qFhh6RCyQOv0SkoI+RIRFc5K6qZKWm6V4/2MKjTT2pMVgm440vUj1s/YMOGd4Ku3B7JnlPu6BjabPZGFutpgjGEcZ0DjnWbXvkYr+Or97yHkytXtC7quI69KzucT43JEG9g0W3btDYfTI1fXNwhyrHWsLu04Npsr+j5dsoqygucYedPuKLJkzbRuZr99zTif0dpjtGQRGVW5ocpbHp8+kj/3lJxz2LBi5wVrHdMyIiRoqdjv7miqG/rxSJY3aA2LXZnnDiXT0t0ulqJqUKpCSMc4rrTFJzjnGcI7Hg/fpy62OLcyTl36POcF6yrR2tCPZyY7E7xHR4GSCmNqivwagiMGSWQgrBpvIpkxjMNAFgxKJsxNcDKN7JUky2ou3Qlrx+fXcs60TDwdP2KMTn0oUeB9jTKp23X/4YntVUVvj2zaPefDB5RMZGUBqS6gJcEl0nGW52ids64rguddYd0CmnXxSdscVojpsyuRaJn4eHbomCZLVTaIXKWJUKkhCpY5keibusT7HrsGqmKHD5q22TBO9sd7uDw+PZIZjZCCdXUcnp5w3idMe5Q4bzkeT8QomMaZeXwgCIH1DqkMUQa68cK6OCq3EoNgGldCDBgtWNbAflPRDR+RzyfxOB9YV0tZ5wzTCFEhlcC6ZNEzRuKjAFHx7v0X9HOPVpK6qCnLlLPXRcYyr9RVxbk/siwTZVGTmYqIJMsLqqrhMvRM53uU0ji/YtfuORSQNLTOOaIQ1LuWdVnIs4y63PHx8YmiLpjngbqsaKtPWOxAt16IInA6H0Ck9NO6OoqiBOGJdgWp0odumokhsswz+90tp9MZCMxT4MXdCz48/gEQqcqaPNvhPazrglSaaZqQQmJtj4vJ8JcXBUa2KKU5n9PvYVVtyPOceXZUxQ6tAgLLYkeatmWZF4JK40/vV+Z1YHYDRZGTVwXzpWfpJqrKs1pHlpXM6yURsmN6aRSmYV1HiBqj00vGro797o6h73j/4Uuurvb004Us16yrZb+7xciS8+mEMTWmKJlthzEZ05QorU1dsK4jMS5kWXq16iwJrOZloSjTOHBdz2lkKhV5XpEXFdM4omX1bD3McEvyw+82dbo8BJcOpTXtbHS24mJIh2Oc2bVXPBw+YuWUUnGxSWK8ICiLO6ZpIs8N03wiKxI/y/uV6COr1UShkphrndDZzGgd43Jk295BBLc6Xt29YRxnlIrpkJ08y3ygLAvqqiXPc6xz2HVCKdDG008TSgJrIh8EQKjIuJzQSqbdR9RpRCgUbdNyuXRkRlHmDW21J4jx+RUOITh2ux2Vz7B2YB5ncuXxq6S7TDR1wdXuNQ+PDqJlnT03V2+w1iZ7q/XM85heojHtN5dloa4blimCdJxOD1TFFYTAPDn229ccT/dM6wPWzUTS2PLm+iVak+gbZosUhmW5UOYlAchLw2xnUJCpDKEy8rKlKDZcuifm5UJd3FBkDTLLsaFnmg9kpmJel7RPRHA8DLRVyWoVbf2S4/kD69pxtd8xzTNGZigRmJeBrrMMw4EX15/gnePxuVPmXKDMrqnyK+zqmeYZZXLGwSJFTp6LdNmZFupySwyRc/fA9f6WsHoeHt/hQ0nb3rBtbql0wVP/NZO2LOtCniW9wzx7qqLGLaBUgbMWfIY0JdZNlGXLsl4Yx8TgM6Lk0p1SKEcrxm7FmBJJCUGxaQo8gmn0KBmpipYQLG4diHmgabZM00JmDEVZ0DY7nk4d8zzilh/tzPiRD5eqSr7rdCMeCGEhzzVSmGdXs0/mueiQUhBJbvO7m5csy8I4jckvEARdb2nbBiE0xpSpOSoC9w/v6aZHqrrErQ6fz/iQFsx51mAtrM6SZZrt5pplGbCrIysy8qJgshNKC/LCUNc187wyDKd0y3MXdrtrzmfBdnvF8XDEm2fBWd0+33IF4NPc0a6ATEvEsiLLApfzOSErrMeXBVEopIJpTD5yu6x4q2g3G5I1MyYelDEoVaRY57QgdUTI9IJZw/SMx0gCHmctxkBV5zw8feTrD/8UZy1Xu9esy4hW6cbbjUekDEiRvBvTNFBVGXWdHOlaVdxc3SGiwLqJti1TOkknAu6HD39AlkfqZ49FDAbnIASPNhrvA1meE4IgomiqKyAwTCeyrElMo+4jZdEyTQuSAmNq7JqUs+tqUVqiWLm//wrvF7JMcTyd0BnP5UTLOPUoHFe7l2yaa879kctwYV5SEieEjKbZEnGcuxMBT0Syba8IcSYvcvI8o+tOWOuef781lz4xu652byiyFiU143ROr4/yGqUzTpf3P/y9mYVnHCacX8kygdE+0WYFlEXBtPYUpSZGi1YCU1TMy8xms2ecHpnmC4U0LMuI90uKQYeAIP1ZV1WFDwuX7j3GCKzrGcYjuSkpy4r7p3fkSJq2ZRhGlNJstzuOpydC/EMLa8YwPrG4AR8MRjR89uYbDOPEsk6cTg84b9nvdxBS+jBFkBOqPzDydPqatr4iKzTzCtOaYsZKCvrny1ddF4hMEULgxd0buvGYMDJUbDfXeDdidEVZtMxieT5c0p5CRM28nFnW/jm8k8gD4zRgnWMMF6w1aOUQsiXEhaauWF2KPF9tX2BUTd5sCMEyLyPGaDJT0g9nhNSYrEB4Q9lsE7PMr+RFzjCdGMYTmzYdLMPygBQlm+bmWW0AShvsOBCd4cXNG4xsKPIG6zyDGJFZZBwc87KybQxNWVFXJXXV8NXblSxrcVbx8u47FHnDai37XY0Mghg9eVaneP060fUf6PuRb376MxACCMmlG6jLHTLsuLt5nRJwTtIPA+ti2W3u+Oan/xwhCL7/9ncJKpXSr9pvkJn0Heycp9zXeG+xPpVhvQ+cwld4Dy9vvkX0geAF5+49mW4wuqHI6x9evtZ1QesMQUrvRgKBiU4ElnViPS1cLj1Vkaf/zTuJ1oK+7ylM9eM9XILXTOuEVCN5blLGGolAPu9NNFLJ5JFmBAJaCby14CPeJQhgu92gVIZ1Lsmxqi1DN5EZAWKklltiSAC+iKYu0yGUmRatFe8+/gCloL+sZNkWKRc+3r+jLHLubn+CZZ2QAqqiITcps75ahw2BZbbsNjdokZPpGkGgLNJivK62SRUwDZSZTvsUvyZpU64BRVlW5Ll5hk5mdEPPtt0hhXjWmnbY8Mi57xIqwbmUQunO7DY7vA2M84Vp6bF24Xp/jfeRxVrquiZGy7yuLMvEOLk0Yw4rr19+jreaceogjozjQNs2aJ3+P7x1lJuWvEzwv7zIOJ8HuuH8vPsIHM8PGKMoiwKpAlmhUQqWJaJ1eh3UTfMcfQZn4Wb3bYbpQDd8ZBoPoAT9MFIXmjybkGQ0+YbCACLS9ym3r5ShKBXWLkhFAl/OJ8qiYNdeYbKccewwGTg/kRUtLji+9+XvkRWGptkyDLDdNfTdhXHq8T7xoCKBYb4wTyNVuWHs09hvXYfnl1xHUarnZX4q/1q74mLqQ4WYNLF2Oj+PPgxdf6QqNwghyUSZjIg2lcqG8QmjFXl5xTilbkpwjhAGIqn0KeSCVIrFJm3utv2E4CXL4lDUCCkYpoGr/SsKlfQLSqbXuQ2Oj0/vWH1PKTd055680Czzyrt3bwnRsd3epcTd2jHKS8KQRMWr20/xXkEUGFUR7ELb7hiHjrrasK4erQz77Ya+PzEvM02zZ14XTGZQLme1E9rIZ42xoiwqrI0URZ0gh3PP+kzLMNpQFgXLIlnXlUv3nqpMvKzLuef29gV5XtINB4QKKJ0+e1IEtMlAxkT4tSmO3E/vCdHy+Dix37+gyhsKs0n6gbZmmixCGOZlYZpXlAQXLMPQIYWkyFs661jXKaVCZcToimlcmacDWmuqXGF0ybJYpmBBKKZpptAbrnev2DS3z0pzTV0bvvjyt5jWjqrcsGtf8ur2DUg4Xc6cL+9QsuLzb/0kRZHi6d1wxodAP3Y0dYtWFVJGjI5cujOZNrTVniIvsN7x/a9/h0jg259+RlvvUNrw4cMDT09fkecldy9fABYpFI/Hr5nnkc/ffE5mKrSSz3vqMaU6lcIvlm2zw3vFh/vvIZV5JkcoXIR+OlIVO25vPkEpg8kM4/T/be9PemzLrvZc7JnlKncVEafIw2Tx8ZME2ffCgHEB//+G2wbUsCTrsySSycw8RcSuVj3L25ibbKuRgAHjjA7Z4WHEjr3WmHOM931eh3MJLTUpZ1Iua4Gff/2MaSpiCGUceTo8FLYV03bl6fAjOWwk+RvjX/rmA6/X/y/JDyB2GNmQUsJajda6pAyuDVrVnMefaNuatt6hBOwOJ9IlEEOmazqu9ze00aS0cbufaesj1likUzydPnC+/kTK5RrX1iUnm6zY1o3KVMSY0Fqz607chjeU3pAio1UiEMryLWaWpZj2ypI5s9sdWaaF4Faejn3hHMWNdQ1YUxdfg4/U9sBp94lheqNvPSBRoqGqI8v6xhI21jWyOMeu36NEyUKPMWIqeDufC+lWllx0HxzTtHA8vOPt9pXX14JYN1qy745kkZEi4qJH5IKsCVGhlKQyHc4FUnI8P33C+wllpuJFSKmg2fsj8zLgtsLjGm63f/KvpNZYWXJkQpi5D29otZT0TWWKk9salnVmWScgP+CTFS7cuY9vgKdpKua1qL20NrgtYJRinK4IIQmpxMF675mXO0pZpnkAseGDJ4uEix7lHefrN07HFw7NR1b3Sl3V3IcvRLGg9A5lOuqmxblAVRdcitYao2tyTlzOn/kPf/6/09RPpKR4O/+EEBDCym5XEi+VNAhhGIeJ0/GZGEIZV4wLy3JDmyKXHccru36Pc1dAIIVmWTagfLcXV36/tCS0ajCqLlksKpFEJiNQwqJUy7rdcW6lrhrmeSuEB62oqobr7TPjeMXKCq1KxMDxdGKZF5b1AsCyhMd3Fd69+4FpHBmXS/GHUGTHx/0PhORYlgW/bbjtShIO7zPvXv7A5u60NpedooG6akv0gltYt6W80JTmdn9Fq0KWHsOVqt7jY5nZD8MdZWG83dj1exAbxrYEvzJ6R90cMFqhe0tMG1orfvfpTwgU43gmpUQMsMYNra5Myx2pBbZusTmRokOIIjuubMv7lxdeXv7A7fqKVpbKJkKEpt0zz9ODJqDIyaOVKhEb0XO/Xx8jroLXIQlyiux3T7y9faPaNxij+fr6mSwSCUFwgRQkbX9g3z2jVVUOhtvGrjux798zfrvinEfKcmi0VV3Gkari6fgBa2rWbSXnjb/99G8IJbnfv9F2PUbVhZeXM1pZXk4/UFXFTySQCDQx5vJvuBkZNa+XX+l2O7ruhAsBrSTjeCFmh1E7du0LIa0kNn798ndWv7BtKyGsaGU4Xz+zzCvj/MbHj3/GeVcwQiSM3vPph39BKYXzKz//8nfG5cb5fKapy0og+I2cy81OVw1KludYa40xBonkcvtG9J5pmom5+22bS4wbT8d33IeE1ZbbtTD9u66kFJINL08/khMMy88IBN5lqlqTk6JpdrhtZZzvzOuVmubxMBe8x7hNpLiSwgJRPIBzLUZ1zOsFJTVt27H6lehWYnL8+vW/k1nZ748Mw41lifRdR0k/iygt2O9PDONMyI5tnQlhKMbHtMeoFqkKS6l4aRJaK5wfMSGibTHCKSUwSqJkRcbhg6VpFXsiy3onm4ZxvpW9SohUVUVV1QghyEnx8cOfSb5kkr87fuLp+I4vX3+GFAtF+XTkfr8VL0qWpemFhNQWKQX34ZVd/4R3oahtdEuMjuAiXVuzbFem5YaQgh8+/hmjKT+nXx9S3mfG8YrWRSHWtsXF7V1pLEIUmXlO+p/jmxAS0/IVpUso1jyv9LsdVdWgRFVyZtKMkP5BzW3pu0JrDWHFaEtdWe7TharqidGy746M08S63onxyLLM3McJ9orVDeXmOE8kSsiYUop1W0p4lsgoKcg58PT0glYt5/PrYx8xPsxumhA2tNZUtsM5eHn5gECRc2aY32iajqfTR7xbuA8/09ZVGS1GB0ISYqbvClNqXWdCXEk5EtxK3wpEbkkRciqKLtDUdc00rSixo28bcmzR0qLbhNE1IW00bVtItp1hW1ZWP3E4Pj8AmoHT8R3OlfFm3z3jN4nbygtqWu7U1hIorC8hFSRZCAv+jk8rUtVM67fCPOvrkinf7/Ehcr68Mq8j6zbi48R9WEk4lvmKtSUql7xijMG5G0onhvsNKRTX6xkpE24tdI2mbTFGcb2UCUbKiRADyq3M84axlLwY76hsxbLOJenRFyL0tkW6+gktDV2j2baNpqtxbqFtG9Z5oe+OjOtATulxCE2Qy55kXVe89Ox3R+7DpZh46yKlnsaVvuuJEdq2RyrBdXote8jKkmNF350won34v2rWdcNai/cZIQSHw4Gfv5bvXt1YUt5wLvF2+YXtcfMDTWUV316/goC27bjdLkipud4uSJVo6j3bFgvp22/UtuSjgKSuelIslO8YIohAitDW++JJkorNTZzPX/nXP/4fZEApiQ8ly2Wc7wgFISzU9TP38YoQUNcdf/7D/xWra4JPxBB49/QDUhic2xBClFuJyFgjiNGzbgtdewARCX55eFuKvSCEQFv3SGl5Puyoq56+nfjr3//zb9xc0hvWNLT1npQdh0NPZXvGqSCprW24jX9FSU3X7hAyPU7ugnUb8HEBnVi2iZQVbfuOZfI0tqGuaub5TkSQ8szh8IRZDDlVhBgey+vw2AEkck5YazkeD1yv3+jrPUYU/4zzueA/XMnqvo/3R2a3ILgNa1uapi9QNmnIFL/Hu6cT0zQDAtOqoioSNVIZ2rZlXSd8DDT1CbYZZWQhLW8LMbuH9DPhY3HYCgHbNmPNgaY6MmxnfBh5efrA7f7Gjz/8iBCReZ2KWq3eIbOlqmrG+YZSmrZrOF+uWLOjbZ6ZpgEhFG2zI0XJGH7m9e0nqqbD2Jrd7j3LkskpUZkKvy0IkQmPk1R+nKSdW2maHeQZWyvG8UZTt5A7Yiyzb6UkJEtOAe8jbVMUOdpYamuZlwEhyot4cyMxzoxjmfPG5Djuatx2J0XBfndiHIrbnezomiNaGW5D0eYvG4SYaNsaITTjeEYqya7rMdLgY2TzExCJ3tN1O7y7YXQqo9buSEiOnIsBN4TIfrcnhpXr9es/AanD8vow63q0Aql4YFwsUECaUjTUticnjZYHVn8nxYXROWJMkH2RqhvDtCwk3KOh2YfhM+LcQiYy3AsyP6uyN2waS0gbVWMwTce6LnjveX45sa0rw/SNnDPe9wTKjQB6RNPgnEebzDBcUEZgtCRjCSGwP3xkWQQxR7p+z+YnZj8yu439bs+2lfGN0oKYPCE52saybgrQWF0RArR1w/k80DQNUSTqpmW4j1hrUKKo0e7DGbhyOOwAwTwXT5HzM6fTiRAi67Y8TsT+sSNIdNWeEGb23TMfX/7EMi/M2yvj/Weqo+I+fMEaTV3t0brGuwshL2gFy7xw2J3QpgU9sW0Lt/sb2lQc2gPjOAHltne/XRnHGy8vJ+7jG1+vvyBzRsl9iQtOEikM+90B5zZijoR1RQrJthUSxe9++DPbttK1RxSCmIpK83h8T1PvixAjOUIooWpa1jwfPmGsQvaGmBxNc2TXx0cEdgkSvFxfMVbxfPrIbneAlLkNX7ie/85u956+7gt9ZBpZ5vsDKZPIjz12bXf84cd/BVksHH/723/HbYHNObquwto9UhggEZPjevmCOEp86AtFg8wf//AfCS5yu39jnC9cbq8M0xsQUBKkOKJU4f1ll9BSEUKRMC/rBWRkfzj8ts1lW0ekyIQIx/1HrrdXqv6I98WZW9k9gpF5uVHZmkq3xXUrMufLZ3xcqJt9ccvunxFUSJlR2jIvxVcgpWALM1JZmvrI/X5FqrKYVFbx+e0X9rsDB/vEtiZS0sSoWV2irfdcb1diEgW5ET3kks/t3FRiUrUgpaKWIQfWdS6d3FT4NdI2NdMyEmIu10jnSDEQhq34AlKisi/klMk+gy3enKK2SYQQMcqQsuN+LVG5sivhaG/nr9S1xnkHAnwZ1j+MZSVbJDpJ1hVkw+oWxtfpEd1c83r+GbLk+fSOdSnKGqkt+/27ciJ0nvtYcOPOzYTccp9KXvk0FwmvMoJ5Gng6vce5lWE80ySL0QbvQUnP5uZy67At3m+IlNk1e/p+zzRNrNvM5frGtk30/R4pNJIKoTzbNtA2T8SoyueYE9oa1sVR2RqlJdZmrJZYVQ4kkY113Ui5IO1bvefl6XfM28C0THT1nv1ux7qOODcwzmeCm7iHCSWOVM2e5ApRO4sCYVRKQbZ0nWXbFoJ3NG1DpCuhT3EkB7CPXJ+67qjqHrcVgOPb+S8En/j9p/8bMYBHYK0jJkFldLlZhISxEWMVMVDGoErhgicxs20r+/0zyJJUaUxFazvu9wuoRNPUwD/4Ymd8iMzLxGG/p607tIzc7xcOuz8QYuLuP3MfX2k6Q0qemCNJSJr+REwSCOy6XZGpRoVpaooNLGOs4eX5U0k/FJJ5PtO2DX1zRMnys1dWl1gEG6irqjjVQ0Vba7q2YV1WvC/jRi0qhqGw1t6/+z3TdGfdFiq7x+iEUpZhPOOdY3844m+eZn8gRoVWkl9//a9o0xaQZ9tznwdiWtnuicOn99zuF8IjlHBabxyOz/TNCe8dt+GvzPNAa48Y74k+PDLtwXuD81uZkqzQ2j1PveTDu0/cbzem8cbl/g2ZG16efsSYCms1f/n731i3kT//6T8ifMsP7//Ir7/+FastOSVccAzjnafTp0LIzhEtDe+fPhXTb1uXHQgKQZHV/6f/8v+k0h279gkQ+OiZti/UteGw+4DRHW7dSmKuBaMUbVtSeaUKXG6fqUyD3xKv56/s9jVNdaCue4QU9O07+vaJYbrj/vb/xm0D7z/88SHGgdtYRq23+88sy40ff/x3JfLCR6Q0nE4fOZ5K5Pf//Om/EvKNrm3xYUIKkLLczja3YmqL0RY3r2QEXfMbh4VVXVO+hNnSmCdW6xnnC6iVnGHbVnb9oXgbRGbaRnwYS+BTcoQUAEFdNez3e16/XdBKc70W+rGtGpwXrPOV7fWtdFoBl+sFY0omtqAA6sgRKGRSYy1V3ZcXqVDYqi7Lw1WTUWhVERMobVmWkWWZCdH/k5uVM3iXWPPKcp6YpoXff/oX3oYzQghOx2eGcSQlDwi+nn/leDwwT8U8WBz6LVHVkD0pppKAKcwDgKhYlrmkt4nA5V5w8TFkxulKY1q0MoS0EWXmPJRsbyEVt+tXYtz4+O7PtM2OdV6orMJtsPqI84n3L+85n79h9AHEivdXBJZxHHB+KTHSqpzOpYSuK2qbnIofpXy2kqbqSk663FiXFXRHjuXE7UPk6+s3gg88nV7Y7164D28YI7heX2nbtpzyRIMWe1y4E/NGiB6ZLdYods07lsUR1Y2cPcs6YI1mGFeW+cb+cGQNkt1ux7KOrG6haUqQnBQWKSuqWtPvnrkPF1AL47gyTq9sa+Tp6Ynb/YaUlrbdMc03XNgeoNSKeV0e+JjIto2kuNE2ZXTydn6jrvcImYqvRAekiPz0+T9z3P+eyu4I0YEIZAQhe+7jnefn57JXQqBkUdg5H/BxKzfGFIkPxWROFrc5Nheoa4FIkl17YFsWvHP0+yMhegRlF3m+XahqyW36hbrqOfbPuNUjUmLXHQjeEwNoU2GtxW03pvHMrj9wqk4MY5kWOLeRH4bdqmqYlgEhDdM8I3Iu3q2YECqweYdtLNO6omXF0+GJ8/mNnPIjz14UiXfTok3Lt9cvRawwvRXuoNakWMx8T4f3zPNIjp6Xdx3j8AvOOV6ePyA1nO9/43j8VMyytkbrPU4vDMMd51cSK/PiUXQo0fH5268ksVBbSWtP7Nt3fP7yMx/ff8K5oipzy0olWz69/PsSDb2dOf3wkWGYUKJGsGBtZJ0cxTTq0Lrgosbp7dEgO7Zt4cff/TuCj1SVYr4NOLfSdTUxb+SUyBl+/fpXNj8RkqMyHcEL9rsjMfBY6hcOXQgJt1xZpgklLY2tHyN6z7o4cqoeBvONcfIs253gAy55LuNfGTaFvTQc+o+cTkUcIEg0TUdd9czrwJevfyl5QkgSkdfzZ5xfaJsG5wN///vf6bsDTXPk+emZZRnQVnM47PmT/A/87e//maq2jPOZHBWH4zMxRqyuWFfHGGZyzPRth5bmt20utd2XjO+wcr1D2z5zHc5sy4auJKQ747QVZ7wufDEhRPmy2RYZTMnVxjFNd9rWEHzk3bsXzuczyhhCLK72/X5HipkQI25bsCGzNx2H/RMh5DKGMPzz/+t2Pz8yJxQpC8bpH4yootGe54kQIlIKqtqCAGsrfJhZN8dx/74whIgIpQg5UlUtKRfkjBCSnASn0wvDMHG/35DSEBMPj8NK23bFVNUYprkwsaxpCaGMolIutNkYPefrgja6NGIpqeuOaRlZtomYHELvUNJibflZnV/o2o4QAtfbmc3PTMtIypFfvy5IlYg+Y7SmMju67gO32ytWtzRNh5INiPSQHBYOnFSZ3a6cQJZlKXN901KbJ5bxC+fr/+BwOIFQDNMGlN/hy7e/cjo+0/fFm9J1e6RSeJ+RouV4fMG9zWirED7R1AqBRom6KItcYvUjm79ze3tDIqhsz6F7prXF27C6NzIJHzva5qnAFv3C5foNFycyAaNrjLVlrJlWbvcLKWWiDwgxMK83lmVit3uoo7Qlx0SIG97PKAFBZ6Z5QCi4DBeUbHg+fSAmgEwWK9P6FbIlppmUZ6YtE/KGrSq+fPk71lZoXRaj5/MbUhqssizLnV2jCFmyDIn9vqc5aFxYH7uvzDguVLY0+OAFdV1yWJyfScKBrKmrMn8fbt8ef7MTwccyxkQ8FsWZylpyFgSf0cLwdPyBr+e/EkKgsiUCfBxHjLUcDu+IcUYL0NLCg9IcQ6TZHwm+7Dc2t9K1e4ZhwJgdTWOZ5jubWnBbxlQKHxaWdSWnSEpF5LFMM+/ff0CKxDjdIQnqusVow+VyQRlN331Ey5av57+y3x/5+O4P6DwiNWThmb1HoXh5/pFxWFHakNNGU+3Ztzsklt99+qGkPOZI37VIGprqSHCJ6+0bWQ4gelJyuG2kaSzeZQ59R9t2LNsN4TTX6ys+rLx++8r7979DqSJ2cWkmU5Fi4LA/0NY9ShiSCJwv3/DeMc1DiXTQM0Zrzj/9habpMNaw3z+XhbhMrOcZJRQvzz88djwrSkcuty88nV44HF7KGkEJbl/PpBQ5HX9g3Qpcct3uLMudr6+S0+ETf/7T//7IhqFQP+wOgSYnmOY7MW4orbgPGz98+MDmVv72679xPDzx5fVv/Pt//Y/lf58rtKhomwM5OVLyWJu43r9wOv1A1z5zuVxZ1y8F8ukjlfmNm8v52yvGlusdUpGXjBCO4+EZ5xwxb9zGC/M8cToeCKE4sKu6RilNXiZyDqS8kXLRVqeUmOY3hN4YpoWUityxa1rIknVT1Lawb6xpi2pIKu7zjVoWJI1MIAll+f3wJEghWJYZv63ktOH8SmUtMTqU0IgsCtYdRd/uSVFiqEElkgn4tKCVhgjrOiIE9H3HPC8IGYu23q/4oNkC3Mcb+qpJCfa7A8s2gMxlR9N03O9XhEhImR9L/5mEKnTZuOCnteSd5A0pI/N6oak7jAGEIsuN8+0bfXsqEu4ciHiUkYS0kWLCKI9RPVr15JQK4mabcFvi5fnIfXxFScvT6YlhPOPcjHOBEBzLMqKNQopUYmBjoKmPBG8RsjC+Ti9H5iny6+fPoDb2PONTZlxGEBFranb9E9f7T1zvf6PblcjiLWy8f/oT364/4/xScOtuoKqbMgr0ruzG7iNd94zzM1lkUk6k7NncjRRD2fd1e9x9AyEZp5lPP/yB12/fyj5l3Pjhh098+/YZP91RWtL3B7xLeO+pq4ppWYuAgY7gPFJ1VHUk5YSUZVdyuX6j6/Yle0RkTqf3jOOElTXXW2GqiSzo6j3ReRACpTTTtJRdkF85X+5I6QluY7gtHE8/kPLG67df8HGl614YxytIMKqhsh29tdyHK1pVhDQS0oqUzxhTcx9fySKV0cRWkjBzjqQEWhX5vHOe4/GJbfNsYWVxMzFCXRsgMgxnurZnGCaarnkYGxOLvxNzpu872rZFJI3RFeM0kIXkuDvRs6NpOl7ffkaZslc7nd5xv19BZPpeEGPBk6zTxMvLJ8bpzrLe0Lqhb98xDGeEhqoRxJyoqz1COOpGse+PdPUz031AxA3nFzbnirdtDbTtjtvyilGlcQfvWd1IXdWEOHAbvmHnPbtHbs6ufQHpCESC8Lxev6KFwmRLzlBVDdY0WCsZ5zvX4U7XVVzHK92+57h7wYeZnFe2TTCM38h5K+MwpVCVRVw0ORr65oWUz2x+omlqbGUxtqhT+/ZISrHsdmJGyYq22iERdG3Psg2FKiIaToffo5Qg5UK1FkISXNlJz7N4RIoLNucR0rC6QrrQArzbaOuew+EJAOdWlnVh1+8YhwvTfGVaRpybWbcKUGzbQt/uihI1CgSWyjakWAEbbWcet/yVw+GINpHVT/jgsPp/rW38r+NfVMlqrx+z82U7s64rMe6RUjGMA8Yq+n6H0WVEVOCKgnWbMKbcKmLwrPNI1x+Yxhs6ga1qUqqomx63Lrh1BRLOTf/EuI9T4HR4x7Y56rqc6IbhRkiRfdeSoqOqDLfbV/ruiRgDm9vIDw+KtYrKKFKWCKFJIYCAZZvRMpKMIuVAXdWsW8TUDV3dsqw3YnCEpPAxMk8j1hYigRAglKGqLHVTcb58Zd4KmkFLU4yVXhPiCjmyriumqmibsqcBiGlmC57KVJiqmJp88KQcEUo+3PASqWqUqtBK04mWHEDZTE7x8bMofE44d8eFTNf16CjKzmV5ZZ7eSFlgK8XlesZahRSSnIsaLoSVymhSCmjZInPHvv5A1pH79F+439+QMnM4nBCiYMqzEAyzJ8RIimfGuYwwkwjEtGJU8Rfcp18glvCuZb2Xz9wkUNA1e7SCKCMpTwiWsgg2hpwTiQ0XEpU1hSwtCrTzcn2FbDDalNEoCZESTd2g7b7QuoVE1goosmytC03i/bt/IcXMtLzRNifa+oltW/j127+ByKxuxNoaRc31+pV52ahrS9P0GGXZZvA+0/fHYqRzntvwShaOtrdAYtc9o1RR4fkw4+OdppXoUFHZljf3+eEFcg9QZ5HXxxjIaPa7T1xun/mg/x0fn//I4haUCizLRozxEQOtkVJT1zvGeeQ2nDGmIYYicxeiYErquvDFVrfS9iXawJr6Qf2NxRicKP6mvBFikZsv642YNrr6wOvljrKPNE1bbunTOJIY8WniuHvGuY0tz/x6/m9ILG1TjMwZgRAtkgxpJIWE3dkHlVzj4shffv1/AR6JASF59/QBRVuk3/NADhuHQ/9w67uCPQoRpRoqc0QbzbTcsKZCraoceGTNtiwoAVoXBebmPR/ev1BYCAK/Op6P7/FpYd7O/Pe/DPxv//7/8eD4aUJeua1fiV4SkifhiE5wejqw25f47o/h9yhdDMhSaL69/cTr+TPjekaZGhcSn374F/a7d0glHyKCCWtrfv+7/wtKqqIYS4r7+MbqbvT9C3/43X9EK0NMudw+64ZlngsQVEhqc+B8feXzl5+oq0KhFoISAVIf+fDyJ/70uxZtxCM4UCMxKCHL8yUFwzKzuIWYAuu6PsztPUoVcrmQEyEEpKjw68g4TUX2/Vs2l7ot1NwQEyUpKJNzIOMQwtI2dUEr5AhIrGkLNywUh3qIK1IYshAIoQgBstD46HHTjBCJdVtxwfH++GdUVnjhHwuo4pR3biKTqCq43c8lh6UpnVjKkgKYUonszXiqSoGMaBuJKVHrhpwlbfPCtg6MmyMTUFoViF6IgKa2DVaXGNbaSqZQlpO75sTL4ROrW9jCiPcz1qqH0srQNZ6cI/v9CaUM61qoybXdY7REiiu2tnjvi2Q6FUKwcytCCES2nE4fuN3PIDakFJBzyScRHVJovM9o23A4fmBez/g4IZUgpcg0T3TNicrumKeVmDzGaobxjS3eMbphmu7suo5pvmJtU+Kfg8NacL6A6X7349NjVPaN8T5gKkFXN4SQ6U4ntm1ldTdydkgpaaoGUkCIyLLdHhSHxI8f/hVjFi63n9jviuIOMi/P71m3kW1bSwqm0oXASmHPVZUFITGmwm8BrQXDdCfkjaauiEnx8cOPWFshKHED5IDzgcrUJTmz2xXDXipfc7duHHYvOL+yufmffomqtvhHQNzx8J66rglpxvuNyvSkJPH+gjHFYX3avQBvTOuvnA4/4uLK7EZMLRnmO2+/vLHvTyQiPkaSdNznv1PZntPuA2leuU9fqZoihGnbmnUbca7kqmzbxun0REqZtv7Avv3IuHxFK8m8rmW8qyQpF6Ob2xzH0wf2rohOvI8oJUs2TPBIJYoM3RjctjKMG03d0nUHBJphmKltS2Urtm2GnNGiASmJOLZtxm0F/nh6OpKJrNuV4DNtp0lULFtAK0NtOkTODMsbVV3j/PYAhb4+fEclL9BaXfY0W4mWqKpEFhver+zqJ+Qj0CyFiI8XQipNKMSM9zOnpxPzNOH8htKW/fGFdXuM+VSFsQ0xZtq+5+vXn9gfTtR1w/l8w00bSnbMU8SFr3y9/EKWgXUdiQRS2LgMP1NVPWTY3IpzDu8y395+IThXIilyLEIjWfauwUVC8Ght2NzEss38/OWvrC4UQ3XaEfDcbxeMUgXUa2uUrEk5MyxXUvT89PO/kVkwuseFAp7MGbZ5RW0jSivG+0rTdtyud376+d8gr1gF59fP9Ls9t/v5YYcofhXnPYhUwuZsjSeQg+T2+c6X158QMuL9iFQBH0eapmfXHbndbrRt4LBriTEhpebd+/e/Pbgy5qL9rrTB+RVJxX5fFS9AiOz3T0j9wF8kB0nRtsfCWUqCbY0Ya3h9vbLNjoTgfHtDV/Dy9EzbQCYSUuDb5b/RVTuaeo9QChE92kjcNiGlYJgGYvQYrSFRGGJaQ05FERFWNjeVU4wUjPcb+85i2x3LPHO9/oqtiwzZmIqcFdZo1nmjOxxIsfgechZ47x9/4MiyDAhhkEphZUXXHEihomufOF9/QSlDVXWFOpt4OJ4LWkQrHjgTqExJtyyNpytLZ22oqyPbUhQ5/jED7+o9KrfEGFiWb9hK8cvXn8vDG1fIAUHG+Q2SQMsGicBauI0TSI2QAWUym5vZdU+EUBpXzpK6Kol3Tf9gthG5jVcyHmUjlcgEr5incmNIWVNVHc4veD9jbEcWEmMrRA5YU5UXoKkY54UUHfv+gNEa1Wo2Vxbb3oGUlmGYOB4PVLZAS/v+9MiYL3nlOSylyRIxwiCFpK8OjPLKOF8LMdpFlJb46Gmqim2JuC0wr3f6bodbHXXd8Xz6gbdLAZKSDUoZpFCs7g0pQYuC36mqHSI2HPpPeOcJ3cp+3zLPRYhABh8yr5fPdF1PzBHv1sJu85pExsXIcL9zOj6hvCEmyfV6wYUZYwr7y6givc55QxtRwu9kTUrg/UYWnl++/X/QWmErXcbLGZQSKFnkoDkFpulKzCtKKfb77p/ZK0optm0lxlRCypq2OLdDaWRNbUsTeqD5ralRoqLd9UxzkWB3TUnf1Lriej0jRLEC1FVL2/ZMc6Rt1SObpy6ju7jSNA3LMqJkCZ/b7949Tr2FTxjzhlKCl5f3hFAc8t6DkAVWmxMFiyQLKRgvSBlcWPny9WfquinCnQfU1ZoWpRS324BQE/O2EFipqrakTaaJGD3aRn75+p9YV0/TFA/SFgakzqQIfb/jPgwMP39GiIhQHmsq+s7i/MCXt5mcBDmnR2ppTYxlvCyVYNsW6rphf9iz+ZG//PRfsdbyP5eFqlEM05m6qjBacrmdqe2JtinWDbdtGAObH7E58Nef/wv7w5EY42OPbAoRZS3mSSEkTQXffv5MrAzZDfzPn3yZunR7Pn/7HwS/smwjdV2xritKGhKSuirPm6k8dV2zbhXGNCUsLwa+fP2VXb+nbYvQxxiLNRajJW/nb79tc7HVvtxUcqapD1jdEVMJRmrqlpQUzo2EuOJDyfreXEabhmVxNHWPrSzPTyfiLiK15sPHU+EJPb8QQmbZBqxSJBdwYeb+dmPXH6nrGu8LH6l6gCaFgHkZsVYTfWRbIodDkSvepzPGWoyxKCUx2pAYud8qdu0H5nTlfDmjrHjg3TPWdgVUmWWBGWrFuo5sYUJqgTANMQbuy1eMLifhnAN994F1teWmJl8eDcShdGa/61mWjXm+0fdtuZ1IUVD22pBTLuqR/YFxuhfkTc4Ikdh1e/xWTExCSi7Xb0hTMOpNbUAmWluzLANKaCprOO6f2TVlnj9vN6yV/9TKRwdW20dCYGHAaRGZpkuhFc8bCIFPI5VpqOyD/jveabs9q1+LkRFNTIX8q3WLjysxQYqeyhoqVdOdTszLBGJmXgpM8j7eSTlRVTXKKLKT7HcnpBggG2IKxLhizQeCz4hsH1k0O67DV1IKVJXGx5XNFclwbYtow/Y141hwLsNSYnVTiCybJ4kRssZKeD1/K0ayWF5mMXk273D+Tl3XCBTpcSjIlIC0EBZOhyeUEiw5si53EAUHpK0BJOREyq6Me9SOWu857N8jsQ80vsPYMh6O2ZFDQCuNlB1aWUY3lrgCI0uU9zKhK0v0hQ0Wc2RzK0o1xfD44NApaXDJE2I5YAQf2fBY0+JdxFr5iCioWNYNkavyebUKgSxKPJWojWaex0eKYiRO+eHWrvHeY4wk+PhIikxAJHhXcnUoB8eilHxjfziRhGCaluL7Cp6mKsRlYwVCFOxNCommrQrZWFm8S+Qk/zmpkLooPXMuQp0QJnI2pFTk29oIhDBoaVDG4L2DVMQzb5evGG3YmY4gMxbFtm30u5a2rSkZUVA1krwlRMjs+jJ9qMwOt0R+/7s/8vr2GR/vWNsSk0fKQKZYF0ASt4StJOO0IVQipUTTSSTl0DYtF3ZdhzU1V3lm2Vaenz/h3IAk8/H9HzC68PtCCJiuRB9kimBDYHBuQWlJ11u8DygpaFvDui7M40xYfdlTdzv604HtOvDy4SPLunK5fS1rCtPRND3aeLzfAE/MQxmp6pIjJBA01Z7KdiAC+50h+sA0zWiV2e12ZOD19fygmP+GzWXfv3C+/or32yP90ZLwxFiujlIoop8LFTaV+WPOnjDPxbEbZrYwl5diX4NQlOCxcsq3psXohowj6sSu3xOCe8D3BCmVHBCpHt6Q4B/jtge3iMiyjsTsqZuS1mbUHsE/5HQTphEIaRGy5nBQZYRjVEkLvN8gl2VhjIFhK9LKXb/nNtwQIpUFetwQoWQtrOtMzDfu8x2lW14OfyZnyWX4iXW9kEJEmdIIINLVLdO6sKwTQmSkUPTtCSk1RnWAx4URIQTOQ86UUYgvue9aWkQWCCJaa0LcULLc2rr2QE6Jb28/0bYd3keMadl8pu97BIrDcc80rQ/j5kjf7ejaPffhQogzu37PMIwYKUixfoACE5sbWFxBhyzrQM6unO7RLPNC2/XYuiLnlWm5MC8D67oW5ZStWdfSEGLeCGkhuExVdQXNv2wYU3xJMXkulzNSK17Pv/J8+oRwuZgj40otd6RYbpApRZp6h5AlmTSlVPZsm8NoiVZwPD7hQ0nQS1mihHos70GpzLI6pusZW0FGkrNCSsM6l0jm6/AZrSTX20zfd+XBlBKlJAlPipm67/F+paqKp8aoCq0L0bmu+4eip+xkxGO8u64jGEu2kWUbkSoRYmRZVlLKvL3deHp6oalOVFXD/f4VFxYqC9tWRhIhLLRNR9M0eB/QuqaqaqZx5XB4YpUenyakluV3S2AesQDLMqFUyelRSpZ922M3pVVTYhS2sYyao3xk7mQ2l/75vVVKsKyFXl3xeN5FZJxLvovWGq1rghf4bUZIC8IQomOc7nTtofirpEcpxfPzO5Z5ZnMepcutoOSWlz1g0zZs60OQERKCcggc5om66ggxFEaYEWhdJg7TvBXETK2ROjNMZ3Ztj/OZ4/Edy3J9mGJrUgpFqp4XlM0M0zc+/vCOaaqoW8vmxgcvMBb/XBb0/R7IHPdH1m2jqlqECHjvqaxF65cS5EcxEj89VQghWZYG72f6Zl+CDi1ARaVLFlPMjpg8AoWxFeM4oaRAVxXaWLZ1RdSCuqqw2uA3z253QijL8all2zyH/VOxSASH6RrmeaJpK3KK+OgZhivH4zNdc2DdJtqm0EFCSBhjiCEjpcJaWw4868rzU2HHSfkb71y+fPsfBQxnFOfbz//MVa/rFiV6tm0tN4VcbrEpRQIZoRLLNj+Wb4oUA8nW9P1TGZ9oybqu1JV+xOsWDMMw3lCyXMecC/iwlh/Y6PJhtC2LK8vz+7LQWIuLni0sKNESfKA2TzRVzWH3ntVNGG24Tp9xzqGtLGl2WNqu3KDWdSHLxDSOKC0J24YLy0PMoCFl+mbPNK/4bUUKQUZSVWXJONy/okyF1pBSTVsdCHFDSs22OaIL2EpjlCJmR0owjGdSutK1zyhhH6FR5UG/jldyjvzuw58YxxGpBePDae1DpK4brDVcb9+QQlBXHT5tJMqNQihfYlcXTwa+fvtS8C3qoVZZHLou8ugtTNx+faWqanxckfOEC8Vp3tU1B90gRUUMhSqQs0CpispWRB8ISJCSxWWMcWxpIjrB+/aEc5H3737H9faVab4ipSgnvnFAiPKznC9f2NzG6dQxTBeycFhT0Zgj83qFvJa/Ty5wHyHLwn4aC9bEWFvGgdry/PTMNC2sm0fKVAQVLj72M+XGK2TBkdSVoW8PbKGIAbbVFeryYc/r2zcyhXqdSWjdczr8nrfzN5z7grELr+efEEJgrHnkyTjIkpRL09O6wZoOIe/l5C8iSjaEEInJ4R8vbICu64s0Wde4EEhsrC4gtSRsM6+fP/N0ek/wEVNJVj8gVSjUipAJvszUnZ8Let1kYgqoqqKuFEol5uVOTB4rLLf7wm73RMzlIKOEpKl3TPMbMZbD1X53IISM967EUQSHqQrjzbkBpU3x2TjHuq3UEqSg2A6EemDzKxDl35CK8m+YCu8UWh5p645lOaOUpusq3s5fiypPaHKMiKzIaIxpUbo00qImdQ+46FTQUGuZbKRQVJkpB+r6EcubNIfdE8s0gBIoJbCmR0oKZVkIUvT4sOL8Ss6Sb28Pi8G8sG4zXddT1xXLvJCRCJVobIsU5vEsFg5g10rGceTl+Qe2bWNZ77RVybR33lHXFU3V8HL8HdM8M283do/Yi7qqGeY7KRV8VUqZ0+mZaZqwVVFvGq2L8jZ66rrH+ZLRMs/LY3Tt0cqw60/8+vl/EMJI3+8Q0rM/dCi9x1qB1pa+7zHWQFbsD8/FFqLK87kuIzEENreQsy7vSyGJ/je+uYQ4oXLFsExYK3BhY14mtK5o9gfINdu0IESC5NFSkdDEuJJyoLIt83JDa8GyOLz3CGlJj+x6F4fHwtqhlELKhHeezRsqW6KKQwykIRNTZHUTIQWkKnNnW/Vsa6KpDni3ErxjXWekAGSNUcWEGcIKRFIqSrb2+MS6Jkg14Pj89VfqpsVKU5zvfkDLjsY+MU1nAhlrGnwqX4R5HKhNIufI7D9DgBQLRoSsESlhRMl4jylxtE+M84jzMzEnjDKIf8yl+wMxOKZ1pqr2SCUejfZOzonbMGGtZl1njLGFbhpKoJbSFuczQgoWdyXjmNaJ2u457v7Iut2LAKLuWZaJjCSlxOX2K1lGlqXQcZumYxivdK1C5owQFiX+4eU4MowapYr3hyzYpERrXU6SUXLYv3/MjxVNV+IBqkowTTesMaSqJonANN2KNLPpGaYBYyukLg77GIsicJxvrNKhtKbR7WPmD1IKlC47q5gCy3Yj5bIbMKphXRfuw42qMrRdWWwKJNpK7sMr9/GCUNDUFpLE6gMxlTRIskQpwzRt3MaFp6cTFZGUCxl813/iNizgLqS0IlVAiBqj+kLBtQ1VfQJg8wU2mLH/JDlsm+e4+8S8nsmp3MqneUFpha1aQkq44AnRIUM5SbZNQ140p+NHyJqYBsLiOO6fHiFmCh8CUkmG4U7fZ7pdxfV2oWlqjNEs04QPHlsVhZlzG0pJ3GNhvT/0XG9XnC+xA1VVhBNG79mWBWt08f1Mdw77J8bpxjyPPD+9MA7bI+21ZduWIvlXinV1tM2OHDLeBw6HIykH9jtBSgHvPF3fMUxf8G57LMol1tRM84jZtShpUSiOxxOX4RvTMmJMeTFWtsIYg1YFmqpUwTv13UMNlcCqx0sxl4hgLTNbcMQ0U9WG9e7pzI6cJFuIxY9jSuKpFAXcqE2Fqcv3XSlD0wq2bcWHDasr2vbIfXpjdV/LbUO3SCVLMNk8YCoYl3vhg8WScROdZAsBoTJaS6TU7I8dAtjihrbin2m2CMHp+Zl5mkgpoYwihlCQQCmz379wud4IuUQ8SJ053z8jB8WyzXT1O477HxnGb4QwM0w3rK0gS2LM5CyY5ju38UxVWaI3rFtC61x8d9KSU+Trt7/j/cbT6eNv21xizFSVwhejPVppdGvY3MC0fCOEXF4qztPUBlvVbC7h/VayzqVBqKqky1UCKFeuZV3KIjm5B3LAAuWUE5NDq4L117qibTtCiNSaooPXTWlcWuNcJEVJV/coLEaBkoplW6iqihAe2AalEcYwrzPHwzPDOCFFMV6+vJwIwaHyQycsFMErcpDs2o5x/Jmqsex2R1TSKFFiZpfljlCxLCmloTXPhAi36RsxJP5xiwwpI2SHD/MDamdID7VYVSmm9UzdVogN+r5nXTe0MSyPE0nXdSVVUraPE/gZIQMCjTUt0zwxLze6rqZve5yzkCyVabjdv9HUPZXdE5yiaSqG+5W2a9jCikByvdxIUdA01eOKnGnrhhjLLH6eS0KdcwVWWVcNSpURSXyYVP+RAf/ph38lRVUMriZwG96wxtC1PfM6oXUx2Z4vr9RVR1UViOi6lR2JoMKFmTUN9N2eHDTDMNK2Nc/PL9yHK1O4Mc8D2io2FwpZWxYac9MYMuKxE9whkI9mXXE4PBHTRsqFCr36jWmegcyPn/7Ar5+/sPgV+8gNqVTH7X5Gq8zfv/4nvrz9wqePn1jWOzGt5FyAiodDUdJtW6FWaK2Z5ht931NVZbbddye0ammqhPMb1qgS3Z0SUhrGcSqnaV2SU7333PzKfvceparHnoTyEGZDDLI04uGM3Zd01X+8NJqmMO6c99RdxzxPWGv/+Z/TPDKvC/vdgdv9yjzfaLuKlGDbZJG3ZvFQUwacX7FW43wZNVZVxeVyKeIIqfEu4H2ibXqmeSoYKNtg6op5nYkBMgarjhz6j3w7/8Rwu6GNxKjqcdvIjPNEXTcFcRNXMBU/f/4LWa54v7FuHmstTdXjfUTrjhA8fnP4KmJ0+V3HceDHT38kpIWYPdf7V5QsKr0Qb8xLpm5KfLNznqZpAP0QWUSyyI8IgTvOj4UG7rci9TYNMsO6bUhGjG6wypTPaRvJSZLYUCaT8sq6DdS1JRPIGeq2hO2FOEP2bKtgWUss+DheUUbQ1M3DJDwzvL1RV0W0kFJkXlfqukFImOYSrXE8PLHMI/eh7Ld0bRF+IYmR1Z9JcmTbCnBYmwrvAiEuj/TcivtYnm+BpOka5vH2TwxWXfWkeUPpTErxt20uUhYKa8mk1g89tUMqyW34TM6KlCNN1zKOC7dxpasavIt0p55huAOmKEBSYPOe1hqU20omScxkmVjCStvukTJjbZkj51ROcLZSGK0RKkEOdM2uRObmzLiO5QuRIlZ3YAohN8bIum2PP2oZg9V1xzBPzOuCVqbMjqsyYjntXwhupm53jPNWQsncyuX+C4fTsSx7oyT5jLSU8VvTEdKGcxPJQ9X3hGlldXdcWGnrAtycl5Xb8gVTa3bmVJINU7nVkQrU05oibW6bmpwUlW2YxjLbluhyAtsfWdc7ldpRN4aQAsN0KbuXvmeZVqw2BVsSHL98/c8458ns6btnYogPOB0P9H7F06lkhoTokBQ21+lwepzW1MP7wUMtFAsGJfkHUsXhoyf4jTpXZSS1ONpmDzITs8fYmrraYUxFGGakykCibbvCAiMXZ3gSpFx0/TlDTAkhKoxW7HcntBEFiZ80MXu6fk+KAts2KKGxpkLISEyeeZpQ+kgmF5GAkChRI7Xh9e0nEkVheL79ijY1KSje3i5FXeU9fb9nZ49E4QltQNnMt/NfyaKo/oIHqRSZMjowNheKs1A09Q5tDFprtm0kxvKz5WRQ2hJzTWc6QthQaiEFx3Afadq6jNOMRSmIruD/Y3ZEH9BKEWNFv+vY1pW6brlczgXWui6kBG27x/tAcg5kZHMbShe1mfcl+mL2HmM6Ig5TtcScqZoWiaWqLMYoQlx5Pf8bXdejZIWhKc/LMhbSBeaBb2kYpxkhFX1XfqfD/olxvCOEYt1WhuFC13WPSAHN5fIFmDE2U9mKpt7x9vaGsQpjVGmiUlDVDcEHonQYBTpr/OIJPhFkUXR2xwO360DKiWla2O1q6qojhsiX11/QWrBtE01bs+ueWF25nRmtUKIipol1G7G2IkXBsq7UdYkvnqYFYyS3exnFex+p6vYRt31gHM5oUzbDUlTY6kBTJ75++8wwDEgpSDnQdc1Dii1xrjwrt9srWnus0WjZ4GJicytVU+O8xz/MonIpdGwfQASN0hUpC0LMiIcFQCnDtq5IlZGKEn+8eQ67Z8gV43Rl2e5FQHV6LpMKpRinO0/7T3TWooRAyrpMpaY79+HGu5f3/1Ry1nXFNM3k/BuPxZQUuG0lhUCla5Q1rNvE5hbquriW26ogT6KVeOeo6ydcyEzTgpIGozRWl3jb2/0NqYvZsK4bpmlmXWdqu+f58HuG6TPaaqZ5BDxSlRn7fbrR73YIqXF+ZRlGjk9HZFBcbhesqZGkx0PtqWyL0oqYJPM8onVimies1iVRT5yQKEq2VEAbSQgSgcDqGqIkJ09MC4qMVmUOvIWZrCrari0mI6lQyqCN4jp9IYWMVgZp6rKsjqGcJJOm755w3pG5sQXPrn1GJc20XHFhKtiZ4UYIni1ckboQar1L3IcbPnpSWuibPQqFCzdu0xu2UmW5K1sO+w+klKgrOB1LhGvwmfv9ivMrX7/dMFoyb5HKtmhTFxx615NTJiVB3zzzev4ZW6nHQxKRQmKtZXMr6zaSUsa7hc2NaAvzbSWGSF+fqGxdRnR5Yt8/U5tnbsNnEJm27UuMrDJM60DOnq7d451EuJmU3QPa2RDjRkrQ93vG6YLRkr4v0cZalZGdtQ3LOpBSOfQIpXAhsTmPC+V2ty4zWhrevXwgusgURnJIhDjh74GXpz9itMZ0B2rbopQFIdjcWMK9YuKwO6KVoq1PKNExTJ9x4U5VFxVUXbXl9qsFIQi6dse6Dmw+cNj9gKKIS7JwjNNC17VoXZzjPoTHbcGzLSs+BUxVMc0j4zrQmg4hKLyrZSiR4e0BpQ2kSExriQtI5XsKihjdw/BKOZGamqA9t7vjj8//wufzz0zTTN8ZRG5Yl42u2RND4eRlEvfbW8GtdyfGccJYjQ8ZYzru9zPOv/L8/BFrO4J3LIsvfrOc0EaWoC+bkKowvYwVhLgR1khTNUhlOF9e2cJKyAqELFHkVuNDIPiA0pISb2Cp7K642LVAIBmmAVsbdHUoBumU2HcHrGoYtis5zY8xmSLlCik3pttMVXVsa5FH9+1TyYzaPDFFQtSPHXGGCG3zhBSRpqmQqiojxlzRNS05JXx0hJxZnUcBq9tKfPi2gpBIITG6LrfduOG9oH5wECWG2h5h9ax4fAj84dN/4H67EmIi5JXD/hMxjgRXxu6VLQbYp+cfWbaJjGddzggl6bsT3kFKC35NvH93xAVHTAspaXLK7PsjyzpTN115P8ZUoo4DoAPny4W2rairst+qqwqtLDk23O6X37a5LEug7VqyjWQKoM6oBlmph17f0NR7pnEpUbyNfhCSNd4njKmRWj1YUi3Pp/cMw4A1kb6zVFVFzpGYC3rchwK7XNe1xCArTcoBJTRhiazzyiImlBbM6/aQ41bF75EjtWpYtg2pK2Sy7PsXlqWgFZqmwzmBsRVVXSNEZlgGEJHbdGEcb8jhja49FvJvTGgtSySvUnhXsPbbNtG3ewSJab2y3x+43S4oIRHaF4WbtqR/qEwQD6ZZwHnH7XYl5A2C4unwnm5/JAyeGLaiIpGRlDxV1UBKj8wSy7xekCLjjKVrTkVll3LBkjQdKRYHr1TiEQpUgbBkNXObf0EpS1vVBB8wslCnp2V6zGEzMSbquuH17WdiWtHqgHggybvDgXmeud2uCJmRQnPoX7jlRGTA6Lbkc6eVcf5CziPkRwNa/84wfinRCSGz5oW2DXg3UlcNQkQSnixiefnEQJjLGKFpmhK9IHVZkGeFRGNUTdceijvbapq653IbEElz7E9ALoyx/gnT7R6su46q8ghrSTGwrne0CpAyu/ZAdAqjHOfrF2bpqVuDSBmlJcZY7sOEzGPxYQlL17bM6xmjaqrqRFUVX8gyD9T7uogEcmSc3tCyZNQYKwq6PTikSsiUaU1DCGBtB2zkbSX4wK470NQ163rHRU9ld+U5cDMxrggSu37HshQasxRllyQEpADW1KQYUMqwrEUJZypY1itWC5QsI9HT6R3BC2J2rG6mrmsIkSwckY37/AoiYdWB2h4RQnDNX8oObb6xbQXYWVf6kYUSHiKMWBbDW0brwDjfkdRFqbQMeL/hQlFrQaZ63NK1MFSNYMwXXPD07dMjHiHjtivObdRVxXC/FYm7MgVqmwObNdzHO6gSASyQ7PuSBut94Ol0IoR//PePjGNZ2r/7cOTXzz8V5Z9WD5HBASVXprlktni/kWNGqo5lKVHYtjIPz13GRV+yWUSNEgnnNqZxYNcLmrpmnFY+fvzEOs+MyxUfiy/q+eUj69eN1Y2M05WYPDllrK4QydLWTyxp5nx75enlPffbzG26MQzXgvkRisoUGKvfBgQtW/C8Xb9hTKFZ9N27ogQTDYJygzq7z0zTHWtMmaLIjDaSqrYs24R3+QGEPfDp00cul9fftrmcTs+s60hGoFQJtBJCl8WPajC6wzuBMUWNdB9eyawsm0dLw/F4LE5Tt+JdoKm6R+hRoahK6Qo+QUmm5a3MjNt/SC03tkc2iZYtp8MTu7bj9faNkBzTXPK5jTGkR5RtypmYQ3HXrglSMSmFVFzlbVtyoK+XN7SusKYrsEM8IUmMhmUbio8jBNq2p66acg3vdsRYcR0+c7m8suuPtE3LNF9xbuawPxBCUVbFXLIQqqoh5xI/oGRNVVdokxFJIQSM88DmFrQuaYA+bGSRiG4jx4RQIIVCG00td2glmNYbLsxo3fLDxz9yubySkqGqGsbpjIuBRHGubyGyrGe0icQQGUNZXh+P75imCW0UwWekLPuuZVkfC++I957j7pllmpinkW0rCP2Xl3cQK3ISjHIk5pWqahAYmtYSUyALUwCeHna9BdGjtUFkifOOYRywVpeTl5twD4OnlIIYEsfDiXV1pJjZNod97KnIvrxMSNzur2x+efz9Fd5HJDzGrcUsJ4VAm6Lae337CgiSEFhTTLdaG6RVnIc7h/4dl7df2PIdjUKpFi17pMq4dcXqiixGLvfLA5Oy4n1kTGP5/G1DSJHn0/uCOLEtGbCVxrsVYzLOLVRVz7ZNIMpN25qKumq4Xt+oaoNzGUJCoZGoEn51u/C0r7HGst/vGO4XmqZFUBhd67aSo+ewe8cw3+n7HdN0w8UZRGJ/2LNuGyjJbt+h19LsrK1K9EFKOF+8M+ERC1GgpYK2atjcyjQtfHz6HavbQEJt+5Lz5BNZJrQUaFmaZ4mnDljbYbQAkQhhBq/43csHvm4zMQW6vuS/SCGKEXeLHHYvjMsNH0riawwOHwK3+w0fViprmJdM03RYW2NNhVEV93FiGO40bc0wlc9A5JLd03Qt8/mNdZhpmo62K4SKdVsY5ysxL4+FfkAbRQqpmEGVAgJSapTUYGCar6zbI+JBZqxpsarh29sdreqyixI1VZU5HPZUpmNd72zbxuX+CjGACBhrkDrzl5/+G8pk3r+ciDHgeIyvgabqWLc7iHJouF4uhJC5xAUICNnT9x21PZBSYtETx/4HQtoI0RWDevBUxtLVLTFq9ONmPi0DdaMfrEZJDAlb1YQQSjqu0CUtV8I4DozT9X+pZ4j8D23n9/pe3+t7fa/v9RuV/P/1D/C9vtf3+l7f6///6ntz+V7f63t9r+/1m9f35vK9vtf3+l7f6zev783le32v7/W9vtdvXt+by/f6Xt/re32v37y+N5fv9b2+1/f6Xr95fW8u3+t7fa/v9b1+8/reXL7X9/pe3+t7/eb1vbl8r+/1vb7X9/rN6/8EVTCXCgdGUowAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "IMG_PATH = \"examples/img1.jpg\"\n", + "\n", + "import onnx\n", + "import onnxruntime\n", + "\n", + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from time import time\n", + "from PIL import Image\n", + "from torchvision.transforms import transforms\n", + "\n", + "from vit_utils.visualization import draw_points_and_skeleton, joints_dict\n", + "from vit_utils.dist_util import get_dist_info, init_dist\n", + "from vit_utils.top_down_eval import keypoints_from_heatmaps\n", + "\n", + "def to_numpy(tensor):\n", + " return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()\n", + "\n", + "ort_session = onnxruntime.InferenceSession(output_onnx)\n", + "\n", + "# Prepare input data\n", + "img = Image.open(IMG_PATH)\n", + "\n", + "org_w, org_h = img.size\n", + "print(f\">>> Original image size: {org_h} X {org_w} (height X width)\")\n", + "print(f\">>> Resized image size: {H} X {W} (height X width)\")\n", + "print(f\">>> Scale change: {org_h/H}, {org_w/W}\")\n", + "img_tensor = transforms.Compose (\n", + " [transforms.Resize((H, W)),\n", + " transforms.ToTensor()]\n", + ")(img).unsqueeze(0).to(device)\n", + "\n", + "\n", + "# Feed to model\n", + "tic = time()\n", + "ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(img_tensor)}\n", + "heatmaps = ort_session.run(None, ort_inputs)[0]\n", + "# heatmaps = vit_pose(img_tensor).detach().cpu().numpy() # N, 17, h/4, w/4\n", + "elapsed_time = time()-tic\n", + "print(f\">>> Output size: {heatmaps.shape} ---> {elapsed_time:.4f} sec. elapsed [{elapsed_time**-1: .1f} fps]\\n\") \n", + "\n", + "points, prob = keypoints_from_heatmaps(heatmaps=heatmaps, center=np.array([[org_w//2, org_h//2]]), scale=np.array([[org_w, org_h]]),\n", + " unbiased=True, use_udp=True)\n", + "points = np.concatenate([points[:, :, ::-1], prob], axis=2)\n", + "\n", + "# Visualization \n", + "for pid, point in enumerate(points):\n", + " img = draw_points_and_skeleton(np.array(img).copy(), point, joints_dict()['coco']['skeleton'], person_index=pid,\n", + " points_color_palette='gist_rainbow', skeleton_color_palette='jet',\n", + " points_palette_samples=10, confidence_threshold=0.4)\n", + " \n", + " plt.figure(figsize=(5,10))\n", + " plt.imshow(img)\n", + " plt.title(\"Result\")\n", + " plt.axis('off')\n", + " plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.17" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/to_trt.ipynb b/ViTPose/easy_ViTPose/easy_ViTPose/to_trt.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ba395d4f715da36bfa8d316fe2c13e16a2c081ef --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/to_trt.ipynb @@ -0,0 +1,327 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import tensorrt as trt\n", + "import onnx\n", + "import onnxruntime\n", + "\n", + "from vit_models.model import ViTPose\n", + "from configs.ViTPose_coco import model_small as model_cfg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ONNX to TRT" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def export_engine(onnx, im, file, half, dynamic, workspace=4, verbose=False, prefix='Tensorrt'):\n", + " logger = trt.Logger(trt.Logger.INFO)\n", + " if verbose:\n", + " logger.min_severity = trt.Logger.Severity.VERBOSE\n", + "\n", + " builder = trt.Builder(logger)\n", + " config = builder.create_builder_config()\n", + " config.max_workspace_size = workspace * 1 << 30\n", + " # config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, workspace << 30) # fix TRT 8.4 deprecation notice\n", + "\n", + " flag = (1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))\n", + " network = builder.create_network(flag)\n", + " parser = trt.OnnxParser(network, logger)\n", + " if not parser.parse_from_file(str(onnx)):\n", + " raise RuntimeError(f'failed to load ONNX file: {onnx}')\n", + "\n", + " inputs = [network.get_input(i) for i in range(network.num_inputs)]\n", + " outputs = [network.get_output(i) for i in range(network.num_outputs)]\n", + " for inp in inputs:\n", + " print(f'{prefix} input \"{inp.name}\" with shape{inp.shape} {inp.dtype}')\n", + " for out in outputs:\n", + " print(f'{prefix} output \"{out.name}\" with shape{out.shape} {out.dtype}')\n", + "\n", + " if dynamic:\n", + " if im.shape[0] <= 1:\n", + " print(f'{prefix} WARNING ⚠️ --dynamic model requires maximum --batch-size argument')\n", + " profile = builder.create_optimization_profile()\n", + " for inp in inputs:\n", + " profile.set_shape(inp.name, (1, *im.shape[1:]), (max(1, im.shape[0] // 2), *im.shape[1:]), im.shape)\n", + " config.add_optimization_profile(profile)\n", + "\n", + " print(f'{prefix} building FP{16 if builder.platform_has_fast_fp16 and half else 32} engine')\n", + " if builder.platform_has_fast_fp16 and half:\n", + " config.set_flag(trt.BuilderFlag.FP16)\n", + " with builder.build_engine(network, config) as engine, open(file, 'wb') as t:\n", + " t.write(engine.serialize())\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "ONNX_PATH = \"ckpts/vitpose-25-h_onnx/vitpose-25-h.onnx\"\n", + "TRT_PATH = ONNX_PATH.replace('.onnx', '.engine')\n", + "C, H, W = (3, 256, 192)\n", + "\n", + "input_names = [\"input_0\"]\n", + "output_names = [\"output_0\"]\n", + "\n", + "device = next(model.parameters()).device\n", + "inputs = torch.randn(1, C, H, W).to(device)\n", + "\n", + "dynamic_axes = {'input_0' : {0 : 'batch_size'},\n", + " 'output_0' : {0 : 'batch_size'}}" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[05/04/2023-11:25:45] [TRT] [I] The logger passed into createInferBuilder differs from one already provided for an existing builder, runtime, or refitter. Uses of the global logger, returned by nvinfer1::getLogger(), will return the existing value.\n", + "\n", + "[05/04/2023-11:25:45] [TRT] [I] [MemUsageChange] Init CUDA: CPU +0, GPU +0, now: CPU 4253, GPU 1346 (MiB)\n", + "[05/04/2023-11:25:45] [TRT] [I] ----------------------------------------------------------------\n", + "[05/04/2023-11:25:45] [TRT] [I] Input filename: ckpts/vitpose-25-h_onnx/vitpose-25-h.onnx\n", + "[05/04/2023-11:25:45] [TRT] [I] ONNX IR version: 0.0.6\n", + "[05/04/2023-11:25:45] [TRT] [I] Opset version: 11\n", + "[05/04/2023-11:25:45] [TRT] [I] Producer name: pytorch\n", + "[05/04/2023-11:25:45] [TRT] [I] Producer version: 1.12.1\n", + "[05/04/2023-11:25:45] [TRT] [I] Domain: \n", + "[05/04/2023-11:25:45] [TRT] [I] Model version: 0\n", + "[05/04/2023-11:25:45] [TRT] [I] Doc string: \n", + "[05/04/2023-11:25:45] [TRT] [I] ----------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3056/1333021398.py:11: DeprecationWarning: Use set_memory_pool_limit instead.\n", + " config.max_workspace_size = workspace * 1 << 30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensorrt input \"input_0\" with shape(-1, 3, 256, 192) DataType.FLOAT\n", + "Tensorrt output \"output_0\" with shape(-1, 25, 64, 48) DataType.FLOAT\n", + "Tensorrt WARNING ⚠️ --dynamic model requires maximum --batch-size argument\n", + "Tensorrt building FP32 engine\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3056/1333021398.py:38: DeprecationWarning: Use build_serialized_network instead.\n", + " with builder.build_engine(network, config) as engine, open(file, 'wb') as t:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[05/04/2023-11:26:01] [TRT] [I] [MemUsageChange] Init cuBLAS/cuBLASLt: CPU +1, GPU +10, now: CPU 6720, GPU 1356 (MiB)\n", + "[05/04/2023-11:26:01] [TRT] [I] [MemUsageChange] Init cuDNN: CPU +0, GPU +8, now: CPU 6720, GPU 1364 (MiB)\n", + "[05/04/2023-11:26:01] [TRT] [I] Local timing cache in use. Profiling results in this builder pass will not be stored.\n", + "[05/04/2023-11:26:16] [TRT] [I] Detected 1 inputs and 1 output network tensors.\n", + "[05/04/2023-11:26:19] [TRT] [I] Total Host Persistent Memory: 6448\n", + "[05/04/2023-11:26:19] [TRT] [I] Total Device Persistent Memory: 1536\n", + "[05/04/2023-11:26:19] [TRT] [I] Total Scratch Memory: 13172736\n", + "[05/04/2023-11:26:19] [TRT] [I] [MemUsageStats] Peak memory usage of TRT CPU/GPU memory allocators: CPU 0 MiB, GPU 0 MiB\n", + "[05/04/2023-11:26:19] [TRT] [I] [BlockAssignment] Algorithm ShiftNTopDown took 0.031095ms to assign 3 blocks to 7 nodes requiring 17301504 bytes.\n", + "[05/04/2023-11:26:19] [TRT] [I] Total Activation Memory: 17301504\n", + "[05/04/2023-11:26:19] [TRT] [I] [MemUsageChange] Init cuBLAS/cuBLASLt: CPU +0, GPU +8, now: CPU 9123, GPU 3804 (MiB)\n", + "[05/04/2023-11:26:19] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in building engine: CPU +0, GPU +0, now: CPU 0, GPU 0 (MiB)\n", + "[05/04/2023-11:26:21] [TRT] [W] The getMaxBatchSize() function should not be used with an engine built from a network created with NetworkDefinitionCreationFlag::kEXPLICIT_BATCH flag. This function will always return 1.\n", + "[05/04/2023-11:26:22] [TRT] [W] The getMaxBatchSize() function should not be used with an engine built from a network created with NetworkDefinitionCreationFlag::kEXPLICIT_BATCH flag. This function will always return 1.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "export_engine(ONNX_PATH, inputs, TRT_PATH, False, True, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inference with TRT model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading cached TensorRT engine from ckpts/vitpose-25-b.engine\n", + "input_0\n", + "output_0\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import pycuda.driver as cuda\n", + "import pycuda.autoinit\n", + "import utils_engine as engine_utils # TRT Engine creation/save/load utils\n", + "\n", + "from time import time\n", + "from PIL import Image\n", + "from torchvision.transforms import transforms\n", + "\n", + "from vit_utils.visualization import draw_points_and_skeleton, joints_dict\n", + "from vit_utils.dist_util import get_dist_info, init_dist\n", + "from vit_utils.top_down_eval import keypoints_from_heatmaps\n", + "\n", + "TRT_PATH = \"ckpts/vitpose-25-b.engine\"\n", + "\n", + "# SETUP TRT\n", + "logger = trt.Logger(trt.Logger.ERROR)\n", + "trt_runtime = trt.Runtime(logger)\n", + "\n", + "print(\"Loading cached TensorRT engine from {}\".format(TRT_PATH))\n", + "trt_engine = engine_utils.load_engine(trt_runtime, TRT_PATH)\n", + "\n", + "# This allocates memory for network inputs/outputs on both CPU and GPU\n", + "inputs, outputs, bindings, stream = engine_utils.allocate_buffers(trt_engine)\n", + "\n", + "# Execution context is needed for inference\n", + "context = trt_engine.create_execution_context()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>> Output size: (1, 25, 64, 48) ---> 0.0242 sec. elapsed [ 41.3 fps]\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Prepare input data\n", + "IMG_PATH = \"examples/img1.jpg\"\n", + "img = cv2.cvtColor(cv2.imread(IMG_PATH), cv2.COLOR_BGR2RGB)\n", + "org_h, org_w = img.shape[:2]\n", + "img_input = cv2.resize(img, (192, 256), interpolation=cv2.INTER_LINEAR)\n", + "img_input = img_input.astype(np.float32).transpose(2, 0, 1)[None, ...] / 255\n", + "\n", + "# Copy it into appropriate place into memory\n", + "# (inputs was returned earlier by allocate_buffers())\n", + "np.copyto(inputs[0].host, img_input.ravel())\n", + "\n", + "# Feed to model\n", + "tic = time()\n", + "bs = 1\n", + "# Fetch output from the model\n", + "heatmaps = engine_utils.do_inference(\n", + " context, bindings=bindings, inputs=inputs,\n", + " outputs=outputs, stream=stream)[0]\n", + "heatmaps = heatmaps.reshape((1, 25, 64, 48))\n", + "\n", + "elapsed_time = time()-tic\n", + "print(f\">>> Output size: {heatmaps.shape} ---> {elapsed_time:.4f} sec. elapsed [{elapsed_time**-1: .1f} fps]\\n\") \n", + "\n", + "points, prob = keypoints_from_heatmaps(heatmaps=heatmaps, center=np.array([[org_w//2, org_h//2]]), scale=np.array([[org_w, org_h]]),\n", + " unbiased=True, use_udp=True)\n", + "points = np.concatenate([points[:, :, ::-1], prob], axis=2)\n", + "\n", + "# Visualization \n", + "for pid, point in enumerate(points):\n", + " img = draw_points_and_skeleton(img.copy(), point, joints_dict()['coco']['skeleton'], person_index=pid,\n", + " points_color_palette='gist_rainbow', skeleton_color_palette='jet',\n", + " points_palette_samples=10, confidence_threshold=0.4)\n", + " \n", + " plt.figure(figsize=(5,10))\n", + " plt.imshow(img)\n", + " plt.title(\"Result\")\n", + " plt.axis('off')\n", + " plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.17" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/train.py b/ViTPose/easy_ViTPose/easy_ViTPose/train.py new file mode 100644 index 0000000000000000000000000000000000000000..8b25629805235a94dc8263b88855d28c9060f0c2 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/train.py @@ -0,0 +1,174 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import copy +import os +import os.path as osp +import time +import warnings +import click +import yaml + +from glob import glob + +import torch +import torch.distributed as dist + +from vit_utils.util import init_random_seed, set_random_seed +from vit_utils.dist_util import get_dist_info, init_dist +from vit_utils.logging import get_root_logger + +import configs.ViTPose_small_coco_256x192 as s_cfg +import configs.ViTPose_base_coco_256x192 as b_cfg +import configs.ViTPose_large_coco_256x192 as l_cfg +import configs.ViTPose_huge_coco_256x192 as h_cfg + +from vit_models.model import ViTPose +from datasets.COCO import COCODataset +from vit_utils.train_valid_fn import train_model + +CUR_PATH = osp.dirname(__file__) + +@click.command() +@click.option('--config-path', type=click.Path(exists=True), default='config.yaml', required=True, help='train config file path') +@click.option('--model-name', type=str, default='b', required=True, help='[b: ViT-B, l: ViT-L, h: ViT-H]') +def main(config_path, model_name): + + cfg = {'b':b_cfg, + 's':s_cfg, + 'l':l_cfg, + 'h':h_cfg}.get(model_name.lower()) + # Load config.yaml + with open(config_path, 'r') as f: + cfg_yaml = yaml.load(f, Loader=yaml.SafeLoader) + + for k, v in cfg_yaml.items(): + if hasattr(cfg, k): + raise ValueError(f"Already exists {k} in config") + else: + cfg.__setattr__(k, v) + + # set cudnn_benchmark + if cfg.cudnn_benchmark: + torch.backends.cudnn.benchmark = True + + # Set work directory (session-level) + if not hasattr(cfg, 'work_dir'): + cfg.__setattr__('work_dir', f"{CUR_PATH}/runs/train") + + if not osp.exists(cfg.work_dir): + os.makedirs(cfg.work_dir) + session_list = sorted(glob(f"{cfg.work_dir}/*")) + if len(session_list) == 0: + session = 1 + else: + session = int(os.path.basename(session_list[-1])) + 1 + session_dir = osp.join(cfg.work_dir, str(session).zfill(3)) + os.makedirs(session_dir) + cfg.__setattr__('work_dir', session_dir) + + + if cfg.autoscale_lr: + # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) + cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8 + + # init distributed env first, since logger depends on the dist info. + if cfg.launcher == 'none': + distributed = False + if len(cfg.gpu_ids) > 1: + warnings.warn( + f"We treat {cfg['gpu_ids']} as gpu-ids, and reset to " + f"{cfg['gpu_ids'][0:1]} as gpu-ids to avoid potential error in " + "non-distribute training time.") + cfg.gpu_ids = cfg.gpu_ids[0:1] + else: + distributed = True + init_dist(cfg.launcher, **cfg.dist_params) + # re-set gpu_ids with distributed training mode + _, world_size = get_dist_info() + cfg.gpu_ids = range(world_size) + + # init the logger before other steps + timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) + log_file = osp.join(session_dir, f'{timestamp}.log') + logger = get_root_logger(log_file=log_file) + + # init the meta dict to record some important information such as + # environment info and seed, which will be logged + meta = dict() + + # log some basic info + logger.info(f'Distributed training: {distributed}') + + # set random seeds + seed = init_random_seed(cfg.seed) + logger.info(f"Set random seed to {seed}, " + f"deterministic: {cfg.deterministic}") + set_random_seed(seed, deterministic=cfg.deterministic) + meta['seed'] = seed + + # Set model + model = ViTPose(cfg.model) + if cfg.resume_from: + # Load ckpt partially + ckpt_state = torch.load(cfg.resume_from)['state_dict'] + ckpt_state.pop('keypoint_head.final_layer.bias') + ckpt_state.pop('keypoint_head.final_layer.weight') + model.load_state_dict(ckpt_state, strict=False) + + # freeze the backbone, leave the head to be finetuned + model.backbone.frozen_stages = model.backbone.depth - 1 + model.backbone.freeze_ffn = True + model.backbone.freeze_attn = True + model.backbone._freeze_stages() + + # Set dataset + datasets_train = COCODataset( + root_path=cfg.data_root, + data_version="feet_train", + is_train=True, + use_gt_bboxes=True, + image_width=192, + image_height=256, + scale=True, + scale_factor=0.35, + flip_prob=0.5, + rotate_prob=0.5, + rotation_factor=45., + half_body_prob=0.3, + use_different_joints_weight=True, + heatmap_sigma=3, + soft_nms=False + ) + + datasets_valid = COCODataset( + root_path=cfg.data_root, + data_version="feet_val", + is_train=False, + use_gt_bboxes=True, + image_width=192, + image_height=256, + scale=False, + scale_factor=0.35, + flip_prob=0.5, + rotate_prob=0.5, + rotation_factor=45., + half_body_prob=0.3, + use_different_joints_weight=True, + heatmap_sigma=3, + soft_nms=False + ) + + train_model( + model=model, + datasets_train=datasets_train, + datasets_valid=datasets_valid, + cfg=cfg, + distributed=distributed, + validate=cfg.validate, + timestamp=timestamp, + meta=meta + ) + + +if __name__ == '__main__': + main() diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fede801f63d9e0aaba60feba0d1565f86327347a --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__init__.py @@ -0,0 +1,8 @@ +import sys +import os.path as osp + +sys.path.append(osp.dirname(osp.dirname(__file__))) + +from vit_utils.util import load_checkpoint, resize, constant_init, normal_init +from vit_utils.top_down_eval import keypoints_from_heatmaps, pose_pck_accuracy +from vit_utils.post_processing import * diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..979fc9211c23f1958b9b517b4486dd7ed1b8862d Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/model.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/model.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4cc44034156fa4ce4e8bb8686f127047117661b4 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/model.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/optimizer.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/optimizer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75c6bcea0e5c0f82636daf78141c859091f1df55 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/__pycache__/optimizer.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/.ipynb_checkpoints/vit-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/.ipynb_checkpoints/vit-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..f2191252b676160526e89df227aa1e8a02d48465 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/.ipynb_checkpoints/vit-checkpoint.py @@ -0,0 +1,397 @@ + +import math +import warnings + +from itertools import repeat +import collections.abc + +import torch +from functools import partial +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint +from torch import Tensor + +# from timm.models.layers import drop_path, to_2tuple, trunc_normal_ + +# from .base_backbone import BaseBackbone + +def drop_path(x, drop_prob: float = 0., training: bool = False, scale_by_keep: bool = True): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + + This is the same as the DropConnect impl I created for EfficientNet, etc networks, however, + the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper... + See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for + changing the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use + 'survival rate' as the argument. + + """ + if drop_prob == 0. or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0 and scale_by_keep: + random_tensor.div_(keep_prob) + return x * random_tensor + +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable) and not isinstance(x, str): + return x + return tuple(repeat(x, n)) + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = _ntuple + +def _trunc_normal_(tensor, mean, std, a, b): + # Cut & paste from PyTorch official master until it's in a few official releases - RW + # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf + def norm_cdf(x): + # Computes standard normal cumulative distribution function + return (1. + math.erf(x / math.sqrt(2.))) / 2. + + if (mean < a - 2 * std) or (mean > b + 2 * std): + warnings.warn("mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " + "The distribution of values may be incorrect.", + stacklevel=2) + + # Values are generated by using a truncated uniform distribution and + # then using the inverse CDF for the normal distribution. + # Get upper and lower cdf values + l = norm_cdf((a - mean) / std) + u = norm_cdf((b - mean) / std) + + # Uniformly fill tensor with values from [l, u], then translate to + # [2l-1, 2u-1]. + tensor.uniform_(2 * l - 1, 2 * u - 1) + + # Use inverse cdf transform for normal distribution to get truncated + # standard normal + tensor.erfinv_() + + # Transform to proper mean, std + tensor.mul_(std * math.sqrt(2.)) + tensor.add_(mean) + + # Clamp to ensure it's in the proper range + tensor.clamp_(min=a, max=b) + return tensor + + +def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.): + # type: (Tensor, float, float, float, float) -> Tensor + r"""Fills the input Tensor with values drawn from a truncated + normal distribution. The values are effectively drawn from the + normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)` + with values outside :math:`[a, b]` redrawn until they are within + the bounds. The method used for generating the random values works + best when :math:`a \leq \text{mean} \leq b`. + + NOTE: this impl is similar to the PyTorch trunc_normal_, the bounds [a, b] are + applied while sampling the normal with mean/std applied, therefore a, b args + should be adjusted to match the range of mean, std args. + + Args: + tensor: an n-dimensional `torch.Tensor` + mean: the mean of the normal distribution + std: the standard deviation of the normal distribution + a: the minimum cutoff value + b: the maximum cutoff value + Examples: + >>> w = torch.empty(3, 5) + >>> nn.init.trunc_normal_(w) + """ + with torch.no_grad(): + return _trunc_normal_(tensor, mean, std, a, b) + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + """ + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + def extra_repr(self): + return 'p={}'.format(self.drop_prob) + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.fc2(x) + x = self.drop(x) + return x + +class Attention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., + proj_drop=0., attn_head_dim=None,): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.dim = dim + + if attn_head_dim is not None: + head_dim = attn_head_dim + all_head_dim = head_dim * self.num_heads + + self.scale = qk_scale or head_dim ** -0.5 + + self.qkv = nn.Linear(dim, all_head_dim * 3, bias=qkv_bias) + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(all_head_dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x): + B, N, C = x.shape + qkv = self.qkv(x) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.proj(x) + x = self.proj_drop(x) + + return x + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, + drop=0., attn_drop=0., drop_path=0., act_layer=nn.GELU, + norm_layer=nn.LayerNorm, attn_head_dim=None + ): + super().__init__() + + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, attn_head_dim=attn_head_dim + ) + + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + def forward(self, x): + x = x + self.drop_path(self.attn(self.norm1(x))) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, ratio=1): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) * (ratio ** 2) + self.patch_shape = (int(img_size[0] // patch_size[0] * ratio), int(img_size[1] // patch_size[1] * ratio)) + self.origin_patch_shape = (int(img_size[0] // patch_size[0]), int(img_size[1] // patch_size[1])) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=(patch_size[0] // ratio), padding=4 + 2 * (ratio//2-1)) + + def forward(self, x): + x = self.proj(x) + B, C, Hp, Wp = x.shape + x = x.view(B, C, Hp * Wp).transpose(1, 2) + return x, (Hp, Wp) + + +class HybridEmbed(nn.Module): + """ CNN Feature Map Embedding + Extract feature map from CNN, flatten, project to embedding dim. + """ + def __init__(self, backbone, img_size=224, feature_size=None, in_chans=3, embed_dim=768): + super().__init__() + assert isinstance(backbone, nn.Module) + img_size = to_2tuple(img_size) + self.img_size = img_size + self.backbone = backbone + if feature_size is None: + with torch.no_grad(): + training = backbone.training + if training: + backbone.eval() + o = self.backbone(torch.zeros(1, in_chans, img_size[0], img_size[1]))[-1] + feature_size = o.shape[-2:] + feature_dim = o.shape[1] + backbone.train(training) + else: + feature_size = to_2tuple(feature_size) + feature_dim = self.backbone.feature_info.channels()[-1] + self.num_patches = feature_size[0] * feature_size[1] + self.proj = nn.Linear(feature_dim, embed_dim) + + def forward(self, x): + x = self.backbone(x)[-1] + x = x.flatten(2).transpose(1, 2) + x = self.proj(x) + return x + + +class ViT(nn.Module): + def __init__(self, + img_size=224, patch_size=16, in_chans=3, num_classes=80, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0., hybrid_backbone=None, norm_layer=None, use_checkpoint=False, + frozen_stages=-1, ratio=1, last_norm=True, + patch_padding='pad', freeze_attn=False, freeze_ffn=False, + ): + super(ViT, self).__init__() + # Protect mutable default arguments + + norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6) + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.frozen_stages = frozen_stages + self.use_checkpoint = use_checkpoint + self.patch_padding = patch_padding + self.freeze_attn = freeze_attn + self.freeze_ffn = freeze_ffn + self.depth = depth + + if hybrid_backbone is not None: + self.patch_embed = HybridEmbed( + hybrid_backbone, img_size=img_size, in_chans=in_chans, embed_dim=embed_dim) + else: + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, ratio=ratio) + num_patches = self.patch_embed.num_patches + + # since the pretraining model has class token + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, + ) + for i in range(depth)]) + + self.last_norm = norm_layer(embed_dim) if last_norm else nn.Identity() + + if self.pos_embed is not None: + trunc_normal_(self.pos_embed, std=.02) + + self._freeze_stages() + + def _freeze_stages(self): + """Freeze parameters.""" + if self.frozen_stages >= 0: + self.patch_embed.eval() + for param in self.patch_embed.parameters(): + param.requires_grad = False + + for i in range(1, self.frozen_stages + 1): + m = self.blocks[i] + m.eval() + for param in m.parameters(): + param.requires_grad = False + + if self.freeze_attn: + for i in range(0, self.depth): + m = self.blocks[i] + m.attn.eval() + m.norm1.eval() + for param in m.attn.parameters(): + param.requires_grad = False + for param in m.norm1.parameters(): + param.requires_grad = False + + if self.freeze_ffn: + self.pos_embed.requires_grad = False + self.patch_embed.eval() + for param in self.patch_embed.parameters(): + param.requires_grad = False + for i in range(0, self.depth): + m = self.blocks[i] + m.mlp.eval() + m.norm2.eval() + for param in m.mlp.parameters(): + param.requires_grad = False + for param in m.norm2.parameters(): + param.requires_grad = False + + def init_weights(self, pretrained=None): + """Initialize the weights in backbone. + Args: + pretrained (str, optional): Path to pre-trained weights. + Defaults to None. + """ + super().init_weights(pretrained, patch_padding=self.patch_padding) + + if pretrained is None: + def _init_weights(m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + self.apply(_init_weights) + + def get_num_layers(self): + return len(self.blocks) + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def forward(self, x): + B, C, H, W = x.shape + x, (Hp, Wp) = self.patch_embed(x) + + if self.pos_embed is not None: + # fit for multiple GPU training + # since the first element for pos embed (sin-cos manner) is zero, it will cause no difference + # print("self.pos_embed shape: ", self.pos_embed.shape) + # print("self.pos_embed[:, 1:]: ", self.pos_embed[:, 1:].shape) + # print("self.pos_embed[:, :1]: ", self.pos_embed[:, :1].shape) + x = x + self.pos_embed[:, 24:] + self.pos_embed[:, :1] + + for blk in self.blocks: + x = blk(x) + + x = self.last_norm(x) + x = x.permute(0, 2, 1).view(B, -1, Hp, Wp).contiguous() + return x + + def train(self, mode=True): + """Convert the model into training mode.""" + super().train(mode) + self._freeze_stages() diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..825ca30b88607d63103f1561e6de0e3266a7b8ca Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/vit.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/vit.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cbef555fb6b746b1a773809a17b52ed3d9146ebc Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/__pycache__/vit.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/vit.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/vit.py new file mode 100644 index 0000000000000000000000000000000000000000..f2191252b676160526e89df227aa1e8a02d48465 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/backbone/vit.py @@ -0,0 +1,397 @@ + +import math +import warnings + +from itertools import repeat +import collections.abc + +import torch +from functools import partial +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint +from torch import Tensor + +# from timm.models.layers import drop_path, to_2tuple, trunc_normal_ + +# from .base_backbone import BaseBackbone + +def drop_path(x, drop_prob: float = 0., training: bool = False, scale_by_keep: bool = True): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + + This is the same as the DropConnect impl I created for EfficientNet, etc networks, however, + the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper... + See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for + changing the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use + 'survival rate' as the argument. + + """ + if drop_prob == 0. or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0 and scale_by_keep: + random_tensor.div_(keep_prob) + return x * random_tensor + +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable) and not isinstance(x, str): + return x + return tuple(repeat(x, n)) + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = _ntuple + +def _trunc_normal_(tensor, mean, std, a, b): + # Cut & paste from PyTorch official master until it's in a few official releases - RW + # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf + def norm_cdf(x): + # Computes standard normal cumulative distribution function + return (1. + math.erf(x / math.sqrt(2.))) / 2. + + if (mean < a - 2 * std) or (mean > b + 2 * std): + warnings.warn("mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " + "The distribution of values may be incorrect.", + stacklevel=2) + + # Values are generated by using a truncated uniform distribution and + # then using the inverse CDF for the normal distribution. + # Get upper and lower cdf values + l = norm_cdf((a - mean) / std) + u = norm_cdf((b - mean) / std) + + # Uniformly fill tensor with values from [l, u], then translate to + # [2l-1, 2u-1]. + tensor.uniform_(2 * l - 1, 2 * u - 1) + + # Use inverse cdf transform for normal distribution to get truncated + # standard normal + tensor.erfinv_() + + # Transform to proper mean, std + tensor.mul_(std * math.sqrt(2.)) + tensor.add_(mean) + + # Clamp to ensure it's in the proper range + tensor.clamp_(min=a, max=b) + return tensor + + +def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.): + # type: (Tensor, float, float, float, float) -> Tensor + r"""Fills the input Tensor with values drawn from a truncated + normal distribution. The values are effectively drawn from the + normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)` + with values outside :math:`[a, b]` redrawn until they are within + the bounds. The method used for generating the random values works + best when :math:`a \leq \text{mean} \leq b`. + + NOTE: this impl is similar to the PyTorch trunc_normal_, the bounds [a, b] are + applied while sampling the normal with mean/std applied, therefore a, b args + should be adjusted to match the range of mean, std args. + + Args: + tensor: an n-dimensional `torch.Tensor` + mean: the mean of the normal distribution + std: the standard deviation of the normal distribution + a: the minimum cutoff value + b: the maximum cutoff value + Examples: + >>> w = torch.empty(3, 5) + >>> nn.init.trunc_normal_(w) + """ + with torch.no_grad(): + return _trunc_normal_(tensor, mean, std, a, b) + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + """ + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + def extra_repr(self): + return 'p={}'.format(self.drop_prob) + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.fc2(x) + x = self.drop(x) + return x + +class Attention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., + proj_drop=0., attn_head_dim=None,): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.dim = dim + + if attn_head_dim is not None: + head_dim = attn_head_dim + all_head_dim = head_dim * self.num_heads + + self.scale = qk_scale or head_dim ** -0.5 + + self.qkv = nn.Linear(dim, all_head_dim * 3, bias=qkv_bias) + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(all_head_dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x): + B, N, C = x.shape + qkv = self.qkv(x) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.proj(x) + x = self.proj_drop(x) + + return x + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, + drop=0., attn_drop=0., drop_path=0., act_layer=nn.GELU, + norm_layer=nn.LayerNorm, attn_head_dim=None + ): + super().__init__() + + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, attn_head_dim=attn_head_dim + ) + + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + def forward(self, x): + x = x + self.drop_path(self.attn(self.norm1(x))) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, ratio=1): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) * (ratio ** 2) + self.patch_shape = (int(img_size[0] // patch_size[0] * ratio), int(img_size[1] // patch_size[1] * ratio)) + self.origin_patch_shape = (int(img_size[0] // patch_size[0]), int(img_size[1] // patch_size[1])) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=(patch_size[0] // ratio), padding=4 + 2 * (ratio//2-1)) + + def forward(self, x): + x = self.proj(x) + B, C, Hp, Wp = x.shape + x = x.view(B, C, Hp * Wp).transpose(1, 2) + return x, (Hp, Wp) + + +class HybridEmbed(nn.Module): + """ CNN Feature Map Embedding + Extract feature map from CNN, flatten, project to embedding dim. + """ + def __init__(self, backbone, img_size=224, feature_size=None, in_chans=3, embed_dim=768): + super().__init__() + assert isinstance(backbone, nn.Module) + img_size = to_2tuple(img_size) + self.img_size = img_size + self.backbone = backbone + if feature_size is None: + with torch.no_grad(): + training = backbone.training + if training: + backbone.eval() + o = self.backbone(torch.zeros(1, in_chans, img_size[0], img_size[1]))[-1] + feature_size = o.shape[-2:] + feature_dim = o.shape[1] + backbone.train(training) + else: + feature_size = to_2tuple(feature_size) + feature_dim = self.backbone.feature_info.channels()[-1] + self.num_patches = feature_size[0] * feature_size[1] + self.proj = nn.Linear(feature_dim, embed_dim) + + def forward(self, x): + x = self.backbone(x)[-1] + x = x.flatten(2).transpose(1, 2) + x = self.proj(x) + return x + + +class ViT(nn.Module): + def __init__(self, + img_size=224, patch_size=16, in_chans=3, num_classes=80, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0., hybrid_backbone=None, norm_layer=None, use_checkpoint=False, + frozen_stages=-1, ratio=1, last_norm=True, + patch_padding='pad', freeze_attn=False, freeze_ffn=False, + ): + super(ViT, self).__init__() + # Protect mutable default arguments + + norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6) + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.frozen_stages = frozen_stages + self.use_checkpoint = use_checkpoint + self.patch_padding = patch_padding + self.freeze_attn = freeze_attn + self.freeze_ffn = freeze_ffn + self.depth = depth + + if hybrid_backbone is not None: + self.patch_embed = HybridEmbed( + hybrid_backbone, img_size=img_size, in_chans=in_chans, embed_dim=embed_dim) + else: + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, ratio=ratio) + num_patches = self.patch_embed.num_patches + + # since the pretraining model has class token + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, + ) + for i in range(depth)]) + + self.last_norm = norm_layer(embed_dim) if last_norm else nn.Identity() + + if self.pos_embed is not None: + trunc_normal_(self.pos_embed, std=.02) + + self._freeze_stages() + + def _freeze_stages(self): + """Freeze parameters.""" + if self.frozen_stages >= 0: + self.patch_embed.eval() + for param in self.patch_embed.parameters(): + param.requires_grad = False + + for i in range(1, self.frozen_stages + 1): + m = self.blocks[i] + m.eval() + for param in m.parameters(): + param.requires_grad = False + + if self.freeze_attn: + for i in range(0, self.depth): + m = self.blocks[i] + m.attn.eval() + m.norm1.eval() + for param in m.attn.parameters(): + param.requires_grad = False + for param in m.norm1.parameters(): + param.requires_grad = False + + if self.freeze_ffn: + self.pos_embed.requires_grad = False + self.patch_embed.eval() + for param in self.patch_embed.parameters(): + param.requires_grad = False + for i in range(0, self.depth): + m = self.blocks[i] + m.mlp.eval() + m.norm2.eval() + for param in m.mlp.parameters(): + param.requires_grad = False + for param in m.norm2.parameters(): + param.requires_grad = False + + def init_weights(self, pretrained=None): + """Initialize the weights in backbone. + Args: + pretrained (str, optional): Path to pre-trained weights. + Defaults to None. + """ + super().init_weights(pretrained, patch_padding=self.patch_padding) + + if pretrained is None: + def _init_weights(m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + self.apply(_init_weights) + + def get_num_layers(self): + return len(self.blocks) + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def forward(self, x): + B, C, H, W = x.shape + x, (Hp, Wp) = self.patch_embed(x) + + if self.pos_embed is not None: + # fit for multiple GPU training + # since the first element for pos embed (sin-cos manner) is zero, it will cause no difference + # print("self.pos_embed shape: ", self.pos_embed.shape) + # print("self.pos_embed[:, 1:]: ", self.pos_embed[:, 1:].shape) + # print("self.pos_embed[:, :1]: ", self.pos_embed[:, :1].shape) + x = x + self.pos_embed[:, 24:] + self.pos_embed[:, :1] + + for blk in self.blocks: + x = blk(x) + + x = self.last_norm(x) + x = x.permute(0, 2, 1).view(B, -1, Hp, Wp).contiguous() + return x + + def train(self, mode=True): + """Convert the model into training mode.""" + super().train(mode) + self._freeze_stages() diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e833eca2b058cdc5e3c953247a6822c4d375d4af Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_base_head.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_base_head.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..182047f7ad6dc6baa61449ac4212455ceb911116 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_base_head.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_simple_head.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_simple_head.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c4a577477651537a5adc089631375ba9d79a57f Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/__pycache__/topdown_heatmap_simple_head.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_base_head.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_base_head.py new file mode 100644 index 0000000000000000000000000000000000000000..0ec9e9ffa78219bdbe7efd8d549a43ad1abf2403 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_base_head.py @@ -0,0 +1,120 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from abc import ABCMeta, abstractmethod + +import numpy as np +import torch.nn as nn + +from .. import keypoints_from_heatmaps + + +class TopdownHeatmapBaseHead(nn.Module): + """Base class for top-down heatmap heads. + + All top-down heatmap heads should subclass it. + All subclass should overwrite: + + Methods:`get_loss`, supporting to calculate loss. + Methods:`get_accuracy`, supporting to calculate accuracy. + Methods:`forward`, supporting to forward model. + Methods:`inference_model`, supporting to inference model. + """ + + __metaclass__ = ABCMeta + + @abstractmethod + def get_loss(self, **kwargs): + """Gets the loss.""" + + @abstractmethod + def get_accuracy(self, **kwargs): + """Gets the accuracy.""" + + @abstractmethod + def forward(self, **kwargs): + """Forward function.""" + + @abstractmethod + def inference_model(self, **kwargs): + """Inference function.""" + + def decode(self, img_metas, output, **kwargs): + """Decode keypoints from heatmaps. + + Args: + img_metas (list(dict)): Information about data augmentation + By default this includes: + + - "image_file: path to the image file + - "center": center of the bbox + - "scale": scale of the bbox + - "rotation": rotation of the bbox + - "bbox_score": score of bbox + output (np.ndarray[N, K, H, W]): model predicted heatmaps. + """ + batch_size = len(img_metas) + + if 'bbox_id' in img_metas[0]: + bbox_ids = [] + else: + bbox_ids = None + + c = np.zeros((batch_size, 2), dtype=np.float32) + s = np.zeros((batch_size, 2), dtype=np.float32) + image_paths = [] + score = np.ones(batch_size) + for i in range(batch_size): + c[i, :] = img_metas[i]['center'] + s[i, :] = img_metas[i]['scale'] + image_paths.append(img_metas[i]['image_file']) + + if 'bbox_score' in img_metas[i]: + score[i] = np.array(img_metas[i]['bbox_score']).reshape(-1) + if bbox_ids is not None: + bbox_ids.append(img_metas[i]['bbox_id']) + + preds, maxvals = keypoints_from_heatmaps( + output, + c, + s, + unbiased=self.test_cfg.get('unbiased_decoding', False), + post_process=self.test_cfg.get('post_process', 'default'), + kernel=self.test_cfg.get('modulate_kernel', 11), + valid_radius_factor=self.test_cfg.get('valid_radius_factor', + 0.0546875), + use_udp=self.test_cfg.get('use_udp', False), + target_type=self.test_cfg.get('target_type', 'GaussianHeatmap')) + + all_preds = np.zeros((batch_size, preds.shape[1], 3), dtype=np.float32) + all_boxes = np.zeros((batch_size, 6), dtype=np.float32) + all_preds[:, :, 0:2] = preds[:, :, 0:2] + all_preds[:, :, 2:3] = maxvals + all_boxes[:, 0:2] = c[:, 0:2] + all_boxes[:, 2:4] = s[:, 0:2] + all_boxes[:, 4] = np.prod(s * 200.0, axis=1) + all_boxes[:, 5] = score + + result = {} + + result['preds'] = all_preds + result['boxes'] = all_boxes + result['image_paths'] = image_paths + result['bbox_ids'] = bbox_ids + + return result + + @staticmethod + def _get_deconv_cfg(deconv_kernel): + """Get configurations for deconv layers.""" + if deconv_kernel == 4: + padding = 1 + output_padding = 0 + elif deconv_kernel == 3: + padding = 1 + output_padding = 1 + elif deconv_kernel == 2: + padding = 0 + output_padding = 0 + else: + raise ValueError(f'Not supported num_kernels ({deconv_kernel}).') + + return deconv_kernel, padding, output_padding diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_simple_head.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_simple_head.py new file mode 100644 index 0000000000000000000000000000000000000000..71ef89e189e0622ffcb24482b81e623806d8e475 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/head/topdown_heatmap_simple_head.py @@ -0,0 +1,334 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +import torch.nn as nn +from .. import constant_init, normal_init + +from .. import pose_pck_accuracy, flip_back, resize +import torch.nn.functional as F +from .topdown_heatmap_base_head import TopdownHeatmapBaseHead + + +class TopdownHeatmapSimpleHead(TopdownHeatmapBaseHead): + """Top-down heatmap simple head. paper ref: Bin Xiao et al. ``Simple + Baselines for Human Pose Estimation and Tracking``. + + TopdownHeatmapSimpleHead is consisted of (>=0) number of deconv layers + and a simple conv2d layer. + + Args: + in_channels (int): Number of input channels + out_channels (int): Number of output channels + num_deconv_layers (int): Number of deconv layers. + num_deconv_layers should >= 0. Note that 0 means + no deconv layers. + num_deconv_filters (list|tuple): Number of filters. + If num_deconv_layers > 0, the length of + num_deconv_kernels (list|tuple): Kernel sizes. + in_index (int|Sequence[int]): Input feature index. Default: 0 + input_transform (str|None): Transformation type of input features. + Options: 'resize_concat', 'multiple_select', None. + Default: None. + + - 'resize_concat': Multiple feature maps will be resized to the + same size as the first one and then concat together. + Usually used in FCN head of HRNet. + - 'multiple_select': Multiple feature maps will be bundle into + a list and passed into decode head. + - None: Only one select feature map is allowed. + align_corners (bool): align_corners argument of F.interpolate. + Default: False. + loss_keypoint (dict): Config for keypoint loss. Default: None. + """ + + def __init__(self, + in_channels, + out_channels, + num_deconv_layers=3, + num_deconv_filters=(256, 256, 256), + num_deconv_kernels=(4, 4, 4), + extra=None, + in_index=0, + input_transform=None, + align_corners=False, + loss_keypoint=None, + train_cfg=None, + test_cfg=None, + upsample=0,): + super().__init__() + + self.in_channels = in_channels + self.loss = loss_keypoint + self.upsample = upsample + + self.train_cfg = {} if train_cfg is None else train_cfg + self.test_cfg = {} if test_cfg is None else test_cfg + self.target_type = self.test_cfg.get('target_type', 'GaussianHeatmap') + + self._init_inputs(in_channels, in_index, input_transform) + self.in_index = in_index + self.align_corners = align_corners + + if extra is not None and not isinstance(extra, dict): + raise TypeError('extra should be dict or None.') + + if num_deconv_layers > 0: + self.deconv_layers = self._make_deconv_layer( + num_deconv_layers, + num_deconv_filters, + num_deconv_kernels, + ) + elif num_deconv_layers == 0: + self.deconv_layers = nn.Identity() + else: + raise ValueError( + f'num_deconv_layers ({num_deconv_layers}) should >= 0.') + + identity_final_layer = False + if extra is not None and 'final_conv_kernel' in extra: + assert extra['final_conv_kernel'] in [0, 1, 3] + if extra['final_conv_kernel'] == 3: + padding = 1 + elif extra['final_conv_kernel'] == 1: + padding = 0 + else: + # 0 for Identity mapping. + identity_final_layer = True + kernel_size = extra['final_conv_kernel'] + else: + kernel_size = 1 + padding = 0 + + if identity_final_layer: + self.final_layer = nn.Identity() + else: + conv_channels = num_deconv_filters[ + -1] if num_deconv_layers > 0 else self.in_channels + + layers = [] + if extra is not None: + num_conv_layers = extra.get('num_conv_layers', 0) + num_conv_kernels = extra.get('num_conv_kernels', + [1] * num_conv_layers) + + for i in range(num_conv_layers): + layers.append( + nn.Conv2d(in_channels=conv_channels, + out_channels=conv_channels, + kernel_size=num_conv_kernels[i], + stride=1, + padding=(num_conv_kernels[i] - 1) // 2) + ) + layers.append(nn.BatchNorm2d(conv_channels)) + layers.append(nn.ReLU(inplace=True)) + + layers.append( + nn.Conv2d(in_channels=conv_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=1, + padding=padding) + ) + + if len(layers) > 1: + self.final_layer = nn.Sequential(*layers) + else: + self.final_layer = layers[0] + + def get_loss(self, output, target, target_weight): + """Calculate top-down keypoint loss. + + Note: + - batch_size: N + - num_keypoints: K + - heatmaps height: H + - heatmaps weight: W + + Args: + output (torch.Tensor[N,K,H,W]): Output heatmaps. + target (torch.Tensor[N,K,H,W]): Target heatmaps. + target_weight (torch.Tensor[N,K,1]): + Weights across different joint types. + """ + + losses = dict() + + assert not isinstance(self.loss, nn.Sequential) + assert target.dim() == 4 and target_weight.dim() == 3 + losses['heatmap_loss'] = self.loss(output, target, target_weight) + + return losses + + def get_accuracy(self, output, target, target_weight): + """Calculate accuracy for top-down keypoint loss. + + Note: + - batch_size: N + - num_keypoints: K + - heatmaps height: H + - heatmaps weight: W + + Args: + output (torch.Tensor[N,K,H,W]): Output heatmaps. + target (torch.Tensor[N,K,H,W]): Target heatmaps. + target_weight (torch.Tensor[N,K,1]): + Weights across different joint types. + """ + + accuracy = dict() + + if self.target_type == 'GaussianHeatmap': + _, avg_acc, _ = pose_pck_accuracy( + output.detach().cpu().numpy(), + target.detach().cpu().numpy(), + target_weight.detach().cpu().numpy().squeeze(-1) > 0) + accuracy['acc_pose'] = float(avg_acc) + + return accuracy + + def forward(self, x): + """Forward function.""" + x = self._transform_inputs(x) + x = self.deconv_layers(x) + x = self.final_layer(x) + return x + + def inference_model(self, x, flip_pairs=None): + """Inference function. + + Returns: + output_heatmap (np.ndarray): Output heatmaps. + + Args: + x (torch.Tensor[N,K,H,W]): Input features. + flip_pairs (None | list[tuple]): + Pairs of keypoints which are mirrored. + """ + output = self.forward(x) + + if flip_pairs is not None: + output_heatmap = flip_back( + output.detach().cpu().numpy(), + flip_pairs, + target_type=self.target_type) + # feature is not aligned, shift flipped heatmap for higher accuracy + if self.test_cfg.get('shift_heatmap', False): + output_heatmap[:, :, :, 1:] = output_heatmap[:, :, :, :-1] + else: + output_heatmap = output.detach().cpu().numpy() + return output_heatmap + + def _init_inputs(self, in_channels, in_index, input_transform): + """Check and initialize input transforms. + + The in_channels, in_index and input_transform must match. + Specifically, when input_transform is None, only single feature map + will be selected. So in_channels and in_index must be of type int. + When input_transform is not None, in_channels and in_index must be + list or tuple, with the same length. + + Args: + in_channels (int|Sequence[int]): Input channels. + in_index (int|Sequence[int]): Input feature index. + input_transform (str|None): Transformation type of input features. + Options: 'resize_concat', 'multiple_select', None. + + - 'resize_concat': Multiple feature maps will be resize to the + same size as first one and than concat together. + Usually used in FCN head of HRNet. + - 'multiple_select': Multiple feature maps will be bundle into + a list and passed into decode head. + - None: Only one select feature map is allowed. + """ + + if input_transform is not None: + assert input_transform in ['resize_concat', 'multiple_select'] + self.input_transform = input_transform + self.in_index = in_index + if input_transform is not None: + assert isinstance(in_channels, (list, tuple)) + assert isinstance(in_index, (list, tuple)) + assert len(in_channels) == len(in_index) + if input_transform == 'resize_concat': + self.in_channels = sum(in_channels) + else: + self.in_channels = in_channels + else: + assert isinstance(in_channels, int) + assert isinstance(in_index, int) + self.in_channels = in_channels + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + + Args: + inputs (list[Tensor] | Tensor): multi-level img features. + + Returns: + Tensor: The transformed inputs + """ + if not isinstance(inputs, list): + if self.upsample > 0: + raise NotImplementedError + return inputs + + if self.input_transform == 'resize_concat': + inputs = [inputs[i] for i in self.in_index] + upsampled_inputs = [ + resize( + input=x, + size=inputs[0].shape[2:], + mode='bilinear', + align_corners=self.align_corners) for x in inputs + ] + inputs = torch.cat(upsampled_inputs, dim=1) + elif self.input_transform == 'multiple_select': + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def _make_deconv_layer(self, num_layers, num_filters, num_kernels): + """Make deconv layers.""" + if num_layers != len(num_filters): + error_msg = f'num_layers({num_layers}) ' \ + f'!= length of num_filters({len(num_filters)})' + raise ValueError(error_msg) + if num_layers != len(num_kernels): + error_msg = f'num_layers({num_layers}) ' \ + f'!= length of num_kernels({len(num_kernels)})' + raise ValueError(error_msg) + + layers = [] + for i in range(num_layers): + kernel, padding, output_padding = \ + self._get_deconv_cfg(num_kernels[i]) + + planes = num_filters[i] + layers.append( + nn.ConvTranspose2d(in_channels=self.in_channels, + out_channels=planes, + kernel_size=kernel, + stride=2, + padding=padding, + output_padding=output_padding, + bias=False) + ) + layers.append(nn.BatchNorm2d(planes)) + layers.append(nn.ReLU(inplace=True)) + self.in_channels = planes + + return nn.Sequential(*layers) + + def init_weights(self): + """Initialize model weights.""" + for _, m in self.deconv_layers.named_modules(): + if isinstance(m, nn.ConvTranspose2d): + normal_init(m, std=0.001) + elif isinstance(m, nn.BatchNorm2d): + constant_init(m, 1) + for m in self.final_layer.modules(): + if isinstance(m, nn.Conv2d): + normal_init(m, std=0.001, bias=0) + elif isinstance(m, nn.BatchNorm2d): + constant_init(m, 1) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed0da76ff43ebecccb39c5b67ea0d36b7e6de2e3 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__init__.py @@ -0,0 +1,16 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .classfication_loss import BCELoss +from .heatmap_loss import AdaptiveWingLoss +from .mesh_loss import GANLoss, MeshLoss +from .mse_loss import JointsMSELoss, JointsOHKMMSELoss +from .multi_loss_factory import AELoss, HeatmapLoss, MultiLossFactory +from .regression_loss import (BoneLoss, L1Loss, MPJPELoss, MSELoss, + SemiSupervisionLoss, SmoothL1Loss, SoftWingLoss, + WingLoss) + +__all__ = [ + 'JointsMSELoss', 'JointsOHKMMSELoss', 'HeatmapLoss', 'AELoss', + 'MultiLossFactory', 'MeshLoss', 'GANLoss', 'SmoothL1Loss', 'WingLoss', + 'MPJPELoss', 'MSELoss', 'L1Loss', 'BCELoss', 'BoneLoss', + 'SemiSupervisionLoss', 'SoftWingLoss', 'AdaptiveWingLoss' +] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8f46f612e02276d9de076270372556585ccd5ad Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/classfication_loss.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/classfication_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55d64c2b3f75b54c53663f74dd7cd85d2f99f976 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/classfication_loss.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/heatmap_loss.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/heatmap_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..633e15b330c0e5514096935dfe4c8d1282c20b03 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/heatmap_loss.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mesh_loss.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mesh_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18d52f099b9c2f33468991212c6856db9a63d1a9 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mesh_loss.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mse_loss.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mse_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..776fff0c5b884001aa4b809021f8e83ab3b2272e Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/mse_loss.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/multi_loss_factory.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/multi_loss_factory.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ac6eda5416b54e6be686c099478a7b3bd5d5304 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/multi_loss_factory.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/regression_loss.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/regression_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31177f3c128465e23017e0acb6985b5ef065e7c0 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/__pycache__/regression_loss.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/classfication_loss.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/classfication_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..4ac4fbc7b3fddfeb58006c831d374853db7fede5 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/classfication_loss.py @@ -0,0 +1,41 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch.nn as nn +import torch.nn.functional as F + + +__all__ = ['BCELoss'] + + +class BCELoss(nn.Module): + """Binary Cross Entropy loss.""" + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.criterion = F.binary_cross_entropy + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_labels: K + + Args: + output (torch.Tensor[N, K]): Output classification. + target (torch.Tensor[N, K]): Target classification. + target_weight (torch.Tensor[N, K] or torch.Tensor[N]): + Weights across different labels. + """ + + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output, target, reduction='none') + if target_weight.dim() == 1: + target_weight = target_weight[:, None] + loss = (loss * target_weight).mean() + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/heatmap_loss.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/heatmap_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..c8d796d3427b44e669292c0e13e6304c50f71377 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/heatmap_loss.py @@ -0,0 +1,83 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +import torch.nn as nn + + +class AdaptiveWingLoss(nn.Module): + """Adaptive wing loss. paper ref: 'Adaptive Wing Loss for Robust Face + Alignment via Heatmap Regression' Wang et al. ICCV'2019. + + Args: + alpha (float), omega (float), epsilon (float), theta (float) + are hyper-parameters. + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, + alpha=2.1, + omega=14, + epsilon=1, + theta=0.5, + use_target_weight=False, + loss_weight=1.): + super().__init__() + self.alpha = float(alpha) + self.omega = float(omega) + self.epsilon = float(epsilon) + self.theta = float(theta) + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def criterion(self, pred, target): + """Criterion of wingloss. + + Note: + batch_size: N + num_keypoints: K + + Args: + pred (torch.Tensor[NxKxHxW]): Predicted heatmaps. + target (torch.Tensor[NxKxHxW]): Target heatmaps. + """ + H, W = pred.shape[2:4] + delta = (target - pred).abs() + + A = self.omega * ( + 1 / (1 + torch.pow(self.theta / self.epsilon, self.alpha - target)) + ) * (self.alpha - target) * (torch.pow( + self.theta / self.epsilon, + self.alpha - target - 1)) * (1 / self.epsilon) + C = self.theta * A - self.omega * torch.log( + 1 + torch.pow(self.theta / self.epsilon, self.alpha - target)) + + losses = torch.where( + delta < self.theta, + self.omega * + torch.log(1 + + torch.pow(delta / self.epsilon, self.alpha - target)), + A * delta - C) + + return torch.mean(losses) + + def forward(self, output, target, target_weight): + """Forward function. + + Note: + batch_size: N + num_keypoints: K + + Args: + output (torch.Tensor[NxKxHxW]): Output heatmaps. + target (torch.Tensor[NxKxHxW]): Target heatmaps. + target_weight (torch.Tensor[NxKx1]): + Weights across different joint types. + """ + if self.use_target_weight: + loss = self.criterion(output * target_weight.unsqueeze(-1), + target * target_weight.unsqueeze(-1)) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mesh_loss.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mesh_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..92f1dd4b360dabd394f32b99ead3c5186e84320c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mesh_loss.py @@ -0,0 +1,402 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +import torch.nn as nn + +__all__ = ['MeshLoss', 'GANLoss'] + +def rot6d_to_rotmat(x): + """Convert 6D rotation representation to 3x3 rotation matrix. + + Based on Zhou et al., "On the Continuity of Rotation + Representations in Neural Networks", CVPR 2019 + Input: + (B,6) Batch of 6-D rotation representations + Output: + (B,3,3) Batch of corresponding rotation matrices + """ + x = x.view(-1, 3, 2) + a1 = x[:, :, 0] + a2 = x[:, :, 1] + b1 = F.normalize(a1) + b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1) + b3 = torch.cross(b1, b2) + return torch.stack((b1, b2, b3), dim=-1) + + +def batch_rodrigues(theta): + """Convert axis-angle representation to rotation matrix. + Args: + theta: size = [B, 3] + Returns: + Rotation matrix corresponding to the quaternion + -- size = [B, 3, 3] + """ + l2norm = torch.norm(theta + 1e-8, p=2, dim=1) + angle = torch.unsqueeze(l2norm, -1) + normalized = torch.div(theta, angle) + angle = angle * 0.5 + v_cos = torch.cos(angle) + v_sin = torch.sin(angle) + quat = torch.cat([v_cos, v_sin * normalized], dim=1) + return quat_to_rotmat(quat) + + +def quat_to_rotmat(quat): + """Convert quaternion coefficients to rotation matrix. + Args: + quat: size = [B, 4] 4 <===>(w, x, y, z) + Returns: + Rotation matrix corresponding to the quaternion + -- size = [B, 3, 3] + """ + norm_quat = quat + norm_quat = norm_quat / norm_quat.norm(p=2, dim=1, keepdim=True) + w, x, y, z = norm_quat[:, 0], norm_quat[:, 1],\ + norm_quat[:, 2], norm_quat[:, 3] + + B = quat.size(0) + + w2, x2, y2, z2 = w.pow(2), x.pow(2), y.pow(2), z.pow(2) + wx, wy, wz = w * x, w * y, w * z + xy, xz, yz = x * y, x * z, y * z + + rotMat = torch.stack([ + w2 + x2 - y2 - z2, 2 * xy - 2 * wz, 2 * wy + 2 * xz, 2 * wz + 2 * xy, + w2 - x2 + y2 - z2, 2 * yz - 2 * wx, 2 * xz - 2 * wy, 2 * wx + 2 * yz, + w2 - x2 - y2 + z2 + ], + dim=1).view(B, 3, 3) + return rotMat + + + +def perspective_projection(points, rotation, translation, focal_length, + camera_center): + """This function computes the perspective projection of a set of 3D points. + + Note: + - batch size: B + - point number: N + + Args: + points (Tensor([B, N, 3])): A set of 3D points + rotation (Tensor([B, 3, 3])): Camera rotation matrix + translation (Tensor([B, 3])): Camera translation + focal_length (Tensor([B,])): Focal length + camera_center (Tensor([B, 2])): Camera center + + Returns: + projected_points (Tensor([B, N, 2])): Projected 2D + points in image space. + """ + + batch_size = points.shape[0] + K = torch.zeros([batch_size, 3, 3], device=points.device) + K[:, 0, 0] = focal_length + K[:, 1, 1] = focal_length + K[:, 2, 2] = 1. + K[:, :-1, -1] = camera_center + + # Transform points + points = torch.einsum('bij,bkj->bki', rotation, points) + points = points + translation.unsqueeze(1) + + # Apply perspective distortion + projected_points = points / points[:, :, -1].unsqueeze(-1) + + # Apply camera intrinsics + projected_points = torch.einsum('bij,bkj->bki', K, projected_points) + projected_points = projected_points[:, :, :-1] + return projected_points + + +class MeshLoss(nn.Module): + """Mix loss for 3D human mesh. It is composed of loss on 2D joints, 3D + joints, mesh vertices and smpl parameters (if any). + + Args: + joints_2d_loss_weight (float): Weight for loss on 2D joints. + joints_3d_loss_weight (float): Weight for loss on 3D joints. + vertex_loss_weight (float): Weight for loss on 3D verteices. + smpl_pose_loss_weight (float): Weight for loss on SMPL + pose parameters. + smpl_beta_loss_weight (float): Weight for loss on SMPL + shape parameters. + img_res (int): Input image resolution. + focal_length (float): Focal length of camera model. Default=5000. + """ + + def __init__(self, + joints_2d_loss_weight, + joints_3d_loss_weight, + vertex_loss_weight, + smpl_pose_loss_weight, + smpl_beta_loss_weight, + img_res, + focal_length=5000): + + super().__init__() + # Per-vertex loss on the mesh + self.criterion_vertex = nn.L1Loss(reduction='none') + + # Joints (2D and 3D) loss + self.criterion_joints_2d = nn.SmoothL1Loss(reduction='none') + self.criterion_joints_3d = nn.SmoothL1Loss(reduction='none') + + # Loss for SMPL parameter regression + self.criterion_regr = nn.MSELoss(reduction='none') + + self.joints_2d_loss_weight = joints_2d_loss_weight + self.joints_3d_loss_weight = joints_3d_loss_weight + self.vertex_loss_weight = vertex_loss_weight + self.smpl_pose_loss_weight = smpl_pose_loss_weight + self.smpl_beta_loss_weight = smpl_beta_loss_weight + self.focal_length = focal_length + self.img_res = img_res + + def joints_2d_loss(self, pred_joints_2d, gt_joints_2d, joints_2d_visible): + """Compute 2D reprojection loss on the joints. + + The loss is weighted by joints_2d_visible. + """ + conf = joints_2d_visible.float() + loss = (conf * + self.criterion_joints_2d(pred_joints_2d, gt_joints_2d)).mean() + return loss + + def joints_3d_loss(self, pred_joints_3d, gt_joints_3d, joints_3d_visible): + """Compute 3D joints loss for the examples that 3D joint annotations + are available. + + The loss is weighted by joints_3d_visible. + """ + conf = joints_3d_visible.float() + if len(gt_joints_3d) > 0: + gt_pelvis = (gt_joints_3d[:, 2, :] + gt_joints_3d[:, 3, :]) / 2 + gt_joints_3d = gt_joints_3d - gt_pelvis[:, None, :] + pred_pelvis = (pred_joints_3d[:, 2, :] + + pred_joints_3d[:, 3, :]) / 2 + pred_joints_3d = pred_joints_3d - pred_pelvis[:, None, :] + return ( + conf * + self.criterion_joints_3d(pred_joints_3d, gt_joints_3d)).mean() + return pred_joints_3d.sum() * 0 + + def vertex_loss(self, pred_vertices, gt_vertices, has_smpl): + """Compute 3D vertex loss for the examples that 3D human mesh + annotations are available. + + The loss is weighted by the has_smpl. + """ + conf = has_smpl.float() + loss_vertex = self.criterion_vertex(pred_vertices, gt_vertices) + loss_vertex = (conf[:, None, None] * loss_vertex).mean() + return loss_vertex + + def smpl_losses(self, pred_rotmat, pred_betas, gt_pose, gt_betas, + has_smpl): + """Compute SMPL parameters loss for the examples that SMPL parameter + annotations are available. + + The loss is weighted by has_smpl. + """ + conf = has_smpl.float() + gt_rotmat = batch_rodrigues(gt_pose.view(-1, 3)).view(-1, 24, 3, 3) + loss_regr_pose = self.criterion_regr(pred_rotmat, gt_rotmat) + loss_regr_betas = self.criterion_regr(pred_betas, gt_betas) + loss_regr_pose = (conf[:, None, None, None] * loss_regr_pose).mean() + loss_regr_betas = (conf[:, None] * loss_regr_betas).mean() + return loss_regr_pose, loss_regr_betas + + def project_points(self, points_3d, camera): + """Perform orthographic projection of 3D points using the camera + parameters, return projected 2D points in image plane. + + Note: + - batch size: B + - point number: N + + Args: + points_3d (Tensor([B, N, 3])): 3D points. + camera (Tensor([B, 3])): camera parameters with the + 3 channel as (scale, translation_x, translation_y) + + Returns: + Tensor([B, N, 2]): projected 2D points \ + in image space. + """ + batch_size = points_3d.shape[0] + device = points_3d.device + cam_t = torch.stack([ + camera[:, 1], camera[:, 2], 2 * self.focal_length / + (self.img_res * camera[:, 0] + 1e-9) + ], + dim=-1) + camera_center = camera.new_zeros([batch_size, 2]) + rot_t = torch.eye( + 3, device=device, + dtype=points_3d.dtype).unsqueeze(0).expand(batch_size, -1, -1) + joints_2d = perspective_projection( + points_3d, + rotation=rot_t, + translation=cam_t, + focal_length=self.focal_length, + camera_center=camera_center) + return joints_2d + + def forward(self, output, target): + """Forward function. + + Args: + output (dict): dict of network predicted results. + Keys: 'vertices', 'joints_3d', 'camera', + 'pose'(optional), 'beta'(optional) + target (dict): dict of ground-truth labels. + Keys: 'vertices', 'joints_3d', 'joints_3d_visible', + 'joints_2d', 'joints_2d_visible', 'pose', 'beta', + 'has_smpl' + + Returns: + dict: dict of losses. + """ + losses = {} + + # Per-vertex loss for the shape + pred_vertices = output['vertices'] + + gt_vertices = target['vertices'] + has_smpl = target['has_smpl'] + loss_vertex = self.vertex_loss(pred_vertices, gt_vertices, has_smpl) + losses['vertex_loss'] = loss_vertex * self.vertex_loss_weight + + # Compute loss on SMPL parameters, if available + if 'pose' in output.keys() and 'beta' in output.keys(): + pred_rotmat = output['pose'] + pred_betas = output['beta'] + gt_pose = target['pose'] + gt_betas = target['beta'] + loss_regr_pose, loss_regr_betas = self.smpl_losses( + pred_rotmat, pred_betas, gt_pose, gt_betas, has_smpl) + losses['smpl_pose_loss'] = \ + loss_regr_pose * self.smpl_pose_loss_weight + losses['smpl_beta_loss'] = \ + loss_regr_betas * self.smpl_beta_loss_weight + + # Compute 3D joints loss + pred_joints_3d = output['joints_3d'] + gt_joints_3d = target['joints_3d'] + joints_3d_visible = target['joints_3d_visible'] + loss_joints_3d = self.joints_3d_loss(pred_joints_3d, gt_joints_3d, + joints_3d_visible) + losses['joints_3d_loss'] = loss_joints_3d * self.joints_3d_loss_weight + + # Compute 2D reprojection loss for the 2D joints + pred_camera = output['camera'] + gt_joints_2d = target['joints_2d'] + joints_2d_visible = target['joints_2d_visible'] + pred_joints_2d = self.project_points(pred_joints_3d, pred_camera) + + # Normalize keypoints to [-1,1] + # The coordinate origin of pred_joints_2d is + # the center of the input image. + pred_joints_2d = 2 * pred_joints_2d / (self.img_res - 1) + # The coordinate origin of gt_joints_2d is + # the top left corner of the input image. + gt_joints_2d = 2 * gt_joints_2d / (self.img_res - 1) - 1 + loss_joints_2d = self.joints_2d_loss(pred_joints_2d, gt_joints_2d, + joints_2d_visible) + losses['joints_2d_loss'] = loss_joints_2d * self.joints_2d_loss_weight + + return losses + + +class GANLoss(nn.Module): + """Define GAN loss. + + Args: + gan_type (str): Support 'vanilla', 'lsgan', 'wgan', 'hinge'. + real_label_val (float): The value for real label. Default: 1.0. + fake_label_val (float): The value for fake label. Default: 0.0. + loss_weight (float): Loss weight. Default: 1.0. + Note that loss_weight is only for generators; and it is always 1.0 + for discriminators. + """ + + def __init__(self, + gan_type, + real_label_val=1.0, + fake_label_val=0.0, + loss_weight=1.0): + super().__init__() + self.gan_type = gan_type + self.loss_weight = loss_weight + self.real_label_val = real_label_val + self.fake_label_val = fake_label_val + + if self.gan_type == 'vanilla': + self.loss = nn.BCEWithLogitsLoss() + elif self.gan_type == 'lsgan': + self.loss = nn.MSELoss() + elif self.gan_type == 'wgan': + self.loss = self._wgan_loss + elif self.gan_type == 'hinge': + self.loss = nn.ReLU() + else: + raise NotImplementedError( + f'GAN type {self.gan_type} is not implemented.') + + @staticmethod + def _wgan_loss(input, target): + """wgan loss. + + Args: + input (Tensor): Input tensor. + target (bool): Target label. + + Returns: + Tensor: wgan loss. + """ + return -input.mean() if target else input.mean() + + def get_target_label(self, input, target_is_real): + """Get target label. + + Args: + input (Tensor): Input tensor. + target_is_real (bool): Whether the target is real or fake. + + Returns: + (bool | Tensor): Target tensor. Return bool for wgan, \ + otherwise, return Tensor. + """ + + if self.gan_type == 'wgan': + return target_is_real + target_val = ( + self.real_label_val if target_is_real else self.fake_label_val) + return input.new_ones(input.size()) * target_val + + def forward(self, input, target_is_real, is_disc=False): + """ + Args: + input (Tensor): The input for the loss module, i.e., the network + prediction. + target_is_real (bool): Whether the targe is real or fake. + is_disc (bool): Whether the loss for discriminators or not. + Default: False. + + Returns: + Tensor: GAN loss value. + """ + target_label = self.get_target_label(input, target_is_real) + if self.gan_type == 'hinge': + if is_disc: # for discriminators in hinge-gan + input = -input if target_is_real else input + loss = self.loss(1 + input).mean() + else: # for generators in hinge-gan + loss = -input.mean() + else: # other gan types + loss = self.loss(input, target_label) + + # loss_weight is always 1.0 for discriminators + return loss if is_disc else loss * self.loss_weight diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mse_loss.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mse_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..51ac42e511a1097a44db69882eaa1df8f5dae617 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/mse_loss.py @@ -0,0 +1,151 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +import torch.nn as nn + + +__all__ = ['JointsMSELoss', 'JointsOHKMMSELoss',] + + +class JointsMSELoss(nn.Module): + """MSE loss for heatmaps. + + Args: + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.criterion = nn.MSELoss() + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight): + """Forward function.""" + batch_size = output.size(0) + num_joints = output.size(1) + + heatmaps_pred = output.reshape( + (batch_size, num_joints, -1)).split(1, 1) + heatmaps_gt = target.reshape((batch_size, num_joints, -1)).split(1, 1) + + loss = 0. + + for idx in range(num_joints): + heatmap_pred = heatmaps_pred[idx].squeeze(1) + heatmap_gt = heatmaps_gt[idx].squeeze(1) + if self.use_target_weight: + loss += self.criterion(heatmap_pred * target_weight[:, idx], + heatmap_gt * target_weight[:, idx]) + else: + loss += self.criterion(heatmap_pred, heatmap_gt) + + return loss / num_joints * self.loss_weight + + +class CombinedTargetMSELoss(nn.Module): + """MSE loss for combined target. + CombinedTarget: The combination of classification target + (response map) and regression target (offset map). + Paper ref: Huang et al. The Devil is in the Details: Delving into + Unbiased Data Processing for Human Pose Estimation (CVPR 2020). + + Args: + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, use_target_weight, loss_weight=1.): + super().__init__() + self.criterion = nn.MSELoss(reduction='mean') + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight): + batch_size = output.size(0) + num_channels = output.size(1) + heatmaps_pred = output.reshape( + (batch_size, num_channels, -1)).split(1, 1) + heatmaps_gt = target.reshape( + (batch_size, num_channels, -1)).split(1, 1) + loss = 0. + num_joints = num_channels // 3 + for idx in range(num_joints): + heatmap_pred = heatmaps_pred[idx * 3].squeeze() + heatmap_gt = heatmaps_gt[idx * 3].squeeze() + offset_x_pred = heatmaps_pred[idx * 3 + 1].squeeze() + offset_x_gt = heatmaps_gt[idx * 3 + 1].squeeze() + offset_y_pred = heatmaps_pred[idx * 3 + 2].squeeze() + offset_y_gt = heatmaps_gt[idx * 3 + 2].squeeze() + if self.use_target_weight: + heatmap_pred = heatmap_pred * target_weight[:, idx] + heatmap_gt = heatmap_gt * target_weight[:, idx] + # classification loss + loss += 0.5 * self.criterion(heatmap_pred, heatmap_gt) + # regression loss + loss += 0.5 * self.criterion(heatmap_gt * offset_x_pred, + heatmap_gt * offset_x_gt) + loss += 0.5 * self.criterion(heatmap_gt * offset_y_pred, + heatmap_gt * offset_y_gt) + return loss / num_joints * self.loss_weight + + +class JointsOHKMMSELoss(nn.Module): + """MSE loss with online hard keypoint mining. + + Args: + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + topk (int): Only top k joint losses are kept. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, use_target_weight=False, topk=8, loss_weight=1.): + super().__init__() + assert topk > 0 + self.criterion = nn.MSELoss(reduction='none') + self.use_target_weight = use_target_weight + self.topk = topk + self.loss_weight = loss_weight + + def _ohkm(self, loss): + """Online hard keypoint mining.""" + ohkm_loss = 0. + N = len(loss) + for i in range(N): + sub_loss = loss[i] + _, topk_idx = torch.topk( + sub_loss, k=self.topk, dim=0, sorted=False) + tmp_loss = torch.gather(sub_loss, 0, topk_idx) + ohkm_loss += torch.sum(tmp_loss) / self.topk + ohkm_loss /= N + return ohkm_loss + + def forward(self, output, target, target_weight): + """Forward function.""" + batch_size = output.size(0) + num_joints = output.size(1) + if num_joints < self.topk: + raise ValueError(f'topk ({self.topk}) should not ' + f'larger than num_joints ({num_joints}).') + heatmaps_pred = output.reshape( + (batch_size, num_joints, -1)).split(1, 1) + heatmaps_gt = target.reshape((batch_size, num_joints, -1)).split(1, 1) + + losses = [] + for idx in range(num_joints): + heatmap_pred = heatmaps_pred[idx].squeeze(1) + heatmap_gt = heatmaps_gt[idx].squeeze(1) + if self.use_target_weight: + losses.append( + self.criterion(heatmap_pred * target_weight[:, idx], + heatmap_gt * target_weight[:, idx])) + else: + losses.append(self.criterion(heatmap_pred, heatmap_gt)) + + losses = [loss.mean(dim=1).unsqueeze(dim=1) for loss in losses] + losses = torch.cat(losses, dim=1) + + return self._ohkm(losses) * self.loss_weight diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/multi_loss_factory.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/multi_loss_factory.py new file mode 100644 index 0000000000000000000000000000000000000000..8ec9ae358cafd663c6f067ae8f01d42522e0031d --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/multi_loss_factory.py @@ -0,0 +1,279 @@ +# ------------------------------------------------------------------------------ +# Adapted from https://github.com/HRNet/HigherHRNet-Human-Pose-Estimation +# Original licence: Copyright (c) Microsoft, under the MIT License. +# ------------------------------------------------------------------------------ + +import torch +import torch.nn as nn + + +__all__ = ['HeatmapLoss', 'AELoss', 'MultiLossFactory'] + + +def _make_input(t, requires_grad=False, device=torch.device('cpu')): + """Make zero inputs for AE loss. + + Args: + t (torch.Tensor): input + requires_grad (bool): Option to use requires_grad. + device: torch device + + Returns: + torch.Tensor: zero input. + """ + inp = torch.autograd.Variable(t, requires_grad=requires_grad) + inp = inp.sum() + inp = inp.to(device) + return inp + + +class HeatmapLoss(nn.Module): + """Accumulate the heatmap loss for each image in the batch. + + Args: + supervise_empty (bool): Whether to supervise empty channels. + """ + + def __init__(self, supervise_empty=True): + super().__init__() + self.supervise_empty = supervise_empty + + def forward(self, pred, gt, mask): + """Forward function. + + Note: + - batch_size: N + - heatmaps weight: W + - heatmaps height: H + - max_num_people: M + - num_keypoints: K + + Args: + pred (torch.Tensor[N,K,H,W]):heatmap of output. + gt (torch.Tensor[N,K,H,W]): target heatmap. + mask (torch.Tensor[N,H,W]): mask of target. + """ + assert pred.size() == gt.size( + ), f'pred.size() is {pred.size()}, gt.size() is {gt.size()}' + + if not self.supervise_empty: + empty_mask = (gt.sum(dim=[2, 3], keepdim=True) > 0).float() + loss = ((pred - gt)**2) * empty_mask.expand_as( + pred) * mask[:, None, :, :].expand_as(pred) + else: + loss = ((pred - gt)**2) * mask[:, None, :, :].expand_as(pred) + loss = loss.mean(dim=3).mean(dim=2).mean(dim=1) + return loss + + +class AELoss(nn.Module): + """Associative Embedding loss. + + `Associative Embedding: End-to-End Learning for Joint Detection and + Grouping `_. + """ + + def __init__(self, loss_type): + super().__init__() + self.loss_type = loss_type + + def singleTagLoss(self, pred_tag, joints): + """Associative embedding loss for one image. + + Note: + - heatmaps weight: W + - heatmaps height: H + - max_num_people: M + - num_keypoints: K + + Args: + pred_tag (torch.Tensor[KxHxW,1]): tag of output for one image. + joints (torch.Tensor[M,K,2]): joints information for one image. + """ + tags = [] + pull = 0 + for joints_per_person in joints: + tmp = [] + for joint in joints_per_person: + if joint[1] > 0: + tmp.append(pred_tag[joint[0]]) + if len(tmp) == 0: + continue + tmp = torch.stack(tmp) + tags.append(torch.mean(tmp, dim=0)) + pull = pull + torch.mean((tmp - tags[-1].expand_as(tmp))**2) + + num_tags = len(tags) + if num_tags == 0: + return ( + _make_input(torch.zeros(1).float(), device=pred_tag.device), + _make_input(torch.zeros(1).float(), device=pred_tag.device)) + elif num_tags == 1: + return (_make_input( + torch.zeros(1).float(), device=pred_tag.device), pull) + + tags = torch.stack(tags) + + size = (num_tags, num_tags) + A = tags.expand(*size) + B = A.permute(1, 0) + + diff = A - B + + if self.loss_type == 'exp': + diff = torch.pow(diff, 2) + push = torch.exp(-diff) + push = torch.sum(push) - num_tags + elif self.loss_type == 'max': + diff = 1 - torch.abs(diff) + push = torch.clamp(diff, min=0).sum() - num_tags + else: + raise ValueError('Unknown ae loss type') + + push_loss = push / ((num_tags - 1) * num_tags) * 0.5 + pull_loss = pull / (num_tags) + + return push_loss, pull_loss + + def forward(self, tags, joints): + """Accumulate the tag loss for each image in the batch. + + Note: + - batch_size: N + - heatmaps weight: W + - heatmaps height: H + - max_num_people: M + - num_keypoints: K + + Args: + tags (torch.Tensor[N,KxHxW,1]): tag channels of output. + joints (torch.Tensor[N,M,K,2]): joints information. + """ + pushes, pulls = [], [] + joints = joints.cpu().data.numpy() + batch_size = tags.size(0) + for i in range(batch_size): + push, pull = self.singleTagLoss(tags[i], joints[i]) + pushes.append(push) + pulls.append(pull) + return torch.stack(pushes), torch.stack(pulls) + + +class MultiLossFactory(nn.Module): + """Loss for bottom-up models. + + Args: + num_joints (int): Number of keypoints. + num_stages (int): Number of stages. + ae_loss_type (str): Type of ae loss. + with_ae_loss (list[bool]): Use ae loss or not in multi-heatmap. + push_loss_factor (list[float]): + Parameter of push loss in multi-heatmap. + pull_loss_factor (list[float]): + Parameter of pull loss in multi-heatmap. + with_heatmap_loss (list[bool]): + Use heatmap loss or not in multi-heatmap. + heatmaps_loss_factor (list[float]): + Parameter of heatmap loss in multi-heatmap. + supervise_empty (bool): Whether to supervise empty channels. + """ + + def __init__(self, + num_joints, + num_stages, + ae_loss_type, + with_ae_loss, + push_loss_factor, + pull_loss_factor, + with_heatmaps_loss, + heatmaps_loss_factor, + supervise_empty=True): + super().__init__() + + assert isinstance(with_heatmaps_loss, (list, tuple)), \ + 'with_heatmaps_loss should be a list or tuple' + assert isinstance(heatmaps_loss_factor, (list, tuple)), \ + 'heatmaps_loss_factor should be a list or tuple' + assert isinstance(with_ae_loss, (list, tuple)), \ + 'with_ae_loss should be a list or tuple' + assert isinstance(push_loss_factor, (list, tuple)), \ + 'push_loss_factor should be a list or tuple' + assert isinstance(pull_loss_factor, (list, tuple)), \ + 'pull_loss_factor should be a list or tuple' + + self.num_joints = num_joints + self.num_stages = num_stages + self.ae_loss_type = ae_loss_type + self.with_ae_loss = with_ae_loss + self.push_loss_factor = push_loss_factor + self.pull_loss_factor = pull_loss_factor + self.with_heatmaps_loss = with_heatmaps_loss + self.heatmaps_loss_factor = heatmaps_loss_factor + + self.heatmaps_loss = \ + nn.ModuleList( + [ + HeatmapLoss(supervise_empty) + if with_heatmaps_loss else None + for with_heatmaps_loss in self.with_heatmaps_loss + ] + ) + + self.ae_loss = \ + nn.ModuleList( + [ + AELoss(self.ae_loss_type) if with_ae_loss else None + for with_ae_loss in self.with_ae_loss + ] + ) + + def forward(self, outputs, heatmaps, masks, joints): + """Forward function to calculate losses. + + Note: + - batch_size: N + - heatmaps weight: W + - heatmaps height: H + - max_num_people: M + - num_keypoints: K + - output_channel: C C=2K if use ae loss else K + + Args: + outputs (list(torch.Tensor[N,C,H,W])): outputs of stages. + heatmaps (list(torch.Tensor[N,K,H,W])): target of heatmaps. + masks (list(torch.Tensor[N,H,W])): masks of heatmaps. + joints (list(torch.Tensor[N,M,K,2])): joints of ae loss. + """ + heatmaps_losses = [] + push_losses = [] + pull_losses = [] + for idx in range(len(outputs)): + offset_feat = 0 + if self.heatmaps_loss[idx]: + heatmaps_pred = outputs[idx][:, :self.num_joints] + offset_feat = self.num_joints + heatmaps_loss = self.heatmaps_loss[idx](heatmaps_pred, + heatmaps[idx], + masks[idx]) + heatmaps_loss = heatmaps_loss * self.heatmaps_loss_factor[idx] + heatmaps_losses.append(heatmaps_loss) + else: + heatmaps_losses.append(None) + + if self.ae_loss[idx]: + tags_pred = outputs[idx][:, offset_feat:] + batch_size = tags_pred.size()[0] + tags_pred = tags_pred.contiguous().view(batch_size, -1, 1) + + push_loss, pull_loss = self.ae_loss[idx](tags_pred, + joints[idx]) + push_loss = push_loss * self.push_loss_factor[idx] + pull_loss = pull_loss * self.pull_loss_factor[idx] + + push_losses.append(push_loss) + pull_losses.append(pull_loss) + else: + push_losses.append(None) + pull_losses.append(None) + + return heatmaps_losses, push_losses, pull_losses diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/regression_loss.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/regression_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..58a29dd6400cb6ddbabcc76afda34116f24c84ae --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/losses/regression_loss.py @@ -0,0 +1,444 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +__all__ = ['SmoothL1Loss', 'SoftWingLoss', 'SoftWingLoss', + 'L1Loss', 'MPJPELoss', 'MSELoss', 'BoneLoss', + 'SemiSupervisionLoss'] + + +class SmoothL1Loss(nn.Module): + """SmoothL1Loss loss. + + Args: + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.criterion = F.smooth_l1_loss + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + - dimension of keypoints: D (D=2 or D=3) + + Args: + output (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + target_weight (torch.Tensor[N, K, D]): + Weights across different joint types. + """ + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output * target_weight, + target * target_weight) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight + + +class WingLoss(nn.Module): + """Wing Loss. paper ref: 'Wing Loss for Robust Facial Landmark Localisation + with Convolutional Neural Networks' Feng et al. CVPR'2018. + + Args: + omega (float): Also referred to as width. + epsilon (float): Also referred to as curvature. + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, + omega=10.0, + epsilon=2.0, + use_target_weight=False, + loss_weight=1.): + super().__init__() + self.omega = omega + self.epsilon = epsilon + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + # constant that smoothly links the piecewise-defined linear + # and nonlinear parts + self.C = self.omega * (1.0 - math.log(1.0 + self.omega / self.epsilon)) + + def criterion(self, pred, target): + """Criterion of wingloss. + + Note: + - batch_size: N + - num_keypoints: K + - dimension of keypoints: D (D=2 or D=3) + + Args: + pred (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + """ + delta = (target - pred).abs() + losses = torch.where( + delta < self.omega, + self.omega * torch.log(1.0 + delta / self.epsilon), delta - self.C) + return torch.mean(torch.sum(losses, dim=[1, 2]), dim=0) + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + - dimension of keypoints: D (D=2 or D=3) + + Args: + output (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + target_weight (torch.Tensor[N,K,D]): + Weights across different joint types. + """ + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output * target_weight, + target * target_weight) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight + + + +class SoftWingLoss(nn.Module): + """Soft Wing Loss 'Structure-Coherent Deep Feature Learning for Robust Face + Alignment' Lin et al. TIP'2021. + + loss = + 1. |x| , if |x| < omega1 + 2. omega2*ln(1+|x|/epsilon) + B, if |x| >= omega1 + + Args: + omega1 (float): The first threshold. + omega2 (float): The second threshold. + epsilon (float): Also referred to as curvature. + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, + omega1=2.0, + omega2=20.0, + epsilon=0.5, + use_target_weight=False, + loss_weight=1.): + super().__init__() + self.omega1 = omega1 + self.omega2 = omega2 + self.epsilon = epsilon + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + # constant that smoothly links the piecewise-defined linear + # and nonlinear parts + self.B = self.omega1 - self.omega2 * math.log(1.0 + self.omega1 / + self.epsilon) + + def criterion(self, pred, target): + """Criterion of wingloss. + + Note: + batch_size: N + num_keypoints: K + dimension of keypoints: D (D=2 or D=3) + + Args: + pred (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + """ + delta = (target - pred).abs() + losses = torch.where( + delta < self.omega1, delta, + self.omega2 * torch.log(1.0 + delta / self.epsilon) + self.B) + return torch.mean(torch.sum(losses, dim=[1, 2]), dim=0) + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + batch_size: N + num_keypoints: K + dimension of keypoints: D (D=2 or D=3) + + Args: + output (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + target_weight (torch.Tensor[N, K, D]): + Weights across different joint types. + """ + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output * target_weight, + target * target_weight) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight + + +class MPJPELoss(nn.Module): + """MPJPE (Mean Per Joint Position Error) loss. + + Args: + use_target_weight (bool): Option to use weighted MSE loss. + Different joint types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + - dimension of keypoints: D (D=2 or D=3) + + Args: + output (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + target_weight (torch.Tensor[N,K,D]): + Weights across different joint types. + """ + + if self.use_target_weight: + assert target_weight is not None + loss = torch.mean( + torch.norm((output - target) * target_weight, dim=-1)) + else: + loss = torch.mean(torch.norm(output - target, dim=-1)) + + return loss * self.loss_weight + + +class L1Loss(nn.Module): + """L1Loss loss .""" + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.criterion = F.l1_loss + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + + Args: + output (torch.Tensor[N, K, 2]): Output regression. + target (torch.Tensor[N, K, 2]): Target regression. + target_weight (torch.Tensor[N, K, 2]): + Weights across different joint types. + """ + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output * target_weight, + target * target_weight) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight + + +class MSELoss(nn.Module): + """MSE loss for coordinate regression.""" + + def __init__(self, use_target_weight=False, loss_weight=1.): + super().__init__() + self.criterion = F.mse_loss + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + + Args: + output (torch.Tensor[N, K, 2]): Output regression. + target (torch.Tensor[N, K, 2]): Target regression. + target_weight (torch.Tensor[N, K, 2]): + Weights across different joint types. + """ + if self.use_target_weight: + assert target_weight is not None + loss = self.criterion(output * target_weight, + target * target_weight) + else: + loss = self.criterion(output, target) + + return loss * self.loss_weight + + +class BoneLoss(nn.Module): + """Bone length loss. + + Args: + joint_parents (list): Indices of each joint's parent joint. + use_target_weight (bool): Option to use weighted bone loss. + Different bone types may have different target weights. + loss_weight (float): Weight of the loss. Default: 1.0. + """ + + def __init__(self, joint_parents, use_target_weight=False, loss_weight=1.): + super().__init__() + self.joint_parents = joint_parents + self.use_target_weight = use_target_weight + self.loss_weight = loss_weight + + self.non_root_indices = [] + for i in range(len(self.joint_parents)): + if i != self.joint_parents[i]: + self.non_root_indices.append(i) + + def forward(self, output, target, target_weight=None): + """Forward function. + + Note: + - batch_size: N + - num_keypoints: K + - dimension of keypoints: D (D=2 or D=3) + + Args: + output (torch.Tensor[N, K, D]): Output regression. + target (torch.Tensor[N, K, D]): Target regression. + target_weight (torch.Tensor[N, K-1]): + Weights across different bone types. + """ + output_bone = torch.norm( + output - output[:, self.joint_parents, :], + dim=-1)[:, self.non_root_indices] + target_bone = torch.norm( + target - target[:, self.joint_parents, :], + dim=-1)[:, self.non_root_indices] + if self.use_target_weight: + assert target_weight is not None + loss = torch.mean( + torch.abs((output_bone * target_weight).mean(dim=0) - + (target_bone * target_weight).mean(dim=0))) + else: + loss = torch.mean( + torch.abs(output_bone.mean(dim=0) - target_bone.mean(dim=0))) + + return loss * self.loss_weight + + +class SemiSupervisionLoss(nn.Module): + """Semi-supervision loss for unlabeled data. It is composed of projection + loss and bone loss. + + Paper ref: `3D human pose estimation in video with temporal convolutions + and semi-supervised training` Dario Pavllo et al. CVPR'2019. + + Args: + joint_parents (list): Indices of each joint's parent joint. + projection_loss_weight (float): Weight for projection loss. + bone_loss_weight (float): Weight for bone loss. + warmup_iterations (int): Number of warmup iterations. In the first + `warmup_iterations` iterations, the model is trained only on + labeled data, and semi-supervision loss will be 0. + This is a workaround since currently we cannot access + epoch number in loss functions. Note that the iteration number in + an epoch can be changed due to different GPU numbers in multi-GPU + settings. So please set this parameter carefully. + warmup_iterations = dataset_size // samples_per_gpu // gpu_num + * warmup_epochs + """ + + def __init__(self, + joint_parents, + projection_loss_weight=1., + bone_loss_weight=1., + warmup_iterations=0): + super().__init__() + self.criterion_projection = MPJPELoss( + loss_weight=projection_loss_weight) + self.criterion_bone = BoneLoss( + joint_parents, loss_weight=bone_loss_weight) + self.warmup_iterations = warmup_iterations + self.num_iterations = 0 + + @staticmethod + def project_joints(x, intrinsics): + """Project 3D joint coordinates to 2D image plane using camera + intrinsic parameters. + + Args: + x (torch.Tensor[N, K, 3]): 3D joint coordinates. + intrinsics (torch.Tensor[N, 4] | torch.Tensor[N, 9]): Camera + intrinsics: f (2), c (2), k (3), p (2). + """ + while intrinsics.dim() < x.dim(): + intrinsics.unsqueeze_(1) + f = intrinsics[..., :2] + c = intrinsics[..., 2:4] + _x = torch.clamp(x[:, :, :2] / x[:, :, 2:], -1, 1) + if intrinsics.shape[-1] == 9: + k = intrinsics[..., 4:7] + p = intrinsics[..., 7:9] + + r2 = torch.sum(_x[:, :, :2]**2, dim=-1, keepdim=True) + radial = 1 + torch.sum( + k * torch.cat((r2, r2**2, r2**3), dim=-1), + dim=-1, + keepdim=True) + tan = torch.sum(p * _x, dim=-1, keepdim=True) + _x = _x * (radial + tan) + p * r2 + _x = f * _x + c + return _x + + def forward(self, output, target): + losses = dict() + + self.num_iterations += 1 + if self.num_iterations <= self.warmup_iterations: + return losses + + labeled_pose = output['labeled_pose'] + unlabeled_pose = output['unlabeled_pose'] + unlabeled_traj = output['unlabeled_traj'] + unlabeled_target_2d = target['unlabeled_target_2d'] + intrinsics = target['intrinsics'] + + # projection loss + unlabeled_output = unlabeled_pose + unlabeled_traj + unlabeled_output_2d = self.project_joints(unlabeled_output, intrinsics) + loss_proj = self.criterion_projection(unlabeled_output_2d, + unlabeled_target_2d, None) + losses['proj_loss'] = loss_proj + + # bone loss + loss_bone = self.criterion_bone(unlabeled_pose, labeled_pose, None) + losses['bone_loss'] = loss_bone + + return losses diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/model.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/model.py new file mode 100644 index 0000000000000000000000000000000000000000..2c0ff63256138b71172f73dbbe6316a9adde6a3f --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/model.py @@ -0,0 +1,24 @@ +import torch.nn as nn + +from .backbone.vit import ViT +from .head.topdown_heatmap_simple_head import TopdownHeatmapSimpleHead + + +__all__ = ['ViTPose'] + + +class ViTPose(nn.Module): + def __init__(self, cfg: dict) -> None: + super(ViTPose, self).__init__() + + backbone_cfg = {k: v for k, v in cfg['backbone'].items() if k != 'type'} + head_cfg = {k: v for k, v in cfg['keypoint_head'].items() if k != 'type'} + + self.backbone = ViT(**backbone_cfg) + self.keypoint_head = TopdownHeatmapSimpleHead(**head_cfg) + + def forward_features(self, x): + return self.backbone(x) + + def forward(self, x): + return self.keypoint_head(self.backbone(x)) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/optimizer.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..4614259691866f160e686fac651af3519e283f66 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_models/optimizer.py @@ -0,0 +1,15 @@ +import torch.optim as optim + +class LayerDecayOptimizer: + def __init__(self, optimizer, layerwise_decay_rate): + self.optimizer = optimizer + self.layerwise_decay_rate = layerwise_decay_rate + self.param_groups = optimizer.param_groups + + def step(self, *args, **kwargs): + for i, group in enumerate(self.optimizer.param_groups): + group['lr'] *= self.layerwise_decay_rate[i] + self.optimizer.step(*args, **kwargs) + + def zero_grad(self, *args, **kwargs): + self.optimizer.zero_grad(*args, **kwargs) \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/.ipynb_checkpoints/train_valid_fn-checkpoint.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/.ipynb_checkpoints/train_valid_fn-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..a127c28e79278be6f9f3b2c3c59aa4d3dd13bb5b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/.ipynb_checkpoints/train_valid_fn-checkpoint.py @@ -0,0 +1,162 @@ +import os.path as osp + +import torch +import torch.nn as nn + +from vit_models.losses import JointsMSELoss +from vit_models.optimizer import LayerDecayOptimizer + +from torch.nn.parallel import DataParallel, DistributedDataParallel +from torch.nn.utils import clip_grad_norm_ +from torch.optim import AdamW +from torch.optim.lr_scheduler import LambdaLR, MultiStepLR +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler +from torch.cuda.amp import autocast, GradScaler +from tqdm import tqdm +from time import time + +from vit_utils.dist_util import get_dist_info, init_dist +from vit_utils.logging import get_root_logger + +@torch.no_grad() +def valid_model(model: nn.Module, dataloaders: DataLoader, criterion: nn.Module, cfg: dict) -> None: + total_loss = 0 + total_metric = 0 + model.eval() + for dataloader in dataloaders: + for batch_idx, batch in enumerate(dataloader): + images, targets, target_weights, __ = batch + images = images.to('cuda') + targets = targets.to('cuda') + target_weights = target_weights.to('cuda') + + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + total_loss += loss.item() + + avg_loss = total_loss/(len(dataloader)*len(dataloaders)) + return avg_loss + +def train_model(model: nn.Module, datasets_train: Dataset, datasets_valid: Dataset, cfg: dict, distributed: bool, validate: bool, timestamp: str, meta: dict) -> None: + logger = get_root_logger() + + # Prepare data loaders + datasets_train = datasets_train if isinstance(datasets_train, (list, tuple)) else [datasets_train] + datasets_valid = datasets_valid if isinstance(datasets_valid, (list, tuple)) else [datasets_valid] + + if distributed: + samplers_train = [DistributedSampler(ds, num_replicas=len(cfg.gpu_ids), rank=torch.cuda.current_device(), shuffle=True, drop_last=False) for ds in datasets_train] + samplers_valid = [DistributedSampler(ds, num_replicas=len(cfg.gpu_ids), rank=torch.cuda.current_device(), shuffle=False, drop_last=False) for ds in datasets_valid] + else: + samplers_train = [None for ds in datasets_train] + samplers_valid = [None for ds in datasets_valid] + + dataloaders_train = [DataLoader(ds, batch_size=cfg.data['samples_per_gpu'], shuffle=True, sampler=sampler, num_workers=cfg.data['workers_per_gpu'], pin_memory=False) for ds, sampler in zip(datasets_train, samplers_train)] + dataloaders_valid = [DataLoader(ds, batch_size=cfg.data['samples_per_gpu'], shuffle=False, sampler=sampler, num_workers=cfg.data['workers_per_gpu'], pin_memory=False) for ds, sampler in zip(datasets_valid, samplers_valid)] + + # put model on gpus + if distributed: + find_unused_parameters = cfg.get('find_unused_parameters', False) + # Sets the `find_unused_parameters` parameter in + # torch.nn.parallel.DistributedDataParallel + + model = DistributedDataParallel( + module=model, + device_ids=[torch.cuda.current_device()], + broadcast_buffers=False, + find_unused_parameters=find_unused_parameters) + else: + model = DataParallel(model, device_ids=cfg.gpu_ids) + + # Loss function + criterion = JointsMSELoss(use_target_weight=cfg.model['keypoint_head']['loss_keypoint']['use_target_weight']) + + # Optimizer + optimizer = AdamW(model.parameters(), lr=cfg.optimizer['lr'], betas=cfg.optimizer['betas'], weight_decay=cfg.optimizer['weight_decay']) + + # Layer-wise learning rate decay + lr_mult = [cfg.optimizer['paramwise_cfg']['layer_decay_rate']] * cfg.optimizer['paramwise_cfg']['num_layers'] + layerwise_optimizer = LayerDecayOptimizer(optimizer, lr_mult) + + + # Learning rate scheduler (MultiStepLR) + milestones = cfg.lr_config['step'] + gamma = 0.1 + scheduler = MultiStepLR(optimizer, milestones, gamma) + + # Warm-up scheduler + num_warmup_steps = cfg.lr_config['warmup_iters'] # Number of warm-up steps + warmup_factor = cfg.lr_config['warmup_ratio'] # Initial learning rate = warmup_factor * learning_rate + warmup_scheduler = LambdaLR( + optimizer, + lr_lambda=lambda step: warmup_factor + (1.0 - warmup_factor) * step / num_warmup_steps + ) + + # AMP setting + if cfg.use_amp: + logger.info("Using Automatic Mixed Precision (AMP) training...") + # Create a GradScaler object for FP16 training + scaler = GradScaler() + + # Logging config + total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + logger.info(f'''\n + #========= [Train Configs] =========# + # - Num GPUs: {len(cfg.gpu_ids)} + # - Batch size (per gpu): {cfg.data['samples_per_gpu']} + # - LR: {cfg.optimizer['lr']: .6f} + # - Num params: {total_params:,d} + # - AMP: {cfg.use_amp} + #===================================# + ''') + + global_step = 0 + for dataloader in dataloaders_train: + for epoch in range(cfg.total_epochs): + model.train() + train_pbar = tqdm(dataloader) + total_loss = 0 + tic = time() + for batch_idx, batch in enumerate(train_pbar): + layerwise_optimizer.zero_grad() + + images, targets, target_weights, __ = batch + images = images.to('cuda') + targets = targets.to('cuda') + target_weights = target_weights.to('cuda') + + if cfg.use_amp: + with autocast(): + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + scaler.scale(loss).backward() + clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip']) + scaler.step(layerwise_optimizer) + scaler.update() + else: + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + loss.backward() + clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip']) + layerwise_optimizer.step() + + if global_step < num_warmup_steps: + warmup_scheduler.step() + global_step += 1 + + total_loss += loss.item() + train_pbar.set_description(f"🏋️> Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Loss {loss.item():.4f} | LR {optimizer.param_groups[0]['lr']:.6f} | Step") + scheduler.step() + + avg_loss_train = total_loss/len(dataloader) + logger.info(f"[Summary-train] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (train) {avg_loss_train:.4f} --- {time()-tic:.5f} sec. elapsed") + ckpt_name = f"epoch{str(epoch).zfill(3)}.pth" + ckpt_path = osp.join(cfg.work_dir, ckpt_name) + torch.save(model.module.state_dict(), ckpt_path) + + # validation + if validate: + tic2 = time() + avg_loss_valid = valid_model(model, dataloaders_valid, criterion, cfg) + logger.info(f"[Summary-valid] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (valid) {avg_loss_valid:.4f} --- {time()-tic2:.5f} sec. elapsed") diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b7522fd601bc77a0b0947a7f26a9f98d42bbc6e --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__init__.py @@ -0,0 +1,6 @@ +from .util import * +from .top_down_eval import * +from .post_processing import * +from .visualization import * +from .dist_util import * +from .logging import * diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2af401adb6dc64830365dc32b9b415be54b1616 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/dist_util.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/dist_util.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5da7e1648f9eac9095d1d09f65c88313a48e166 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/dist_util.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/logging.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/logging.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..468089158358c2fc2e3da4945adddbf015894c55 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/logging.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/top_down_eval.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/top_down_eval.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69f42e03b14bf5ff45085133ae119f6274b8d58f Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/top_down_eval.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/train_valid_fn.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/train_valid_fn.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b11589573caec1252c8e27e6d84ecc68e84b7cc Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/train_valid_fn.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/transform.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/transform.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0b463db02863d9c01cc85e52f48b9d0504f66c9 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/transform.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/util.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/util.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9dffcb50361d809a55a3fed87bda4274c9632319 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/util.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/visualization.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/visualization.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8578e31bd7c146dd591e3762e540bfbe645af466 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/__pycache__/visualization.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/dist_util.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/dist_util.py new file mode 100644 index 0000000000000000000000000000000000000000..a61150b93e64cccce6d7ce7395a6b96009468429 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/dist_util.py @@ -0,0 +1,212 @@ +# Copyright (c) OpenMMLab. All rights reserved. +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import functools +import os +import socket +import subprocess +from collections import OrderedDict +from typing import Callable, List, Optional, Tuple + +import torch +import torch.multiprocessing as mp +from torch import distributed as dist +from torch._utils import (_flatten_dense_tensors, _take_tensors, + _unflatten_dense_tensors) + + +def is_mps_available() -> bool: + """Return True if mps devices exist. + + It's specialized for mac m1 chips and require torch version 1.12 or higher. + """ + try: + import torch + return hasattr(torch.backends, + 'mps') and torch.backends.mps.is_available() + except Exception: + return False + +def _find_free_port() -> str: + # Copied from https://github.com/facebookresearch/detectron2/blob/main/detectron2/engine/launch.py # noqa: E501 + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + # Binding to port 0 will cause the OS to find an available port for us + sock.bind(('', 0)) + port = sock.getsockname()[1] + sock.close() + # NOTE: there is still a chance the port could be taken by other processes. + return port + + +def _is_free_port(port: int) -> bool: + ips = socket.gethostbyname_ex(socket.gethostname())[-1] + ips.append('localhost') + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + return all(s.connect_ex((ip, port)) != 0 for ip in ips) + + +def init_dist(launcher: str, backend: str = 'nccl', **kwargs) -> None: + if mp.get_start_method(allow_none=True) is None: + mp.set_start_method('spawn') + if launcher == 'pytorch': + _init_dist_pytorch(backend, **kwargs) + elif launcher == 'mpi': + _init_dist_mpi(backend, **kwargs) + elif launcher == 'slurm': + _init_dist_slurm(backend, **kwargs) + else: + raise ValueError(f'Invalid launcher type: {launcher}') + + +def _init_dist_pytorch(backend: str, **kwargs) -> None: + # TODO: use local_rank instead of rank % num_gpus + rank = int(os.environ['RANK']) + num_gpus = torch.cuda.device_count() + torch.cuda.set_device(rank % num_gpus) + dist.init_process_group(backend=backend, **kwargs) + + +def _init_dist_mpi(backend: str, **kwargs) -> None: + local_rank = int(os.environ['OMPI_COMM_WORLD_LOCAL_RANK']) + torch.cuda.set_device(local_rank) + if 'MASTER_PORT' not in os.environ: + # 29500 is torch.distributed default port + os.environ['MASTER_PORT'] = '29500' + if 'MASTER_ADDR' not in os.environ: + raise KeyError('The environment variable MASTER_ADDR is not set') + os.environ['WORLD_SIZE'] = os.environ['OMPI_COMM_WORLD_SIZE'] + os.environ['RANK'] = os.environ['OMPI_COMM_WORLD_RANK'] + dist.init_process_group(backend=backend, **kwargs) + + +def _init_dist_slurm(backend: str, port: Optional[int] = None) -> None: + """Initialize slurm distributed training environment. + + If argument ``port`` is not specified, then the master port will be system + environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system + environment variable, then a default port ``29500`` will be used. + + Args: + backend (str): Backend of torch.distributed. + port (int, optional): Master port. Defaults to None. + """ + proc_id = int(os.environ['SLURM_PROCID']) + ntasks = int(os.environ['SLURM_NTASKS']) + node_list = os.environ['SLURM_NODELIST'] + num_gpus = torch.cuda.device_count() + torch.cuda.set_device(proc_id % num_gpus) + addr = subprocess.getoutput( + f'scontrol show hostname {node_list} | head -n1') + # specify master port + if port is not None: + os.environ['MASTER_PORT'] = str(port) + elif 'MASTER_PORT' in os.environ: + pass # use MASTER_PORT in the environment variable + else: + # if torch.distributed default port(29500) is available + # then use it, else find a free port + if _is_free_port(29500): + os.environ['MASTER_PORT'] = '29500' + else: + os.environ['MASTER_PORT'] = str(_find_free_port()) + # use MASTER_ADDR in the environment variable if it already exists + if 'MASTER_ADDR' not in os.environ: + os.environ['MASTER_ADDR'] = addr + os.environ['WORLD_SIZE'] = str(ntasks) + os.environ['LOCAL_RANK'] = str(proc_id % num_gpus) + os.environ['RANK'] = str(proc_id) + dist.init_process_group(backend=backend) + + +def get_dist_info() -> Tuple[int, int]: + if dist.is_available() and dist.is_initialized(): + rank = dist.get_rank() + world_size = dist.get_world_size() + else: + rank = 0 + world_size = 1 + return rank, world_size + + +def master_only(func: Callable) -> Callable: + + @functools.wraps(func) + def wrapper(*args, **kwargs): + rank, _ = get_dist_info() + if rank == 0: + return func(*args, **kwargs) + + return wrapper + + +def allreduce_params(params: List[torch.nn.Parameter], + coalesce: bool = True, + bucket_size_mb: int = -1) -> None: + """Allreduce parameters. + + Args: + params (list[torch.nn.Parameter]): List of parameters or buffers + of a model. + coalesce (bool, optional): Whether allreduce parameters as a whole. + Defaults to True. + bucket_size_mb (int, optional): Size of bucket, the unit is MB. + Defaults to -1. + """ + _, world_size = get_dist_info() + if world_size == 1: + return + params = [param.data for param in params] + if coalesce: + _allreduce_coalesced(params, world_size, bucket_size_mb) + else: + for tensor in params: + dist.all_reduce(tensor.div_(world_size)) + + +def allreduce_grads(params: List[torch.nn.Parameter], + coalesce: bool = True, + bucket_size_mb: int = -1) -> None: + """Allreduce gradients. + + Args: + params (list[torch.nn.Parameter]): List of parameters of a model. + coalesce (bool, optional): Whether allreduce parameters as a whole. + Defaults to True. + bucket_size_mb (int, optional): Size of bucket, the unit is MB. + Defaults to -1. + """ + grads = [ + param.grad.data for param in params + if param.requires_grad and param.grad is not None + ] + _, world_size = get_dist_info() + if world_size == 1: + return + if coalesce: + _allreduce_coalesced(grads, world_size, bucket_size_mb) + else: + for tensor in grads: + dist.all_reduce(tensor.div_(world_size)) + + +def _allreduce_coalesced(tensors: torch.Tensor, + world_size: int, + bucket_size_mb: int = -1) -> None: + if bucket_size_mb > 0: + bucket_size_bytes = bucket_size_mb * 1024 * 1024 + buckets = _take_tensors(tensors, bucket_size_bytes) + else: + buckets = OrderedDict() + for tensor in tensors: + tp = tensor.type() + if tp not in buckets: + buckets[tp] = [] + buckets[tp].append(tensor) + buckets = buckets.values() + + for bucket in buckets: + flat_tensors = _flatten_dense_tensors(bucket) + dist.all_reduce(flat_tensors) + flat_tensors.div_(world_size) + for tensor, synced in zip( + bucket, _unflatten_dense_tensors(flat_tensors, bucket)): + tensor.copy_(synced) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/inference.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..af209130f85f88e59a7e0e4676249552cab2bbb0 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/inference.py @@ -0,0 +1,94 @@ +import cv2 +import numpy as np +import json + + +rotation_map = { + 0: None, + 90: cv2.ROTATE_90_COUNTERCLOCKWISE, + 180: cv2.ROTATE_180, + 270: cv2.ROTATE_90_CLOCKWISE +} + +class NumpyEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, np.ndarray): + return obj.tolist() + return json.JSONEncoder.default(self, obj) + +def draw_bboxes(image, bounding_boxes, boxes_id, scores): + image_with_boxes = image.copy() + + for bbox, bbox_id, score in zip(bounding_boxes, boxes_id, scores): + x1, y1, x2, y2 = bbox + cv2.rectangle(image_with_boxes, (x1, y1), (x2, y2), (128, 128, 0), 2) + + label = f'#{bbox_id}: {score:.2f}' + + (label_width, label_height), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1) + label_x = x1 + label_y = y1 - 5 if y1 > 20 else y1 + 20 + + # Draw a filled rectangle as the background for the label + cv2.rectangle(image_with_boxes, (x1, label_y - label_height - 5), + (x1 + label_width, label_y + 5), (128, 128, 0), cv2.FILLED) + cv2.putText(image_with_boxes, label, (label_x, label_y), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1) + + return image_with_boxes + + +def pad_image(image: np.ndarray, aspect_ratio: float) -> np.ndarray: + # Get the current aspect ratio of the image + image_height, image_width = image.shape[:2] + current_aspect_ratio = image_width / image_height + + left_pad = 0 + top_pad = 0 + # Determine whether to pad horizontally or vertically + if current_aspect_ratio < aspect_ratio: + # Pad horizontally + target_width = int(aspect_ratio * image_height) + pad_width = target_width - image_width + left_pad = pad_width // 2 + right_pad = pad_width - left_pad + + padded_image = np.pad(image, + pad_width=((0, 0), (left_pad, right_pad), (0, 0)), + mode='constant') + else: + # Pad vertically + target_height = int(image_width / aspect_ratio) + pad_height = target_height - image_height + top_pad = pad_height // 2 + bottom_pad = pad_height - top_pad + + padded_image = np.pad(image, + pad_width=((top_pad, bottom_pad), (0, 0), (0, 0)), + mode='constant') + + return padded_image, (left_pad, top_pad) + + +class VideoReader(object): + def __init__(self, file_name, rotate=0): + self.file_name = file_name + self.rotate = rotation_map[rotate] + try: # OpenCV needs int to read from webcam + self.file_name = int(file_name) + except ValueError: + pass + + def __iter__(self): + self.cap = cv2.VideoCapture(self.file_name) + if not self.cap.isOpened(): + raise IOError('Video {} cannot be opened'.format(self.file_name)) + return self + + def __next__(self): + was_read, img = self.cap.read() + if not was_read: + raise StopIteration + if self.rotate is not None: + img = cv2.rotate(img, self.rotate) + return cv2.cvtColor(img, cv2.COLOR_BGR2RGB) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/logging.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/logging.py new file mode 100644 index 0000000000000000000000000000000000000000..4e62c00c3eb234d694880f1099b8a5e80a7d1d4a --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/logging.py @@ -0,0 +1,133 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import logging + +import torch.distributed as dist + +logger_initialized: dict = {} + + +def get_logger(name, log_file=None, log_level=logging.INFO, file_mode='w'): + """Initialize and get a logger by name. + + If the logger has not been initialized, this method will initialize the + logger by adding one or two handlers, otherwise the initialized logger will + be directly returned. During initialization, a StreamHandler will always be + added. If `log_file` is specified and the process rank is 0, a FileHandler + will also be added. + + Args: + name (str): Logger name. + log_file (str | None): The log filename. If specified, a FileHandler + will be added to the logger. + log_level (int): The logger level. Note that only the process of + rank 0 is affected, and other processes will set the level to + "Error" thus be silent most of the time. + file_mode (str): The file mode used in opening log file. + Defaults to 'w'. + + Returns: + logging.Logger: The expected logger. + """ + logger = logging.getLogger(name) + if name in logger_initialized: + return logger + # handle hierarchical names + # e.g., logger "a" is initialized, then logger "a.b" will skip the + # initialization since it is a child of "a". + for logger_name in logger_initialized: + if name.startswith(logger_name): + return logger + + # handle duplicate logs to the console + # Starting in 1.8.0, PyTorch DDP attaches a StreamHandler (NOTSET) + # to the root logger. As logger.propagate is True by default, this root + # level handler causes logging messages from rank>0 processes to + # unexpectedly show up on the console, creating much unwanted clutter. + # To fix this issue, we set the root logger's StreamHandler, if any, to log + # at the ERROR level. + for handler in logger.root.handlers: + if type(handler) is logging.StreamHandler: + handler.setLevel(logging.ERROR) + + stream_handler = logging.StreamHandler() + handlers = [stream_handler] + + if dist.is_available() and dist.is_initialized(): + rank = dist.get_rank() + else: + rank = 0 + + # only rank 0 will add a FileHandler + if rank == 0 and log_file is not None: + # Here, the default behaviour of the official logger is 'a'. Thus, we + # provide an interface to change the file mode to the default + # behaviour. + file_handler = logging.FileHandler(log_file, file_mode) + handlers.append(file_handler) + + formatter = logging.Formatter( + '%(asctime)s - %(name)s - %(levelname)s - %(message)s') + for handler in handlers: + handler.setFormatter(formatter) + handler.setLevel(log_level) + logger.addHandler(handler) + + if rank == 0: + logger.setLevel(log_level) + else: + logger.setLevel(logging.ERROR) + + logger_initialized[name] = True + + return logger + + +def print_log(msg, logger=None, level=logging.INFO): + """Print a log message. + + Args: + msg (str): The message to be logged. + logger (logging.Logger | str | None): The logger to be used. + Some special loggers are: + + - "silent": no message will be printed. + - other str: the logger obtained with `get_root_logger(logger)`. + - None: The `print()` method will be used to print log messages. + level (int): Logging level. Only available when `logger` is a Logger + object or "root". + """ + if logger is None: + print(msg) + elif isinstance(logger, logging.Logger): + logger.log(level, msg) + elif logger == 'silent': + pass + elif isinstance(logger, str): + _logger = get_logger(logger) + _logger.log(level, msg) + else: + raise TypeError( + 'logger should be either a logging.Logger object, str, ' + f'"silent" or None, but got {type(logger)}') + + +def get_root_logger(log_file=None, log_level=logging.INFO): + """Use `get_logger` method in mmcv to get the root logger. + + The logger will be initialized if it has not been initialized. By default a + StreamHandler will be added. If `log_file` is specified, a FileHandler will + also be added. The name of the root logger is the top-level package name, + e.g., "mmpose". + + Args: + log_file (str | None): The log filename. If specified, a FileHandler + will be added to the root logger. + log_level (int): The root logger level. Note that only the process of + rank 0 is affected, while other processes will set the level to + "Error" and be silent most of the time. + + Returns: + logging.Logger: The root logger. + """ + return get_logger(__name__.split('.')[0], log_file, log_level) + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.c b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.c new file mode 100644 index 0000000000000000000000000000000000000000..9a38c0fc78adf50c8ea77ae6652b86e8f4858372 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.c @@ -0,0 +1,7952 @@ +/* Generated by Cython 0.29.32 */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_32" +#define CYTHON_HEX_VERSION 0x001D20F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #endif + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__cpu_nms +#define __PYX_HAVE_API__cpu_nms +/* Early includes */ +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "cpu_nms.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":690 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":691 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":692 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":693 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":697 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":698 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":700 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":704 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":705 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":714 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":715 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":716 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":718 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":719 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":720 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":722 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":723 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":725 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":726 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":727 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":729 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":730 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":731 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":733 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* BufferIndexError.proto */ +static void __Pyx_RaiseBufferIndexError(int axis); + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; + +/* Module declarations from 'cpu_nms' */ +static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_7cpu_nms_max(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/ +static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_7cpu_nms_min(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int_t = { "int_t", NULL, sizeof(__pyx_t_5numpy_int_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int_t), 0 }; +#define __Pyx_MODULE_NAME "cpu_nms" +extern int __pyx_module_is_main_cpu_nms; +int __pyx_module_is_main_cpu_nms = 0; + +/* Implementation of 'cpu_nms' */ +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_h[] = "h"; +static const char __pyx_k_i[] = "i"; +static const char __pyx_k_j[] = "_j"; +static const char __pyx_k_w[] = "w"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_x1[] = "x1"; +static const char __pyx_k_x2[] = "x2"; +static const char __pyx_k_y1[] = "y1"; +static const char __pyx_k_y2[] = "y2"; +static const char __pyx_k_i_2[] = "_i"; +static const char __pyx_k_int[] = "int"; +static const char __pyx_k_ix1[] = "ix1"; +static const char __pyx_k_ix2[] = "ix2"; +static const char __pyx_k_iy1[] = "iy1"; +static const char __pyx_k_iy2[] = "iy2"; +static const char __pyx_k_j_2[] = "j"; +static const char __pyx_k_ovr[] = "ovr"; +static const char __pyx_k_xx1[] = "xx1"; +static const char __pyx_k_xx2[] = "xx2"; +static const char __pyx_k_yy1[] = "yy1"; +static const char __pyx_k_yy2[] = "yy2"; +static const char __pyx_k_dets[] = "dets"; +static const char __pyx_k_keep[] = "keep"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_areas[] = "areas"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_iarea[] = "iarea"; +static const char __pyx_k_inter[] = "inter"; +static const char __pyx_k_ndets[] = "ndets"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_order[] = "order"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_astype[] = "astype"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_scores[] = "scores"; +static const char __pyx_k_thresh[] = "thresh"; +static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_cpu_nms[] = "cpu_nms"; +static const char __pyx_k_suppressed[] = "suppressed"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_cpu_nms_pyx[] = "cpu_nms.pyx"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_n_s_areas; +static PyObject *__pyx_n_s_argsort; +static PyObject *__pyx_n_s_astype; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_cpu_nms; +static PyObject *__pyx_kp_s_cpu_nms_pyx; +static PyObject *__pyx_n_s_dets; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_h; +static PyObject *__pyx_n_s_i; +static PyObject *__pyx_n_s_i_2; +static PyObject *__pyx_n_s_iarea; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_int; +static PyObject *__pyx_n_s_inter; +static PyObject *__pyx_n_s_ix1; +static PyObject *__pyx_n_s_ix2; +static PyObject *__pyx_n_s_iy1; +static PyObject *__pyx_n_s_iy2; +static PyObject *__pyx_n_s_j; +static PyObject *__pyx_n_s_j_2; +static PyObject *__pyx_n_s_keep; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_ndets; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_order; +static PyObject *__pyx_n_s_ovr; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_scores; +static PyObject *__pyx_n_s_suppressed; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_thresh; +static PyObject *__pyx_n_s_w; +static PyObject *__pyx_n_s_x1; +static PyObject *__pyx_n_s_x2; +static PyObject *__pyx_n_s_xx1; +static PyObject *__pyx_n_s_xx2; +static PyObject *__pyx_n_s_y1; +static PyObject *__pyx_n_s_y2; +static PyObject *__pyx_n_s_yy1; +static PyObject *__pyx_n_s_yy2; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_7cpu_nms_cpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh); /* proto */ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_slice__7; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_codeobj__11; +/* Late includes */ + +/* "cpu_nms.pyx":14 + * cimport numpy as np + * + * cdef inline np.float32_t max(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<< + * return a if a >= b else b + * + */ + +static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_7cpu_nms_max(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) { + __pyx_t_5numpy_float32_t __pyx_r; + __Pyx_RefNannyDeclarations + __pyx_t_5numpy_float32_t __pyx_t_1; + __Pyx_RefNannySetupContext("max", 0); + + /* "cpu_nms.pyx":15 + * + * cdef inline np.float32_t max(np.float32_t a, np.float32_t b): + * return a if a >= b else b # <<<<<<<<<<<<<< + * + * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): + */ + if (((__pyx_v_a >= __pyx_v_b) != 0)) { + __pyx_t_1 = __pyx_v_a; + } else { + __pyx_t_1 = __pyx_v_b; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "cpu_nms.pyx":14 + * cimport numpy as np + * + * cdef inline np.float32_t max(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<< + * return a if a >= b else b + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpu_nms.pyx":17 + * return a if a >= b else b + * + * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<< + * return a if a <= b else b + * + */ + +static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_7cpu_nms_min(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) { + __pyx_t_5numpy_float32_t __pyx_r; + __Pyx_RefNannyDeclarations + __pyx_t_5numpy_float32_t __pyx_t_1; + __Pyx_RefNannySetupContext("min", 0); + + /* "cpu_nms.pyx":18 + * + * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): + * return a if a <= b else b # <<<<<<<<<<<<<< + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + */ + if (((__pyx_v_a <= __pyx_v_b) != 0)) { + __pyx_t_1 = __pyx_v_a; + } else { + __pyx_t_1 = __pyx_v_b; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "cpu_nms.pyx":17 + * return a if a >= b else b + * + * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<< + * return a if a <= b else b + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpu_nms.pyx":20 + * return a if a <= b else b + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7cpu_nms_1cpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_7cpu_nms_1cpu_nms = {"cpu_nms", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7cpu_nms_1cpu_nms, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7cpu_nms_1cpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_dets = 0; + PyObject *__pyx_v_thresh = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cpu_nms (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("cpu_nms", 1, 2, 2, 1); __PYX_ERR(0, 20, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cpu_nms") < 0)) __PYX_ERR(0, 20, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_dets = ((PyArrayObject *)values[0]); + __pyx_v_thresh = ((PyObject*)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cpu_nms", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("cpu_nms.cpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 20, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 20, __pyx_L1_error) + __pyx_r = __pyx_pf_7cpu_nms_cpu_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7cpu_nms_cpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh) { + PyArrayObject *__pyx_v_x1 = 0; + PyArrayObject *__pyx_v_y1 = 0; + PyArrayObject *__pyx_v_x2 = 0; + PyArrayObject *__pyx_v_y2 = 0; + PyArrayObject *__pyx_v_scores = 0; + PyArrayObject *__pyx_v_areas = 0; + PyArrayObject *__pyx_v_order = 0; + int __pyx_v_ndets; + PyArrayObject *__pyx_v_suppressed = 0; + int __pyx_v__i; + int __pyx_v__j; + int __pyx_v_i; + int __pyx_v_j; + __pyx_t_5numpy_float32_t __pyx_v_ix1; + __pyx_t_5numpy_float32_t __pyx_v_iy1; + __pyx_t_5numpy_float32_t __pyx_v_ix2; + __pyx_t_5numpy_float32_t __pyx_v_iy2; + __pyx_t_5numpy_float32_t __pyx_v_iarea; + __pyx_t_5numpy_float32_t __pyx_v_xx1; + __pyx_t_5numpy_float32_t __pyx_v_yy1; + __pyx_t_5numpy_float32_t __pyx_v_xx2; + __pyx_t_5numpy_float32_t __pyx_v_yy2; + __pyx_t_5numpy_float32_t __pyx_v_w; + __pyx_t_5numpy_float32_t __pyx_v_h; + __pyx_t_5numpy_float32_t __pyx_v_inter; + __pyx_t_5numpy_float32_t __pyx_v_ovr; + PyObject *__pyx_v_keep = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_areas; + __Pyx_Buffer __pyx_pybuffer_areas; + __Pyx_LocalBuf_ND __pyx_pybuffernd_dets; + __Pyx_Buffer __pyx_pybuffer_dets; + __Pyx_LocalBuf_ND __pyx_pybuffernd_order; + __Pyx_Buffer __pyx_pybuffer_order; + __Pyx_LocalBuf_ND __pyx_pybuffernd_scores; + __Pyx_Buffer __pyx_pybuffer_scores; + __Pyx_LocalBuf_ND __pyx_pybuffernd_suppressed; + __Pyx_Buffer __pyx_pybuffer_suppressed; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x1; + __Pyx_Buffer __pyx_pybuffer_x1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x2; + __Pyx_Buffer __pyx_pybuffer_x2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_y1; + __Pyx_Buffer __pyx_pybuffer_y1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_y2; + __Pyx_Buffer __pyx_pybuffer_y2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyArrayObject *__pyx_t_2 = NULL; + PyArrayObject *__pyx_t_3 = NULL; + PyArrayObject *__pyx_t_4 = NULL; + PyArrayObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyArrayObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyArrayObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyArrayObject *__pyx_t_13 = NULL; + int __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + int __pyx_t_21; + int __pyx_t_22; + int __pyx_t_23; + __pyx_t_5numpy_float32_t __pyx_t_24; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cpu_nms", 0); + __pyx_pybuffer_x1.pybuffer.buf = NULL; + __pyx_pybuffer_x1.refcount = 0; + __pyx_pybuffernd_x1.data = NULL; + __pyx_pybuffernd_x1.rcbuffer = &__pyx_pybuffer_x1; + __pyx_pybuffer_y1.pybuffer.buf = NULL; + __pyx_pybuffer_y1.refcount = 0; + __pyx_pybuffernd_y1.data = NULL; + __pyx_pybuffernd_y1.rcbuffer = &__pyx_pybuffer_y1; + __pyx_pybuffer_x2.pybuffer.buf = NULL; + __pyx_pybuffer_x2.refcount = 0; + __pyx_pybuffernd_x2.data = NULL; + __pyx_pybuffernd_x2.rcbuffer = &__pyx_pybuffer_x2; + __pyx_pybuffer_y2.pybuffer.buf = NULL; + __pyx_pybuffer_y2.refcount = 0; + __pyx_pybuffernd_y2.data = NULL; + __pyx_pybuffernd_y2.rcbuffer = &__pyx_pybuffer_y2; + __pyx_pybuffer_scores.pybuffer.buf = NULL; + __pyx_pybuffer_scores.refcount = 0; + __pyx_pybuffernd_scores.data = NULL; + __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores; + __pyx_pybuffer_areas.pybuffer.buf = NULL; + __pyx_pybuffer_areas.refcount = 0; + __pyx_pybuffernd_areas.data = NULL; + __pyx_pybuffernd_areas.rcbuffer = &__pyx_pybuffer_areas; + __pyx_pybuffer_order.pybuffer.buf = NULL; + __pyx_pybuffer_order.refcount = 0; + __pyx_pybuffernd_order.data = NULL; + __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order; + __pyx_pybuffer_suppressed.pybuffer.buf = NULL; + __pyx_pybuffer_suppressed.refcount = 0; + __pyx_pybuffernd_suppressed.data = NULL; + __pyx_pybuffernd_suppressed.rcbuffer = &__pyx_pybuffer_suppressed; + __pyx_pybuffer_dets.pybuffer.buf = NULL; + __pyx_pybuffer_dets.refcount = 0; + __pyx_pybuffernd_dets.data = NULL; + __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 20, __pyx_L1_error) + } + __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1]; + + /* "cpu_nms.pyx":21 + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_t_2 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x1.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_x1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 21, __pyx_L1_error) + } else {__pyx_pybuffernd_x1.diminfo[0].strides = __pyx_pybuffernd_x1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x1.diminfo[0].shape = __pyx_pybuffernd_x1.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_2 = 0; + __pyx_v_x1 = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":22 + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_3 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_y1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 22, __pyx_L1_error) + } else {__pyx_pybuffernd_y1.diminfo[0].strides = __pyx_pybuffernd_y1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y1.diminfo[0].shape = __pyx_pybuffernd_y1.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_3 = 0; + __pyx_v_y1 = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":23 + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_4 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x2.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_x2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 23, __pyx_L1_error) + } else {__pyx_pybuffernd_x2.diminfo[0].strides = __pyx_pybuffernd_x2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x2.diminfo[0].shape = __pyx_pybuffernd_x2.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_4 = 0; + __pyx_v_x2 = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":24 + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + * + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 24, __pyx_L1_error) + __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y2.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_y2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 24, __pyx_L1_error) + } else {__pyx_pybuffernd_y2.diminfo[0].strides = __pyx_pybuffernd_y2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y2.diminfo[0].shape = __pyx_pybuffernd_y2.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_5 = 0; + __pyx_v_y2 = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":25 + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 25, __pyx_L1_error) + } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_6 = 0; + __pyx_v_scores = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":27 + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + * + * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) # <<<<<<<<<<<<<< + * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1].astype('i') + * + */ + __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_x2), ((PyObject *)__pyx_v_x1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_y2), ((PyObject *)__pyx_v_y1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Multiply(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_t_9 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_areas.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_areas = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 27, __pyx_L1_error) + } else {__pyx_pybuffernd_areas.diminfo[0].strides = __pyx_pybuffernd_areas.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_areas.diminfo[0].shape = __pyx_pybuffernd_areas.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_9 = 0; + __pyx_v_areas = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":28 + * + * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) + * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1].astype('i') # <<<<<<<<<<<<<< + * + * cdef int ndets = dets.shape[0] + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_slice__7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_n_s_i) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_n_s_i); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_11 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 28, __pyx_L1_error) + } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_11 = 0; + __pyx_v_order = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "cpu_nms.pyx":30 + * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1].astype('i') + * + * cdef int ndets = dets.shape[0] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.int_t, ndim=1] suppressed = \ + * np.zeros((ndets), dtype=np.int) + */ + __pyx_v_ndets = (__pyx_v_dets->dimensions[0]); + + /* "cpu_nms.pyx":32 + * cdef int ndets = dets.shape[0] + * cdef np.ndarray[np.int_t, ndim=1] suppressed = \ + * np.zeros((ndets), dtype=np.int) # <<<<<<<<<<<<<< + * + * # nominal indices + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ndets); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, __pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_13 = ((PyArrayObject *)__pyx_t_12); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { + __pyx_v_suppressed = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 31, __pyx_L1_error) + } else {__pyx_pybuffernd_suppressed.diminfo[0].strides = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_suppressed.diminfo[0].shape = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_13 = 0; + __pyx_v_suppressed = ((PyArrayObject *)__pyx_t_12); + __pyx_t_12 = 0; + + /* "cpu_nms.pyx":45 + * cdef np.float32_t inter, ovr + * + * keep = [] # <<<<<<<<<<<<<< + * for _i in range(ndets): + * i = order[_i] + */ + __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_v_keep = ((PyObject*)__pyx_t_12); + __pyx_t_12 = 0; + + /* "cpu_nms.pyx":46 + * + * keep = [] + * for _i in range(ndets): # <<<<<<<<<<<<<< + * i = order[_i] + * if suppressed[i] == 1: + */ + __pyx_t_14 = __pyx_v_ndets; + __pyx_t_15 = __pyx_t_14; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { + __pyx_v__i = __pyx_t_16; + + /* "cpu_nms.pyx":47 + * keep = [] + * for _i in range(ndets): + * i = order[_i] # <<<<<<<<<<<<<< + * if suppressed[i] == 1: + * continue + */ + __pyx_t_17 = __pyx_v__i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_order.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 47, __pyx_L1_error) + } + __pyx_v_i = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_order.diminfo[0].strides)); + + /* "cpu_nms.pyx":48 + * for _i in range(ndets): + * i = order[_i] + * if suppressed[i] == 1: # <<<<<<<<<<<<<< + * continue + * keep.append(i) + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_suppressed.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 48, __pyx_L1_error) + } + __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0); + if (__pyx_t_19) { + + /* "cpu_nms.pyx":49 + * i = order[_i] + * if suppressed[i] == 1: + * continue # <<<<<<<<<<<<<< + * keep.append(i) + * ix1 = x1[i] + */ + goto __pyx_L3_continue; + + /* "cpu_nms.pyx":48 + * for _i in range(ndets): + * i = order[_i] + * if suppressed[i] == 1: # <<<<<<<<<<<<<< + * continue + * keep.append(i) + */ + } + + /* "cpu_nms.pyx":50 + * if suppressed[i] == 1: + * continue + * keep.append(i) # <<<<<<<<<<<<<< + * ix1 = x1[i] + * iy1 = y1[i] + */ + __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_keep, __pyx_t_12); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "cpu_nms.pyx":51 + * continue + * keep.append(i) + * ix1 = x1[i] # <<<<<<<<<<<<<< + * iy1 = y1[i] + * ix2 = x2[i] + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_x1.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 51, __pyx_L1_error) + } + __pyx_v_ix1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_x1.diminfo[0].strides)); + + /* "cpu_nms.pyx":52 + * keep.append(i) + * ix1 = x1[i] + * iy1 = y1[i] # <<<<<<<<<<<<<< + * ix2 = x2[i] + * iy2 = y2[i] + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_y1.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 52, __pyx_L1_error) + } + __pyx_v_iy1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_y1.diminfo[0].strides)); + + /* "cpu_nms.pyx":53 + * ix1 = x1[i] + * iy1 = y1[i] + * ix2 = x2[i] # <<<<<<<<<<<<<< + * iy2 = y2[i] + * iarea = areas[i] + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_x2.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 53, __pyx_L1_error) + } + __pyx_v_ix2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_x2.diminfo[0].strides)); + + /* "cpu_nms.pyx":54 + * iy1 = y1[i] + * ix2 = x2[i] + * iy2 = y2[i] # <<<<<<<<<<<<<< + * iarea = areas[i] + * for _j in range(_i + 1, ndets): + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_y2.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 54, __pyx_L1_error) + } + __pyx_v_iy2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_y2.diminfo[0].strides)); + + /* "cpu_nms.pyx":55 + * ix2 = x2[i] + * iy2 = y2[i] + * iarea = areas[i] # <<<<<<<<<<<<<< + * for _j in range(_i + 1, ndets): + * j = order[_j] + */ + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_areas.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_18 = 0; + if (unlikely(__pyx_t_18 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_18); + __PYX_ERR(0, 55, __pyx_L1_error) + } + __pyx_v_iarea = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_areas.diminfo[0].strides)); + + /* "cpu_nms.pyx":56 + * iy2 = y2[i] + * iarea = areas[i] + * for _j in range(_i + 1, ndets): # <<<<<<<<<<<<<< + * j = order[_j] + * if suppressed[j] == 1: + */ + __pyx_t_18 = __pyx_v_ndets; + __pyx_t_21 = __pyx_t_18; + for (__pyx_t_22 = (__pyx_v__i + 1); __pyx_t_22 < __pyx_t_21; __pyx_t_22+=1) { + __pyx_v__j = __pyx_t_22; + + /* "cpu_nms.pyx":57 + * iarea = areas[i] + * for _j in range(_i + 1, ndets): + * j = order[_j] # <<<<<<<<<<<<<< + * if suppressed[j] == 1: + * continue + */ + __pyx_t_17 = __pyx_v__j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_order.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 57, __pyx_L1_error) + } + __pyx_v_j = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_order.diminfo[0].strides)); + + /* "cpu_nms.pyx":58 + * for _j in range(_i + 1, ndets): + * j = order[_j] + * if suppressed[j] == 1: # <<<<<<<<<<<<<< + * continue + * xx1 = max(ix1, x1[j]) + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_suppressed.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 58, __pyx_L1_error) + } + __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0); + if (__pyx_t_19) { + + /* "cpu_nms.pyx":59 + * j = order[_j] + * if suppressed[j] == 1: + * continue # <<<<<<<<<<<<<< + * xx1 = max(ix1, x1[j]) + * yy1 = max(iy1, y1[j]) + */ + goto __pyx_L6_continue; + + /* "cpu_nms.pyx":58 + * for _j in range(_i + 1, ndets): + * j = order[_j] + * if suppressed[j] == 1: # <<<<<<<<<<<<<< + * continue + * xx1 = max(ix1, x1[j]) + */ + } + + /* "cpu_nms.pyx":60 + * if suppressed[j] == 1: + * continue + * xx1 = max(ix1, x1[j]) # <<<<<<<<<<<<<< + * yy1 = max(iy1, y1[j]) + * xx2 = min(ix2, x2[j]) + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_x1.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 60, __pyx_L1_error) + } + __pyx_v_xx1 = __pyx_f_7cpu_nms_max(__pyx_v_ix1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_x1.diminfo[0].strides))); + + /* "cpu_nms.pyx":61 + * continue + * xx1 = max(ix1, x1[j]) + * yy1 = max(iy1, y1[j]) # <<<<<<<<<<<<<< + * xx2 = min(ix2, x2[j]) + * yy2 = min(iy2, y2[j]) + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_y1.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_v_yy1 = __pyx_f_7cpu_nms_max(__pyx_v_iy1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_y1.diminfo[0].strides))); + + /* "cpu_nms.pyx":62 + * xx1 = max(ix1, x1[j]) + * yy1 = max(iy1, y1[j]) + * xx2 = min(ix2, x2[j]) # <<<<<<<<<<<<<< + * yy2 = min(iy2, y2[j]) + * w = max(0.0, xx2 - xx1 + 1) + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_x2.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 62, __pyx_L1_error) + } + __pyx_v_xx2 = __pyx_f_7cpu_nms_min(__pyx_v_ix2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_x2.diminfo[0].strides))); + + /* "cpu_nms.pyx":63 + * yy1 = max(iy1, y1[j]) + * xx2 = min(ix2, x2[j]) + * yy2 = min(iy2, y2[j]) # <<<<<<<<<<<<<< + * w = max(0.0, xx2 - xx1 + 1) + * h = max(0.0, yy2 - yy1 + 1) + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_y2.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 63, __pyx_L1_error) + } + __pyx_v_yy2 = __pyx_f_7cpu_nms_min(__pyx_v_iy2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_y2.diminfo[0].strides))); + + /* "cpu_nms.pyx":64 + * xx2 = min(ix2, x2[j]) + * yy2 = min(iy2, y2[j]) + * w = max(0.0, xx2 - xx1 + 1) # <<<<<<<<<<<<<< + * h = max(0.0, yy2 - yy1 + 1) + * inter = w * h + */ + __pyx_v_w = __pyx_f_7cpu_nms_max(0.0, ((__pyx_v_xx2 - __pyx_v_xx1) + 1.0)); + + /* "cpu_nms.pyx":65 + * yy2 = min(iy2, y2[j]) + * w = max(0.0, xx2 - xx1 + 1) + * h = max(0.0, yy2 - yy1 + 1) # <<<<<<<<<<<<<< + * inter = w * h + * ovr = inter / (iarea + areas[j] - inter) + */ + __pyx_v_h = __pyx_f_7cpu_nms_max(0.0, ((__pyx_v_yy2 - __pyx_v_yy1) + 1.0)); + + /* "cpu_nms.pyx":66 + * w = max(0.0, xx2 - xx1 + 1) + * h = max(0.0, yy2 - yy1 + 1) + * inter = w * h # <<<<<<<<<<<<<< + * ovr = inter / (iarea + areas[j] - inter) + * if ovr >= thresh: + */ + __pyx_v_inter = (__pyx_v_w * __pyx_v_h); + + /* "cpu_nms.pyx":67 + * h = max(0.0, yy2 - yy1 + 1) + * inter = w * h + * ovr = inter / (iarea + areas[j] - inter) # <<<<<<<<<<<<<< + * if ovr >= thresh: + * suppressed[j] = 1 + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_areas.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 67, __pyx_L1_error) + } + __pyx_t_24 = ((__pyx_v_iarea + (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_areas.diminfo[0].strides))) - __pyx_v_inter); + if (unlikely(__pyx_t_24 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 67, __pyx_L1_error) + } + __pyx_v_ovr = (__pyx_v_inter / __pyx_t_24); + + /* "cpu_nms.pyx":68 + * inter = w * h + * ovr = inter / (iarea + areas[j] - inter) + * if ovr >= thresh: # <<<<<<<<<<<<<< + * suppressed[j] = 1 + * + */ + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ovr); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_1 = PyObject_RichCompare(__pyx_t_12, __pyx_v_thresh, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_19 < 0)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_19) { + + /* "cpu_nms.pyx":69 + * ovr = inter / (iarea + areas[j] - inter) + * if ovr >= thresh: + * suppressed[j] = 1 # <<<<<<<<<<<<<< + * + * return keep + */ + __pyx_t_17 = __pyx_v_j; + __pyx_t_23 = -1; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_suppressed.diminfo[0].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_23 = 0; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_23 = 0; + if (unlikely(__pyx_t_23 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_23); + __PYX_ERR(0, 69, __pyx_L1_error) + } + *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_suppressed.diminfo[0].strides) = 1; + + /* "cpu_nms.pyx":68 + * inter = w * h + * ovr = inter / (iarea + areas[j] - inter) + * if ovr >= thresh: # <<<<<<<<<<<<<< + * suppressed[j] = 1 + * + */ + } + __pyx_L6_continue:; + } + __pyx_L3_continue:; + } + + /* "cpu_nms.pyx":71 + * suppressed[j] = 1 + * + * return keep # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_keep); + __pyx_r = __pyx_v_keep; + goto __pyx_L0; + + /* "cpu_nms.pyx":20 + * return a if a <= b else b + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cpu_nms.cpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x1); + __Pyx_XDECREF((PyObject *)__pyx_v_y1); + __Pyx_XDECREF((PyObject *)__pyx_v_x2); + __Pyx_XDECREF((PyObject *)__pyx_v_y2); + __Pyx_XDECREF((PyObject *)__pyx_v_scores); + __Pyx_XDECREF((PyObject *)__pyx_v_areas); + __Pyx_XDECREF((PyObject *)__pyx_v_order); + __Pyx_XDECREF((PyObject *)__pyx_v_suppressed); + __Pyx_XDECREF(__pyx_v_keep); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":736 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":739 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":742 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":745 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":748 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":752 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":754 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":930 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":931 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":934 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":936 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":937 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":943 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":944 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 945, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":949 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":950 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 951, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":955 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":956 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":957 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 957, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + */ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_cpu_nms(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_cpu_nms}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "cpu_nms", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_s_areas, __pyx_k_areas, sizeof(__pyx_k_areas), 0, 0, 1, 1}, + {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, + {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_cpu_nms, __pyx_k_cpu_nms, sizeof(__pyx_k_cpu_nms), 0, 0, 1, 1}, + {&__pyx_kp_s_cpu_nms_pyx, __pyx_k_cpu_nms_pyx, sizeof(__pyx_k_cpu_nms_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_dets, __pyx_k_dets, sizeof(__pyx_k_dets), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_h, __pyx_k_h, sizeof(__pyx_k_h), 0, 0, 1, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_i_2, __pyx_k_i_2, sizeof(__pyx_k_i_2), 0, 0, 1, 1}, + {&__pyx_n_s_iarea, __pyx_k_iarea, sizeof(__pyx_k_iarea), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1}, + {&__pyx_n_s_inter, __pyx_k_inter, sizeof(__pyx_k_inter), 0, 0, 1, 1}, + {&__pyx_n_s_ix1, __pyx_k_ix1, sizeof(__pyx_k_ix1), 0, 0, 1, 1}, + {&__pyx_n_s_ix2, __pyx_k_ix2, sizeof(__pyx_k_ix2), 0, 0, 1, 1}, + {&__pyx_n_s_iy1, __pyx_k_iy1, sizeof(__pyx_k_iy1), 0, 0, 1, 1}, + {&__pyx_n_s_iy2, __pyx_k_iy2, sizeof(__pyx_k_iy2), 0, 0, 1, 1}, + {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_j_2, __pyx_k_j_2, sizeof(__pyx_k_j_2), 0, 0, 1, 1}, + {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_ndets, __pyx_k_ndets, sizeof(__pyx_k_ndets), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, + {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, + {&__pyx_n_s_ovr, __pyx_k_ovr, sizeof(__pyx_k_ovr), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_scores, __pyx_k_scores, sizeof(__pyx_k_scores), 0, 0, 1, 1}, + {&__pyx_n_s_suppressed, __pyx_k_suppressed, sizeof(__pyx_k_suppressed), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1}, + {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1}, + {&__pyx_n_s_x1, __pyx_k_x1, sizeof(__pyx_k_x1), 0, 0, 1, 1}, + {&__pyx_n_s_x2, __pyx_k_x2, sizeof(__pyx_k_x2), 0, 0, 1, 1}, + {&__pyx_n_s_xx1, __pyx_k_xx1, sizeof(__pyx_k_xx1), 0, 0, 1, 1}, + {&__pyx_n_s_xx2, __pyx_k_xx2, sizeof(__pyx_k_xx2), 0, 0, 1, 1}, + {&__pyx_n_s_y1, __pyx_k_y1, sizeof(__pyx_k_y1), 0, 0, 1, 1}, + {&__pyx_n_s_y2, __pyx_k_y2, sizeof(__pyx_k_y2), 0, 0, 1, 1}, + {&__pyx_n_s_yy1, __pyx_k_yy1, sizeof(__pyx_k_yy1), 0, 0, 1, 1}, + {&__pyx_n_s_yy2, __pyx_k_yy2, sizeof(__pyx_k_yy2), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "cpu_nms.pyx":21 + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "cpu_nms.pyx":22 + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + */ + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_1); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "cpu_nms.pyx":23 + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + */ + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_2); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "cpu_nms.pyx":24 + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + * + */ + __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_3); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "cpu_nms.pyx":25 + * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) + */ + __pyx_tuple__6 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_4); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "cpu_nms.pyx":28 + * + * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) + * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1].astype('i') # <<<<<<<<<<<<<< + * + * cdef int ndets = dets.shape[0] + */ + __pyx_slice__7 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__7)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__7); + __Pyx_GIVEREF(__pyx_slice__7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "cpu_nms.pyx":20 + * return a if a <= b else b + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + */ + __pyx_tuple__10 = PyTuple_Pack(29, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_x1, __pyx_n_s_y1, __pyx_n_s_x2, __pyx_n_s_y2, __pyx_n_s_scores, __pyx_n_s_areas, __pyx_n_s_order, __pyx_n_s_ndets, __pyx_n_s_suppressed, __pyx_n_s_i_2, __pyx_n_s_j, __pyx_n_s_i, __pyx_n_s_j_2, __pyx_n_s_ix1, __pyx_n_s_iy1, __pyx_n_s_ix2, __pyx_n_s_iy2, __pyx_n_s_iarea, __pyx_n_s_xx1, __pyx_n_s_yy1, __pyx_n_s_xx2, __pyx_n_s_yy2, __pyx_n_s_w, __pyx_n_s_h, __pyx_n_s_inter, __pyx_n_s_ovr, __pyx_n_s_keep); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 29, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cpu_nms_pyx, __pyx_n_s_cpu_nms, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcpu_nms(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcpu_nms(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_cpu_nms(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_cpu_nms(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_cpu_nms(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'cpu_nms' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cpu_nms(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("cpu_nms", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_cpu_nms) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "cpu_nms")) { + if (unlikely(PyDict_SetItemString(modules, "cpu_nms", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "cpu_nms.pyx":11 + * from __future__ import print_function + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cpu_nms.pyx":20 + * return a if a <= b else b + * + * def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7cpu_nms_1cpu_nms, NULL, __pyx_n_s_cpu_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cpu_nms, __pyx_t_1) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cpu_nms.pyx":1 + * # ------------------------------------------------------------------------------ # <<<<<<<<<<<<<< + * # Copyright (c) Microsoft + * # Licensed under the MIT License. + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init cpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init cpu_nms"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ + #if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +#else + if (likely(PyCFunction_Check(func))) +#endif + { + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCall2Args */ + static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* BufferIndexError */ + static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-37m-x86_64-linux-gnu.so b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-37m-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..15f053c5364a7aa75f568dac77c74be7b2fc3b24 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-37m-x86_64-linux-gnu.so differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-39-x86_64-linux-gnu.so b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-39-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..d9da25778d89e0baab25d1ad350ffe74d8f659bb Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.cpython-39-x86_64-linux-gnu.so differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.pyx b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.pyx new file mode 100644 index 0000000000000000000000000000000000000000..bcc41ac9ee670922b84cd7fe2582948c75a14999 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/cpu_nms.pyx @@ -0,0 +1,71 @@ +# ------------------------------------------------------------------------------ +# Copyright (c) Microsoft +# Licensed under the MIT License. +# Written by Bin Xiao (Bin.Xiao@microsoft.com) +# ------------------------------------------------------------------------------ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +cimport numpy as np + +cdef inline np.float32_t max(np.float32_t a, np.float32_t b): + return a if a >= b else b + +cdef inline np.float32_t min(np.float32_t a, np.float32_t b): + return a if a <= b else b + +def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): + cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] + cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] + cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] + cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] + cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] + + cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) + cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1].astype('i') + + cdef int ndets = dets.shape[0] + cdef np.ndarray[np.int_t, ndim=1] suppressed = \ + np.zeros((ndets), dtype=np.int) + + # nominal indices + cdef int _i, _j + # sorted indices + cdef int i, j + # temp variables for box i's (the box currently under consideration) + cdef np.float32_t ix1, iy1, ix2, iy2, iarea + # variables for computing overlap with box j (lower scoring box) + cdef np.float32_t xx1, yy1, xx2, yy2 + cdef np.float32_t w, h + cdef np.float32_t inter, ovr + + keep = [] + for _i in range(ndets): + i = order[_i] + if suppressed[i] == 1: + continue + keep.append(i) + ix1 = x1[i] + iy1 = y1[i] + ix2 = x2[i] + iy2 = y2[i] + iarea = areas[i] + for _j in range(_i + 1, ndets): + j = order[_j] + if suppressed[j] == 1: + continue + xx1 = max(ix1, x1[j]) + yy1 = max(iy1, y1[j]) + xx2 = min(ix2, x2[j]) + yy2 = min(iy2, y2[j]) + w = max(0.0, xx2 - xx1 + 1) + h = max(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (iarea + areas[j] - inter) + if ovr >= thresh: + suppressed[j] = 1 + + return keep diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpp b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7a90201f49e02a9a1e6fbcc458ad951032ee717c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpp @@ -0,0 +1,7357 @@ +/* Generated by Cython 0.29.32 */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_32" +#define CYTHON_HEX_VERSION 0x001D20F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #endif + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__gpu_nms +#define __PYX_HAVE_API__gpu_nms +/* Early includes */ +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + +#include "gpu_nms.hpp" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "gpu_nms.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":690 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":691 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":692 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":693 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":697 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":698 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":700 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":704 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":705 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":714 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":715 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":716 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":718 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":719 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":720 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":722 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":723 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":725 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":726 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":727 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":729 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":730 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":731 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":733 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* BufferIndexError.proto */ +static void __Pyx_RaiseBufferIndexError(int axis); + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; + +/* Module declarations from 'gpu_nms' */ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t = { "int32_t", NULL, sizeof(__pyx_t_5numpy_int32_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int32_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int32_t), 0 }; +#define __Pyx_MODULE_NAME "gpu_nms" +extern int __pyx_module_is_main_gpu_nms; +int __pyx_module_is_main_gpu_nms = 0; + +/* Implementation of 'gpu_nms' */ +static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_dets[] = "dets"; +static const char __pyx_k_keep[] = "keep"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_int32[] = "int32"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_order[] = "order"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_astype[] = "astype"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_scores[] = "scores"; +static const char __pyx_k_thresh[] = "thresh"; +static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_gpu_nms[] = "gpu_nms"; +static const char __pyx_k_num_out[] = "num_out"; +static const char __pyx_k_boxes_dim[] = "boxes_dim"; +static const char __pyx_k_boxes_num[] = "boxes_num"; +static const char __pyx_k_device_id[] = "device_id"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_gpu_nms_pyx[] = "gpu_nms.pyx"; +static const char __pyx_k_sorted_dets[] = "sorted_dets"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_n_s_argsort; +static PyObject *__pyx_n_s_astype; +static PyObject *__pyx_n_s_boxes_dim; +static PyObject *__pyx_n_s_boxes_num; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_dets; +static PyObject *__pyx_n_s_device_id; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_gpu_nms; +static PyObject *__pyx_kp_s_gpu_nms_pyx; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_int32; +static PyObject *__pyx_n_s_keep; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_num_out; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_order; +static PyObject *__pyx_n_s_scores; +static PyObject *__pyx_n_s_sorted_dets; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_thresh; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id); /* proto */ +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_slice__3; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_codeobj__7; +/* Late includes */ + +/* "gpu_nms.pyx":19 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_7gpu_nms_1gpu_nms = {"gpu_nms", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7gpu_nms_1gpu_nms, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_dets = 0; + PyObject *__pyx_v_thresh = 0; + __pyx_t_5numpy_int32_t __pyx_v_device_id; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("gpu_nms (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,&__pyx_n_s_device_id,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("gpu_nms", 0, 2, 3, 1); __PYX_ERR(0, 19, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_device_id); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gpu_nms") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_dets = ((PyArrayObject *)values[0]); + __pyx_v_thresh = ((PyObject*)values[1]); + if (values[2]) { + __pyx_v_device_id = __Pyx_PyInt_As_npy_int32(values[2]); if (unlikely((__pyx_v_device_id == ((npy_int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 20, __pyx_L3_error) + } else { + __pyx_v_device_id = ((__pyx_t_5numpy_int32_t)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("gpu_nms", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gpu_nms.gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 19, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_r = __pyx_pf_7gpu_nms_gpu_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh, __pyx_v_device_id); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id) { + int __pyx_v_boxes_num; + int __pyx_v_boxes_dim; + int __pyx_v_num_out; + PyArrayObject *__pyx_v_keep = 0; + PyArrayObject *__pyx_v_scores = 0; + PyArrayObject *__pyx_v_order = 0; + PyArrayObject *__pyx_v_sorted_dets = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_dets; + __Pyx_Buffer __pyx_pybuffer_dets; + __Pyx_LocalBuf_ND __pyx_pybuffernd_keep; + __Pyx_Buffer __pyx_pybuffer_keep; + __Pyx_LocalBuf_ND __pyx_pybuffernd_order; + __Pyx_Buffer __pyx_pybuffer_order; + __Pyx_LocalBuf_ND __pyx_pybuffernd_scores; + __Pyx_Buffer __pyx_pybuffer_scores; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sorted_dets; + __Pyx_Buffer __pyx_pybuffer_sorted_dets; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + PyArrayObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + PyArrayObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + float __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("gpu_nms", 0); + __pyx_pybuffer_keep.pybuffer.buf = NULL; + __pyx_pybuffer_keep.refcount = 0; + __pyx_pybuffernd_keep.data = NULL; + __pyx_pybuffernd_keep.rcbuffer = &__pyx_pybuffer_keep; + __pyx_pybuffer_scores.pybuffer.buf = NULL; + __pyx_pybuffer_scores.refcount = 0; + __pyx_pybuffernd_scores.data = NULL; + __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores; + __pyx_pybuffer_order.pybuffer.buf = NULL; + __pyx_pybuffer_order.refcount = 0; + __pyx_pybuffernd_order.data = NULL; + __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order; + __pyx_pybuffer_sorted_dets.pybuffer.buf = NULL; + __pyx_pybuffer_sorted_dets.refcount = 0; + __pyx_pybuffernd_sorted_dets.data = NULL; + __pyx_pybuffernd_sorted_dets.rcbuffer = &__pyx_pybuffer_sorted_dets; + __pyx_pybuffer_dets.pybuffer.buf = NULL; + __pyx_pybuffer_dets.refcount = 0; + __pyx_pybuffernd_dets.data = NULL; + __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 19, __pyx_L1_error) + } + __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1]; + + /* "gpu_nms.pyx":21 + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] # <<<<<<<<<<<<<< + * cdef int boxes_dim = dets.shape[1] + * cdef int num_out + */ + __pyx_v_boxes_num = (__pyx_v_dets->dimensions[0]); + + /* "gpu_nms.pyx":22 + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + * cdef int boxes_dim = dets.shape[1] # <<<<<<<<<<<<<< + * cdef int num_out + * cdef np.ndarray[np.int32_t, ndim=1] \ + */ + __pyx_v_boxes_dim = (__pyx_v_dets->dimensions[1]); + + /* "gpu_nms.pyx":25 + * cdef int num_out + * cdef np.ndarray[np.int32_t, ndim=1] \ + * keep = np.zeros(boxes_num, dtype=np.int32) # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_boxes_num); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_keep = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 24, __pyx_L1_error) + } else {__pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_6 = 0; + __pyx_v_keep = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "gpu_nms.pyx":27 + * keep = np.zeros(boxes_num, dtype=np.int32) + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.int32_t, ndim=1] \ + * order = scores.argsort()[::-1].astype(np.int32) + */ + __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_t_7 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 26, __pyx_L1_error) + } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_7 = 0; + __pyx_v_scores = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "gpu_nms.pyx":29 + * scores = dets[:, 4] + * cdef np.ndarray[np.int32_t, ndim=1] \ + * order = scores.argsort()[::-1].astype(np.int32) # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_slice__3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 28, __pyx_L1_error) + } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_8 = 0; + __pyx_v_order = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "gpu_nms.pyx":31 + * order = scores.argsort()[::-1].astype(np.int32) + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] # <<<<<<<<<<<<<< + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] + */ + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)__pyx_v_order)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_order)); + PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_order)); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_slice_); + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_t_9 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_sorted_dets = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 30, __pyx_L1_error) + } else {__pyx_pybuffernd_sorted_dets.diminfo[0].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sorted_dets.diminfo[0].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sorted_dets.diminfo[1].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sorted_dets.diminfo[1].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_9 = 0; + __pyx_v_sorted_dets = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "gpu_nms.pyx":32 + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) # <<<<<<<<<<<<<< + * keep = keep[:num_out] + * return list(order[keep]) + */ + __pyx_t_10 = 0; + __pyx_t_11 = -1; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_keep.diminfo[0].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_keep.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 32, __pyx_L1_error) + } + __pyx_t_12 = 0; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (__pyx_t_12 < 0) { + __pyx_t_12 += __pyx_pybuffernd_sorted_dets.diminfo[0].shape; + if (unlikely(__pyx_t_12 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_sorted_dets.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_sorted_dets.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_sorted_dets.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 32, __pyx_L1_error) + } + __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_v_thresh); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L1_error) + _nms((&(*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int32_t *, __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_keep.diminfo[0].strides))), (&__pyx_v_num_out), (&(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_sorted_dets.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_sorted_dets.diminfo[1].strides))), __pyx_v_boxes_num, __pyx_v_boxes_dim, __pyx_t_14, __pyx_v_device_id); + + /* "gpu_nms.pyx":33 + * sorted_dets = dets[order, :] + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] # <<<<<<<<<<<<<< + * return list(order[keep]) + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_num_out); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySlice_New(Py_None, __pyx_t_1, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_keep), __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_v_keep, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_15); Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_15, __pyx_t_16, __pyx_t_17); + } + __pyx_t_15 = __pyx_t_16 = __pyx_t_17 = 0; + } + __pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 33, __pyx_L1_error) + } + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_keep, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "gpu_nms.pyx":34 + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] + * return list(order[keep]) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_order), ((PyObject *)__pyx_v_keep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "gpu_nms.pyx":19 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("gpu_nms.gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_keep); + __Pyx_XDECREF((PyObject *)__pyx_v_scores); + __Pyx_XDECREF((PyObject *)__pyx_v_order); + __Pyx_XDECREF((PyObject *)__pyx_v_sorted_dets); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":736 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":739 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":742 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":745 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":748 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":752 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":754 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":930 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":931 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":934 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":936 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":937 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":943 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":944 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 945, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":949 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":950 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 951, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":955 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":956 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":957 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 957, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + */ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_gpu_nms(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_gpu_nms}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "gpu_nms", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, + {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, + {&__pyx_n_s_boxes_dim, __pyx_k_boxes_dim, sizeof(__pyx_k_boxes_dim), 0, 0, 1, 1}, + {&__pyx_n_s_boxes_num, __pyx_k_boxes_num, sizeof(__pyx_k_boxes_num), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_dets, __pyx_k_dets, sizeof(__pyx_k_dets), 0, 0, 1, 1}, + {&__pyx_n_s_device_id, __pyx_k_device_id, sizeof(__pyx_k_device_id), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_gpu_nms, __pyx_k_gpu_nms, sizeof(__pyx_k_gpu_nms), 0, 0, 1, 1}, + {&__pyx_kp_s_gpu_nms_pyx, __pyx_k_gpu_nms_pyx, sizeof(__pyx_k_gpu_nms_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 0, 1, 1}, + {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_num_out, __pyx_k_num_out, sizeof(__pyx_k_num_out), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, + {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, + {&__pyx_n_s_scores, __pyx_k_scores, sizeof(__pyx_k_scores), 0, 0, 1, 1}, + {&__pyx_n_s_sorted_dets, __pyx_k_sorted_dets, sizeof(__pyx_k_sorted_dets), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "gpu_nms.pyx":27 + * keep = np.zeros(boxes_num, dtype=np.int32) + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.int32_t, ndim=1] \ + * order = scores.argsort()[::-1].astype(np.int32) + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_4); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "gpu_nms.pyx":29 + * scores = dets[:, 4] + * cdef np.ndarray[np.int32_t, ndim=1] \ + * order = scores.argsort()[::-1].astype(np.int32) # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + */ + __pyx_slice__3 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__3); + __Pyx_GIVEREF(__pyx_slice__3); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "gpu_nms.pyx":19 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + __pyx_tuple__6 = PyTuple_Pack(10, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_device_id, __pyx_n_s_boxes_num, __pyx_n_s_boxes_dim, __pyx_n_s_num_out, __pyx_n_s_keep, __pyx_n_s_scores, __pyx_n_s_order, __pyx_n_s_sorted_dets); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gpu_nms_pyx, __pyx_n_s_gpu_nms, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initgpu_nms(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initgpu_nms(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_gpu_nms(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_gpu_nms(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_gpu_nms(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'gpu_nms' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_gpu_nms(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("gpu_nms", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_gpu_nms) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "gpu_nms")) { + if (unlikely(PyDict_SetItemString(modules, "gpu_nms", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "gpu_nms.pyx":11 + * from __future__ import print_function + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gpu_nms.pyx":14 + * cimport numpy as np + * + * assert sizeof(int) == sizeof(np.int32_t) # <<<<<<<<<<<<<< + * + * cdef extern from "gpu_nms.hpp": + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((sizeof(int)) == (sizeof(__pyx_t_5numpy_int32_t))) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 14, __pyx_L1_error) + } + } + #endif + + /* "gpu_nms.pyx":19 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7gpu_nms_1gpu_nms, NULL, __pyx_n_s_gpu_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_gpu_nms, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gpu_nms.pyx":1 + * # ------------------------------------------------------------------------------ # <<<<<<<<<<<<<< + * # Copyright (c) Microsoft + * # Licensed under the MIT License. + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../../anaconda3/envs/HRNet/lib/python3.7/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init gpu_nms"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* PyObjectGetAttrStr */ + #if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ + static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ + #if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +#else + if (likely(PyCFunction_Check(func))) +#endif + { + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCall2Args */ + static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* BufferIndexError */ + static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/* BufferFallbackError */ + static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntFromPy */ + static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const npy_int32 neg_one = (npy_int32) -1, const_zero = (npy_int32) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(npy_int32) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (npy_int32) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (npy_int32) 0; + case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, digits[0]) + case 2: + if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 2 * PyLong_SHIFT) { + return (npy_int32) (((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 3 * PyLong_SHIFT) { + return (npy_int32) (((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 4 * PyLong_SHIFT) { + return (npy_int32) (((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (npy_int32) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(npy_int32) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(npy_int32) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (npy_int32) 0; + case -1: __PYX_VERIFY_RETURN_INT(npy_int32, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, +digits[0]) + case -2: + if (8 * sizeof(npy_int32) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + return (npy_int32) ((((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + return (npy_int32) ((((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { + return (npy_int32) ((((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + } +#endif + if (sizeof(npy_int32) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(npy_int32) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + npy_int32 val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (npy_int32) -1; + } + } else { + npy_int32 val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (npy_int32) -1; + val = __Pyx_PyInt_As_npy_int32(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to npy_int32"); + return (npy_int32) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to npy_int32"); + return (npy_int32) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-37m-x86_64-linux-gnu.so b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-37m-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..53f71fb79054668f902fbdb2f20ae4bdd0ee8689 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-37m-x86_64-linux-gnu.so differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-39-x86_64-linux-gnu.so b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-39-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..c1ce043659f5cdc062091e2517f9ba74f8150738 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cpython-39-x86_64-linux-gnu.so differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cu b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cu new file mode 100644 index 0000000000000000000000000000000000000000..9401fdb81f44ba8df579c9d5e8575a5df11f5393 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.cu @@ -0,0 +1,7080 @@ +// ------------------------------------------------------------------ +// Copyright (c) Microsoft +// Licensed under The MIT License +// Modified from MATLAB Faster R-CNN (https://github.com/shaoqingren/faster_rcnn) +// ------------------------------------------------------------------ + +//#include "gpu_nms.hpp" +#include +#include + + +#define CUDA_CHECK(condition) \ + /* Code block avoids redefinition of cudaError_t error */ \ + do { \ + cudaError_t error = condition; \ + if (error != cudaSuccess) { \ + std::cout << cudaGetErrorString(error) << std::endl; \ + } \ + } while (0) + +#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0)) +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = DIVUP(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +void _set_device(int device_id) { + int current_device; + CUDA_CHECK(cudaGetDevice(¤t_device)); + if (current_device == device_id) { + return; + } + // The call to cudaSetDevice must come before any calls to Get, which + // may perform initialization using the GPU. + CUDA_CHECK(cudaSetDevice(device_id)); +} + +void _nms(long* keep_out, int* num_out, const float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh, int device_id) { + _set_device(device_id); + + float* boxes_dev = NULL; + unsigned long long* mask_dev = NULL; + + const int col_blocks = DIVUP(boxes_num, threadsPerBlock); + + CUDA_CHECK(cudaMalloc(&boxes_dev, + boxes_num * boxes_dim * sizeof(float))); + CUDA_CHECK(cudaMemcpy(boxes_dev, + boxes_host, + boxes_num * boxes_dim * sizeof(float), + cudaMemcpyHostToDevice)); + + CUDA_CHECK(cudaMalloc(&mask_dev, + boxes_num * col_blocks * sizeof(unsigned long long))); + + dim3 blocks(DIVUP(boxes_num, threadsPerBlock), + DIVUP(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + CUDA_CHECK(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + *num_out = num_to_keep; + + CUDA_CHECK(cudaFree(boxes_dev)); + CUDA_CHECK(cudaFree(mask_dev)); +} + + + + + + + + + + +/* Generated by Cython 0.24 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_24" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 + #define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #define CYTHON_INLINE inline +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + operator T&() { return *ptr; } + private: + T *ptr; +}; + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__nms__gpu_nms +#define __PYX_HAVE_API__nms__gpu_nms +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "gpu_nms.hpp" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* None.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "nms\\gpu_nms.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* None.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +/* None.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +/* BufferFormatCheck.proto */ +static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); // PROTO + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* BufferIndexError.proto */ +static void __Pyx_RaiseBufferIndexError(int axis); + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +/* PyThreadStateGet.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* None.proto */ +static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; +static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* None.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* None.proto */ +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* None.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* None.proto */ +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +/* None.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* PyIdentifierFromString.proto */ +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +/* ModuleImport.proto */ +static PyObject *__Pyx_ImportModule(const char *name); + +/* TypeImport.proto */ +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'nms.gpu_nms' */ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t = { "int32_t", NULL, sizeof(__pyx_t_5numpy_int32_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int32_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int32_t), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_intp_t = { "intp_t", NULL, sizeof(__pyx_t_5numpy_intp_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_intp_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_intp_t), 0 }; +#define __Pyx_MODULE_NAME "nms.gpu_nms" +int __pyx_module_is_main_nms__gpu_nms = 0; + +/* Implementation of 'nms.gpu_nms' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_dets[] = "dets"; +static const char __pyx_k_keep[] = "keep"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_int32[] = "int32"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_order[] = "order"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_scores[] = "scores"; +static const char __pyx_k_thresh[] = "thresh"; +static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_gpu_nms[] = "gpu_nms"; +static const char __pyx_k_num_out[] = "num_out"; +static const char __pyx_k_boxes_dim[] = "boxes_dim"; +static const char __pyx_k_boxes_num[] = "boxes_num"; +static const char __pyx_k_device_id[] = "device_id"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_nms_gpu_nms[] = "nms.gpu_nms"; +static const char __pyx_k_sorted_dets[] = "sorted_dets"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static const char __pyx_k_D_v_zix_caffe_caffe_win_20160523[] = "D:\\v-zix\\caffe\\caffe-win-20160523\\models\\py-faster-rcnn-windows\\lib\\nms\\gpu_nms.pyx"; +static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_s_D_v_zix_caffe_caffe_win_20160523; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_argsort; +static PyObject *__pyx_n_s_boxes_dim; +static PyObject *__pyx_n_s_boxes_num; +static PyObject *__pyx_n_s_dets; +static PyObject *__pyx_n_s_device_id; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_gpu_nms; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_int32; +static PyObject *__pyx_n_s_keep; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_nms_gpu_nms; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_num_out; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_order; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_scores; +static PyObject *__pyx_n_s_sorted_dets; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_thresh; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_3nms_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_slice__3; +static PyObject *__pyx_slice__4; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_codeobj__12; + +/* "nms/gpu_nms.pyx":16 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_3nms_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_3nms_7gpu_nms_1gpu_nms = {"gpu_nms", (PyCFunction)__pyx_pw_3nms_7gpu_nms_1gpu_nms, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_3nms_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_dets = 0; + PyObject *__pyx_v_thresh = 0; + __pyx_t_5numpy_int32_t __pyx_v_device_id; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("gpu_nms (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,&__pyx_n_s_device_id,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("gpu_nms", 0, 2, 3, 1); __PYX_ERR(0, 16, __pyx_L3_error) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_device_id); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gpu_nms") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_dets = ((PyArrayObject *)values[0]); + __pyx_v_thresh = ((PyObject*)values[1]); + if (values[2]) { + __pyx_v_device_id = __Pyx_PyInt_As_npy_int32(values[2]); if (unlikely((__pyx_v_device_id == (npy_int32)-1) && PyErr_Occurred())) __PYX_ERR(0, 17, __pyx_L3_error) + } else { + __pyx_v_device_id = ((__pyx_t_5numpy_int32_t)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("gpu_nms", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 16, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("nms.gpu_nms.gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 16, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_r = __pyx_pf_3nms_7gpu_nms_gpu_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh, __pyx_v_device_id); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3nms_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id) { + int __pyx_v_boxes_num; + int __pyx_v_boxes_dim; + int __pyx_v_num_out; + PyArrayObject *__pyx_v_keep = 0; + PyArrayObject *__pyx_v_scores = 0; + PyArrayObject *__pyx_v_order = 0; + PyArrayObject *__pyx_v_sorted_dets = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_dets; + __Pyx_Buffer __pyx_pybuffer_dets; + __Pyx_LocalBuf_ND __pyx_pybuffernd_keep; + __Pyx_Buffer __pyx_pybuffer_keep; + __Pyx_LocalBuf_ND __pyx_pybuffernd_order; + __Pyx_Buffer __pyx_pybuffer_order; + __Pyx_LocalBuf_ND __pyx_pybuffernd_scores; + __Pyx_Buffer __pyx_pybuffer_scores; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sorted_dets; + __Pyx_Buffer __pyx_pybuffer_sorted_dets; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + PyArrayObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + PyArrayObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + float __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + __Pyx_RefNannySetupContext("gpu_nms", 0); + __pyx_pybuffer_keep.pybuffer.buf = NULL; + __pyx_pybuffer_keep.refcount = 0; + __pyx_pybuffernd_keep.data = NULL; + __pyx_pybuffernd_keep.rcbuffer = &__pyx_pybuffer_keep; + __pyx_pybuffer_scores.pybuffer.buf = NULL; + __pyx_pybuffer_scores.refcount = 0; + __pyx_pybuffernd_scores.data = NULL; + __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores; + __pyx_pybuffer_order.pybuffer.buf = NULL; + __pyx_pybuffer_order.refcount = 0; + __pyx_pybuffernd_order.data = NULL; + __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order; + __pyx_pybuffer_sorted_dets.pybuffer.buf = NULL; + __pyx_pybuffer_sorted_dets.refcount = 0; + __pyx_pybuffernd_sorted_dets.data = NULL; + __pyx_pybuffernd_sorted_dets.rcbuffer = &__pyx_pybuffer_sorted_dets; + __pyx_pybuffer_dets.pybuffer.buf = NULL; + __pyx_pybuffer_dets.refcount = 0; + __pyx_pybuffernd_dets.data = NULL; + __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error) + } + __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1]; + + /* "nms/gpu_nms.pyx":18 + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] # <<<<<<<<<<<<<< + * cdef int boxes_dim = dets.shape[1] + * cdef int num_out + */ + __pyx_v_boxes_num = (__pyx_v_dets->dimensions[0]); + + /* "nms/gpu_nms.pyx":19 + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + * cdef int boxes_dim = dets.shape[1] # <<<<<<<<<<<<<< + * cdef int num_out + * cdef np.ndarray[np.int32_t, ndim=1] \ + */ + __pyx_v_boxes_dim = (__pyx_v_dets->dimensions[1]); + + /* "nms/gpu_nms.pyx":22 + * cdef int num_out + * cdef np.ndarray[np.int32_t, ndim=1] \ + * keep = np.zeros(boxes_num, dtype=np.int32) # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_boxes_num); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_keep = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 21, __pyx_L1_error) + } else {__pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_6 = 0; + __pyx_v_keep = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "nms/gpu_nms.pyx":24 + * keep = np.zeros(boxes_num, dtype=np.int32) + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] # <<<<<<<<<<<<<< + * #cdef np.ndarray[np.int_t, ndim=1] \ // 20160601, by xzn + * # order = scores.argsort()[::-1] + */ + __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 24, __pyx_L1_error) + __pyx_t_7 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 23, __pyx_L1_error) + } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_7 = 0; + __pyx_v_scores = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "nms/gpu_nms.pyx":28 + * # order = scores.argsort()[::-1] + * cdef np.ndarray[np.intp_t, ndim=1] \ + * order = scores.argsort()[::-1] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_GetItem(__pyx_t_5, __pyx_slice__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_intp_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 27, __pyx_L1_error) + } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_8 = 0; + __pyx_v_order = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "nms/gpu_nms.pyx":30 + * order = scores.argsort()[::-1] + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] # <<<<<<<<<<<<<< + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_order)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_order)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_order)); + __Pyx_INCREF(__pyx_slice__4); + __Pyx_GIVEREF(__pyx_slice__4); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_slice__4); + __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_9 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_sorted_dets = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 29, __pyx_L1_error) + } else {__pyx_pybuffernd_sorted_dets.diminfo[0].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sorted_dets.diminfo[0].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sorted_dets.diminfo[1].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sorted_dets.diminfo[1].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_9 = 0; + __pyx_v_sorted_dets = ((PyArrayObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "nms/gpu_nms.pyx":31 + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) # <<<<<<<<<<<<<< + * keep = keep[:num_out] + * return list(order[keep]) + */ + __pyx_t_10 = 0; + __pyx_t_11 = -1; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_keep.diminfo[0].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_keep.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 31, __pyx_L1_error) + } + __pyx_t_12 = 0; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (__pyx_t_12 < 0) { + __pyx_t_12 += __pyx_pybuffernd_sorted_dets.diminfo[0].shape; + if (unlikely(__pyx_t_12 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_sorted_dets.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_sorted_dets.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_sorted_dets.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 31, __pyx_L1_error) + } + __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_v_thresh); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error) + _nms((&(*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int32_t *, __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_keep.diminfo[0].strides))), (&__pyx_v_num_out), (&(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_sorted_dets.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_sorted_dets.diminfo[1].strides))), __pyx_v_boxes_num, __pyx_v_boxes_dim, __pyx_t_14, __pyx_v_device_id); + + /* "nms/gpu_nms.pyx":32 + * sorted_dets = dets[order, :] + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] # <<<<<<<<<<<<<< + * return list(order[keep]) + */ + __pyx_t_5 = __Pyx_PyObject_GetSlice(((PyObject *)__pyx_v_keep), 0, __pyx_v_num_out, NULL, NULL, NULL, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_v_keep, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_15); Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_15, __pyx_t_16, __pyx_t_17); + } + } + __pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) + } + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_keep, ((PyArrayObject *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "nms/gpu_nms.pyx":33 + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] + * return list(order[keep]) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_order), ((PyObject *)__pyx_v_keep)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "nms/gpu_nms.pyx":16 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("nms.gpu_nms.gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_keep); + __Pyx_XDECREF((PyObject *)__pyx_v_scores); + __Pyx_XDECREF((PyObject *)__pyx_v_order); + __Pyx_XDECREF((PyObject *)__pyx_v_sorted_dets); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 218, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 222, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 259, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = ((char *)"b"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = ((char *)"B"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = ((char *)"h"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = ((char *)"H"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = ((char *)"i"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = ((char *)"I"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = ((char *)"l"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = ((char *)"L"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = ((char *)"q"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = ((char *)"Q"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = ((char *)"f"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = ((char *)"d"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = ((char *)"g"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = ((char *)"Zf"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = ((char *)"Zd"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = ((char *)"Zg"); + break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = ((char *)"O"); + break; + default: + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 278, __pyx_L1_error) + break; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error) + __pyx_v_f = __pyx_t_7; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 794, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 795, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 796, __pyx_L1_error) + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error) + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 799, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 803, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 823, __pyx_L1_error) + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 844, __pyx_L1_error) + } + __pyx_L15:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "gpu_nms", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_D_v_zix_caffe_caffe_win_20160523, __pyx_k_D_v_zix_caffe_caffe_win_20160523, sizeof(__pyx_k_D_v_zix_caffe_caffe_win_20160523), 0, 0, 1, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, + {&__pyx_n_s_boxes_dim, __pyx_k_boxes_dim, sizeof(__pyx_k_boxes_dim), 0, 0, 1, 1}, + {&__pyx_n_s_boxes_num, __pyx_k_boxes_num, sizeof(__pyx_k_boxes_num), 0, 0, 1, 1}, + {&__pyx_n_s_dets, __pyx_k_dets, sizeof(__pyx_k_dets), 0, 0, 1, 1}, + {&__pyx_n_s_device_id, __pyx_k_device_id, sizeof(__pyx_k_device_id), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_gpu_nms, __pyx_k_gpu_nms, sizeof(__pyx_k_gpu_nms), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 0, 1, 1}, + {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_nms_gpu_nms, __pyx_k_nms_gpu_nms, sizeof(__pyx_k_nms_gpu_nms), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_num_out, __pyx_k_num_out, sizeof(__pyx_k_num_out), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_scores, __pyx_k_scores, sizeof(__pyx_k_scores), 0, 0, 1, 1}, + {&__pyx_n_s_sorted_dets, __pyx_k_sorted_dets, sizeof(__pyx_k_sorted_dets), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 231, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "nms/gpu_nms.pyx":24 + * keep = np.zeros(boxes_num, dtype=np.int32) + * cdef np.ndarray[np.float32_t, ndim=1] \ + * scores = dets[:, 4] # <<<<<<<<<<<<<< + * #cdef np.ndarray[np.int_t, ndim=1] \ // 20160601, by xzn + * # order = scores.argsort()[::-1] + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_4); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "nms/gpu_nms.pyx":28 + * # order = scores.argsort()[::-1] + * cdef np.ndarray[np.intp_t, ndim=1] \ + * order = scores.argsort()[::-1] # <<<<<<<<<<<<<< + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] + */ + __pyx_slice__3 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__3); + __Pyx_GIVEREF(__pyx_slice__3); + + /* "nms/gpu_nms.pyx":30 + * order = scores.argsort()[::-1] + * cdef np.ndarray[np.float32_t, ndim=2] \ + * sorted_dets = dets[order, :] # <<<<<<<<<<<<<< + * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + * keep = keep[:num_out] + */ + __pyx_slice__4 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__4)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__4); + __Pyx_GIVEREF(__pyx_slice__4); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 803, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "nms/gpu_nms.pyx":16 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + __pyx_tuple__11 = PyTuple_Pack(10, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_device_id, __pyx_n_s_boxes_num, __pyx_n_s_boxes_dim, __pyx_n_s_num_out, __pyx_n_s_keep, __pyx_n_s_scores, __pyx_n_s_order, __pyx_n_s_sorted_dets); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_D_v_zix_caffe_caffe_win_20160523, __pyx_n_s_gpu_nms, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initgpu_nms(void); /*proto*/ +PyMODINIT_FUNC initgpu_nms(void) +#else +PyMODINIT_FUNC PyInit_gpu_nms(void); /*proto*/ +PyMODINIT_FUNC PyInit_gpu_nms(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_gpu_nms(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("gpu_nms", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_nms__gpu_nms) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "nms.gpu_nms")) { + if (unlikely(PyDict_SetItemString(modules, "nms.gpu_nms", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error) + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error) + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "nms/gpu_nms.pyx":8 + * # -------------------------------------------------------- + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "nms/gpu_nms.pyx":11 + * cimport numpy as np + * + * assert sizeof(int) == sizeof(np.int32_t) # <<<<<<<<<<<<<< + * + * cdef extern from "gpu_nms.hpp": + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((sizeof(int)) == (sizeof(__pyx_t_5numpy_int32_t))) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 11, __pyx_L1_error) + } + } + #endif + + /* "nms/gpu_nms.pyx":16 + * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + * + * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<< + * np.int32_t device_id=0): + * cdef int boxes_num = dets.shape[0] + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3nms_7gpu_nms_1gpu_nms, NULL, __pyx_n_s_nms_gpu_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_gpu_nms, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "nms/gpu_nms.pyx":1 + * # -------------------------------------------------------- # <<<<<<<<<<<<<< + * # Faster R-CNN + * # Copyright (c) 2015 Microsoft + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init nms.gpu_nms", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init nms.gpu_nms"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +/* BufferFormatCheck */ +static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { + unsigned int n = 1; + return *(unsigned char*)(&n) != 0; +} +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t < '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static CYTHON_INLINE PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} +static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static CYTHON_INLINE int __Pyx_GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + if (obj == Py_None || obj == NULL) { + __Pyx_ZeroBuffer(buf); + return 0; + } + buf->buf = NULL; + if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; + if (buf->ndim != nd) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned)buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_ZeroBuffer(buf); + return -1; +} +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (info->buf == NULL) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} + +/* GetBuiltinName */ + static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* GetModuleGlobalName */ + static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* BufferIndexError */ + static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/* SliceObject */ + static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { +#if CYTHON_COMPILING_IN_CPYTHON + PyMappingMethods* mp; +#if PY_MAJOR_VERSION < 3 + PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; + if (likely(ms && ms->sq_slice)) { + if (!has_cstart) { + if (_py_start && (*_py_start != Py_None)) { + cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); + if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstart = 0; + } + if (!has_cstop) { + if (_py_stop && (*_py_stop != Py_None)) { + cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); + if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstop = PY_SSIZE_T_MAX; + } + if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { + Py_ssize_t l = ms->sq_length(obj); + if (likely(l >= 0)) { + if (cstop < 0) { + cstop += l; + if (cstop < 0) cstop = 0; + } + if (cstart < 0) { + cstart += l; + if (cstart < 0) cstart = 0; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + goto bad; + PyErr_Clear(); + } + } + return ms->sq_slice(obj, cstart, cstop); + } +#endif + mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyInt_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyInt_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_COMPILING_IN_CPYTHON + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + PyErr_Format(PyExc_TypeError, + "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); +bad: + return NULL; +} + +/* BufferFallbackError */ + static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); +} + +/* PyErrFetchRestore */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; } + Py_DECREF(obj); + view->obj = NULL; +} +#endif + + + /* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* None */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* None */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* None */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* None */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *x) { + const npy_int32 neg_one = (npy_int32) -1, const_zero = (npy_int32) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(npy_int32) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (npy_int32) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (npy_int32) 0; + case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, digits[0]) + case 2: + if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 2 * PyLong_SHIFT) { + return (npy_int32) (((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 3 * PyLong_SHIFT) { + return (npy_int32) (((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) >= 4 * PyLong_SHIFT) { + return (npy_int32) (((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (npy_int32) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(npy_int32) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(npy_int32) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (npy_int32) 0; + case -1: __PYX_VERIFY_RETURN_INT(npy_int32, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, +digits[0]) + case -2: + if (8 * sizeof(npy_int32) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + return (npy_int32) ((((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + return (npy_int32) ((((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { + return (npy_int32) (((npy_int32)-1)*(((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { + return (npy_int32) ((((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); + } + } + break; + } +#endif + if (sizeof(npy_int32) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, long, PyLong_AsLong(x)) + } else if (sizeof(npy_int32) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int32, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + npy_int32 val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (npy_int32) -1; + } + } else { + npy_int32 val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (npy_int32) -1; + val = __Pyx_PyInt_As_npy_int32(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to npy_int32"); + return (npy_int32) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to npy_int32"); + return (npy_int32) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* ModuleImport */ + #ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd", + module_name, class_name, basicsize, size); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd", + module_name, class_name, basicsize, size); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ + diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.hpp b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.hpp new file mode 100644 index 0000000000000000000000000000000000000000..e608e090e01c91471db0b83c7ec0b044bcb7fafb --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.hpp @@ -0,0 +1,2 @@ +void _nms(int* keep_out, int* num_out, const float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh, int device_id); diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.pyx b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.pyx new file mode 100644 index 0000000000000000000000000000000000000000..07ecfef09bf048d78eeca8411b00f7b6484bb202 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/gpu_nms.pyx @@ -0,0 +1,34 @@ +# ------------------------------------------------------------------------------ +# Copyright (c) Microsoft +# Licensed under the MIT License. +# Written by Bin Xiao (Bin.Xiao@microsoft.com) +# ------------------------------------------------------------------------------ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +cimport numpy as np + +assert sizeof(int) == sizeof(np.int32_t) + +cdef extern from "gpu_nms.hpp": + void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int) + +def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, + np.int32_t device_id=0): + cdef int boxes_num = dets.shape[0] + cdef int boxes_dim = dets.shape[1] + cdef int num_out + cdef np.ndarray[np.int32_t, ndim=1] \ + keep = np.zeros(boxes_num, dtype=np.int32) + cdef np.ndarray[np.float32_t, ndim=1] \ + scores = dets[:, 4] + cdef np.ndarray[np.int32_t, ndim=1] \ + order = scores.argsort()[::-1].astype(np.int32) + cdef np.ndarray[np.float32_t, ndim=2] \ + sorted_dets = dets[order, :] + _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) + keep = keep[:num_out] + return list(order[keep]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms.py new file mode 100644 index 0000000000000000000000000000000000000000..e934c5d452b4d1798fcd4d66877e67314b9d7e1c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms.py @@ -0,0 +1,180 @@ +# ------------------------------------------------------------------------------ +# Copyright (c) Microsoft +# Licensed under the MIT License. +# Modified from py-faster-rcnn (https://github.com/rbgirshick/py-faster-rcnn) +# ------------------------------------------------------------------------------ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + +from .cpu_nms import cpu_nms +from .gpu_nms import gpu_nms + + +def py_nms_wrapper(thresh): + def _nms(dets): + return nms(dets, thresh) + return _nms + + +def cpu_nms_wrapper(thresh): + def _nms(dets): + return cpu_nms(dets, thresh) + return _nms + + +def gpu_nms_wrapper(thresh, device_id): + def _nms(dets): + return gpu_nms(dets, thresh, device_id) + return _nms + + +def nms(dets, thresh): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh + :param dets: [[x1, y1, x2, y2 score]] + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if dets.shape[0] == 0: + return [] + + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.minimum(x2[i], x2[order[1:]]) + yy2 = np.minimum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thresh)[0] + order = order[inds + 1] + + return keep + + +def oks_iou(g, d, a_g, a_d, sigmas=None, in_vis_thre=None): + if not isinstance(sigmas, np.ndarray): + sigmas = np.array([.26, .25, .25, .35, .35, .79, .79, .72, .72, .62, .62, 1.07, 1.07, .87, .87, .89, .89]) / 10.0 + vars = (sigmas * 2) ** 2 + xg = g[0::3] + yg = g[1::3] + vg = g[2::3] + ious = np.zeros((d.shape[0])) + for n_d in range(0, d.shape[0]): + xd = d[n_d, 0::3] + yd = d[n_d, 1::3] + vd = d[n_d, 2::3] + dx = xd - xg + dy = yd - yg + e = (dx ** 2 + dy ** 2) / vars / ((a_g + a_d[n_d]) / 2 + np.spacing(1)) / 2 + if in_vis_thre is not None: + ind = list(vg > in_vis_thre) and list(vd > in_vis_thre) + e = e[ind] + ious[n_d] = np.sum(np.exp(-e)) / e.shape[0] if e.shape[0] != 0 else 0.0 + return ious + + +def oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh, overlap = oks + :param kpts_db + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if len(kpts_db) == 0: + return [] + + scores = np.array([kpts_db[i]['score'] for i in range(len(kpts_db))]) + kpts = np.array([kpts_db[i]['keypoints'].flatten() for i in range(len(kpts_db))]) + areas = np.array([kpts_db[i]['area'] for i in range(len(kpts_db))]) + + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], sigmas, in_vis_thre) + + inds = np.where(oks_ovr <= thresh)[0] + order = order[inds + 1] + + return keep + + +def rescore(overlap, scores, thresh, type='gaussian'): + assert overlap.shape[0] == scores.shape[0] + if type == 'linear': + inds = np.where(overlap >= thresh)[0] + scores[inds] = scores[inds] * (1 - overlap[inds]) + else: + scores = scores * np.exp(- overlap**2 / thresh) + + return scores + + +def soft_oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh, overlap = oks + :param kpts_db + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if len(kpts_db) == 0: + return [] + + scores = np.array([kpts_db[i]['score'] for i in range(len(kpts_db))]) + kpts = np.array([kpts_db[i]['keypoints'].flatten() for i in range(len(kpts_db))]) + areas = np.array([kpts_db[i]['area'] for i in range(len(kpts_db))]) + + order = scores.argsort()[::-1] + scores = scores[order] + + # max_dets = order.size + max_dets = 20 + keep = np.zeros(max_dets, dtype=np.intp) + keep_cnt = 0 + while order.size > 0 and keep_cnt < max_dets: + i = order[0] + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], sigmas, in_vis_thre) + + order = order[1:] + scores = rescore(oks_ovr, scores[1:], thresh) + + tmp = scores.argsort()[::-1] + order = order[tmp] + scores = scores[tmp] + + keep[keep_cnt] = i + keep_cnt += 1 + + keep = keep[:keep_cnt] + + return keep + # kpts_db = kpts_db[:keep_cnt] + + # return kpts_db diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_kernel.cu b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..2ec3df06a82855b0e9581ee036b3eee365e6110c --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_kernel.cu @@ -0,0 +1,143 @@ +// ------------------------------------------------------------------ +// Copyright (c) Microsoft +// Licensed under The MIT License +// Modified from MATLAB Faster R-CNN (https://github.com/shaoqingren/faster_rcnn) +// ------------------------------------------------------------------ + +#include "gpu_nms.hpp" +#include +#include + +#define CUDA_CHECK(condition) \ + /* Code block avoids redefinition of cudaError_t error */ \ + do { \ + cudaError_t error = condition; \ + if (error != cudaSuccess) { \ + std::cout << cudaGetErrorString(error) << std::endl; \ + } \ + } while (0) + +#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0)) +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = DIVUP(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +void _set_device(int device_id) { + int current_device; + CUDA_CHECK(cudaGetDevice(¤t_device)); + if (current_device == device_id) { + return; + } + // The call to cudaSetDevice must come before any calls to Get, which + // may perform initialization using the GPU. + CUDA_CHECK(cudaSetDevice(device_id)); +} + +void _nms(int* keep_out, int* num_out, const float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh, int device_id) { + _set_device(device_id); + + float* boxes_dev = NULL; + unsigned long long* mask_dev = NULL; + + const int col_blocks = DIVUP(boxes_num, threadsPerBlock); + + CUDA_CHECK(cudaMalloc(&boxes_dev, + boxes_num * boxes_dim * sizeof(float))); + CUDA_CHECK(cudaMemcpy(boxes_dev, + boxes_host, + boxes_num * boxes_dim * sizeof(float), + cudaMemcpyHostToDevice)); + + CUDA_CHECK(cudaMalloc(&mask_dev, + boxes_num * col_blocks * sizeof(unsigned long long))); + + dim3 blocks(DIVUP(boxes_num, threadsPerBlock), + DIVUP(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + CUDA_CHECK(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + *num_out = num_to_keep; + + CUDA_CHECK(cudaFree(boxes_dev)); + CUDA_CHECK(cudaFree(mask_dev)); +} diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_ori.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_ori.py new file mode 100644 index 0000000000000000000000000000000000000000..ff6b5c91e8fd52115823dd6429dbff7b62a80fee --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/nms_ori.py @@ -0,0 +1,180 @@ +# ------------------------------------------------------------------------------ +# Copyright (c) Microsoft +# Licensed under the MIT License. +# Modified from py-faster-rcnn (https://github.com/rbgirshick/py-faster-rcnn) +# ------------------------------------------------------------------------------ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + +from cpu_nms import cpu_nms +from gpu_nms import gpu_nms + + +def py_nms_wrapper(thresh): + def _nms(dets): + return nms(dets, thresh) + return _nms + + +def cpu_nms_wrapper(thresh): + def _nms(dets): + return cpu_nms(dets, thresh) + return _nms + + +def gpu_nms_wrapper(thresh, device_id): + def _nms(dets): + return gpu_nms(dets, thresh, device_id) + return _nms + + +def nms(dets, thresh): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh + :param dets: [[x1, y1, x2, y2 score]] + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if dets.shape[0] == 0: + return [] + + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.minimum(x2[i], x2[order[1:]]) + yy2 = np.minimum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thresh)[0] + order = order[inds + 1] + + return keep + + +def oks_iou(g, d, a_g, a_d, sigmas=None, in_vis_thre=None): + if not isinstance(sigmas, np.ndarray): + sigmas = np.array([.26, .25, .25, .35, .35, .79, .79, .72, .72, .62, .62, 1.07, 1.07, .87, .87, .89, .89]) / 10.0 + vars = (sigmas * 2) ** 2 + xg = g[0::3] + yg = g[1::3] + vg = g[2::3] + ious = np.zeros((d.shape[0])) + for n_d in range(0, d.shape[0]): + xd = d[n_d, 0::3] + yd = d[n_d, 1::3] + vd = d[n_d, 2::3] + dx = xd - xg + dy = yd - yg + e = (dx ** 2 + dy ** 2) / vars / ((a_g + a_d[n_d]) / 2 + np.spacing(1)) / 2 + if in_vis_thre is not None: + ind = list(vg > in_vis_thre) and list(vd > in_vis_thre) + e = e[ind] + ious[n_d] = np.sum(np.exp(-e)) / e.shape[0] if e.shape[0] != 0 else 0.0 + return ious + + +def oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh, overlap = oks + :param kpts_db + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if len(kpts_db) == 0: + return [] + + scores = np.array([kpts_db[i]['score'] for i in range(len(kpts_db))]) + kpts = np.array([kpts_db[i]['keypoints'].flatten() for i in range(len(kpts_db))]) + areas = np.array([kpts_db[i]['area'] for i in range(len(kpts_db))]) + + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], sigmas, in_vis_thre) + + inds = np.where(oks_ovr <= thresh)[0] + order = order[inds + 1] + + return keep + + +def rescore(overlap, scores, thresh, type='gaussian'): + assert overlap.shape[0] == scores.shape[0] + if type == 'linear': + inds = np.where(overlap >= thresh)[0] + scores[inds] = scores[inds] * (1 - overlap[inds]) + else: + scores = scores * np.exp(- overlap**2 / thresh) + + return scores + + +def soft_oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None): + """ + greedily select boxes with high confidence and overlap with current maximum <= thresh + rule out overlap >= thresh, overlap = oks + :param kpts_db + :param thresh: retain overlap < thresh + :return: indexes to keep + """ + if len(kpts_db) == 0: + return [] + + scores = np.array([kpts_db[i]['score'] for i in range(len(kpts_db))]) + kpts = np.array([kpts_db[i]['keypoints'].flatten() for i in range(len(kpts_db))]) + areas = np.array([kpts_db[i]['area'] for i in range(len(kpts_db))]) + + order = scores.argsort()[::-1] + scores = scores[order] + + # max_dets = order.size + max_dets = 20 + keep = np.zeros(max_dets, dtype=np.intp) + keep_cnt = 0 + while order.size > 0 and keep_cnt < max_dets: + i = order[0] + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], sigmas, in_vis_thre) + + order = order[1:] + scores = rescore(oks_ovr, scores[1:], thresh) + + tmp = scores.argsort()[::-1] + order = order[tmp] + scores = scores[tmp] + + keep[keep_cnt] = i + keep_cnt += 1 + + keep = keep[:keep_cnt] + + return keep + # kpts_db = kpts_db[:keep_cnt] + + # return kpts_db diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/setup_linux.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/setup_linux.py new file mode 100644 index 0000000000000000000000000000000000000000..e549a0691948a51cd9c45163aaeaec70bca31e39 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/nms/setup_linux.py @@ -0,0 +1,141 @@ +# -------------------------------------------------------- +# Pose.gluon +# Copyright (c) 2018-present Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Modified from py-faster-rcnn (https://github.com/rbgirshick/py-faster-rcnn) +# -------------------------------------------------------- + +import os +from os.path import join as pjoin +from setuptools import setup +from distutils.extension import Extension +from Cython.Distutils import build_ext +import numpy as np + + +def find_in_path(name, path): + "Find a file in a search path" + # Adapted fom + # http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/ + for dir in path.split(os.pathsep): + binpath = pjoin(dir, name) + if os.path.exists(binpath): + return os.path.abspath(binpath) + return None + + +def locate_cuda(): + """Locate the CUDA environment on the system + Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64' + and values giving the absolute path to each directory. + Starts by looking for the CUDAHOME env variable. If not found, everything + is based on finding 'nvcc' in the PATH. + """ + + # first check if the CUDAHOME env variable is in use + if 'CUDAHOME' in os.environ: + home = os.environ['CUDAHOME'] + nvcc = pjoin(home, 'bin', 'nvcc') + else: + # otherwise, search the PATH for NVCC + default_path = pjoin(os.sep, 'usr', 'local', 'cuda', 'bin') + nvcc = find_in_path('nvcc', os.environ['PATH'] + os.pathsep + default_path) + if nvcc is None: + raise EnvironmentError('The nvcc binary could not be ' + 'located in your $PATH. Either add it to your path, or set $CUDAHOME') + home = os.path.dirname(os.path.dirname(nvcc)) + + cudaconfig = {'home':home, 'nvcc':nvcc, + 'include': pjoin(home, 'include'), + 'lib64': pjoin(home, 'lib64')} + for k, v in cudaconfig.items(): + if not os.path.exists(v): + raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v)) + + return cudaconfig +CUDA = locate_cuda() + + +# Obtain the numpy include directory. This logic works across numpy versions. +try: + numpy_include = np.get_include() +except AttributeError: + numpy_include = np.get_numpy_include() + + +def customize_compiler_for_nvcc(self): + """inject deep into distutils to customize how the dispatch + to gcc/nvcc works. + If you subclass UnixCCompiler, it's not trivial to get your subclass + injected in, and still have the right customizations (i.e. + distutils.sysconfig.customize_compiler) run on it. So instead of going + the OO route, I have this. Note, it's kindof like a wierd functional + subclassing going on.""" + + # tell the compiler it can processes .cu + self.src_extensions.append('.cu') + + # save references to the default compiler_so and _comple methods + default_compiler_so = self.compiler_so + super = self._compile + + # now redefine the _compile method. This gets executed for each + # object but distutils doesn't have the ability to change compilers + # based on source extension: we add it. + def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts): + if os.path.splitext(src)[1] == '.cu': + # use the cuda for .cu files + self.set_executable('compiler_so', CUDA['nvcc']) + # use only a subset of the extra_postargs, which are 1-1 translated + # from the extra_compile_args in the Extension class + postargs = extra_postargs['nvcc'] + else: + postargs = extra_postargs['gcc'] + + super(obj, src, ext, cc_args, postargs, pp_opts) + # reset the default compiler_so, which we might have changed for cuda + self.compiler_so = default_compiler_so + + # inject our redefined _compile method into the class + self._compile = _compile + + +# run the customize_compiler +class custom_build_ext(build_ext): + def build_extensions(self): + customize_compiler_for_nvcc(self.compiler) + build_ext.build_extensions(self) + + +ext_modules = [ + Extension( + "cpu_nms", + ["cpu_nms.pyx"], + extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]}, + include_dirs = [numpy_include] + ), + Extension('gpu_nms', + ['nms_kernel.cu', 'gpu_nms.pyx'], + library_dirs=[CUDA['lib64']], + libraries=['cudart'], + language='c++', + runtime_library_dirs=[CUDA['lib64']], + # this syntax is specific to this build system + # we're only going to use certain compiler args with nvcc and not with + # gcc the implementation of this trick is in customize_compiler() below + extra_compile_args={'gcc': ["-Wno-unused-function"], + 'nvcc': ['-arch=sm_35', + '--ptxas-options=-v', + '-c', + '--compiler-options', + "'-fPIC'"]}, + include_dirs = [numpy_include, CUDA['include']] + ), +] + +setup( + name='nms', + ext_modules=ext_modules, + # inject our custom trigger + cmdclass={'build_ext': custom_build_ext}, +) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__init__.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8c9710b730373a0d213fa3ab788ed0bbe72b70df --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .nms import oks_iou, oks_nms, soft_oks_nms +from .one_euro_filter import OneEuroFilter +from .post_transforms import (affine_transform, flip_back, fliplr_joints, + fliplr_regression, get_affine_transform, + get_warp_matrix, rotate_point, transform_preds, + warp_affine_joints) + +__all__ = [ + 'oks_nms', 'soft_oks_nms', 'affine_transform', 'rotate_point', 'flip_back', + 'fliplr_joints', 'fliplr_regression', 'transform_preds', + 'get_affine_transform', 'get_warp_matrix', 'warp_affine_joints', + 'OneEuroFilter', 'oks_iou' +] diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/__init__.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c020c99f19ad32360510a3c806b76e48020fe18e Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/__init__.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/nms.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/nms.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f461f48dfedd7bb3898097cc26845c403dd565f Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/nms.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/one_euro_filter.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/one_euro_filter.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1776fead6d405c4d5e3117f728e9f267fbe211fd Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/one_euro_filter.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/post_transforms.cpython-39.pyc b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/post_transforms.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..deeb0e20060afdf039be725122851ab4bc23b8a1 Binary files /dev/null and b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/__pycache__/post_transforms.cpython-39.pyc differ diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/group.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/group.py new file mode 100644 index 0000000000000000000000000000000000000000..c8d4d4d112fdb8669a17a04207eb9bf9701bf642 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/group.py @@ -0,0 +1,410 @@ +# ------------------------------------------------------------------------------ +# Adapted from https://github.com/princeton-vl/pose-ae-train/ +# Original licence: Copyright (c) 2017, umich-vl, under BSD 3-Clause License. +# ------------------------------------------------------------------------------ + +import numpy as np +import torch +from munkres import Munkres + +from ..top_down_eval import post_dark_udp + + +def _py_max_match(scores): + """Apply munkres algorithm to get the best match. + + Args: + scores(np.ndarray): cost matrix. + + Returns: + np.ndarray: best match. + """ + m = Munkres() + tmp = m.compute(scores) + tmp = np.array(tmp).astype(int) + return tmp + + +def _match_by_tag(inp, params): + """Match joints by tags. Use Munkres algorithm to calculate the best match + for keypoints grouping. + + Note: + number of keypoints: K + max number of people in an image: M (M=30 by default) + dim of tags: L + If use flip testing, L=2; else L=1. + + Args: + inp(tuple): + tag_k (np.ndarray[KxMxL]): tag corresponding to the + top k values of feature map per keypoint. + loc_k (np.ndarray[KxMx2]): top k locations of the + feature maps for keypoint. + val_k (np.ndarray[KxM]): top k value of the + feature maps per keypoint. + params(Params): class Params(). + + Returns: + np.ndarray: result of pose groups. + """ + assert isinstance(params, _Params), 'params should be class _Params()' + + tag_k, loc_k, val_k = inp + + default_ = np.zeros((params.num_joints, 3 + tag_k.shape[2]), + dtype=np.float32) + + joint_dict = {} + tag_dict = {} + for i in range(params.num_joints): + idx = params.joint_order[i] + + tags = tag_k[idx] + joints = np.concatenate((loc_k[idx], val_k[idx, :, None], tags), 1) + mask = joints[:, 2] > params.detection_threshold + tags = tags[mask] + joints = joints[mask] + + if joints.shape[0] == 0: + continue + + if i == 0 or len(joint_dict) == 0: + for tag, joint in zip(tags, joints): + key = tag[0] + joint_dict.setdefault(key, np.copy(default_))[idx] = joint + tag_dict[key] = [tag] + else: + grouped_keys = list(joint_dict.keys())[:params.max_num_people] + grouped_tags = [np.mean(tag_dict[i], axis=0) for i in grouped_keys] + + if (params.ignore_too_much + and len(grouped_keys) == params.max_num_people): + continue + + diff = joints[:, None, 3:] - np.array(grouped_tags)[None, :, :] + diff_normed = np.linalg.norm(diff, ord=2, axis=2) + diff_saved = np.copy(diff_normed) + + if params.use_detection_val: + diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] + + num_added = diff.shape[0] + num_grouped = diff.shape[1] + + if num_added > num_grouped: + diff_normed = np.concatenate( + (diff_normed, + np.zeros((num_added, num_added - num_grouped), + dtype=np.float32) + 1e10), + axis=1) + + pairs = _py_max_match(diff_normed) + for row, col in pairs: + if (row < num_added and col < num_grouped + and diff_saved[row][col] < params.tag_threshold): + key = grouped_keys[col] + joint_dict[key][idx] = joints[row] + tag_dict[key].append(tags[row]) + else: + key = tags[row][0] + joint_dict.setdefault(key, np.copy(default_))[idx] = \ + joints[row] + tag_dict[key] = [tags[row]] + + results = np.array([joint_dict[i] for i in joint_dict]).astype(np.float32) + return results + + +class _Params: + """A class of parameter. + + Args: + cfg(Config): config. + """ + + def __init__(self, cfg): + self.num_joints = cfg['num_joints'] + self.max_num_people = cfg['max_num_people'] + + self.detection_threshold = cfg['detection_threshold'] + self.tag_threshold = cfg['tag_threshold'] + self.use_detection_val = cfg['use_detection_val'] + self.ignore_too_much = cfg['ignore_too_much'] + + if self.num_joints == 17: + self.joint_order = [ + i - 1 for i in + [1, 2, 3, 4, 5, 6, 7, 12, 13, 8, 9, 10, 11, 14, 15, 16, 17] + ] + else: + self.joint_order = list(np.arange(self.num_joints)) + + +class HeatmapParser: + """The heatmap parser for post processing.""" + + def __init__(self, cfg): + self.params = _Params(cfg) + self.tag_per_joint = cfg['tag_per_joint'] + self.pool = torch.nn.MaxPool2d(cfg['nms_kernel'], 1, + cfg['nms_padding']) + self.use_udp = cfg.get('use_udp', False) + self.score_per_joint = cfg.get('score_per_joint', False) + + def nms(self, heatmaps): + """Non-Maximum Suppression for heatmaps. + + Args: + heatmap(torch.Tensor): Heatmaps before nms. + + Returns: + torch.Tensor: Heatmaps after nms. + """ + + maxm = self.pool(heatmaps) + maxm = torch.eq(maxm, heatmaps).float() + heatmaps = heatmaps * maxm + + return heatmaps + + def match(self, tag_k, loc_k, val_k): + """Group keypoints to human poses in a batch. + + Args: + tag_k (np.ndarray[NxKxMxL]): tag corresponding to the + top k values of feature map per keypoint. + loc_k (np.ndarray[NxKxMx2]): top k locations of the + feature maps for keypoint. + val_k (np.ndarray[NxKxM]): top k value of the + feature maps per keypoint. + + Returns: + list + """ + + def _match(x): + return _match_by_tag(x, self.params) + + return list(map(_match, zip(tag_k, loc_k, val_k))) + + def top_k(self, heatmaps, tags): + """Find top_k values in an image. + + Note: + batch size: N + number of keypoints: K + heatmap height: H + heatmap width: W + max number of people: M + dim of tags: L + If use flip testing, L=2; else L=1. + + Args: + heatmaps (torch.Tensor[NxKxHxW]) + tags (torch.Tensor[NxKxHxWxL]) + + Returns: + dict: A dict containing top_k values. + + - tag_k (np.ndarray[NxKxMxL]): + tag corresponding to the top k values of + feature map per keypoint. + - loc_k (np.ndarray[NxKxMx2]): + top k location of feature map per keypoint. + - val_k (np.ndarray[NxKxM]): + top k value of feature map per keypoint. + """ + heatmaps = self.nms(heatmaps) + N, K, H, W = heatmaps.size() + heatmaps = heatmaps.view(N, K, -1) + val_k, ind = heatmaps.topk(self.params.max_num_people, dim=2) + + tags = tags.view(tags.size(0), tags.size(1), W * H, -1) + if not self.tag_per_joint: + tags = tags.expand(-1, self.params.num_joints, -1, -1) + + tag_k = torch.stack( + [torch.gather(tags[..., i], 2, ind) for i in range(tags.size(3))], + dim=3) + + x = ind % W + y = ind // W + + ind_k = torch.stack((x, y), dim=3) + + results = { + 'tag_k': tag_k.cpu().numpy(), + 'loc_k': ind_k.cpu().numpy(), + 'val_k': val_k.cpu().numpy() + } + + return results + + @staticmethod + def adjust(results, heatmaps): + """Adjust the coordinates for better accuracy. + + Note: + batch size: N + number of keypoints: K + heatmap height: H + heatmap width: W + + Args: + results (list(np.ndarray)): Keypoint predictions. + heatmaps (torch.Tensor[NxKxHxW]): Heatmaps. + """ + _, _, H, W = heatmaps.shape + for batch_id, people in enumerate(results): + for people_id, people_i in enumerate(people): + for joint_id, joint in enumerate(people_i): + if joint[2] > 0: + x, y = joint[0:2] + xx, yy = int(x), int(y) + tmp = heatmaps[batch_id][joint_id] + if tmp[min(H - 1, yy + 1), xx] > tmp[max(0, yy - 1), + xx]: + y += 0.25 + else: + y -= 0.25 + + if tmp[yy, min(W - 1, xx + 1)] > tmp[yy, + max(0, xx - 1)]: + x += 0.25 + else: + x -= 0.25 + results[batch_id][people_id, joint_id, + 0:2] = (x + 0.5, y + 0.5) + return results + + @staticmethod + def refine(heatmap, tag, keypoints, use_udp=False): + """Given initial keypoint predictions, we identify missing joints. + + Note: + number of keypoints: K + heatmap height: H + heatmap width: W + dim of tags: L + If use flip testing, L=2; else L=1. + + Args: + heatmap: np.ndarray(K, H, W). + tag: np.ndarray(K, H, W) | np.ndarray(K, H, W, L) + keypoints: np.ndarray of size (K, 3 + L) + last dim is (x, y, score, tag). + use_udp: bool-unbiased data processing + + Returns: + np.ndarray: The refined keypoints. + """ + + K, H, W = heatmap.shape + if len(tag.shape) == 3: + tag = tag[..., None] + + tags = [] + for i in range(K): + if keypoints[i, 2] > 0: + # save tag value of detected keypoint + x, y = keypoints[i][:2].astype(int) + x = np.clip(x, 0, W - 1) + y = np.clip(y, 0, H - 1) + tags.append(tag[i, y, x]) + + # mean tag of current detected people + prev_tag = np.mean(tags, axis=0) + results = [] + + for _heatmap, _tag in zip(heatmap, tag): + # distance of all tag values with mean tag of + # current detected people + distance_tag = (((_tag - + prev_tag[None, None, :])**2).sum(axis=2)**0.5) + norm_heatmap = _heatmap - np.round(distance_tag) + + # find maximum position + y, x = np.unravel_index(np.argmax(norm_heatmap), _heatmap.shape) + xx = x.copy() + yy = y.copy() + # detection score at maximum position + val = _heatmap[y, x] + if not use_udp: + # offset by 0.5 + x += 0.5 + y += 0.5 + + # add a quarter offset + if _heatmap[yy, min(W - 1, xx + 1)] > _heatmap[yy, max(0, xx - 1)]: + x += 0.25 + else: + x -= 0.25 + + if _heatmap[min(H - 1, yy + 1), xx] > _heatmap[max(0, yy - 1), xx]: + y += 0.25 + else: + y -= 0.25 + + results.append((x, y, val)) + results = np.array(results) + + if results is not None: + for i in range(K): + # add keypoint if it is not detected + if results[i, 2] > 0 and keypoints[i, 2] == 0: + keypoints[i, :3] = results[i, :3] + + return keypoints + + def parse(self, heatmaps, tags, adjust=True, refine=True): + """Group keypoints into poses given heatmap and tag. + + Note: + batch size: N + number of keypoints: K + heatmap height: H + heatmap width: W + dim of tags: L + If use flip testing, L=2; else L=1. + + Args: + heatmaps (torch.Tensor[NxKxHxW]): model output heatmaps. + tags (torch.Tensor[NxKxHxWxL]): model output tagmaps. + + Returns: + tuple: A tuple containing keypoint grouping results. + + - results (list(np.ndarray)): Pose results. + - scores (list/list(np.ndarray)): Score of people. + """ + results = self.match(**self.top_k(heatmaps, tags)) + + if adjust: + if self.use_udp: + for i in range(len(results)): + if results[i].shape[0] > 0: + results[i][..., :2] = post_dark_udp( + results[i][..., :2].copy(), heatmaps[i:i + 1, :]) + else: + results = self.adjust(results, heatmaps) + + if self.score_per_joint: + scores = [i[:, 2] for i in results[0]] + else: + scores = [i[:, 2].mean() for i in results[0]] + + if refine: + results = results[0] + # for every detected person + for i in range(len(results)): + heatmap_numpy = heatmaps[0].cpu().numpy() + tag_numpy = tags[0].cpu().numpy() + if not self.tag_per_joint: + tag_numpy = np.tile(tag_numpy, + (self.params.num_joints, 1, 1, 1)) + results[i] = self.refine( + heatmap_numpy, tag_numpy, results[i], use_udp=self.use_udp) + results = [results] + + return results, scores diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/nms.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/nms.py new file mode 100644 index 0000000000000000000000000000000000000000..3d78f73ebdcfce7e73b43e2b5d36bbdd0af16773 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/nms.py @@ -0,0 +1,207 @@ +# ------------------------------------------------------------------------------ +# Adapted from https://github.com/leoxiaobin/deep-high-resolution-net.pytorch +# Original licence: Copyright (c) Microsoft, under the MIT License. +# ------------------------------------------------------------------------------ + +import numpy as np + + +def nms(dets, thr): + """Greedily select boxes with high confidence and overlap <= thr. + + Args: + dets: [[x1, y1, x2, y2, score]]. + thr: Retain overlap < thr. + + Returns: + list: Indexes to keep. + """ + if len(dets) == 0: + return [] + + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while len(order) > 0: + i = order[0] + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.minimum(x2[i], x2[order[1:]]) + yy2 = np.minimum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thr)[0] + order = order[inds + 1] + + return keep + + +def oks_iou(g, d, a_g, a_d, sigmas=None, vis_thr=None): + """Calculate oks ious. + + Args: + g: Ground truth keypoints. + d: Detected keypoints. + a_g: Area of the ground truth object. + a_d: Area of the detected object. + sigmas: standard deviation of keypoint labelling. + vis_thr: threshold of the keypoint visibility. + + Returns: + list: The oks ious. + """ + if sigmas is None: + sigmas = np.array([ + .26, .25, .25, .35, .35, .79, .79, .72, .72, .62, .62, 1.07, 1.07, + .87, .87, .89, .89 + ]) / 10.0 + vars = (sigmas * 2)**2 + xg = g[0::3] + yg = g[1::3] + vg = g[2::3] + ious = np.zeros(len(d), dtype=np.float32) + for n_d in range(0, len(d)): + xd = d[n_d, 0::3] + yd = d[n_d, 1::3] + vd = d[n_d, 2::3] + dx = xd - xg + dy = yd - yg + e = (dx**2 + dy**2) / vars / ((a_g + a_d[n_d]) / 2 + np.spacing(1)) / 2 + if vis_thr is not None: + ind = list(vg > vis_thr) and list(vd > vis_thr) + e = e[ind] + ious[n_d] = np.sum(np.exp(-e)) / len(e) if len(e) != 0 else 0.0 + return ious + + +def oks_nms(kpts_db, thr, sigmas=None, vis_thr=None, score_per_joint=False): + """OKS NMS implementations. + + Args: + kpts_db: keypoints. + thr: Retain overlap < thr. + sigmas: standard deviation of keypoint labelling. + vis_thr: threshold of the keypoint visibility. + score_per_joint: the input scores (in kpts_db) are per joint scores + + Returns: + np.ndarray: indexes to keep. + """ + if len(kpts_db) == 0: + return [] + + if score_per_joint: + scores = np.array([k['score'].mean() for k in kpts_db]) + else: + scores = np.array([k['score'] for k in kpts_db]) + + kpts = np.array([k['keypoints'].flatten() for k in kpts_db]) + areas = np.array([k['area'] for k in kpts_db]) + + order = scores.argsort()[::-1] + + keep = [] + while len(order) > 0: + i = order[0] + keep.append(i) + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], + sigmas, vis_thr) + + inds = np.where(oks_ovr <= thr)[0] + order = order[inds + 1] + + keep = np.array(keep) + + return keep + + +def _rescore(overlap, scores, thr, type='gaussian'): + """Rescoring mechanism gaussian or linear. + + Args: + overlap: calculated ious + scores: target scores. + thr: retain oks overlap < thr. + type: 'gaussian' or 'linear' + + Returns: + np.ndarray: indexes to keep + """ + assert len(overlap) == len(scores) + assert type in ['gaussian', 'linear'] + + if type == 'linear': + inds = np.where(overlap >= thr)[0] + scores[inds] = scores[inds] * (1 - overlap[inds]) + else: + scores = scores * np.exp(-overlap**2 / thr) + + return scores + + +def soft_oks_nms(kpts_db, + thr, + max_dets=20, + sigmas=None, + vis_thr=None, + score_per_joint=False): + """Soft OKS NMS implementations. + + Args: + kpts_db + thr: retain oks overlap < thr. + max_dets: max number of detections to keep. + sigmas: Keypoint labelling uncertainty. + score_per_joint: the input scores (in kpts_db) are per joint scores + + Returns: + np.ndarray: indexes to keep. + """ + if len(kpts_db) == 0: + return [] + + if score_per_joint: + scores = np.array([k['score'].mean() for k in kpts_db]) + else: + scores = np.array([k['score'] for k in kpts_db]) + + kpts = np.array([k['keypoints'].flatten() for k in kpts_db]) + areas = np.array([k['area'] for k in kpts_db]) + + order = scores.argsort()[::-1] + scores = scores[order] + + keep = np.zeros(max_dets, dtype=np.intp) + keep_cnt = 0 + while len(order) > 0 and keep_cnt < max_dets: + i = order[0] + + oks_ovr = oks_iou(kpts[i], kpts[order[1:]], areas[i], areas[order[1:]], + sigmas, vis_thr) + + order = order[1:] + scores = _rescore(oks_ovr, scores[1:], thr) + + tmp = scores.argsort()[::-1] + order = order[tmp] + scores = scores[tmp] + + keep[keep_cnt] = i + keep_cnt += 1 + + keep = keep[:keep_cnt] + + return keep diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/one_euro_filter.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/one_euro_filter.py new file mode 100644 index 0000000000000000000000000000000000000000..7db4e14c8825cfc187a3d8459cc652e1193d3ebb --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/one_euro_filter.py @@ -0,0 +1,102 @@ +# ------------------------------------------------------------------------------ +# Adapted from https://github.com/HoBeom/OneEuroFilter-Numpy +# Original licence: Copyright (c) HoBeom Jeon, under the MIT License. +# ------------------------------------------------------------------------------ +from time import time + +import numpy as np + + +def smoothing_factor(t_e, cutoff): + r = 2 * np.pi * cutoff * t_e + return r / (r + 1) + + +def exponential_smoothing(a, x, x_prev): + return a * x + (1 - a) * x_prev + + +class OneEuroFilter: + + def __init__(self, + x0, + dx0=0.0, + min_cutoff=1.7, + beta=0.3, + d_cutoff=30.0, + fps=None): + """One Euro Filter for keypoints smoothing. + + Args: + x0 (np.ndarray[K, 2]): Initialize keypoints value + dx0 (float): 0.0 + min_cutoff (float): parameter for one euro filter + beta (float): parameter for one euro filter + d_cutoff (float): Input data FPS + fps (float): Video FPS for video inference + """ + + # The parameters. + self.data_shape = x0.shape + self.min_cutoff = np.full(x0.shape, min_cutoff) + self.beta = np.full(x0.shape, beta) + self.d_cutoff = np.full(x0.shape, d_cutoff) + # Previous values. + self.x_prev = x0.astype(np.float32) + self.dx_prev = np.full(x0.shape, dx0) + self.mask_prev = np.ma.masked_where(x0 <= 0, x0) + self.realtime = True + if fps is None: + # Using in realtime inference + self.t_e = None + self.skip_frame_factor = d_cutoff + else: + # fps using video inference + self.realtime = False + self.d_cutoff = np.full(x0.shape, float(fps)) + self.t_prev = time() + + def __call__(self, x, t_e=1.0): + """Compute the filtered signal. + + Hyper-parameters (cutoff, beta) are from `VNect + `__ . + + Realtime Camera fps (d_cutoff) default 30.0 + + Args: + x (np.ndarray[K, 2]): keypoints results in frame + t_e (Optional): video skip frame count for posetrack + evaluation + """ + assert x.shape == self.data_shape + + t = 0 + if self.realtime: + t = time() + t_e = (t - self.t_prev) * self.skip_frame_factor + t_e = np.full(x.shape, t_e) + + # missing keypoints mask + mask = np.ma.masked_where(x <= 0, x) + + # The filtered derivative of the signal. + a_d = smoothing_factor(t_e, self.d_cutoff) + dx = (x - self.x_prev) / t_e + dx_hat = exponential_smoothing(a_d, dx, self.dx_prev) + + # The filtered signal. + cutoff = self.min_cutoff + self.beta * np.abs(dx_hat) + a = smoothing_factor(t_e, cutoff) + x_hat = exponential_smoothing(a, x, self.x_prev) + + # missing keypoints remove + np.copyto(x_hat, -10, where=mask.mask) + + # Memorize the previous values. + self.x_prev = x_hat + self.dx_prev = dx_hat + self.t_prev = t + self.mask_prev = mask + + return x_hat diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/post_transforms.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/post_transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..11a8371b53d22d41db6ca0dc7647f0dca75d2560 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/post_processing/post_transforms.py @@ -0,0 +1,366 @@ +# ------------------------------------------------------------------------------ +# Adapted from https://github.com/leoxiaobin/deep-high-resolution-net.pytorch +# Original licence: Copyright (c) Microsoft, under the MIT License. +# ------------------------------------------------------------------------------ + +import math + +import cv2 +import numpy as np +import torch + + +def fliplr_joints(joints_3d, joints_3d_visible, img_width, flip_pairs): + """Flip human joints horizontally. + + Note: + - num_keypoints: K + + Args: + joints_3d (np.ndarray([K, 3])): Coordinates of keypoints. + joints_3d_visible (np.ndarray([K, 1])): Visibility of keypoints. + img_width (int): Image width. + flip_pairs (list[tuple]): Pairs of keypoints which are mirrored + (for example, left ear and right ear). + + Returns: + tuple: Flipped human joints. + + - joints_3d_flipped (np.ndarray([K, 3])): Flipped joints. + - joints_3d_visible_flipped (np.ndarray([K, 1])): Joint visibility. + """ + + assert len(joints_3d) == len(joints_3d_visible) + assert img_width > 0 + + joints_3d_flipped = joints_3d.copy() + joints_3d_visible_flipped = joints_3d_visible.copy() + + # Swap left-right parts + for left, right in flip_pairs: + joints_3d_flipped[left, :] = joints_3d[right, :] + joints_3d_flipped[right, :] = joints_3d[left, :] + + joints_3d_visible_flipped[left, :] = joints_3d_visible[right, :] + joints_3d_visible_flipped[right, :] = joints_3d_visible[left, :] + + # Flip horizontally + joints_3d_flipped[:, 0] = img_width - 1 - joints_3d_flipped[:, 0] + joints_3d_flipped = joints_3d_flipped * joints_3d_visible_flipped + + return joints_3d_flipped, joints_3d_visible_flipped + + +def fliplr_regression(regression, + flip_pairs, + center_mode='static', + center_x=0.5, + center_index=0): + """Flip human joints horizontally. + + Note: + - batch_size: N + - num_keypoint: K + + Args: + regression (np.ndarray([..., K, C])): Coordinates of keypoints, where K + is the joint number and C is the dimension. Example shapes are: + + - [N, K, C]: a batch of keypoints where N is the batch size. + - [N, T, K, C]: a batch of pose sequences, where T is the frame + number. + flip_pairs (list[tuple()]): Pairs of keypoints which are mirrored + (for example, left ear -- right ear). + center_mode (str): The mode to set the center location on the x-axis + to flip around. Options are: + + - static: use a static x value (see center_x also) + - root: use a root joint (see center_index also) + center_x (float): Set the x-axis location of the flip center. Only used + when center_mode=static. + center_index (int): Set the index of the root joint, whose x location + will be used as the flip center. Only used when center_mode=root. + + Returns: + np.ndarray([..., K, C]): Flipped joints. + """ + assert regression.ndim >= 2, f'Invalid pose shape {regression.shape}' + + allowed_center_mode = {'static', 'root'} + assert center_mode in allowed_center_mode, 'Get invalid center_mode ' \ + f'{center_mode}, allowed choices are {allowed_center_mode}' + + if center_mode == 'static': + x_c = center_x + elif center_mode == 'root': + assert regression.shape[-2] > center_index + x_c = regression[..., center_index:center_index + 1, 0] + + regression_flipped = regression.copy() + # Swap left-right parts + for left, right in flip_pairs: + regression_flipped[..., left, :] = regression[..., right, :] + regression_flipped[..., right, :] = regression[..., left, :] + + # Flip horizontally + regression_flipped[..., 0] = x_c * 2 - regression_flipped[..., 0] + return regression_flipped + + +def flip_back(output_flipped, flip_pairs, target_type='GaussianHeatmap'): + """Flip the flipped heatmaps back to the original form. + + Note: + - batch_size: N + - num_keypoints: K + - heatmap height: H + - heatmap width: W + + Args: + output_flipped (np.ndarray[N, K, H, W]): The output heatmaps obtained + from the flipped images. + flip_pairs (list[tuple()): Pairs of keypoints which are mirrored + (for example, left ear -- right ear). + target_type (str): GaussianHeatmap or CombinedTarget + + Returns: + np.ndarray: heatmaps that flipped back to the original image + """ + assert output_flipped.ndim == 4, \ + 'output_flipped should be [batch_size, num_keypoints, height, width]' + shape_ori = output_flipped.shape + channels = 1 + if target_type.lower() == 'CombinedTarget'.lower(): + channels = 3 + output_flipped[:, 1::3, ...] = -output_flipped[:, 1::3, ...] + output_flipped = output_flipped.reshape(shape_ori[0], -1, channels, + shape_ori[2], shape_ori[3]) + output_flipped_back = output_flipped.copy() + + # Swap left-right parts + for left, right in flip_pairs: + output_flipped_back[:, left, ...] = output_flipped[:, right, ...] + output_flipped_back[:, right, ...] = output_flipped[:, left, ...] + output_flipped_back = output_flipped_back.reshape(shape_ori) + # Flip horizontally + output_flipped_back = output_flipped_back[..., ::-1] + return output_flipped_back + + +def transform_preds(coords, center, scale, output_size, use_udp=False): + """Get final keypoint predictions from heatmaps and apply scaling and + translation to map them back to the image. + + Note: + num_keypoints: K + + Args: + coords (np.ndarray[K, ndims]): + + * If ndims=2, corrds are predicted keypoint location. + * If ndims=4, corrds are composed of (x, y, scores, tags) + * If ndims=5, corrds are composed of (x, y, scores, tags, + flipped_tags) + + center (np.ndarray[2, ]): Center of the bounding box (x, y). + scale (np.ndarray[2, ]): Scale of the bounding box + wrt [width, height]. + output_size (np.ndarray[2, ] | list(2,)): Size of the + destination heatmaps. + use_udp (bool): Use unbiased data processing + + Returns: + np.ndarray: Predicted coordinates in the images. + """ + assert coords.shape[1] in (2, 4, 5) + assert len(center) == 2 + assert len(scale) == 2 + assert len(output_size) == 2 + + # Recover the scale which is normalized by a factor of 200. + # scale = scale * 200.0 + + if use_udp: + scale_x = scale[0] / (output_size[0] - 1.0) + scale_y = scale[1] / (output_size[1] - 1.0) + else: + scale_x = scale[0] / output_size[0] + scale_y = scale[1] / output_size[1] + + target_coords = np.ones_like(coords) + target_coords[:, 0] = coords[:, 0] * scale_x + center[0] - scale[0] * 0.5 + target_coords[:, 1] = coords[:, 1] * scale_y + center[1] - scale[1] * 0.5 + + return target_coords + + +def get_affine_transform(center, + scale, + rot, + output_size, + shift=(0., 0.), + inv=False): + """Get the affine transform matrix, given the center/scale/rot/output_size. + + Args: + center (np.ndarray[2, ]): Center of the bounding box (x, y). + scale (np.ndarray[2, ]): Scale of the bounding box + wrt [width, height]. + rot (float): Rotation angle (degree). + output_size (np.ndarray[2, ] | list(2,)): Size of the + destination heatmaps. + shift (0-100%): Shift translation ratio wrt the width/height. + Default (0., 0.). + inv (bool): Option to inverse the affine transform direction. + (inv=False: src->dst or inv=True: dst->src) + + Returns: + np.ndarray: The transform matrix. + """ + assert len(center) == 2 + assert len(scale) == 2 + assert len(output_size) == 2 + assert len(shift) == 2 + + # pixel_std is 200. + scale_tmp = scale * 200.0 + + shift = np.array(shift) + src_w = scale_tmp[0] + dst_w = output_size[0] + dst_h = output_size[1] + + rot_rad = np.pi * rot / 180 + src_dir = rotate_point([0., src_w * -0.5], rot_rad) + dst_dir = np.array([0., dst_w * -0.5]) + + src = np.zeros((3, 2), dtype=np.float32) + src[0, :] = center + scale_tmp * shift + src[1, :] = center + src_dir + scale_tmp * shift + src[2, :] = _get_3rd_point(src[0, :], src[1, :]) + + dst = np.zeros((3, 2), dtype=np.float32) + dst[0, :] = [dst_w * 0.5, dst_h * 0.5] + dst[1, :] = np.array([dst_w * 0.5, dst_h * 0.5]) + dst_dir + dst[2, :] = _get_3rd_point(dst[0, :], dst[1, :]) + + if inv: + trans = cv2.getAffineTransform(np.float32(dst), np.float32(src)) + else: + trans = cv2.getAffineTransform(np.float32(src), np.float32(dst)) + + return trans + + +def affine_transform(pt, trans_mat): + """Apply an affine transformation to the points. + + Args: + pt (np.ndarray): a 2 dimensional point to be transformed + trans_mat (np.ndarray): 2x3 matrix of an affine transform + + Returns: + np.ndarray: Transformed points. + """ + assert len(pt) == 2 + new_pt = np.array(trans_mat) @ np.array([pt[0], pt[1], 1.]) + + return new_pt + + +def _get_3rd_point(a, b): + """To calculate the affine matrix, three pairs of points are required. This + function is used to get the 3rd point, given 2D points a & b. + + The 3rd point is defined by rotating vector `a - b` by 90 degrees + anticlockwise, using b as the rotation center. + + Args: + a (np.ndarray): point(x,y) + b (np.ndarray): point(x,y) + + Returns: + np.ndarray: The 3rd point. + """ + assert len(a) == 2 + assert len(b) == 2 + direction = a - b + third_pt = b + np.array([-direction[1], direction[0]], dtype=np.float32) + + return third_pt + + +def rotate_point(pt, angle_rad): + """Rotate a point by an angle. + + Args: + pt (list[float]): 2 dimensional point to be rotated + angle_rad (float): rotation angle by radian + + Returns: + list[float]: Rotated point. + """ + assert len(pt) == 2 + sn, cs = np.sin(angle_rad), np.cos(angle_rad) + new_x = pt[0] * cs - pt[1] * sn + new_y = pt[0] * sn + pt[1] * cs + rotated_pt = [new_x, new_y] + + return rotated_pt + + +def get_warp_matrix(theta, size_input, size_dst, size_target): + """Calculate the transformation matrix under the constraint of unbiased. + Paper ref: Huang et al. The Devil is in the Details: Delving into Unbiased + Data Processing for Human Pose Estimation (CVPR 2020). + + Args: + theta (float): Rotation angle in degrees. + size_input (np.ndarray): Size of input image [w, h]. + size_dst (np.ndarray): Size of output image [w, h]. + size_target (np.ndarray): Size of ROI in input plane [w, h]. + + Returns: + np.ndarray: A matrix for transformation. + """ + theta = np.deg2rad(theta) + matrix = np.zeros((2, 3), dtype=np.float32) + scale_x = size_dst[0] / size_target[0] + scale_y = size_dst[1] / size_target[1] + matrix[0, 0] = math.cos(theta) * scale_x + matrix[0, 1] = -math.sin(theta) * scale_x + matrix[0, 2] = scale_x * (-0.5 * size_input[0] * math.cos(theta) + + 0.5 * size_input[1] * math.sin(theta) + + 0.5 * size_target[0]) + matrix[1, 0] = math.sin(theta) * scale_y + matrix[1, 1] = math.cos(theta) * scale_y + matrix[1, 2] = scale_y * (-0.5 * size_input[0] * math.sin(theta) - + 0.5 * size_input[1] * math.cos(theta) + + 0.5 * size_target[1]) + return matrix + + +def warp_affine_joints(joints, mat): + """Apply affine transformation defined by the transform matrix on the + joints. + + Args: + joints (np.ndarray[..., 2]): Origin coordinate of joints. + mat (np.ndarray[3, 2]): The affine matrix. + + Returns: + np.ndarray[..., 2]: Result coordinate of joints. + """ + joints = np.array(joints) + shape = joints.shape + joints = joints.reshape(-1, 2) + return np.dot( + np.concatenate((joints, joints[:, 0:1] * 0 + 1), axis=1), + mat.T).reshape(shape) + + +def affine_transform_torch(pts, t): + npts = pts.shape[0] + pts_homo = torch.cat([pts, torch.ones(npts, 1, device=pts.device)], dim=1) + out = torch.mm(t, torch.t(pts_homo)) + return torch.t(out[:2, :]) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/top_down_eval.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/top_down_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..8d90eb8ee1e6d4d806102ab6dc377ace43d54e26 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/top_down_eval.py @@ -0,0 +1,703 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import warnings + +import cv2 +import numpy as np + +from .post_processing import transform_preds + +# def heatmap2coords(heatmaps: np.ndarray, original_resolution: tuple[int, int]=(256, 192)) -> np.ndarray: +# __, __, heatmap_h, heatmap_w = heatmaps.shape +# output = [] +# for heatmap in heatmaps: +# keypoint_coords = [] +# for joint in heatmap: +# keypoint_coord = np.unravel_index(np.argmax(joint), (heatmap_h, heatmap_w)) +# """ +# - 0: coord_y / (height//4) * bbox_height + bb_y1 +# - 1: coord_x / (width//4) * bbox_width + bb_x1 +# - 2: confidences +# """ +# coord_y = keypoint_coord[0] / heatmap_h*original_resolution[0] +# coord_x = keypoint_coord[1] / heatmap_w*original_resolution[1] +# prob = joint[keypoint_coord] +# keypoint_coords.append([coord_y, coord_x, prob]) +# output.append(keypoint_coords) + +# return np.array(output).astype(float) + +def _calc_distances(preds, targets, mask, normalize): + """Calculate the normalized distances between preds and target. + + Note: + batch_size: N + num_keypoints: K + dimension of keypoints: D (normally, D=2 or D=3) + + Args: + preds (np.ndarray[N, K, D]): Predicted keypoint location. + targets (np.ndarray[N, K, D]): Groundtruth keypoint location. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + normalize (np.ndarray[N, D]): Typical value is heatmap_size + + Returns: + np.ndarray[K, N]: The normalized distances. \ + If target keypoints are missing, the distance is -1. + """ + N, K, _ = preds.shape + # set mask=0 when normalize==0 + _mask = mask.copy() + _mask[np.where((normalize == 0).sum(1))[0], :] = False + distances = np.full((N, K), -1, dtype=np.float32) + # handle invalid values + normalize[np.where(normalize <= 0)] = 1e6 + distances[_mask] = np.linalg.norm( + ((preds - targets) / normalize[:, None, :])[_mask], axis=-1) + return distances.T + + +def _distance_acc(distances, thr=0.5): + """Return the percentage below the distance threshold, while ignoring + distances values with -1. + + Note: + batch_size: N + Args: + distances (np.ndarray[N, ]): The normalized distances. + thr (float): Threshold of the distances. + + Returns: + float: Percentage of distances below the threshold. \ + If all target keypoints are missing, return -1. + """ + distance_valid = distances != -1 + num_distance_valid = distance_valid.sum() + if num_distance_valid > 0: + return (distances[distance_valid] < thr).sum() / num_distance_valid + return -1 + + +def _get_max_preds(heatmaps): + """Get keypoint predictions from score maps. + + Note: + batch_size: N + num_keypoints: K + heatmap height: H + heatmap width: W + + Args: + heatmaps (np.ndarray[N, K, H, W]): model predicted heatmaps. + + Returns: + tuple: A tuple containing aggregated results. + + - preds (np.ndarray[N, K, 2]): Predicted keypoint location. + - maxvals (np.ndarray[N, K, 1]): Scores (confidence) of the keypoints. + """ + assert isinstance(heatmaps, + np.ndarray), ('heatmaps should be numpy.ndarray') + assert heatmaps.ndim == 4, 'batch_images should be 4-ndim' + + N, K, _, W = heatmaps.shape + heatmaps_reshaped = heatmaps.reshape((N, K, -1)) + idx = np.argmax(heatmaps_reshaped, 2).reshape((N, K, 1)) + maxvals = np.amax(heatmaps_reshaped, 2).reshape((N, K, 1)) + + preds = np.tile(idx, (1, 1, 2)).astype(np.float32) + preds[:, :, 0] = preds[:, :, 0] % W + preds[:, :, 1] = preds[:, :, 1] // W + + preds = np.where(np.tile(maxvals, (1, 1, 2)) > 0.0, preds, -1) + return preds, maxvals + + +def _get_max_preds_3d(heatmaps): + """Get keypoint predictions from 3D score maps. + + Note: + batch size: N + num keypoints: K + heatmap depth size: D + heatmap height: H + heatmap width: W + + Args: + heatmaps (np.ndarray[N, K, D, H, W]): model predicted heatmaps. + + Returns: + tuple: A tuple containing aggregated results. + + - preds (np.ndarray[N, K, 3]): Predicted keypoint location. + - maxvals (np.ndarray[N, K, 1]): Scores (confidence) of the keypoints. + """ + assert isinstance(heatmaps, np.ndarray), \ + ('heatmaps should be numpy.ndarray') + assert heatmaps.ndim == 5, 'heatmaps should be 5-ndim' + + N, K, D, H, W = heatmaps.shape + heatmaps_reshaped = heatmaps.reshape((N, K, -1)) + idx = np.argmax(heatmaps_reshaped, 2).reshape((N, K, 1)) + maxvals = np.amax(heatmaps_reshaped, 2).reshape((N, K, 1)) + + preds = np.zeros((N, K, 3), dtype=np.float32) + _idx = idx[..., 0] + preds[..., 2] = _idx // (H * W) + preds[..., 1] = (_idx // W) % H + preds[..., 0] = _idx % W + + preds = np.where(maxvals > 0.0, preds, -1) + return preds, maxvals + + +def pose_pck_accuracy(output, target, mask, thr=0.05, normalize=None): + """Calculate the pose accuracy of PCK for each individual keypoint and the + averaged accuracy across all keypoints from heatmaps. + + Note: + PCK metric measures accuracy of the localization of the body joints. + The distances between predicted positions and the ground-truth ones + are typically normalized by the bounding box size. + The threshold (thr) of the normalized distance is commonly set + as 0.05, 0.1 or 0.2 etc. + + - batch_size: N + - num_keypoints: K + - heatmap height: H + - heatmap width: W + + Args: + output (np.ndarray[N, K, H, W]): Model output heatmaps. + target (np.ndarray[N, K, H, W]): Groundtruth heatmaps. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + thr (float): Threshold of PCK calculation. Default 0.05. + normalize (np.ndarray[N, 2]): Normalization factor for H&W. + + Returns: + tuple: A tuple containing keypoint accuracy. + + - np.ndarray[K]: Accuracy of each keypoint. + - float: Averaged accuracy across all keypoints. + - int: Number of valid keypoints. + """ + N, K, H, W = output.shape + if K == 0: + return None, 0, 0 + if normalize is None: + normalize = np.tile(np.array([[H, W]]), (N, 1)) + + pred, _ = _get_max_preds(output) + gt, _ = _get_max_preds(target) + return keypoint_pck_accuracy(pred, gt, mask, thr, normalize) + + +def keypoint_pck_accuracy(pred, gt, mask, thr, normalize): + """Calculate the pose accuracy of PCK for each individual keypoint and the + averaged accuracy across all keypoints for coordinates. + + Note: + PCK metric measures accuracy of the localization of the body joints. + The distances between predicted positions and the ground-truth ones + are typically normalized by the bounding box size. + The threshold (thr) of the normalized distance is commonly set + as 0.05, 0.1 or 0.2 etc. + + - batch_size: N + - num_keypoints: K + + Args: + pred (np.ndarray[N, K, 2]): Predicted keypoint location. + gt (np.ndarray[N, K, 2]): Groundtruth keypoint location. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + thr (float): Threshold of PCK calculation. + normalize (np.ndarray[N, 2]): Normalization factor for H&W. + + Returns: + tuple: A tuple containing keypoint accuracy. + + - acc (np.ndarray[K]): Accuracy of each keypoint. + - avg_acc (float): Averaged accuracy across all keypoints. + - cnt (int): Number of valid keypoints. + """ + distances = _calc_distances(pred, gt, mask, normalize) + + acc = np.array([_distance_acc(d, thr) for d in distances]) + valid_acc = acc[acc >= 0] + cnt = len(valid_acc) + avg_acc = valid_acc.mean() if cnt > 0 else 0 + return acc, avg_acc, cnt + + +def keypoint_auc(pred, gt, mask, normalize, num_step=20): + """Calculate the pose accuracy of PCK for each individual keypoint and the + averaged accuracy across all keypoints for coordinates. + + Note: + - batch_size: N + - num_keypoints: K + + Args: + pred (np.ndarray[N, K, 2]): Predicted keypoint location. + gt (np.ndarray[N, K, 2]): Groundtruth keypoint location. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + normalize (float): Normalization factor. + + Returns: + float: Area under curve. + """ + nor = np.tile(np.array([[normalize, normalize]]), (pred.shape[0], 1)) + x = [1.0 * i / num_step for i in range(num_step)] + y = [] + for thr in x: + _, avg_acc, _ = keypoint_pck_accuracy(pred, gt, mask, thr, nor) + y.append(avg_acc) + + auc = 0 + for i in range(num_step): + auc += 1.0 / num_step * y[i] + return auc + + +def keypoint_nme(pred, gt, mask, normalize_factor): + """Calculate the normalized mean error (NME). + + Note: + - batch_size: N + - num_keypoints: K + + Args: + pred (np.ndarray[N, K, 2]): Predicted keypoint location. + gt (np.ndarray[N, K, 2]): Groundtruth keypoint location. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + normalize_factor (np.ndarray[N, 2]): Normalization factor. + + Returns: + float: normalized mean error + """ + distances = _calc_distances(pred, gt, mask, normalize_factor) + distance_valid = distances[distances != -1] + return distance_valid.sum() / max(1, len(distance_valid)) + + +def keypoint_epe(pred, gt, mask): + """Calculate the end-point error. + + Note: + - batch_size: N + - num_keypoints: K + + Args: + pred (np.ndarray[N, K, 2]): Predicted keypoint location. + gt (np.ndarray[N, K, 2]): Groundtruth keypoint location. + mask (np.ndarray[N, K]): Visibility of the target. False for invisible + joints, and True for visible. Invisible joints will be ignored for + accuracy calculation. + + Returns: + float: Average end-point error. + """ + + distances = _calc_distances( + pred, gt, mask, + np.ones((pred.shape[0], pred.shape[2]), dtype=np.float32)) + distance_valid = distances[distances != -1] + return distance_valid.sum() / max(1, len(distance_valid)) + + +def _taylor(heatmap, coord): + """Distribution aware coordinate decoding method. + + Note: + - heatmap height: H + - heatmap width: W + + Args: + heatmap (np.ndarray[H, W]): Heatmap of a particular joint type. + coord (np.ndarray[2,]): Coordinates of the predicted keypoints. + + Returns: + np.ndarray[2,]: Updated coordinates. + """ + H, W = heatmap.shape[:2] + px, py = int(coord[0]), int(coord[1]) + if 1 < px < W - 2 and 1 < py < H - 2: + dx = 0.5 * (heatmap[py][px + 1] - heatmap[py][px - 1]) + dy = 0.5 * (heatmap[py + 1][px] - heatmap[py - 1][px]) + dxx = 0.25 * ( + heatmap[py][px + 2] - 2 * heatmap[py][px] + heatmap[py][px - 2]) + dxy = 0.25 * ( + heatmap[py + 1][px + 1] - heatmap[py - 1][px + 1] - + heatmap[py + 1][px - 1] + heatmap[py - 1][px - 1]) + dyy = 0.25 * ( + heatmap[py + 2 * 1][px] - 2 * heatmap[py][px] + + heatmap[py - 2 * 1][px]) + derivative = np.array([[dx], [dy]]) + hessian = np.array([[dxx, dxy], [dxy, dyy]]) + if dxx * dyy - dxy**2 != 0: + hessianinv = np.linalg.inv(hessian) + offset = -hessianinv @ derivative + offset = np.squeeze(np.array(offset.T), axis=0) + coord += offset + return coord + + +def post_dark_udp(coords, batch_heatmaps, kernel=3): + """DARK post-pocessing. Implemented by udp. Paper ref: Huang et al. The + Devil is in the Details: Delving into Unbiased Data Processing for Human + Pose Estimation (CVPR 2020). Zhang et al. Distribution-Aware Coordinate + Representation for Human Pose Estimation (CVPR 2020). + + Note: + - batch size: B + - num keypoints: K + - num persons: N + - height of heatmaps: H + - width of heatmaps: W + + B=1 for bottom_up paradigm where all persons share the same heatmap. + B=N for top_down paradigm where each person has its own heatmaps. + + Args: + coords (np.ndarray[N, K, 2]): Initial coordinates of human pose. + batch_heatmaps (np.ndarray[B, K, H, W]): batch_heatmaps + kernel (int): Gaussian kernel size (K) for modulation. + + Returns: + np.ndarray([N, K, 2]): Refined coordinates. + """ + if not isinstance(batch_heatmaps, np.ndarray): + batch_heatmaps = batch_heatmaps.cpu().numpy() + B, K, H, W = batch_heatmaps.shape + N = coords.shape[0] + assert (B == 1 or B == N) + for heatmaps in batch_heatmaps: + for heatmap in heatmaps: + cv2.GaussianBlur(heatmap, (kernel, kernel), 0, heatmap) + np.clip(batch_heatmaps, 0.001, 50, batch_heatmaps) + np.log(batch_heatmaps, batch_heatmaps) + + batch_heatmaps_pad = np.pad( + batch_heatmaps, ((0, 0), (0, 0), (1, 1), (1, 1)), + mode='edge').flatten() + + index = coords[..., 0] + 1 + (coords[..., 1] + 1) * (W + 2) + index += (W + 2) * (H + 2) * np.arange(0, B * K).reshape(-1, K) + index = index.astype(int).reshape(-1, 1) + i_ = batch_heatmaps_pad[index] + ix1 = batch_heatmaps_pad[index + 1] + iy1 = batch_heatmaps_pad[index + W + 2] + ix1y1 = batch_heatmaps_pad[index + W + 3] + ix1_y1_ = batch_heatmaps_pad[index - W - 3] + ix1_ = batch_heatmaps_pad[index - 1] + iy1_ = batch_heatmaps_pad[index - 2 - W] + + dx = 0.5 * (ix1 - ix1_) + dy = 0.5 * (iy1 - iy1_) + derivative = np.concatenate([dx, dy], axis=1) + derivative = derivative.reshape(N, K, 2, 1) + dxx = ix1 - 2 * i_ + ix1_ + dyy = iy1 - 2 * i_ + iy1_ + dxy = 0.5 * (ix1y1 - ix1 - iy1 + i_ + i_ - ix1_ - iy1_ + ix1_y1_) + hessian = np.concatenate([dxx, dxy, dxy, dyy], axis=1) + hessian = hessian.reshape(N, K, 2, 2) + hessian = np.linalg.inv(hessian + np.finfo(np.float32).eps * np.eye(2)) + coords -= np.einsum('ijmn,ijnk->ijmk', hessian, derivative).squeeze() + return coords + + +def _gaussian_blur(heatmaps, kernel=11): + """Modulate heatmap distribution with Gaussian. + sigma = 0.3*((kernel_size-1)*0.5-1)+0.8 + sigma~=3 if k=17 + sigma=2 if k=11; + sigma~=1.5 if k=7; + sigma~=1 if k=3; + + Note: + - batch_size: N + - num_keypoints: K + - heatmap height: H + - heatmap width: W + + Args: + heatmaps (np.ndarray[N, K, H, W]): model predicted heatmaps. + kernel (int): Gaussian kernel size (K) for modulation, which should + match the heatmap gaussian sigma when training. + K=17 for sigma=3 and k=11 for sigma=2. + + Returns: + np.ndarray ([N, K, H, W]): Modulated heatmap distribution. + """ + assert kernel % 2 == 1 + + border = (kernel - 1) // 2 + batch_size = heatmaps.shape[0] + num_joints = heatmaps.shape[1] + height = heatmaps.shape[2] + width = heatmaps.shape[3] + for i in range(batch_size): + for j in range(num_joints): + origin_max = np.max(heatmaps[i, j]) + dr = np.zeros((height + 2 * border, width + 2 * border), + dtype=np.float32) + dr[border:-border, border:-border] = heatmaps[i, j].copy() + dr = cv2.GaussianBlur(dr, (kernel, kernel), 0) + heatmaps[i, j] = dr[border:-border, border:-border].copy() + heatmaps[i, j] *= origin_max / np.max(heatmaps[i, j]) + return heatmaps + + +def keypoints_from_regression(regression_preds, center, scale, img_size): + """Get final keypoint predictions from regression vectors and transform + them back to the image. + + Note: + - batch_size: N + - num_keypoints: K + + Args: + regression_preds (np.ndarray[N, K, 2]): model prediction. + center (np.ndarray[N, 2]): Center of the bounding box (x, y). + scale (np.ndarray[N, 2]): Scale of the bounding box + wrt height/width. + img_size (list(img_width, img_height)): model input image size. + + Returns: + tuple: + + - preds (np.ndarray[N, K, 2]): Predicted keypoint location in images. + - maxvals (np.ndarray[N, K, 1]): Scores (confidence) of the keypoints. + """ + N, K, _ = regression_preds.shape + preds, maxvals = regression_preds, np.ones((N, K, 1), dtype=np.float32) + + preds = preds * img_size + + # Transform back to the image + for i in range(N): + preds[i] = transform_preds(preds[i], center[i], scale[i], img_size) + + return preds, maxvals + + +def keypoints_from_heatmaps(heatmaps, + center, + scale, + unbiased=False, + post_process='default', + kernel=11, + valid_radius_factor=0.0546875, + use_udp=False, + target_type='GaussianHeatmap'): + """Get final keypoint predictions from heatmaps and transform them back to + the image. + + Note: + - batch size: N + - num keypoints: K + - heatmap height: H + - heatmap width: W + + Args: + heatmaps (np.ndarray[N, K, H, W]): model predicted heatmaps. + center (np.ndarray[N, 2]): Center of the bounding box (x, y). + scale (np.ndarray[N, 2]): Scale of the bounding box + wrt height/width. + post_process (str/None): Choice of methods to post-process + heatmaps. Currently supported: None, 'default', 'unbiased', + 'megvii'. + unbiased (bool): Option to use unbiased decoding. Mutually + exclusive with megvii. + Note: this arg is deprecated and unbiased=True can be replaced + by post_process='unbiased' + Paper ref: Zhang et al. Distribution-Aware Coordinate + Representation for Human Pose Estimation (CVPR 2020). + kernel (int): Gaussian kernel size (K) for modulation, which should + match the heatmap gaussian sigma when training. + K=17 for sigma=3 and k=11 for sigma=2. + valid_radius_factor (float): The radius factor of the positive area + in classification heatmap for UDP. + use_udp (bool): Use unbiased data processing. + target_type (str): 'GaussianHeatmap' or 'CombinedTarget'. + GaussianHeatmap: Classification target with gaussian distribution. + CombinedTarget: The combination of classification target + (response map) and regression target (offset map). + Paper ref: Huang et al. The Devil is in the Details: Delving into + Unbiased Data Processing for Human Pose Estimation (CVPR 2020). + + Returns: + tuple: A tuple containing keypoint predictions and scores. + + - preds (np.ndarray[N, K, 2]): Predicted keypoint location in images. + - maxvals (np.ndarray[N, K, 1]): Scores (confidence) of the keypoints. + """ + # Avoid being affected + heatmaps = heatmaps.copy() + + # detect conflicts + if unbiased: + assert post_process not in [False, None, 'megvii'] + if post_process in ['megvii', 'unbiased']: + assert kernel > 0 + if use_udp: + assert not post_process == 'megvii' + + # normalize configs + if post_process is False: + warnings.warn( + 'post_process=False is deprecated, ' + 'please use post_process=None instead', DeprecationWarning) + post_process = None + elif post_process is True: + if unbiased is True: + warnings.warn( + 'post_process=True, unbiased=True is deprecated,' + " please use post_process='unbiased' instead", + DeprecationWarning) + post_process = 'unbiased' + else: + warnings.warn( + 'post_process=True, unbiased=False is deprecated, ' + "please use post_process='default' instead", + DeprecationWarning) + post_process = 'default' + elif post_process == 'default': + if unbiased is True: + warnings.warn( + 'unbiased=True is deprecated, please use ' + "post_process='unbiased' instead", DeprecationWarning) + post_process = 'unbiased' + + # start processing + if post_process == 'megvii': + heatmaps = _gaussian_blur(heatmaps, kernel=kernel) + + N, K, H, W = heatmaps.shape + if use_udp: + if target_type.lower() == 'GaussianHeatMap'.lower(): + preds, maxvals = _get_max_preds(heatmaps) + preds = post_dark_udp(preds, heatmaps, kernel=kernel) + elif target_type.lower() == 'CombinedTarget'.lower(): + for person_heatmaps in heatmaps: + for i, heatmap in enumerate(person_heatmaps): + kt = 2 * kernel + 1 if i % 3 == 0 else kernel + cv2.GaussianBlur(heatmap, (kt, kt), 0, heatmap) + # valid radius is in direct proportion to the height of heatmap. + valid_radius = valid_radius_factor * H + offset_x = heatmaps[:, 1::3, :].flatten() * valid_radius + offset_y = heatmaps[:, 2::3, :].flatten() * valid_radius + heatmaps = heatmaps[:, ::3, :] + preds, maxvals = _get_max_preds(heatmaps) + index = preds[..., 0] + preds[..., 1] * W + index += W * H * np.arange(0, N * K / 3) + index = index.astype(int).reshape(N, K // 3, 1) + preds += np.concatenate((offset_x[index], offset_y[index]), axis=2) + else: + raise ValueError('target_type should be either ' + "'GaussianHeatmap' or 'CombinedTarget'") + else: + preds, maxvals = _get_max_preds(heatmaps) + if post_process == 'unbiased': # alleviate biased coordinate + # apply Gaussian distribution modulation. + heatmaps = np.log( + np.maximum(_gaussian_blur(heatmaps, kernel), 1e-10)) + for n in range(N): + for k in range(K): + preds[n][k] = _taylor(heatmaps[n][k], preds[n][k]) + elif post_process is not None: + # add +/-0.25 shift to the predicted locations for higher acc. + for n in range(N): + for k in range(K): + heatmap = heatmaps[n][k] + px = int(preds[n][k][0]) + py = int(preds[n][k][1]) + if 1 < px < W - 1 and 1 < py < H - 1: + diff = np.array([ + heatmap[py][px + 1] - heatmap[py][px - 1], + heatmap[py + 1][px] - heatmap[py - 1][px] + ]) + preds[n][k] += np.sign(diff) * .25 + if post_process == 'megvii': + preds[n][k] += 0.5 + + # Transform back to the image + for i in range(N): + preds[i] = transform_preds( + preds[i], center[i], scale[i], [W, H], use_udp=use_udp) + + if post_process == 'megvii': + maxvals = maxvals / 255.0 + 0.5 + + return preds, maxvals + + +def keypoints_from_heatmaps3d(heatmaps, center, scale): + """Get final keypoint predictions from 3d heatmaps and transform them back + to the image. + + Note: + - batch size: N + - num keypoints: K + - heatmap depth size: D + - heatmap height: H + - heatmap width: W + + Args: + heatmaps (np.ndarray[N, K, D, H, W]): model predicted heatmaps. + center (np.ndarray[N, 2]): Center of the bounding box (x, y). + scale (np.ndarray[N, 2]): Scale of the bounding box + wrt height/width. + + Returns: + tuple: A tuple containing keypoint predictions and scores. + + - preds (np.ndarray[N, K, 3]): Predicted 3d keypoint location \ + in images. + - maxvals (np.ndarray[N, K, 1]): Scores (confidence) of the keypoints. + """ + N, K, D, H, W = heatmaps.shape + preds, maxvals = _get_max_preds_3d(heatmaps) + # Transform back to the image + for i in range(N): + preds[i, :, :2] = transform_preds(preds[i, :, :2], center[i], scale[i], + [W, H]) + return preds, maxvals + + +def multilabel_classification_accuracy(pred, gt, mask, thr=0.5): + """Get multi-label classification accuracy. + + Note: + - batch size: N + - label number: L + + Args: + pred (np.ndarray[N, L, 2]): model predicted labels. + gt (np.ndarray[N, L, 2]): ground-truth labels. + mask (np.ndarray[N, 1] or np.ndarray[N, L] ): reliability of + ground-truth labels. + + Returns: + float: multi-label classification accuracy. + """ + # we only compute accuracy on the samples with ground-truth of all labels. + valid = (mask > 0).min(axis=1) if mask.ndim == 2 else (mask > 0) + pred, gt = pred[valid], gt[valid] + + if pred.shape[0] == 0: + acc = 0.0 # when no sample is with gt labels, set acc to 0. + else: + # The classification of a sample is regarded as correct + # only if it's correct for all labels. + acc = (((pred - thr) * (gt - thr)) > 0).all(axis=1).mean() + return acc diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/train_valid_fn.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/train_valid_fn.py new file mode 100644 index 0000000000000000000000000000000000000000..a127c28e79278be6f9f3b2c3c59aa4d3dd13bb5b --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/train_valid_fn.py @@ -0,0 +1,162 @@ +import os.path as osp + +import torch +import torch.nn as nn + +from vit_models.losses import JointsMSELoss +from vit_models.optimizer import LayerDecayOptimizer + +from torch.nn.parallel import DataParallel, DistributedDataParallel +from torch.nn.utils import clip_grad_norm_ +from torch.optim import AdamW +from torch.optim.lr_scheduler import LambdaLR, MultiStepLR +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler +from torch.cuda.amp import autocast, GradScaler +from tqdm import tqdm +from time import time + +from vit_utils.dist_util import get_dist_info, init_dist +from vit_utils.logging import get_root_logger + +@torch.no_grad() +def valid_model(model: nn.Module, dataloaders: DataLoader, criterion: nn.Module, cfg: dict) -> None: + total_loss = 0 + total_metric = 0 + model.eval() + for dataloader in dataloaders: + for batch_idx, batch in enumerate(dataloader): + images, targets, target_weights, __ = batch + images = images.to('cuda') + targets = targets.to('cuda') + target_weights = target_weights.to('cuda') + + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + total_loss += loss.item() + + avg_loss = total_loss/(len(dataloader)*len(dataloaders)) + return avg_loss + +def train_model(model: nn.Module, datasets_train: Dataset, datasets_valid: Dataset, cfg: dict, distributed: bool, validate: bool, timestamp: str, meta: dict) -> None: + logger = get_root_logger() + + # Prepare data loaders + datasets_train = datasets_train if isinstance(datasets_train, (list, tuple)) else [datasets_train] + datasets_valid = datasets_valid if isinstance(datasets_valid, (list, tuple)) else [datasets_valid] + + if distributed: + samplers_train = [DistributedSampler(ds, num_replicas=len(cfg.gpu_ids), rank=torch.cuda.current_device(), shuffle=True, drop_last=False) for ds in datasets_train] + samplers_valid = [DistributedSampler(ds, num_replicas=len(cfg.gpu_ids), rank=torch.cuda.current_device(), shuffle=False, drop_last=False) for ds in datasets_valid] + else: + samplers_train = [None for ds in datasets_train] + samplers_valid = [None for ds in datasets_valid] + + dataloaders_train = [DataLoader(ds, batch_size=cfg.data['samples_per_gpu'], shuffle=True, sampler=sampler, num_workers=cfg.data['workers_per_gpu'], pin_memory=False) for ds, sampler in zip(datasets_train, samplers_train)] + dataloaders_valid = [DataLoader(ds, batch_size=cfg.data['samples_per_gpu'], shuffle=False, sampler=sampler, num_workers=cfg.data['workers_per_gpu'], pin_memory=False) for ds, sampler in zip(datasets_valid, samplers_valid)] + + # put model on gpus + if distributed: + find_unused_parameters = cfg.get('find_unused_parameters', False) + # Sets the `find_unused_parameters` parameter in + # torch.nn.parallel.DistributedDataParallel + + model = DistributedDataParallel( + module=model, + device_ids=[torch.cuda.current_device()], + broadcast_buffers=False, + find_unused_parameters=find_unused_parameters) + else: + model = DataParallel(model, device_ids=cfg.gpu_ids) + + # Loss function + criterion = JointsMSELoss(use_target_weight=cfg.model['keypoint_head']['loss_keypoint']['use_target_weight']) + + # Optimizer + optimizer = AdamW(model.parameters(), lr=cfg.optimizer['lr'], betas=cfg.optimizer['betas'], weight_decay=cfg.optimizer['weight_decay']) + + # Layer-wise learning rate decay + lr_mult = [cfg.optimizer['paramwise_cfg']['layer_decay_rate']] * cfg.optimizer['paramwise_cfg']['num_layers'] + layerwise_optimizer = LayerDecayOptimizer(optimizer, lr_mult) + + + # Learning rate scheduler (MultiStepLR) + milestones = cfg.lr_config['step'] + gamma = 0.1 + scheduler = MultiStepLR(optimizer, milestones, gamma) + + # Warm-up scheduler + num_warmup_steps = cfg.lr_config['warmup_iters'] # Number of warm-up steps + warmup_factor = cfg.lr_config['warmup_ratio'] # Initial learning rate = warmup_factor * learning_rate + warmup_scheduler = LambdaLR( + optimizer, + lr_lambda=lambda step: warmup_factor + (1.0 - warmup_factor) * step / num_warmup_steps + ) + + # AMP setting + if cfg.use_amp: + logger.info("Using Automatic Mixed Precision (AMP) training...") + # Create a GradScaler object for FP16 training + scaler = GradScaler() + + # Logging config + total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + logger.info(f'''\n + #========= [Train Configs] =========# + # - Num GPUs: {len(cfg.gpu_ids)} + # - Batch size (per gpu): {cfg.data['samples_per_gpu']} + # - LR: {cfg.optimizer['lr']: .6f} + # - Num params: {total_params:,d} + # - AMP: {cfg.use_amp} + #===================================# + ''') + + global_step = 0 + for dataloader in dataloaders_train: + for epoch in range(cfg.total_epochs): + model.train() + train_pbar = tqdm(dataloader) + total_loss = 0 + tic = time() + for batch_idx, batch in enumerate(train_pbar): + layerwise_optimizer.zero_grad() + + images, targets, target_weights, __ = batch + images = images.to('cuda') + targets = targets.to('cuda') + target_weights = target_weights.to('cuda') + + if cfg.use_amp: + with autocast(): + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + scaler.scale(loss).backward() + clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip']) + scaler.step(layerwise_optimizer) + scaler.update() + else: + outputs = model(images) + loss = criterion(outputs, targets, target_weights) + loss.backward() + clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip']) + layerwise_optimizer.step() + + if global_step < num_warmup_steps: + warmup_scheduler.step() + global_step += 1 + + total_loss += loss.item() + train_pbar.set_description(f"🏋️> Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Loss {loss.item():.4f} | LR {optimizer.param_groups[0]['lr']:.6f} | Step") + scheduler.step() + + avg_loss_train = total_loss/len(dataloader) + logger.info(f"[Summary-train] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (train) {avg_loss_train:.4f} --- {time()-tic:.5f} sec. elapsed") + ckpt_name = f"epoch{str(epoch).zfill(3)}.pth" + ckpt_path = osp.join(cfg.work_dir, ckpt_name) + torch.save(model.module.state_dict(), ckpt_path) + + # validation + if validate: + tic2 = time() + avg_loss_valid = valid_model(model, dataloaders_valid, criterion, cfg) + logger.info(f"[Summary-valid] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (valid) {avg_loss_valid:.4f} --- {time()-tic2:.5f} sec. elapsed") diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/transform.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..879c9e6052595e886d77201a9936c27e14724221 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/transform.py @@ -0,0 +1,96 @@ +import math +import cv2 +import munkres +import numpy as np +import torch + + +# solution proposed in https://github.com/pytorch/pytorch/issues/229#issuecomment-299424875 +def flip_tensor(tensor, dim=0): + """ + flip the tensor on the dimension dim + """ + inv_idx = torch.arange(tensor.shape[dim] - 1, -1, -1).to(tensor.device) + return tensor.index_select(dim, inv_idx) + + +# +# derived from https://github.com/leoxiaobin/deep-high-resolution-net.pytorch +def flip_back(output_flipped, matched_parts): + assert len(output_flipped.shape) == 4, 'output_flipped has to be [batch_size, num_joints, height, width]' + + output_flipped = flip_tensor(output_flipped, dim=-1) + + for pair in matched_parts: + tmp = output_flipped[:, pair[0]].clone() + output_flipped[:, pair[0]] = output_flipped[:, pair[1]] + output_flipped[:, pair[1]] = tmp + + return output_flipped + + +def fliplr_joints(joints, joints_vis, width, matched_parts): + # Flip horizontal + joints[:, 0] = width - joints[:, 0] - 1 + + # Change left-right parts + for pair in matched_parts: + joints[pair[0], :], joints[pair[1], :] = \ + joints[pair[1], :], joints[pair[0], :].copy() + joints_vis[pair[0], :], joints_vis[pair[1], :] = \ + joints_vis[pair[1], :], joints_vis[pair[0], :].copy() + + return joints * joints_vis, joints_vis + + +def get_affine_transform(center, scale, pixel_std, rot, output_size, shift=np.array([0, 0], dtype=np.float32), inv=0): + if not isinstance(scale, np.ndarray) and not isinstance(scale, list): + print(scale) + scale = np.array([scale, scale]) + + scale_tmp = scale * 1.0 * pixel_std # It was scale_tmp = scale * 200.0 + src_w = scale_tmp[0] + dst_w = output_size[0] + dst_h = output_size[1] + + rot_rad = np.pi * rot / 180 + src_dir = get_dir([0, src_w * -0.5], rot_rad) + dst_dir = np.array([0, dst_w * -0.5], np.float32) + + src = np.zeros((3, 2), dtype=np.float32) + dst = np.zeros((3, 2), dtype=np.float32) + src[0, :] = center + scale_tmp * shift + src[1, :] = center + src_dir + scale_tmp * shift + dst[0, :] = [dst_w * 0.5, dst_h * 0.5] + dst[1, :] = np.array([dst_w * 0.5, dst_h * 0.5]) + dst_dir + + src[2:, :] = get_3rd_point(src[0, :], src[1, :]) + dst[2:, :] = get_3rd_point(dst[0, :], dst[1, :]) + + if inv: + trans = cv2.getAffineTransform(np.float32(dst), np.float32(src)) + else: + trans = cv2.getAffineTransform(np.float32(src), np.float32(dst)) + + return trans + + +def affine_transform(pt, t): + new_pt = np.array([pt[0], pt[1], 1.]).T + new_pt = np.dot(t, new_pt) + return new_pt[:2] + + +def get_3rd_point(a, b): + direct = a - b + return b + np.array([-direct[1], direct[0]], dtype=np.float32) + + +def get_dir(src_point, rot_rad): + sn, cs = np.sin(rot_rad), np.cos(rot_rad) + + src_result = [0, 0] + src_result[0] = src_point[0] * cs - src_point[1] * sn + src_result[1] = src_point[0] * sn + src_point[1] * cs + + return src_result diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/util.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/util.py new file mode 100644 index 0000000000000000000000000000000000000000..0e6138a14184816acbcb7e29b1bb43ba4938fbbd --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/util.py @@ -0,0 +1,265 @@ +from collections import OrderedDict +from importlib import import_module +import os +import random +import re +import warnings +from typing import Union, Any + +import numpy as np +import torch +from torch import distributed as dist +import torch.nn as nn +from torch.nn.parallel import DataParallel, DistributedDataParallel + +from .dist_util import get_dist_info + +MODULE_WRAPPERS = [DataParallel, DistributedDataParallel] + + +MODEL_ABBR_MAP = { + 's': 'small', + 'b': 'base', + 'l': 'large', + 'h': 'huge' +} + + +def infer_dataset_by_path(model_path: str) -> Union[str, Any]: + model = os.path.basename(model_path) + p = r'-([a-zA-Z0-9_]+)\.[pth, onnx, engine]' + m = re.search(p, model) + if not m: + raise ValueError('Could not infer the dataset from ckpt name, specify it') + return m.group(1) + + +def dyn_model_import(dataset: str, model: str): + config_name = f'configs.ViTPose_{dataset}' + imp = import_module(config_name) + model = f'model_{MODEL_ABBR_MAP[model]}' + return getattr(imp, model) + + +def init_random_seed(seed=None, device='cuda'): + """Initialize random seed. + + If the seed is not set, the seed will be automatically randomized, + and then broadcast to all processes to prevent some potential bugs. + + Args: + seed (int, Optional): The seed. Default to None. + device (str): The device where the seed will be put on. + Default to 'cuda'. + + Returns: + int: Seed to be used. + """ + if seed is not None: + return seed + + # Make sure all ranks share the same random seed to prevent + # some potential bugs. Please refer to + # https://github.com/open-mmlab/mmdetection/issues/6339 + rank, world_size = get_dist_info() + seed = np.random.randint(2**31) + if world_size == 1: + return seed + + if rank == 0: + random_num = torch.tensor(seed, dtype=torch.int32, device=device) + else: + random_num = torch.tensor(0, dtype=torch.int32, device=device) + dist.broadcast(random_num, src=0) + return random_num.item() + + +def set_random_seed(seed: int, + deterministic: bool = False, + use_rank_shift: bool = False) -> None: + """Set random seed. + + Args: + seed (int): Seed to be used. + deterministic (bool): Whether to set the deterministic option for + CUDNN backend, i.e., set `torch.backends.cudnn.deterministic` + to True and `torch.backends.cudnn.benchmark` to False. + Default: False. + rank_shift (bool): Whether to add rank number to the random seed to + have different random seed in different threads. Default: False. + """ + if use_rank_shift: + rank, _ = get_dist_info() + seed += rank + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + if deterministic: + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + +def is_module_wrapper(module: nn.Module) -> bool: + """ Check if module wrrapper exists recursively """ + def is_module_in_wrapper(module, module_wrapper): + module_wrappers = tuple(module_wrapper.module_dict.values()) + if isinstance(module, module_wrappers): + return True + for child in module_wrapper.children.values(): + if is_module_in_wrapper(module, child): + return True + return is_module_in_wrapper(module, MODULE_WRAPPERS) + + +def load_state_dict(module, state_dict, strict=False, logger=None): + """Load state_dict to a module. + + This method is modified from :meth:`torch.nn.Module.load_state_dict`. + Default value for ``strict`` is set to ``False`` and the message for + param mismatch will be shown even if strict is False. + + Args: + module (Module): Module that receives the state_dict. + state_dict (OrderedDict): Weights. + strict (bool): whether to strictly enforce that the keys + in :attr:`state_dict` match the keys returned by this module's + :meth:`~torch.nn.Module.state_dict` function. Default: ``False``. + logger (:obj:`logging.Logger`, optional): Logger to log the error + message. If not specified, print function will be used. + """ + unexpected_keys = [] + all_missing_keys = [] + err_msg = [] + + metadata = getattr(state_dict, '_metadata', None) + state_dict = state_dict.copy() + if metadata is not None: + state_dict._metadata = metadata + + # use _load_from_state_dict to enable checkpoint version control + def load(module, prefix=''): + # recursively check parallel module in case that the model has a + # complicated structure, e.g., nn.Module(nn.Module(DDP)) + if is_module_wrapper(module): + module = module.module + local_metadata = {} if metadata is None else metadata.get( + prefix[:-1], {}) + module._load_from_state_dict(state_dict, prefix, local_metadata, True, + all_missing_keys, unexpected_keys, + err_msg) + for name, child in module._modules.items(): + if child is not None: + load(child, prefix + name + '.') + + load(module) + load = None # break load->load reference cycle + + # ignore "num_batches_tracked" of BN layers + missing_keys = [ + key for key in all_missing_keys if 'num_batches_tracked' not in key + ] + + if unexpected_keys: + err_msg.append('unexpected key in source ' + f'state_dict: {", ".join(unexpected_keys)}\n') + if missing_keys: + err_msg.append( + f'missing keys in source state_dict: {", ".join(missing_keys)}\n') + + rank, _ = get_dist_info() + if len(err_msg) > 0 and rank == 0: + err_msg.insert( + 0, 'The model and loaded state dict do not match exactly\n') + err_msg = '\n'.join(err_msg) + if strict: + raise RuntimeError(err_msg) + elif logger is not None: + logger.warning(err_msg) + else: + print(err_msg) + + +def load_checkpoint(model, + filename, + map_location='cpu', + strict=False, + logger=None): + """Load checkpoint from a file or URI. + + Args: + model (Module): Module to load checkpoint. + filename (str): Accept local filepath, URL, ``torchvision://xxx``, + ``open-mmlab://xxx``. + map_location (str): Same as :func:`torch.load`. + strict (bool): Whether to allow different params for the model and + checkpoint. + logger (:mod:`logging.Logger` or None): The logger for error message. + + Returns: + dict or OrderedDict: The loaded checkpoint. + """ + checkpoint = torch.load(filename, map_location=map_location, weights_only=True) + # OrderedDict is a subclass of dict + if not isinstance(checkpoint, dict): + raise RuntimeError( + f'No state_dict found in checkpoint file {filename}') + # get state_dict from checkpoint + if 'state_dict' in checkpoint: + state_dict_tmp = checkpoint['state_dict'] + else: + state_dict_tmp = checkpoint + + state_dict = OrderedDict() + # strip prefix of state_dict + for k, v in state_dict_tmp.items(): + if k.startswith('module.backbone.'): + state_dict[k[16:]] = v + elif k.startswith('module.'): + state_dict[k[7:]] = v + elif k.startswith('backbone.'): + state_dict[k[9:]] = v + else: + state_dict[k] = v + # load state_dict + load_state_dict(model, state_dict, strict, logger) + return checkpoint + + +def resize(input, + size=None, + scale_factor=None, + mode='nearest', + align_corners=None, + warning=True): + if warning: + if size is not None and align_corners: + input_h, input_w = int(input.shape[0]), int(input.shape[1]) + output_h, output_w = int(size[0]), int(size[1]) + if output_h > input_h or output_w > output_h: + if ((output_h > 1 and output_w > 1 and input_h > 1 + and input_w > 1) and (output_h - 1) % (input_h - 1) + and (output_w - 1) % (input_w - 1)): + warnings.warn( + f'When align_corners={align_corners}, ' + 'the output would more aligned if ' + f'input size {(input_h, input_w)} is `x+1` and ' + f'out size {(output_h, output_w)} is `nx+1`') + +def constant_init(module: nn.Module, val: float, bias: float = 0) -> None: + if hasattr(module, 'weight') and module.weight is not None: + nn.init.constant_(module.weight, val) + if hasattr(module, 'bias') and module.bias is not None: + nn.init.constant_(module.bias, bias) + + +def normal_init(module: nn.Module, + mean: float = 0, + std: float = 1, + bias: float = 0) -> None: + if hasattr(module, 'weight') and module.weight is not None: + nn.init.normal_(module.weight, mean, std) + if hasattr(module, 'bias') and module.bias is not None: + nn.init.constant_(module.bias, bias) diff --git a/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/visualization.py b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/visualization.py new file mode 100644 index 0000000000000000000000000000000000000000..64ec00a0edaa13b9c5965c506ec0e519b6268ae6 --- /dev/null +++ b/ViTPose/easy_ViTPose/easy_ViTPose/vit_utils/visualization.py @@ -0,0 +1,556 @@ +import cv2 +import matplotlib.pyplot as plt +import numpy as np +import torchvision +import ffmpeg + + +__all__ = ["joints_dict", "draw_points_and_skeleton"] + + +def joints_dict(): + joints = { + "coco_25": { + "keypoints": { + 0: "nose", + 1: "left_eye", + 2: "right_eye", + 3: "left_ear", + 4: "right_ear", + 5: "neck", + 6: "left_shoulder", + 7: "right_shoulder", + 8: "left_elbow", + 9: "right_elbow", + 10: "left_wrist", + 11: "right_wrist", + 12: "left_hip", + 13: "right_hip", + 14: "hip", + 15: "left_knee", + 16: "right_knee", + 17: "left_ankle", + 18: "right_ankle", + 19: "left_big_toe", + 20: "left_small_toe", + 21: "left_heel", + 22: "right_big_toe", + 23: "right_small_toe", + 24: "right_heel", + }, + "skeleton": [ + [17, 15], [15, 12], [18, 16], [16, 13], [12, 14], [13, 14], [5, 14], + [6, 5], [7, 5], [6, 8], [7, 9], [8, 10], [9, 11], [1, 2], [0, 1], [0, 2], + [1, 3], [2, 4], [17, 21], [18, 24], [19, 20], [22, 23], [19, 21], + [22, 24], [5, 0] + ] + }, + + "coco": { + "keypoints": { + 0: "nose", + 1: "left_eye", + 2: "right_eye", + 3: "left_ear", + 4: "right_ear", + 5: "left_shoulder", + 6: "right_shoulder", + 7: "left_elbow", + 8: "right_elbow", + 9: "left_wrist", + 10: "right_wrist", + 11: "left_hip", + 12: "right_hip", + 13: "left_knee", + 14: "right_knee", + 15: "left_ankle", + 16: "right_ankle" + }, + "skeleton": [ + [15, 13], [13, 11], [16, 14], [14, 12], [11, 12], [5, 11], [6, 12], + [5, 6], [5, 7], [6, 8], [7, 9], [8, 10], [1, 2], [0, 1], + [0, 2], [1, 3], [2, 4], [0, 5], [0, 6] + ] + }, + + "mpii": { + "keypoints": { + 0: "right_ankle", + 1: "right_knee", + 2: "right_hip", + 3: "left_hip", + 4: "left_knee", + 5: "left_ankle", + 6: "pelvis", + 7: "thorax", + 8: "upper_neck", + 9: "head top", + 10: "right_wrist", + 11: "right_elbow", + 12: "right_shoulder", + 13: "left_shoulder", + 14: "left_elbow", + 15: "left_wrist" + }, + "skeleton": [ + [5, 4], [4, 3], [0, 1], [1, 2], [3, 2], [3, 6], [2, 6], [6, 7], + [7, 8], [8, 9], [13, 7], [12, 7], [13, 14], [12, 11], [14, 15], + [11, 10], + ] + }, + + 'ap10k': { + 'keypoints': { + 0: 'L_Eye', + 1: 'R_Eye', + 2: 'Nose', + 3: 'Neck', + 4: 'Root of tail', + 5: 'L_Shoulder', + 6: 'L_Elbow', + 7: 'L_F_Paw', + 8: 'R_Shoulder', + 9: 'R_Elbow', + 10: 'R_F_Paw', + 11: 'L_Hip', + 12: 'L_Knee', + 13: 'L_B_Paw', + 14: 'R_Hip', + 15: 'R_Knee', + 16: 'R_B_Paw' + }, + 'skeleton': [ + [0, 1], [0, 2], [1, 2], [2, 3], [3, 4], [3, 5], [5, 6], [6, 7], + [3, 8], [8, 9], [9, 10], [4, 11], [11, 12], [12, 13], [4, 14], + [14, 15], [15, 16] + ] + }, + + 'apt36k': { + 'keypoints': { + 0: 'L_Eye', + 1: 'R_Eye', + 2: 'Nose', + 3: 'Neck', + 4: 'Root of tail', + 5: 'L_Shoulder', + 6: 'L_Elbow', + 7: 'L_F_Paw', + 8: 'R_Shoulder', + 9: 'R_Elbow', + 10: 'R_F_Paw', + 11: 'L_Hip', + 12: 'L_Knee', + 13: 'L_B_Paw', + 14: 'R_Hip', + 15: 'R_Knee', + 16: 'R_B_Paw' + }, + 'skeleton': [ + [0, 1], [0, 2], [1, 2], [2, 3], [3, 4], [3, 5], [5, 6], [6, 7], + [3, 8], [8, 9], [9, 10], [4, 11], [11, 12], [12, 13], [4, 14], + [14, 15], [15, 16] + ] + }, + + 'aic': { + 'keypoints': { + 0: 'right_shoulder', + 1: 'right_elbow', + 2: 'right_wrist', + 3: 'left_shoulder', + 4: 'left_elbow', + 5: 'left_wrist', + 6: 'right_hip', + 7: 'right_knee', + 8: 'right_ankle', + 9: 'left_hip', + 10: 'left_knee', + 11: 'left_ankle', + 12: 'head_top', + 13: 'neck' + }, + 'skeleton': [ + [2, 1], [1, 0], [0, 13], [13, 3], [3, 4], [4, 5], [8, 7], + [7, 6], [6, 9], [9, 10], [10, 11], [12, 13], [0, 6], [3, 9] + ] + }, + + 'wholebody': { + 'keypoints': { + 0: 'nose', + 1: 'left_eye', + 2: 'right_eye', + 3: 'left_ear', + 4: 'right_ear', + 5: 'left_shoulder', + 6: 'right_shoulder', + 7: 'left_elbow', + 8: 'right_elbow', + 9: 'left_wrist', + 10: 'right_wrist', + 11: 'left_hip', + 12: 'right_hip', + 13: 'left_knee', + 14: 'right_knee', + 15: 'left_ankle', + 16: 'right_ankle', + 17: 'left_big_toe', + 18: 'left_small_toe', + 19: 'left_heel', + 20: 'right_big_toe', + 21: 'right_small_toe', + 22: 'right_heel', + 23: 'face-0', + 24: 'face-1', + 25: 'face-2', + 26: 'face-3', + 27: 'face-4', + 28: 'face-5', + 29: 'face-6', + 30: 'face-7', + 31: 'face-8', + 32: 'face-9', + 33: 'face-10', + 34: 'face-11', + 35: 'face-12', + 36: 'face-13', + 37: 'face-14', + 38: 'face-15', + 39: 'face-16', + 40: 'face-17', + 41: 'face-18', + 42: 'face-19', + 43: 'face-20', + 44: 'face-21', + 45: 'face-22', + 46: 'face-23', + 47: 'face-24', + 48: 'face-25', + 49: 'face-26', + 50: 'face-27', + 51: 'face-28', + 52: 'face-29', + 53: 'face-30', + 54: 'face-31', + 55: 'face-32', + 56: 'face-33', + 57: 'face-34', + 58: 'face-35', + 59: 'face-36', + 60: 'face-37', + 61: 'face-38', + 62: 'face-39', + 63: 'face-40', + 64: 'face-41', + 65: 'face-42', + 66: 'face-43', + 67: 'face-44', + 68: 'face-45', + 69: 'face-46', + 70: 'face-47', + 71: 'face-48', + 72: 'face-49', + 73: 'face-50', + 74: 'face-51', + 75: 'face-52', + 76: 'face-53', + 77: 'face-54', + 78: 'face-55', + 79: 'face-56', + 80: 'face-57', + 81: 'face-58', + 82: 'face-59', + 83: 'face-60', + 84: 'face-61', + 85: 'face-62', + 86: 'face-63', + 87: 'face-64', + 88: 'face-65', + 89: 'face-66', + 90: 'face-67', + 91: 'left_hand_root', + 92: 'left_thumb1', + 93: 'left_thumb2', + 94: 'left_thumb3', + 95: 'left_thumb4', + 96: 'left_forefinger1', + 97: 'left_forefinger2', + 98: 'left_forefinger3', + 99: 'left_forefinger4', + 100: 'left_middle_finger1', + 101: 'left_middle_finger2', + 102: 'left_middle_finger3', + 103: 'left_middle_finger4', + 104: 'left_ring_finger1', + 105: 'left_ring_finger2', + 106: 'left_ring_finger3', + 107: 'left_ring_finger4', + 108: 'left_pinky_finger1', + 109: 'left_pinky_finger2', + 110: 'left_pinky_finger3', + 111: 'left_pinky_finger4', + 112: 'right_hand_root', + 113: 'right_thumb1', + 114: 'right_thumb2', + 115: 'right_thumb3', + 116: 'right_thumb4', + 117: 'right_forefinger1', + 118: 'right_forefinger2', + 119: 'right_forefinger3', + 120: 'right_forefinger4', + 121: 'right_middle_finger1', + 122: 'right_middle_finger2', + 123: 'right_middle_finger3', + 124: 'right_middle_finger4', + 125: 'right_ring_finger1', + 126: 'right_ring_finger2', + 127: 'right_ring_finger3', + 128: 'right_ring_finger4', + 129: 'right_pinky_finger1', + 130: 'right_pinky_finger2', + 131: 'right_pinky_finger3', + 132: 'right_pinky_finger4' + }, + 'skeleton': [ + [15, 13], [13, 11], [16, 14], [14, 12], [11, 12], [5, 11], [6, 12], + [5, 6], [5, 7], [6, 8], [7, 9], [8, 10], [1, 2], [0, 1], [0, 2], + [1, 3], [2, 4], [3, 5], [4, 6], [15, 17], [15, 18], [15, 19], + [16, 20], [16, 21], [16, 22], [91, 92], [92, 93], [93, 94], + [94, 95], [91, 96], [96, 97], [97, 98], [98, 99], [91, 100], + [100, 101], [101, 102], [102, 103], [91, 104], [104, 105], + [105, 106], [106, 107], [91, 108], [108, 109], [109, 110], + [110, 111], [112, 113], [113, 114], [114, 115], [115, 116], + [112, 117], [117, 118], [118, 119], [119, 120], [112, 121], + [121, 122], [122, 123], [123, 124], [112, 125], [125, 126], + [126, 127], [127, 128], [112, 129], [129, 130], [130, 131], + [131, 132] + ] + } + } + return joints + + +def draw_points(image, points, color_palette='tab20', palette_samples=16, confidence_threshold=0.5): + """ + Draws `points` on `image`. + + Args: + image: image in opencv format + points: list of points to be drawn. + Shape: (nof_points, 3) + Format: each point should contain (y, x, confidence) + color_palette: name of a matplotlib color palette + Default: 'tab20' + palette_samples: number of different colors sampled from the `color_palette` + Default: 16 + confidence_threshold: only points with a confidence higher than this threshold will be drawn. Range: [0, 1] + Default: 0.5 + + Returns: + A new image with overlaid points + + """ + try: + colors = np.round( + np.array(plt.get_cmap(color_palette).colors) * 255 + ).astype(np.uint8)[:, ::-1].tolist() + except AttributeError: # if palette has not pre-defined colors + colors = np.round( + np.array(plt.get_cmap(color_palette)(np.linspace(0, 1, palette_samples))) * 255 + ).astype(np.uint8)[:, -2::-1].tolist() + + circle_size = max(1, min(image.shape[:2]) // 150) # ToDo Shape it taking into account the size of the detection + # circle_size = max(2, int(np.sqrt(np.max(np.max(points, axis=0) - np.min(points, axis=0)) // 16))) + + for i, pt in enumerate(points): + if pt[2] > confidence_threshold: + image = cv2.circle(image, (int(pt[1]), int(pt[0])), circle_size, tuple(colors[i % len(colors)]), -1) + + return image + + +def draw_skeleton(image, points, skeleton, color_palette='Set2', palette_samples=8, person_index=0, + confidence_threshold=0.5): + """ + Draws a `skeleton` on `image`. + + Args: + image: image in opencv format + points: list of points to be drawn. + Shape: (nof_points, 3) + Format: each point should contain (y, x, confidence) + skeleton: list of joints to be drawn + Shape: (nof_joints, 2) + Format: each joint should contain (point_a, point_b) where `point_a` and `point_b` are an index in `points` + color_palette: name of a matplotlib color palette + Default: 'Set2' + palette_samples: number of different colors sampled from the `color_palette` + Default: 8 + person_index: index of the person in `image` + Default: 0 + confidence_threshold: only points with a confidence higher than this threshold will be drawn. Range: [0, 1] + Default: 0.5 + + Returns: + A new image with overlaid joints + + """ + try: + colors = np.round( + np.array(plt.get_cmap(color_palette).colors) * 255 + ).astype(np.uint8)[:, ::-1].tolist() + except AttributeError: # if palette has not pre-defined colors + colors = np.round( + np.array(plt.get_cmap(color_palette)(np.linspace(0, 1, palette_samples))) * 255 + ).astype(np.uint8)[:, -2::-1].tolist() + + for i, joint in enumerate(skeleton): + pt1, pt2 = points[joint] + if pt1[2] > confidence_threshold and pt2[2] > confidence_threshold: + image = cv2.line( + image, (int(pt1[1]), int(pt1[0])), (int(pt2[1]), int(pt2[0])), + tuple(colors[person_index % len(colors)]), 2 + ) + + return image + + +def draw_points_and_skeleton(image, points, skeleton, points_color_palette='tab20', points_palette_samples=16, + skeleton_color_palette='Set2', skeleton_palette_samples=8, person_index=0, + confidence_threshold=0.5): + """ + Draws `points` and `skeleton` on `image`. + + Args: + image: image in opencv format + points: list of points to be drawn. + Shape: (nof_points, 3) + Format: each point should contain (y, x, confidence) + skeleton: list of joints to be drawn + Shape: (nof_joints, 2) + Format: each joint should contain (point_a, point_b) where `point_a` and `point_b` are an index in `points` + points_color_palette: name of a matplotlib color palette + Default: 'tab20' + points_palette_samples: number of different colors sampled from the `color_palette` + Default: 16 + skeleton_color_palette: name of a matplotlib color palette + Default: 'Set2' + skeleton_palette_samples: number of different colors sampled from the `color_palette` + Default: 8 + person_index: index of the person in `image` + Default: 0 + confidence_threshold: only points with a confidence higher than this threshold will be drawn. Range: [0, 1] + Default: 0.5 + + Returns: + A new image with overlaid joints + + """ + image = draw_skeleton(image, points, skeleton, color_palette=skeleton_color_palette, + palette_samples=skeleton_palette_samples, person_index=person_index, + confidence_threshold=confidence_threshold) + image = draw_points(image, points, color_palette=points_color_palette, palette_samples=points_palette_samples, + confidence_threshold=confidence_threshold) + return image + + +def save_images(images, target, joint_target, output, joint_output, joint_visibility, summary_writer=None, step=0, + prefix=''): + """ + Creates a grid of images with gt joints and a grid with predicted joints. + This is a basic function for debugging purposes only. + + If summary_writer is not None, the grid will be written in that SummaryWriter with name "{prefix}_images" and + "{prefix}_predictions". + + Args: + images (torch.Tensor): a tensor of images with shape (batch x channels x height x width). + target (torch.Tensor): a tensor of gt heatmaps with shape (batch x channels x height x width). + joint_target (torch.Tensor): a tensor of gt joints with shape (batch x joints x 2). + output (torch.Tensor): a tensor of predicted heatmaps with shape (batch x channels x height x width). + joint_output (torch.Tensor): a tensor of predicted joints with shape (batch x joints x 2). + joint_visibility (torch.Tensor): a tensor of joint visibility with shape (batch x joints). + summary_writer (tb.SummaryWriter): a SummaryWriter where write the grids. + Default: None + step (int): summary_writer step. + Default: 0 + prefix (str): summary_writer name prefix. + Default: "" + + Returns: + A pair of images which are built from torchvision.utils.make_grid + """ + # Input images with gt + images_ok = images.detach().clone() + images_ok[:, 0].mul_(0.229).add_(0.485) + images_ok[:, 1].mul_(0.224).add_(0.456) + images_ok[:, 2].mul_(0.225).add_(0.406) + for i in range(images.shape[0]): + joints = joint_target[i] * 4. + joints_vis = joint_visibility[i] + + for joint, joint_vis in zip(joints, joints_vis): + if joint_vis[0]: + a = int(joint[1].item()) + b = int(joint[0].item()) + # images_ok[i][:, a-1:a+1, b-1:b+1] = torch.tensor([1, 0, 0]) + images_ok[i][0, a - 1:a + 1, b - 1:b + 1] = 1 + images_ok[i][1:, a - 1:a + 1, b - 1:b + 1] = 0 + grid_gt = torchvision.utils.make_grid(images_ok, nrow=int(images_ok.shape[0] ** 0.5), padding=2, normalize=False) + if summary_writer is not None: + summary_writer.add_image(prefix + 'images', grid_gt, global_step=step) + + # Input images with prediction + images_ok = images.detach().clone() + images_ok[:, 0].mul_(0.229).add_(0.485) + images_ok[:, 1].mul_(0.224).add_(0.456) + images_ok[:, 2].mul_(0.225).add_(0.406) + for i in range(images.shape[0]): + joints = joint_output[i] * 4. + joints_vis = joint_visibility[i] + + for joint, joint_vis in zip(joints, joints_vis): + if joint_vis[0]: + a = int(joint[1].item()) + b = int(joint[0].item()) + # images_ok[i][:, a-1:a+1, b-1:b+1] = torch.tensor([1, 0, 0]) + images_ok[i][0, a - 1:a + 1, b - 1:b + 1] = 1 + images_ok[i][1:, a - 1:a + 1, b - 1:b + 1] = 0 + grid_pred = torchvision.utils.make_grid(images_ok, nrow=int(images_ok.shape[0] ** 0.5), padding=2, normalize=False) + if summary_writer is not None: + summary_writer.add_image(prefix + 'predictions', grid_pred, global_step=step) + + # Heatmaps + # ToDo + # for h in range(0,17): + # heatmap = torchvision.utils.make_grid(output[h].detach(), nrow=int(np.sqrt(output.shape[0])), + # padding=2, normalize=True, range=(0, 1)) + # summary_writer.add_image('train_heatmap_%d' % h, heatmap, global_step=step + epoch*len_dl_train) + + return grid_gt, grid_pred + + +def check_video_rotation(filename): + # thanks to + # https://stackoverflow.com/questions/53097092/frame-from-video-is-upside-down-after-extracting/55747773#55747773 + + # this returns meta-data of the video file in form of a dictionary + meta_dict = ffmpeg.probe(filename) + + # from the dictionary, meta_dict['streams'][0]['tags']['rotate'] is the key + # we are looking for + rotation_code = None + try: + if int(meta_dict['streams'][0]['tags']['rotate']) == 90: + rotation_code = cv2.ROTATE_90_CLOCKWISE + elif int(meta_dict['streams'][0]['tags']['rotate']) == 180: + rotation_code = cv2.ROTATE_180 + elif int(meta_dict['streams'][0]['tags']['rotate']) == 270: + rotation_code = cv2.ROTATE_90_COUNTERCLOCKWISE + else: + raise ValueError + except KeyError: + pass + + return rotation_code diff --git a/ViTPose/easy_ViTPose/evaluation_on_coco.py b/ViTPose/easy_ViTPose/evaluation_on_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..7bb2e0a722ecab7967dd931321d19164fcea9b3f --- /dev/null +++ b/ViTPose/easy_ViTPose/evaluation_on_coco.py @@ -0,0 +1,92 @@ +# Reference: https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb + +import cv2 +from easy_ViTPose.inference import VitInference +from pathlib import Path +import os +from tqdm.auto import tqdm + +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval +from statistics import mean +import json +import argparse + +def parse_arguments(): + + parser = argparse.ArgumentParser(description='Argument Parser for infer') + parser.add_argument('--model_path', type=str, + help='Path to the ViT Pose model') + parser.add_argument('--model-name', type=str, choices=['s', 'b', 'l', 'h'], + help='[s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H]') + parser.add_argument('--yolo_path', type=str, + help='Path to the YOLOv8 model') + parser.add_argument('--img_folder_path', type=str, + help='Path to the folder containing images') + parser.add_argument('--annFile', type=str, + help='Path to the COCO annotations file') + return parser.parse_args() + + +def evaluation_on_coco(model_path, model_name, yolo_path, img_folder_path, annFile): + # get image IDs of images in val set + # Opening JSON file + f = open(annFile) + gt_annotations = json.load(f) + f.close() + + image_ids = set() + for ann in gt_annotations['images']: + image_ids.add(ann['id']) + + + model = VitInference(model_path, yolo_path, model_name = model_name, yolo_size=640, is_video=False, device=None) + results_list = [] + + for image_id in tqdm(image_ids): + # run inference here + img_path = os.path.join(img_folder_path, str(image_id).zfill(12) + '.jpg') + img = cv2.imread(img_path) + + + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + frame_keypoints = model.inference(img) + for key in frame_keypoints: + results_element = {} + results_element['image_id'] = image_id + results_element['category_id'] = 1 + results_element['score'] = model._scores_bbox[key] + results_element['bbox'] = [] + keypoints = [] + for k in frame_keypoints[key]: + keypoints.append(float(round(k[1], 0))) + keypoints.append(float(round(k[0], 0))) + keypoints.append(0) + results_element['keypoints'] = keypoints + results_list.append(results_element) + + + # Define the file path where you want to save the JSON file + file_path = "results.json" + # Save the list of dictionaries to a JSON file + with open(file_path, "w") as json_file: + json.dump(results_list, json_file, indent=4) + + + #initialize COCO ground truth api + annType = 'keypoints' + cocoGt=COCO(annFile) + #initialize COCO detections api + resFile="results.json" + cocoDt=cocoGt.loadRes(resFile) + # running evaluation + cocoEval = COCOeval(cocoGt,cocoDt,annType) + cocoEval.params.imgIds = [int(i) for i in image_ids] + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + + +if __name__ == '__main__': + args = parse_arguments() + evaluation_on_coco(args.model_path, args.model_name, args.yolo_path, args.img_folder_path, args.annFile) \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/export.py b/ViTPose/easy_ViTPose/export.py new file mode 100644 index 0000000000000000000000000000000000000000..8a6020364b0cbaf68c3fe9d525b063777197d07c --- /dev/null +++ b/ViTPose/easy_ViTPose/export.py @@ -0,0 +1,97 @@ +import os +import torch +import argparse + +from easy_ViTPose.vit_models.model import ViTPose +from easy_ViTPose.vit_utils.util import infer_dataset_by_path, dyn_model_import + + +parser = argparse.ArgumentParser() +parser.add_argument('--model-ckpt', type=str, required=True, + help='The torch model that shall be used for conversion') +parser.add_argument('--model-name', type=str, required=True, choices=['s', 'b', 'l', 'h'], + help='[s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H]') +parser.add_argument('--output', type=str, default='ckpts/', + help='File (without extension) or dir path for checkpoint output') +parser.add_argument('--dataset', type=str, required=False, default=None, + help='Name of the dataset. If None it"s extracted from the file name. \ + ["coco", "coco_25", "wholebody", "mpii", "ap10k", "apt36k", "aic"]') +args = parser.parse_args() + + +# Get dataset and model_cfg +dataset = args.dataset +if dataset is None: + dataset = infer_dataset_by_path(args.model_ckpt) +assert dataset in ['mpii', 'coco', 'coco_25', 'wholebody', 'aic', 'ap10k', 'apt36k'], \ + 'The specified dataset is not valid' +model_cfg = dyn_model_import(dataset, args.model_name) + +# Convert to onnx and save +print('>>> Converting to ONNX') +CKPT_PATH = args.model_ckpt +C, H, W = (3, 256, 192) + +model = ViTPose(model_cfg) + +ckpt = torch.load(CKPT_PATH, map_location='cpu', weights_only=True) +if 'state_dict' in ckpt: + ckpt = ckpt['state_dict'] + +model.load_state_dict(ckpt) +model.eval() + +input_names = ["input_0"] +output_names = ["output_0"] + +device = next(model.parameters()).device +inputs = torch.randn(1, C, H, W).to(device) + +dynamic_axes = {'input_0': {0: 'batch_size'}, + 'output_0': {0: 'batch_size'}} + +out_name = os.path.basename(args.model_ckpt).replace('.pth', '.onnx') +if not os.path.isdir(args.output): + out_name = os.path.basename(args.output) +output_onnx = os.path.join(os.path.dirname(args.output), out_name) + +torch_out = torch.onnx.export(model, inputs, output_onnx, export_params=True, verbose=False, + input_names=input_names, output_names=output_names, + dynamic_axes=dynamic_axes) +print(f">>> Saved at: {os.path.abspath(output_onnx)}") +print('=' * 80) +print() + +try: + import torch_tensorrt +except ModuleNotFoundError: + print('>>> TRT module not found, skipping') + import sys + sys.exit() + +# From yolo convert script, onnx -> trt +print('>>> Converting to TRT') +trt_ts_module = torch_tensorrt.compile(model, + # If the inputs to the module are plain Tensors, specify them via the `inputs` argument: + inputs = [ + torch_tensorrt.Input( # Specify input object with shape and dtype + shape=[1, C, H, W], + dtype=torch.float32 + ) + ], + + # TODO: ADD Datatype for inference. Allowed options torch.(float|half|int8|int32|bool) + enabled_precisions = {torch.float32}, # half Run with FP16 + workspace_size = 1 << 28 +) + +# Export +output_trt = output_onnx.replace('.onnx', '.engine') + +input_names = ["input_0"] +output_names = ["output_0"] + +device = next(model.parameters()).device +torch.jit.save(trt_ts_module, output_trt) # save the TRT embedded Torchscript + +print(f">>> Saved at: {os.path.abspath(output_trt)}") diff --git a/ViTPose/easy_ViTPose/inference.py b/ViTPose/easy_ViTPose/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..7edfb072fc1f7543ab629a1d9684c59fa9c36fac --- /dev/null +++ b/ViTPose/easy_ViTPose/inference.py @@ -0,0 +1,188 @@ +import argparse +import json +import os +import time + +from PIL import Image +import cv2 +import numpy as np +import torch +import tqdm + +from easy_ViTPose.vit_utils.inference import NumpyEncoder, VideoReader +from easy_ViTPose.inference import VitInference +from easy_ViTPose.vit_utils.visualization import joints_dict + +try: + import onnxruntime # noqa: F401 + has_onnx = True +except ModuleNotFoundError: + has_onnx = False + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument('--input', type=str, required=True, + help='path to image / video or webcam ID (=cv2)') + parser.add_argument('--output-path', type=str, default='', + help='output path, if the path provided is a directory ' + 'output files are "input_name +_result{extension}".') + parser.add_argument('--model', type=str, required=True, + help='checkpoint path of the model') + parser.add_argument('--yolo', type=str, required=False, default=None, + help='checkpoint path of the yolo model') + parser.add_argument('--dataset', type=str, required=False, default=None, + help='Name of the dataset. If None it"s extracted from the file name. \ + ["coco", "coco_25", "wholebody", "mpii", "ap10k", "apt36k", "aic"]') + parser.add_argument('--det-class', type=str, required=False, default=None, + help='["human", "cat", "dog", "horse", "sheep", \ + "cow", "elephant", "bear", "zebra", "giraffe", "animals"]') + parser.add_argument('--model-name', type=str, required=False, choices=['s', 'b', 'l', 'h'], + help='[s: ViT-S, b: ViT-B, l: ViT-L, h: ViT-H]') + parser.add_argument('--yolo-size', type=int, required=False, default=320, + help='YOLOv8 image size during inference') + parser.add_argument('--conf-threshold', type=float, required=False, default=0.5, + help='Minimum confidence for keypoints to be drawn. [0, 1] range') + parser.add_argument('--rotate', type=int, choices=[0, 90, 180, 270], + required=False, default=0, + help='Rotate the image of [90, 180, 270] degress counterclockwise') + parser.add_argument('--yolo-step', type=int, + required=False, default=1, + help='The tracker can be used to predict the bboxes instead of yolo for performance, ' + 'this flag specifies how often yolo is applied (e.g. 1 applies yolo every frame). ' + 'This does not have any effect when is_video is False') + parser.add_argument('--single-pose', default=False, action='store_true', + help='Do not use SORT tracker because single pose is expected in the video') + parser.add_argument('--show', default=False, action='store_true', + help='preview result during inference') + parser.add_argument('--show-yolo', default=False, action='store_true', + help='draw yolo results') + parser.add_argument('--show-raw-yolo', default=False, action='store_true', + help='draw yolo result before that SORT is applied for tracking' + ' (only valid during video inference)') + parser.add_argument('--save-img', default=False, action='store_true', + help='save image results') + parser.add_argument('--save-json', default=False, action='store_true', + help='save json results') + args = parser.parse_args() + + use_mps = hasattr(torch.backends, 'mps') and torch.backends.mps.is_available() + use_cuda = torch.cuda.is_available() + + # Load Yolo + yolo = args.yolo + if yolo is None: + yolo = 'easy_ViTPose/' + ('yolov8s' + ('.onnx' if has_onnx and not (use_mps or use_cuda) else '.pt')) + input_path = args.input + + # Load the image / video reader + try: # Check if is webcam + int(input_path) + is_video = True + except ValueError: + assert os.path.isfile(input_path), 'The input file does not exist' + is_video = input_path[input_path.rfind('.') + 1:].lower() in ['mp4', 'mov'] + + ext = '.mp4' if is_video else '.png' + assert not (args.save_img or args.save_json) or args.output_path, \ + 'Specify an output path if using save-img or save-json flags' + output_path = args.output_path + if output_path: + if os.path.isdir(output_path): + og_ext = input_path[input_path.rfind('.'):] + save_name_img = os.path.basename(input_path).replace(og_ext, f"_result{ext}") + save_name_json = os.path.basename(input_path).replace(og_ext, "_result.json") + output_path_img = os.path.join(output_path, save_name_img) + output_path_json = os.path.join(output_path, save_name_json) + else: + output_path_img = output_path + f'{ext}' + output_path_json = output_path + '.json' + + wait = 0 + total_frames = 1 + if is_video: + reader = VideoReader(input_path, args.rotate) + cap = cv2.VideoCapture(input_path) # type: ignore + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + cap.release() + wait = 15 + if args.save_img: + cap = cv2.VideoCapture(input_path) # type: ignore + fps = cap.get(cv2.CAP_PROP_FPS) + ret, frame = cap.read() + cap.release() + assert ret + assert fps > 0 + output_size = frame.shape[:2][::-1] + + # Check if we have X264 otherwise use default MJPG + try: + temp_video = cv2.VideoWriter('/tmp/checkcodec.mp4', + cv2.VideoWriter_fourcc(*'h264'), 30, (32, 32)) + opened = temp_video.isOpened() + except Exception: + opened = False + codec = 'h264' if opened else 'MJPG' + out_writer = cv2.VideoWriter(output_path_img, + cv2.VideoWriter_fourcc(*codec), # More efficient codec + fps, output_size) # type: ignore + else: + reader = [np.array(Image.open(input_path).rotate(args.rotate))] # type: ignore + + # Initialize model + model = VitInference(args.model, yolo, args.model_name, + args.det_class, args.dataset, + args.yolo_size, is_video=is_video, + single_pose=args.single_pose, + yolo_step=args.yolo_step) # type: ignore + print(f">>> Model loaded: {args.model}") + + print(f'>>> Running inference on {input_path}') + keypoints = [] + fps = [] + tot_time = 0. + for (ith, img) in tqdm.tqdm(enumerate(reader), total=total_frames): + t0 = time.time() + + # Run inference + frame_keypoints = model.inference(img) + keypoints.append(frame_keypoints) + + delta = time.time() - t0 + tot_time += delta + fps.append(delta) + + # Draw the poses and save the output img + if args.show or args.save_img: + # Draw result and transform to BGR + img = model.draw(args.show_yolo, args.show_raw_yolo, args.conf_threshold)[..., ::-1] + + if args.save_img: + # TODO: If exists add (1), (2), ... + if is_video: + out_writer.write(img) + else: + print('>>> Saving output image') + cv2.imwrite(output_path_img, img) + + if args.show: + cv2.imshow('preview', img) + cv2.waitKey(wait) + + if is_video: + tot_poses = sum(len(k) for k in keypoints) + print(f'>>> Mean inference FPS: {1 / np.mean(fps):.2f}') + print(f'>>> Total poses predicted: {tot_poses} mean per frame: ' + f'{(tot_poses / (ith + 1)):.2f}') + print(f'>>> Mean FPS per pose: {(tot_poses / tot_time):.2f}') + + if args.save_json: + print('>>> Saving output json') + with open(output_path_json, 'w') as f: + out = {'keypoints': keypoints, + 'skeleton': joints_dict()[model.dataset]['keypoints']} + json.dump(out, f, cls=NumpyEncoder) + + if is_video and args.save_img: + out_writer.release() + cv2.destroyAllWindows() diff --git a/ViTPose/easy_ViTPose/model_split.py b/ViTPose/easy_ViTPose/model_split.py new file mode 100644 index 0000000000000000000000000000000000000000..4a382c697787c9a92b432a236d9a8802a218c143 --- /dev/null +++ b/ViTPose/easy_ViTPose/model_split.py @@ -0,0 +1,119 @@ +import torch +import os +import argparse +import copy + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--source', type=str, required=True) + parser.add_argument('--prefix', type=str, required=True) + parser.add_argument('--target', type=str, default=None) + args = parser.parse_args() + return args + +def main(): + + args = parse_args() + + if args.target is None: + args.target = '/'.join(args.source.split('/')[:-1]) + + ckpt = torch.load(args.source, map_location='cpu', weights_only=True) + + experts = dict() + + new_ckpt = copy.deepcopy(ckpt) + + state_dict = new_ckpt['state_dict'] + + for key, value in state_dict.items(): + if 'mlp.experts' in key: + experts[key] = value + + keys = ckpt['state_dict'].keys() + + weight_names = ['keypoint_head.deconv_layers.0.weight', + 'keypoint_head.deconv_layers.1.weight', + 'keypoint_head.deconv_layers.1.bias', + 'keypoint_head.deconv_layers.1.running_mean', + 'keypoint_head.deconv_layers.1.running_var', + 'keypoint_head.deconv_layers.1.num_batches_tracked', + 'keypoint_head.deconv_layers.3.weight', + 'keypoint_head.deconv_layers.4.weight', + 'keypoint_head.deconv_layers.4.bias', + 'keypoint_head.deconv_layers.4.running_mean', + 'keypoint_head.deconv_layers.4.running_var', + 'keypoint_head.deconv_layers.4.num_batches_tracked', + 'keypoint_head.final_layer.weight', + 'keypoint_head.final_layer.bias'] + + target_expert = 0 + new_ckpt = copy.deepcopy(ckpt) + + for key in keys: + if 'mlp.fc2' in key: + value = new_ckpt['state_dict'][key] + value = torch.cat([value, experts[key.replace('fc2.', f'experts.{target_expert}.')]], dim=0) + new_ckpt['state_dict'][key] = value + + # remove unnecessary part in the state dict + for j in range(5): + # remove associate part + for tensor_name in weight_names: + new_ckpt['state_dict'].pop(tensor_name.replace('keypoint_head', + f'associate_keypoint_heads.{j}')) + # remove expert part + keys = new_ckpt['state_dict'].keys() + for key in list(keys): + if 'expert' in key: + new_ckpt['state_dict'].pop(key) + + torch.save(new_ckpt, os.path.join(args.target, args.prefix + 'coco.pth')) + + names = ['aic', 'mpii', 'ap10k', 'apt36k','wholebody'] + num_keypoints = [14, 16, 17, 17, 133] + exist_range = True + + for i in range(5): + + new_ckpt = copy.deepcopy(ckpt) + + target_expert = i + 1 + + for key in keys: + if 'mlp.fc2' in key: + expert_key = key.replace('fc2.', f'experts.{target_expert}.') + if expert_key in experts: + value = new_ckpt['state_dict'][key] + value = torch.cat([value, experts[expert_key]], dim=0) + else: + exist_range = False + + new_ckpt['state_dict'][key] = value + + if not exist_range: + break + + for tensor_name in weight_names: + new_ckpt['state_dict'][tensor_name] = new_ckpt['state_dict'][tensor_name.replace('keypoint_head', + f'associate_keypoint_heads.{i}')] + + for tensor_name in ['keypoint_head.final_layer.weight', 'keypoint_head.final_layer.bias']: + new_ckpt['state_dict'][tensor_name] = new_ckpt['state_dict'][tensor_name][:num_keypoints[i]] + + # remove unnecessary part in the state dict + for j in range(5): + # remove associate part + for tensor_name in weight_names: + new_ckpt['state_dict'].pop(tensor_name.replace('keypoint_head', + f'associate_keypoint_heads.{j}')) + # remove expert part + keys = new_ckpt['state_dict'].keys() + for key in list(keys): + if 'expert' in key: + new_ckpt['state_dict'].pop(key) + + torch.save(new_ckpt, os.path.join(args.target, f'{args.prefix}{names[i]}.pth')) + +if __name__ == '__main__': + main() diff --git a/ViTPose/easy_ViTPose/models/.gitignore b/ViTPose/easy_ViTPose/models/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..08b80ec5eb3c41a4055c5879683dd7be20a68a39 --- /dev/null +++ b/ViTPose/easy_ViTPose/models/.gitignore @@ -0,0 +1,5 @@ +# Ignore everything in this directory +* +# Except this file and the download script +!.gitignore +!download.sh diff --git a/ViTPose/easy_ViTPose/models/download.sh b/ViTPose/easy_ViTPose/models/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..6cb2c64324826292d9ea24b82a429d12d7705656 --- /dev/null +++ b/ViTPose/easy_ViTPose/models/download.sh @@ -0,0 +1,4 @@ +#! /usr/bin/env bash +DIR=$(dirname "$0") +wget -O $DIR/vitpose-l-ap10k.onnx https://huggingface.co/JunkyByte/easy_ViTPose/resolve/main/onnx/ap10k/vitpose-l-ap10k.onnx +wget -O $DIR/yolov8l.pt https://huggingface.co/Ultralytics/YOLOv8/resolve/main/yolov8l.pt diff --git a/ViTPose/easy_ViTPose/requirements.txt b/ViTPose/easy_ViTPose/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..56b923420b88956bf3f77d7ae700d0af987dadd2 --- /dev/null +++ b/ViTPose/easy_ViTPose/requirements.txt @@ -0,0 +1,50 @@ +certifi==2023.7.22 +charset-normalizer==3.2.0 +coloredlogs==15.0.1 +contourpy==1.1.1 +cycler==0.11.0 +ffmpeg==1.4 +filelock==3.12.4 +filterpy==1.4.5 +flatbuffers==23.5.26 +fonttools==4.43.0 +humanfriendly==10.0 +idna==3.4 +imageio==2.31.3 +importlib-resources==6.1.0 +jinja2>=3.1.3 +kiwisolver==1.4.5 +lazy_loader==0.3 +MarkupSafe==2.1.3 +matplotlib==3.8.0 +mpmath==1.3.0 +networkx==3.1 +numpy==1.26.0 +onnx==1.14.1 +onnxruntime==1.16.0 +opencv-python==4.8.0.76 +packaging==23.1 +pandas==2.1.1 +Pillow>=10.2.0 +protobuf==4.24.3 +psutil==5.9.5 +py-cpuinfo==9.0.0 +pycocotools==2.0.8 +pyparsing==3.1.1 +python-dateutil==2.8.2 +pytz==2023.3.post1 +PyWavelets==1.4.1 +PyYAML==6.0.1 +requests==2.31.0 +scikit-image==0.21.0 +scipy==1.11.2 +seaborn==0.12.2 +six==1.16.0 +sympy==1.12 +tifffile==2023.9.18 +tqdm==4.66.1 +typing_extensions==4.8.0 +tzdata==2023.3 +ultralytics==8.2.48 +urllib3>=2.0.7 +zipp==3.17.0 diff --git a/ViTPose/easy_ViTPose/requirements_gpu.txt b/ViTPose/easy_ViTPose/requirements_gpu.txt new file mode 100644 index 0000000000000000000000000000000000000000..fa47af223c3eaeb1abe01177ed6c6912001eb425 --- /dev/null +++ b/ViTPose/easy_ViTPose/requirements_gpu.txt @@ -0,0 +1,3 @@ +onnxruntime-gpu>=1.13.0 +tensorrt>=8.5.1.7 +torch-tensorrt>=1.4.0 \ No newline at end of file diff --git a/ViTPose/easy_ViTPose/runs/train/001/20241223_145957.log b/ViTPose/easy_ViTPose/runs/train/001/20241223_145957.log new file mode 100644 index 0000000000000000000000000000000000000000..e1c6ee48dae97674ac9155ebd465d92e3ae6ebb7 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/001/20241223_145957.log @@ -0,0 +1,2 @@ +2024-12-23 14:59:57,403 - vit_utils - INFO - Distributed training: False +2024-12-23 14:59:57,403 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/002/20241223_150309.log b/ViTPose/easy_ViTPose/runs/train/002/20241223_150309.log new file mode 100644 index 0000000000000000000000000000000000000000..9f828adfeb33d1d696dfce999d64351eb0e17509 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/002/20241223_150309.log @@ -0,0 +1,2 @@ +2024-12-23 15:03:09,896 - vit_utils - INFO - Distributed training: False +2024-12-23 15:03:09,911 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/003/20241223_150351.log b/ViTPose/easy_ViTPose/runs/train/003/20241223_150351.log new file mode 100644 index 0000000000000000000000000000000000000000..4b272bbc3689984665785654fafff65e0d0876ff --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/003/20241223_150351.log @@ -0,0 +1,2 @@ +2024-12-23 15:03:51,251 - vit_utils - INFO - Distributed training: False +2024-12-23 15:03:51,251 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/004/20241223_151223.log b/ViTPose/easy_ViTPose/runs/train/004/20241223_151223.log new file mode 100644 index 0000000000000000000000000000000000000000..0a240ec3b56043680ab24771ff39dc22baf0e94f --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/004/20241223_151223.log @@ -0,0 +1,13 @@ +2024-12-23 15:12:23,144 - vit_utils - INFO - Distributed training: False +2024-12-23 15:12:23,144 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 15:12:23,756 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 15:12:23,771 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 64 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/005/20241223_151851.log b/ViTPose/easy_ViTPose/runs/train/005/20241223_151851.log new file mode 100644 index 0000000000000000000000000000000000000000..52d771972511600b62375ee31cd120c2359a4b9f --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/005/20241223_151851.log @@ -0,0 +1,13 @@ +2024-12-23 15:18:51,703 - vit_utils - INFO - Distributed training: False +2024-12-23 15:18:51,703 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 15:18:52,378 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 15:18:52,378 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/006/20241223_165154.log b/ViTPose/easy_ViTPose/runs/train/006/20241223_165154.log new file mode 100644 index 0000000000000000000000000000000000000000..f636e9962bce16b99d1549ad9b128d07eb7e71d1 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/006/20241223_165154.log @@ -0,0 +1,13 @@ +2024-12-23 16:51:54,518 - vit_utils - INFO - Distributed training: False +2024-12-23 16:51:54,518 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 16:52:00,567 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 16:52:00,567 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/007/20241223_165757.log b/ViTPose/easy_ViTPose/runs/train/007/20241223_165757.log new file mode 100644 index 0000000000000000000000000000000000000000..9fba734f6561a8e2081b045f9814b6df3a92ff7c --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/007/20241223_165757.log @@ -0,0 +1,13 @@ +2024-12-23 16:57:57,889 - vit_utils - INFO - Distributed training: False +2024-12-23 16:57:57,889 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 16:57:58,374 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 16:57:58,374 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/008/20241223_170953.log b/ViTPose/easy_ViTPose/runs/train/008/20241223_170953.log new file mode 100644 index 0000000000000000000000000000000000000000..0f09bca9ea0d940a285c94493124e21bedf8d2fe --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/008/20241223_170953.log @@ -0,0 +1,2 @@ +2024-12-23 17:09:53,332 - vit_utils - INFO - Distributed training: False +2024-12-23 17:09:53,332 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/009/20241223_171106.log b/ViTPose/easy_ViTPose/runs/train/009/20241223_171106.log new file mode 100644 index 0000000000000000000000000000000000000000..fbcfef2b6744509e288b60ad82d8b98ac187562b --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/009/20241223_171106.log @@ -0,0 +1,13 @@ +2024-12-23 17:11:06,399 - vit_utils - INFO - Distributed training: False +2024-12-23 17:11:06,399 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 17:11:07,042 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 17:11:07,042 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/010/20241223_171712.log b/ViTPose/easy_ViTPose/runs/train/010/20241223_171712.log new file mode 100644 index 0000000000000000000000000000000000000000..b04cc402ed0459db92340560b12a159be363d8dc --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/010/20241223_171712.log @@ -0,0 +1,13 @@ +2024-12-23 17:17:12,685 - vit_utils - INFO - Distributed training: False +2024-12-23 17:17:12,685 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 17:17:13,344 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 17:17:13,360 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/011/20241223_172001.log b/ViTPose/easy_ViTPose/runs/train/011/20241223_172001.log new file mode 100644 index 0000000000000000000000000000000000000000..617c77c77335a0b71ce4236760e442302324eaa9 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/011/20241223_172001.log @@ -0,0 +1,2 @@ +2024-12-23 17:20:01,722 - vit_utils - INFO - Distributed training: False +2024-12-23 17:20:01,722 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/012/20241223_181550.log b/ViTPose/easy_ViTPose/runs/train/012/20241223_181550.log new file mode 100644 index 0000000000000000000000000000000000000000..94c8ff5604b04a9cefabf844006fc3c1ce5f47e7 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/012/20241223_181550.log @@ -0,0 +1,13 @@ +2024-12-23 18:15:50,841 - vit_utils - INFO - Distributed training: False +2024-12-23 18:15:50,841 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-23 18:15:51,542 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-23 18:15:51,558 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/013/20241224_080559.log b/ViTPose/easy_ViTPose/runs/train/013/20241224_080559.log new file mode 100644 index 0000000000000000000000000000000000000000..5d5f435d60a6607509198c808d674fe1d8c0d348 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/013/20241224_080559.log @@ -0,0 +1,13 @@ +2024-12-24 08:05:59,562 - vit_utils - INFO - Distributed training: False +2024-12-24 08:05:59,562 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 08:06:00,353 - vit_utils - INFO - Using Automatic Mixed Precision (AMP) training... +2024-12-24 08:06:00,358 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: True + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/014/20241224_091922.log b/ViTPose/easy_ViTPose/runs/train/014/20241224_091922.log new file mode 100644 index 0000000000000000000000000000000000000000..fe4cd19892989a185cc22b853f5108bade2924c5 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/014/20241224_091922.log @@ -0,0 +1,12 @@ +2024-12-24 09:19:22,111 - vit_utils - INFO - Distributed training: False +2024-12-24 09:19:22,112 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 09:20:59,069 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: False + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/015/20241224_092511.log b/ViTPose/easy_ViTPose/runs/train/015/20241224_092511.log new file mode 100644 index 0000000000000000000000000000000000000000..28871b6a8128d432923ec0ef9680dc21cfb2ac8e --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/015/20241224_092511.log @@ -0,0 +1,12 @@ +2024-12-24 09:25:11,271 - vit_utils - INFO - Distributed training: False +2024-12-24 09:25:11,272 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 09:25:11,707 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 1 + # - LR: 0.000500 + # - Num params: 24,290,577 + # - AMP: False + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/016/20241224_092913.log b/ViTPose/easy_ViTPose/runs/train/016/20241224_092913.log new file mode 100644 index 0000000000000000000000000000000000000000..131ac5fe2a93cc34ab48d234b4e65dc96534735d --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/016/20241224_092913.log @@ -0,0 +1,4 @@ +2024-12-24 09:29:13,730 - vit_utils - INFO - Distributed training: False +2024-12-24 09:29:13,733 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 09:29:23,378 - vit_utils - INFO - Distributed training: False +2024-12-24 09:29:23,384 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/017/20241224_095013.log b/ViTPose/easy_ViTPose/runs/train/017/20241224_095013.log new file mode 100644 index 0000000000000000000000000000000000000000..9bc488847727f521e75f52976ff8bae1a65493ec --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/017/20241224_095013.log @@ -0,0 +1,2 @@ +2024-12-24 09:50:13,761 - vit_utils - INFO - Distributed training: False +2024-12-24 09:50:13,762 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/018/20241224_095931.log b/ViTPose/easy_ViTPose/runs/train/018/20241224_095931.log new file mode 100644 index 0000000000000000000000000000000000000000..e1503f7b501d2c50b76430d91eab13dd9092205f --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/018/20241224_095931.log @@ -0,0 +1,2 @@ +2024-12-24 09:59:31,513 - vit_utils - INFO - Distributed training: False +2024-12-24 09:59:31,515 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/019/20241224_100609.log b/ViTPose/easy_ViTPose/runs/train/019/20241224_100609.log new file mode 100644 index 0000000000000000000000000000000000000000..1bc30b919487d137d826bf7b48de80b17a56d1b4 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/019/20241224_100609.log @@ -0,0 +1,2 @@ +2024-12-24 10:06:09,002 - vit_utils - INFO - Distributed training: False +2024-12-24 10:06:09,003 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/020/20241224_101254.log b/ViTPose/easy_ViTPose/runs/train/020/20241224_101254.log new file mode 100644 index 0000000000000000000000000000000000000000..dc40141aca539b65b43f605e2c14632de00df561 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/020/20241224_101254.log @@ -0,0 +1,2 @@ +2024-12-24 10:12:54,393 - vit_utils - INFO - Distributed training: False +2024-12-24 10:12:54,394 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/021/20241224_102343.log b/ViTPose/easy_ViTPose/runs/train/021/20241224_102343.log new file mode 100644 index 0000000000000000000000000000000000000000..7bc1559078fa357dfe802be4a9c84365c5b65012 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/021/20241224_102343.log @@ -0,0 +1,2 @@ +2024-12-24 10:23:43,420 - vit_utils - INFO - Distributed training: False +2024-12-24 10:23:43,424 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/022/20241224_103043.log b/ViTPose/easy_ViTPose/runs/train/022/20241224_103043.log new file mode 100644 index 0000000000000000000000000000000000000000..7ef72571572c2d79edeea6d5bd9ac2cd5af16411 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/022/20241224_103043.log @@ -0,0 +1,2 @@ +2024-12-24 10:30:43,848 - vit_utils - INFO - Distributed training: False +2024-12-24 10:30:43,849 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/023/20241224_104924.log b/ViTPose/easy_ViTPose/runs/train/023/20241224_104924.log new file mode 100644 index 0000000000000000000000000000000000000000..e6f2aa9c804208583145f68c135104bdf1eef724 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/023/20241224_104924.log @@ -0,0 +1,4 @@ +2024-12-24 10:49:24,974 - vit_utils - INFO - Distributed training: False +2024-12-24 10:49:24,976 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 10:51:55,675 - vit_utils - INFO - Distributed training: False +2024-12-24 10:51:55,677 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/024/20241224_105408.log b/ViTPose/easy_ViTPose/runs/train/024/20241224_105408.log new file mode 100644 index 0000000000000000000000000000000000000000..3dbcbdeead3781b295882b14a9bb46f90f475797 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/024/20241224_105408.log @@ -0,0 +1,2 @@ +2024-12-24 10:54:08,018 - vit_utils - INFO - Distributed training: False +2024-12-24 10:54:08,019 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/025/20241224_110025.log b/ViTPose/easy_ViTPose/runs/train/025/20241224_110025.log new file mode 100644 index 0000000000000000000000000000000000000000..e36d6b97668c5d907ca873ff92cb850861da155e --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/025/20241224_110025.log @@ -0,0 +1,2 @@ +2024-12-24 11:00:25,479 - vit_utils - INFO - Distributed training: False +2024-12-24 11:00:25,480 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/026/20241224_110439.log b/ViTPose/easy_ViTPose/runs/train/026/20241224_110439.log new file mode 100644 index 0000000000000000000000000000000000000000..3bbac25e56d49cd80cd8d598f423dba1e916432e --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/026/20241224_110439.log @@ -0,0 +1,2 @@ +2024-12-24 11:04:39,670 - vit_utils - INFO - Distributed training: False +2024-12-24 11:04:39,672 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/027/20241224_110803.log b/ViTPose/easy_ViTPose/runs/train/027/20241224_110803.log new file mode 100644 index 0000000000000000000000000000000000000000..40c2a582e9872c5ab52ce95c4bad55b0684aea89 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/027/20241224_110803.log @@ -0,0 +1,2 @@ +2024-12-24 11:08:03,264 - vit_utils - INFO - Distributed training: False +2024-12-24 11:08:03,265 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/029/20241224_111613.log b/ViTPose/easy_ViTPose/runs/train/029/20241224_111613.log new file mode 100644 index 0000000000000000000000000000000000000000..ed8bd59591fba39b84f66badce39d8455bf127d3 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/029/20241224_111613.log @@ -0,0 +1,2 @@ +2024-12-24 11:16:13,063 - vit_utils - INFO - Distributed training: False +2024-12-24 11:16:13,064 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/030/20241224_112153.log b/ViTPose/easy_ViTPose/runs/train/030/20241224_112153.log new file mode 100644 index 0000000000000000000000000000000000000000..a0f6e639037ede1f42045b8fe0af39abc0233a86 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/030/20241224_112153.log @@ -0,0 +1,2 @@ +2024-12-24 11:21:53,383 - vit_utils - INFO - Distributed training: False +2024-12-24 11:21:53,384 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/031/20241224_112923.log b/ViTPose/easy_ViTPose/runs/train/031/20241224_112923.log new file mode 100644 index 0000000000000000000000000000000000000000..74310a33b5fbd75b10ce9a0ad662c0bd52f54f5b --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/031/20241224_112923.log @@ -0,0 +1,2 @@ +2024-12-24 11:29:23,145 - vit_utils - INFO - Distributed training: False +2024-12-24 11:29:23,147 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/032/20241224_115715.log b/ViTPose/easy_ViTPose/runs/train/032/20241224_115715.log new file mode 100644 index 0000000000000000000000000000000000000000..a8e68e4d4a2f4abc8ee1d16fcc2686353a354810 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/032/20241224_115715.log @@ -0,0 +1,2 @@ +2024-12-24 11:57:15,377 - vit_utils - INFO - Distributed training: False +2024-12-24 11:57:15,378 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/033/20241224_140555.log b/ViTPose/easy_ViTPose/runs/train/033/20241224_140555.log new file mode 100644 index 0000000000000000000000000000000000000000..91440322c88722da98190ac9812ae0cfe6874bff --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/033/20241224_140555.log @@ -0,0 +1,12 @@ +2024-12-24 14:05:55,217 - vit_utils - INFO - Distributed training: False +2024-12-24 14:05:55,218 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 15:02:04,992 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 2,627,601 + # - AMP: False + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/034/20241224_150448.log b/ViTPose/easy_ViTPose/runs/train/034/20241224_150448.log new file mode 100644 index 0000000000000000000000000000000000000000..9ddc49045e81f317fc84b92136d4bec697cd6f54 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/034/20241224_150448.log @@ -0,0 +1,12 @@ +2024-12-24 15:04:48,233 - vit_utils - INFO - Distributed training: False +2024-12-24 15:04:48,234 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 15:04:49,062 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 2,627,601 + # - AMP: False + #===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/035/20241224_150729.log b/ViTPose/easy_ViTPose/runs/train/035/20241224_150729.log new file mode 100644 index 0000000000000000000000000000000000000000..7c213a7cc1a7f4d48ea9b4ac378314a2ced091a0 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/035/20241224_150729.log @@ -0,0 +1,32 @@ +2024-12-24 15:07:29,150 - vit_utils - INFO - Distributed training: False +2024-12-24 15:07:29,151 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 15:07:29,999 - vit_utils - INFO - + + #========= [Train Configs] =========# + # - Num GPUs: 1 + # - Batch size (per gpu): 4 + # - LR: 0.000500 + # - Num params: 2,627,601 + # - AMP: False + #===================================# + +2024-12-24 15:16:16,506 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:17:07,105 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/036/20241224_151954.log b/ViTPose/easy_ViTPose/runs/train/036/20241224_151954.log new file mode 100644 index 0000000000000000000000000000000000000000..87a1e76c005e26189f9e804a0fcef6f72589d37d --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/036/20241224_151954.log @@ -0,0 +1,92 @@ +2024-12-24 15:19:54,831 - vit_utils - INFO - Distributed training: False +2024-12-24 15:19:54,832 - vit_utils - INFO - Set random seed to 0, deterministic: True +2024-12-24 15:19:55,683 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:21:28,892 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:22:09,621 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:23:28,159 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:24:06,929 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:24:10,683 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:24:54,773 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:25:09,886 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + +2024-12-24 15:25:44,488 - vit_utils - INFO - + +#========= [Train Configs] =========# +# - Num GPUs: 1 +# - Batch size (per gpu): 4 +# - LR: 0.000500 +# - Num params: 2,627,601 +# - AMP: False +#===================================# + diff --git a/ViTPose/easy_ViTPose/runs/train/037/20241224_152742.log b/ViTPose/easy_ViTPose/runs/train/037/20241224_152742.log new file mode 100644 index 0000000000000000000000000000000000000000..f5e20ae3a35a613deb3f32022cf6e220c5713976 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/037/20241224_152742.log @@ -0,0 +1,2 @@ +2024-12-24 15:27:42,982 - vit_utils - INFO - Distributed training: False +2024-12-24 15:27:42,983 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/038/20241224_155841.log b/ViTPose/easy_ViTPose/runs/train/038/20241224_155841.log new file mode 100644 index 0000000000000000000000000000000000000000..674004d5acbf398c6bca427eb3ccdec718af1fe2 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/038/20241224_155841.log @@ -0,0 +1,2 @@ +2024-12-24 15:58:41,640 - vit_utils - INFO - Distributed training: False +2024-12-24 15:58:41,641 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/039/20241224_162021.log b/ViTPose/easy_ViTPose/runs/train/039/20241224_162021.log new file mode 100644 index 0000000000000000000000000000000000000000..60c66bd70702c9baa4a476f7c3f8775072f465ae --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/039/20241224_162021.log @@ -0,0 +1,2 @@ +2024-12-24 16:20:21,389 - vit_utils - INFO - Distributed training: False +2024-12-24 16:20:21,390 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/040/20241224_163358.log b/ViTPose/easy_ViTPose/runs/train/040/20241224_163358.log new file mode 100644 index 0000000000000000000000000000000000000000..d605ae2cf885cc6061560238387c1717b350b953 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/040/20241224_163358.log @@ -0,0 +1,2 @@ +2024-12-24 16:33:58,210 - vit_utils - INFO - Distributed training: False +2024-12-24 16:33:58,212 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/041/20241224_163607.log b/ViTPose/easy_ViTPose/runs/train/041/20241224_163607.log new file mode 100644 index 0000000000000000000000000000000000000000..08fb744b79cfb262ba250a12b422dd4ef07c1cdf --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/041/20241224_163607.log @@ -0,0 +1,2 @@ +2024-12-24 16:36:07,360 - vit_utils - INFO - Distributed training: False +2024-12-24 16:36:07,361 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/042/20241224_170826.log b/ViTPose/easy_ViTPose/runs/train/042/20241224_170826.log new file mode 100644 index 0000000000000000000000000000000000000000..2313b41a1760f38a4c10ee473956e979ff336344 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/042/20241224_170826.log @@ -0,0 +1,2 @@ +2024-12-24 17:08:26,262 - vit_utils - INFO - Distributed training: False +2024-12-24 17:08:26,263 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/runs/train/043/20241225_085231.log b/ViTPose/easy_ViTPose/runs/train/043/20241225_085231.log new file mode 100644 index 0000000000000000000000000000000000000000..77753fb0aff2c6d3c1d3ac33ba4849043a850892 --- /dev/null +++ b/ViTPose/easy_ViTPose/runs/train/043/20241225_085231.log @@ -0,0 +1,2 @@ +2024-12-25 08:52:31,377 - vit_utils - INFO - Distributed training: False +2024-12-25 08:52:31,378 - vit_utils - INFO - Set random seed to 0, deterministic: True diff --git a/ViTPose/easy_ViTPose/setup.py b/ViTPose/easy_ViTPose/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..c00d51c77304079a2c92f9d68d05062cecb9ca8d --- /dev/null +++ b/ViTPose/easy_ViTPose/setup.py @@ -0,0 +1,10 @@ +from setuptools import setup, find_packages + +setup( + name='easy_ViTPose', + author="JunkyByte", + author_email="adriano.donninelli@hotmail.it", + version='1.1', + url="https://github.com/JunkyByte/easy_ViTPose", + packages=find_packages(include=['easy_ViTPose', 'easy_ViTPose.*']), +) diff --git a/ViTPose/yolov8s.pt b/ViTPose/yolov8s.pt new file mode 100644 index 0000000000000000000000000000000000000000..ee7201e87d30043a5182c12b349b1a45608ded65 --- /dev/null +++ b/ViTPose/yolov8s.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f47a78bf100391c2a140b7ac73a1caae18c32779be7d310658112f7ac9aa78a +size 22588772