From 7e860e6761ab00d1d44c2d858889600c6efad5f7 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Thu, 25 Aug 2022 11:11:53 +0530 Subject: [PATCH 01/15] sample notebooks for yolov4 and tiny-yoloV2 --- ...VEP_tiny_yolov2_obj_detection_sample.ipynb | 741 +++++++++++ .../OVEP_yolov4_obj_detection_sample.ipynb | 1149 +++++++++++++++++ 2 files changed, 1890 insertions(+) create mode 100644 python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb create mode 100644 python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb diff --git a/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb b/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb new file mode 100644 index 000000000..c44a4d4be --- /dev/null +++ b/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb @@ -0,0 +1,741 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6330a8a6", + "metadata": { + "id": "6330a8a6" + }, + "source": [ + "Copyright (C) 2021-2022, Intel Corporation\n", + "\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "id": "aa6f534b", + "metadata": { + "id": "aa6f534b" + }, + "source": [ + "# Object detection with tiny YOLOv2 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a tinyYOLOv2 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "\n", + "\n", + "2. The sample involves presenting an Image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 20 different objects like birds, buses, cars, people and much more.\n", + "\n", + "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/tiny_yolo_v2_object_detection)." + ] + }, + { + "cell_type": "markdown", + "id": "b2c9aa57", + "metadata": { + "id": "b2c9aa57" + }, + "source": [ + "### Install Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "809559b8", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "809559b8", + "outputId": "1b4d78a7-fd0c-4ca8-bed7-186c290238cd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip -q install --upgrade pip\n", + "!pip -q install folium==0.2.1\n", + "!pip -q install imgaug==0.2.6\n", + "!pip -q install certifi==2022.5.18.1\n", + "!pip -q install flatbuffers==2.0\n", + "!pip -q install numpy==1.21.6\n", + "!pip -q install onnx==1.11.0\n", + "!pip -q install opencv-python==4.5.5.64\n", + "!pip -q install scipy==1.7.3\n", + "!pip -q install typing-extensions==4.1.1\n", + "!pip -q install onnxruntime-openvino==1.11.0" + ] + }, + { + "cell_type": "markdown", + "id": "24d73115", + "metadata": { + "id": "24d73115" + }, + "source": [ + "### Import Necessary Resources" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f72e3ca", + "metadata": { + "id": "6f72e3ca" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import onnxruntime as rt\n", + "import cv2\n", + "import time\n", + "import os\n", + "from pathlib import Path\n", + "import argparse\n", + "import platform\n", + "from google.colab.patches import cv2_imshow\n", + "import sys" + ] + }, + { + "cell_type": "markdown", + "id": "9399694a", + "metadata": { + "id": "9399694a" + }, + "source": [ + "### Get the model and input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2b38cc9", + "metadata": { + "id": "e2b38cc9" + }, + "outputs": [], + "source": [ + "#Create List of files in the directory\n", + "files = os.listdir('.')\n", + "\n", + "#Get the neccesary files into the directory if they don't already exist\n", + "if ('tinyyolov2-8.onnx' not in files):\n", + " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/tiny-yolov2/model/tinyyolov2-8.onnx?raw=true -O tinyyolov2-8.onnx\n", + "if ('dog.bmp' not in files):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/512x512/dog.bmp" + ] + }, + { + "cell_type": "markdown", + "id": "ceff9a38", + "metadata": { + "id": "ceff9a38" + }, + "source": [ + "## Preprocess" + ] + }, + { + "cell_type": "markdown", + "id": "cb2dd5ca", + "metadata": { + "id": "cb2dd5ca" + }, + "source": [ + "### Reshape the input to align with the model\n", + "\n", + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image is re-shaped to the desired image size i.e. $(416 \\times 416)$ using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34a2817f", + "metadata": { + "id": "34a2817f" + }, + "outputs": [], + "source": [ + "def image_preprocess(frame):\n", + " in_frame = cv2.resize(frame, (416, 416))\n", + " preprocessed_image = np.asarray(in_frame)\n", + " preprocessed_image = preprocessed_image.astype(np.float32)\n", + " preprocessed_image = preprocessed_image.transpose(2,0,1)\n", + " #Reshaping the input array to align with the input shape of the model\n", + " preprocessed_image = preprocessed_image.reshape(1,3,416,416)\n", + " return preprocessed_image" + ] + }, + { + "cell_type": "markdown", + "id": "6dbc9aa8", + "metadata": { + "id": "6dbc9aa8" + }, + "source": [ + "### Check file paths\n", + "\n", + "`check_model_extention` is a helper function which checks if the model is present in the location specified. It also validates the model by checking the model file extension. \n", + "The expected model file should be of `.onnx` format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca5d9356", + "metadata": { + "id": "ca5d9356" + }, + "outputs": [], + "source": [ + "def check_model_extension(fp):\n", + " # Split the extension from the path and normalise it to lowercase.\n", + " ext = Path(fp).suffix.lower()\n", + "\n", + " # Now we can simply use != to check for inconsitencies with model file.\n", + " if(ext != \".onnx\"):\n", + " raise NameError(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", + " \n", + " if not Path(fp).exists():\n", + " raise OSError(\"[ ERROR ] Path of the onnx model file is Invalid\")" + ] + }, + { + "cell_type": "markdown", + "id": "bfc0e076", + "metadata": { + "id": "bfc0e076" + }, + "source": [ + "## Postprocess" + ] + }, + { + "cell_type": "markdown", + "id": "fca5634d", + "metadata": { + "id": "fca5634d" + }, + "source": [ + "### Add the appropriate bounding boxes and the class label to the image based on the inference results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a331243", + "metadata": { + "id": "7a331243" + }, + "outputs": [], + "source": [ + "def postprocess_output(out, frame, x_scale, y_scale):\n", + " out = out[0][0]\n", + " num_classes = 20\n", + " anchors = [1.08, 1.19, 3.42, 4.41, 6.63, 11.38, 9.42, 5.11, 16.62, 10.52]\n", + " \n", + " # color look up table for different classes for object detection sample\n", + " clut = [(0,0,0),(255,0,0),(255,0,255),(0,0,255),(0,255,0),(0,255,128),\n", + " (128,255,0),(128,128,0),(0,128,255),(128,0,128),\n", + " (255,0,128),(128,0,255),(255,128,128),(128,255,128),(255,255,0),\n", + " (255,128,128),(128,128,255),(255,128,128),(128,255,128),(128,255,128)]\n", + "\n", + " # 20 labels that the tiny-yolov2 model can do the object_detection on\n", + " label = [\"aeroplane\",\"bicycle\",\"bird\",\"boat\",\"bottle\",\n", + " \"bus\",\"car\",\"cat\",\"chair\",\"cow\",\"diningtable\",\n", + " \"dog\",\"horse\",\"motorbike\",\"person\",\"pottedplant\",\n", + " \"sheep\",\"sofa\",\"train\",\"tvmonitor\"]\n", + "\n", + " existing_labels = {l: [] for l in label}\n", + "\n", + " #Inside this loop we compute the bounding box b for grid cell (cy, cx)\n", + " for cy in range(0,13):\n", + " for cx in range(0,13):\n", + " for b in range(0,5):\n", + " # First we read the tx, ty, width(tw), and height(th) for the bounding box from the out array, as well as the confidence score\n", + " channel = b*(num_classes+5)\n", + " tx = out[channel ][cy][cx]\n", + " ty = out[channel+1][cy][cx]\n", + " tw = out[channel+2][cy][cx]\n", + " th = out[channel+3][cy][cx]\n", + " tc = out[channel+4][cy][cx]\n", + "\n", + " x = (float(cx) + sigmoid(tx))*32\n", + " y = (float(cy) + sigmoid(ty))*32\n", + " w = np.exp(tw) * 32 * anchors[2*b]\n", + " h = np.exp(th) * 32 * anchors[2*b+1]\n", + "\n", + " #calculating the confidence score\n", + " confidence = sigmoid(tc) # The confidence value for the bounding box is given by tc\n", + " classes = np.zeros(num_classes)\n", + " for c in range(0,num_classes):\n", + " classes[c] = out[channel + 5 +c][cy][cx]\n", + " # we take the softmax to turn the array into a probability distribution. And then we pick the class with the largest score as the winner.\n", + " classes = softmax(classes)\n", + " detected_class = classes.argmax()\n", + " # Now we can compute the final score for this bounding box and we only want to keep the ones whose combined score is over a certain threshold\n", + " if 0.75 < classes[detected_class]*confidence:\n", + " color =clut[detected_class]\n", + " x = (x - w/2)*x_scale\n", + " y = (y - h/2)*y_scale\n", + " w *= x_scale\n", + " h *= y_scale\n", + " \n", + " labelX = int((x+x+w)/2)\n", + " labelY = int((y+y+h)/2)\n", + " addLabel = True\n", + " lab_threshold = 100\n", + " for point in existing_labels[label[detected_class]]:\n", + " if labelX < point[0] + lab_threshold and labelX > point[0] - lab_threshold and \\\n", + " labelY < point[1] + lab_threshold and labelY > point[1] - lab_threshold:\n", + " addLabel = False\n", + " #Adding class labels to the output of the frame and also drawing a rectangular bounding box around the object detected.\n", + " if addLabel:\n", + " bbox_mess = f'{label[detected_class]}:{classes[detected_class]*confidence:.3f}'\n", + " cv2.rectangle(frame, (int(x),int(y)),(int(x+w),int(y+h)),color,2)\n", + " cv2.rectangle(frame, (int(x),int(y-13)),(int(x)+9*len(bbox_mess),int(y)),color,-1)\n", + " cv2.putText(frame,bbox_mess,(int(x)+2,int(y)-3),cv2.FONT_HERSHEY_COMPLEX,0.4,(255,255,255),1)\n", + " existing_labels[label[detected_class]].append((labelX,labelY))\n", + " print(f'{label[detected_class]} detected in frame with {classes[detected_class]*confidence*100}% probability ')" + ] + }, + { + "cell_type": "markdown", + "id": "86200685", + "metadata": { + "id": "86200685" + }, + "source": [ + "### Show the image with the bounding boxes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ff22f1f", + "metadata": { + "id": "4ff22f1f" + }, + "outputs": [], + "source": [ + "def show_bbox(device, frame, inference_time):\n", + " cv2.putText(frame,device,(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", + " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", + " cv2_imshow(frame)" + ] + }, + { + "cell_type": "markdown", + "id": "2a609551", + "metadata": { + "id": "2a609551" + }, + "source": [ + "### sigmoid and softmax functions to make sense of infrence output for the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b22f9ad", + "metadata": { + "id": "7b22f9ad" + }, + "outputs": [], + "source": [ + "def sigmoid(x, derivative=False):\n", + " return x*(1-x) if derivative else 1/(1+np.exp(-x))\n", + "\n", + "def softmax(x):\n", + " score_mat_exp = np.exp(np.asarray(x))\n", + " return score_mat_exp / score_mat_exp.sum(0)" + ] + }, + { + "cell_type": "markdown", + "id": "xEQDTN4xKgfs", + "metadata": { + "id": "xEQDTN4xKgfs" + }, + "source": [ + "## Inference" + ] + }, + { + "cell_type": "markdown", + "id": "7617f559", + "metadata": { + "id": "7617f559" + }, + "source": [ + "### Create a session for inference based on the device selected\n", + "\n", + "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", + " \n", + "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", + "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", + "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", + "\n", + "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", + "\n", + "The device option should be chosen from any one of the below options: \n", + "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "438b7b76", + "metadata": { + "id": "438b7b76" + }, + "outputs": [], + "source": [ + "def create_sess(device):\n", + " so = rt.SessionOptions()\n", + " so.log_severity_level = 3\n", + " if (device == 'cpu'):\n", + " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", + " #Specify the path to the ONNX model on your machine and register the CPU EP\n", + " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", + " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", + " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", + " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", + " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", + " '''\n", + " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", + " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", + " '''\n", + " else:\n", + " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", + "\n", + " # Get the input name of the model\n", + " input_name = sess.get_inputs()[0].name\n", + "\n", + " return sess, input_name" + ] + }, + { + "cell_type": "markdown", + "id": "d1a39044", + "metadata": { + "id": "d1a39044" + }, + "source": [ + "### Specify the device and path to model, Image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39fec459", + "metadata": { + "id": "39fec459" + }, + "outputs": [], + "source": [ + "model = \"tinyyolov2-8.onnx\"\n", + "image = \"dog.bmp\"" + ] + }, + { + "cell_type": "markdown", + "id": "3df2a717", + "metadata": { + "id": "3df2a717" + }, + "source": [ + "### Validate model file path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d29f8f8", + "metadata": { + "id": "4d29f8f8" + }, + "outputs": [], + "source": [ + "check_model_extension(model)" + ] + }, + { + "cell_type": "markdown", + "id": "j5QfFB1PJ_uq", + "metadata": { + "id": "j5QfFB1PJ_uq" + }, + "source": [ + "### Setup input and output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "DX-C07_3zcck", + "metadata": { + "id": "DX-C07_3zcck" + }, + "outputs": [], + "source": [ + "if (image):\n", + " \n", + " #Check if image file exists\n", + " if not Path(image).is_file():\n", + " raise OSError(\"Input image file \", image, \" doesn't exist as a file\")\n", + "\n", + " # Open the image file\n", + " cap = cv2.imread(image)\n", + "\n", + " height, width, c = cap.shape\n", + " x_scale = float(width)/416.0 #In the document of tino-yolo-v2, input shape of this network is (1,3,416,416).\n", + " y_scale = float(height)/416.0\n", + "\n", + " output_file = Path(image).stem+'_tiny_yolov2_out_py.jpg'" + ] + }, + { + "cell_type": "markdown", + "id": "2SgMAeXVfQrR", + "metadata": { + "id": "2SgMAeXVfQrR" + }, + "source": [ + "### Run the inference with default CPU Execution Provider \n", + "\n", + "Now the `tinyyolov2-8.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", + "- `cpu`: default CPU Execution Provider (MLAS) \n", + "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", + "\n", + "The below code block performs the following operations:\n", + "\n", + "1. Creates a Onnx Runtime Session using `cpu` as device\n", + "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", + "3. Performs prediction on the same image for $100$-times\n", + "4. Calculates average inference time\n", + "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1sssvylKfR_0", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 651 + }, + "id": "1sssvylKfR_0", + "outputId": "58cf8a7d-fce7-4c70-b89f-2c881ee89e52" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\n", + "PREDICTION - BEGIN\n", + "Avg Inference time in ms: 171.4293139199998\n", + "PREDICTION - END\n", + "dog detected in frame with 80.20803000214038% probability \n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "### create a session with cpu which is the default CPU Execution Provider\n", + "sess, input_name = create_sess(\"cpu\")\n", + "\n", + "#capturing one frame at a time from the video feed and performing the inference\n", + "frame = cap.copy()\n", + "\n", + "#preprocessing the input frame and reshaping it.\n", + "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", + "preprocessed_image = image_preprocess(frame)\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "start = time.perf_counter()\n", + "#Running the session by passing in the input data of the model\n", + "for i in range(100):\n", + " out = sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "end = time.perf_counter()\n", + "inference_time = end - start\n", + "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", + "print(\"PREDICTION - END\")\n", + "\n", + "#Get the output\n", + "postprocess_output(out, frame, x_scale, y_scale)\n", + "\n", + "#Show the output\n", + "show_bbox(\"cpu\", frame, inference_time)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, frame.astype(np.uint8))\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "XUkRaU9uI0zX", + "metadata": { + "id": "XUkRaU9uI0zX" + }, + "source": [ + "### Run the inference with OpenVINO Execution Provider\n", + "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b5517d1", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8b5517d1", + "outputId": "d41168dc-d37a-43d1-ef64-95b551dc798a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device type selected is: CPU_FP32 using the OpenVINO Execution Provider\n", + "PREDICTION - BEGIN\n", + "Avg Inference time in ms: 143.52424147999955\n", + "PREDICTION - END\n", + "dog detected in frame with 80.20795232381303% probability \n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", + "sess, input_name = create_sess(\"CPU_FP32\")\n", + "\n", + "#capturing one frame at a time from the video feed and performing the inference\n", + "frame = cap.copy()\n", + "\n", + "#preprocessing the input frame and reshaping it.\n", + "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", + "preprocessed_image = image_preprocess(frame)\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "start = time.perf_counter()\n", + "#Running the session by passing in the input data of the model\n", + "for i in range(100):\n", + " out = sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "end = time.perf_counter()\n", + "inference_time = end - start\n", + "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", + "print(\"PREDICTION - END\")\n", + "\n", + "#Get the output\n", + "postprocess_output(out, frame, x_scale, y_scale)\n", + "\n", + "#Show the output\n", + "show_bbox(\"CPU_FP32\", frame, inference_time)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, frame.astype(np.uint8))\n", + "print('\\n')" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "OVEP_tiny_yolov2_obj_detection_sample.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.8.10 ('tiny_yolovV2': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "vscode": { + "interpreter": { + "hash": "0226610a830f21b877cea989523fd0c295c7466b3cab1c0f323be92db3371acd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb b/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb new file mode 100644 index 000000000..3e320f5b9 --- /dev/null +++ b/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb @@ -0,0 +1,1149 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b6157254", + "metadata": { + "id": "b6157254" + }, + "source": [ + "Copyright (C) 2021-2022, Intel Corporation\n", + "\n", + "SPDX-License-Identifier: Apache-2.0\n", + "\n", + "Major Portions of this code are copyright of their respective authors and released under the Apache License Version 2.0:\n", + "- onnx, Copyright 2021-2022. For licensing see https://github.com/onnx/models/blob/master/LICENSE" + ] + }, + { + "cell_type": "markdown", + "id": "dfed77f6", + "metadata": { + "id": "dfed77f6" + }, + "source": [ + "# Object detection with YOLOv4 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a YOLOv4 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "\n", + "\n", + "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset.\n", + "\n", + "\n", + "4. Once the inferencing is done on the sample, the recording of the same also gets downloaded on the disk.\n", + "\n", + "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/yolov4_object_detection)." + ] + }, + { + "cell_type": "markdown", + "id": "08dd644b", + "metadata": { + "id": "08dd644b" + }, + "source": [ + "## Install Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d18b13f8", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d18b13f8", + "outputId": "98506653-ce93-4ff7-ff27-45fba7012df0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[K |████████████████████████████████| 2.0 MB 7.7 MB/s \n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m70.0/70.0 kB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for folium (setup.py) ... \u001b[?25l\u001b[?25hdone\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", + "datascience 0.17.5 requires folium>=0.9.1, but you have folium 0.2.1 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m631.4/631.4 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for imgaug (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m155.2/155.2 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m61.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.5/60.5 MB\u001b[0m \u001b[31m11.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m37.6/37.6 MB\u001b[0m \u001b[31m13.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip -q install --upgrade pip\n", + "!pip -q install folium==0.2.1\n", + "!pip -q install imgaug==0.2.6\n", + "!pip -q install certifi==2022.5.18.1\n", + "!pip -q install flatbuffers==2.0\n", + "!pip -q install numpy==1.21.6\n", + "!pip -q install onnx==1.11.0\n", + "!pip -q install opencv-python==4.5.5.64\n", + "!pip -q install scipy==1.7.3\n", + "!pip -q install typing-extensions==4.1.1\n", + "!pip -q install onnxruntime-openvino==1.11.0" + ] + }, + { + "cell_type": "markdown", + "id": "97b43517", + "metadata": { + "id": "97b43517" + }, + "source": [ + "## Import Necessary Resources" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06698673", + "metadata": { + "id": "06698673" + }, + "outputs": [], + "source": [ + "import cv2\n", + "import numpy as np\n", + "from onnx import numpy_helper\n", + "import onnx\n", + "import onnxruntime as rt\n", + "import os\n", + "from PIL import Image\n", + "from scipy import special\n", + "import colorsys\n", + "import random\n", + "import argparse\n", + "import sys\n", + "import time\n", + "from google.colab.patches import cv2_imshow" + ] + }, + { + "cell_type": "markdown", + "id": "3c7fe112", + "metadata": { + "id": "3c7fe112" + }, + "source": [ + "## Get the model and input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "MtdBsnOeJJkk", + "metadata": { + "id": "MtdBsnOeJJkk", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3e2cb8e1-9f7f-43d9-92ba-f51c9fdeb891" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2022-08-19 04:47:57-- https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/yolov4_anchors.txt\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 69 [text/plain]\n", + "Saving to: ‘yolov4_anchors.txt’\n", + "\n", + "\ryolov4_anchors.txt 0%[ ] 0 --.-KB/s \ryolov4_anchors.txt 100%[===================>] 69 --.-KB/s in 0s \n", + "\n", + "2022-08-19 04:47:57 (3.34 MB/s) - ‘yolov4_anchors.txt’ saved [69/69]\n", + "\n", + "--2022-08-19 04:47:57-- https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/coco.names\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 625 [text/plain]\n", + "Saving to: ‘coco.names’\n", + "\n", + "coco.names 100%[===================>] 625 --.-KB/s in 0s \n", + "\n", + "2022-08-19 04:47:57 (26.0 MB/s) - ‘coco.names’ saved [625/625]\n", + "\n", + "--2022-08-19 04:47:57-- https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx?raw=true\n", + "Resolving github.com (github.com)... 140.82.114.3\n", + "Connecting to github.com (github.com)|140.82.114.3|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://github.com/onnx/models/raw/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx [following]\n", + "--2022-08-19 04:47:57-- https://github.com/onnx/models/raw/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx\n", + "Reusing existing connection to github.com:443.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://media.githubusercontent.com/media/onnx/models/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx [following]\n", + "--2022-08-19 04:47:58-- https://media.githubusercontent.com/media/onnx/models/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx\n", + "Resolving media.githubusercontent.com (media.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to media.githubusercontent.com (media.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 257470589 (246M) [application/octet-stream]\n", + "Saving to: ‘yolov4.onnx’\n", + "\n", + "yolov4.onnx 100%[===================>] 245.54M 269MB/s in 0.9s \n", + "\n", + "2022-08-19 04:48:20 (269 MB/s) - ‘yolov4.onnx’ saved [257470589/257470589]\n", + "\n", + "--2022-08-19 04:48:20-- https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg\n", + "Resolving storage.openvinotoolkit.org (storage.openvinotoolkit.org)... 13.226.225.80, 13.226.225.13, 13.226.225.84, ...\n", + "Connecting to storage.openvinotoolkit.org (storage.openvinotoolkit.org)|13.226.225.80|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 51473 (50K) [image/jpeg]\n", + "Saving to: ‘cat.jpg’\n", + "\n", + "cat.jpg 100%[===================>] 50.27K --.-KB/s in 0.1s \n", + "\n", + "2022-08-19 04:48:21 (386 KB/s) - ‘cat.jpg’ saved [51473/51473]\n", + "\n" + ] + } + ], + "source": [ + "files = os.listdir('.')\n", + "if ('yolov4_anchors.txt' not in files):\n", + " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/yolov4_anchors.txt\n", + "if ('coco.names' not in files):\n", + " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/coco.names\n", + "if ('yolov4.onnx' not in files):\n", + " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx?raw=true -O yolov4.onnx\n", + "if ('cat.jpg' not in files):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" + ] + }, + { + "cell_type": "markdown", + "id": "71fec400", + "metadata": { + "id": "71fec400" + }, + "source": [ + "## Preprocess" + ] + }, + { + "cell_type": "markdown", + "id": "23e66f38", + "metadata": { + "id": "23e66f38" + }, + "source": [ + "### Reshape the input to align with the model" + ] + }, + { + "cell_type": "markdown", + "id": "a4ba63cf", + "metadata": { + "id": "a4ba63cf" + }, + "source": [ + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", + "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", + "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bab58d5", + "metadata": { + "id": "1bab58d5" + }, + "outputs": [], + "source": [ + "def image_preprocess(image, target_size, gt_boxes=None):\n", + " \n", + " ih, iw = target_size\n", + " h, w, _ = image.shape\n", + "\n", + " scale = min(iw/w, ih/h)\n", + "\n", + " nw, nh = int(scale * w), int(scale * h)\n", + " image_resized = cv2.resize(image, (nw, nh))\n", + "\n", + " image_padded = np.full(shape=[ih, iw, 3], fill_value=128.0)\n", + " dw, dh = (iw - nw) // 2, (ih-nh) // 2\n", + " image_padded[dh:nh+dh, dw:nw+dw, :] = image_resized\n", + " image_padded = image_padded / 255.\n", + "\n", + " if gt_boxes is None:\n", + " return image_padded\n", + "\n", + " else:\n", + " gt_boxes[:, [0, 2]] = gt_boxes[:, [0, 2]] * scale + dw\n", + " gt_boxes[:, [1, 3]] = gt_boxes[:, [1, 3]] * scale + dh\n", + " return image_padded, gt_boxes" + ] + }, + { + "cell_type": "markdown", + "id": "2d86e239", + "metadata": { + "id": "2d86e239" + }, + "source": [ + "### Check file paths\n", + "\n", + "`check_model_extention` is a helper function which checks if the model is present in the location specified. \n", + "It also validates the model by checking the model file extension. The expected model file should be of `.onnx` format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ad33e3d", + "metadata": { + "id": "2ad33e3d" + }, + "outputs": [], + "source": [ + "def check_model_extension(fp):\n", + " # Split the extension from the path and normalise it to lowercase.\n", + " ext = os.path.splitext(fp)[-1].lower()\n", + "\n", + " # Now we can simply use != to check for inequality, no need for wildcards.\n", + " if(ext != \".onnx\"):\n", + " raise Exception(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", + " \n", + " if not os.path.exists(fp):\n", + " raise Exception(\"[ ERROR ] Path of the onnx model file is Invalid\")" + ] + }, + { + "cell_type": "markdown", + "id": "38c0ebb9", + "metadata": { + "id": "38c0ebb9" + }, + "source": [ + "## Postprocess" + ] + }, + { + "cell_type": "markdown", + "id": "9f7fe3af", + "metadata": { + "id": "9f7fe3af" + }, + "source": [ + "### Defines anchor boxes" + ] + }, + { + "cell_type": "markdown", + "id": "53492b22", + "metadata": { + "id": "53492b22" + }, + "source": [ + "\n", + "Anchor boxes are a set of predefined bounding boxes of a certain height and width. These boxes are defined to capture the scale and aspect ratio of specific object classes we want to detect and are typically chosen based on object sizes in the training datasets. The use of anchor boxes improves the speed and efficiency for the detection portion of a deep learning neural network framework. Anchor boxes, facilitates the evaluation of object predictions at once, making real-time object detection systems possible.\n", + "\n", + "The following function takes the anchor box prediction probabilities and refines it corresponding to the tiled anchor boxes of the input image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3478f30", + "metadata": { + "id": "f3478f30" + }, + "outputs": [], + "source": [ + "def postprocess_bbbox(pred_bbox):\n", + " for i, pred in enumerate(pred_bbox):\n", + " conv_shape = pred.shape\n", + " output_size = conv_shape[1]\n", + " conv_raw_dxdy = pred[:, :, :, :, 0:2]\n", + " conv_raw_dwdh = pred[:, :, :, :, 2:4]\n", + " xy_grid = np.meshgrid(np.arange(output_size), np.arange(output_size))\n", + " xy_grid = np.expand_dims(np.stack(xy_grid, axis=-1), axis=2)\n", + "\n", + " xy_grid = np.tile(np.expand_dims(xy_grid, axis=0), [1, 1, 1, 3, 1])\n", + " xy_grid = xy_grid.astype(float)\n", + "\n", + " pred_xy = ((special.expit(conv_raw_dxdy) * XYSCALE[i]) - 0.5 * (XYSCALE[i] - 1) + xy_grid) * STRIDES[i]\n", + " pred_wh = (np.exp(conv_raw_dwdh) * ANCHORS[i])\n", + " pred[:, :, :, :, 0:4] = np.concatenate([pred_xy, pred_wh], axis=-1)\n", + "\n", + " pred_bbox = [np.reshape(x, (-1, np.shape(x)[-1])) for x in pred_bbox]\n", + " pred_bbox = np.concatenate(pred_bbox, axis=0)\n", + " return pred_bbox" + ] + }, + { + "cell_type": "markdown", + "id": "176a4ec6", + "metadata": { + "id": "176a4ec6" + }, + "source": [ + "### Removes boundary boxs with a low detection probability" + ] + }, + { + "cell_type": "markdown", + "id": "6dca198c", + "metadata": { + "id": "6dca198c" + }, + "source": [ + "The following function takes input as the prediction boxes (obtained by the previous function) and processes them to create bounding boxes. It also gets rid of certain prediction boxes based on a score threshold value." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c82a10a", + "metadata": { + "id": "3c82a10a" + }, + "outputs": [], + "source": [ + "def postprocess_boxes(pred_bbox, org_img_shape, input_size, score_threshold):\n", + " valid_scale=[0, np.inf]\n", + " pred_bbox = np.array(pred_bbox)\n", + "\n", + " pred_xywh = pred_bbox[:, 0:4]\n", + " pred_conf = pred_bbox[:, 4]\n", + " pred_prob = pred_bbox[:, 5:]\n", + "\n", + " # # (1) (x, y, w, h) --> (xmin, ymin, xmax, ymax)\n", + " pred_coor = np.concatenate([pred_xywh[:, :2] - pred_xywh[:, 2:] * 0.5,\n", + " pred_xywh[:, :2] + pred_xywh[:, 2:] * 0.5], axis=-1)\n", + " # # (2) (xmin, ymin, xmax, ymax) -> (xmin_org, ymin_org, xmax_org, ymax_org)\n", + " org_h, org_w = org_img_shape\n", + " resize_ratio = min(input_size / org_w, input_size / org_h)\n", + "\n", + " dw = (input_size - resize_ratio * org_w) / 2\n", + " dh = (input_size - resize_ratio * org_h) / 2\n", + "\n", + " pred_coor[:, 0::2] = 1.0 * (pred_coor[:, 0::2] - dw) / resize_ratio\n", + " pred_coor[:, 1::2] = 1.0 * (pred_coor[:, 1::2] - dh) / resize_ratio\n", + "\n", + " # # (3) clip some boxes that are out of range\n", + " pred_coor = np.concatenate([np.maximum(pred_coor[:, :2], [0, 0]),\n", + " np.minimum(pred_coor[:, 2:], [org_w - 1, org_h - 1])], axis=-1)\n", + " invalid_mask = np.logical_or((pred_coor[:, 0] > pred_coor[:, 2]), (pred_coor[:, 1] > pred_coor[:, 3]))\n", + " pred_coor[invalid_mask] = 0\n", + "\n", + " # # (4) discard some invalid boxes\n", + " bboxes_scale = np.sqrt(np.multiply.reduce(pred_coor[:, 2:4] - pred_coor[:, 0:2], axis=-1))\n", + " scale_mask = np.logical_and((valid_scale[0] < bboxes_scale), (bboxes_scale < valid_scale[1]))\n", + "\n", + " # # (5) discard some boxes with low scores\n", + " classes = np.argmax(pred_prob, axis=-1)\n", + " scores = pred_conf * pred_prob[np.arange(len(pred_coor)), classes]\n", + " score_mask = scores > score_threshold\n", + " mask = np.logical_and(scale_mask, score_mask)\n", + " coors, scores, classes = pred_coor[mask], scores[mask], classes[mask]\n", + "\n", + " return np.concatenate([coors, scores[:, np.newaxis], classes[:, np.newaxis]], axis=-1)" + ] + }, + { + "cell_type": "markdown", + "id": "050c9844", + "metadata": { + "id": "050c9844" + }, + "source": [ + "### Calculate the Intersection Over Union value" + ] + }, + { + "cell_type": "markdown", + "id": "72b703d4", + "metadata": { + "id": "72b703d4" + }, + "source": [ + "Intersection over Union (IoU) is an evaluation technique for understanding how well the model is performing. However, during the time of inference, it is used to suppress the bounding-boxes that have a high IoU value with the bounding box with maximum probability." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6df6791", + "metadata": { + "id": "d6df6791" + }, + "outputs": [], + "source": [ + "def bboxes_iou(boxes1, boxes2):\n", + " boxes1 = np.array(boxes1)\n", + " boxes2 = np.array(boxes2)\n", + "\n", + " boxes1_area = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])\n", + " boxes2_area = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])\n", + "\n", + " left_up = np.maximum(boxes1[..., :2], boxes2[..., :2])\n", + " right_down = np.minimum(boxes1[..., 2:], boxes2[..., 2:])\n", + "\n", + " inter_section = np.maximum(right_down - left_up, 0.0)\n", + " inter_area = inter_section[..., 0] * inter_section[..., 1]\n", + " union_area = boxes1_area + boxes2_area - inter_area\n", + " ious = np.maximum(1.0 * inter_area / union_area, np.finfo(np.float32).eps)\n", + "\n", + " return ious" + ] + }, + { + "cell_type": "markdown", + "id": "b82006d4", + "metadata": { + "id": "b82006d4" + }, + "source": [ + "### Non Max Suppression: select the most appropriate bounding box\n" + ] + }, + { + "cell_type": "markdown", + "id": "0616b442", + "metadata": { + "id": "0616b442" + }, + "source": [ + "It is the process of taking the boxes with maximum probability and suppressing the near-by boxes with non-max probabilities. \n", + "This is process is repeated until for a single object-class only one box is remaining." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baec34ba", + "metadata": { + "id": "baec34ba" + }, + "outputs": [], + "source": [ + "def nms(bboxes, iou_threshold, sigma=0.3, method='nms'):\n", + " \"\"\"\n", + " :param bboxes: (xmin, ymin, xmax, ymax, score, class)\n", + " Note: soft-nms, https://arxiv.org/pdf/1704.04503.pdf\n", + " https://github.com/bharatsingh430/soft-nms\n", + " \"\"\"\n", + " classes_in_img = list(set(bboxes[:, 5]))\n", + " best_bboxes = []\n", + "\n", + " for cls in classes_in_img:\n", + " cls_mask = (bboxes[:, 5] == cls)\n", + " cls_bboxes = bboxes[cls_mask]\n", + "\n", + " while len(cls_bboxes) > 0:\n", + " max_ind = np.argmax(cls_bboxes[:, 4])\n", + " best_bbox = cls_bboxes[max_ind]\n", + " best_bboxes.append(best_bbox)\n", + " cls_bboxes = np.concatenate([cls_bboxes[: max_ind], cls_bboxes[max_ind + 1:]])\n", + " iou = bboxes_iou(best_bbox[np.newaxis, :4], cls_bboxes[:, :4])\n", + " weight = np.ones((len(iou),), dtype=np.float32)\n", + "\n", + " assert method in ['nms', 'soft-nms']\n", + "\n", + " if method == 'nms':\n", + " iou_mask = iou > iou_threshold\n", + " weight[iou_mask] = 0.0\n", + "\n", + " if method == 'soft-nms':\n", + " weight = np.exp(-(1.0 * iou ** 2 / sigma))\n", + "\n", + " cls_bboxes[:, 4] = cls_bboxes[:, 4] * weight\n", + " score_mask = cls_bboxes[:, 4] > 0.\n", + " cls_bboxes = cls_bboxes[score_mask]\n", + "\n", + " return best_bboxes" + ] + }, + { + "cell_type": "markdown", + "id": "a01bb4ca", + "metadata": { + "id": "a01bb4ca" + }, + "source": [ + "### Load class name from a file" + ] + }, + { + "cell_type": "markdown", + "id": "f7e95103", + "metadata": { + "id": "f7e95103" + }, + "source": [ + "- 80 different classes: person, bicycle, car, motorbike, aeroplane, bus, train, truck, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dbced12b", + "metadata": { + "id": "dbced12b" + }, + "outputs": [], + "source": [ + "def read_class_names(class_file_name):\n", + " names = {}\n", + " with open(class_file_name, 'r') as data:\n", + " for ID, name in enumerate(data):\n", + " names[ID] = name.strip('\\n')\n", + " return names" + ] + }, + { + "cell_type": "markdown", + "id": "f10420fe", + "metadata": { + "id": "f10420fe" + }, + "source": [ + "### Output an image with all the bounding boxes" + ] + }, + { + "cell_type": "markdown", + "id": "542f85d8", + "metadata": { + "id": "542f85d8" + }, + "source": [ + "Below function is an helper function to draw the bounding box in the input image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "def814e0", + "metadata": { + "id": "def814e0" + }, + "outputs": [], + "source": [ + "def draw_bbox(image, bboxes, classes=read_class_names(\"coco.names\"), show_label=True):\n", + " \"\"\"\n", + " bboxes: [x_min, y_min, x_max, y_max, probability, cls_id] format coordinates.\n", + " \"\"\"\n", + "\n", + " num_classes = len(classes)\n", + " image_h, image_w, _ = image.shape\n", + " hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]\n", + " colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n", + " colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))\n", + "\n", + " random.seed(0)\n", + " random.shuffle(colors)\n", + " random.seed(None)\n", + "\n", + " for i, bbox in enumerate(bboxes):\n", + " coor = np.array(bbox[:4], dtype=np.int32)\n", + " fontScale = 0.5\n", + " score = bbox[4]\n", + " class_ind = int(bbox[5])\n", + " bbox_color = colors[class_ind]\n", + " bbox_thick = int(0.6 * (image_h + image_w) / 600)\n", + " c1, c2 = (coor[0], coor[1]), (coor[2], coor[3])\n", + " cv2.rectangle(image, c1, c2, bbox_color, bbox_thick)\n", + "\n", + " if show_label:\n", + " bbox_mess = '%s: %.2f' % (classes[class_ind], score)\n", + " t_size = cv2.getTextSize(bbox_mess, 0, fontScale, thickness=bbox_thick//2)[0]\n", + " cv2.rectangle(image, c1, (c1[0] + t_size[0], c1[1] - t_size[1] - 3), bbox_color, -1)\n", + " cv2.putText(image, bbox_mess, (c1[0], c1[1]-2), cv2.FONT_HERSHEY_SIMPLEX,\n", + " fontScale, (0, 0, 0), bbox_thick//2, lineType=cv2.LINE_AA)\n", + " print('{} detected in frame with {}% probability '.format(classes[class_ind], score*100))\n", + " \n", + " return image" + ] + }, + { + "cell_type": "markdown", + "id": "9aff6a84", + "metadata": { + "id": "9aff6a84" + }, + "source": [ + "### Load the anchors from a file" + ] + }, + { + "cell_type": "markdown", + "id": "b1ca5c16", + "metadata": { + "id": "b1ca5c16" + }, + "source": [ + "The predefined anchors for the data-set on which the YoloV4 model was trained are loaded." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2e8b7fc", + "metadata": { + "id": "c2e8b7fc" + }, + "outputs": [], + "source": [ + "def get_anchors(anchors_path, tiny=False):\n", + " with open(anchors_path) as f:\n", + " anchors = f.readline()\n", + " anchors = np.array(anchors.split(','), dtype=np.float32)\n", + " return anchors.reshape(3, 3, 2)" + ] + }, + { + "cell_type": "markdown", + "id": "410bbc8d", + "metadata": { + "id": "410bbc8d" + }, + "source": [ + "## Inference" + ] + }, + { + "cell_type": "markdown", + "id": "e440c091", + "metadata": { + "id": "e440c091" + }, + "source": [ + "### Create a session for inference based on the device selected" + ] + }, + { + "cell_type": "markdown", + "id": "acb0a5ab", + "metadata": { + "id": "acb0a5ab" + }, + "source": [ + "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", + " \n", + "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", + "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", + "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", + "\n", + "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", + "\n", + "The device option should be chosen from any one of the below options: \n", + "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b8ceece", + "metadata": { + "id": "8b8ceece" + }, + "outputs": [], + "source": [ + "def create_sess(device):\n", + " so = rt.SessionOptions()\n", + " so.log_severity_level = 3\n", + " if (device == 'cpu'):\n", + " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", + " #Specify the path to the ONNX model on your machine and register the CPU EP\n", + " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", + " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", + " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", + " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", + " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", + " '''\n", + " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", + " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", + " '''\n", + " else:\n", + " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", + "\n", + " # Get the input name of the model\n", + " input_name = sess.get_inputs()[0].name\n", + "\n", + " return sess, input_name" + ] + }, + { + "cell_type": "markdown", + "id": "94bbfc56", + "metadata": { + "id": "94bbfc56" + }, + "source": [ + "### Specify the path to anchors file on your machine" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef9d3383", + "metadata": { + "id": "ef9d3383" + }, + "outputs": [], + "source": [ + "ANCHORS = \"yolov4_anchors.txt\" \n", + "STRIDES = [8, 16, 32]\n", + "XYSCALE = [1.2, 1.1, 1.05]\n", + "ANCHORS = get_anchors(ANCHORS)\n", + "STRIDES = np.array(STRIDES)" + ] + }, + { + "cell_type": "markdown", + "id": "c66ab52f", + "metadata": { + "id": "c66ab52f" + }, + "source": [ + "### Specify the path to model, and image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c968df7", + "metadata": { + "id": "7c968df7" + }, + "outputs": [], + "source": [ + "model = \"yolov4.onnx\"\n", + "image = \"cat.jpg\"" + ] + }, + { + "cell_type": "markdown", + "id": "00e6b53e", + "metadata": { + "id": "00e6b53e" + }, + "source": [ + "### Validate model file path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3031833b", + "metadata": { + "id": "3031833b" + }, + "outputs": [], + "source": [ + "check_model_extension(model)" + ] + }, + { + "cell_type": "markdown", + "id": "d446b2cf", + "metadata": { + "id": "d446b2cf" + }, + "source": [ + "### Setup input and output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bff0f18", + "metadata": { + "id": "3bff0f18" + }, + "outputs": [], + "source": [ + "if (image):\n", + " # Open the image file\n", + " if not os.path.isfile(image):\n", + " print(\"Input image file \", image, \" doesn't exist\")\n", + " sys.exit(1)\n", + " cap = cv2.imread(image)\n", + " output_file = image[:-4]+'_yolov4_out_py.jpg'" + ] + }, + { + "cell_type": "markdown", + "id": "83da97e8", + "metadata": { + "id": "83da97e8" + }, + "source": [ + "### Run the inference with CPU Execution Provider " + ] + }, + { + "cell_type": "markdown", + "id": "0b265eee", + "metadata": { + "id": "0b265eee" + }, + "source": [ + "Now the `yolov4.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", + "- `cpu`: default CPU Execution Provider (MLAS) \n", + "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", + "\n", + "The below code block performs the following operations:\n", + "\n", + "1. Creates a Onnx Runtime Session using `cpu` as device\n", + "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", + "3. Performs prediction on the same image for $100$-times\n", + "4. Calculates average inference time\n", + "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e2091e9", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 439 + }, + "id": "7e2091e9", + "outputId": "774325bb-e9cc-4649-ce69-297d9102bacb" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\n", + "PREDICTION - BEGIN\n", + "Avg Inference time in ms: 1200.997841\n", + "PREDICTION - END\n", + "cat detected in frame with 97.1569299697876% probability \n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "### create a session with cpu which is the default CPU Execution Provider\n", + "sess, input_name = create_sess(\"cpu\")\n", + "\n", + "input_size = 416\n", + "original_image = cap.copy()\n", + "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", + "original_image_size = original_image.shape[:2]\n", + "\n", + "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", + "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", + "\n", + "outputs = sess.get_outputs()\n", + "output_names = list(map(lambda output: output.name, outputs))\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(output_names, {input_name: image_data})\n", + "\n", + "start = time.time()\n", + "for i in range(100):\n", + " detections = sess.run(output_names, {input_name: image_data})\n", + "\n", + "end = time.time()\n", + "inference_time = end - start\n", + "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", + "print(\"PREDICTION - END\") \n", + "\n", + "pred_bbox = postprocess_bbbox(detections)\n", + "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", + "bboxes = nms(bboxes, 0.213, method='nms')\n", + "image_out = draw_bbox(original_image, bboxes)\n", + "\n", + "cv2.putText(image_out,\"cpu\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + "\n", + "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", + "cv2_imshow(image_out)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", + "\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "2a86773c", + "metadata": { + "id": "2a86773c" + }, + "source": [ + "### Run the inference **with** OpenVINO Execution Provider" + ] + }, + { + "cell_type": "markdown", + "id": "8c04daa0", + "metadata": { + "id": "8c04daa0" + }, + "source": [ + "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a72e6bf7", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "a72e6bf7", + "outputId": "b5a207ac-7c1f-42f2-eb8f-0b4aaa72f273" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device type selected is: CPU_FP32 using the OpenVINO Execution Provider\n", + "PREDICTION - BEGIN\n", + "Avg Inference time in ms: 1038.376327\n", + "PREDICTION - END\n", + "cat detected in frame with 97.15692400932312% probability \n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", + "sess, input_name = create_sess(\"CPU_FP32\")\n", + "\n", + "input_size = 416\n", + "original_image = cap.copy()\n", + "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", + "original_image_size = original_image.shape[:2]\n", + "\n", + "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", + "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", + "\n", + "outputs = sess.get_outputs()\n", + "output_names = list(map(lambda output: output.name, outputs))\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(output_names, {input_name: image_data})\n", + "\n", + "start = time.time()\n", + "for i in range(100):\n", + " detections = sess.run(output_names, {input_name: image_data})\n", + "\n", + "end = time.time()\n", + "inference_time = end - start\n", + "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", + "print(\"PREDICTION - END\") \n", + "\n", + "pred_bbox = postprocess_bbbox(detections)\n", + "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", + "bboxes = nms(bboxes, 0.213, method='nms')\n", + "image_out = draw_bbox(original_image, bboxes)\n", + "\n", + "cv2.putText(image_out,\"CPU_FP32\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + "\n", + "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", + "cv2_imshow(image_out)\n", + "\n", + "print('\\n')\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", + "\n", + "print('\\n')" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "OVEP_yolov4_obj_detection_sample.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.8.10 ('yolov4': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "vscode": { + "interpreter": { + "hash": "7c4a41788a1f5a54de98941c88996114c38916598df611346d841c8cb6d26f64" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From d41a518ca20a099c6c8857e76fe942aca5b8282f Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Thu, 25 Aug 2022 12:02:45 +0530 Subject: [PATCH 02/15] folder restucturing for notebooks --- ...VEP_tiny_yolov2_obj_detection_sample.ipynb | 649 ++++++++++++ .../OVEP_yolov4_obj_detection_sample.ipynb | 979 ++++++++++++++++++ 2 files changed, 1628 insertions(+) create mode 100644 python/OpenVINO_EP/tiny_yolo_v2_object_detection/notebooks/OVEP_tiny_yolov2_obj_detection_sample.ipynb create mode 100644 python/OpenVINO_EP/yolov4_object_detection/notebooks/OVEP_yolov4_obj_detection_sample.ipynb diff --git a/python/OpenVINO_EP/tiny_yolo_v2_object_detection/notebooks/OVEP_tiny_yolov2_obj_detection_sample.ipynb b/python/OpenVINO_EP/tiny_yolo_v2_object_detection/notebooks/OVEP_tiny_yolov2_obj_detection_sample.ipynb new file mode 100644 index 000000000..1c19c0b96 --- /dev/null +++ b/python/OpenVINO_EP/tiny_yolo_v2_object_detection/notebooks/OVEP_tiny_yolov2_obj_detection_sample.ipynb @@ -0,0 +1,649 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6330a8a6", + "metadata": { + "id": "6330a8a6" + }, + "source": [ + "Copyright (C) 2021-2022, Intel Corporation\n", + "\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "id": "aa6f534b", + "metadata": { + "id": "aa6f534b" + }, + "source": [ + "# Object detection with tiny YOLOv2 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a tinyYOLOv2 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "\n", + "\n", + "2. The sample involves presenting an Image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 20 different objects like birds, buses, cars, people and much more.\n", + "\n", + "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/tiny_yolo_v2_object_detection)." + ] + }, + { + "cell_type": "markdown", + "id": "b2c9aa57", + "metadata": { + "id": "b2c9aa57" + }, + "source": [ + "### Install Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "809559b8", + "metadata": { + "id": "809559b8" + }, + "outputs": [], + "source": [ + "!pip -q install --upgrade pip\n", + "!pip -q install folium==0.2.1\n", + "!pip -q install imgaug==0.2.6\n", + "!pip -q install certifi==2022.5.18.1\n", + "!pip -q install flatbuffers==2.0\n", + "!pip -q install numpy==1.21.6\n", + "!pip -q install onnx==1.11.0\n", + "!pip -q install opencv-python==4.5.5.64\n", + "!pip -q install scipy==1.7.3\n", + "!pip -q install typing-extensions==4.1.1\n", + "!pip -q install onnxruntime-openvino==1.11.0" + ] + }, + { + "cell_type": "markdown", + "id": "24d73115", + "metadata": { + "id": "24d73115" + }, + "source": [ + "### Import Necessary Resources" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f72e3ca", + "metadata": { + "id": "6f72e3ca" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import onnxruntime as rt\n", + "import cv2\n", + "import time\n", + "import os\n", + "from pathlib import Path\n", + "import argparse\n", + "import platform\n", + "from google.colab.patches import cv2_imshow\n", + "import sys" + ] + }, + { + "cell_type": "markdown", + "id": "9399694a", + "metadata": { + "id": "9399694a" + }, + "source": [ + "### Get the model and input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2b38cc9", + "metadata": { + "id": "e2b38cc9" + }, + "outputs": [], + "source": [ + "#Create List of files in the directory\n", + "files = os.listdir('.')\n", + "\n", + "#Get the neccesary files into the directory if they don't already exist\n", + "if ('tinyyolov2-8.onnx' not in files):\n", + " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/tiny-yolov2/model/tinyyolov2-8.onnx?raw=true -O tinyyolov2-8.onnx\n", + "if ('dog.bmp' not in files):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/512x512/dog.bmp" + ] + }, + { + "cell_type": "markdown", + "id": "ceff9a38", + "metadata": { + "id": "ceff9a38" + }, + "source": [ + "## Preprocess" + ] + }, + { + "cell_type": "markdown", + "id": "cb2dd5ca", + "metadata": { + "id": "cb2dd5ca" + }, + "source": [ + "### Reshape the input to align with the model\n", + "\n", + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image is re-shaped to the desired image size i.e. $(416 \\times 416)$ using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34a2817f", + "metadata": { + "id": "34a2817f" + }, + "outputs": [], + "source": [ + "def image_preprocess(frame):\n", + " in_frame = cv2.resize(frame, (416, 416))\n", + " preprocessed_image = np.asarray(in_frame)\n", + " preprocessed_image = preprocessed_image.astype(np.float32)\n", + " preprocessed_image = preprocessed_image.transpose(2,0,1)\n", + " #Reshaping the input array to align with the input shape of the model\n", + " preprocessed_image = preprocessed_image.reshape(1,3,416,416)\n", + " return preprocessed_image" + ] + }, + { + "cell_type": "markdown", + "id": "6dbc9aa8", + "metadata": { + "id": "6dbc9aa8" + }, + "source": [ + "### Check file paths\n", + "\n", + "`check_model_extention` is a helper function which checks if the model is present in the location specified. It also validates the model by checking the model file extension. \n", + "The expected model file should be of `.onnx` format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca5d9356", + "metadata": { + "id": "ca5d9356" + }, + "outputs": [], + "source": [ + "def check_model_extension(fp):\n", + " # Split the extension from the path and normalise it to lowercase.\n", + " ext = Path(fp).suffix.lower()\n", + "\n", + " # Now we can simply use != to check for inconsitencies with model file.\n", + " if(ext != \".onnx\"):\n", + " raise NameError(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", + " \n", + " if not Path(fp).exists():\n", + " raise OSError(\"[ ERROR ] Path of the onnx model file is Invalid\")" + ] + }, + { + "cell_type": "markdown", + "id": "bfc0e076", + "metadata": { + "id": "bfc0e076" + }, + "source": [ + "## Postprocess" + ] + }, + { + "cell_type": "markdown", + "id": "fca5634d", + "metadata": { + "id": "fca5634d" + }, + "source": [ + "### Add the appropriate bounding boxes and the class label to the image based on the inference results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a331243", + "metadata": { + "id": "7a331243" + }, + "outputs": [], + "source": [ + "def postprocess_output(out, frame, x_scale, y_scale):\n", + " out = out[0][0]\n", + " num_classes = 20\n", + " anchors = [1.08, 1.19, 3.42, 4.41, 6.63, 11.38, 9.42, 5.11, 16.62, 10.52]\n", + " \n", + " # color look up table for different classes for object detection sample\n", + " clut = [(0,0,0),(255,0,0),(255,0,255),(0,0,255),(0,255,0),(0,255,128),\n", + " (128,255,0),(128,128,0),(0,128,255),(128,0,128),\n", + " (255,0,128),(128,0,255),(255,128,128),(128,255,128),(255,255,0),\n", + " (255,128,128),(128,128,255),(255,128,128),(128,255,128),(128,255,128)]\n", + "\n", + " # 20 labels that the tiny-yolov2 model can do the object_detection on\n", + " label = [\"aeroplane\",\"bicycle\",\"bird\",\"boat\",\"bottle\",\n", + " \"bus\",\"car\",\"cat\",\"chair\",\"cow\",\"diningtable\",\n", + " \"dog\",\"horse\",\"motorbike\",\"person\",\"pottedplant\",\n", + " \"sheep\",\"sofa\",\"train\",\"tvmonitor\"]\n", + "\n", + " existing_labels = {l: [] for l in label}\n", + "\n", + " #Inside this loop we compute the bounding box b for grid cell (cy, cx)\n", + " for cy in range(0,13):\n", + " for cx in range(0,13):\n", + " for b in range(0,5):\n", + " # First we read the tx, ty, width(tw), and height(th) for the bounding box from the out array, as well as the confidence score\n", + " channel = b*(num_classes+5)\n", + " tx = out[channel ][cy][cx]\n", + " ty = out[channel+1][cy][cx]\n", + " tw = out[channel+2][cy][cx]\n", + " th = out[channel+3][cy][cx]\n", + " tc = out[channel+4][cy][cx]\n", + "\n", + " x = (float(cx) + sigmoid(tx))*32\n", + " y = (float(cy) + sigmoid(ty))*32\n", + " w = np.exp(tw) * 32 * anchors[2*b]\n", + " h = np.exp(th) * 32 * anchors[2*b+1]\n", + "\n", + " #calculating the confidence score\n", + " confidence = sigmoid(tc) # The confidence value for the bounding box is given by tc\n", + " classes = np.zeros(num_classes)\n", + " for c in range(0,num_classes):\n", + " classes[c] = out[channel + 5 +c][cy][cx]\n", + " # we take the softmax to turn the array into a probability distribution. And then we pick the class with the largest score as the winner.\n", + " classes = softmax(classes)\n", + " detected_class = classes.argmax()\n", + " # Now we can compute the final score for this bounding box and we only want to keep the ones whose combined score is over a certain threshold\n", + " if 0.75 < classes[detected_class]*confidence:\n", + " color =clut[detected_class]\n", + " x = (x - w/2)*x_scale\n", + " y = (y - h/2)*y_scale\n", + " w *= x_scale\n", + " h *= y_scale\n", + " \n", + " labelX = int((x+x+w)/2)\n", + " labelY = int((y+y+h)/2)\n", + " addLabel = True\n", + " lab_threshold = 100\n", + " for point in existing_labels[label[detected_class]]:\n", + " if labelX < point[0] + lab_threshold and labelX > point[0] - lab_threshold and \\\n", + " labelY < point[1] + lab_threshold and labelY > point[1] - lab_threshold:\n", + " addLabel = False\n", + " #Adding class labels to the output of the frame and also drawing a rectangular bounding box around the object detected.\n", + " if addLabel:\n", + " bbox_mess = f'{label[detected_class]}:{classes[detected_class]*confidence:.3f}'\n", + " cv2.rectangle(frame, (int(x),int(y)),(int(x+w),int(y+h)),color,2)\n", + " cv2.rectangle(frame, (int(x),int(y-13)),(int(x)+9*len(bbox_mess),int(y)),color,-1)\n", + " cv2.putText(frame,bbox_mess,(int(x)+2,int(y)-3),cv2.FONT_HERSHEY_COMPLEX,0.4,(255,255,255),1)\n", + " existing_labels[label[detected_class]].append((labelX,labelY))\n", + " print(f'{label[detected_class]} detected in frame with {classes[detected_class]*confidence*100}% probability ')" + ] + }, + { + "cell_type": "markdown", + "id": "86200685", + "metadata": { + "id": "86200685" + }, + "source": [ + "### Show the image with the bounding boxes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ff22f1f", + "metadata": { + "id": "4ff22f1f" + }, + "outputs": [], + "source": [ + "def show_bbox(device, frame, inference_time):\n", + " cv2.putText(frame,device,(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", + " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", + " cv2_imshow(frame)" + ] + }, + { + "cell_type": "markdown", + "id": "2a609551", + "metadata": { + "id": "2a609551" + }, + "source": [ + "### sigmoid and softmax functions to make sense of infrence output for the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b22f9ad", + "metadata": { + "id": "7b22f9ad" + }, + "outputs": [], + "source": [ + "def sigmoid(x, derivative=False):\n", + " return x*(1-x) if derivative else 1/(1+np.exp(-x))\n", + "\n", + "def softmax(x):\n", + " score_mat_exp = np.exp(np.asarray(x))\n", + " return score_mat_exp / score_mat_exp.sum(0)" + ] + }, + { + "cell_type": "markdown", + "id": "xEQDTN4xKgfs", + "metadata": { + "id": "xEQDTN4xKgfs" + }, + "source": [ + "## Inference" + ] + }, + { + "cell_type": "markdown", + "id": "7617f559", + "metadata": { + "id": "7617f559" + }, + "source": [ + "### Create a session for inference based on the device selected\n", + "\n", + "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", + " \n", + "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", + "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", + "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", + "\n", + "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", + "\n", + "The device option should be chosen from any one of the below options: \n", + "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "438b7b76", + "metadata": { + "id": "438b7b76" + }, + "outputs": [], + "source": [ + "def create_sess(device):\n", + " so = rt.SessionOptions()\n", + " so.log_severity_level = 3\n", + " if (device == 'cpu'):\n", + " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", + " #Specify the path to the ONNX model on your machine and register the CPU EP\n", + " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", + " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", + " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", + " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", + " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", + " '''\n", + " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", + " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", + " '''\n", + " else:\n", + " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", + "\n", + " # Get the input name of the model\n", + " input_name = sess.get_inputs()[0].name\n", + "\n", + " return sess, input_name" + ] + }, + { + "cell_type": "markdown", + "id": "d1a39044", + "metadata": { + "id": "d1a39044" + }, + "source": [ + "### Specify the device and path to model, Image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39fec459", + "metadata": { + "id": "39fec459" + }, + "outputs": [], + "source": [ + "model = \"tinyyolov2-8.onnx\"\n", + "image = \"dog.bmp\"" + ] + }, + { + "cell_type": "markdown", + "id": "3df2a717", + "metadata": { + "id": "3df2a717" + }, + "source": [ + "### Validate model file path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d29f8f8", + "metadata": { + "id": "4d29f8f8" + }, + "outputs": [], + "source": [ + "check_model_extension(model)" + ] + }, + { + "cell_type": "markdown", + "id": "j5QfFB1PJ_uq", + "metadata": { + "id": "j5QfFB1PJ_uq" + }, + "source": [ + "### Setup input and output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "DX-C07_3zcck", + "metadata": { + "id": "DX-C07_3zcck" + }, + "outputs": [], + "source": [ + "if (image):\n", + " \n", + " #Check if image file exists\n", + " if not Path(image).is_file():\n", + " raise OSError(\"Input image file \", image, \" doesn't exist as a file\")\n", + "\n", + " # Open the image file\n", + " cap = cv2.imread(image)\n", + "\n", + " height, width, c = cap.shape\n", + " x_scale = float(width)/416.0 #In the document of tino-yolo-v2, input shape of this network is (1,3,416,416).\n", + " y_scale = float(height)/416.0\n", + "\n", + " output_file = Path(image).stem+'_tiny_yolov2_out_py.jpg'" + ] + }, + { + "cell_type": "markdown", + "id": "2SgMAeXVfQrR", + "metadata": { + "id": "2SgMAeXVfQrR" + }, + "source": [ + "### Run the inference with default CPU Execution Provider \n", + "\n", + "Now the `tinyyolov2-8.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", + "- `cpu`: default CPU Execution Provider (MLAS) \n", + "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", + "\n", + "The below code block performs the following operations:\n", + "\n", + "1. Creates a Onnx Runtime Session using `cpu` as device\n", + "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", + "3. Performs prediction on the same image for $100$-times\n", + "4. Calculates average inference time\n", + "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1sssvylKfR_0", + "metadata": { + "id": "1sssvylKfR_0" + }, + "outputs": [], + "source": [ + "### create a session with cpu which is the default CPU Execution Provider\n", + "sess, input_name = create_sess(\"cpu\")\n", + "\n", + "#capturing one frame at a time from the video feed and performing the inference\n", + "frame = cap.copy()\n", + "\n", + "#preprocessing the input frame and reshaping it.\n", + "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", + "preprocessed_image = image_preprocess(frame)\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "start = time.perf_counter()\n", + "#Running the session by passing in the input data of the model\n", + "for i in range(100):\n", + " out = sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "end = time.perf_counter()\n", + "inference_time = end - start\n", + "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", + "print(\"PREDICTION - END\")\n", + "\n", + "#Get the output\n", + "postprocess_output(out, frame, x_scale, y_scale)\n", + "\n", + "#Show the output\n", + "show_bbox(\"cpu\", frame, inference_time)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, frame.astype(np.uint8))\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "XUkRaU9uI0zX", + "metadata": { + "id": "XUkRaU9uI0zX" + }, + "source": [ + "### Run the inference with OpenVINO Execution Provider\n", + "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b5517d1", + "metadata": { + "id": "8b5517d1" + }, + "outputs": [], + "source": [ + "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", + "sess, input_name = create_sess(\"CPU_FP32\")\n", + "\n", + "#capturing one frame at a time from the video feed and performing the inference\n", + "frame = cap.copy()\n", + "\n", + "#preprocessing the input frame and reshaping it.\n", + "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", + "preprocessed_image = image_preprocess(frame)\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "start = time.perf_counter()\n", + "#Running the session by passing in the input data of the model\n", + "for i in range(100):\n", + " out = sess.run(None, {input_name: preprocessed_image})\n", + "\n", + "end = time.perf_counter()\n", + "inference_time = end - start\n", + "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", + "print(\"PREDICTION - END\")\n", + "\n", + "#Get the output\n", + "postprocess_output(out, frame, x_scale, y_scale)\n", + "\n", + "#Show the output\n", + "show_bbox(\"CPU_FP32\", frame, inference_time)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, frame.astype(np.uint8))\n", + "print('\\n')" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "OVEP_tiny_yolov2_obj_detection_sample.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.8.10 ('tiny_yolovV2': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "vscode": { + "interpreter": { + "hash": "0226610a830f21b877cea989523fd0c295c7466b3cab1c0f323be92db3371acd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov4_object_detection/notebooks/OVEP_yolov4_obj_detection_sample.ipynb b/python/OpenVINO_EP/yolov4_object_detection/notebooks/OVEP_yolov4_obj_detection_sample.ipynb new file mode 100644 index 000000000..e15fd1d31 --- /dev/null +++ b/python/OpenVINO_EP/yolov4_object_detection/notebooks/OVEP_yolov4_obj_detection_sample.ipynb @@ -0,0 +1,979 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b6157254", + "metadata": { + "id": "b6157254" + }, + "source": [ + "Copyright (C) 2021-2022, Intel Corporation\n", + "\n", + "SPDX-License-Identifier: Apache-2.0\n", + "\n", + "Major Portions of this code are copyright of their respective authors and released under the Apache License Version 2.0:\n", + "- onnx, Copyright 2021-2022. For licensing see https://github.com/onnx/models/blob/master/LICENSE" + ] + }, + { + "cell_type": "markdown", + "id": "dfed77f6", + "metadata": { + "id": "dfed77f6" + }, + "source": [ + "# Object detection with YOLOv4 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a YOLOv4 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "\n", + "\n", + "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset.\n", + "\n", + "\n", + "4. Once the inferencing is done on the sample, the recording of the same also gets downloaded on the disk.\n", + "\n", + "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/yolov4_object_detection)." + ] + }, + { + "cell_type": "markdown", + "id": "08dd644b", + "metadata": { + "id": "08dd644b" + }, + "source": [ + "## Install Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d18b13f8", + "metadata": { + "id": "d18b13f8" + }, + "outputs": [], + "source": [ + "!pip -q install --upgrade pip\n", + "!pip -q install folium==0.2.1\n", + "!pip -q install imgaug==0.2.6\n", + "!pip -q install certifi==2022.5.18.1\n", + "!pip -q install flatbuffers==2.0\n", + "!pip -q install numpy==1.21.6\n", + "!pip -q install onnx==1.11.0\n", + "!pip -q install opencv-python==4.5.5.64\n", + "!pip -q install scipy==1.7.3\n", + "!pip -q install typing-extensions==4.1.1\n", + "!pip -q install onnxruntime-openvino==1.11.0" + ] + }, + { + "cell_type": "markdown", + "id": "97b43517", + "metadata": { + "id": "97b43517" + }, + "source": [ + "## Import Necessary Resources" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06698673", + "metadata": { + "id": "06698673" + }, + "outputs": [], + "source": [ + "import cv2\n", + "import numpy as np\n", + "from onnx import numpy_helper\n", + "import onnx\n", + "import onnxruntime as rt\n", + "import os\n", + "from PIL import Image\n", + "from scipy import special\n", + "import colorsys\n", + "import random\n", + "import argparse\n", + "import sys\n", + "import time\n", + "from google.colab.patches import cv2_imshow" + ] + }, + { + "cell_type": "markdown", + "id": "3c7fe112", + "metadata": { + "id": "3c7fe112" + }, + "source": [ + "## Get the model and input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "MtdBsnOeJJkk", + "metadata": { + "id": "MtdBsnOeJJkk" + }, + "outputs": [], + "source": [ + "files = os.listdir('.')\n", + "if ('yolov4_anchors.txt' not in files):\n", + " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/yolov4_anchors.txt\n", + "if ('coco.names' not in files):\n", + " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/coco.names\n", + "if ('yolov4.onnx' not in files):\n", + " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx?raw=true -O yolov4.onnx\n", + "if ('cat.jpg' not in files):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" + ] + }, + { + "cell_type": "markdown", + "id": "71fec400", + "metadata": { + "id": "71fec400" + }, + "source": [ + "## Preprocess" + ] + }, + { + "cell_type": "markdown", + "id": "23e66f38", + "metadata": { + "id": "23e66f38" + }, + "source": [ + "### Reshape the input to align with the model" + ] + }, + { + "cell_type": "markdown", + "id": "a4ba63cf", + "metadata": { + "id": "a4ba63cf" + }, + "source": [ + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", + "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", + "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bab58d5", + "metadata": { + "id": "1bab58d5" + }, + "outputs": [], + "source": [ + "def image_preprocess(image, target_size, gt_boxes=None):\n", + " \n", + " ih, iw = target_size\n", + " h, w, _ = image.shape\n", + "\n", + " scale = min(iw/w, ih/h)\n", + "\n", + " nw, nh = int(scale * w), int(scale * h)\n", + " image_resized = cv2.resize(image, (nw, nh))\n", + "\n", + " image_padded = np.full(shape=[ih, iw, 3], fill_value=128.0)\n", + " dw, dh = (iw - nw) // 2, (ih-nh) // 2\n", + " image_padded[dh:nh+dh, dw:nw+dw, :] = image_resized\n", + " image_padded = image_padded / 255.\n", + "\n", + " if gt_boxes is None:\n", + " return image_padded\n", + "\n", + " else:\n", + " gt_boxes[:, [0, 2]] = gt_boxes[:, [0, 2]] * scale + dw\n", + " gt_boxes[:, [1, 3]] = gt_boxes[:, [1, 3]] * scale + dh\n", + " return image_padded, gt_boxes" + ] + }, + { + "cell_type": "markdown", + "id": "2d86e239", + "metadata": { + "id": "2d86e239" + }, + "source": [ + "### Check file paths\n", + "\n", + "`check_model_extention` is a helper function which checks if the model is present in the location specified. \n", + "It also validates the model by checking the model file extension. The expected model file should be of `.onnx` format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ad33e3d", + "metadata": { + "id": "2ad33e3d" + }, + "outputs": [], + "source": [ + "def check_model_extension(fp):\n", + " # Split the extension from the path and normalise it to lowercase.\n", + " ext = os.path.splitext(fp)[-1].lower()\n", + "\n", + " # Now we can simply use != to check for inequality, no need for wildcards.\n", + " if(ext != \".onnx\"):\n", + " raise Exception(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", + " \n", + " if not os.path.exists(fp):\n", + " raise Exception(\"[ ERROR ] Path of the onnx model file is Invalid\")" + ] + }, + { + "cell_type": "markdown", + "id": "38c0ebb9", + "metadata": { + "id": "38c0ebb9" + }, + "source": [ + "## Postprocess" + ] + }, + { + "cell_type": "markdown", + "id": "9f7fe3af", + "metadata": { + "id": "9f7fe3af" + }, + "source": [ + "### Defines anchor boxes" + ] + }, + { + "cell_type": "markdown", + "id": "53492b22", + "metadata": { + "id": "53492b22" + }, + "source": [ + "\n", + "Anchor boxes are a set of predefined bounding boxes of a certain height and width. These boxes are defined to capture the scale and aspect ratio of specific object classes we want to detect and are typically chosen based on object sizes in the training datasets. The use of anchor boxes improves the speed and efficiency for the detection portion of a deep learning neural network framework. Anchor boxes, facilitates the evaluation of object predictions at once, making real-time object detection systems possible.\n", + "\n", + "The following function takes the anchor box prediction probabilities and refines it corresponding to the tiled anchor boxes of the input image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3478f30", + "metadata": { + "id": "f3478f30" + }, + "outputs": [], + "source": [ + "def postprocess_bbbox(pred_bbox):\n", + " for i, pred in enumerate(pred_bbox):\n", + " conv_shape = pred.shape\n", + " output_size = conv_shape[1]\n", + " conv_raw_dxdy = pred[:, :, :, :, 0:2]\n", + " conv_raw_dwdh = pred[:, :, :, :, 2:4]\n", + " xy_grid = np.meshgrid(np.arange(output_size), np.arange(output_size))\n", + " xy_grid = np.expand_dims(np.stack(xy_grid, axis=-1), axis=2)\n", + "\n", + " xy_grid = np.tile(np.expand_dims(xy_grid, axis=0), [1, 1, 1, 3, 1])\n", + " xy_grid = xy_grid.astype(float)\n", + "\n", + " pred_xy = ((special.expit(conv_raw_dxdy) * XYSCALE[i]) - 0.5 * (XYSCALE[i] - 1) + xy_grid) * STRIDES[i]\n", + " pred_wh = (np.exp(conv_raw_dwdh) * ANCHORS[i])\n", + " pred[:, :, :, :, 0:4] = np.concatenate([pred_xy, pred_wh], axis=-1)\n", + "\n", + " pred_bbox = [np.reshape(x, (-1, np.shape(x)[-1])) for x in pred_bbox]\n", + " pred_bbox = np.concatenate(pred_bbox, axis=0)\n", + " return pred_bbox" + ] + }, + { + "cell_type": "markdown", + "id": "176a4ec6", + "metadata": { + "id": "176a4ec6" + }, + "source": [ + "### Removes boundary boxs with a low detection probability" + ] + }, + { + "cell_type": "markdown", + "id": "6dca198c", + "metadata": { + "id": "6dca198c" + }, + "source": [ + "The following function takes input as the prediction boxes (obtained by the previous function) and processes them to create bounding boxes. It also gets rid of certain prediction boxes based on a score threshold value." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c82a10a", + "metadata": { + "id": "3c82a10a" + }, + "outputs": [], + "source": [ + "def postprocess_boxes(pred_bbox, org_img_shape, input_size, score_threshold):\n", + " valid_scale=[0, np.inf]\n", + " pred_bbox = np.array(pred_bbox)\n", + "\n", + " pred_xywh = pred_bbox[:, 0:4]\n", + " pred_conf = pred_bbox[:, 4]\n", + " pred_prob = pred_bbox[:, 5:]\n", + "\n", + " # # (1) (x, y, w, h) --> (xmin, ymin, xmax, ymax)\n", + " pred_coor = np.concatenate([pred_xywh[:, :2] - pred_xywh[:, 2:] * 0.5,\n", + " pred_xywh[:, :2] + pred_xywh[:, 2:] * 0.5], axis=-1)\n", + " # # (2) (xmin, ymin, xmax, ymax) -> (xmin_org, ymin_org, xmax_org, ymax_org)\n", + " org_h, org_w = org_img_shape\n", + " resize_ratio = min(input_size / org_w, input_size / org_h)\n", + "\n", + " dw = (input_size - resize_ratio * org_w) / 2\n", + " dh = (input_size - resize_ratio * org_h) / 2\n", + "\n", + " pred_coor[:, 0::2] = 1.0 * (pred_coor[:, 0::2] - dw) / resize_ratio\n", + " pred_coor[:, 1::2] = 1.0 * (pred_coor[:, 1::2] - dh) / resize_ratio\n", + "\n", + " # # (3) clip some boxes that are out of range\n", + " pred_coor = np.concatenate([np.maximum(pred_coor[:, :2], [0, 0]),\n", + " np.minimum(pred_coor[:, 2:], [org_w - 1, org_h - 1])], axis=-1)\n", + " invalid_mask = np.logical_or((pred_coor[:, 0] > pred_coor[:, 2]), (pred_coor[:, 1] > pred_coor[:, 3]))\n", + " pred_coor[invalid_mask] = 0\n", + "\n", + " # # (4) discard some invalid boxes\n", + " bboxes_scale = np.sqrt(np.multiply.reduce(pred_coor[:, 2:4] - pred_coor[:, 0:2], axis=-1))\n", + " scale_mask = np.logical_and((valid_scale[0] < bboxes_scale), (bboxes_scale < valid_scale[1]))\n", + "\n", + " # # (5) discard some boxes with low scores\n", + " classes = np.argmax(pred_prob, axis=-1)\n", + " scores = pred_conf * pred_prob[np.arange(len(pred_coor)), classes]\n", + " score_mask = scores > score_threshold\n", + " mask = np.logical_and(scale_mask, score_mask)\n", + " coors, scores, classes = pred_coor[mask], scores[mask], classes[mask]\n", + "\n", + " return np.concatenate([coors, scores[:, np.newaxis], classes[:, np.newaxis]], axis=-1)" + ] + }, + { + "cell_type": "markdown", + "id": "050c9844", + "metadata": { + "id": "050c9844" + }, + "source": [ + "### Calculate the Intersection Over Union value" + ] + }, + { + "cell_type": "markdown", + "id": "72b703d4", + "metadata": { + "id": "72b703d4" + }, + "source": [ + "Intersection over Union (IoU) is an evaluation technique for understanding how well the model is performing. However, during the time of inference, it is used to suppress the bounding-boxes that have a high IoU value with the bounding box with maximum probability." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6df6791", + "metadata": { + "id": "d6df6791" + }, + "outputs": [], + "source": [ + "def bboxes_iou(boxes1, boxes2):\n", + " boxes1 = np.array(boxes1)\n", + " boxes2 = np.array(boxes2)\n", + "\n", + " boxes1_area = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])\n", + " boxes2_area = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])\n", + "\n", + " left_up = np.maximum(boxes1[..., :2], boxes2[..., :2])\n", + " right_down = np.minimum(boxes1[..., 2:], boxes2[..., 2:])\n", + "\n", + " inter_section = np.maximum(right_down - left_up, 0.0)\n", + " inter_area = inter_section[..., 0] * inter_section[..., 1]\n", + " union_area = boxes1_area + boxes2_area - inter_area\n", + " ious = np.maximum(1.0 * inter_area / union_area, np.finfo(np.float32).eps)\n", + "\n", + " return ious" + ] + }, + { + "cell_type": "markdown", + "id": "b82006d4", + "metadata": { + "id": "b82006d4" + }, + "source": [ + "### Non Max Suppression: select the most appropriate bounding box\n" + ] + }, + { + "cell_type": "markdown", + "id": "0616b442", + "metadata": { + "id": "0616b442" + }, + "source": [ + "It is the process of taking the boxes with maximum probability and suppressing the near-by boxes with non-max probabilities. \n", + "This is process is repeated until for a single object-class only one box is remaining." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baec34ba", + "metadata": { + "id": "baec34ba" + }, + "outputs": [], + "source": [ + "def nms(bboxes, iou_threshold, sigma=0.3, method='nms'):\n", + " \"\"\"\n", + " :param bboxes: (xmin, ymin, xmax, ymax, score, class)\n", + " Note: soft-nms, https://arxiv.org/pdf/1704.04503.pdf\n", + " https://github.com/bharatsingh430/soft-nms\n", + " \"\"\"\n", + " classes_in_img = list(set(bboxes[:, 5]))\n", + " best_bboxes = []\n", + "\n", + " for cls in classes_in_img:\n", + " cls_mask = (bboxes[:, 5] == cls)\n", + " cls_bboxes = bboxes[cls_mask]\n", + "\n", + " while len(cls_bboxes) > 0:\n", + " max_ind = np.argmax(cls_bboxes[:, 4])\n", + " best_bbox = cls_bboxes[max_ind]\n", + " best_bboxes.append(best_bbox)\n", + " cls_bboxes = np.concatenate([cls_bboxes[: max_ind], cls_bboxes[max_ind + 1:]])\n", + " iou = bboxes_iou(best_bbox[np.newaxis, :4], cls_bboxes[:, :4])\n", + " weight = np.ones((len(iou),), dtype=np.float32)\n", + "\n", + " assert method in ['nms', 'soft-nms']\n", + "\n", + " if method == 'nms':\n", + " iou_mask = iou > iou_threshold\n", + " weight[iou_mask] = 0.0\n", + "\n", + " if method == 'soft-nms':\n", + " weight = np.exp(-(1.0 * iou ** 2 / sigma))\n", + "\n", + " cls_bboxes[:, 4] = cls_bboxes[:, 4] * weight\n", + " score_mask = cls_bboxes[:, 4] > 0.\n", + " cls_bboxes = cls_bboxes[score_mask]\n", + "\n", + " return best_bboxes" + ] + }, + { + "cell_type": "markdown", + "id": "a01bb4ca", + "metadata": { + "id": "a01bb4ca" + }, + "source": [ + "### Load class name from a file" + ] + }, + { + "cell_type": "markdown", + "id": "f7e95103", + "metadata": { + "id": "f7e95103" + }, + "source": [ + "- 80 different classes: person, bicycle, car, motorbike, aeroplane, bus, train, truck, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dbced12b", + "metadata": { + "id": "dbced12b" + }, + "outputs": [], + "source": [ + "def read_class_names(class_file_name):\n", + " names = {}\n", + " with open(class_file_name, 'r') as data:\n", + " for ID, name in enumerate(data):\n", + " names[ID] = name.strip('\\n')\n", + " return names" + ] + }, + { + "cell_type": "markdown", + "id": "f10420fe", + "metadata": { + "id": "f10420fe" + }, + "source": [ + "### Output an image with all the bounding boxes" + ] + }, + { + "cell_type": "markdown", + "id": "542f85d8", + "metadata": { + "id": "542f85d8" + }, + "source": [ + "Below function is an helper function to draw the bounding box in the input image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "def814e0", + "metadata": { + "id": "def814e0" + }, + "outputs": [], + "source": [ + "def draw_bbox(image, bboxes, classes=read_class_names(\"coco.names\"), show_label=True):\n", + " \"\"\"\n", + " bboxes: [x_min, y_min, x_max, y_max, probability, cls_id] format coordinates.\n", + " \"\"\"\n", + "\n", + " num_classes = len(classes)\n", + " image_h, image_w, _ = image.shape\n", + " hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]\n", + " colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n", + " colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))\n", + "\n", + " random.seed(0)\n", + " random.shuffle(colors)\n", + " random.seed(None)\n", + "\n", + " for i, bbox in enumerate(bboxes):\n", + " coor = np.array(bbox[:4], dtype=np.int32)\n", + " fontScale = 0.5\n", + " score = bbox[4]\n", + " class_ind = int(bbox[5])\n", + " bbox_color = colors[class_ind]\n", + " bbox_thick = int(0.6 * (image_h + image_w) / 600)\n", + " c1, c2 = (coor[0], coor[1]), (coor[2], coor[3])\n", + " cv2.rectangle(image, c1, c2, bbox_color, bbox_thick)\n", + "\n", + " if show_label:\n", + " bbox_mess = '%s: %.2f' % (classes[class_ind], score)\n", + " t_size = cv2.getTextSize(bbox_mess, 0, fontScale, thickness=bbox_thick//2)[0]\n", + " cv2.rectangle(image, c1, (c1[0] + t_size[0], c1[1] - t_size[1] - 3), bbox_color, -1)\n", + " cv2.putText(image, bbox_mess, (c1[0], c1[1]-2), cv2.FONT_HERSHEY_SIMPLEX,\n", + " fontScale, (0, 0, 0), bbox_thick//2, lineType=cv2.LINE_AA)\n", + " print('{} detected in frame with {}% probability '.format(classes[class_ind], score*100))\n", + " \n", + " return image" + ] + }, + { + "cell_type": "markdown", + "id": "9aff6a84", + "metadata": { + "id": "9aff6a84" + }, + "source": [ + "### Load the anchors from a file" + ] + }, + { + "cell_type": "markdown", + "id": "b1ca5c16", + "metadata": { + "id": "b1ca5c16" + }, + "source": [ + "The predefined anchors for the data-set on which the YoloV4 model was trained are loaded." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2e8b7fc", + "metadata": { + "id": "c2e8b7fc" + }, + "outputs": [], + "source": [ + "def get_anchors(anchors_path, tiny=False):\n", + " with open(anchors_path) as f:\n", + " anchors = f.readline()\n", + " anchors = np.array(anchors.split(','), dtype=np.float32)\n", + " return anchors.reshape(3, 3, 2)" + ] + }, + { + "cell_type": "markdown", + "id": "410bbc8d", + "metadata": { + "id": "410bbc8d" + }, + "source": [ + "## Inference" + ] + }, + { + "cell_type": "markdown", + "id": "e440c091", + "metadata": { + "id": "e440c091" + }, + "source": [ + "### Create a session for inference based on the device selected" + ] + }, + { + "cell_type": "markdown", + "id": "acb0a5ab", + "metadata": { + "id": "acb0a5ab" + }, + "source": [ + "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", + " \n", + "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", + "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", + "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", + "\n", + "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", + "\n", + "The device option should be chosen from any one of the below options: \n", + "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b8ceece", + "metadata": { + "id": "8b8ceece" + }, + "outputs": [], + "source": [ + "def create_sess(device):\n", + " so = rt.SessionOptions()\n", + " so.log_severity_level = 3\n", + " if (device == 'cpu'):\n", + " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", + " #Specify the path to the ONNX model on your machine and register the CPU EP\n", + " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", + " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", + " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", + " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", + " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", + " '''\n", + " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", + " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", + " '''\n", + " else:\n", + " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", + "\n", + " # Get the input name of the model\n", + " input_name = sess.get_inputs()[0].name\n", + "\n", + " return sess, input_name" + ] + }, + { + "cell_type": "markdown", + "id": "94bbfc56", + "metadata": { + "id": "94bbfc56" + }, + "source": [ + "### Specify the path to anchors file on your machine" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef9d3383", + "metadata": { + "id": "ef9d3383" + }, + "outputs": [], + "source": [ + "ANCHORS = \"yolov4_anchors.txt\" \n", + "STRIDES = [8, 16, 32]\n", + "XYSCALE = [1.2, 1.1, 1.05]\n", + "ANCHORS = get_anchors(ANCHORS)\n", + "STRIDES = np.array(STRIDES)" + ] + }, + { + "cell_type": "markdown", + "id": "c66ab52f", + "metadata": { + "id": "c66ab52f" + }, + "source": [ + "### Specify the path to model, and image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c968df7", + "metadata": { + "id": "7c968df7" + }, + "outputs": [], + "source": [ + "model = \"yolov4.onnx\"\n", + "image = \"cat.jpg\"" + ] + }, + { + "cell_type": "markdown", + "id": "00e6b53e", + "metadata": { + "id": "00e6b53e" + }, + "source": [ + "### Validate model file path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3031833b", + "metadata": { + "id": "3031833b" + }, + "outputs": [], + "source": [ + "check_model_extension(model)" + ] + }, + { + "cell_type": "markdown", + "id": "d446b2cf", + "metadata": { + "id": "d446b2cf" + }, + "source": [ + "### Setup input and output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bff0f18", + "metadata": { + "id": "3bff0f18" + }, + "outputs": [], + "source": [ + "if (image):\n", + " # Open the image file\n", + " if not os.path.isfile(image):\n", + " print(\"Input image file \", image, \" doesn't exist\")\n", + " sys.exit(1)\n", + " cap = cv2.imread(image)\n", + " output_file = image[:-4]+'_yolov4_out_py.jpg'" + ] + }, + { + "cell_type": "markdown", + "id": "83da97e8", + "metadata": { + "id": "83da97e8" + }, + "source": [ + "### Run the inference with CPU Execution Provider " + ] + }, + { + "cell_type": "markdown", + "id": "0b265eee", + "metadata": { + "id": "0b265eee" + }, + "source": [ + "Now the `yolov4.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", + "- `cpu`: default CPU Execution Provider (MLAS) \n", + "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", + "\n", + "The below code block performs the following operations:\n", + "\n", + "1. Creates a Onnx Runtime Session using `cpu` as device\n", + "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", + "3. Performs prediction on the same image for $100$-times\n", + "4. Calculates average inference time\n", + "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e2091e9", + "metadata": { + "id": "7e2091e9" + }, + "outputs": [], + "source": [ + "### create a session with cpu which is the default CPU Execution Provider\n", + "sess, input_name = create_sess(\"cpu\")\n", + "\n", + "input_size = 416\n", + "original_image = cap.copy()\n", + "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", + "original_image_size = original_image.shape[:2]\n", + "\n", + "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", + "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", + "\n", + "outputs = sess.get_outputs()\n", + "output_names = list(map(lambda output: output.name, outputs))\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(output_names, {input_name: image_data})\n", + "\n", + "start = time.time()\n", + "for i in range(100):\n", + " detections = sess.run(output_names, {input_name: image_data})\n", + "\n", + "end = time.time()\n", + "inference_time = end - start\n", + "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", + "print(\"PREDICTION - END\") \n", + "\n", + "pred_bbox = postprocess_bbbox(detections)\n", + "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", + "bboxes = nms(bboxes, 0.213, method='nms')\n", + "image_out = draw_bbox(original_image, bboxes)\n", + "\n", + "cv2.putText(image_out,\"cpu\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + "\n", + "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", + "cv2_imshow(image_out)\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", + "\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "2a86773c", + "metadata": { + "id": "2a86773c" + }, + "source": [ + "### Run the inference **with** OpenVINO Execution Provider" + ] + }, + { + "cell_type": "markdown", + "id": "8c04daa0", + "metadata": { + "id": "8c04daa0" + }, + "source": [ + "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a72e6bf7", + "metadata": { + "id": "a72e6bf7" + }, + "outputs": [], + "source": [ + "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", + "sess, input_name = create_sess(\"CPU_FP32\")\n", + "\n", + "input_size = 416\n", + "original_image = cap.copy()\n", + "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", + "original_image_size = original_image.shape[:2]\n", + "\n", + "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", + "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", + "\n", + "outputs = sess.get_outputs()\n", + "output_names = list(map(lambda output: output.name, outputs))\n", + "\n", + "print(\"PREDICTION - BEGIN\")\n", + "#warmup\n", + "sess.run(output_names, {input_name: image_data})\n", + "\n", + "start = time.time()\n", + "for i in range(100):\n", + " detections = sess.run(output_names, {input_name: image_data})\n", + "\n", + "end = time.time()\n", + "inference_time = end - start\n", + "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", + "print(\"PREDICTION - END\") \n", + "\n", + "pred_bbox = postprocess_bbbox(detections)\n", + "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", + "bboxes = nms(bboxes, 0.213, method='nms')\n", + "image_out = draw_bbox(original_image, bboxes)\n", + "\n", + "cv2.putText(image_out,\"CPU_FP32\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", + "\n", + "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", + "cv2_imshow(image_out)\n", + "\n", + "print('\\n')\n", + "\n", + "#Write the frame with the detection boxes\n", + "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", + "\n", + "print('\\n')" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "OVEP_yolov4_obj_detection_sample.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.8.10 ('yolov4': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "vscode": { + "interpreter": { + "hash": "7c4a41788a1f5a54de98941c88996114c38916598df611346d841c8cb6d26f64" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 47a81b7458af87b4db201800cbf67a5134bcca3b Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Thu, 25 Aug 2022 12:03:52 +0530 Subject: [PATCH 03/15] folder restucturing for notebooks --- ...VEP_tiny_yolov2_obj_detection_sample.ipynb | 741 ----------- .../OVEP_yolov4_obj_detection_sample.ipynb | 1149 ----------------- 2 files changed, 1890 deletions(-) delete mode 100644 python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb delete mode 100644 python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb diff --git a/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb b/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb deleted file mode 100644 index c44a4d4be..000000000 --- a/python/OpenVINO_EP/tiny_yolo_v2_object_detection/OVEP_tiny_yolov2_obj_detection_sample.ipynb +++ /dev/null @@ -1,741 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "6330a8a6", - "metadata": { - "id": "6330a8a6" - }, - "source": [ - "Copyright (C) 2021-2022, Intel Corporation\n", - "\n", - "SPDX-License-Identifier: Apache-2.0" - ] - }, - { - "cell_type": "markdown", - "id": "aa6f534b", - "metadata": { - "id": "aa6f534b" - }, - "source": [ - "# Object detection with tiny YOLOv2 in Python using OpenVINO™ Execution Provider:\n", - "\n", - "1. The Object detection sample uses a tinyYOLOv2 Deep Learning ONNX Model from the ONNX Model Zoo.\n", - "\n", - "\n", - "2. The sample involves presenting an Image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 20 different objects like birds, buses, cars, people and much more.\n", - "\n", - "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/tiny_yolo_v2_object_detection)." - ] - }, - { - "cell_type": "markdown", - "id": "b2c9aa57", - "metadata": { - "id": "b2c9aa57" - }, - "source": [ - "### Install Requirements" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "809559b8", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "809559b8", - "outputId": "1b4d78a7-fd0c-4ca8-bed7-186c290238cd" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m" - ] - } - ], - "source": [ - "!pip -q install --upgrade pip\n", - "!pip -q install folium==0.2.1\n", - "!pip -q install imgaug==0.2.6\n", - "!pip -q install certifi==2022.5.18.1\n", - "!pip -q install flatbuffers==2.0\n", - "!pip -q install numpy==1.21.6\n", - "!pip -q install onnx==1.11.0\n", - "!pip -q install opencv-python==4.5.5.64\n", - "!pip -q install scipy==1.7.3\n", - "!pip -q install typing-extensions==4.1.1\n", - "!pip -q install onnxruntime-openvino==1.11.0" - ] - }, - { - "cell_type": "markdown", - "id": "24d73115", - "metadata": { - "id": "24d73115" - }, - "source": [ - "### Import Necessary Resources" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6f72e3ca", - "metadata": { - "id": "6f72e3ca" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import onnxruntime as rt\n", - "import cv2\n", - "import time\n", - "import os\n", - "from pathlib import Path\n", - "import argparse\n", - "import platform\n", - "from google.colab.patches import cv2_imshow\n", - "import sys" - ] - }, - { - "cell_type": "markdown", - "id": "9399694a", - "metadata": { - "id": "9399694a" - }, - "source": [ - "### Get the model and input" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e2b38cc9", - "metadata": { - "id": "e2b38cc9" - }, - "outputs": [], - "source": [ - "#Create List of files in the directory\n", - "files = os.listdir('.')\n", - "\n", - "#Get the neccesary files into the directory if they don't already exist\n", - "if ('tinyyolov2-8.onnx' not in files):\n", - " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/tiny-yolov2/model/tinyyolov2-8.onnx?raw=true -O tinyyolov2-8.onnx\n", - "if ('dog.bmp' not in files):\n", - " !wget https://storage.openvinotoolkit.org/data/test_data/images/512x512/dog.bmp" - ] - }, - { - "cell_type": "markdown", - "id": "ceff9a38", - "metadata": { - "id": "ceff9a38" - }, - "source": [ - "## Preprocess" - ] - }, - { - "cell_type": "markdown", - "id": "cb2dd5ca", - "metadata": { - "id": "cb2dd5ca" - }, - "source": [ - "### Reshape the input to align with the model\n", - "\n", - "\n", - "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image is re-shaped to the desired image size i.e. $(416 \\times 416)$ using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "34a2817f", - "metadata": { - "id": "34a2817f" - }, - "outputs": [], - "source": [ - "def image_preprocess(frame):\n", - " in_frame = cv2.resize(frame, (416, 416))\n", - " preprocessed_image = np.asarray(in_frame)\n", - " preprocessed_image = preprocessed_image.astype(np.float32)\n", - " preprocessed_image = preprocessed_image.transpose(2,0,1)\n", - " #Reshaping the input array to align with the input shape of the model\n", - " preprocessed_image = preprocessed_image.reshape(1,3,416,416)\n", - " return preprocessed_image" - ] - }, - { - "cell_type": "markdown", - "id": "6dbc9aa8", - "metadata": { - "id": "6dbc9aa8" - }, - "source": [ - "### Check file paths\n", - "\n", - "`check_model_extention` is a helper function which checks if the model is present in the location specified. It also validates the model by checking the model file extension. \n", - "The expected model file should be of `.onnx` format." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ca5d9356", - "metadata": { - "id": "ca5d9356" - }, - "outputs": [], - "source": [ - "def check_model_extension(fp):\n", - " # Split the extension from the path and normalise it to lowercase.\n", - " ext = Path(fp).suffix.lower()\n", - "\n", - " # Now we can simply use != to check for inconsitencies with model file.\n", - " if(ext != \".onnx\"):\n", - " raise NameError(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", - " \n", - " if not Path(fp).exists():\n", - " raise OSError(\"[ ERROR ] Path of the onnx model file is Invalid\")" - ] - }, - { - "cell_type": "markdown", - "id": "bfc0e076", - "metadata": { - "id": "bfc0e076" - }, - "source": [ - "## Postprocess" - ] - }, - { - "cell_type": "markdown", - "id": "fca5634d", - "metadata": { - "id": "fca5634d" - }, - "source": [ - "### Add the appropriate bounding boxes and the class label to the image based on the inference results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7a331243", - "metadata": { - "id": "7a331243" - }, - "outputs": [], - "source": [ - "def postprocess_output(out, frame, x_scale, y_scale):\n", - " out = out[0][0]\n", - " num_classes = 20\n", - " anchors = [1.08, 1.19, 3.42, 4.41, 6.63, 11.38, 9.42, 5.11, 16.62, 10.52]\n", - " \n", - " # color look up table for different classes for object detection sample\n", - " clut = [(0,0,0),(255,0,0),(255,0,255),(0,0,255),(0,255,0),(0,255,128),\n", - " (128,255,0),(128,128,0),(0,128,255),(128,0,128),\n", - " (255,0,128),(128,0,255),(255,128,128),(128,255,128),(255,255,0),\n", - " (255,128,128),(128,128,255),(255,128,128),(128,255,128),(128,255,128)]\n", - "\n", - " # 20 labels that the tiny-yolov2 model can do the object_detection on\n", - " label = [\"aeroplane\",\"bicycle\",\"bird\",\"boat\",\"bottle\",\n", - " \"bus\",\"car\",\"cat\",\"chair\",\"cow\",\"diningtable\",\n", - " \"dog\",\"horse\",\"motorbike\",\"person\",\"pottedplant\",\n", - " \"sheep\",\"sofa\",\"train\",\"tvmonitor\"]\n", - "\n", - " existing_labels = {l: [] for l in label}\n", - "\n", - " #Inside this loop we compute the bounding box b for grid cell (cy, cx)\n", - " for cy in range(0,13):\n", - " for cx in range(0,13):\n", - " for b in range(0,5):\n", - " # First we read the tx, ty, width(tw), and height(th) for the bounding box from the out array, as well as the confidence score\n", - " channel = b*(num_classes+5)\n", - " tx = out[channel ][cy][cx]\n", - " ty = out[channel+1][cy][cx]\n", - " tw = out[channel+2][cy][cx]\n", - " th = out[channel+3][cy][cx]\n", - " tc = out[channel+4][cy][cx]\n", - "\n", - " x = (float(cx) + sigmoid(tx))*32\n", - " y = (float(cy) + sigmoid(ty))*32\n", - " w = np.exp(tw) * 32 * anchors[2*b]\n", - " h = np.exp(th) * 32 * anchors[2*b+1]\n", - "\n", - " #calculating the confidence score\n", - " confidence = sigmoid(tc) # The confidence value for the bounding box is given by tc\n", - " classes = np.zeros(num_classes)\n", - " for c in range(0,num_classes):\n", - " classes[c] = out[channel + 5 +c][cy][cx]\n", - " # we take the softmax to turn the array into a probability distribution. And then we pick the class with the largest score as the winner.\n", - " classes = softmax(classes)\n", - " detected_class = classes.argmax()\n", - " # Now we can compute the final score for this bounding box and we only want to keep the ones whose combined score is over a certain threshold\n", - " if 0.75 < classes[detected_class]*confidence:\n", - " color =clut[detected_class]\n", - " x = (x - w/2)*x_scale\n", - " y = (y - h/2)*y_scale\n", - " w *= x_scale\n", - " h *= y_scale\n", - " \n", - " labelX = int((x+x+w)/2)\n", - " labelY = int((y+y+h)/2)\n", - " addLabel = True\n", - " lab_threshold = 100\n", - " for point in existing_labels[label[detected_class]]:\n", - " if labelX < point[0] + lab_threshold and labelX > point[0] - lab_threshold and \\\n", - " labelY < point[1] + lab_threshold and labelY > point[1] - lab_threshold:\n", - " addLabel = False\n", - " #Adding class labels to the output of the frame and also drawing a rectangular bounding box around the object detected.\n", - " if addLabel:\n", - " bbox_mess = f'{label[detected_class]}:{classes[detected_class]*confidence:.3f}'\n", - " cv2.rectangle(frame, (int(x),int(y)),(int(x+w),int(y+h)),color,2)\n", - " cv2.rectangle(frame, (int(x),int(y-13)),(int(x)+9*len(bbox_mess),int(y)),color,-1)\n", - " cv2.putText(frame,bbox_mess,(int(x)+2,int(y)-3),cv2.FONT_HERSHEY_COMPLEX,0.4,(255,255,255),1)\n", - " existing_labels[label[detected_class]].append((labelX,labelY))\n", - " print(f'{label[detected_class]} detected in frame with {classes[detected_class]*confidence*100}% probability ')" - ] - }, - { - "cell_type": "markdown", - "id": "86200685", - "metadata": { - "id": "86200685" - }, - "source": [ - "### Show the image with the bounding boxes" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ff22f1f", - "metadata": { - "id": "4ff22f1f" - }, - "outputs": [], - "source": [ - "def show_bbox(device, frame, inference_time):\n", - " cv2.putText(frame,device,(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", - " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", - " frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", - " cv2_imshow(frame)" - ] - }, - { - "cell_type": "markdown", - "id": "2a609551", - "metadata": { - "id": "2a609551" - }, - "source": [ - "### sigmoid and softmax functions to make sense of infrence output for the model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7b22f9ad", - "metadata": { - "id": "7b22f9ad" - }, - "outputs": [], - "source": [ - "def sigmoid(x, derivative=False):\n", - " return x*(1-x) if derivative else 1/(1+np.exp(-x))\n", - "\n", - "def softmax(x):\n", - " score_mat_exp = np.exp(np.asarray(x))\n", - " return score_mat_exp / score_mat_exp.sum(0)" - ] - }, - { - "cell_type": "markdown", - "id": "xEQDTN4xKgfs", - "metadata": { - "id": "xEQDTN4xKgfs" - }, - "source": [ - "## Inference" - ] - }, - { - "cell_type": "markdown", - "id": "7617f559", - "metadata": { - "id": "7617f559" - }, - "source": [ - "### Create a session for inference based on the device selected\n", - "\n", - "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", - " \n", - "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", - "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", - "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", - "\n", - "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", - "\n", - "The device option should be chosen from any one of the below options: \n", - "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "438b7b76", - "metadata": { - "id": "438b7b76" - }, - "outputs": [], - "source": [ - "def create_sess(device):\n", - " so = rt.SessionOptions()\n", - " so.log_severity_level = 3\n", - " if (device == 'cpu'):\n", - " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", - " #Specify the path to the ONNX model on your machine and register the CPU EP\n", - " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", - " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", - " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", - " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", - " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", - " '''\n", - " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", - " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", - " '''\n", - " else:\n", - " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", - "\n", - " # Get the input name of the model\n", - " input_name = sess.get_inputs()[0].name\n", - "\n", - " return sess, input_name" - ] - }, - { - "cell_type": "markdown", - "id": "d1a39044", - "metadata": { - "id": "d1a39044" - }, - "source": [ - "### Specify the device and path to model, Image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "39fec459", - "metadata": { - "id": "39fec459" - }, - "outputs": [], - "source": [ - "model = \"tinyyolov2-8.onnx\"\n", - "image = \"dog.bmp\"" - ] - }, - { - "cell_type": "markdown", - "id": "3df2a717", - "metadata": { - "id": "3df2a717" - }, - "source": [ - "### Validate model file path" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4d29f8f8", - "metadata": { - "id": "4d29f8f8" - }, - "outputs": [], - "source": [ - "check_model_extension(model)" - ] - }, - { - "cell_type": "markdown", - "id": "j5QfFB1PJ_uq", - "metadata": { - "id": "j5QfFB1PJ_uq" - }, - "source": [ - "### Setup input and output" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "DX-C07_3zcck", - "metadata": { - "id": "DX-C07_3zcck" - }, - "outputs": [], - "source": [ - "if (image):\n", - " \n", - " #Check if image file exists\n", - " if not Path(image).is_file():\n", - " raise OSError(\"Input image file \", image, \" doesn't exist as a file\")\n", - "\n", - " # Open the image file\n", - " cap = cv2.imread(image)\n", - "\n", - " height, width, c = cap.shape\n", - " x_scale = float(width)/416.0 #In the document of tino-yolo-v2, input shape of this network is (1,3,416,416).\n", - " y_scale = float(height)/416.0\n", - "\n", - " output_file = Path(image).stem+'_tiny_yolov2_out_py.jpg'" - ] - }, - { - "cell_type": "markdown", - "id": "2SgMAeXVfQrR", - "metadata": { - "id": "2SgMAeXVfQrR" - }, - "source": [ - "### Run the inference with default CPU Execution Provider \n", - "\n", - "Now the `tinyyolov2-8.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", - "- `cpu`: default CPU Execution Provider (MLAS) \n", - "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", - "\n", - "The below code block performs the following operations:\n", - "\n", - "1. Creates a Onnx Runtime Session using `cpu` as device\n", - "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", - "3. Performs prediction on the same image for $100$-times\n", - "4. Calculates average inference time\n", - "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1sssvylKfR_0", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 651 - }, - "id": "1sssvylKfR_0", - "outputId": "58cf8a7d-fce7-4c70-b89f-2c881ee89e52" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\n", - "PREDICTION - BEGIN\n", - "Avg Inference time in ms: 171.4293139199998\n", - "PREDICTION - END\n", - "dog detected in frame with 80.20803000214038% probability \n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "### create a session with cpu which is the default CPU Execution Provider\n", - "sess, input_name = create_sess(\"cpu\")\n", - "\n", - "#capturing one frame at a time from the video feed and performing the inference\n", - "frame = cap.copy()\n", - "\n", - "#preprocessing the input frame and reshaping it.\n", - "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", - "preprocessed_image = image_preprocess(frame)\n", - "\n", - "print(\"PREDICTION - BEGIN\")\n", - "#warmup\n", - "sess.run(None, {input_name: preprocessed_image})\n", - "\n", - "start = time.perf_counter()\n", - "#Running the session by passing in the input data of the model\n", - "for i in range(100):\n", - " out = sess.run(None, {input_name: preprocessed_image})\n", - "\n", - "end = time.perf_counter()\n", - "inference_time = end - start\n", - "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", - "print(\"PREDICTION - END\")\n", - "\n", - "#Get the output\n", - "postprocess_output(out, frame, x_scale, y_scale)\n", - "\n", - "#Show the output\n", - "show_bbox(\"cpu\", frame, inference_time)\n", - "\n", - "#Write the frame with the detection boxes\n", - "cv2.imwrite(output_file, frame.astype(np.uint8))\n", - "print('\\n')" - ] - }, - { - "cell_type": "markdown", - "id": "XUkRaU9uI0zX", - "metadata": { - "id": "XUkRaU9uI0zX" - }, - "source": [ - "### Run the inference with OpenVINO Execution Provider\n", - "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b5517d1", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "8b5517d1", - "outputId": "d41168dc-d37a-43d1-ef64-95b551dc798a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Device type selected is: CPU_FP32 using the OpenVINO Execution Provider\n", - "PREDICTION - BEGIN\n", - "Avg Inference time in ms: 143.52424147999955\n", - "PREDICTION - END\n", - "dog detected in frame with 80.20795232381303% probability \n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", - "sess, input_name = create_sess(\"CPU_FP32\")\n", - "\n", - "#capturing one frame at a time from the video feed and performing the inference\n", - "frame = cap.copy()\n", - "\n", - "#preprocessing the input frame and reshaping it.\n", - "#In the document of tiny-yolo-v2, input shape of this network is (1,3,416,416). so we resize the model frame w.r.t that size.\n", - "preprocessed_image = image_preprocess(frame)\n", - "\n", - "print(\"PREDICTION - BEGIN\")\n", - "#warmup\n", - "sess.run(None, {input_name: preprocessed_image})\n", - "\n", - "start = time.perf_counter()\n", - "#Running the session by passing in the input data of the model\n", - "for i in range(100):\n", - " out = sess.run(None, {input_name: preprocessed_image})\n", - "\n", - "end = time.perf_counter()\n", - "inference_time = end - start\n", - "print(f'Avg Inference time in ms: {(inference_time/100 * 1000)}')\n", - "print(\"PREDICTION - END\")\n", - "\n", - "#Get the output\n", - "postprocess_output(out, frame, x_scale, y_scale)\n", - "\n", - "#Show the output\n", - "show_bbox(\"CPU_FP32\", frame, inference_time)\n", - "\n", - "#Write the frame with the detection boxes\n", - "cv2.imwrite(output_file, frame.astype(np.uint8))\n", - "print('\\n')" - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "OVEP_tiny_yolov2_obj_detection_sample.ipynb", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3.8.10 ('tiny_yolovV2': venv)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - }, - "vscode": { - "interpreter": { - "hash": "0226610a830f21b877cea989523fd0c295c7466b3cab1c0f323be92db3371acd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb b/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb deleted file mode 100644 index 3e320f5b9..000000000 --- a/python/OpenVINO_EP/yolov4_object_detection/OVEP_yolov4_obj_detection_sample.ipynb +++ /dev/null @@ -1,1149 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b6157254", - "metadata": { - "id": "b6157254" - }, - "source": [ - "Copyright (C) 2021-2022, Intel Corporation\n", - "\n", - "SPDX-License-Identifier: Apache-2.0\n", - "\n", - "Major Portions of this code are copyright of their respective authors and released under the Apache License Version 2.0:\n", - "- onnx, Copyright 2021-2022. For licensing see https://github.com/onnx/models/blob/master/LICENSE" - ] - }, - { - "cell_type": "markdown", - "id": "dfed77f6", - "metadata": { - "id": "dfed77f6" - }, - "source": [ - "# Object detection with YOLOv4 in Python using OpenVINO™ Execution Provider:\n", - "\n", - "1. The Object detection sample uses a YOLOv4 Deep Learning ONNX Model from the ONNX Model Zoo.\n", - "\n", - "\n", - "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset.\n", - "\n", - "\n", - "4. Once the inferencing is done on the sample, the recording of the same also gets downloaded on the disk.\n", - "\n", - "The source code for this sample is available [here](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/python/OpenVINO_EP/yolov4_object_detection)." - ] - }, - { - "cell_type": "markdown", - "id": "08dd644b", - "metadata": { - "id": "08dd644b" - }, - "source": [ - "## Install Requirements" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d18b13f8", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "d18b13f8", - "outputId": "98506653-ce93-4ff7-ff27-45fba7012df0" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[K |████████████████████████████████| 2.0 MB 7.7 MB/s \n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m70.0/70.0 kB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Building wheel for folium (setup.py) ... \u001b[?25l\u001b[?25hdone\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", - "datascience 0.17.5 requires folium>=0.9.1, but you have folium 0.2.1 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m631.4/631.4 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Building wheel for imgaug (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m155.2/155.2 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m61.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.5/60.5 MB\u001b[0m \u001b[31m11.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m37.6/37.6 MB\u001b[0m \u001b[31m13.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", - "\u001b[0m" - ] - } - ], - "source": [ - "!pip -q install --upgrade pip\n", - "!pip -q install folium==0.2.1\n", - "!pip -q install imgaug==0.2.6\n", - "!pip -q install certifi==2022.5.18.1\n", - "!pip -q install flatbuffers==2.0\n", - "!pip -q install numpy==1.21.6\n", - "!pip -q install onnx==1.11.0\n", - "!pip -q install opencv-python==4.5.5.64\n", - "!pip -q install scipy==1.7.3\n", - "!pip -q install typing-extensions==4.1.1\n", - "!pip -q install onnxruntime-openvino==1.11.0" - ] - }, - { - "cell_type": "markdown", - "id": "97b43517", - "metadata": { - "id": "97b43517" - }, - "source": [ - "## Import Necessary Resources" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06698673", - "metadata": { - "id": "06698673" - }, - "outputs": [], - "source": [ - "import cv2\n", - "import numpy as np\n", - "from onnx import numpy_helper\n", - "import onnx\n", - "import onnxruntime as rt\n", - "import os\n", - "from PIL import Image\n", - "from scipy import special\n", - "import colorsys\n", - "import random\n", - "import argparse\n", - "import sys\n", - "import time\n", - "from google.colab.patches import cv2_imshow" - ] - }, - { - "cell_type": "markdown", - "id": "3c7fe112", - "metadata": { - "id": "3c7fe112" - }, - "source": [ - "## Get the model and input" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "MtdBsnOeJJkk", - "metadata": { - "id": "MtdBsnOeJJkk", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "3e2cb8e1-9f7f-43d9-92ba-f51c9fdeb891" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2022-08-19 04:47:57-- https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/yolov4_anchors.txt\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 69 [text/plain]\n", - "Saving to: ‘yolov4_anchors.txt’\n", - "\n", - "\ryolov4_anchors.txt 0%[ ] 0 --.-KB/s \ryolov4_anchors.txt 100%[===================>] 69 --.-KB/s in 0s \n", - "\n", - "2022-08-19 04:47:57 (3.34 MB/s) - ‘yolov4_anchors.txt’ saved [69/69]\n", - "\n", - "--2022-08-19 04:47:57-- https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/coco.names\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.110.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 625 [text/plain]\n", - "Saving to: ‘coco.names’\n", - "\n", - "coco.names 100%[===================>] 625 --.-KB/s in 0s \n", - "\n", - "2022-08-19 04:47:57 (26.0 MB/s) - ‘coco.names’ saved [625/625]\n", - "\n", - "--2022-08-19 04:47:57-- https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx?raw=true\n", - "Resolving github.com (github.com)... 140.82.114.3\n", - "Connecting to github.com (github.com)|140.82.114.3|:443... connected.\n", - "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://github.com/onnx/models/raw/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx [following]\n", - "--2022-08-19 04:47:57-- https://github.com/onnx/models/raw/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx\n", - "Reusing existing connection to github.com:443.\n", - "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://media.githubusercontent.com/media/onnx/models/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx [following]\n", - "--2022-08-19 04:47:58-- https://media.githubusercontent.com/media/onnx/models/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx\n", - "Resolving media.githubusercontent.com (media.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", - "Connecting to media.githubusercontent.com (media.githubusercontent.com)|185.199.108.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 257470589 (246M) [application/octet-stream]\n", - "Saving to: ‘yolov4.onnx’\n", - "\n", - "yolov4.onnx 100%[===================>] 245.54M 269MB/s in 0.9s \n", - "\n", - "2022-08-19 04:48:20 (269 MB/s) - ‘yolov4.onnx’ saved [257470589/257470589]\n", - "\n", - "--2022-08-19 04:48:20-- https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg\n", - "Resolving storage.openvinotoolkit.org (storage.openvinotoolkit.org)... 13.226.225.80, 13.226.225.13, 13.226.225.84, ...\n", - "Connecting to storage.openvinotoolkit.org (storage.openvinotoolkit.org)|13.226.225.80|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 51473 (50K) [image/jpeg]\n", - "Saving to: ‘cat.jpg’\n", - "\n", - "cat.jpg 100%[===================>] 50.27K --.-KB/s in 0.1s \n", - "\n", - "2022-08-19 04:48:21 (386 KB/s) - ‘cat.jpg’ saved [51473/51473]\n", - "\n" - ] - } - ], - "source": [ - "files = os.listdir('.')\n", - "if ('yolov4_anchors.txt' not in files):\n", - " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/yolov4_anchors.txt\n", - "if ('coco.names' not in files):\n", - " !wget https://raw.githubusercontent.com/microsoft/onnxruntime-inference-examples/main/python/OpenVINO_EP/yolov4_object_detection/coco.names\n", - "if ('yolov4.onnx' not in files):\n", - " !wget https://github.com/onnx/models/blob/main/vision/object_detection_segmentation/yolov4/model/yolov4.onnx?raw=true -O yolov4.onnx\n", - "if ('cat.jpg' not in files):\n", - " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" - ] - }, - { - "cell_type": "markdown", - "id": "71fec400", - "metadata": { - "id": "71fec400" - }, - "source": [ - "## Preprocess" - ] - }, - { - "cell_type": "markdown", - "id": "23e66f38", - "metadata": { - "id": "23e66f38" - }, - "source": [ - "### Reshape the input to align with the model" - ] - }, - { - "cell_type": "markdown", - "id": "a4ba63cf", - "metadata": { - "id": "a4ba63cf" - }, - "source": [ - "\n", - "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", - "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", - "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `image_preprocess` helper function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1bab58d5", - "metadata": { - "id": "1bab58d5" - }, - "outputs": [], - "source": [ - "def image_preprocess(image, target_size, gt_boxes=None):\n", - " \n", - " ih, iw = target_size\n", - " h, w, _ = image.shape\n", - "\n", - " scale = min(iw/w, ih/h)\n", - "\n", - " nw, nh = int(scale * w), int(scale * h)\n", - " image_resized = cv2.resize(image, (nw, nh))\n", - "\n", - " image_padded = np.full(shape=[ih, iw, 3], fill_value=128.0)\n", - " dw, dh = (iw - nw) // 2, (ih-nh) // 2\n", - " image_padded[dh:nh+dh, dw:nw+dw, :] = image_resized\n", - " image_padded = image_padded / 255.\n", - "\n", - " if gt_boxes is None:\n", - " return image_padded\n", - "\n", - " else:\n", - " gt_boxes[:, [0, 2]] = gt_boxes[:, [0, 2]] * scale + dw\n", - " gt_boxes[:, [1, 3]] = gt_boxes[:, [1, 3]] * scale + dh\n", - " return image_padded, gt_boxes" - ] - }, - { - "cell_type": "markdown", - "id": "2d86e239", - "metadata": { - "id": "2d86e239" - }, - "source": [ - "### Check file paths\n", - "\n", - "`check_model_extention` is a helper function which checks if the model is present in the location specified. \n", - "It also validates the model by checking the model file extension. The expected model file should be of `.onnx` format." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2ad33e3d", - "metadata": { - "id": "2ad33e3d" - }, - "outputs": [], - "source": [ - "def check_model_extension(fp):\n", - " # Split the extension from the path and normalise it to lowercase.\n", - " ext = os.path.splitext(fp)[-1].lower()\n", - "\n", - " # Now we can simply use != to check for inequality, no need for wildcards.\n", - " if(ext != \".onnx\"):\n", - " raise Exception(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", - " \n", - " if not os.path.exists(fp):\n", - " raise Exception(\"[ ERROR ] Path of the onnx model file is Invalid\")" - ] - }, - { - "cell_type": "markdown", - "id": "38c0ebb9", - "metadata": { - "id": "38c0ebb9" - }, - "source": [ - "## Postprocess" - ] - }, - { - "cell_type": "markdown", - "id": "9f7fe3af", - "metadata": { - "id": "9f7fe3af" - }, - "source": [ - "### Defines anchor boxes" - ] - }, - { - "cell_type": "markdown", - "id": "53492b22", - "metadata": { - "id": "53492b22" - }, - "source": [ - "\n", - "Anchor boxes are a set of predefined bounding boxes of a certain height and width. These boxes are defined to capture the scale and aspect ratio of specific object classes we want to detect and are typically chosen based on object sizes in the training datasets. The use of anchor boxes improves the speed and efficiency for the detection portion of a deep learning neural network framework. Anchor boxes, facilitates the evaluation of object predictions at once, making real-time object detection systems possible.\n", - "\n", - "The following function takes the anchor box prediction probabilities and refines it corresponding to the tiled anchor boxes of the input image." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f3478f30", - "metadata": { - "id": "f3478f30" - }, - "outputs": [], - "source": [ - "def postprocess_bbbox(pred_bbox):\n", - " for i, pred in enumerate(pred_bbox):\n", - " conv_shape = pred.shape\n", - " output_size = conv_shape[1]\n", - " conv_raw_dxdy = pred[:, :, :, :, 0:2]\n", - " conv_raw_dwdh = pred[:, :, :, :, 2:4]\n", - " xy_grid = np.meshgrid(np.arange(output_size), np.arange(output_size))\n", - " xy_grid = np.expand_dims(np.stack(xy_grid, axis=-1), axis=2)\n", - "\n", - " xy_grid = np.tile(np.expand_dims(xy_grid, axis=0), [1, 1, 1, 3, 1])\n", - " xy_grid = xy_grid.astype(float)\n", - "\n", - " pred_xy = ((special.expit(conv_raw_dxdy) * XYSCALE[i]) - 0.5 * (XYSCALE[i] - 1) + xy_grid) * STRIDES[i]\n", - " pred_wh = (np.exp(conv_raw_dwdh) * ANCHORS[i])\n", - " pred[:, :, :, :, 0:4] = np.concatenate([pred_xy, pred_wh], axis=-1)\n", - "\n", - " pred_bbox = [np.reshape(x, (-1, np.shape(x)[-1])) for x in pred_bbox]\n", - " pred_bbox = np.concatenate(pred_bbox, axis=0)\n", - " return pred_bbox" - ] - }, - { - "cell_type": "markdown", - "id": "176a4ec6", - "metadata": { - "id": "176a4ec6" - }, - "source": [ - "### Removes boundary boxs with a low detection probability" - ] - }, - { - "cell_type": "markdown", - "id": "6dca198c", - "metadata": { - "id": "6dca198c" - }, - "source": [ - "The following function takes input as the prediction boxes (obtained by the previous function) and processes them to create bounding boxes. It also gets rid of certain prediction boxes based on a score threshold value." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3c82a10a", - "metadata": { - "id": "3c82a10a" - }, - "outputs": [], - "source": [ - "def postprocess_boxes(pred_bbox, org_img_shape, input_size, score_threshold):\n", - " valid_scale=[0, np.inf]\n", - " pred_bbox = np.array(pred_bbox)\n", - "\n", - " pred_xywh = pred_bbox[:, 0:4]\n", - " pred_conf = pred_bbox[:, 4]\n", - " pred_prob = pred_bbox[:, 5:]\n", - "\n", - " # # (1) (x, y, w, h) --> (xmin, ymin, xmax, ymax)\n", - " pred_coor = np.concatenate([pred_xywh[:, :2] - pred_xywh[:, 2:] * 0.5,\n", - " pred_xywh[:, :2] + pred_xywh[:, 2:] * 0.5], axis=-1)\n", - " # # (2) (xmin, ymin, xmax, ymax) -> (xmin_org, ymin_org, xmax_org, ymax_org)\n", - " org_h, org_w = org_img_shape\n", - " resize_ratio = min(input_size / org_w, input_size / org_h)\n", - "\n", - " dw = (input_size - resize_ratio * org_w) / 2\n", - " dh = (input_size - resize_ratio * org_h) / 2\n", - "\n", - " pred_coor[:, 0::2] = 1.0 * (pred_coor[:, 0::2] - dw) / resize_ratio\n", - " pred_coor[:, 1::2] = 1.0 * (pred_coor[:, 1::2] - dh) / resize_ratio\n", - "\n", - " # # (3) clip some boxes that are out of range\n", - " pred_coor = np.concatenate([np.maximum(pred_coor[:, :2], [0, 0]),\n", - " np.minimum(pred_coor[:, 2:], [org_w - 1, org_h - 1])], axis=-1)\n", - " invalid_mask = np.logical_or((pred_coor[:, 0] > pred_coor[:, 2]), (pred_coor[:, 1] > pred_coor[:, 3]))\n", - " pred_coor[invalid_mask] = 0\n", - "\n", - " # # (4) discard some invalid boxes\n", - " bboxes_scale = np.sqrt(np.multiply.reduce(pred_coor[:, 2:4] - pred_coor[:, 0:2], axis=-1))\n", - " scale_mask = np.logical_and((valid_scale[0] < bboxes_scale), (bboxes_scale < valid_scale[1]))\n", - "\n", - " # # (5) discard some boxes with low scores\n", - " classes = np.argmax(pred_prob, axis=-1)\n", - " scores = pred_conf * pred_prob[np.arange(len(pred_coor)), classes]\n", - " score_mask = scores > score_threshold\n", - " mask = np.logical_and(scale_mask, score_mask)\n", - " coors, scores, classes = pred_coor[mask], scores[mask], classes[mask]\n", - "\n", - " return np.concatenate([coors, scores[:, np.newaxis], classes[:, np.newaxis]], axis=-1)" - ] - }, - { - "cell_type": "markdown", - "id": "050c9844", - "metadata": { - "id": "050c9844" - }, - "source": [ - "### Calculate the Intersection Over Union value" - ] - }, - { - "cell_type": "markdown", - "id": "72b703d4", - "metadata": { - "id": "72b703d4" - }, - "source": [ - "Intersection over Union (IoU) is an evaluation technique for understanding how well the model is performing. However, during the time of inference, it is used to suppress the bounding-boxes that have a high IoU value with the bounding box with maximum probability." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d6df6791", - "metadata": { - "id": "d6df6791" - }, - "outputs": [], - "source": [ - "def bboxes_iou(boxes1, boxes2):\n", - " boxes1 = np.array(boxes1)\n", - " boxes2 = np.array(boxes2)\n", - "\n", - " boxes1_area = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])\n", - " boxes2_area = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])\n", - "\n", - " left_up = np.maximum(boxes1[..., :2], boxes2[..., :2])\n", - " right_down = np.minimum(boxes1[..., 2:], boxes2[..., 2:])\n", - "\n", - " inter_section = np.maximum(right_down - left_up, 0.0)\n", - " inter_area = inter_section[..., 0] * inter_section[..., 1]\n", - " union_area = boxes1_area + boxes2_area - inter_area\n", - " ious = np.maximum(1.0 * inter_area / union_area, np.finfo(np.float32).eps)\n", - "\n", - " return ious" - ] - }, - { - "cell_type": "markdown", - "id": "b82006d4", - "metadata": { - "id": "b82006d4" - }, - "source": [ - "### Non Max Suppression: select the most appropriate bounding box\n" - ] - }, - { - "cell_type": "markdown", - "id": "0616b442", - "metadata": { - "id": "0616b442" - }, - "source": [ - "It is the process of taking the boxes with maximum probability and suppressing the near-by boxes with non-max probabilities. \n", - "This is process is repeated until for a single object-class only one box is remaining." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "baec34ba", - "metadata": { - "id": "baec34ba" - }, - "outputs": [], - "source": [ - "def nms(bboxes, iou_threshold, sigma=0.3, method='nms'):\n", - " \"\"\"\n", - " :param bboxes: (xmin, ymin, xmax, ymax, score, class)\n", - " Note: soft-nms, https://arxiv.org/pdf/1704.04503.pdf\n", - " https://github.com/bharatsingh430/soft-nms\n", - " \"\"\"\n", - " classes_in_img = list(set(bboxes[:, 5]))\n", - " best_bboxes = []\n", - "\n", - " for cls in classes_in_img:\n", - " cls_mask = (bboxes[:, 5] == cls)\n", - " cls_bboxes = bboxes[cls_mask]\n", - "\n", - " while len(cls_bboxes) > 0:\n", - " max_ind = np.argmax(cls_bboxes[:, 4])\n", - " best_bbox = cls_bboxes[max_ind]\n", - " best_bboxes.append(best_bbox)\n", - " cls_bboxes = np.concatenate([cls_bboxes[: max_ind], cls_bboxes[max_ind + 1:]])\n", - " iou = bboxes_iou(best_bbox[np.newaxis, :4], cls_bboxes[:, :4])\n", - " weight = np.ones((len(iou),), dtype=np.float32)\n", - "\n", - " assert method in ['nms', 'soft-nms']\n", - "\n", - " if method == 'nms':\n", - " iou_mask = iou > iou_threshold\n", - " weight[iou_mask] = 0.0\n", - "\n", - " if method == 'soft-nms':\n", - " weight = np.exp(-(1.0 * iou ** 2 / sigma))\n", - "\n", - " cls_bboxes[:, 4] = cls_bboxes[:, 4] * weight\n", - " score_mask = cls_bboxes[:, 4] > 0.\n", - " cls_bboxes = cls_bboxes[score_mask]\n", - "\n", - " return best_bboxes" - ] - }, - { - "cell_type": "markdown", - "id": "a01bb4ca", - "metadata": { - "id": "a01bb4ca" - }, - "source": [ - "### Load class name from a file" - ] - }, - { - "cell_type": "markdown", - "id": "f7e95103", - "metadata": { - "id": "f7e95103" - }, - "source": [ - "- 80 different classes: person, bicycle, car, motorbike, aeroplane, bus, train, truck, etc." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dbced12b", - "metadata": { - "id": "dbced12b" - }, - "outputs": [], - "source": [ - "def read_class_names(class_file_name):\n", - " names = {}\n", - " with open(class_file_name, 'r') as data:\n", - " for ID, name in enumerate(data):\n", - " names[ID] = name.strip('\\n')\n", - " return names" - ] - }, - { - "cell_type": "markdown", - "id": "f10420fe", - "metadata": { - "id": "f10420fe" - }, - "source": [ - "### Output an image with all the bounding boxes" - ] - }, - { - "cell_type": "markdown", - "id": "542f85d8", - "metadata": { - "id": "542f85d8" - }, - "source": [ - "Below function is an helper function to draw the bounding box in the input image." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "def814e0", - "metadata": { - "id": "def814e0" - }, - "outputs": [], - "source": [ - "def draw_bbox(image, bboxes, classes=read_class_names(\"coco.names\"), show_label=True):\n", - " \"\"\"\n", - " bboxes: [x_min, y_min, x_max, y_max, probability, cls_id] format coordinates.\n", - " \"\"\"\n", - "\n", - " num_classes = len(classes)\n", - " image_h, image_w, _ = image.shape\n", - " hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]\n", - " colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n", - " colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))\n", - "\n", - " random.seed(0)\n", - " random.shuffle(colors)\n", - " random.seed(None)\n", - "\n", - " for i, bbox in enumerate(bboxes):\n", - " coor = np.array(bbox[:4], dtype=np.int32)\n", - " fontScale = 0.5\n", - " score = bbox[4]\n", - " class_ind = int(bbox[5])\n", - " bbox_color = colors[class_ind]\n", - " bbox_thick = int(0.6 * (image_h + image_w) / 600)\n", - " c1, c2 = (coor[0], coor[1]), (coor[2], coor[3])\n", - " cv2.rectangle(image, c1, c2, bbox_color, bbox_thick)\n", - "\n", - " if show_label:\n", - " bbox_mess = '%s: %.2f' % (classes[class_ind], score)\n", - " t_size = cv2.getTextSize(bbox_mess, 0, fontScale, thickness=bbox_thick//2)[0]\n", - " cv2.rectangle(image, c1, (c1[0] + t_size[0], c1[1] - t_size[1] - 3), bbox_color, -1)\n", - " cv2.putText(image, bbox_mess, (c1[0], c1[1]-2), cv2.FONT_HERSHEY_SIMPLEX,\n", - " fontScale, (0, 0, 0), bbox_thick//2, lineType=cv2.LINE_AA)\n", - " print('{} detected in frame with {}% probability '.format(classes[class_ind], score*100))\n", - " \n", - " return image" - ] - }, - { - "cell_type": "markdown", - "id": "9aff6a84", - "metadata": { - "id": "9aff6a84" - }, - "source": [ - "### Load the anchors from a file" - ] - }, - { - "cell_type": "markdown", - "id": "b1ca5c16", - "metadata": { - "id": "b1ca5c16" - }, - "source": [ - "The predefined anchors for the data-set on which the YoloV4 model was trained are loaded." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c2e8b7fc", - "metadata": { - "id": "c2e8b7fc" - }, - "outputs": [], - "source": [ - "def get_anchors(anchors_path, tiny=False):\n", - " with open(anchors_path) as f:\n", - " anchors = f.readline()\n", - " anchors = np.array(anchors.split(','), dtype=np.float32)\n", - " return anchors.reshape(3, 3, 2)" - ] - }, - { - "cell_type": "markdown", - "id": "410bbc8d", - "metadata": { - "id": "410bbc8d" - }, - "source": [ - "## Inference" - ] - }, - { - "cell_type": "markdown", - "id": "e440c091", - "metadata": { - "id": "e440c091" - }, - "source": [ - "### Create a session for inference based on the device selected" - ] - }, - { - "cell_type": "markdown", - "id": "acb0a5ab", - "metadata": { - "id": "acb0a5ab" - }, - "source": [ - "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", - " \n", - "1. Create a ONNX Runtime Session Option instance using `onnxruntime.SessionOptions()`\n", - "2. Using the session options instance create a Inference Session object by passing the model and the execution provider as arguments.\n", - "Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", - "\n", - "The below `create_sess` function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model.\n", - "\n", - "The device option should be chosen from any one of the below options: \n", - "- `cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b8ceece", - "metadata": { - "id": "8b8ceece" - }, - "outputs": [], - "source": [ - "def create_sess(device):\n", - " so = rt.SessionOptions()\n", - " so.log_severity_level = 3\n", - " if (device == 'cpu'):\n", - " print(\"Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\")\n", - " #Specify the path to the ONNX model on your machine and register the CPU EP\n", - " sess = rt.InferenceSession(model, so, providers=['CPUExecutionProvider'])\n", - " elif (device == 'CPU_FP32' or device == 'GPU_FP32' or device == 'GPU_FP16' or device == 'MYRIAD_FP16' or device == 'VADM_FP16'):\n", - " #Specify the path to the ONNX model on your machine and register the OpenVINO EP\n", - " sess = rt.InferenceSession(model, so, providers=['OpenVINOExecutionProvider'], provider_options=[{'device_type' : device}])\n", - " print(\"Device type selected is: \" + device + \" using the OpenVINO Execution Provider\")\n", - " '''\n", - " other 'device_type' options are: (Any hardware target can be assigned if you have the access to it)\n", - " 'CPU_FP32', 'GPU_FP32', 'GPU_FP16', 'MYRIAD_FP16', 'VAD-M_FP16'\n", - " '''\n", - " else:\n", - " raise Exception(\"Device type selected is not [cpu, CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VADM_FP16]\")\n", - "\n", - " # Get the input name of the model\n", - " input_name = sess.get_inputs()[0].name\n", - "\n", - " return sess, input_name" - ] - }, - { - "cell_type": "markdown", - "id": "94bbfc56", - "metadata": { - "id": "94bbfc56" - }, - "source": [ - "### Specify the path to anchors file on your machine" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ef9d3383", - "metadata": { - "id": "ef9d3383" - }, - "outputs": [], - "source": [ - "ANCHORS = \"yolov4_anchors.txt\" \n", - "STRIDES = [8, 16, 32]\n", - "XYSCALE = [1.2, 1.1, 1.05]\n", - "ANCHORS = get_anchors(ANCHORS)\n", - "STRIDES = np.array(STRIDES)" - ] - }, - { - "cell_type": "markdown", - "id": "c66ab52f", - "metadata": { - "id": "c66ab52f" - }, - "source": [ - "### Specify the path to model, and image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7c968df7", - "metadata": { - "id": "7c968df7" - }, - "outputs": [], - "source": [ - "model = \"yolov4.onnx\"\n", - "image = \"cat.jpg\"" - ] - }, - { - "cell_type": "markdown", - "id": "00e6b53e", - "metadata": { - "id": "00e6b53e" - }, - "source": [ - "### Validate model file path" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3031833b", - "metadata": { - "id": "3031833b" - }, - "outputs": [], - "source": [ - "check_model_extension(model)" - ] - }, - { - "cell_type": "markdown", - "id": "d446b2cf", - "metadata": { - "id": "d446b2cf" - }, - "source": [ - "### Setup input and output" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3bff0f18", - "metadata": { - "id": "3bff0f18" - }, - "outputs": [], - "source": [ - "if (image):\n", - " # Open the image file\n", - " if not os.path.isfile(image):\n", - " print(\"Input image file \", image, \" doesn't exist\")\n", - " sys.exit(1)\n", - " cap = cv2.imread(image)\n", - " output_file = image[:-4]+'_yolov4_out_py.jpg'" - ] - }, - { - "cell_type": "markdown", - "id": "83da97e8", - "metadata": { - "id": "83da97e8" - }, - "source": [ - "### Run the inference with CPU Execution Provider " - ] - }, - { - "cell_type": "markdown", - "id": "0b265eee", - "metadata": { - "id": "0b265eee" - }, - "source": [ - "Now the `yolov4.onnx` model will run inference on `cat.jpg` image using the below two execution providers:\n", - "- `cpu`: default CPU Execution Provider (MLAS) \n", - "- `CPU_FP32`: Execution on CPU with OpenVino Execution Provider\n", - "\n", - "The below code block performs the following operations:\n", - "\n", - "1. Creates a Onnx Runtime Session using `cpu` as device\n", - "2. Loads the input image and performs pre-processing using `image_preprocess` function\n", - "3. Performs prediction on the same image for $100$-times\n", - "4. Calculates average inference time\n", - "5. Performs post-processing, non-max suppression & bounding-box drawing using the predicted outputs from the model\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7e2091e9", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 439 - }, - "id": "7e2091e9", - "outputId": "774325bb-e9cc-4649-ce69-297d9102bacb" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Device type selected is 'cpu' which is the default CPU Execution Provider (MLAS)\n", - "PREDICTION - BEGIN\n", - "Avg Inference time in ms: 1200.997841\n", - "PREDICTION - END\n", - "cat detected in frame with 97.1569299697876% probability \n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "### create a session with cpu which is the default CPU Execution Provider\n", - "sess, input_name = create_sess(\"cpu\")\n", - "\n", - "input_size = 416\n", - "original_image = cap.copy()\n", - "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", - "original_image_size = original_image.shape[:2]\n", - "\n", - "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", - "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", - "\n", - "outputs = sess.get_outputs()\n", - "output_names = list(map(lambda output: output.name, outputs))\n", - "\n", - "print(\"PREDICTION - BEGIN\")\n", - "#warmup\n", - "sess.run(output_names, {input_name: image_data})\n", - "\n", - "start = time.time()\n", - "for i in range(100):\n", - " detections = sess.run(output_names, {input_name: image_data})\n", - "\n", - "end = time.time()\n", - "inference_time = end - start\n", - "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", - "print(\"PREDICTION - END\") \n", - "\n", - "pred_bbox = postprocess_bbbox(detections)\n", - "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", - "bboxes = nms(bboxes, 0.213, method='nms')\n", - "image_out = draw_bbox(original_image, bboxes)\n", - "\n", - "cv2.putText(image_out,\"cpu\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", - "\n", - "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", - "cv2_imshow(image_out)\n", - "\n", - "#Write the frame with the detection boxes\n", - "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", - "\n", - "print('\\n')" - ] - }, - { - "cell_type": "markdown", - "id": "2a86773c", - "metadata": { - "id": "2a86773c" - }, - "source": [ - "### Run the inference **with** OpenVINO Execution Provider" - ] - }, - { - "cell_type": "markdown", - "id": "8c04daa0", - "metadata": { - "id": "8c04daa0" - }, - "source": [ - "The below code block performs the same opertions as [before](#cpu_exec) with `CPU_FP32` as device, that runs on OpenVINO Execution Provider for ONNX Runtime." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a72e6bf7", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "a72e6bf7", - "outputId": "b5a207ac-7c1f-42f2-eb8f-0b4aaa72f273" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Device type selected is: CPU_FP32 using the OpenVINO Execution Provider\n", - "PREDICTION - BEGIN\n", - "Avg Inference time in ms: 1038.376327\n", - "PREDICTION - END\n", - "cat detected in frame with 97.15692400932312% probability \n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "\n", - "\n", - "\n" - ] - } - ], - "source": [ - "### create a session with CPU_FP32 using the OpenVINO Execution Provider\n", - "sess, input_name = create_sess(\"CPU_FP32\")\n", - "\n", - "input_size = 416\n", - "original_image = cap.copy()\n", - "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n", - "original_image_size = original_image.shape[:2]\n", - "\n", - "image_data = image_preprocess(np.copy(original_image), [input_size, input_size])\n", - "image_data = image_data[np.newaxis, ...].astype(np.float32)\n", - "\n", - "outputs = sess.get_outputs()\n", - "output_names = list(map(lambda output: output.name, outputs))\n", - "\n", - "print(\"PREDICTION - BEGIN\")\n", - "#warmup\n", - "sess.run(output_names, {input_name: image_data})\n", - "\n", - "start = time.time()\n", - "for i in range(100):\n", - " detections = sess.run(output_names, {input_name: image_data})\n", - "\n", - "end = time.time()\n", - "inference_time = end - start\n", - "print('Avg Inference time in ms: %f' % (inference_time/100 * 1000))\n", - "print(\"PREDICTION - END\") \n", - "\n", - "pred_bbox = postprocess_bbbox(detections)\n", - "bboxes = postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)\n", - "bboxes = nms(bboxes, 0.213, method='nms')\n", - "image_out = draw_bbox(original_image, bboxes)\n", - "\n", - "cv2.putText(image_out,\"CPU_FP32\",(10,20),cv2.FONT_HERSHEY_COMPLEX,0.5,(255,255,255),1)\n", - "\n", - "image_out = cv2.cvtColor(image_out, cv2.COLOR_BGR2RGB)\n", - "cv2_imshow(image_out)\n", - "\n", - "print('\\n')\n", - "\n", - "#Write the frame with the detection boxes\n", - "cv2.imwrite(output_file, image_out.astype(np.uint8))\n", - "\n", - "print('\\n')" - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "OVEP_yolov4_obj_detection_sample.ipynb", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3.8.10 ('yolov4': venv)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - }, - "vscode": { - "interpreter": { - "hash": "7c4a41788a1f5a54de98941c88996114c38916598df611346d841c8cb6d26f64" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file From 499b607b7d5770fe6959b1944ddf004ccb23da5b Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 2 Sep 2022 14:25:13 +0530 Subject: [PATCH 04/15] yolov7 sample notebook --- .../README.md | 48 ++ .../OVEP_yoloV7-tiny_object_detection.ipynb | 806 ++++++++++++++++++ 2 files changed, 854 insertions(+) create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md new file mode 100644 index 000000000..e36e4241d --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -0,0 +1,48 @@ +# FP32/INT8 YOLOv7 Sample + +## Virtual Environement +Create a virtual environment either using a the `conda` virtual environment or `python venv`. + +### Conda +```bash +$ conda create -n yolov7 python=3.8 +$ conda activate yolov7 +``` +### Python venv +```bash +$ python3 -m venv yolov7 +$ source yolov7/bin/activate +``` + +## Install required packages +After creating and activating virtual environment, install the required packages: + +1. Jupyter Notebook +``` +$ pip install jupyter +``` +2. NNCF Experimental +``` +$ git clone https://github.com/openvinotoolkit/nncf.git +$ cd nncf && python setup.py install --onnx +$ pip install -qr onnxruntime-openvino==1.12.0 +$ rm -fR nncf +``` +## YoloV7 + +The YoloV7 repository, has a `requirements.txt` file which will install all the necessary packages. + +**Please follow the instructions mentioned within the notebook. You might have to restart the notebook once the packages are installed.** + +## Dataset +The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. + +## Outputs + +- `yolov7-tiny.onnx` +- `yolov7-tiny-quantized.onnx` +- `cat-yolov7-detected.jpg` + +## References +### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) +### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb new file mode 100644 index 000000000..31d8ef0ab --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -0,0 +1,806 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b6157254", + "metadata": { + "id": "b6157254" + }, + "source": [ + "Major Portions of this code are copyright of their respective authors and released under the General Public License Version 3.0:\n", + "- For licensing see https://github.com/WongKinYiu/yolov7/blob/main/LICENSE.md" + ] + }, + { + "cell_type": "markdown", + "id": "dfed77f6", + "metadata": { + "id": "dfed77f6" + }, + "source": [ + "# Object detection with YOLOv7 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a YOLOv4 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "\n", + "\n", + "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset.\n", + "\n", + "\n", + "4. Once the inferencing is done on the sample, the recording of the same also gets downloaded on the disk.\n", + "\n", + "The source code for this sample is available [here](https://github.com/WongKinYiu/yolov7)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Before starting with this notebook please make sure to perform the required installations as mentioned below:**\n", + "1. [YoloV7 installation requirements](https://github.com/WongKinYiu/yolov7#installation)\n", + "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)\n", + "\n", + "## Install Requirements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### YoloV7" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "# Uncomment and the run the below lines once, if you're running this notebook\n", + "# for the first time in your virtual environment.\n", + "# Note: Comment the below line and restart the notebook before proceeding further.\n", + "\n", + "# if not os.path.exists('yolov7'):\n", + "# !git clone https://github.com/WongKinYiu/yolov7 # clone\n", + "# !cp -R yolov7/* .\n", + "# !pip install -qr requirements.txt # install\n", + "# !rm -fR yolov7" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note: You might have to restart the session before continuing. Please make sure to comment the above cells once the installations are complete and the session is restarted.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download COCO validation dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "\n", + "if not os.path.exists(\"../datasets\"):\n", + " # Download COCO val\n", + " torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", + " !unzip -q tmp.zip -d ../datasets && rm tmp.zip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export yolov7-tiny model to ONNX format" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", + " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", + " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", + "if not os.path.exists('cat.jpg'):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Inference for ONNX model\n", + "import cv2\n", + "import time\n", + "import requests\n", + "import random\n", + "import logging\n", + "import numpy as np\n", + "import onnxruntime\n", + "from PIL import Image\n", + "from pathlib import Path\n", + "from collections import OrderedDict,namedtuple\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define necessary helper functions\n", + "### Pre-Processing\n", + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", + "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", + "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `image_preprocess` helper function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32):\n", + " # Resize and pad image while meeting stride-multiple constraints\n", + " shape = im.shape[:2] # current shape [height, width]\n", + " if isinstance(new_shape, int):\n", + " new_shape = (new_shape, new_shape)\n", + "\n", + " # Scale ratio (new / old)\n", + " r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])\n", + " if not scaleup: # only scale down, do not scale up (for better val mAP)\n", + " r = min(r, 1.0)\n", + "\n", + " # Compute padding\n", + " new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))\n", + " dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding\n", + "\n", + " if auto: # minimum rectangle\n", + " dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding\n", + "\n", + " dw /= 2 # divide padding into 2 sides\n", + " dh /= 2\n", + "\n", + " if shape[::-1] != new_unpad: # resize\n", + " im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)\n", + " top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))\n", + " left, right = int(round(dw - 0.1)), int(round(dw + 0.1))\n", + " im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border\n", + " return im, r, (dw, dh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Labels and Colors for Lables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "random.seed(42)\n", + "names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', \n", + " 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', \n", + " 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', \n", + " 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', \n", + " 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', \n", + " 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', \n", + " 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', \n", + " 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', \n", + " 'hair drier', 'toothbrush']\n", + "colors = {name:[random.randint(0, 255) for _ in range(3)] for i,name in enumerate(names)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read & Pre-Process Image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def set_logging(rank=-1):\n", + " logging.basicConfig(\n", + " format=\"%(message)s\",\n", + " level=logging.INFO if rank in [-1, 0] else logging.WARN)\n", + " \n", + "set_logging(5) # run before defining LOGGER\n", + "LOGGER = logging.getLogger(\"yolov7\")\n", + "\n", + "def preProcess_image(img_path):\n", + " img = cv2.imread(img_path)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + " image = img.copy()\n", + " image, ratio, dwdh = letterbox(image, auto=False)\n", + " image = image.transpose((2, 0, 1))\n", + " image = np.expand_dims(image, 0)\n", + " image = np.ascontiguousarray(image)\n", + "\n", + " im = image.astype(np.float32)\n", + " im /= 255\n", + " print(\"Image Shape:\", im.shape, sep='\\t')\n", + " return im, ratio, dwdh\n", + "\n", + "def create_session(model_path, device='CPU_FP32'):\n", + " \n", + " if device == 'CPU_FP32':\n", + " providers = ['OpenVINOExecutionProvider']\n", + " elif device == 'cpu':\n", + " providers = ['CPUExecutionProvider']\n", + " else:\n", + " LOGGER.info(f'No provider passed, using default CPU EP ...')\n", + " providers = ['CPUExecutionProvider']\n", + " \n", + " LOGGER.info(f'Use ORT providers: {providers}')\n", + " \n", + " sess = onnxruntime.InferenceSession(model_path,\n", + " providers=providers,\n", + " provider_options=[{'device_type': device}])\n", + "\n", + " outname = [i.name for i in sess.get_outputs()]\n", + " inname = [i.name for i in sess.get_inputs()]\n", + " \n", + " return sess, outname, inname\n", + "\n", + "\n", + "def run_inference(model_path, img_input, device='CPU_FP32', num_runs=10, warm_up=3):\n", + " \n", + " img0, proces_ratio, dwdh = preProcess_image(img_input)\n", + " session, outputs, inputs = create_session(model_path, device)\n", + " \n", + " pred_times = []\n", + " inp = {inputs[0]:img0}\n", + "\n", + " \n", + " # Inference\n", + " for iter_num in range(num_runs + 2):\n", + "\n", + " # warmup session\n", + " if iter_num <= warm_up:\n", + " session.run(outputs, inp)[0]\n", + " continue\n", + "\n", + " start = time.time()\n", + " pred = session.run(outputs, inp)[0]\n", + " end = time.time()\n", + " inference_time = end - start\n", + " pred_times.append(inference_time)\n", + " \n", + "\n", + " ori_images = cv2.imread(img_input)\n", + " ori_images = [cv2.cvtColor(ori_images, cv2.COLOR_BGR2RGB)]\n", + "\n", + " for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(pred):\n", + " image = ori_images[int(batch_id)]\n", + " box = np.array([x0,y0,x1,y1])\n", + " box -= np.array(dwdh*2)\n", + " box /= proces_ratio\n", + " box = box.round().astype(np.int32).tolist()\n", + " cls_id = int(cls_id)\n", + " score = round(float(score),3)\n", + " name = names[cls_id]\n", + " color = colors[name]\n", + " name += ' '+str(score)\n", + " cv2.rectangle(image,box[:2],box[2:],color,2)\n", + " cv2.putText(image,name,(box[0], box[1] - 2),cv2.FONT_HERSHEY_SIMPLEX,0.45,[225, 255, 255],thickness=1)\n", + " cv2.putText(image, 'FPS: {:.8f}'.format(1.0 / inference_time),\n", + " (10, 40), cv2.FONT_HERSHEY_COMPLEX, 0.45, (255, 255, 255), 0) \n", + " print('Avg Inference time in ms: %f' %\n", + " (sum(pred_times) / len(pred_times) * 1000))\n", + " plt.imshow(Image.fromarray(ori_images[0]))\n", + " plt.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using CPU Execution Provider (MLAS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", + " \"img_input\": \"cat.jpg\",\n", + " \"device\":'cpu',\n", + " \"num_runs\":10}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using OpenVino Execution Provider" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", + " \"img_input\": \"cat.jpg\",\n", + " \"device\":'CPU_FP32',\n", + " \"num_runs\":10}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NNCF PTQ for YoloV7" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantize yolov7-tiny model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build PTQ API dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import onnx\n", + "\n", + "from nncf.experimental.post_training.compression_builder import CompressionBuilder\n", + "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantization\n", + "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantizationParameters\n", + "from nncf.common.utils.logger import logger as nncf_logger\n", + "from nncf.experimental.post_training.api import dataset as ptq_api_dataset\n", + "from nncf.experimental.onnx.tensor import ONNXNNCFTensor\n", + "from utils.datasets import LoadImagesAndLabels\n", + "\n", + "class YoloV7Dataset(ptq_api_dataset.Dataset):\n", + " def __init__(self, path, batch_size, shuffle):\n", + " super().__init__(batch_size, shuffle)\n", + " self.load_images = LoadImagesAndLabels(path)\n", + "\n", + " def __getitem__(self, item):\n", + " img, _, _, _ = self.load_images[item]\n", + " # Input should be in [0,1].\n", + " img = (1 / 255.) * img\n", + " return {\"images\": ONNXNNCFTensor(img.numpy())}\n", + "\n", + " def __len__(self):\n", + " return len(self.load_images)\n", + "\n", + "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run PTQ" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_model = onnx.load(\"yolov7-tiny.onnx\")\n", + "num_init_samples = 100\n", + "# We'll ignore detector head not to quantize them\n", + "ignored_scopes = [\n", + " # Head branch 1\n", + " \"Mul_217\",\n", + " \"Add_219\",\n", + " \"Mul_221\",\n", + " \"Mul_223\",\n", + " \"Mul_227\",\n", + " # Head branch 2\n", + " \"Mul_251\",\n", + " \"Add_253\",\n", + " \"Mul_255\",\n", + " \"Mul_257\",\n", + " \"Mul_261\",\n", + " # Head branch 3\n", + " \"Mul_285\",\n", + " \"Add_287\",\n", + " \"Mul_289\",\n", + " \"Mul_291\",\n", + " \"Mul_295\",\n", + " # \"Conv_287\",\n", + " # \"Conv_293\",\n", + " # \"Conv_225\",\n", + "]\n", + "output_model_path = \"yolov7-tiny-quantized.onnx\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 1: Create a pipeline of compression algorithms.\n", + "builder = CompressionBuilder()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 2: Create the quantization algorithm and add to the builder.\n", + "quantization_parameters = PostTrainingQuantizationParameters(\n", + " number_samples=num_init_samples,\n", + " ignored_scopes=ignored_scopes\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "quantization = PostTrainingQuantization(quantization_parameters)\n", + "builder.add_algorithm(quantization)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 4: Execute the pipeline.\n", + "nncf_logger.info(\"Post-Training Quantization has just started!\")\n", + "quantized_model = builder.apply(original_model, dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 5: Save the quantized model.\n", + "onnx.save(quantized_model, output_model_path)\n", + "nncf_logger.info(\n", + " \"The quantized model is saved on {}\".format(output_model_path))\n", + "\n", + "onnx.checker.check_model(output_model_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Inference on INT-8 model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using CPU Execution Provider (MLAS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", + " \"img_input\": \"cat.jpg\",\n", + " \"device\":'cpu',\n", + " \"num_runs\":10}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using OpenVino Execution Provider" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", + " \"img_input\": \"cat.jpg\",\n", + " \"device\":'CPU_FP32',\n", + " \"num_runs\":10}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "id": "45ea764a", + "metadata": {}, + "source": [ + "# Benchmarking outputs on Ice-Lake CPU" + ] + }, + { + "cell_type": "markdown", + "id": "38c93e68", + "metadata": {}, + "source": [ + "- Benchmarks performed on Ice-Lake CPUs using openvino's [benchmark app](https://github.com/openvinotoolkit/openvino/tree/master/tools/benchmark_tool)\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "dd8faa25", + "metadata": {}, + "source": [ + "## Benchmark of YoloV7-Tiny\n", + "```bash\n", + "\n", + "[Step 1/11] Parsing and validating input arguments\n", + "[ INFO ] Parsing input parameters\n", + "[Step 2/11] Loading Inference Engine\n", + "[ INFO ] OpenVINO: OpenVINO Runtime version ......... 2022.1.0\n", + "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", + "[ INFO ]\n", + "[ INFO ] Device info:\n", + "[ INFO ] CPU\n", + "[ INFO ] openvino_intel_cpu_plugin version ......... 2022.1.0\n", + "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", + "[ INFO ]\n", + "[ INFO ]\n", + "[Step 3/11] Setting device configuration\n", + "[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to THROUGHPUT.\n", + "[Step 4/11] Reading network files\n", + "[ INFO ] Loading network files\n", + "[ INFO ] Read network took 105.86 ms\n", + "[Step 5/11] Resizing network to match image sizes and given batch\n", + "[ WARNING ] images: layout is not set explicitly, so it is defaulted to NCHW. It is STRONGLY recommended to set layout manually to avoid further issues.\n", + "[ INFO ] Reshaping network: 'images': {1,3,640,640}\n", + "[ INFO ] Reshape network took 0.01 ms\n", + "[Step 6/11] Configuring input of the model\n", + "[ INFO ] Network batch size: 1\n", + "Network inputs:\n", + " images (node: images) : u8 / [N,C,H,W]\n", + "Network outputs:\n", + " output (node: output) : f32 / [...]\n", + "[Step 7/11] Loading the model to the device\n", + "[ INFO ] Load network took 778.20 ms\n", + "[Step 8/11] Setting optimal runtime parameters\n", + "[ INFO ] Device: CPU\n", + "[ INFO ] { NETWORK_NAME , torch-jit-export }\n", + "[ INFO ] { OPTIMAL_NUMBER_OF_INFER_REQUESTS , 16 }\n", + "[ INFO ] { NUM_STREAMS , 16 }\n", + "[ INFO ] { AFFINITY , CORE }\n", + "[ INFO ] { INFERENCE_NUM_THREADS , 0 }\n", + "[ INFO ] { PERF_COUNT , NO }\n", + "[ INFO ] { INFERENCE_PRECISION_HINT , f32 }\n", + "[ INFO ] { PERFORMANCE_HINT , THROUGHPUT }\n", + "[ INFO ] { PERFORMANCE_HINT_NUM_REQUESTS , 0 }\n", + "[Step 9/11] Creating infer requests and preparing input blobs with data\n", + "[ WARNING ] No input files were given: all inputs will be filled with random values!\n", + "[ INFO ] Test Config 0\n", + "[ INFO ] images ([N,C,H,W], u8, {1, 3, 640, 640}, static): random (image is expected)\n", + "[Step 10/11] Measuring performance (Start inference asynchronously, 16 inference requests, limits: 60000 ms duration)\n", + "[ INFO ] BENCHMARK IS IN INFERENCE ONLY MODE.\n", + "[ INFO ] Input blobs will be filled once before performance measurements.\n", + "[ INFO ] First inference took 101.71 ms\n", + "\n", + "[Step 11/11] Dumping statistics report\n", + "[ INFO ] Count: 9728 iterations\n", + "[ INFO ] Duration: 60123.06 ms\n", + "[ INFO ] Latency:\n", + "[ INFO ] Median: 98.49 ms\n", + "[ INFO ] Average: 98.81 ms\n", + "[ INFO ] Min: 55.92 ms\n", + "[ INFO ] Max: 140.48 ms\n", + "[ INFO ] Throughput: 161.80 FPS\n", + "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "dccbf2f3", + "metadata": {}, + "source": [ + "## Benchmark of YoloV-INT-8\n", + "```bash\n", + "[Step 1/11] Parsing and validating input arguments\n", + "[ INFO ] Parsing input parameters\n", + "[Step 2/11] Loading Inference Engine\n", + "[ INFO ] OpenVINO: OpenVINO Runtime version ......... 2022.1.0\n", + "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", + "[ INFO ]\n", + "[ INFO ] Device info:\n", + "[ INFO ] CPU\n", + "[ INFO ] openvino_intel_cpu_plugin version ......... 2022.1.0\n", + "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", + "[ INFO ]\n", + "[ INFO ]\n", + "[Step 3/11] Setting device configuration\n", + "[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to THROUGHPUT.\n", + "[Step 4/11] Reading network files\n", + "[ INFO ] Loading network files\n", + "[ INFO ] Read network took 173.56 ms\n", + "[Step 5/11] Resizing network to match image sizes and given batch\n", + "[ WARNING ] images: layout is not set explicitly, so it is defaulted to NCHW. It is STRONGLY recommended to set layout manually to avoid further issues.\n", + "[ INFO ] Reshaping network: 'images': {1,3,640,640}\n", + "[ INFO ] Reshape network took 0.01 ms\n", + "[Step 6/11] Configuring input of the model\n", + "[ INFO ] Network batch size: 1\n", + "Network inputs:\n", + " images (node: images) : u8 / [N,C,H,W]\n", + "Network outputs:\n", + " output (node: output) : f32 / [...]\n", + "[Step 7/11] Loading the model to the device\n", + "[ INFO ] Load network took 1317.18 ms\n", + "[Step 8/11] Setting optimal runtime parameters\n", + "[ INFO ] Device: CPU\n", + "[ INFO ] { NETWORK_NAME , torch-jit-export }\n", + "[ INFO ] { OPTIMAL_NUMBER_OF_INFER_REQUESTS , 16 }\n", + "[ INFO ] { NUM_STREAMS , 16 }\n", + "[ INFO ] { AFFINITY , CORE }\n", + "[ INFO ] { INFERENCE_NUM_THREADS , 0 }\n", + "[ INFO ] { PERF_COUNT , NO }\n", + "[ INFO ] { INFERENCE_PRECISION_HINT , f32 }\n", + "[ INFO ] { PERFORMANCE_HINT , THROUGHPUT }\n", + "[ INFO ] { PERFORMANCE_HINT_NUM_REQUESTS , 0 }\n", + "[Step 9/11] Creating infer requests and preparing input blobs with data\n", + "[ WARNING ] No input files were given: all inputs will be filled with random values!\n", + "[ INFO ] Test Config 0\n", + "[ INFO ] images ([N,C,H,W], u8, {1, 3, 640, 640}, static): random (image is expected)\n", + "[Step 10/11] Measuring performance (Start inference asynchronously, 16 inference requests, limits: 60000 ms duration)\n", + "[ INFO ] BENCHMARK IS IN INFERENCE ONLY MODE.\n", + "[ INFO ] Input blobs will be filled once before performance measurements.\n", + "[ INFO ] First inference took 82.32 ms\n", + "\n", + "[Step 11/11] Dumping statistics report\n", + "[ INFO ] Count: 17456 iterations\n", + "[ INFO ] Duration: 60073.91 ms\n", + "[ INFO ] Latency:\n", + "[ INFO ] Median: 54.81 ms\n", + "[ INFO ] Average: 55.02 ms\n", + "[ INFO ] Min: 34.86 ms\n", + "[ INFO ] Max: 88.69 ms\n", + "[ INFO ] Throughput: 290.58 FPS\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "d1ab597c", + "metadata": {}, + "source": [ + "# Onnx-Perf Test (FIL-Memory)\n", + "\n", + "## Perf-Test of YoloV7-tiny\n", + "### CPU\n", + "- **Performance (100 runs)**\n", + " - Average inference time cost: 17.3229 ms\n", + "- **Memory (100 runs)**\n", + " - Peak working set size: 124084224 bytes\n", + "\n", + "### OpenVINO\n", + "- **Performance (100 runs)**\n", + " - Average inference time cost: 20.0252 ms\n", + "- **Memory (100 runs)**\n", + " - Peak working set size: 290312192 bytes\n", + "- **FIL (Avg. 10 runs)**\n", + " - (Session creation time cost + Compute Cost): 0.6095 s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Perf-Test of YoloV7-tiny - INT8\n", + "### CPU\n", + "- **Performance (100 runs)**\n", + " - Average inference time cost: 89.9862 ms\n", + "- **Memory (100 runs)**\n", + " - Peak working set size: 164581376 bytes\n", + "\n", + "### OpenVINO - INT8\n", + "- **Performance (100 runs)**\n", + " - Average inference time cost: 6.40079 ms\n", + "- **Memory (100 runs)**\n", + " - Peak working set size: 300990464 bytes\n", + "- **FIL (Avg. 10 runs)**\n", + " - (Session creation time cost + Compute Cost): 1.05403456 s\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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.8.13" + }, + "vscode": { + "interpreter": { + "hash": "7ef3e8097f70ab31f7176b80e6879dd38c66e9b9742ffc082cc999ecbfceb4e1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 9cdf8a78a87728f2be7f3a24b89b4a39f4b16793 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 2 Sep 2022 15:43:49 +0530 Subject: [PATCH 05/15] updates --- .../README.md | 275 +++++++- .../OVEP_yoloV7-tiny_object_detection.ipynb | 661 +++++++++++------- 2 files changed, 659 insertions(+), 277 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index e36e4241d..15b9354a0 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -1,48 +1,259 @@ -# FP32/INT8 YOLOv7 Sample +# Official YOLOv7 -## Virtual Environement -Create a virtual environment either using a the `conda` virtual environment or `python venv`. +Implementation of paper - [YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors](https://arxiv.org/abs/2207.02696) -### Conda -```bash -$ conda create -n yolov7 python=3.8 -$ conda activate yolov7 +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/yolov7-trainable-bag-of-freebies-sets-new/real-time-object-detection-on-coco)](https://paperswithcode.com/sota/real-time-object-detection-on-coco?p=yolov7-trainable-bag-of-freebies-sets-new) +[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/akhaliq/yolov7) +Open In Colab +[![arxiv.org](http://img.shields.io/badge/cs.CV-arXiv%3A2207.02696-B31B1B.svg)](https://arxiv.org/abs/2207.02696) + + + +## Web Demo + +- Integrated into [Huggingface Spaces 🤗](https://huggingface.co/spaces/akhaliq/yolov7) using Gradio. Try out the Web Demo [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/akhaliq/yolov7) + +## Performance + +MS COCO + +| Model | Test Size | APtest | AP50test | AP75test | batch 1 fps | batch 32 average time | +| :-- | :-: | :-: | :-: | :-: | :-: | :-: | +| [**YOLOv7**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt) | 640 | **51.4%** | **69.7%** | **55.9%** | 161 *fps* | 2.8 *ms* | +| [**YOLOv7-X**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x.pt) | 640 | **53.1%** | **71.2%** | **57.8%** | 114 *fps* | 4.3 *ms* | +| | | | | | | | +| [**YOLOv7-W6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6.pt) | 1280 | **54.9%** | **72.6%** | **60.1%** | 84 *fps* | 7.6 *ms* | +| [**YOLOv7-E6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6.pt) | 1280 | **56.0%** | **73.5%** | **61.2%** | 56 *fps* | 12.3 *ms* | +| [**YOLOv7-D6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6.pt) | 1280 | **56.6%** | **74.0%** | **61.8%** | 44 *fps* | 15.0 *ms* | +| [**YOLOv7-E6E**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt) | 1280 | **56.8%** | **74.4%** | **62.1%** | 36 *fps* | 18.7 *ms* | + +## Installation + +Docker environment (recommended) +
Expand + +``` shell +# create the docker container, you can change the share memory size if you have more. +nvidia-docker run --name yolov7 -it -v your_coco_path/:/coco/ -v your_code_path/:/yolov7 --shm-size=64g nvcr.io/nvidia/pytorch:21.08-py3 + +# apt install required packages +apt update +apt install -y zip htop screen libgl1-mesa-glx + +# pip install required packages +pip install seaborn thop + +# go to code folder +cd /yolov7 +``` + +
+ +## Testing + +[`yolov7.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt) [`yolov7x.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x.pt) [`yolov7-w6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6.pt) [`yolov7-e6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6.pt) [`yolov7-d6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6.pt) [`yolov7-e6e.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt) + +``` shell +python test.py --data data/coco.yaml --img 640 --batch 32 --conf 0.001 --iou 0.65 --device 0 --weights yolov7.pt --name yolov7_640_val +``` + +You will get the results: + +``` + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.51206 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.69730 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.55521 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.35247 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.55937 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.66693 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.38453 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.63765 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.68772 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.53766 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.73549 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.83868 +``` + +To measure accuracy, download [COCO-annotations for Pycocotools](http://images.cocodataset.org/annotations/annotations_trainval2017.zip) to the `./coco/annotations/instances_val2017.json` + +## Training + +Data preparation + +``` shell +bash scripts/get_coco.sh +``` + +* Download MS COCO dataset images ([train](http://images.cocodataset.org/zips/train2017.zip), [val](http://images.cocodataset.org/zips/val2017.zip), [test](http://images.cocodataset.org/zips/test2017.zip)) and [labels](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/coco2017labels-segments.zip). If you have previously used a different version of YOLO, we strongly recommend that you delete `train2017.cache` and `val2017.cache` files, and redownload [labels](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/coco2017labels-segments.zip) + +Single GPU training + +``` shell +# train p5 models +python train.py --workers 8 --device 0 --batch-size 32 --data data/coco.yaml --img 640 640 --cfg cfg/training/yolov7.yaml --weights '' --name yolov7 --hyp data/hyp.scratch.p5.yaml + +# train p6 models +python train_aux.py --workers 8 --device 0 --batch-size 16 --data data/coco.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6.yaml --weights '' --name yolov7-w6 --hyp data/hyp.scratch.p6.yaml +``` + +Multiple GPU training + +``` shell +# train p5 models +python -m torch.distributed.launch --nproc_per_node 4 --master_port 9527 train.py --workers 8 --device 0,1,2,3 --sync-bn --batch-size 128 --data data/coco.yaml --img 640 640 --cfg cfg/training/yolov7.yaml --weights '' --name yolov7 --hyp data/hyp.scratch.p5.yaml + +# train p6 models +python -m torch.distributed.launch --nproc_per_node 8 --master_port 9527 train_aux.py --workers 8 --device 0,1,2,3,4,5,6,7 --sync-bn --batch-size 128 --data data/coco.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6.yaml --weights '' --name yolov7-w6 --hyp data/hyp.scratch.p6.yaml +``` + +## Transfer learning + +[`yolov7_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7_training.pt) [`yolov7x_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x_training.pt) [`yolov7-w6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6_training.pt) [`yolov7-e6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6_training.pt) [`yolov7-d6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6_training.pt) [`yolov7-e6e_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e_training.pt) + +Single GPU finetuning for custom dataset + +``` shell +# finetune p5 models +python train.py --workers 8 --device 0 --batch-size 32 --data data/custom.yaml --img 640 640 --cfg cfg/training/yolov7-custom.yaml --weights 'yolov7_training.pt' --name yolov7-custom --hyp data/hyp.scratch.custom.yaml + +# finetune p6 models +python train_aux.py --workers 8 --device 0 --batch-size 16 --data data/custom.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6-custom.yaml --weights 'yolov7-w6_training.pt' --name yolov7-w6-custom --hyp data/hyp.scratch.custom.yaml +``` + +## Re-parameterization + +See [reparameterization.ipynb](tools/reparameterization.ipynb) + +## Inference + +On video: +``` shell +python detect.py --weights yolov7.pt --conf 0.25 --img-size 640 --source yourvideo.mp4 ``` -### Python venv -```bash -$ python3 -m venv yolov7 -$ source yolov7/bin/activate + +On image: +``` shell +python detect.py --weights yolov7.pt --conf 0.25 --img-size 640 --source inference/images/horses.jpg ``` -## Install required packages -After creating and activating virtual environment, install the required packages: + -1. Jupyter Notebook + +## Export + +**Pytorch to CoreML (and inference on MacOS/iOS)** Open In Colab + +**Pytorch to ONNX with NMS (and inference)** Open In Colab +```shell +python export.py --weights yolov7-tiny.pt --grid --end2end --simplify \ + --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640 ``` -$ pip install jupyter + +**Pytorch to TensorRT with NMS (and inference)** Open In Colab + +```shell +wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt +python export.py --weights ./yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 +git clone https://github.com/Linaom1214/tensorrt-python.git +python ./tensorrt-python/export.py -o yolov7-tiny.onnx -e yolov7-tiny-nms.trt -p fp16 ``` -2. NNCF Experimental + +**Pytorch to TensorRT another way** Open In Colab
Expand + + +```shell +wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt +python export.py --weights yolov7-tiny.pt --grid --include-nms +git clone https://github.com/Linaom1214/tensorrt-python.git +python ./tensorrt-python/export.py -o yolov7-tiny.onnx -e yolov7-tiny-nms.trt -p fp16 + +# Or use trtexec to convert ONNX to TensorRT engine +/usr/src/tensorrt/bin/trtexec --onnx=yolov7-tiny.onnx --saveEngine=yolov7-tiny-nms.trt --fp16 ``` -$ git clone https://github.com/openvinotoolkit/nncf.git -$ cd nncf && python setup.py install --onnx -$ pip install -qr onnxruntime-openvino==1.12.0 -$ rm -fR nncf + +
+ +Tested with: Python 3.7.13, Pytorch 1.12.0+cu113 + +## Pose estimation + +[`code`](https://github.com/WongKinYiu/yolov7/tree/pose) [`yolov7-w6-pose.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt) + +See [keypoint.ipynb](https://github.com/WongKinYiu/yolov7/blob/main/tools/keypoint.ipynb). + + + + +## Instance segmentation + +[`code`](https://github.com/WongKinYiu/yolov7/tree/mask) [`yolov7-mask.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-mask.pt) + +See [instance.ipynb](https://github.com/WongKinYiu/yolov7/blob/main/tools/instance.ipynb). + + + + +## Citation + ``` -## YoloV7 +@article{wang2022yolov7, + title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, + author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, + journal={arXiv preprint arXiv:2207.02696}, + year={2022} +} +``` + + +## Teaser + +Yolov7-semantic & YOLOv7-panoptic & YOLOv7-caption -The YoloV7 repository, has a `requirements.txt` file which will install all the necessary packages. + -**Please follow the instructions mentioned within the notebook. You might have to restart the notebook once the packages are installed.** -## Dataset -The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. +## Acknowledgements -## Outputs +
Expand -- `yolov7-tiny.onnx` -- `yolov7-tiny-quantized.onnx` -- `cat-yolov7-detected.jpg` +* [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet) +* [https://github.com/WongKinYiu/yolor](https://github.com/WongKinYiu/yolor) +* [https://github.com/WongKinYiu/PyTorch_YOLOv4](https://github.com/WongKinYiu/PyTorch_YOLOv4) +* [https://github.com/WongKinYiu/ScaledYOLOv4](https://github.com/WongKinYiu/ScaledYOLOv4) +* [https://github.com/Megvii-BaseDetection/YOLOX](https://github.com/Megvii-BaseDetection/YOLOX) +* [https://github.com/ultralytics/yolov3](https://github.com/ultralytics/yolov3) +* [https://github.com/ultralytics/yolov5](https://github.com/ultralytics/yolov5) +* [https://github.com/DingXiaoH/RepVGG](https://github.com/DingXiaoH/RepVGG) +* [https://github.com/JUGGHM/OREPA_CVPR2022](https://github.com/JUGGHM/OREPA_CVPR2022) +* [https://github.com/TexasInstruments/edgeai-yolov5/tree/yolo-pose](https://github.com/TexasInstruments/edgeai-yolov5/tree/yolo-pose) -## References -### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) -### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file +
diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index 31d8ef0ab..ad080c0a3 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -20,15 +20,10 @@ "source": [ "# Object detection with YOLOv7 in Python using OpenVINO™ Execution Provider:\n", "\n", - "1. The Object detection sample uses a YOLOv4 Deep Learning ONNX Model from the ONNX Model Zoo.\n", + "1. The Object detection sample uses a YOLOv7 Deep Learning ONNX Model.\n", "\n", "\n", - "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset.\n", - "\n", - "\n", - "4. Once the inferencing is done on the sample, the recording of the same also gets downloaded on the disk.\n", - "\n", - "The source code for this sample is available [here](https://github.com/WongKinYiu/yolov7)." + "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset." ] }, { @@ -51,15 +46,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "import os\n", + "# import os\n", "\n", - "# Uncomment and the run the below lines once, if you're running this notebook\n", - "# for the first time in your virtual environment.\n", - "# Note: Comment the below line and restart the notebook before proceeding further.\n", + "# # Uncomment and the run the below lines once, if you're running this notebook\n", + "# # for the first time in your virtual environment.\n", + "# # Note: Comment the below line and restart the notebook before proceeding further.\n", "\n", "# if not os.path.exists('yolov7'):\n", "# !git clone https://github.com/WongKinYiu/yolov7 # clone\n", @@ -84,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -106,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -126,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -158,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -200,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -226,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -332,9 +327,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Avg Inference time in ms: 67.445099\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -353,9 +367,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Avg Inference time in ms: 33.327848\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -388,9 +421,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Scanning '../datasets/coco/labels/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupted: 100%|████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m onnx\u001b[38;5;241m.\u001b[39msave(quantized_model, output_model_path)\n\u001b[1;32m 2\u001b[0m nncf_logger\u001b[38;5;241m.\u001b[39minfo(\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe quantized model is saved on \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(output_model_path))\n\u001b[0;32m----> 5\u001b[0m \u001b[43monnx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchecker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_model_path\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.8/site-packages/onnx/checker.py:96\u001b[0m, in \u001b[0;36mcheck_model\u001b[0;34m(model, full_check)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcheck_model\u001b[39m(model: Union[ModelProto, Text, \u001b[38;5;28mbytes\u001b[39m], full_check: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 94\u001b[0m \u001b[38;5;66;03m# If model is a path instead of ModelProto\u001b[39;00m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(model, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m---> 96\u001b[0m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_model_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m full_check:\n\u001b[1;32m 98\u001b[0m onnx\u001b[38;5;241m.\u001b[39mshape_inference\u001b[38;5;241m.\u001b[39minfer_shapes_path(model, check_type\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, strict_mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "\u001b[0;31mValidationError\u001b[0m: scale_images initializer name is not unique" + ] + } + ], + "source": [ "onnx.save(quantized_model, output_model_path)\n", "nncf_logger.info(\n", " \"The quantized model is saved on {}\".format(output_model_path))\n", @@ -535,9 +846,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n" + ] + }, + { + "ename": "Fail", + "evalue": "[ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFail\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [17]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m params \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_path\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myolov7-tiny-quantized.onnx\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimg_input\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcat.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_runs\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m10\u001b[39m}\n\u001b[0;32m----> 6\u001b[0m \u001b[43mrun_inference\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", + "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mrun_inference\u001b[0;34m(model_path, img_input, device, num_runs, warm_up)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_inference\u001b[39m(model_path, img_input, device\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m, num_runs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, warm_up\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m):\n\u001b[1;32m 48\u001b[0m img0, proces_ratio, dwdh \u001b[38;5;241m=\u001b[39m preProcess_image(img_input)\n\u001b[0;32m---> 49\u001b[0m session, outputs, inputs \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m pred_times \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 52\u001b[0m inp \u001b[38;5;241m=\u001b[39m {inputs[\u001b[38;5;241m0\u001b[39m]:img0}\n", + "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mcreate_session\u001b[0;34m(model_path, device)\u001b[0m\n\u001b[1;32m 32\u001b[0m providers \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPUExecutionProvider\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 34\u001b[0m LOGGER\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUse ORT providers: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mproviders\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 36\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43monnxruntime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43mproviders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdevice_type\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m}\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m outname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_outputs()]\n\u001b[1;32m 41\u001b[0m inname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_inputs()]\n", + "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:347\u001b[0m, in \u001b[0;36mInferenceSession.__init__\u001b[0;34m(self, path_or_bytes, sess_options, providers, provider_options, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m disabled_optimizers \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 347\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_inference_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisabled_optimizers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m 349\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_fallback:\n", + "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:384\u001b[0m, in \u001b[0;36mInferenceSession._create_inference_session\u001b[0;34m(self, providers, provider_options, disabled_optimizers)\u001b[0m\n\u001b[1;32m 382\u001b[0m session_options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01melse\u001b[39;00m C\u001b[38;5;241m.\u001b[39mget_default_session_options()\n\u001b[1;32m 383\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_path:\n\u001b[0;32m--> 384\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_config_from_model\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 385\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 386\u001b[0m sess \u001b[38;5;241m=\u001b[39m C\u001b[38;5;241m.\u001b[39mInferenceSession(session_options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_bytes, \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_read_config_from_model)\n", + "\u001b[0;31mFail\u001b[0m: [ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images)." + ] + } + ], "source": [ "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -556,9 +890,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n" + ] + }, + { + "ename": "Fail", + "evalue": "[ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFail\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [18]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m params \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_path\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myolov7-tiny-quantized.onnx\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimg_input\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcat.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_runs\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m10\u001b[39m}\n\u001b[0;32m----> 6\u001b[0m \u001b[43mrun_inference\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", + "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mrun_inference\u001b[0;34m(model_path, img_input, device, num_runs, warm_up)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_inference\u001b[39m(model_path, img_input, device\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m, num_runs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, warm_up\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m):\n\u001b[1;32m 48\u001b[0m img0, proces_ratio, dwdh \u001b[38;5;241m=\u001b[39m preProcess_image(img_input)\n\u001b[0;32m---> 49\u001b[0m session, outputs, inputs \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m pred_times \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 52\u001b[0m inp \u001b[38;5;241m=\u001b[39m {inputs[\u001b[38;5;241m0\u001b[39m]:img0}\n", + "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mcreate_session\u001b[0;34m(model_path, device)\u001b[0m\n\u001b[1;32m 32\u001b[0m providers \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPUExecutionProvider\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 34\u001b[0m LOGGER\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUse ORT providers: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mproviders\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 36\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43monnxruntime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43mproviders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdevice_type\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m}\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m outname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_outputs()]\n\u001b[1;32m 41\u001b[0m inname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_inputs()]\n", + "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:347\u001b[0m, in \u001b[0;36mInferenceSession.__init__\u001b[0;34m(self, path_or_bytes, sess_options, providers, provider_options, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m disabled_optimizers \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 347\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_inference_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisabled_optimizers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m 349\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_fallback:\n", + "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:384\u001b[0m, in \u001b[0;36mInferenceSession._create_inference_session\u001b[0;34m(self, providers, provider_options, disabled_optimizers)\u001b[0m\n\u001b[1;32m 382\u001b[0m session_options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01melse\u001b[39;00m C\u001b[38;5;241m.\u001b[39mget_default_session_options()\n\u001b[1;32m 383\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_path:\n\u001b[0;32m--> 384\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_config_from_model\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 385\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 386\u001b[0m sess \u001b[38;5;241m=\u001b[39m C\u001b[38;5;241m.\u001b[39mInferenceSession(session_options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_bytes, \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_read_config_from_model)\n", + "\u001b[0;31mFail\u001b[0m: [ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images)." + ] + } + ], "source": [ "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -573,7 +930,7 @@ "id": "45ea764a", "metadata": {}, "source": [ - "# Benchmarking outputs on Ice-Lake CPU" + "# Benchmarking" ] }, { @@ -581,200 +938,14 @@ "id": "38c93e68", "metadata": {}, "source": [ - "- Benchmarks performed on Ice-Lake CPUs using openvino's [benchmark app](https://github.com/openvinotoolkit/openvino/tree/master/tools/benchmark_tool)\n", + "- Benchmarks can be performed using:\n", + " - openvino's [benchmark app](https://github.com/openvinotoolkit/openvino/tree/master/tools/benchmark_tool)\n", + " \n", "\n", "\n", "" ] - }, - { - "cell_type": "markdown", - "id": "dd8faa25", - "metadata": {}, - "source": [ - "## Benchmark of YoloV7-Tiny\n", - "```bash\n", - "\n", - "[Step 1/11] Parsing and validating input arguments\n", - "[ INFO ] Parsing input parameters\n", - "[Step 2/11] Loading Inference Engine\n", - "[ INFO ] OpenVINO: OpenVINO Runtime version ......... 2022.1.0\n", - "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", - "[ INFO ]\n", - "[ INFO ] Device info:\n", - "[ INFO ] CPU\n", - "[ INFO ] openvino_intel_cpu_plugin version ......... 2022.1.0\n", - "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", - "[ INFO ]\n", - "[ INFO ]\n", - "[Step 3/11] Setting device configuration\n", - "[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to THROUGHPUT.\n", - "[Step 4/11] Reading network files\n", - "[ INFO ] Loading network files\n", - "[ INFO ] Read network took 105.86 ms\n", - "[Step 5/11] Resizing network to match image sizes and given batch\n", - "[ WARNING ] images: layout is not set explicitly, so it is defaulted to NCHW. It is STRONGLY recommended to set layout manually to avoid further issues.\n", - "[ INFO ] Reshaping network: 'images': {1,3,640,640}\n", - "[ INFO ] Reshape network took 0.01 ms\n", - "[Step 6/11] Configuring input of the model\n", - "[ INFO ] Network batch size: 1\n", - "Network inputs:\n", - " images (node: images) : u8 / [N,C,H,W]\n", - "Network outputs:\n", - " output (node: output) : f32 / [...]\n", - "[Step 7/11] Loading the model to the device\n", - "[ INFO ] Load network took 778.20 ms\n", - "[Step 8/11] Setting optimal runtime parameters\n", - "[ INFO ] Device: CPU\n", - "[ INFO ] { NETWORK_NAME , torch-jit-export }\n", - "[ INFO ] { OPTIMAL_NUMBER_OF_INFER_REQUESTS , 16 }\n", - "[ INFO ] { NUM_STREAMS , 16 }\n", - "[ INFO ] { AFFINITY , CORE }\n", - "[ INFO ] { INFERENCE_NUM_THREADS , 0 }\n", - "[ INFO ] { PERF_COUNT , NO }\n", - "[ INFO ] { INFERENCE_PRECISION_HINT , f32 }\n", - "[ INFO ] { PERFORMANCE_HINT , THROUGHPUT }\n", - "[ INFO ] { PERFORMANCE_HINT_NUM_REQUESTS , 0 }\n", - "[Step 9/11] Creating infer requests and preparing input blobs with data\n", - "[ WARNING ] No input files were given: all inputs will be filled with random values!\n", - "[ INFO ] Test Config 0\n", - "[ INFO ] images ([N,C,H,W], u8, {1, 3, 640, 640}, static): random (image is expected)\n", - "[Step 10/11] Measuring performance (Start inference asynchronously, 16 inference requests, limits: 60000 ms duration)\n", - "[ INFO ] BENCHMARK IS IN INFERENCE ONLY MODE.\n", - "[ INFO ] Input blobs will be filled once before performance measurements.\n", - "[ INFO ] First inference took 101.71 ms\n", - "\n", - "[Step 11/11] Dumping statistics report\n", - "[ INFO ] Count: 9728 iterations\n", - "[ INFO ] Duration: 60123.06 ms\n", - "[ INFO ] Latency:\n", - "[ INFO ] Median: 98.49 ms\n", - "[ INFO ] Average: 98.81 ms\n", - "[ INFO ] Min: 55.92 ms\n", - "[ INFO ] Max: 140.48 ms\n", - "[ INFO ] Throughput: 161.80 FPS\n", - "\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "dccbf2f3", - "metadata": {}, - "source": [ - "## Benchmark of YoloV-INT-8\n", - "```bash\n", - "[Step 1/11] Parsing and validating input arguments\n", - "[ INFO ] Parsing input parameters\n", - "[Step 2/11] Loading Inference Engine\n", - "[ INFO ] OpenVINO: OpenVINO Runtime version ......... 2022.1.0\n", - "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", - "[ INFO ]\n", - "[ INFO ] Device info:\n", - "[ INFO ] CPU\n", - "[ INFO ] openvino_intel_cpu_plugin version ......... 2022.1.0\n", - "[ INFO ] Build ........... 2022.1.0-7019-cdb9bec7210-releases/2022/1\n", - "[ INFO ]\n", - "[ INFO ]\n", - "[Step 3/11] Setting device configuration\n", - "[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to THROUGHPUT.\n", - "[Step 4/11] Reading network files\n", - "[ INFO ] Loading network files\n", - "[ INFO ] Read network took 173.56 ms\n", - "[Step 5/11] Resizing network to match image sizes and given batch\n", - "[ WARNING ] images: layout is not set explicitly, so it is defaulted to NCHW. It is STRONGLY recommended to set layout manually to avoid further issues.\n", - "[ INFO ] Reshaping network: 'images': {1,3,640,640}\n", - "[ INFO ] Reshape network took 0.01 ms\n", - "[Step 6/11] Configuring input of the model\n", - "[ INFO ] Network batch size: 1\n", - "Network inputs:\n", - " images (node: images) : u8 / [N,C,H,W]\n", - "Network outputs:\n", - " output (node: output) : f32 / [...]\n", - "[Step 7/11] Loading the model to the device\n", - "[ INFO ] Load network took 1317.18 ms\n", - "[Step 8/11] Setting optimal runtime parameters\n", - "[ INFO ] Device: CPU\n", - "[ INFO ] { NETWORK_NAME , torch-jit-export }\n", - "[ INFO ] { OPTIMAL_NUMBER_OF_INFER_REQUESTS , 16 }\n", - "[ INFO ] { NUM_STREAMS , 16 }\n", - "[ INFO ] { AFFINITY , CORE }\n", - "[ INFO ] { INFERENCE_NUM_THREADS , 0 }\n", - "[ INFO ] { PERF_COUNT , NO }\n", - "[ INFO ] { INFERENCE_PRECISION_HINT , f32 }\n", - "[ INFO ] { PERFORMANCE_HINT , THROUGHPUT }\n", - "[ INFO ] { PERFORMANCE_HINT_NUM_REQUESTS , 0 }\n", - "[Step 9/11] Creating infer requests and preparing input blobs with data\n", - "[ WARNING ] No input files were given: all inputs will be filled with random values!\n", - "[ INFO ] Test Config 0\n", - "[ INFO ] images ([N,C,H,W], u8, {1, 3, 640, 640}, static): random (image is expected)\n", - "[Step 10/11] Measuring performance (Start inference asynchronously, 16 inference requests, limits: 60000 ms duration)\n", - "[ INFO ] BENCHMARK IS IN INFERENCE ONLY MODE.\n", - "[ INFO ] Input blobs will be filled once before performance measurements.\n", - "[ INFO ] First inference took 82.32 ms\n", - "\n", - "[Step 11/11] Dumping statistics report\n", - "[ INFO ] Count: 17456 iterations\n", - "[ INFO ] Duration: 60073.91 ms\n", - "[ INFO ] Latency:\n", - "[ INFO ] Median: 54.81 ms\n", - "[ INFO ] Average: 55.02 ms\n", - "[ INFO ] Min: 34.86 ms\n", - "[ INFO ] Max: 88.69 ms\n", - "[ INFO ] Throughput: 290.58 FPS\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "d1ab597c", - "metadata": {}, - "source": [ - "# Onnx-Perf Test (FIL-Memory)\n", - "\n", - "## Perf-Test of YoloV7-tiny\n", - "### CPU\n", - "- **Performance (100 runs)**\n", - " - Average inference time cost: 17.3229 ms\n", - "- **Memory (100 runs)**\n", - " - Peak working set size: 124084224 bytes\n", - "\n", - "### OpenVINO\n", - "- **Performance (100 runs)**\n", - " - Average inference time cost: 20.0252 ms\n", - "- **Memory (100 runs)**\n", - " - Peak working set size: 290312192 bytes\n", - "- **FIL (Avg. 10 runs)**\n", - " - (Session creation time cost + Compute Cost): 0.6095 s" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Perf-Test of YoloV7-tiny - INT8\n", - "### CPU\n", - "- **Performance (100 runs)**\n", - " - Average inference time cost: 89.9862 ms\n", - "- **Memory (100 runs)**\n", - " - Peak working set size: 164581376 bytes\n", - "\n", - "### OpenVINO - INT8\n", - "- **Performance (100 runs)**\n", - " - Average inference time cost: 6.40079 ms\n", - "- **Memory (100 runs)**\n", - " - Peak working set size: 300990464 bytes\n", - "- **FIL (Avg. 10 runs)**\n", - " - (Session creation time cost + Compute Cost): 1.05403456 s\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] } ], "metadata": { From 27c7c39fbe68fa10205f88ab5d8a8ae9ae21904e Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 2 Sep 2022 15:46:30 +0530 Subject: [PATCH 06/15] updates Readme --- .../README.md | 275 ++---------------- 1 file changed, 32 insertions(+), 243 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index 15b9354a0..e36e4241d 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -1,259 +1,48 @@ -# Official YOLOv7 +# FP32/INT8 YOLOv7 Sample -Implementation of paper - [YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors](https://arxiv.org/abs/2207.02696) +## Virtual Environement +Create a virtual environment either using a the `conda` virtual environment or `python venv`. -[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/yolov7-trainable-bag-of-freebies-sets-new/real-time-object-detection-on-coco)](https://paperswithcode.com/sota/real-time-object-detection-on-coco?p=yolov7-trainable-bag-of-freebies-sets-new) -[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/akhaliq/yolov7) -Open In Colab -[![arxiv.org](http://img.shields.io/badge/cs.CV-arXiv%3A2207.02696-B31B1B.svg)](https://arxiv.org/abs/2207.02696) - - - -## Web Demo - -- Integrated into [Huggingface Spaces 🤗](https://huggingface.co/spaces/akhaliq/yolov7) using Gradio. Try out the Web Demo [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/akhaliq/yolov7) - -## Performance - -MS COCO - -| Model | Test Size | APtest | AP50test | AP75test | batch 1 fps | batch 32 average time | -| :-- | :-: | :-: | :-: | :-: | :-: | :-: | -| [**YOLOv7**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt) | 640 | **51.4%** | **69.7%** | **55.9%** | 161 *fps* | 2.8 *ms* | -| [**YOLOv7-X**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x.pt) | 640 | **53.1%** | **71.2%** | **57.8%** | 114 *fps* | 4.3 *ms* | -| | | | | | | | -| [**YOLOv7-W6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6.pt) | 1280 | **54.9%** | **72.6%** | **60.1%** | 84 *fps* | 7.6 *ms* | -| [**YOLOv7-E6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6.pt) | 1280 | **56.0%** | **73.5%** | **61.2%** | 56 *fps* | 12.3 *ms* | -| [**YOLOv7-D6**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6.pt) | 1280 | **56.6%** | **74.0%** | **61.8%** | 44 *fps* | 15.0 *ms* | -| [**YOLOv7-E6E**](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt) | 1280 | **56.8%** | **74.4%** | **62.1%** | 36 *fps* | 18.7 *ms* | - -## Installation - -Docker environment (recommended) -
Expand - -``` shell -# create the docker container, you can change the share memory size if you have more. -nvidia-docker run --name yolov7 -it -v your_coco_path/:/coco/ -v your_code_path/:/yolov7 --shm-size=64g nvcr.io/nvidia/pytorch:21.08-py3 - -# apt install required packages -apt update -apt install -y zip htop screen libgl1-mesa-glx - -# pip install required packages -pip install seaborn thop - -# go to code folder -cd /yolov7 -``` - -
- -## Testing - -[`yolov7.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt) [`yolov7x.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x.pt) [`yolov7-w6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6.pt) [`yolov7-e6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6.pt) [`yolov7-d6.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6.pt) [`yolov7-e6e.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt) - -``` shell -python test.py --data data/coco.yaml --img 640 --batch 32 --conf 0.001 --iou 0.65 --device 0 --weights yolov7.pt --name yolov7_640_val -``` - -You will get the results: - -``` - Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.51206 - Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.69730 - Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.55521 - Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.35247 - Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.55937 - Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.66693 - Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.38453 - Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.63765 - Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.68772 - Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.53766 - Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.73549 - Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.83868 -``` - -To measure accuracy, download [COCO-annotations for Pycocotools](http://images.cocodataset.org/annotations/annotations_trainval2017.zip) to the `./coco/annotations/instances_val2017.json` - -## Training - -Data preparation - -``` shell -bash scripts/get_coco.sh -``` - -* Download MS COCO dataset images ([train](http://images.cocodataset.org/zips/train2017.zip), [val](http://images.cocodataset.org/zips/val2017.zip), [test](http://images.cocodataset.org/zips/test2017.zip)) and [labels](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/coco2017labels-segments.zip). If you have previously used a different version of YOLO, we strongly recommend that you delete `train2017.cache` and `val2017.cache` files, and redownload [labels](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/coco2017labels-segments.zip) - -Single GPU training - -``` shell -# train p5 models -python train.py --workers 8 --device 0 --batch-size 32 --data data/coco.yaml --img 640 640 --cfg cfg/training/yolov7.yaml --weights '' --name yolov7 --hyp data/hyp.scratch.p5.yaml - -# train p6 models -python train_aux.py --workers 8 --device 0 --batch-size 16 --data data/coco.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6.yaml --weights '' --name yolov7-w6 --hyp data/hyp.scratch.p6.yaml -``` - -Multiple GPU training - -``` shell -# train p5 models -python -m torch.distributed.launch --nproc_per_node 4 --master_port 9527 train.py --workers 8 --device 0,1,2,3 --sync-bn --batch-size 128 --data data/coco.yaml --img 640 640 --cfg cfg/training/yolov7.yaml --weights '' --name yolov7 --hyp data/hyp.scratch.p5.yaml - -# train p6 models -python -m torch.distributed.launch --nproc_per_node 8 --master_port 9527 train_aux.py --workers 8 --device 0,1,2,3,4,5,6,7 --sync-bn --batch-size 128 --data data/coco.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6.yaml --weights '' --name yolov7-w6 --hyp data/hyp.scratch.p6.yaml -``` - -## Transfer learning - -[`yolov7_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7_training.pt) [`yolov7x_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x_training.pt) [`yolov7-w6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6_training.pt) [`yolov7-e6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6_training.pt) [`yolov7-d6_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6_training.pt) [`yolov7-e6e_training.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e_training.pt) - -Single GPU finetuning for custom dataset - -``` shell -# finetune p5 models -python train.py --workers 8 --device 0 --batch-size 32 --data data/custom.yaml --img 640 640 --cfg cfg/training/yolov7-custom.yaml --weights 'yolov7_training.pt' --name yolov7-custom --hyp data/hyp.scratch.custom.yaml - -# finetune p6 models -python train_aux.py --workers 8 --device 0 --batch-size 16 --data data/custom.yaml --img 1280 1280 --cfg cfg/training/yolov7-w6-custom.yaml --weights 'yolov7-w6_training.pt' --name yolov7-w6-custom --hyp data/hyp.scratch.custom.yaml -``` - -## Re-parameterization - -See [reparameterization.ipynb](tools/reparameterization.ipynb) - -## Inference - -On video: -``` shell -python detect.py --weights yolov7.pt --conf 0.25 --img-size 640 --source yourvideo.mp4 +### Conda +```bash +$ conda create -n yolov7 python=3.8 +$ conda activate yolov7 ``` - -On image: -``` shell -python detect.py --weights yolov7.pt --conf 0.25 --img-size 640 --source inference/images/horses.jpg +### Python venv +```bash +$ python3 -m venv yolov7 +$ source yolov7/bin/activate ``` - +## Install required packages +After creating and activating virtual environment, install the required packages: - -## Export - -**Pytorch to CoreML (and inference on MacOS/iOS)** Open In Colab - -**Pytorch to ONNX with NMS (and inference)** Open In Colab -```shell -python export.py --weights yolov7-tiny.pt --grid --end2end --simplify \ - --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640 +1. Jupyter Notebook ``` - -**Pytorch to TensorRT with NMS (and inference)** Open In Colab - -```shell -wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt -python export.py --weights ./yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 -git clone https://github.com/Linaom1214/tensorrt-python.git -python ./tensorrt-python/export.py -o yolov7-tiny.onnx -e yolov7-tiny-nms.trt -p fp16 +$ pip install jupyter ``` - -**Pytorch to TensorRT another way** Open In Colab
Expand - - -```shell -wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt -python export.py --weights yolov7-tiny.pt --grid --include-nms -git clone https://github.com/Linaom1214/tensorrt-python.git -python ./tensorrt-python/export.py -o yolov7-tiny.onnx -e yolov7-tiny-nms.trt -p fp16 - -# Or use trtexec to convert ONNX to TensorRT engine -/usr/src/tensorrt/bin/trtexec --onnx=yolov7-tiny.onnx --saveEngine=yolov7-tiny-nms.trt --fp16 +2. NNCF Experimental ``` - -
- -Tested with: Python 3.7.13, Pytorch 1.12.0+cu113 - -## Pose estimation - -[`code`](https://github.com/WongKinYiu/yolov7/tree/pose) [`yolov7-w6-pose.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt) - -See [keypoint.ipynb](https://github.com/WongKinYiu/yolov7/blob/main/tools/keypoint.ipynb). - - - - -## Instance segmentation - -[`code`](https://github.com/WongKinYiu/yolov7/tree/mask) [`yolov7-mask.pt`](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-mask.pt) - -See [instance.ipynb](https://github.com/WongKinYiu/yolov7/blob/main/tools/instance.ipynb). - - - - -## Citation - +$ git clone https://github.com/openvinotoolkit/nncf.git +$ cd nncf && python setup.py install --onnx +$ pip install -qr onnxruntime-openvino==1.12.0 +$ rm -fR nncf ``` -@article{wang2022yolov7, - title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, - author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, - journal={arXiv preprint arXiv:2207.02696}, - year={2022} -} -``` - - -## Teaser - -Yolov7-semantic & YOLOv7-panoptic & YOLOv7-caption +## YoloV7 - +The YoloV7 repository, has a `requirements.txt` file which will install all the necessary packages. +**Please follow the instructions mentioned within the notebook. You might have to restart the notebook once the packages are installed.** -## Acknowledgements +## Dataset +The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. -
Expand +## Outputs -* [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet) -* [https://github.com/WongKinYiu/yolor](https://github.com/WongKinYiu/yolor) -* [https://github.com/WongKinYiu/PyTorch_YOLOv4](https://github.com/WongKinYiu/PyTorch_YOLOv4) -* [https://github.com/WongKinYiu/ScaledYOLOv4](https://github.com/WongKinYiu/ScaledYOLOv4) -* [https://github.com/Megvii-BaseDetection/YOLOX](https://github.com/Megvii-BaseDetection/YOLOX) -* [https://github.com/ultralytics/yolov3](https://github.com/ultralytics/yolov3) -* [https://github.com/ultralytics/yolov5](https://github.com/ultralytics/yolov5) -* [https://github.com/DingXiaoH/RepVGG](https://github.com/DingXiaoH/RepVGG) -* [https://github.com/JUGGHM/OREPA_CVPR2022](https://github.com/JUGGHM/OREPA_CVPR2022) -* [https://github.com/TexasInstruments/edgeai-yolov5/tree/yolo-pose](https://github.com/TexasInstruments/edgeai-yolov5/tree/yolo-pose) +- `yolov7-tiny.onnx` +- `yolov7-tiny-quantized.onnx` +- `cat-yolov7-detected.jpg` -
+## References +### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) +### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file From b0c3cf94af7a81be924c1d7dcbb71c5f9dc768ce Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 2 Sep 2022 16:58:23 +0530 Subject: [PATCH 07/15] error corrections --- .../README.md | 25 +- .../OVEP_yoloV7-tiny_object_detection.ipynb | 461 ++---------------- 2 files changed, 57 insertions(+), 429 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index e36e4241d..a0736aa3f 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -4,12 +4,12 @@ Create a virtual environment either using a the `conda` virtual environment or `python venv`. ### Conda -```bash +``` $ conda create -n yolov7 python=3.8 $ conda activate yolov7 ``` ### Python venv -```bash +``` $ python3 -m venv yolov7 $ source yolov7/bin/activate ``` @@ -19,21 +19,26 @@ After creating and activating virtual environment, install the required packages 1. Jupyter Notebook ``` -$ pip install jupyter +$ pip install --no-cache-dir jupyter ``` 2. NNCF Experimental ``` $ git clone https://github.com/openvinotoolkit/nncf.git $ cd nncf && python setup.py install --onnx -$ pip install -qr onnxruntime-openvino==1.12.0 -$ rm -fR nncf +$ pip install --no-cache-dir onnxruntime-openvino==1.11.0 +$ pip install --no-cache-dir onnxconverter_common +$ cd .. && rm -fR nncf ``` -## YoloV7 - -The YoloV7 repository, has a `requirements.txt` file which will install all the necessary packages. - -**Please follow the instructions mentioned within the notebook. You might have to restart the notebook once the packages are installed.** +3. YoloV7 requirements +``` +$ cd notebooks +$ git clone https://github.com/WongKinYiu/yolov7 +$ cp -R yolov7/* . +$ pip install --no-cache-dir -r requirements.txt +$ rm -fR yolov7 +``` +Launch the notebook from here. ## Dataset The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index ad080c0a3..4df6cfdde 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -32,42 +32,7 @@ "source": [ "**Before starting with this notebook please make sure to perform the required installations as mentioned below:**\n", "1. [YoloV7 installation requirements](https://github.com/WongKinYiu/yolov7#installation)\n", - "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)\n", - "\n", - "## Install Requirements" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### YoloV7" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# import os\n", - "\n", - "# # Uncomment and the run the below lines once, if you're running this notebook\n", - "# # for the first time in your virtual environment.\n", - "# # Note: Comment the below line and restart the notebook before proceeding further.\n", - "\n", - "# if not os.path.exists('yolov7'):\n", - "# !git clone https://github.com/WongKinYiu/yolov7 # clone\n", - "# !cp -R yolov7/* .\n", - "# !pip install -qr requirements.txt # install\n", - "# !rm -fR yolov7" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Note: You might have to restart the session before continuing. Please make sure to comment the above cells once the installations are complete and the session is restarted.**" + "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)" ] }, { @@ -79,12 +44,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "import torch\n", + "import warnings\n", + "warnings.filterwarnings(action=\"ignore\")\n", "\n", "if not os.path.exists(\"../datasets\"):\n", " # Download COCO val\n", @@ -101,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -121,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -148,12 +115,12 @@ "\n", "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", - "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `image_preprocess` helper function." + "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `preProcess_image` helper function." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -195,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -221,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -296,7 +263,8 @@ "\n", " ori_images = cv2.imread(img_input)\n", " ori_images = [cv2.cvtColor(ori_images, cv2.COLOR_BGR2RGB)]\n", - "\n", + " \n", + " # NMS (Non-Max Supression)\n", " for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(pred):\n", " image = ori_images[int(batch_id)]\n", " box = np.array([x0,y0,x1,y1])\n", @@ -315,7 +283,9 @@ " print('Avg Inference time in ms: %f' %\n", " (sum(pred_times) / len(pred_times) * 1000))\n", " plt.imshow(Image.fromarray(ori_images[0]))\n", - " plt.axis('off')" + " plt.axis('off')\n", + " f = f\"{img_input.split('.')[0]}_{model_path.split('.')[0]}_{device}.jpg\"\n", + " plt.imsave(f, Image.fromarray(ori_images[0]))" ] }, { @@ -327,28 +297,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Avg Inference time in ms: 67.445099\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -367,28 +318,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Avg Inference time in ms: 33.327848\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -421,17 +353,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Scanning '../datasets/coco/labels/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupted: 100%|████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m onnx\u001b[38;5;241m.\u001b[39msave(quantized_model, output_model_path)\n\u001b[1;32m 2\u001b[0m nncf_logger\u001b[38;5;241m.\u001b[39minfo(\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe quantized model is saved on \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(output_model_path))\n\u001b[0;32m----> 5\u001b[0m \u001b[43monnx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchecker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_model_path\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.8/site-packages/onnx/checker.py:96\u001b[0m, in \u001b[0;36mcheck_model\u001b[0;34m(model, full_check)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcheck_model\u001b[39m(model: Union[ModelProto, Text, \u001b[38;5;28mbytes\u001b[39m], full_check: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 94\u001b[0m \u001b[38;5;66;03m# If model is a path instead of ModelProto\u001b[39;00m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(model, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m---> 96\u001b[0m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_model_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m full_check:\n\u001b[1;32m 98\u001b[0m onnx\u001b[38;5;241m.\u001b[39mshape_inference\u001b[38;5;241m.\u001b[39minfer_shapes_path(model, check_type\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, strict_mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "\u001b[0;31mValidationError\u001b[0m: scale_images initializer name is not unique" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "onnx.save(quantized_model, output_model_path)\n", "nncf_logger.info(\n", @@ -846,32 +513,11 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n" - ] - }, - { - "ename": "Fail", - "evalue": "[ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images).", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFail\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [17]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m params \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_path\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myolov7-tiny-quantized.onnx\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimg_input\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcat.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_runs\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m10\u001b[39m}\n\u001b[0;32m----> 6\u001b[0m \u001b[43mrun_inference\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", - "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mrun_inference\u001b[0;34m(model_path, img_input, device, num_runs, warm_up)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_inference\u001b[39m(model_path, img_input, device\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m, num_runs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, warm_up\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m):\n\u001b[1;32m 48\u001b[0m img0, proces_ratio, dwdh \u001b[38;5;241m=\u001b[39m preProcess_image(img_input)\n\u001b[0;32m---> 49\u001b[0m session, outputs, inputs \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m pred_times \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 52\u001b[0m inp \u001b[38;5;241m=\u001b[39m {inputs[\u001b[38;5;241m0\u001b[39m]:img0}\n", - "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mcreate_session\u001b[0;34m(model_path, device)\u001b[0m\n\u001b[1;32m 32\u001b[0m providers \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPUExecutionProvider\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 34\u001b[0m LOGGER\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUse ORT providers: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mproviders\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 36\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43monnxruntime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43mproviders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdevice_type\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m}\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m outname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_outputs()]\n\u001b[1;32m 41\u001b[0m inname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_inputs()]\n", - "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:347\u001b[0m, in \u001b[0;36mInferenceSession.__init__\u001b[0;34m(self, path_or_bytes, sess_options, providers, provider_options, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m disabled_optimizers \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 347\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_inference_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisabled_optimizers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m 349\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_fallback:\n", - "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:384\u001b[0m, in \u001b[0;36mInferenceSession._create_inference_session\u001b[0;34m(self, providers, provider_options, disabled_optimizers)\u001b[0m\n\u001b[1;32m 382\u001b[0m session_options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01melse\u001b[39;00m C\u001b[38;5;241m.\u001b[39mget_default_session_options()\n\u001b[1;32m 383\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_path:\n\u001b[0;32m--> 384\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_config_from_model\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 385\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 386\u001b[0m sess \u001b[38;5;241m=\u001b[39m C\u001b[38;5;241m.\u001b[39mInferenceSession(session_options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_bytes, \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_read_config_from_model)\n", - "\u001b[0;31mFail\u001b[0m: [ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images)." - ] - } - ], + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], "source": [ "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -890,32 +536,9 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n" - ] - }, - { - "ename": "Fail", - "evalue": "[ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images).", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFail\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [18]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m params \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_path\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myolov7-tiny-quantized.onnx\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimg_input\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcat.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdevice\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_runs\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m10\u001b[39m}\n\u001b[0;32m----> 6\u001b[0m \u001b[43mrun_inference\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", - "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mrun_inference\u001b[0;34m(model_path, img_input, device, num_runs, warm_up)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_inference\u001b[39m(model_path, img_input, device\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPU_FP32\u001b[39m\u001b[38;5;124m'\u001b[39m, num_runs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, warm_up\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m):\n\u001b[1;32m 48\u001b[0m img0, proces_ratio, dwdh \u001b[38;5;241m=\u001b[39m preProcess_image(img_input)\n\u001b[0;32m---> 49\u001b[0m session, outputs, inputs \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m pred_times \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 52\u001b[0m inp \u001b[38;5;241m=\u001b[39m {inputs[\u001b[38;5;241m0\u001b[39m]:img0}\n", - "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36mcreate_session\u001b[0;34m(model_path, device)\u001b[0m\n\u001b[1;32m 32\u001b[0m providers \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCPUExecutionProvider\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 34\u001b[0m LOGGER\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUse ORT providers: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mproviders\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 36\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43monnxruntime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43mproviders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdevice_type\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m}\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m outname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_outputs()]\n\u001b[1;32m 41\u001b[0m inname \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39mname \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m sess\u001b[38;5;241m.\u001b[39mget_inputs()]\n", - "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:347\u001b[0m, in \u001b[0;36mInferenceSession.__init__\u001b[0;34m(self, path_or_bytes, sess_options, providers, provider_options, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m disabled_optimizers \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisabled_optimizers\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 347\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_inference_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43mproviders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisabled_optimizers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m 349\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_fallback:\n", - "File \u001b[0;32m~/miniconda3/envs/yolov7_test/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:384\u001b[0m, in \u001b[0;36mInferenceSession._create_inference_session\u001b[0;34m(self, providers, provider_options, disabled_optimizers)\u001b[0m\n\u001b[1;32m 382\u001b[0m session_options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sess_options \u001b[38;5;28;01melse\u001b[39;00m C\u001b[38;5;241m.\u001b[39mget_default_session_options()\n\u001b[1;32m 383\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_path:\n\u001b[0;32m--> 384\u001b[0m sess \u001b[38;5;241m=\u001b[39m \u001b[43mC\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mInferenceSession\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_config_from_model\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 385\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 386\u001b[0m sess \u001b[38;5;241m=\u001b[39m C\u001b[38;5;241m.\u001b[39mInferenceSession(session_options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model_bytes, \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_read_config_from_model)\n", - "\u001b[0;31mFail\u001b[0m: [ONNXRuntimeError] : 1 : FAIL : Load model from yolov7-tiny-quantized.onnx failed:This is an invalid model. Error: two nodes with same node name (QuantizeLinear_images)." - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", " \"img_input\": \"cat.jpg\",\n", @@ -964,7 +587,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.10" }, "vscode": { "interpreter": { From 94bbe62b29c271943690944ab41637c24bfa49bb Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 2 Sep 2022 17:07:51 +0530 Subject: [PATCH 08/15] error corrections + comments --- .../OVEP_yoloV7-tiny_object_detection.ipynb | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index 4df6cfdde..461652dbd 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -234,9 +234,36 @@ " outname = [i.name for i in sess.get_outputs()]\n", " inname = [i.name for i in sess.get_inputs()]\n", " \n", - " return sess, outname, inname\n", + " return sess, outname, inname\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run Inference Function\n", "\n", + "The `run-inference` function takes inputs as:\n", + "- `model_path` $\\rightarrow$ `.onnx`\n", + "- `img_input` $\\rightarrow$ `.jpg`\n", + "- `device` $\\rightarrow$ `device using which the inference should be run e.g. cpu, CPU_FP32` \n", + " Based on the device arguement the execution providers are selected.\n", "\n", + "It performs the following tasks:\n", + "- Pre-process the input image as per model requirements\n", + "- Creates the appropriate onnxruntime session as per the device arguement\n", + "- Runs inferences according to the number of runs passed\n", + "- Performs non-max suppression on the predictions\n", + "- Adds bounding boxes on the detected objects\n", + "- Saves a copy of the inferred image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "def run_inference(model_path, img_input, device='CPU_FP32', num_runs=10, warm_up=3):\n", " \n", " img0, proces_ratio, dwdh = preProcess_image(img_input)\n", From 2b5a1a48b3a049702d7de29896a4ae22e8323f15 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Wed, 7 Sep 2022 10:33:39 +0530 Subject: [PATCH 09/15] cleanup --- .../README.md | 53 -- .../OVEP_yoloV7-tiny_object_detection.ipynb | 627 ------------------ 2 files changed, 680 deletions(-) delete mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md delete mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md deleted file mode 100644 index a0736aa3f..000000000 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ /dev/null @@ -1,53 +0,0 @@ -# FP32/INT8 YOLOv7 Sample - -## Virtual Environement -Create a virtual environment either using a the `conda` virtual environment or `python venv`. - -### Conda -``` -$ conda create -n yolov7 python=3.8 -$ conda activate yolov7 -``` -### Python venv -``` -$ python3 -m venv yolov7 -$ source yolov7/bin/activate -``` - -## Install required packages -After creating and activating virtual environment, install the required packages: - -1. Jupyter Notebook -``` -$ pip install --no-cache-dir jupyter -``` -2. NNCF Experimental -``` -$ git clone https://github.com/openvinotoolkit/nncf.git -$ cd nncf && python setup.py install --onnx -$ pip install --no-cache-dir onnxruntime-openvino==1.11.0 -$ pip install --no-cache-dir onnxconverter_common -$ cd .. && rm -fR nncf -``` -3. YoloV7 requirements - -``` -$ cd notebooks -$ git clone https://github.com/WongKinYiu/yolov7 -$ cp -R yolov7/* . -$ pip install --no-cache-dir -r requirements.txt -$ rm -fR yolov7 -``` -Launch the notebook from here. -## Dataset -The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. - -## Outputs - -- `yolov7-tiny.onnx` -- `yolov7-tiny-quantized.onnx` -- `cat-yolov7-detected.jpg` - -## References -### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) -### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb deleted file mode 100644 index 461652dbd..000000000 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ /dev/null @@ -1,627 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b6157254", - "metadata": { - "id": "b6157254" - }, - "source": [ - "Major Portions of this code are copyright of their respective authors and released under the General Public License Version 3.0:\n", - "- For licensing see https://github.com/WongKinYiu/yolov7/blob/main/LICENSE.md" - ] - }, - { - "cell_type": "markdown", - "id": "dfed77f6", - "metadata": { - "id": "dfed77f6" - }, - "source": [ - "# Object detection with YOLOv7 in Python using OpenVINO™ Execution Provider:\n", - "\n", - "1. The Object detection sample uses a YOLOv7 Deep Learning ONNX Model.\n", - "\n", - "\n", - "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Before starting with this notebook please make sure to perform the required installations as mentioned below:**\n", - "1. [YoloV7 installation requirements](https://github.com/WongKinYiu/yolov7#installation)\n", - "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Download COCO validation dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import torch\n", - "import warnings\n", - "warnings.filterwarnings(action=\"ignore\")\n", - "\n", - "if not os.path.exists(\"../datasets\"):\n", - " # Download COCO val\n", - " torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", - " !unzip -q tmp.zip -d ../datasets && rm tmp.zip" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Export yolov7-tiny model to ONNX format" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", - " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", - " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", - "if not os.path.exists('cat.jpg'):\n", - " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Import Required Libraries" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Inference for ONNX model\n", - "import cv2\n", - "import time\n", - "import requests\n", - "import random\n", - "import logging\n", - "import numpy as np\n", - "import onnxruntime\n", - "from PIL import Image\n", - "from pathlib import Path\n", - "from collections import OrderedDict,namedtuple\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define necessary helper functions\n", - "### Pre-Processing\n", - "\n", - "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", - "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", - "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `preProcess_image` helper function." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32):\n", - " # Resize and pad image while meeting stride-multiple constraints\n", - " shape = im.shape[:2] # current shape [height, width]\n", - " if isinstance(new_shape, int):\n", - " new_shape = (new_shape, new_shape)\n", - "\n", - " # Scale ratio (new / old)\n", - " r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])\n", - " if not scaleup: # only scale down, do not scale up (for better val mAP)\n", - " r = min(r, 1.0)\n", - "\n", - " # Compute padding\n", - " new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))\n", - " dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding\n", - "\n", - " if auto: # minimum rectangle\n", - " dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding\n", - "\n", - " dw /= 2 # divide padding into 2 sides\n", - " dh /= 2\n", - "\n", - " if shape[::-1] != new_unpad: # resize\n", - " im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)\n", - " top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))\n", - " left, right = int(round(dw - 0.1)), int(round(dw + 0.1))\n", - " im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border\n", - " return im, r, (dw, dh)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Labels and Colors for Lables" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "random.seed(42)\n", - "names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', \n", - " 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', \n", - " 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', \n", - " 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', \n", - " 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', \n", - " 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', \n", - " 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', \n", - " 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', \n", - " 'hair drier', 'toothbrush']\n", - "colors = {name:[random.randint(0, 255) for _ in range(3)] for i,name in enumerate(names)}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read & Pre-Process Image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def set_logging(rank=-1):\n", - " logging.basicConfig(\n", - " format=\"%(message)s\",\n", - " level=logging.INFO if rank in [-1, 0] else logging.WARN)\n", - " \n", - "set_logging(5) # run before defining LOGGER\n", - "LOGGER = logging.getLogger(\"yolov7\")\n", - "\n", - "def preProcess_image(img_path):\n", - " img = cv2.imread(img_path)\n", - " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", - "\n", - " image = img.copy()\n", - " image, ratio, dwdh = letterbox(image, auto=False)\n", - " image = image.transpose((2, 0, 1))\n", - " image = np.expand_dims(image, 0)\n", - " image = np.ascontiguousarray(image)\n", - "\n", - " im = image.astype(np.float32)\n", - " im /= 255\n", - " print(\"Image Shape:\", im.shape, sep='\\t')\n", - " return im, ratio, dwdh\n", - "\n", - "def create_session(model_path, device='CPU_FP32'):\n", - " \n", - " if device == 'CPU_FP32':\n", - " providers = ['OpenVINOExecutionProvider']\n", - " elif device == 'cpu':\n", - " providers = ['CPUExecutionProvider']\n", - " else:\n", - " LOGGER.info(f'No provider passed, using default CPU EP ...')\n", - " providers = ['CPUExecutionProvider']\n", - " \n", - " LOGGER.info(f'Use ORT providers: {providers}')\n", - " \n", - " sess = onnxruntime.InferenceSession(model_path,\n", - " providers=providers,\n", - " provider_options=[{'device_type': device}])\n", - "\n", - " outname = [i.name for i in sess.get_outputs()]\n", - " inname = [i.name for i in sess.get_inputs()]\n", - " \n", - " return sess, outname, inname\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Run Inference Function\n", - "\n", - "The `run-inference` function takes inputs as:\n", - "- `model_path` $\\rightarrow$ `.onnx`\n", - "- `img_input` $\\rightarrow$ `.jpg`\n", - "- `device` $\\rightarrow$ `device using which the inference should be run e.g. cpu, CPU_FP32` \n", - " Based on the device arguement the execution providers are selected.\n", - "\n", - "It performs the following tasks:\n", - "- Pre-process the input image as per model requirements\n", - "- Creates the appropriate onnxruntime session as per the device arguement\n", - "- Runs inferences according to the number of runs passed\n", - "- Performs non-max suppression on the predictions\n", - "- Adds bounding boxes on the detected objects\n", - "- Saves a copy of the inferred image." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def run_inference(model_path, img_input, device='CPU_FP32', num_runs=10, warm_up=3):\n", - " \n", - " img0, proces_ratio, dwdh = preProcess_image(img_input)\n", - " session, outputs, inputs = create_session(model_path, device)\n", - " \n", - " pred_times = []\n", - " inp = {inputs[0]:img0}\n", - "\n", - " \n", - " # Inference\n", - " for iter_num in range(num_runs + 2):\n", - "\n", - " # warmup session\n", - " if iter_num <= warm_up:\n", - " session.run(outputs, inp)[0]\n", - " continue\n", - "\n", - " start = time.time()\n", - " pred = session.run(outputs, inp)[0]\n", - " end = time.time()\n", - " inference_time = end - start\n", - " pred_times.append(inference_time)\n", - " \n", - "\n", - " ori_images = cv2.imread(img_input)\n", - " ori_images = [cv2.cvtColor(ori_images, cv2.COLOR_BGR2RGB)]\n", - " \n", - " # NMS (Non-Max Supression)\n", - " for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(pred):\n", - " image = ori_images[int(batch_id)]\n", - " box = np.array([x0,y0,x1,y1])\n", - " box -= np.array(dwdh*2)\n", - " box /= proces_ratio\n", - " box = box.round().astype(np.int32).tolist()\n", - " cls_id = int(cls_id)\n", - " score = round(float(score),3)\n", - " name = names[cls_id]\n", - " color = colors[name]\n", - " name += ' '+str(score)\n", - " cv2.rectangle(image,box[:2],box[2:],color,2)\n", - " cv2.putText(image,name,(box[0], box[1] - 2),cv2.FONT_HERSHEY_SIMPLEX,0.45,[225, 255, 255],thickness=1)\n", - " cv2.putText(image, 'FPS: {:.8f}'.format(1.0 / inference_time),\n", - " (10, 40), cv2.FONT_HERSHEY_COMPLEX, 0.45, (255, 255, 255), 0) \n", - " print('Avg Inference time in ms: %f' %\n", - " (sum(pred_times) / len(pred_times) * 1000))\n", - " plt.imshow(Image.fromarray(ori_images[0]))\n", - " plt.axis('off')\n", - " f = f\"{img_input.split('.')[0]}_{model_path.split('.')[0]}_{device}.jpg\"\n", - " plt.imsave(f, Image.fromarray(ori_images[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inference using CPU Execution Provider (MLAS)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", - " \"img_input\": \"cat.jpg\",\n", - " \"device\":'cpu',\n", - " \"num_runs\":10}\n", - "\n", - "run_inference(**params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inference using OpenVino Execution Provider" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "params = {\"model_path\":\"yolov7-tiny.onnx\",\n", - " \"img_input\": \"cat.jpg\",\n", - " \"device\":'CPU_FP32',\n", - " \"num_runs\":10}\n", - "\n", - "run_inference(**params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# NNCF PTQ for YoloV7" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quantize yolov7-tiny model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Build PTQ API dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import onnx\n", - "\n", - "from nncf.experimental.post_training.compression_builder import CompressionBuilder\n", - "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantization\n", - "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantizationParameters\n", - "from nncf.common.utils.logger import logger as nncf_logger\n", - "from nncf.experimental.post_training.api import dataset as ptq_api_dataset\n", - "from nncf.experimental.onnx.tensor import ONNXNNCFTensor\n", - "from utils.datasets import LoadImagesAndLabels\n", - "\n", - "class YoloV7Dataset(ptq_api_dataset.Dataset):\n", - " def __init__(self, path, batch_size, shuffle):\n", - " super().__init__(batch_size, shuffle)\n", - " self.load_images = LoadImagesAndLabels(path)\n", - "\n", - " def __getitem__(self, item):\n", - " img, _, _, _ = self.load_images[item]\n", - " # Input should be in [0,1].\n", - " img = (1 / 255.) * img\n", - " return {\"images\": ONNXNNCFTensor(img.numpy())}\n", - "\n", - " def __len__(self):\n", - " return len(self.load_images)\n", - "\n", - "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run PTQ" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "original_model = onnx.load(\"yolov7-tiny.onnx\")\n", - "num_init_samples = 100\n", - "# We'll ignore detector head not to quantize them\n", - "ignored_scopes = [\n", - " # Head branch 1\n", - " \"Mul_217\",\n", - " \"Add_219\",\n", - " \"Mul_221\",\n", - " \"Mul_223\",\n", - " \"Mul_227\",\n", - " # Head branch 2\n", - " \"Mul_251\",\n", - " \"Add_253\",\n", - " \"Mul_255\",\n", - " \"Mul_257\",\n", - " \"Mul_261\",\n", - " # Head branch 3\n", - " \"Mul_285\",\n", - " \"Add_287\",\n", - " \"Mul_289\",\n", - " \"Mul_291\",\n", - " \"Mul_295\",\n", - "]\n", - "output_model_path = \"yolov7-tiny-quantized.onnx\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Step 1: Create a pipeline of compression algorithms." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "builder = CompressionBuilder()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Step 2: Create the quantization algorithm and add to the builder." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "quantization_parameters = PostTrainingQuantizationParameters(\n", - " number_samples=num_init_samples,\n", - " ignored_scopes=ignored_scopes\n", - ")\n", - "quantization = PostTrainingQuantization(quantization_parameters)\n", - "builder.add_algorithm(quantization)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Step 3: Execute the pipeline." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "nncf_logger.info(\"Post-Training Quantization has just started!\")\n", - "quantized_model = builder.apply(original_model, dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Step 4: Save the quantized model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "onnx.save(quantized_model, output_model_path)\n", - "nncf_logger.info(\n", - " \"The quantized model is saved on {}\".format(output_model_path))\n", - "\n", - "onnx.checker.check_model(output_model_path)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run Inference on INT-8 model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inference using CPU Execution Provider (MLAS)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", - " \"img_input\": \"cat.jpg\",\n", - " \"device\":'cpu',\n", - " \"num_runs\":10}\n", - "\n", - "run_inference(**params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inference using OpenVino Execution Provider" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "params = {\"model_path\":\"yolov7-tiny-quantized.onnx\",\n", - " \"img_input\": \"cat.jpg\",\n", - " \"device\":'CPU_FP32',\n", - " \"num_runs\":10}\n", - "\n", - "run_inference(**params)" - ] - }, - { - "cell_type": "markdown", - "id": "45ea764a", - "metadata": {}, - "source": [ - "# Benchmarking" - ] - }, - { - "cell_type": "markdown", - "id": "38c93e68", - "metadata": {}, - "source": [ - "- Benchmarks can be performed using:\n", - " - openvino's [benchmark app](https://github.com/openvinotoolkit/openvino/tree/master/tools/benchmark_tool)\n", - " \n", - "\n", - "\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.8.10" - }, - "vscode": { - "interpreter": { - "hash": "7ef3e8097f70ab31f7176b80e6879dd38c66e9b9742ffc082cc999ecbfceb4e1" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 5001d275fa7bc78929ee0c9abcf8fdaf99f2a0f4 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Tue, 13 Sep 2022 18:47:19 +0530 Subject: [PATCH 10/15] inital commit - reference check --- .../README.md | 53 + .../OVEP_yoloV7-tiny_object_detection.ipynb | 973 ++++++++++++++++++ 2 files changed, 1026 insertions(+) create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md new file mode 100644 index 000000000..a0736aa3f --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -0,0 +1,53 @@ +# FP32/INT8 YOLOv7 Sample + +## Virtual Environement +Create a virtual environment either using a the `conda` virtual environment or `python venv`. + +### Conda +``` +$ conda create -n yolov7 python=3.8 +$ conda activate yolov7 +``` +### Python venv +``` +$ python3 -m venv yolov7 +$ source yolov7/bin/activate +``` + +## Install required packages +After creating and activating virtual environment, install the required packages: + +1. Jupyter Notebook +``` +$ pip install --no-cache-dir jupyter +``` +2. NNCF Experimental +``` +$ git clone https://github.com/openvinotoolkit/nncf.git +$ cd nncf && python setup.py install --onnx +$ pip install --no-cache-dir onnxruntime-openvino==1.11.0 +$ pip install --no-cache-dir onnxconverter_common +$ cd .. && rm -fR nncf +``` +3. YoloV7 requirements + +``` +$ cd notebooks +$ git clone https://github.com/WongKinYiu/yolov7 +$ cp -R yolov7/* . +$ pip install --no-cache-dir -r requirements.txt +$ rm -fR yolov7 +``` +Launch the notebook from here. +## Dataset +The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. + +## Outputs + +- `yolov7-tiny.onnx` +- `yolov7-tiny-quantized.onnx` +- `cat-yolov7-detected.jpg` + +## References +### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) +### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb new file mode 100644 index 000000000..ff2a025ad --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -0,0 +1,973 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b6157254", + "metadata": { + "id": "b6157254" + }, + "source": [ + "Copyright (C) 2021-2022, Intel Corporation\n", + "\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "id": "b6157254", + "metadata": { + "id": "b6157254" + }, + "source": [ + "Major Portions of this code are copyright of their respective authors and released under the General Public License Version 3.0:\n", + "- For licensing see https://github.com/WongKinYiu/yolov7/blob/main/LICENSE.md" + ] + }, + { + "cell_type": "markdown", + "id": "dfed77f6", + "metadata": { + "id": "dfed77f6" + }, + "source": [ + "# Object detection with YOLOv7 in Python using OpenVINO™ Execution Provider:\n", + "\n", + "1. The Object detection sample uses a YOLOv7 Deep Learning ONNX Model.\n", + "\n", + "\n", + "2. The sample involves presenting an image to ONNX Runtime (RT), which uses the OpenVINO™ Execution Provider to run inference on various Intel hardware devices as mentioned before and perform object detection to detect up to 80 different objects like person, bicycle, car, motorbike and much more from the coco dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Before starting with this notebook please make sure to perform the required installations as mentioned below:**\n", + "1. [YoloV7 installation requirements](https://github.com/WongKinYiu/yolov7#installation)\n", + "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download COCO validation dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import os\n", + "# import torch\n", + "# import warnings\n", + "# warnings.filterwarnings(action=\"ignore\")\n", + "\n", + "# if not os.path.exists(\"../datasets\"):\n", + "# # Download COCO val\n", + "# torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", + "# !unzip -q tmp.zip -d ../datasets && rm tmp.zip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export yolov7-tiny model to ONNX format\n", + "```python\n", + "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", + " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", + " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "if not os.path.exists('cat.jpg'):\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Inference for ONNX model\n", + "import cv2\n", + "import time\n", + "import requests\n", + "import random\n", + "import logging\n", + "import numpy as np\n", + "import onnxruntime\n", + "from PIL import Image\n", + "from pathlib import Path\n", + "from collections import OrderedDict,namedtuple\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define necessary helper functions\n", + "### Pre-Processing\n", + "\n", + "When we are using a pre-trained model, which is trained & fine-tuned using a fixed image size as input, we should resize our image to a shape which is expected by the model. The image reshaped using a scaling factor which is a ratio between the desired height/width and the actual image height/width. \n", + "$$scale = min \\biggl( \\frac{\\text{target height}}{\\text{input image height}}, \\frac{\\text{target width}}{\\text{input image width}} \\biggl)$$ \n", + "Using the $scale$-factor, image height & width are calculated which is then re-shaped to the desired image size using the `opencv` package. Here this is acheived by the `preProcess_image` helper function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32):\n", + " # Resize and pad image while meeting stride-multiple constraints\n", + " shape = im.shape[:2] # current shape [height, width]\n", + " if isinstance(new_shape, int):\n", + " new_shape = (new_shape, new_shape)\n", + "\n", + " # Scale ratio (new / old)\n", + " r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])\n", + " if not scaleup: # only scale down, do not scale up (for better val mAP)\n", + " r = min(r, 1.0)\n", + "\n", + " # Compute padding\n", + " new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))\n", + " dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding\n", + "\n", + " if auto: # minimum rectangle\n", + " dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding\n", + "\n", + " dw /= 2 # divide padding into 2 sides\n", + " dh /= 2\n", + "\n", + " if shape[::-1] != new_unpad: # resize\n", + " im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)\n", + " top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))\n", + " left, right = int(round(dw - 0.1)), int(round(dw + 0.1))\n", + " im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border\n", + " return im, r, (dw, dh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Labels and Colors for Lables" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "random.seed(42)\n", + "names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', \n", + " 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', \n", + " 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', \n", + " 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', \n", + " 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', \n", + " 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', \n", + " 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', \n", + " 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', \n", + " 'hair drier', 'toothbrush']\n", + "colors = {name:[random.randint(0, 255) for _ in range(3)] for i,name in enumerate(names)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read & Pre-Process Image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def set_logging(rank=-1):\n", + " logging.basicConfig(\n", + " format=\"%(message)s\",\n", + " level=logging.INFO if rank in [-1, 0] else logging.WARN)\n", + " \n", + "set_logging(0) # run before defining LOGGER\n", + "LOGGER = logging.getLogger(\"yolov7\")\n", + "\n", + "def preProcess_image(img_path):\n", + " img = cv2.imread(img_path)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + " image = img.copy()\n", + " image, ratio, dwdh = letterbox(image, auto=False)\n", + " image = image.transpose((2, 0, 1))\n", + " image = np.expand_dims(image, 0)\n", + " image = np.ascontiguousarray(image)\n", + "\n", + " im = image.astype(np.float32)\n", + " im /= 255\n", + " print(\"Image Shape:\", im.shape, sep='\\t')\n", + " return im, ratio, dwdh\n", + "\n", + "def create_session(model_path, device='CPU_FP32'):\n", + " \n", + " if device == 'CPU_FP32':\n", + " providers = ['OpenVINOExecutionProvider']\n", + " elif device == 'cpu':\n", + " providers = ['CPUExecutionProvider']\n", + " else:\n", + " LOGGER.info(f'No provider passed, using default CPU EP ...')\n", + " providers = ['CPUExecutionProvider']\n", + " \n", + " # LOGGER.info(f'Use ORT providers: {providers}')\n", + " print(f'Use ORT providers: {providers}')\n", + " \n", + " sess = onnxruntime.InferenceSession(model_path,\n", + " providers=providers,\n", + " provider_options=[{'device_type': device}])\n", + "\n", + " outname = [i.name for i in sess.get_outputs()]\n", + " inname = [i.name for i in sess.get_inputs()]\n", + " \n", + " return sess, outname, inname\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run Inference Function\n", + "\n", + "The `run-inference` function takes inputs as:\n", + "- `model_path` $\\rightarrow$ `.onnx`\n", + "- `img_input` $\\rightarrow$ `.jpg`\n", + "- `device` $\\rightarrow$ `device using which the inference should be run e.g. cpu, CPU_FP32` \n", + " Based on the device arguement the execution providers are selected.\n", + "\n", + "It performs the following tasks:\n", + "- Pre-process the input image as per model requirements\n", + "- Creates the appropriate onnxruntime session as per the device arguement\n", + "- Runs inferences according to the number of runs passed\n", + "- Performs non-max suppression on the predictions\n", + "- Adds bounding boxes on the detected objects\n", + "- Saves a copy of the inferred image." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def run_inference(model_path, img_input, device='CPU_FP32', num_runs=10, warm_up=3):\n", + " \n", + " img0, proces_ratio, dwdh = preProcess_image(img_input)\n", + " session, outputs, inputs = create_session(model_path, device)\n", + " \n", + " pred_times = []\n", + " inp = {inputs[0]:img0}\n", + "\n", + " \n", + " # Inference\n", + " for iter_num in range(num_runs + 2):\n", + "\n", + " # warmup session\n", + " if iter_num <= warm_up:\n", + " session.run(outputs, inp)[0]\n", + " continue\n", + "\n", + " start = time.time()\n", + " pred = session.run(outputs, inp)[0]\n", + " end = time.time()\n", + " inference_time = end - start\n", + " pred_times.append(inference_time)\n", + " \n", + "\n", + " ori_images = cv2.imread(img_input)\n", + " ori_images = [cv2.cvtColor(ori_images, cv2.COLOR_BGR2RGB)]\n", + " \n", + " # NMS (Non-Max Supression)\n", + " for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(pred):\n", + " image = ori_images[int(batch_id)]\n", + " box = np.array([x0,y0,x1,y1])\n", + " box -= np.array(dwdh*2)\n", + " box /= proces_ratio\n", + " box = box.round().astype(np.int32).tolist()\n", + " cls_id = int(cls_id)\n", + " score = round(float(score),3)\n", + " name = names[cls_id]\n", + " color = colors[name]\n", + " name += ' '+str(score)\n", + " cv2.rectangle(image,box[:2],box[2:],color,2)\n", + " cv2.putText(image,name,(box[0], box[1] - 2),cv2.FONT_HERSHEY_SIMPLEX,0.45,[225, 255, 255],thickness=1)\n", + " cv2.putText(image, 'FPS: {:.8f}'.format(1.0 / inference_time),\n", + " (10, 40), cv2.FONT_HERSHEY_COMPLEX, 0.45, (255, 255, 255), 0) \n", + " print('Avg Inference time in ms: %f' %\n", + " (sum(pred_times) / len(pred_times) * 1000))\n", + " plt.imshow(Image.fromarray(ori_images[0]))\n", + " plt.axis('off')\n", + " f = f\"{img_input.split('.')[0]}_{model_path.split('.')[0]}_{device}.jpg\"\n", + " plt.imsave(f, Image.fromarray(ori_images[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using CPU Execution Provider (MLAS)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "model_path = 'yolov7-tiny.onnx'\n", + "img_path = 'cat.jpg'\n", + "num_iters = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Use ORT providers: ['CPUExecutionProvider']\n", + "Avg Inference time in ms: 37.153132\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eaBtuVEfCv9Ka+3hnHPn27cHu9tut2fsBk8YbGwwGDMY4wABB8IUEogZEpIHCfDykbwQSCADISSQ8IUQEsYAIcxhNgZsMHjG8+zudnf7dvftO51h772WVN8fUkklLa199rlt8r0/ruzb55y1tKRSqVSTSiViZsb1cr1cL9fL9XK9ADD//wbgerlerpfr5Xr5f0+5LhSul+vlerlerpdYrguF6+V6uV6ul+sllutC4Xq5Xq6X6+V6ieW6ULherpfr5Xq5XmK5LhSul+vlerlerpdYrguF6+V6uV6ul+sllutC4Xq5Xq6X6+V6iaXdtOK/+gdfAX3OzTkXf2fm+C7WIYAZ4T95IaJhB84Crgc1ASQGCACrqtKn9Kf7rRV5J/2RYzADDDWO3sJaC8eMpm2y9vTvRARjDIgo9rtarbL3RAQC4P9bb0O+Tw8ZgIyDwzgZBAOABjhn5giH/JN+SryW49dw+PaGdQGAGhOfGSN6gwPC6MLMpG8dw7nQl2EYQyDytfQEengBJlbtCBAm/tTwRrgYANJ4Yw0iwFAxRqFFA2ttwl2A0cxmaNs24s8Yg6ZJc09CwgEPmtZlDuAYlgDTGEwmk/he2pF6TdOAe+vHTAaEKba25nDOxXbJUOxUw2RMI4PMcaGKHzYn/BGF3z1ua7jUfXj8ebh9nya+m0ymAIDlYoW+72HZgpmxuLKL6fETeNRjHosbb3kUmnaKrdkxP+eEbI10XYeDxS6WywOsVqtIJx6WQANhrfs/KUxfrq/Wxu7xLGu6G+EFLQg1vHm8JPr2xVXq+r4cmBP/KV5mz2v8MP/GZetdUfOg7oBfVJ7V+GFcJ2r+jSF85df83er4dNlYKCTA1zPiBGnJOtSrgoEJgRhq0jcUcV3UUxARDdpZLyQwhMgQDBuQQmatH2NMbL8q1BAIzOWT5ZyLjKI2UZzBI4RKANNg/OV4pY/yby0oamNKTE4Yc94+s4cq7yuIu/hMtRkYARkEpmLgCb8HoUFeCGADwIaux4xVjnTBLEJSKx2KQNiPSRha07Z+LthgtVrBWuvha8L4kOa0aRo0TZMYNJFn0qEIo7TWwjmXcGm86DfkIXPwjHUymcA555loEEjUNmgMwZgGhqYJnijgCAyuCHoHoiaOu07bSUiTMFTKaVC3K0xQt2VMAyIT/lHAOeC6Hp2zsM6BDDChFsyMS53F4x97G06cOQMQxfk2IIDSfBIRmkbabtE0AHMfxmUA9uAyLBgU/idzO0IWEGZqFBmUlaWOCMY0Zr0Ga+tY5iJ7FgStCIX0LOF40E7xPv+bMvLV9dfxlxLSNNa8JMVRcERxXjcpGwuFwxiN/F1jqmWdygv5xROZ9ENltSHi1gmBAXKj6VFIckMgBpxaQHoxlUW+FUFR60tL7t3dXezs7FTqJViG36cxjPUxNlatBdWERt5//o0IhCH9UNauFpLM7NFKHLVFvyQpMPPaoh32rWH07ZgBjWVjCOaInksiilo6a21cMUZW2iEzD5h0iW+t1cv4pXtZfJ7pe6Y6nU7Rti12d3fRtq1q0zNQY4baIEbopzaHY8WvGbFTc5zE8RnyzDvixADGWxaEJBQArzV7pu5xaq3FwcEBmukcW9vHMZnMYl1iBhecLq2TFm3joqIjwpLBAPNAWfPrnwByQBIV+bwLhREBsBjS2JApZ4J4bC0RMks/Pqb6eqo2UeGNZfFTVVdAx9rZpF+AYIICImsvzvOG5QhCIf4GICF6nWRb9y4OOBAxBRoYsy6yb0b6GquTT1DQBoZqeEbQm2jkWsMcg5eI0Pc9tFbuYQx1QBmRx74K4hwjnhLHhxL9YHyVPg5pTzTivu8D82VYdlHDEo1Ka/dDATumSeULfp0W5rX+4bywDU4AzoW2twKM/6cYvmi0ZRFLT5hYiQfvthKhR5llKILD0wiDnXe9UJOYiy1csGNKzzrGUVMYBmOOYxelKwkwIgMmAzCDyCh69Eq/0Hjf91gul7h06RJuetQdaCdzgBqIbg2gEPWpNKYBtxMA5F2WHAQ3LJL7MEI/VCEGLoOkOGhLydcVXAQcVPCW0U+J2/hlvaxTRseshzFlY50Sffg6zl1PueAzMNRu2M6wHMF9lANb/l0OsPx7VPtmhiGvqROZ6NPT9fSirMEwVsZM7jEpXvoXM2sCdYIY0wrkedM0OH36NMrlIt0yOBmCA3OyrjWUxFcTDMKgyvHU2ijnRrYB9N6FxpFowl7YBWN9YNmFxc3jQrNeKOGGc4uupJ/o5jIl4YsbAhmzF6HAao7GFvkY7WU0RQ0sHGzv4TLGwDmHrusyq8X2DOcsjBIWbduCuy4wx8QKS1x7n7nWouvujTSvOTbj+L2qiya6KINgJBMsBKnmLR9jCJNpcntaa9F1HR5++AI++VM/B5OtLbAIGWM8VEwDqaD3a5xjNA1HRYLCuDn4keL8AiBi6P2okhbyOdN/D5Wd0krQeB4of6hZ7eNCGcyeptbVCSASDMS1p4VaDa51paZsa97lZWIDMmJxH00wHEko1BjTpuaULgOtG2JKho0xThKbB7oHqa+GsMnCXCeFNx3TOo2iNr6ouHD+PIe3EA7xTcmkNyOUUpABajO0gFHGkd7lLqEEaW5ulwuq73t0XQdr/Sa9184aADYwFRnv0JVweHFoGu+7FqGjvx/iQqyu4UIpF50IBVcZU7nQRKjWlKCIRwTXByc3T9/3Gc5iMAIxLAOLxQLGNGgaCwqM0ZHuExF/fe8Fku0ZZLxbAAQQ54Ihg9u5zBLqug5EDdqW0IT950nTRmHhQOgdRSZ8cucEtra2wMTYX17F4mDpBcJqhQaEJz/hiTh5+iwsWXTOeh5HLnjvLdhpehK8NyBiEDGMYTD3IDaBSRowesj+gnM9DBm0RtxuSSjXFTyKdYLj4dAyxoSFUXPFvTlGvjXroErrA7iGgB5Fm89hK2g/CkfhLt7dq9fTurKxUIhbk7IopPOCRxsycNYCbty1oUtkUgyATYxxkTYZDoTE5PxCdHCW0TQS9ZGA8NoxxYnM/YAuquPrGP0mzGFsTJTTU9aO/iZpvk3cQ6GwtGITep7hQMQB5ababgnXmPuuZkbrd6YixL0GF/7HQEuA4x6GHARy/5kFs8AnrgWJ2hBGrASk34yIi5sI6LmvjG1sY1Dhg32PXgOOAMVxJeFNaBgxGimoVv5vinaG/6/WPoMgUIgJ/Qf9nYAmKDXCoYJb3EcSmQZogMm0Rd91sIEeDRPQOAAGTNb34HxfhidoDEBwIQCMwr/E+AVPxhjAeC3bkAkbyIS2nYAaE33NXiD4cbXGYNq0sL3FbD4DG8aV/StYLZdoyM97004xP76FY2enOH3qNLy732AquLYGnTFBCaZgISX0E5kohJgd2rZBDwB9D7IOxgGudzAEOOvQswMmK8znc/S9U4qMqI/JVYTwjhXnyK2mumKT6IMCOkWZdMHqCX0V3obB36Gp9UpP+S4P2MjeVJRtIqjx50LKr00RwJ72mByYD2DMNHYhvHCTcqSN5oyRCtFn/jxh3PkADyssbUUmpZDCClEuLXpqPLFpZBUQA9AmZ5VXV+Ec07L136PM+LBxVmtqqZ5cH/obQ+s3uWpjOFwgjAg6XyGvb0Qg+L8dy/d+UZlIzBHzYTillAxug0zghbpBhBAnd0oOVC7sau7I2m9ZP2GFsHgnqKhZ67uwePTCTeoIR21X+jfCwAUvjgFi9F2HvusRrZu4yF3wtsnil7gmEqxlzpFy76BpGoAS9Jr2wQwXBm105E5QpBgWtu/Rw0dNWefQtD4stZnMMdvaxtb2DmazOQzExZh82Amqkq5Fjkn0k8DmGbCECnv8hb0OACAeWLwciGPgRpJ1o7XJ4M5iOLD1llzbtmkfMCgOXqAERRbC9HXoqbhBMarxjbll099aqA3X3bp1Ku2LIEh0n+NYhs1+8QSXlghKsdKG+2a1srFQGJMy2Z4B1KIIPO6oJlEk+ogETywZD4suCkF4BhGqYY6qTs3kG4XnEEtn0AcNNYcxIZK3HX9TwNb6q8O7iVU2VjR8UUAX7SpxFV0nucaj4U+CYTg3RX3i4ZCqtJOiUGquH11L+mLU8KCZt4cno+GN3VwB0LVoFjsiAurPN7geztq0pgLTZOcjpuRLmLCiBoxA5qAU8qnXbMTMgZ+Z3E0YrFOZpxSp5fcimrbFZDLFZD7H9vYOtnd24phEoCWFzbu4amSnhYLg2Ed0BeEcx5KUPoCCazLRpVYAh8/jqCq/e1gnkwmMMei6DkGpjh4PiUDTimSsUeonBZ0M1o/Cr/oKOf1vTmel1a/7y9ZBASuL5kMMR+5jbymUAKquEwABMDIGsO6QBZPaiy1Fl0rSQL1K4uPao3ZLQWtQhJlcPImhZm4a49sqtavaZmwNtvHx65dIB58q1oXuo9ZOepaIR75bB+dYOZzJ5f1EXCGHNfzitS4mgB0MXLDAPc6d24zIM3hoGLeilYJsLOpQWyks8vEisDmlzct3TGKQqE8508D0uq3RQjanMZonjg6e7uTgoShLOpjAtxk38VW9klEwMxx7t2E5VgetfZu0Bkwu1MUdSGHDdzqdou/7uF6kbWMakDHh4KFfZ61p0LQTNO0Epm0B42fdcKHBA/GcT4k/LQx8uxKRlg6DaUNZ+nZsssOq5fj18xpT1q5CYwht22I2m8UgAIYPQXfs4qZO7nXggn8HpYTqa28Qor1WIBxBaVP8RI+7+jkngP0+SwMCw1qPx7b9S3AfZf0XAycKnDrO32aD9m1UNI8BUtsgD+SgD8dvnNPx3D5MLuc9QaNzgD7IUhtbyUgPc8Pkg0GmPJYCaJM2fP/jk1fTFta1mf6uaSgEYGQc6hNm9q6P8JKZ0XNQAFjCP4cLsobjgSUCgMl4pVj1qXHmacvPnWg7iWEUeDHr8UxsknsoHqEQxp3DVcPlmEZOBdyitLCcKg4x+mQsICcFmMOmsPepMydLQXCktT/mdJq9UaG1GY1SEjZ+gzcJppXtYfe9m8SfP0B0pTSN0JOPeHLOouMOK0c4u30Ck3YC07RwCFZBBQ+GASbO5kQreVImkwmWyyWcQxyvCeOLe4JNbXM3V4zWKV1J+BKmswkaQ9jf30ffdZ4ViKUwsr4hpgREcA6ZeoJP6D5hI60FodENhcAQihGboqIgGY4w+8N24XE4S7MufF6XI1sK4yUxaf/XUcwjVAhA3hEyBzS8f92/tNDRCYdqxqojqVua05vBWxNcgLYUdBlj3mU7NctB/34010atlCZnWqyZAKvA6pmHgWwd53pimr+hllQyB1+Zybc06C2sPSHgOD/stcvsVHEYQ3VvgeQ/Fbga46F28WWoy9AKRbbeNjK9KwIpGxg8LXOwHIjiCfi4e+BSeCvBC0wgnJwOgiAK1qrllIo/Pdz4vQQLwLGPvDIGvbVo0cAYsbIbMPfobO/RwYBpW2zNZ2hnE1DThJAPA9mmlgHKYUaHofYuQsn3o633JAT82Q5vXRnyqTc2ofRoPdYWneCF/TmhHhhERx+BQ6l/+qvaui7X2GYHbcdK7YvBelLPpWj+79cG0DSbsfuNhYKVyU49BaCVJqA1QzTIVlfY9BDTTTQxgmgLSptg758URgByygSXcLzgsogCg9KPQIyyeJjTtygZB4Ipq7C4iQZSZeDKUhi6iBJRiebgz2XozSABKG3gReHKSGMKWmiurSTMa1rxdXRaizQmY9rBaV0ZG6n6PiJDFh9nq0tCZ4Vl5gIj18YynDHFisICtIAYCk2KeM3djPLTR+9EFNY0s7A4SpYTYQy9RKU7tGEZyj2p8asUFjbquT5YZQE2auGYqKUKOfqqQTi0DSIRRQuJsjBTrXkPLHhnvfAulB1DhCYwXBmnYYBcULKY/QayXrNE2NnZwaSZegbs/Dyb5JyDBB8M2CUnOMN5tbgEHAAL593dpvEhyGFdmEhnNo6R9YxyE8GLDbKL45K+mX00GCGnVUbv11WkPbVfVpBMSX+5YEiWA8f/Kh5EjBR1h0Hh8KJmrWRzStmPYZ2SP+nvoi9blKTNhNIRNppJISf1PKKkRB++AAthYJRHLPnKiRlmfxPgY+xCiKvqj/WqKvuGQrRogVEbrMBaaWedtjtqchKyPYW8LVKGSiIyAqkEcWn4McxM2gsaYnQqVLRZ6bfm6qs9Lxm1XgRJMKSxeRzqPxPcaV44UwZKLSkJPmQLWdrIsB7IRMadQhGHglkERMJjvleQGKp07n+QBj48jCxXvhlZS1QJX8ppm9W/oCWHyk7ht4QhW/Cs5sUPukJb+XcMLmg10AXSfBiF++ieM+qZaUCTKabTWVDQEk0QiaUj8HBkcNWiFEFZtk3TQset9jEUVNBVtqYZc8kkteMPcbwxyggus2SJXNJrSPaAWJNFhs/DlC9ZBzlf0MpgvlhrymXJU7J5Vd+WpXR1x54JOSxR+zi8bC4UmgbOJsknkprIE/hwg6cEOi1amUKnCKkcePQJhoVEhlS/64vuO1oj6z7gunAZc+eMmesl5QwnOm8n/JG0rsp+R9m3/rusVxNWYyZrDEXknIGU32mmPrqPMdK3zHFtLKLN1cZWg390HMWiyuiNNFyVhcuxWr5ewoZ05M0mCPDK+KQZPX95SUnJGJu5RaS+WAjVMUvoYbFmBFbHzmvwlNryOkbSu+OzcGhUlCPv7mkwnW2hCWGM1tkgOCRVEg0EVCkYmDnLPhsxQoRpO/EeLdvBWRu5giusWs03RDUYuAkxTPQXaYGChcAOXlHwZygy2ivh1vhcwxfWvVtXxmg6U2Q3KLVacT2nwLYjl42Fgj+pmGcm9ATXwMDBSlrnptC6SsRpOzISQJ40bcCMuQluKiCTvGNLLDMlx3x6mTgaaWbIiGvwqRpJo1b1vdaSIj0yRrwhHDWN8DB4x56H2Au1AEc0jsE4c80/+YeV1qutAySBMexnA3JVVcVtVtOaqvBGpSWnx0ww0LCtqrY2RgfKwjxsNMKgpGZKMxHWQjgVPCiEzJLNrIZqR4CP5XewFphMptE6ZXgGGc8aF1PhwTMwRGibBjvbPomjs4zl6gBd32Fr5zja+Tx+qFEef1V4c84BTRKqKQzXCzCDBiBCY1fBCyTjK+nEmxBDxSwX6Xr+fPCJjZaTWCEcYEvg5murpHGpXgr9MaVxk7W0Tnhw0fe6+pnK7VxI6jnS7obC5gjRR9n2kvrd+3K9e0lP0HCn2w/SQPzQQyQWJpP8Ri0o+ueC79E0cM4fAFo32Jp2P6gfFl5JHGPtrnsHIB3ACXX6uDmawwSIJTQucIbwM8Y5wljRgjT2POhjYO0NfnpNkbNNrOBLP2KOIz9/6cCQ9EOEDB++Qv5rSfPrLI34XcHfR12A11A2b8XTP5Fovhw03zQXem+mLLWxZ60TeQ0x5C+aTgyaJqQR9364qFhZYjRgf5AtMELL7BOdkw9jbcwE1jKIfN6jVbfCzgmPuzJAw6moqQxmDpFrQbAzgKZt0ToHR/4aFa9U+NPcFDR7XxxEGPgVWpyxEHrhIWaEpqyzI1E3w4CKWkmhu7ngOcyCrcGySb2aFTI27yU3ThbOsD7zuLAoyyNKnR0BiL2VjCaTYwF4mdwhA5ZIorqZTlldgIMgqsAa/Ey6HR21kmAzkaCOwh9G3TQUgw2TNsISLusZqEx8/Ic0WUJ8UatRU5v6DC67IvXGuACLvyFqW3GeKGnhGAqBXFPyzJ8izGkeGHKiOT+sRqi7jxiAc3bQHxFBcqoJLpqmCdlYEfhaXWgKvJpZuWKeEnuJQ4/PjGqjZALrlnTUV/UYNpDaMXBCJZFj5piXqdrPiLtC4DVNg7YNZxY4+dkzoRu+MxSimwKsfgswuHpCmyak/SZDODjYx+Wrl3H2pjOA2vQWsIhUVBrBe7cik/OWDgFw1sbTw+l779f3Y0wnikVwJiPLh+wS+VPZJkQfOeIgSFjB0/gzCUhrLc6RJ/oqPmtF8CdKjHpxiKQeKmMD99aaPge0jiFvHGtBhpdb6x9zSyFsdMoGUFRYHfxFFh7syHhZkl0lK4CZw15yEhBacGhNACiHEFeOeif5wmMP6kvNoNRRdSEIxRij0Iljq0jrNe6bzEVVAk8k3BFJoREpoNui9BwKDtFwK5bMujLmpmFQalMJo1rRzFGGofMiiZmr+yQCMlrOrIDYYYRroIXFefb/cdbnByIf7+jvvQhaLwAf2iqWWQ68d5PIUf+IWvYzT0p7VgNKm6pe6/b5P02mV/o2TYnavGQ8h5LlSC4wYAYwrq1GFAWOyCSrhRSlEOJNdYEpg/06MrERRMsE0d2j1gDJ6mAQkxekxoDbxu8dsAVbB+e6aNUMBWHCbTaeIGCEQ2lGx+G1fNOQhCF76ynxsCKqKEQPIRykJEdwokgoMUchQMVZBydpyxWPEuuJmaL3msQfUWja2sr3cOSaj0MhLAJO1fJN3wYYRFjq6MK4VspvoHSHksEUlXP+zEn5IMKm1vzmQiEsD2HuCYi6WwT6xqgApfwPkhZXM8hMg1WIp5whag08nEZTMIb+yEWkyBvdup4oUv9Nb/IDRMOvchhL4VHVFsOMakvXa9j16ycFLmlnnHkcru0kq0MYiwj3ugulZjJLX0TKHlQLXawbscL0OMq2JHiAK+9ywJEWtGNvAYoGFPynkCslC+smMfrADAQ2gWvEVNfWiLg7/RgwSH2T5L7u34/aR+gMhV08QazmlcD+3rIBHrjoT5huA3HbChTeyiIET02EacC4I1o4CJowX3JNJnmh6y0WBtiiWy3QGviLorgBDSzlfBXpPqJQcH4Pi8NpaJ/zyIKD5WD7Hl2/gGMLdihclJ5XOAYcd0EJkEXE8ZKsPH20z/3TWwuWgAqwP/RHBoQm3J5HkLMjDO8CZyKfpJCE1XgBmqx4SbqZBFE+a0FdljUR51IUMuGkTul/oqDwYLJEXgjL1LwlniSPsCbhwYEPRbLlcobq5YgJ8XLtW+6ApWB2Zn42pZ0kRqSRUjLZ3IWzjtlpV0ppjsnC56wNn4hLTs0OfIxh4qPwoSQ+NtmvOOyZhk/7X8c3n8SUTt/Vxl+axblvXjGkjGFhUL+sVz2oJSkdKP9e4BjLJKvvM8jmCuoQYtH/YGxEILaBKaSFZMOCbyr9Di2YIlh0BF6tjABecwYlra/MIKu+hPqw+jq/bkBdlVj9pgizlLUUBVXQTklcRxTvifDx/5TRgbgPBHznvHSnsFStZZ+NlQnsHKzt/Ap3jIODBSaTKU4cOxHlVDmXGn+6T2b2lgY7WOtTrvfO71Fw7/8tl/7f/v4VdLaL+wDNZAqDdPsbM2PZ9YB1WbSRdjUKTLVLk8RCaJoG3Lb+nu5wha6044jCIUIDS87rHGG+CBN4RTRdImVAsKz7UgEDHG6EE5pi4TNNUHCUYsLss+ZGQaPwiUB3ijQj7QqbZbUe/YdByPggHQcMLsYdK0e+T0H/dE6WmbgN8lOoUs+GkLOhhVHE9Y7z3xFma4KgKjQ+MkETLIhXXc0IDJmihusvqwhhbnrkXMNU/vw/WWiowGRwVK2d4oPs0h7OGcjYz9iWMWiCQJIDdwQfKj3GAKrjqFg/Y3+L9jy0Ziptc/0xSGUfAAqaH5L8JpYf4ECmgWwoy90FpASJFqp1qy8O0gtINHC2B4zBtJ1ie3sGwAv71WqFWdNg0rZguHjtZikQynFE+rAd+m6FxcEB9vf3YfsVVp1F34fnqwWWyyX6vgv7DQxqCFgcgCjkJ0Jwi4Ub3DJrNAiB3tKADsuxi4DRtNg0DRrToGkbsPOHYjutxAUbjchgEq5dbSZTf2kSAcDE221EILQgAL3rQey8uzNuwgdVOgTIJEAJzDYd06oQUkk30RrIaynrzLdL5A9PEhusyZ6TlUeU5kJcBQgIlJuiykkbflPXUmvLodQ8MiECKJdFqu/dDpn+4vswJpqSNbiGzIxQi6KqwV+WMm66ZOY1TT93Ywzxc5hgqFkHGt7ym00ZZ3gYLQVtFerFHy+qP4TxhqfZe40DrUykASDDibglzZpxHFaqeB+pc1i9CGNQkopW1vddEbajsHCqTqStawqcvi4Eyv2etD8YXBbOAo7ROYeeLSazKXAMIGJYZ8NdEzR0QVTWgaaxBx54AFuzCdh2ONjbx6rrsFwuYzTTauV/d67zsMheS0yJAX8SG97bwD5cSfEL8mcpWFzGRdBIwTits6DGwPZBjBpCH+fBCznHBEmhleYp5A8SgdJ1XggQwUwmySpS/4xJF17J+mvbFs5xzACbzRN5HgVj0AReJanTHQi276N1kxIimngPCFxuSTN75YHFVuiLvY+R8jHIfSSEKi4BcTF5+ToYuAcXyRRWjzBkWOPaqK8/pjVXL9kutbQRjbaEc9MiWuwYI6mZ1o+kHIVhHeUCeN1mIuiSCaWiXWJjsEQFAhK91I5aB4PvlFYaVQJZfGvgXycAR/ElcHLNQhjvJ93VXDSHxPQ9zx4ybV0HOITqBi/8A0MU8kkNlS6Zv6wP0SYR9mocAc5hsVzi6v4edg8OcPbGW+OB1eAzAgfN1x9Kk1d5X1Kcc5jO5mC3QrdaoutWcLZH3y3RrVZYdSt0fReieuS2RC/q9UVNkr4kTU2uQHpXoGjz4qcrYxxDa8yI6SeIAEtw8GlAmMMz8m4kP0CZLwYFK8mqPRQiAq8OEj06zmlT0SiRD/X1d3Yr3mPgrSClIBgiWOs8M6c0z22wdMLHkHu1szTjYHR9D2rIn0w3Lci0aCsWda0cUShQIg79rFYlCovwO4T4A2MoZosob4uHL/1zZoUkHZmgGYBESgkjCnWU9M8YZGYZaLNuODx5XradmqKEhOybwvzL+qw2VbasgBr2ebiAK/vdvIiGmsAI/vlwOYq+B2AIdcAHI65qFe+V8KWbF2aln0bSUxZKtb9QCqtqk1F7wZMLhNxFUpuk0iIdCk5GPt96jFI5bRj6TdOsiaog0M4ieZL+VfT3AlRZg4x4Wx4Bk9kc3PfwXhxG31kY08KYFqL6je2Fpf/6qB7nLGazKZZ7B+i6Prj9eljboe9XcLaDv20vZUoIfLikCPUz4yahuOAxAMAS1pw8FgUWwh69ighDsjxTy5ys00jCnPZtXLIIXe+vpGWnNtLZBvd6alGgEdcniXVnEMNrEdxVhJDyOjZBaBqDPoTRp1BdH4rsL22SThirvvd5tMgLhqadYDKRmyrXl82FgmnSrFFClhwflwElevG5vPVi9jh24CHFeuQIf1QT5V8p7ScKBD/pchmk9BGZDMv+gdKQSfbi/QRrfpzgT337+apYIjQULKmPOvspmbHsK/joh4pOM8LIIvFjKAz0ISjZWCxhOIq1UI7PG6EFrPpimBo3VOGcBOUmCu+9YEiaa3K7QefzSjAEmKSeMWaYxwfpu1GLU7vtVH3tdkxtyU1d+fh8GmxFm/GbugtHjzvikDlmWSEgj3CiAVWEzXmCoUkWuUaMeLOb0E7ef95YjLqBZ8rOMEy7hZvO3YLZ1g6cA2xvcbBcoZ1uoZ3O4bPkpvVhjIzd/+0IoLC5yiDAdkDv9wtWfQ9HQOccOtuhdz3SFbMhBFgsbQBkEk58H8E9RELrUAsBSeYFXAbRlOEuMX3OzxMhfVupHB9koi/wQG8dJBwwuyAQLNjVoikJDJtg8+FeIcNsIg2WQIKw+e//Z9A771bt+z4IJtm/bSIu/boyYGsjHogIy78cS6FWKkymoqqkBcgh53oePXAtRRZRCYGXG4kZDCDm3O1Ui7aJ2mU4ZDWmHUk5bPO4dC+UloyE0GVjWFOG1kGFAVWiqMZwvck+SxS+SIsoW1TDBpJA2MCCKfdYdKSPC9JQ3GAa1465GoF0lOIVlnx/pybo068UtWs9vnHX2WYwRC157BNRyD4mJXqbAQBb8x1MJ1NMpxMY4yMKd3d3cdNNN2NrvuWDbkyeGiVTHMQlAgDhIOru3j729/exWq1gw3kHbx2I8kYoQ2vjWQglIOM9GjVK2xAdQ0EJrV8O6wtNilauLGZRhHIcBPeaDRnR43WYGtZgXcR1lYagaToKCCfB20DX96o/jtLPj6noi/x8OJVaZ1M6fMQ3r426Lir+Xj8Gk8YzAuioFj4GEyqCocLIa/79MV+zEINRLogaPJv79Tlk1cx9jF4zGMKSKS1Zf0krkb+jpaa0Vt1eDc/lhvc64Rn7NgTTGLjeRsHrZF1rLVS5SpJCfDhRDhfsUOt3zocj9n0fx0hF+2MCsBQ8pXIgFuN6wUlJQ46Q1cdRCpmNy6EawbCvCF/NwgxMb+g2Zb9ORSk1Pim27R2Wtsfe7lVwn0JfRVpljFC8A6QYJDswW3SrFZaLRQwYaEyIAKQWzMtYP6NvudKTK2ML7yPsBTKOSl9jdMKpQrW+/qnht1bcRz45OHOZGkjad5BTU76unDlB5AeAEjwV+IViq3yp0Cq8srGZCxV4BCGp+uar5EeXECiKB2NS3aGLZJ07Y90EbyqUpG5KRLdZ+/F9sOVqzKU84FVjSqGyX5MseVxSG0Tkk4CZxOz1d6Vg8GNNAlVVHcLuf4vwDxj8GtwP24lPIoEl5Upp1ihOPDNn7w9vP31XzmkZzVX7vhSGm/Q5bkGtUxhilcG7I1u9le/iXIlrCZV3SAwpm19O7gI1FJTzMFCYTIsHzj+A6dYxTGfbMOTDN0+fPYN20sJzae+uKBm5bzDYHezA1sLaDlevXsVqtUq8IoyXkMKyBxYagHhtrr/KLbM21eynjil9M6bkjCk95d8Uwtlrrrtyjkb/IVfcBoVENQxWgwOiGw0YtQR1+5QeZrxCqdIRDrEuN3UdX9N1nNpcGkpZ2ZxLG26S+6fUTv3vaWypLy1s8jKYSAVfbDMgJGmGUrO+cEvGkBEpq1PFlKM+W3cK5k2R7/HEcfCUXkTNeJ1Gn/qpMaIhmayDIy8VLWykFwxwk8OWM0tZCOsZ9yaFgubKzP5mrb7HfD7PBMM6AVJpMBufVI+6wbp2qm2HsMYjjK+2PsbaT4r6uAWWWyrSVDlPfmaXyxWWKwsXb35rMJvNsLW1FW7sCsw5MMwSXgDRMW5tj8VigYODA9i+9wKDGdE9Knc8y4564nBgzjfqM/djpiXJoGqM/VpoKrQVeIWyHQc1Y4CFYrTi0vGWEq8RChLWXbiKRjIW1/7OYY5yIbYty4zVSGhtO3k5svuo9KENJLI6qYlMe5ZTgEKd8h8Xn3IkONVumJfBgCgw/kL7zxeW0I3f3EkTkhpWSpQaQ9KEtYtHw23kqGOSSrGZIU7CfwU+SpOU1ZQ2BgwqXw2S/Eu7jGr1st6vcaEIPmW7OBM1Siil/YZcyx9+lQuF0Z4LxlhqY3L9I8Douh5XLl/G7KabsvoxA20CWBofdlhoXGH00PijWC/QSN54GmIIE/T7ZwBQ0IO22MInTm/Wa15UwFSoieBCQ471WX2gBIOmURseMhMuXryIG258NNq29e0Zg/l8Hq/ajG6bmKrCqLUU2mQfidZ3vb8PWTZDw/r17hWG4x7MKh9RuPlNLXYABOIi8R7IX2KXsYJAY5QEwmFehlLB8tviksZC03bwcIgAJtHshetyxJW0nf7J/CCud/+EwmFBRCvJX0uQUvaIYKkWTQ8MyC2NfgycYNX/4RA19bG+o1kjMiG9yRARYAbAIeY2TU7TNHl6h6jpkFoQBunYnQzAT8BAU+ZG5GS25ogQ771NDxngFIWUSc1y0SHh0sHFvGdxQ5tEWGghkTSFhAP9HNCpMyKfYIConmcoZ7oCKsUPSeWWyt9Lv9iwKMY+ED5JC2IKCeacR0RLPtUyGePPprgo+jKtNIejntaiHEftb/2NuB4MQu6opsV8OgOsQ9O0SbssZjY2acoZFwxgMBce4wxwOn8i4s+IQqPyV3ieHtwiZii06y4t+MUNRB4ewxWhRK7wd8eAkSg+z6CZPYmRk5PO3lJJuowoIAmvJqzDVc/4yH3n8bRnfSK2j+/AGLkruUXTtv6eaKXBe2FgozYsa951PVarFRb7+1js7fveyEfLOOf/9XYV5taEsxFpI1UnYpB5jniD0Eu+3nM8DoVvuQ8gv6d3ok+LtNWeBb8+U6SQfK+0eviwXUnmFzJHef4gZyZM+NghMGabmHYQAJ6/DBWTqpsu8rGgvgZFolwxxhDYcpr5vyxLoVa0bxMB3MB5s3o114qefPH/Z1UqJmJ8Fd6PM5Cs5mgp/ay5qR2D8BRTGDaZxuYZRc1XnWknou1y8GOW7o5DxnZYWefG0q6b2qIp61IQ8CKovM/a55DprIULWvlYO9fqIlpXBC4ig+m0xdmzZzfrp8qUx91NuR97TWEkbRqi+NJhpJdpq1lznJ9A1nVjB1RunAPhjDeYOGbhGQPBWouu69F3PW699VbMZjO1Fl2MQJL7ECDrgZOiBqQwXuccuq6DtTamk+i6DswunFFgEHxqCIsloBhxJohrwnPTeajhqng2pNF83kQoHEZPGvea96XmA64s4lxmDgdVXJI4GaxjySmlEa58E2Fz/ns3UAfWl81vXisQUC4gb/YSkpuoxmyLvQRKBzCkNb+W5ICT6GQu+z764mONOjPK3BgVpI77H5VfkyhtnrI4LAgEp7T//NuxdvX4jTGwth8shgLAoQWRaTnrGe4mTHJggUH4Zk2LT9YQgKitx7u8aDgPNe1tHaylYDQMwFB2L4MeuykSv63FR1hFMRxQ9xvHcTisY8WnHpC2gpUgKqHqR48vjpfzfbDoRkISGDVa0D/9OrLwoch6LJImeui3ds7hYLHA7bffjrZJ7CAK3axHpRhEmvHwOufQrZZYLhdYLBboOh+C2vddsBQkhbULqR88AoTW1gmF+LtYUKiv9xpuxp6xAKDXun8z+K5Gm8IPnXMAi8fEj4/j6exCSZD2WTaBxxUyzSdyl70AFeiiwlvzah5jR7kC65qij3TJCDIo9cmkzL8bZcLBqognjllaPOT7MboQK3NDbXnY9phWogi1In2Te6fOHAfwkx5lAYt/kLW1biyHMeNaGbNmxvpQIBXvABEK+ryGxsdRi2aKY7AcvdHyz6E2SiSKz1h/NPw1girigKIWL9+TvBb3RzD3Nx1L1b0ovytFwcS2Oa6BWpGcPH3fY293FydOHB9YOn6PojiAlaSeGCuxvcVCBILkM3Kw1obzCQ6yj8DBf57IY4y2GHLWRiy22nBy9/W4Ula2LQOJ2nv8ZhhKXCrBmds8/o6M2dd7VeaCwC7troO2XN8brKvYcuAzf6nuo2rjgbFvUhKi/SKMUlE7ZlNvVd5ARNWc+BzdMXWmV4Oj/D3tA4T/FNqej8wzqYqGlrWmk0ch6D7iTXAYEttQQ9Ptj1shj6TkriRA2E6phWs2H78Z0+zWEC5RXZhlmhEhphUYg1cY06YW05CxkPpv5bBRvUWIvRhpIjROwGja+sCvM46+yUKt0Wa5Kog5brwjumBFuInmmtrQmi4zYzJpoyDOWq4w6vQih2u59ALBWweS1sLBOtGoOcJHYW7zuUj4JyKAOEuvHvGH9QrfZkUsBfWkppGrooWBtOHvRBhXVPV6zWAuFD2uwCPf1NoaWiJ1uDmuzb8EoVAmPBMCihqd4qNjoWsK1Ei01YFkUtnr7Zn1pRlW9p3UV/CMMP51/fp2Q6/kJ10iD/ymori3Bi2kMYlACTHIpTpgiODYgIxvq2maeChLBk6oCAGtwWiNIx/IxmMuyzp3D6kDQ0LK8X3B6JK2PcbUD+9Pt1f7O18gYyPS74u+FDBrQE34JFHDFbFr2JSmyYUzKloS9bWvIAraazIlQtM5A5AL2uW5+KQdGMQcLonx9QyaqOCL64LI+/tnsxme9OQnYzKZ+Q1sny4n7MWbgv5krCbCKkoQGOj7PrMStXUpjEmUOYm/yU8op3TWRAQyE7SUBK8IPYas9TzSJ02DxlUxNfG5nJuq8CYwwPpSneEdKLFfpsAjANZnkUTwFt845nhZVOKDqWfdx6Bo2mEO8TT1e0EAgPS8A/HQ5WFlc0vB5fffRqabMQMgEbYimPie4ztfzeWNBImbb64E4ZPsiEJLSvpDYlApH9O1axM+IsA4n3qW2K+WXItKRCU+Sp+uQpChNCE5NqosBx95kRaPZJ+U9jLhaHzY3ljiuUHZRBgUguUwfHG4LywlRlBpHhTMpU+4BGeTeSm1stJ8B9L5l+HCThCrFtN/RV8R2CUtNOnvqPp9VpwVjudrsIhLr1JkrsFgVXiKDj5+DSnp/hItSbsxoi60YUKuTgLBkOT19zemMQVeZQItwfoIIoWDxWKJ/b2r2Dp2HGcf/VifIC4kvQOH70NIZhLC0oaMSzRQAGiwc+wE2pAWu+99JJJ1K4C7cHGP9aebrc82yuTAITy1baeYmAbGNEBj/H3RROiiJu3/SWh0EgYBu3K/9BpLT9cX68mPS/GoIPT9EtZrjSE3K/i+XeY68q3KOYy4/Af80QCQkHJ9r7R4TUYBl+yrFiqykwEJBqiudxfoUNr9GOc+EmkpWnS5EKMfHICIpyc+/Vl4zgtfUtYctP1nr/5N7O9dxae/9BVZjdow3/6GP8GbXvv7EQkv+/K/jdM33IhCjOK1v/3LsNbiOS/8LPzCj37/psNMJZi48/kxfMk3/EPVcmabAADe8frX4I1/9Nsgohia9okveime9pwXZJL9Nf/7F/CBd7w5ENNQYIpA+Lyv/Eacu+U2+cyDE/j33e97B37nF348PvzML/oq3P6UO6tDuHD+Pvzyf/13kWg/6cWfjzs/6VOrdfevXsHP/Pt/BnF7fdxzXoDnf/YXVev23Qo//q/+bwCMT/ncL8bHPfv5Ch1+Qb33zX+GN//x7+BLv/kfAwB+4yf+I+6/6/0AgLad4Ku+/XszJWO1XOAn/813xhvRmBnbx0/gK77lnw0pJoznf/3o9+OBe+/OfOFSHvOkp+FzvuzrAAA/9f3/BAd7VyMOCagKroG0KAoV1dKlKOqFckQ1xXfxp4IjfiX6TGQwiSmXYydGyGmTLCVrJeY/cB7HOZNxSTC4cJXpYtGBmhUaYn9AzSTBsY65DkYdBjObb8G0E8xCRJqz1t+ZcHCArlvFQ4bCxNqJz9xpGkLbTHxILbxwduTTQa+WyyBcvPuJbbrIy2viQVFS6ylXRocH+JIRVhkja6GnlRE/Ru16k0DWVG/Yp9OCJVNypDvycxWURa4ps47TB5BlxgPFrzoesdDG3lfKkYRC7ff64vKAX3zoPO76wLvw7E/5TADAm//01di9/DAkFaRjxie+8LMw397B+fvuxnvf8WY8/8UvAxHhHW96HR786L0ZiX78J30qnvKM54KI8OY/eRVe8NlfgPP33oX77/6Q6hUAM26+7XG48VGPwdmbbtl0iMNxsNeOzt1yG173u7+K5WKR+vDqCp7x/Bfj2IlT6aAUEZ7zos/FZDrDO9742tjU8z7z5XjGC16C2Xwbb3/9H2f9RQ3bGLzwpa/AY5/0dDx471348HveJsMBwHjyMz4Jp87emMF58uw52L7Hu970J4Px7F+9Evv5pBe/DB/37E/BZDrDm1/zu1m9m269HY990tOzdrePncCxE6fwut/9Fc2xAgOyUS04ceoMjGnwF699lV/MYfFOZjN86su/FDfd9jgAwHQ+BxHh+KkzeO5nfj7e9YbXFNYC4cV/9avwmt/4BSz29wAATdPixltvxx/+ys+gWy0VLoAXf/FXYTKdIV/Cqcy3dmLfptHx776vct9Dm9m6+HHW6Xsd41xnqXulIGCwEAZ5H6mXbM1xWneDDVEgpGkoD/8BIDlbACwXS2xvb+PEqVMAUcx7xL6xoaFJHh4fUCKWka9HhtC2ANEE1LRRi+57i2YyxXQyge06dF0XhQNAaCdTtJMpmrbxuf5FQweDYf19ysFE6K0NFoyFlcNfYQ1CcippcCtuN+3q1Bu8OZJC/8oCzTwcSFaK1+0KNZHjjA2s/docR/Va6dnZJjag3E3D8QmFUPG87IRQ59O1cqSN5poJr5+XRPjgRz+C3nZRKLznL16Pg/2rmG9t4fx994CZ8fHPeQHAjEsXHsRbXveHeP6LXwYA+MC7/gLvffub4qInItzxlDtx6x1PQtMYvOV1r8azXvBi/PQPfS8euv/eMPJAGM7hc17xN3HHUz8eu5cvHmWIqsgs+TE99NF7cc/734393avhte/r8U97ZoaTW+94Mp75KS/Gm1/z+3jDq38zLvpnveAlOHH6LE6ePRc1gcEmEgjPedHnoJ1M8ZbX/C7+/FW/kb0/fe5mHDt5upgDwoP33Y0/+/1fXzuaOz/p03Djox+LD737bVldAvDUZz8fj33S04uxAwf7u/iz3/+12Jcs9kwTI8KlBz+KP//dXwUI6G0PMOPxdz4bT7jz2WBm3PO+d2K5v4eTZ8/hjqc9E8/59Jfi+//+V6Dvuji22dY2vvXf/RTu+/AHcNd73pbN2+v/4H9jsbebFgoRPv0LvzwtBUZmLZy96dG48dbbR3FR3cfIclaXmECulSl5Ut30F8dO7V11YSac5vpmBaKo5eZKRfVe7Uy7TP5354Cu63DmzFmcPns2U6FrzDTrPA09uq9Achc3+8PJQXt3TCDToDUE17ZoJxM0ywZdmHdqWpim9VZKxlltsKQIbTuBcwxjbHjl4oUyUZlyDhb9gOnW5lkMwXTXQTnCpFgORs5DRu8fl3+LNVhTM4awMel+8zbFnUVx3il5Zcb2EkboblOhsOGtnbWB8+BfeBH/9jcM6W+Apz7jk/FpL31FrLNaLWHtcELLdgeSnYHVYoG2nWA6n2M6n2E6m0Ow2ncrLBcHWC2X8ZN2MsV0NsdkOttw1B6Rq+UCn/WKr8Etj328PAZA3lyWwz4AyBh88Sv/IU6dvdF/axpMZ1uYzrZARPjzV/0aXve7vwxD6Y7YsiwXB1ge7KPvuwQFEabzlIMmph4IfnDTtJjOtzDb2o7/2sk0+361XGJ5sB81bhmGaGvV0ZOJ7fn2dzCbb8e+jTFBA1zGpH4+/Qfhw+/+C/zvn/yPWB7s4+d/+F/ggXvvwsc95wX43C//ej+GeLdwmM4wz1/4dd+CO572jPDMv9N4NsZgvrXjtVkzxCMR4bkv+Xx8+hd+efZsnNklwR//VE+t/J7ReP7JNRV9k05oL7ZfXcCeBTP5dMhj3RP8joWJqmz45yzY9QD7MwNkGmztHMP29rEYxaeHlZazHjMlSIg89zCqnmlAxl9bieCq0m0SEUzbYjafo53O0DStv6bFsD/xzBYx/UUYrzEG0+kUs9kMs4n/ub29jfl8jtlshul0irZtvRtK3wEODOhChC6rvzWWyZh49/WgcEEDelaIEBI/hX/pnEINBvkn6UPIiNc/CXk9n0Cw+rT1IG2zt++0glDrq2x3XTmypbBW2gQzR2QcgHSjlABVENtP/fA/T+aYzicu/2PE9NW6G2t7/Kfv+Qf4ym/+Ttxw86MBAKvlAX74u/4+AOD3fumn8Hu/9FPZdy//ym/A455yJx5+4H78+L/5x2tGmsZ4sLeLH/7Ov6PaSX6Gv/2PfwDT2Rz3fvh9Q4Ihxm1PeDJe8fXfrvBTpn3IccHs8J/+yTfFZxrXf+Mf/gucPncz3v/2Nw2+f/pzX4inP/eF2bM/+71fxR/8ys/Ev3/63/0/VaL+nC/7Ojz9uZ8aNXPZUwCAMzfegm/5N/89q3/vB9+Dn/j+74x//94v/jd/yY2E6Aa47/zkF+GFn/cK/MC3fNVwwMW4U7/yQhabf/53v+9H8T/+/Xfj/W97I2645TZ8/T/7D/6bQ/3eRy/Kij+03se218Pa1lBV9hr0t+w3Qink7WEQHDkw9QBazOdb6FYWk8nM+/KjK0JvjtcZTXhQuORkfXqXsHMuaL+Adew3V4nAFJggGRgANgg4OOc3YAJ/ICI0mMDGi7IYxqS9AwBomuTKNK2F7ZdZgMpAoSwXXmUhStbWvJraP6gy1eBCoxZ6A1pSvGv8xACJNFSvAMDfQ83OevecSfyu73uQUy6q8Nw6BzgHRybmqyqFIgBQE2hg0wAVHGlPwSeUK+8gTtINEInASHEqrM7S/ZWveCXayRQPnb9vMGnEQKtyFhlmGHVz0Fd/y3fh1JlzeOufvhp/+nu/BoQb3H7pv/4gnveSz8edz/1UTGdzfO23fS8A4NW/9nN4X2CgkWiJ8M43/gle879/McuPNDTFlNUDia/2k//kZz4XL/w8vyH+0z/wT9F3K6yWC0iqEwD4nz/yfXjME5+GZz7/M/Dj3/ft+Jrv+JdRK/F3tIbwNuciQ3XO+b/VYrv5MXfg5V/z9wAAx06ewR//+s/hrX/yqgjvV/2D78ENN9+Kd7/5dXj1L/90Ni9Pffbz8Ypv+A78zx/5l3EsotVM5lv4m//3vwIRYWvnON7/9jfit3/uv8TvP+8rvwlPvPPZuPTQefzsv//ujA7OPeo2vPKf/CB+9Hu+RaVEpni9YQPC53751+LJz/pkrBYHEcNEhLe+5vdw4aP34gv/9j/IYBXLJ85HsDhk452I8PKv+WZ03crnNlKaoFYYCMBXfOt34z1vfh1+47//ED7vq/+Ob5/q4qPUb0j9y7aOkh6AwLXS75z+lkBmTT8QZhC0uprEIaJ4OT2QGxEWPSjcUZw00eHJ67iWjD5r4fzF9K4DXA+2Fl23wJve/FYQNZgf28LZG8+C+wYr22M6m8lqDuOyqa+odQJkGs+MlZXWNA3gAIYFwW8IszAzJvhcZSaERRoQHMAO5PRl8hSlsmbPkdHJOgmWBMEzPbIGTWPQTuYZXrybyafXkH0Bz5wNmHtYF/YnxA3F7EPInUuZ15xEGXnLGTAwzoeWIrSJxgurFI7rce/YgNCAjN9j8gfIXCYMwGqjvPFCVd/zTH5RxbRJxshtk/4MR9uYIDQJIH0PZaCjPmzMI1fQ15UjbjR75ri+TpCupEzXUP7iz/8I5265DVs7xxNTjpOVE8Izn/8ZePzHfUL8+w1/+Ntgdrjw0fuwd/VyJMbdK5fw1tf9ET7ywfdF0F70sr+GZ7/wJdg+fgJv/dNXR5je8OrfQrdcYPfypYqvtoawBP9nfOGXY7a1jVM33ITJdIpX/8rP4tJDD4RLx1N1AHjmCz4L99/9Abz1tb+PSw9+FL/50z+CT/+Cr8DHP/8zMJnN8eY//p2sv5objohw9eIF/Mlv/mKsc+bGW/Bxn/gCvPHVvwkA+PPf+zW0kykuPvhRXLn4UO6nZMajbn8iPvfLvx6/9bP/OdMUbN/hNb/xCwFkxs7xU/jkz3w5fu9/eqvgHX/+x7jrvW/H8uAAVy4+lGHk+KkzOH3uZrzsK78Jr/rln8LelUt+0Rq5eJyxc+IkHrrvHvz57/168Ad7uJaLA9z3offht3/2P+Oz//orkx8VCK6xNBWPuv2J+KTP+gIwM377Z/5zcHslv/jLvvrv4IWf/9fw5j/6Hbz3LX+Gpm3x0q/8RrzrDa/Bh9/9NpwN1qOUTJEZTr72cWR8XyyH7POKMIntaF07cwPUi9TxqVSC4KjBpzcyRtqIGnJyAsHA+Eyl4dpUay0mbYvb73gCTp8+FRlUEO1JKGTdKBcEEO9a0FqptRZkWhgYz7TIa8qud0orxvCiqdp4xMtQua1Qoo4y3EV3Zv5ch3dLEeWLYeDYwcrf7Bk9W+cjnJwFO4ZpCXCS2TRAZiiiiBkhp5MBwUCuG/Yp9wFqCtoLTDuzwsh7CVxFafC6tldO/ft0RsSB0VvCVN29TLI3RsJaeWPrV8o1pc4+7H0ytXKT60PveTsIhMc84akBoUpoZMTsI0Y0o3j3W/4ctu8yEnrinc/GXe97J85/5MM4/5EPR0TffOvjsHXsOE6dPYc7nvoJ+MA73wIAuPt976ouzvEx+TDRJzz92ZjOt2CaFlcuXsD5ez6Ed77htZXavp3HP/1ZuOf978Jd7307AOCdb3gNbnns43HH056JW+94shcKyDU8Dcdjn/R07F25hAvn78U73/Ca+O4zv+RrcPtTPh6XLzyA97/tjXjPW/4Mj3rcE+Gs1rZS2do5hqc95wX47f/xo2AANz76sZhtbeOe978L73j9H8f+nvrs5+H5n/0FuPdD78N73/p63PXet+P0uZtw+oabh42Sn5unf9Kn4rW/9YvYv3o5vSLCE+58Fo6fOovzH/kw3vOm13kLQi2Kxf4u3vn61+D2p358xhBMmOv3/8UbcOXCAzh5w414yrOfB2bGu974Wiz2dmNd5xgv/cpvxBPufDbu+9B78ZEPvAuPf9qzcOfzXoTz93wIN932uLT/A+CJn/CJWOzv4fKFB3D/h99fxVWtRFZMuWNlrGg3TMUPMWh77F1qMDHNgS85+zyFMWovJxC00JCMzlqH5XKFM2fP4tZbb8WxY8czuFNbCSwCKp4q9ucJKuP3Vk3tzm45xZwjIFsDws/idwbleQLthhlzP0o97b6R4pyD7X3eMscOxtloSXhl1sEZB2ONFxjwG9lRKAQOS5zgMj0DZMCm8Uqi7eHAMG0b9liS9s7gGD2W8G3g0CMeqCMOJ/U42p4EoDFeWzEiLMO+hGzU+yZDX940SOGsrHB/SDlySGqNkQ2I1Mu16v3Jq+UCB3s+goecZ6Ni1ui18YY//G28921vjH9rXyEYoEmDl37Z1+J//dgP4v57Pug3lEMDv/dLPwUiwlOe8Vy85Iu+Au9/x5t9G5Xx1ManBoLpbI6XfdU34j/9k7+bWShS5tvH4GyP1XIxijMA+JPf/iVsHz/pHQAVJiDtHjtxGp/28i/D+972Blz4nXsHdW9+zB34nC97JX747a/E1rETeN5nfSH2rlzC/T/zgcEYrO2xe+UiCMD28ZN45gteglPnbsLP/dA/L3vHfPsYXv43vhn//ju+FpjN8JRnPR9P+8QX4oPf8y0RF+LjZ2bsXrk4uJOaiPCSL/1a7Jw4hQc+cle0IOQdEcE0DbaPn8Srf+mncPXSw7DhWs3Z1jae9IyfwO/8j/+CyxcewFOf8ykKunLTLBeCp264CZ/+V78Ku5cv4ZM/+wsBAK3Snl74+V/qhcsbXoOP3v3BUWZSPpM9raRrxZU3WmQzs2xb6/p1EZCUIh1VFR7U4dPrUBwHSoP1tOaFAjuHruuxu7uHRz/2DsxmcxhqgODS8S6VlOQOYdzZnquaAy08AELTmOgSGQgZQH1DA16i9ypk2MkrFywLzjduS2uhLGPCEyBQsCCMgw9WkFQ7jsP98QxuOZ6pYPZaucaFREAZIpCdSjLskHm2Q88rTLd24Jx3s/lU5OHbrs/wyMxg24Kc8fo/A86m8TEsQN7V7IL1B/JCr23mQTCYIS5CehF2DmwZm9oLR0pzUZuUUkgAAEF8icg5PTNe/4e/jde/+rcOtTikD92fC/HJ2o/8JX/7W/GHv/7zeMMf/U78zijfY9Yexs346ga6p+b4vlbnr3zN38X9d30Af/TrP1/0lff9Fd/yz3DyzDm86435eYJMYzAGf+s7/y3ayQTve9sbhlYE54vgb3z792Hn+Em87XWvro7pofvuwX//1/8IAPDXvun/g3OPug13vfftdaaifn/ZV/0d3PFxz8CF8/dlqAgDQ9+t8B+/8xvTN0FjmUxycqrh68ZHPxZf9e3fC2bGf/nu/wsP3nt3FfYSJi0UmrZNliaAj971AfzQt39t9u0TPv45+JJv8mP/r9/zrdHNhZF5HPQdfjoIYyOxyq+5jFE8UZ4FNr0Y/JJgz3UXMANN4SHj4KLlnmF7i25p0fcON910E6bTOYAWchfD8FxFDKz1Vjx7q4NMA7nLw6d7EZjY59lRLTjnQgaInCFpnpG5g+KVI+JlsLF+lc8Uz/VeU1kvfZuidbhI3ijZmb0Dw2LSNumeA0hkXRLawmOaVviND6Xteouru7s4ffIs0lXAHodt2wKOvRXCfhMeAT7HPazto8CJ8BuCkXuICGDrnUcgQkMNmkkbBUCkB3hXWB9uvgt+rnKSq+XI0UdlDqSa1sVMEYDMnxcQMzCllQsp1g3JtGrMWJ8WDR17qnbjJjYAvOwrvx5XHn4If/Trv1Admx5DWb7mO74v1rly8SH85Pf/k2q9CNKG7OPlf+ObcenCg/iDX/4p2L7Hj/w/fwev+Mb/uwofg/Hhd/8FfuMnfxgA8GP//FvxeV/xjRv18zM/+E/xqS/7UpxRh/n0/O1dvYwf++ffisX+Hn71x38Qz3jBS3DnJ78o9e8HFZmRuAdNCEEUH3NSHwMRGq+NymNvvvf44X/0ShzsXgUR4TFPehq+6JXfFmDycL3vra/Hj333/4W/9Y9/YKB59iEA4X/84HfhI+9/90bjv5Yiw3XrtImPWU95EUEkB7QEB845TCYTz9oinwvnAkjwTMH6Dnd7ELB/cICDgwVuPHczppOZPxim0rQUnRduHB9V4xggVhYFpaQeRDnzJMoDBwQuuSmuaRrES+4V49XfJLawXoHcRMgP64nl0UTa9BZBYKgpYwXEfuFoLYYmGhMCalxsy1lGQ4xj29uYzCeJXyoFs2UCQp4oA4KT/QRimIkBTRoYcMCV8z/ldjYm+Et8PNzUBL7VGDTGZHh0xmEyncQDgGZDPG0sFIxsoGhiibcxBU3B5RtBdzz14/GcT/vs2Manf/5fw1te+yq8+01/pibam7w3P/ZxeOFL/2qs+7yXfD5OnD6DN/7hbwGcolDEsBcB8Pu/+JM4duoMvuhrvjkzt5nhN3l/5kcDhhymszme8oznYra1jd/5+f+mRqemnuvr//f/109gsb+H25/8dHz88z4dX/S3vxUAcMMtt+H+uz4Q4HH4pR/9frzkS/4m7nzep+MxT3pa/H772Em8/lW/EfcIiAif/9V/F4950tOw/8Y/hQHBOofV/i6cc/i457wAj7r9CZn8vOHmW/HgfXdjubcHYqA72IezPR73lI/Hl3zDd2SW1fm7P4Tf/5//LUZEdQcHsN0KNz36dnxxCJOVOTh28jTYOSz39mAAdIsD9KslTpw+iy/5hu9IABCwf/kyfuU//wAaajyTgM+9Q2j8POn1a0TQqiaCVfGyr05hvlvHjqNtJ/ifP/wvsH/1EogAZ1dYBDfjX/nab4GzfWzIa2etP8+xWkXYpDz7RZ+LO5//GfHvl/+tv4/X/NrP4SMf8ALEUnKTi7AjDrH9gQgiWRO8n1yMooQKjJx/UlaVQobmcgopkZ6VUiInksEsKIyuGRABtgO7SWS2XoMkGA4+7+D79swEIDLorWfq586d85a08ZvBTcqtGt1Oog0TnN8wJcBfS+kjiLxLpAE573Yi8pusgQsEpdTCuR5sQphlYJ+CbKfcSmQYjuUmuaTR+z5dRCgRZZp9+bPmEi6DN5JwDeJMtc3sI5C8dUDJ1atg9fucrNzAQRCSxwsRYTJpMJlMfb64oB6yE7wCNgiRuOfBJtDjBAiCiZwDGuMVKwLYEIhNZO4UGJWf+iYEc8iYvMLQNJytx+oBx0rZ/DpOj+ZCsYikFP5M8bQMH23y4H0fwYP33ROfLfb3Qj3lugCjXy3x8AP34cL5e2NzB7uXoReMB8Rjgp3DW//kD/D+d7wFtzzmDkznc4jfO+zR4Py9d+Pu970rfvOBd7wFlx56INscFQjGZKjtOrzltb+PD7zjLVgtDrDY38822S4/9ADu+9D7w/C9Jv8Xf/oq7ISTx4EkcOnCA3jvW16HB++9KxLm5YsP4d1v+lN85P3vilopO8b73vJnOHHmXNzUin1deBAP3X+3wjPhw+/6C+xduZxVZAAfvfsDuO+D783Gde8H35v52gWtlx96AKvFfuYieujeu/D21726UAQIVx56EHe95+0xpbE/8OP/MTPe9qd/gHY6w70ffHdmNfh2CIu9q3jra38vc+9dfug8PvK+d+GD73gzYi5MZqyWB3jTH/5mwmPggNY6XHzg/jDuYdnfvYL7Pvhe3PfB98Rnes9H40TH5cuijUykoAqPAc6+TDw7Cayau6OYygG9ZYKEKnZmhCkwGDmHIN8qrTpuizPBOcYqCM6trS0cP3481oNimLJJLXNNYqGEK0VZbpHjxGzT5UpCvQmQ6O4zwXMQcgpRYF7kwp4Eh7sVwqJNKBMYlJiouDvH3Erys+ZG1nVqxcCn8nBhLoXLEXnRp+c895QYhb/UfoYZFkZOkdZEQESXWpgIYfjeqoFXwtlbEKrTuDYFZ0TJMs/dUJsJBeJNnPsA/u23f91gYzHBlSbBGBNCvhLxSOEghYOsBrQJDG8+DSeRo6UApPCzVFIMtyBYTECE/vIi0l0jyA0XYTG2DKayTbWwYqqNWM/EZ5o4ImG5tDglS2rThIysBVAc+qLyDmog+I/9cxc1vXopN+lKItZhtsw6iqPxBGdMWijG+FhxIrCzXnvvegByT3eeDlnOH/TdEtaqMy8JIbFfZod0yYrXSJkZy+UyC4msMYZaiXWlPxF28VOXWTURB3HBUaQ1wPgcQAUTSEJhuADXbnBrJjLCsLLxoo3w6JE7iGbtGXHXWVy+fBnGGJw8fRqPf/wTgaYBNx5GYyaYTLfi3OQHoCQnUhir8TmKTOtdJSbQgwmJ9PyhKx/2ulwusVwewHEPT04mmysvlPxZBaH9RJfBrQT4zV+Ibj7E55ig0POh65Vu4tq7KDAr+C/n0c93WrvpmT4/44NZ5QSJT2+OnG8A6ewDI+V1Yn/IL0YtcdjkDuvdtPl5Hi9sxPwZ4uVvfcM/HOCxLEeKPqoyyKIOS+IqBVRRKQCcDHhNDMP6eSMaDl8cNDgspp50FfuTb7RWc3gZ9pdaiXUgOMnx4smqjxqdEt9Rc5Rb5qRBa70JSo3OWBmBGQFSlDivSZvIsRW8GzJOqVv7ncMYjBH/pYBOIQ4eXpsJWpAkWZOiD6R57UcLhDQ/ifEOYdJjyA+8Dd/XNhyH+r/0umlZTz9j+1k1eMZKSXMDGmQGyEJyi/h1k045Mwtj83N+8eJFnLv5Jtxw841gY9A0SbOM5yOQ00jGwEPs+6jilPwIXknQdyqAISm3M4GAfL3k79RcCnOuaL4lTkthUL7XeBxzO4lwWrdS9EVQorw0TTN4n+MoqaFNEBIoLY0wUL/hrk0khFTmnk9Ya9GvOhARZu3MC2zWKy3hsDb2w8rH/pwCBvDkJQxg5MuNYdh0gFXV74hlU2aqbYF1zCGr7XMAwJ/25HTJzigwh3S9wXgPFxDJ11rWM0SYti3QNphMJuicD8HjlQ138YZsQZGppHsicq1NNjrrWmC+jIbCIPqAK4x/PX1wcA9AyyH1S+3bYXqSaHH8Hy4sPh6k5IQJKC0YvJDu+x533H47Tp+7AceOH88uWjHBnozs2Vk0xfkDGadYqQzAMsPfMsIZuZH6RhQA4kmIFlSnriPQHt9DWlSX1ZRjP2IpLbh1pSYQx9qQn1rRGXVjAV5AH0IxnO5SDcaeFwISoQQbFF5OlrS1FtPpNMs0UYqETXiRLpvvKWygaZZ+tDqSZMJzCS6Y2MRXmL5BDIOran+HWDablhKhtcNJsU6RbVPf2MZFXdGKRINtmga2t8HFRoqxhoUTrcICN4WcfaSa6lg10aDMpPGJw4zfyGT2OWgYQoAGKbRvaJoT+bHq3PqbltIVVYOxXLjZ9+qf/yBQI4lRmr6NNBj86bpdsYZKwjvKWI5aMo22wJvAI24KoZnpdIozZ89i69iObyNonEb832DEXdCxfEpZlFJwb8Af9PLfNVG4aPwZYwA2qIXIK3Ku9TiuO2ZwjbcQE1VWLIYEQ+WdzDHzwF3u6/nx+7MCFO61GAKaW3b+P1StqZg2a9ymPQcRDiCGZYZpG7Su9VFLEtpajFfT6zoc1Mrm7iPJBhJvSZP/SIiaEGKEKVSXVae1DYZsKHpgUy+qw7TodJta+iaxmSG7eoGRmKVU9KPM4s2Zptak9XcsnCWhRylFQ/2TAFInuRkwjVGXtwinMiDY2HZ5Q9MYY92U4Y7V4cLsE7dO7xyIDVpygLWAtWA4f/5U1k0w/RNqvGYTNSauaYjj8IngHC5UD1Nq6vA2XdBwKd4cp+hnhMnHWQ0ukeg2Q44/OgIcWc1yCpQ2rSgqvNKCNm3IokG4itMLDesYvbNoZz4Tbs78EJiNj1rKBATJ5qqkQBWh6KGhOK8kfCzlh+J0CU7TtGDLPlqc9MlkwOcASlE9w/3KIQtdr5jWteHIyEvXbnVtBEtW6IlSBmRfXMR3PjsVq0YPQ9EXI+dPpSItiqBjoTGZ09SGcz6ktzGtPzQYXeyU02vkm0HBHEBZL0dwH7lsIQiI7NIOvV6cVKqvDOQSgzOpBjDiHpnSOuKUhklMDFy1I71r/5xGQcW/lwM2LNemVVO8dTMJNOVDLRkOVFijEEHbRO8wScSH0uL8Ijr8EMqYdrDO+sohK8cWmDP8QSiQgSEGeuvzxMDKSS/fhxyvb1L+mkg5OhnhIVZNWrw0eJ8W/BBW/Sy3qigpEXXtIUHKNTjTMxNsjrHlJhrcI7NUy/2E9MML3hC90zTp2s4QpQKEnYa2gWl8OCkplw8Hi86wgw8pdsKmQWAwN2ptp84lWMQbxUO3SLLiWp9CglyQP6J9+1O6pY2v51xbmZuVIY2UMEnbg79Z1YnnJrQQEi0tVoxKnz+oW0+/kYUsk9gKOaRje2Axy4N0K3/HDeYGbduibdv87NgIDjYXCUcSCh45w4kKoWxxqJWJVP400RJ9ySOQNOCaV2ZNcS6ENinXssE3xlTXtZX8vRXypArjojT5pavIL6yodsNfDyqr+XBmfxjs5TjrwkLmZmjVCUMWy5atQ+/SngjBx26nsZj4TxjDOoZZ4l8007F7KNaNMXuv/luvczitUFAVA08ctci0L/eRujBLCMVl50Km3WnTwEVXvKfDxhjc9uhbsL21HTaUBafpLg6GyvhJDkCrbkNXJVRhZlh2/vCb4UKwSkhkGrOfb47PiULo/QirOGrJrCUNyVEsZ6WFkzHh4BgU8zFq/anvk8Z6iBVztFK2w+G4gust+r6Pd0gY44V6Y5pMMD9SOI680VwW5jQhdWCShqX94tfWV5EnJfPnKfPxGnBy2ALeGGxdkZO2McbH4gIFYr18I45AxGBO0UhEfOjEf2x82xWzOEyhD531ed2JyMdAOxs3lEXfBKXNOO2T9+Gmfoz5WMa4hf72ES6+TLCNVBmhhTFhPO66+NgXBrLw0UrH/r4CZpw8vqPq+A1fcSf4J4gWOMetZ0BvWIvk95+I4kNBFSadXTv2pWFLAkEUjbAXoTT0bO8M6XmE4VCM6OE/UrzLBryEZnMifIgQGlpvmjaJPTOvGqNHLAYEYxrwxF84BAwPon2MZCyAIwmFYQRGhAZDjTNtxo6DmrXHXG8/dBIJJORSIYPouoq1Yh2XzL8hqMPWB66KcTjWfovCTBMtcuP77Xx9F/LQc1yIQfBSOPTnDif8TZhatLrWjDv2H76VS1KkLRlz0zQRbkiOKhBsYAhN00RC9hpumv8cpvzEarlBvYkFV45nU8ti7D0XdbXywTi8jU2KVgPWA6R+lAIqA8pgPt9C74A2HotmgBqAe4B9Zk3ZC0hU4oZuneAk4XBJlKGwNyRMUlnI8Zsw56vVKlO46rhKkWgDoU91RSBvr+6C0c9K+snwVloZQMUlBtTOnug+M9qMstLjRvbY1pWaYNTvxvDo4U0b049UQTnCOYURic2osv3SKEiD9f9SW5x9VDKp9E0qhITfdWFeac9ic6YwyiDXMCENWWk1aS1tAFcNVggj4mh+6/blgFXpahorY+82EQiDd0QApayaTWPATeOvExRBxUgshQgNEAWCDt2zPWVEkua7vshJ1Svh2mSf5C9DaydD0Z88Vo5q1Ry2FzTmFom/O8A6CxDh5JkbkO0h+MrB6vS/CwNMqTVkrUN957Xj2ArLU+0+SgEneo6S+yiHnyWFMgObBPeOCQYizZs2FwhjbtNUCnwXwmeTUssSve65nuOh+zRZYDVaKG+nrMKz4RrY3FLgMc2fiueJeEpNUAuFXGomhA8sjqJPkvtpmbzmvME8VUhF9aeeksCqQ+KGvsScTyqii/Ia2Rh0f/6vGkThe9EIAl6TaS+N+hzzSQCtd0+VZR1zkffxjRCk/NcjCEQN2naCpjGw1IX5UHfUxvXJ8S5mfbYg05qE+QhcBVbi4kwQIihiqlp9htP3VPydgTheKPtRfS0RNHlDm27rydhoCEemz5R9MML9lRCfdvqMgnuJMN/aQrLltP5rAgKE+yO2xbFuYka6dYTvPZ2Eb8J8lutCrAXAwjnKGJuLvIDA2Z5VSKmhFCygpFvK1uoAeRUFbuCn940Op79Kh8XwpQKXNRXvK76JATrMYY7SBA+U4AE9F32Q/qlfpVlOIvLo0ZWbCwV9TyjSJGXZbv1vIRmXaPSFOeQUMUn9QyVweu+Uy4hcPQ+JT8ewXnvWcOXavDbR8m/GrJdYX7Ee6cM5b2rrdgemqQiEwFQbQwBTTHyVpRcGkPxRFJkGR6a8nuGXOKi6YdxwYQiRNTBozARb8234KKiFj4iIZw443AcMv2mnLASJqfbJ0FRqEVaKg+o5WXpBkw1vG5TaZX28pTBfV3fwrfqvHaFP7eoauiC1eq5oLm8h9kZB2MttY4k3cOQBvvh5dsGVU7pPuGnQTKaYz2aYzqYxS60X0BRak/ubGRJKJGwkT/znr5/U4sQL5anvMsQfO2IQLGIuJIWTdH+wg3MiFFqw9UpdaChbLwl/oeeMblNKB/Uw6aY12i/WusxDxtO1chibVTwFOS3JmvXvxZ2KBC+rOC6x6EEwTOiJAcq38yMsJIJBgx/OBxkDSZgjSqhWcuRnErc+J2X8fYiZavkYbDTrO2EVZOu+AaKk3UDRr/RZdzMd1UVwlPrDutoKOFoZ820qcoQnLgsf1lfei11tFcmqWd/34QBGXhF1OIrPCPPZDO2k8fn1SRROfVo5L2VeGEOE+l1xI4VzK+r/dEl3PNPQ/7wOnkOJW3/rMXK4u0krFkqbF6WBgOlsiu2dnYB3ChFKHI19Ih89lIBMcPg7jX2bBhyu2ZTEd4BYCQgKC4kGGGDT1rVYCjoNfhwFSbBBPo5oBmomXQi+MZznl3emUgoEr/io3NgD7A77WeeS5ALW6p6ASWoM2xC9RRSvyY3vuD7O0l0alXLF6f34KYbCipvKK6kDkEbLke9T0EAe6pc7DJJi8mv9rINl01SwR22/NjFa6PixX1PXw3aRC8lMGxkhxPpGVP5tWUbHXFW4k+ZVLhJjCMwdFgf7cP0Si/09rFaLgUAgpXUye+YS3xV+0bFFvomAG9uUy4Z4iMtspHFlqZA/YSrmeaW9Kn4P7U4z+B7RJaTem8HmptYD836N8Sm+DREm7SS+Z+YQIBB4bryNx4R0zJxoWtJgK1qXfoNjCqLNMfnkk0bXoRyu6A4lykKSowAo8GYCrjNaDD9JCyWFIwouKC+PoomV5JjyDGT/pIWMLiizzNbR5hgd1HAAgS0oUNY5PbJqH2P7CvK7WCZSDPn7FNg5uCJgo6bQjJVHbCnoMiY0/rJKyagfmeY/fFaT1NcyrvV9CXHWGY4Wfo8Ep6OWVMV8xsiC8QqbQ9916OwKtl+hX62itlOObWxx2D63E2obgNdiFaybv8O+qykCuUtrs29rfZdMaKQlACm1gteyCelSYI2npJHrPpxzcMZnT20n/qcwYOcYjTEwjU5EKQcGgitKvD/BrUMhA3FwLAUhzz6ooAkc1xNt5vIo507vJ8VzKvHbMUykcfn2ckUiuXXSCopNCa0rC7aci6OUko7187G5r603JgB2qMzqjAZjfdd4ETNiLivnHCxbQNzUos/ItJAAcHg5Uu4jD0i5gI+2cDdtt/TT1kqNSPzfQy1X93XY35u4oqqaOWGw8b2J20es46hQKL/aOoZTakybOONqGk7pwxz7DsxgZ9H3HTrLcF0HdjbQWxi8U/ULz7/sxXDhSjhsfqW9wwT5tbqW1mp3kFTkqArK8u9rV4QiG4wa/dr5VBoxO78vd+nSJZw8exOmMaWF8mcbccEFBh17C8EaMRMqx+aVc125IYYwcfCfM0MyYgzoTKyEiGt1XmJsHYuQnE79ePzByCKKqBAIJQWMYnCMVtaQ0JgFWtY5lAakziEW7OGKUc7lfD6s8G1lIJuujiOlzta/ywLXABLpRF0aYD11uWqaIXBUxoQXNVwLNdIa1aOonndF2YuaMMoXvdQTAhhpf8T0G2gbxS9EgHV+PASvAWhNq9pGge/DNNcMFo4RzglzNCQpZjlY52BtHxa131MIF0LFfPHCUcQXHc16AD7zEEeXw1GtSz2O+cnTsKsluoP9+tgOKfMTp2AmUxkyBMxufw92eeCfI82RYFla3jpxCk34Xgozo18coF8cxPYAxnTnGNrZVvDpp3H2ywVWe1ciU24awmRrG7OdY6HFtERtt8Li8qUcH2EtOjAuXHgYN9z8GGzNt0PHXrnwG/sGjVZQs7WmR6XWkfj7maOv2qhaMt44Jy58YyhW8EvT7y1ISobohguIT+6ftHUq/MU5h7b1t8z1fb+WMQ+UQD0qqh+QExyFSti8aH5Ye09FHc7ph1m/jp/UFI4aLct6lKZECfBKFw9wkUO8vhzZfaTdHr64qB5zHKjXABLQHAiLo1ZcbRtygyMJZQDgcKm4CuPSxVnAGJ+1kMPBqqRqCQAZyEQEfV/pYG4qEyPajZCtXCySTVpYQ6WmVLalmbtR/UVBG46vs+R2r2iydeyJABJgcg1M9xtN3KhwJkEw6ugwDUCNT+XPS8i9vcwGDTGacH9s7xwc9wAz2tkcVUwHywOox16XWmatfPLX/gN89B1vwrt/6xeH2CiEYA1vz/2av4cbnvBxg+dv/+Wfwvv/4Dfi300Um2kTjwl41pe9Ejc95RMG37/nt38R7/ndX47DdI7xcS/9Ejzu+S8e1L3rz16NN/7cfwaFmCoC4fHP+2x83Mu+dFD3wfe9A6/5T98LAJjSCgwDZxqfw8gxnv4Jz8DOseNx89H1HQCgjesj3G9hg8UAf5kTGbnYyIFdAxOeAxbMBCa5F8NfyQnj/B6FQfjHYPRoSdJuSxydR5a+uMdaC4eUVReCV/9LYAIGcL6ttm2wXIYrV1GP0QfGGZmmeb2OsqjJYt1uVuoaqu8HKIVCpGtiNOEqUPEIaJkqARUl/FkvmQWhFULJGeUpSfOWMYhr5RHuKVDl5zBZm5FJj3iqgBceDb9eP0lEacmCevghVb6JdlUhMA4pmaYv3dBInAMhcx8lQoAScopJVbUCk7Sx4H8tNxMBYKjxVKEfPMmsDTeEoYRn8LvSQAk+v45oqnA9rEtZMn3qZI5pgJPgslHgrVuEQvyjFoRW449YPvd7fgRv/Kn/iD/9//7rDAWf9i3fvVGTMs93ve4P8PZf/ek4jk/5hn80rBvGf/7db8Wf/8S/zwZw2zOfh8/8tn+F3/9X3xafMYAr992NP/oP3xXbfepLX4HjNz0aie5MUm5MAzLA6dOnQU0LcU+UygYRvOvOiOKE9D4iQfKRqbssPFjhD5+u0Uc0hZTZASTLPnuuUZzWkd8+N0Qgav0dHF3nDQpQCF8XekrkpVVP7U5+JPt5426qaykaws2IcJSGj1iyuxNqihWQLtq6hnKk8J1cSg//Efm45NIXloyHNYd61g5gs9FRealxgNWEE7UZAxLhsAFTHDJH8vcjKMtj7J+Yx6TqxXYiCHmERvl3TTta16fHs1wZPmbeehyM+ek1nEkgKByIcUQEGEJDQRBo2CVyRi1q7V9el9yuhvsqfCjwXcFN7Vk7m8PZHna1QL9M/9700z+Cyc5x3PkFX5mGXLgoCMDzvvZbcf9fvB7v+4PfyL5/yy/8V4AM7vzCry6Aht+PWer+DsDs0E5ngUYM7vyCr8RkvoU3/dyPol8u0C0O0C8X+MAf/ibuecNr8Pyv+4ceBqPmhQgnT55E05h4yjoLE0ayG6trIP5pwj0LwoCRvEix5D6obPM7ZPBkRrooHRwOOjZ5emxCEgiouztiLzIOcZWp39fVr67HONZC2SvbUP/qL8fpM1XKYZKLkcbhzZ+PtV27d1rCfmW+H4G+dDRLYRPTiogGcelSxK9Wk9RUtDFmJpYlSkoyaNsWvQ59rBBDBeDMP1obT/1ZOr2smSZR3o7WJ7Lxyfc15YHEFNQv0+KrwTbcZwDSBd8jKS3WouUQDV4aIN++AcERgZoGJibJS0yHQDjz2Mfj7BOeCmYXfeEPvvcdePiu92eazy1PfxZOPOoxCcTw7vI9H8ID73kbyBg8/tM+F/MTp3D2jifjSZ/5cjhr8YE//M2qBBwVPBjSxqV7Pohbn/U8nLj1sR5+TjB4fcDXP3v7k/Gh1/4+9h76aNbG5Xs/jFue/mycuvWxWbsPvOdtaOfbWd1bnv5szE+ewYf+9FXx2alHPxYP3/1+XP7Ih0JXfjx7F85j+8wNOPu4J/tnPgTIC7imxWw2S5p2RFxRqmuuUKRIV9cbl7pCnRkLuJEhkRcU58+fhyHCzs5OzOyaUbZiZOFJel4wf1Y/N2F6h9Fx1VqtfVPSFSFYSetcuwlXaT3WU24Yufe86HtMISzfD8BVEBy1XNMdzeuKRlC1fkmDBUPdtK+E2KQtNU2TCYWs/VAnjgd5qJxExGjta7xvP5CxGnrSaxupYuQJj9FCKRFBrqfkwxgSxYAwhYkV7rrMFXWE+dQJW7QVJMKRQnvcmLjhLDHnRITjN9yMG5/0NNzyCc8VSMKcE1b7e9h76KNgZpx81G245WnPwtk7npzBsXPDTbjn9X+MB9/7dhARHv3MT8Z05zhOPOo2TI+dgOs7fPCPfuvQ8YQRDCy3YtCBqRnI7ZUExORx8s3ODTdi69QZLC5fTM/O3YzZiZMRT4Lv+9/2hsEKve3ZL0B3sI83//yPZvM7P3YSx87dgqsP3AeQPym8dfIMds7dHGo4f7LfMJq2QTudeiUsqvYkXCjCroVruqbD04jUEqVNl+Q6qqk3CTeCNyFqQybsvzAuXLiASdtia2sLfd8PLtSJjJ79vqPmc+U6inSOumDQ9K2DNBKIFF2cYsHWFNQqHgYDzktNOFCYB1brXayjrF9GUqCET4wwfEnMN1QEEy+9ZjMB13B4bXDtW1H6vo91Ysx1pn7U263rH/noElPlQPAS3eI3rhbL1TpeHtswYdHMZjNM2hb7+/tYrFaYTqdpXCJwIp0XG8rVkgi6ip/4zG/wcrbY6rA2jQmheMb7cClEaoxYUjUiH2vb974+zj61T3GxN2TgAhPyb/2FO9Q0IGvRh400MsYHATQNPuEVX4OLd30Ar/63/9jjwXmN8ekv/+t4xiv+Jv7kP30vqGnwgm/8R3jHr/+cd8MgMe7nff23Q1yQYMZrfvCf4oV//5/h/DvfjPf+zi8JhGuF+XCMdfxRHFUauoxUqjvb4+O/8Ktw4ubb8PZf+cn47bP/+jfg1G134OEPvy/HpWLSesoVHwXgXUy3PedTcOJRj8Gr/u0/9pu4zHj8i16KJ77oZegO9sHwlhYBaJsG8/kMAGADN/O8ONGHuOwaY3Jyk70EIqxN5RvJQ275Kt1pEmGWPnEkqToIT3zSk0Ds79q4evVq8IknpUe3KOubUFcOo5CI9FsvYxb+mDDJhjqwCpIgKoBJ76OyJ+0QJCyFkIStr+MibgQu11sYk/aDhl1pAaI0yRFmJO2rE0fVerVy5I3m4bV5wyI+51K30HlVyqGk3D+hThQsdlAvdAKfGkCEgwEz0FITYua1L3w4yZO2xZXLl6NvW4fLxWoCMwFwfKhmnWkYSmvgso4odOz/0O8NtfBhm87/jKkAbPjYxJvL1i0a3R/gUxYQKC6mI5eoXTIsbBQ+hgxgCL0BWgfEjX/x6cLgc7/rh/CG//ZDeOgD70bMB974q0ff+b9/HmDGZL6Fz/ve/+IFCyrMWthPEIziC76W4QwF3voSMaqq/+73/D180t/8Vtz+yZ+Ox37Sp6W29cX3xV0Z+pBSEj4m4MzT8Z/+6L/GE170Ujz1pa/AF/zrH1cwJ6Yta3DaGrQTApkejAmMmwCNpxtZEzANuGlC5Jh35xgVMip40KxD07Exxt8xAwcTTsk6TH3UWqBjoTkLRsNyKtsvHMnfJf14fASmqFEqayJgwo0wOymbboaK1Rr7Fo9AEIjlemFOgREZO1W8RORifC/CJqx1VtYBADC14WdQZh1A6npSZn+OxOc24uq6zgujFpKTv9c1fGABbYi1IwuFdb7+zNRjPeEF4ov6g0JeGIyaR0VfRMn3Gfe3lHmmLRzAL6rlcpmZljIR+YQEbQf5Iopmejl+lNW01TFesnGSjDv/JqUfznNNZUxnrJ9SMBVm7kZuwRIHQNo3IqAhgmmCdsQOztogwwyMYpQyD6Y1sH0Pf2+zFy7UNPiTH/k+XPzw+yNc2sUz2CMS/cAA5cZfiY+6W3Ns89GPN1q8FfSwc3jbL/0E2vn24N3tz/t0HL/5VhCF+7Y5uNgUE3r+K78d977ldX6PhCSKC2B2uPv1f4Tz735rOJRmAwNinHnsE3Hny78CBIN+1aFvHYy14NUKE0wwmbT6ftfACyifb8rHXKOLbJzM/kI2gooiQ4A1Z+oiaxhy4E9UkjJySBS6QqHBIXS8QdFjMMbAFr579pXiINb65NUYVAe6xmj/VbwKg1DHjBOvDPdUmzy4pN5J/E/sSZ+E1/2TWHeZdbG+XHPuo5qvXD8fyxl+lH5K5jXWf1YI0OxZMxJNcGNatt5TiG4tNSbvSkDQ4CuLaA1sNSY1XicJhhwPxaKu4EbDAqI4F6UwHtuwGoNtsLEO0fYIbEwk7uiiC+2+6zf/F849+eloZjOcf+dbw3OX0ajrO7zjV34a5574NKx2r6K7Z6/sPLY9hKpuMtQZvlaRh3XveNFL0S8XuPt1r8qERK0cXHwoNiLM8PZP+UycuOW2zD0gFZgZ7XSGJ3/2F+LB974dD3/ovVheuRRo00XdYbV7Bcurl0PONm8t3vy0Z+HGJ98ZGjMhaV2I4AKgtTAO3FoiwbJ4IS43dRV8lTE6MJpMSQoj1daG4nlRP/byRzmIPD7m8zl2d1eKMfvnjos74NcwxdKyATBgpGP8T3ATAa7V0b8oKSj8Qfdfg3WtksWpTtr/S3xD5wtb35a2ZYawDHjGOESDcm0Z5daUdQgZ0/q0H/eo/ehvc00k9aHDPEtYRt0vVSYrh0NGGPE1aDljG9Jei8jrXasGtambpPymhiOSfwVRJ/eS/tbD/aHX/C5O3/4EnHnck9J4rFc1j91wM07eejts3+H9r/p1H/lzy60DjRaq7TgmUi/WjLkmEC588N3YPnMOOzfclH1363NegH61xP1/8fpAW8Dp25+I2fGTA7yceNRjcOzczZEGiQi3PvN5mB0/icv3fjihJtSf7RzHDU94Kk49+nbc/ed/hL2Hzsdv9dxun74Bp267I46NyODcE56GG590Jx76wLsAEJpmgqZt/QVG5BlEFpzAyODSGCrXSa1wpR4HiyX3++hvUrRQcXWzt76CUBDaOKxsZMHWeIoAWApm/Y0aAKt/tVFdi3qbrZ2aQlL5G+BquGl8y+OhuDVeppo9Eu84klBY13EkQFCMdU4vMdDKNLOOdY7Yb67p1r8pmcO62HiN9BKF0V9YvCm/WYf6UjNfN8m6Xt5G+pYKnBZf5h8VcNQIdC1hifrHeYSKY85wEvecomDzsNrVEgDQzrcwmW+hnW/BzLfwmOd/Bp78OV8c++2XC8AYtFtbmGxt+3/zbe+rD91EIQ+CaSdoZ1v+5HQhyPRZiJJxvOG//gBu+8QX4nEv+CxMt3YwmYd+KEUmybif/de/ATc/7VnpPEFo4ymf88W449M+B5P5FiazOSbzLZAx+MgbX4t3/trPxnrTMI5zT3oanvnXvg5v+In/ALDDZL6NdraFZjaPTJOI8OhnfDKe8YqvxWQ+T7hqW1z6yIfxuh/7fhgQdnaOYTqd+fE1Xihw3GODEqAqRTYPA0UiXpD70eO0e+mQE4ISzqxw6mPl2d+Z4gqNOzBoSXcxtlj0eli3XgdyieuuCT2Xpach+7vStpB8SXe5sBxRKgeAaCUWSblUEomLJbvW4OCkoKbzCcPxRUGOIe8aKxu7j8Q8K90uY0iQ+v6SmfBwneA/ojDWcMgmNbMFs78eEkjEOnBtbag5Z9Zj+G+5dI7aZlnEFJXF9bEsRsGpcbHJ/JVFtkJh/On0aEIH88A4IXLhAPA+6ODj/rMf+3d4wos+F5/7Pf8xa/edv/ozeMOv/mw45wC86vu+Dc/68m/As77slQMY7nrogQGOnvDiz8cTXvz5sN0Kv/OdrxxkbK2V1Abh9hd+Fm5/4WeNVEy/3vlFfwM3PP6peOvP/AgAxLHf9omfits+8VOzz86/663Z38//pu/MLJLP/q4fzt4fPPwgXv0vvy1QsYf/xC234fP+xY9m9R563zvRNBMcO3kM02bi+X3j4MjBwR9eakwLKpWy5LPwFph+zuwvmC/GK3iq3mzowgfGtyE0ZYyJZ1N0Qk5JvirWR9u2cNzDWadAG8/tVb7fuIwpzjw8L7XJyhv2P1QQY/tr17LcnjjaU/h5GFRasFnEaMwMjyGliQEYzUg7eSHeENPf/y1f7UGVDoFBtktNcJsy4lTPARLdUG6aHAZivNmsQTtpYdo2+lNFMBER9F1HgzYVr9ewyjfeW5FEhL9tKuEjX2xrQF1HWLEPhTsOflx2MIZgqFE3ayixxYDj4oyG/CzwOLYflH1bWhIyRtUWg2FM4y8MMQZd1wXB7Im1axY4f8u7YxuT+RYmWztZu93BHrqQPE7GPd05jnY6H8DULw/QHezFYc+On4JpQmQHGItLFwbfxFJZZ7NjJ2HCvQMlTP3yIP49P3EaZBrYbonV3tX4fHrsBJp2Ovx+sR8T4gHA7MSpbLN9AJqzWFy5GP9uZ0M8AYDtV1juXoknxcl7SDDhKZ6y/0kwDYHNNmAaTyJm4g8TGonYMqAmCA1jQM3E/ySE1BchEirsVQC5tSWdMsKzkIrbNCGHEhjGtD6DQNP49qP0CGcQ4HD1yhUsFntw1gIu0WPUeJmHZxkO4SNi76xbhMwcM8rGU9FYH1G5jrmX66a0ctQbrySFsVprw50HCHQZbp6DU642GdU6S0RC4A2Y+/DePw/3+CFaikSgpsXXft03jY5HytFONEOxsBojOUpjyJmVEK0cOKkxrvEJIjAHAWAdJlOD+XwO5xz29vawvb2N5XKpQB4hsErz8RHn78uqHv0UQ+nGiLg+hlSXmeX66YjvGG0cYMh0PTUNmxxGq5WNLJTCDZfOoAQ4nIVcTwkAi/lVXDlxP+xkFZ9Zu8Ji9/Kw7YIvH6weBlbDagAyiu0PHhh9t0npFw+Ov1Rt7e6fr/e/eGij73v9/Sb1x/AU6pW31vW8wofnb8djV0+BUeGofl6HkepRUwYntqP3h0ZKsg5ZGvLh0UaeJZcSQzmuAoOLjiqxKKyHL96xAOXOOsQy2NjaL/mGrB/mIFWPaH0UMJQuqVHYOH/PQYiKnZKs7sP7lL5yfqZ8GhyUbOPPErG4/Dbk0BvvKRzm0xdAN22rtjkkPkf5V+YByurr5yQbVzJJORwxdLLiyDyUuIK2rhfUoYbL4ShQ40bci1Fv1dPM2I9jiJpfxMsQN7qfNByuPh+Fr2hrfMw5bvvJEgc7lzbAxPXySAuTw8Pt/ehtp5igxM4DaV6CJpvxSB4l2MG8F2tB2qz/HmgtWhgo6GnIemoK1MfapSouLPn5SMtm8FVS7Mfv1Av9q3hiK2W4NyLKGKv/IngZ/JOjBKpc030KY++jpqukcw1pg00uEkkGvwkFpBwpzIdqEV7foGD2Epy1ODjYB0CYTCbZVZAlTNm4gmpOQJLkeg1F11luxZDA5F/Ki1G5LIIMUEqXap9Y2kz1BQe1DeakPaRxHpXgj+qzLdNZZy43Y+KNUPGZbUPCwv/3FHEdxDuE4d0ojWR4pfrm618eNAV+AvMi8udUZC0YY9A2DazpwZSss77v0U5KjZ+EuOKhKk0/otFruiqdFnFtywdxE0KtB7fOtSNrwdc30aOR3D1HtQySdyEPNR8TLNF16j/OOO465bbmoah4IqvtHFYySy4bes6favtDtU3y7PBv/EvCiDfnCdcsFGodbPoMGGohBIIxwLFjxzCfz/HQQw9hsVgM6paCwYRDP3AUtWXrGMQpl9FyuQy5YZAYe7EpVG46iaDRIkAz7jETS4SE1NcWhqqU3sWka37yvEASE7CGu7qWtSnryoVIbjWMWYMaR7G3wrcJ5LHiJejnzj8R88WJOALADuZC+ivhJABsGiVvExzRzbbBPknceIODY8Ky73Hh0iWcf+ABPPTQQ5jNZjh9+gRuufEmnD19BtO2RUMGvVhBpIS/9DXo5VqECAPkNwqJvMnv2KLrezj2J4r39vZw6dIlXL54CadPncYT7rgDHz31Hlya3R9badtJZl0LjWmFTTNyT0mU6FHowiMxw1tkTpSz+DwzcQOwicKfSNw0+RxMJjO07RKdtZAwVqmvQzKvNYijJhhYrVuHZDHU6Hpj1xTq8y8Y8X3WrfTa+qnVq/U6sDrib37vxrMU3YZKUb5BuabDa4dFCZSa/SZtAgznGA8//DCYGavVKm4Qt207vNdUfSeCn1ntwSKfNMec7ikIhNC2bdgclZp+OvMbxPTgoCyAQyynsRdaIBSNkwHswDz/P1tKgVFqYXXLD9D7Cb7usN2cmZNCguC+TjeG2uqp4vgpr2cE6Znk7ukA7tEtV9jb3cWV3atoJzO08wkOFgvcfffdePjBh/CYRz8ap06dBVEXBpSE1LpyZOsis7IAax1sOBFuwfjoR8/j8pXL2Nvbw97+Hu5/4DzOnDiO1dYSmKVmmtYMwsE94w68ucCRdQ5MIXhhA6KTvQiOGQRUlFH86bKTz7UymUxgmgn8/SeJbsR9bO0wm8FhZUyhkSL7FswEIgY2iFIb7Qvr5zcJhPRkSIuyzoZWQPxrxEoQWTtWIq8TmhVleEPGsrlQECVDMWOSP+UZIV4Flw2GK0hk9qYvyYcpekYsAGOasNcQbjkTOGJnDHbhOXmmwizai2g0IWadOd6rAPI5YLq+R2d7vy1nXIQ7krS2ozkl96Pwd3IuJLsCwQ+m8e8zD3EcN+KF6Ql3non5yzFk4bkg3U2YUE9YLriJaMB4dakzRRq8HzX5lXCoCYOhC89rKT6BG7DuknAiQmPa4BJRydHI+XBH6TME1VoovEBZYxr9RUlaMUMuRdLwOmqwu7+PK1f3sDjoMN3aAcwshtzur3p8+J778BhMsXN67k/1RjKX0daLh3F0+JX6DKGm3sqGvUPXdbjv4Yu4eGUXi4XFsiMsl4T+gPHwpX3QTX3WTkNb3tIA0vkC8sYoGPGWPQ4pU7ws4JhcT8ZEAMj5UNWIy2AlGADGWZAxwR0FOOvXlidSbylQCPwwDQUrKK3JzDqvzlv9Wc3KleeuWHF52xKvb8BwHtdk4hxp16y0p9sOLyN/KF03TvE/eSj7gQ6yxLUoScpPFFbJvhiM/1pK5NIhT5pmZYeVIwgFTgxM/TcZKhiOJxOWhRQMLpJsKjklwhLLgCTKuVxpQbsXDSi9Gkog8d3pPO7OubAAOWj/HP6NOIZEAip5kQSB5kwVCahyMw2tD+W2KohNEmjFoXvKjn7lHLihll8l7gFe8qIFxToLYexvMgRn6xZk6Roiklu+FP6iQE0C3deiOAdJOU3SdygA5XnSrDwP46g57+3vYbFYIpy38kzPND7ts3PYWyxx/sEHcVN7Btvb25i0LSKrEZg34v6KNiqL3o/DRA3TOcaq63H58hXs7u9j1fVY9RarzqHvPbC7+/uY931OrVS5dZBLECnSsUQfeQuAosWV66YpbQUgsj6t3agTMsCREZeBEzIHaewS6sojrr6xUnoiRJnKxk35vGReHCKAKSTcTG6xmguzHACp99rVHL+NCqX/m9W74bLPD8EpnWNz91XJU+N6jU/iwIkoEPnh5ZoS4onEdIpp1ACsa6Kc/fSfqdC4YY+jbw6DE+FLYh+X7MCATXH0jhltyMrpma9evMWYNaNUBJLusRnXynWepEQGRV1mRU6Iiy72xJI6QOVvwtEws8niGxMemxBqYvp1C0QLBWNSRIbX6kRXzS080U5h1Ib+gK6GVlNSFnKBKYuYrcP+3j5W3conTrM+OZ+hScz86lrgoYcfQjthmBsIk2PH4hWjngkeipLQb7IrRmeATKTJZdfj6u4BHnr4EjoC2AKuc+h7C8sOjXHYP9hH2/fIT0kUSgXkACNB0poOVuNAaISjoJT/LfTpmEGNCVl3Q3tJ46kNDFooUrDSTYgwZBWOWm7w1ooOX409ULjas9Z7TXkJt9OB/YHXGk0dKiTWlvW5kYYwJr6aJPAY3xxps9pFisrcBA4p154ldcN6qXiWF0Mqixa8ZozBc5RawEhfY1qvz5qqhFf4aYjS+b5wsJJMrh1XoxAopcklLd6L4rOaDrV3CBYqUlsLDi/MwnPvWxNeFLRJF29rWsNqNiol49TPs2cin4rU3VInnnqvzNeQQecLkGi4EDL9OvxhQAOciiWQ96dbQFYfxOi6Dvv7C3TLDmgaEDVg68BT/x3BWz3NfIrzDzwAY3wm0+PHjnlma5KmHMw4D18QFnmKcifKNVx27jCNUGDb2z/AxUuXcfHyZXS9xX7nfJ4oxzCOwb1DR8BisY+d0iJzLl7OW1eykkoSlbbiWbQs4nxVTho7BhPHxJupHzkjIXNAkcmJkJZZMRQyw5KBdoKJ66ycM9lAd67P5jbCqIZXs5D1ujbsg1qcK8ZV9Jn4itK4kVsAWR8ZjvO28pLoZbD/E2lZqY+x+zWCiuVH3q50P7Cm1pQjC4VS49XPrzVa4JAOHynPC81QzP8efYD6Wq1cTx8WNVHJOFgfqRCtoIpg2LiIVsrDnEwfS3wnd1QtRC4vWrOSRanDUMVXOvYtxd8NhhvUBj7k0bdt/UOdbThraw2U9UEQgdmgZ4fertD3KwAtHBlYazzTaQBxMwBAT4QP33sfHr6yi8c99rE4dvw4WmrQGIrhnHI61SLxenF1GNMCQbNmasDs78swYa/MBUb48MVLeOChC9jdX2DVO8C06HiFftHDrXrY3gJwo2u79HWD8/DTeKDNCCv3hz6jBi+Mh9lnK2iaQdtEhN5ZtIYA58CGYOLmg1x65TfIW4yskSBg+9Bn6UrxgsVm/UpY+WQyGVqFpZtkBCeabuWeltLy0AEsZASTtVNEQ+Hg16iens3XZdy3EVdSXBd692oNjxrw3yghceiCLsrRoo9QIL2iVa/zPQvCCMhcT4cy1srrqHWwTlTnQDBgNrFOZKbMIE6uIgAxtprAAMkhEO2nHI4/DmIjBp+sinXupTTW3JoAgv/b+UXKzOAYQSP7KXVhs+keQvWZf5HDpuobUulDIHHuDq1p4TCSC57ytiz70DmP60TELCY9CC6kXFgH6/p3pTVC0UyfhAR7jh3YWji3gs/+zZhNZ5hMJmgmrXdmTVp0/QoXrlzE/vsOMGkNdubHcOPp0zgW9hrayQTtZBLx4tjFPm3vtVvHjIOux2J/gfvuuw/nzp3D8RMnYEyD3f1LuOcj96MHwcHAtA2sBZbLFbrlAm7hcwWxAXq2mEymMKZDlkOnuMJ1dAIS0hLOK7VqqSZk/8c5FxLxafwGawg+y47sVZTu1+iCNZspS9oVXfILmU9WLsTB+8Kadc7Gcx9lexRp2ytjMYEgcr4lOJP1PRDIA2xquIKgCX9ba4PVH4Nl9eg9L8hQVBMOKSKsVvMoiuPGQqExSlsDvDYRfI/JEiYgMlYBSqdoYMiuvJGBijYdh5CXwmpCVo05fpu5WgQe+S4j7ijjIcCn6MjQMEuDYyqZ+jXThNSLIGxqiw1IwiyHVfcZhFx4ntxuDswdDCYQwSC1Nz2eLnsY5d/JFB8X7CQ3p8Fr9f4T47OYmnBrWiV+1CDsDWhVigFwoIhg3kbfapgiCv6MkrmMwZdKwmUmECi4EGNOn3DOhRn9qochnyOLwjWipiE0TYvGNFgcLLC/dxEdMw6W53FiexvHtraxvb2F7Z0dnDx9Bg9fuIC9/X10fY/JpMX2fAv+TmWLVddhf7lCt1xh9+oVnL94GcePH8dsPgXDYXexAjUTIAiQ5bJHv9hHv+p88jjHADs01OL48R1MpnuAcr444xkyjdFkRA0rzTK4OUW1YqeqJEuBkCwf7860cY07AtjMYpoVfxcUyy/xFkVpxwTFwsAEoW8CmC5GLZWMM44RksMsLJroklrP9JLimmhXcCOadW5VSDbZ0DqJ2onA+xQuB+iVdrlwB9WF3zpXj2b0An/p3vI0rVzySlDmwmIza2HzLKmkcusoTmcpsSsAUXHRc0kIPvbwuxFmJlouD78ZlHJMQjiZhUKRTjIiid+5wGCKF3Hi828yeNTklFtamaYTN1k56yuSsSa8+JOSNkASCSIJxAQYQYHcz9tG8LV+4d1k8as6wyxgyGAkSaSlIUxw6ueyx4LGwDQTTwMUcFxajOBhGCcnZSCddg7hi5SWvp4ILRg21X4ygSBaamPQhPMvLnhknHWwqx5dSBhniEDwG8+TpsUKhMVihasd4yMPPAxyFtPpBNvb29g+dgxnbrgR9913H65cvoKu6zCfz3Di2DEY8vcTr1YrLLse5CzmU4MHL17G1vYcJ08ex3y+hclkCn9Ez6Lvrd8IP9iD7ZJGbJhgqMXp08fhZit0SIn3ODKHxFTLkjEzJRQAf+CTI7Mc7gylPQEGh415alzo1xNoDIUN/3yAWVqjXicgNCHpnqEQ7cVeO2O1hsXn7xmfYop65USY1lsc+bsUkpoYbOnGpOI70quxquwN9yFd6Gc9XOV3m9D1Ya5jJTbli/X8VZWNhULsXGgtmH4mQBBNqKataCkEEy4gB7PPt15Z2AN/YPgPD9oDRASPIeVa/O1j/sccItHO10ldHvn+kBJRLCaj0kiCUCKOCqPIwMz8t6I9FH2vc+uVLj4RnjWmUtJBY8IpXG1l1ZRTYBitoy0WNcUibDLTviZojoJbVRpjMJ1OMZvN0LYtbNdFRtpbhl069M5H+kydRUMGTdugnbaw7ABrMZ206FYOi2WHRXcFFy5fxYfvuR8gA5ADwWF31+FgeRAVKoJBww2aSQPnLBb9ArP5BNPpFPv7e9jaAqYTr6U6Z7FcLnH1yi4a8sJLcoJZu8KZM2ewO9tDhysJx+LSYIaRQwlVDXpI0/LbuiLro7MObL1V1bQTtM3M7y+QAZvgDQj0z8HKG6xtQhxTYvryjgA2kMgg3zeCVSd0HW9fPnS+B3evl7AU7q2yZD56+UYsC/W4LpTqlkTNDbZJ2YzmE14y5XzD9XJNN68REAelmfvwUhMNnH/WGH/JhiS808nvaiVjJIpBbCz2ss/Hvyn9gsMKa15Vvr2WTWUxT6tfqoemWMR6aZRXL9bKet88PGNDvojKy06y5Ug5PdT3KdZbLLqmfwdw2HAGDUNOr7XIAm8JOLazjflsFvqS8yD+kigmoHM+/5Y/fBUO2ZHDYrWP4yeOg8mgYwDNBNT4zWpuGsC0cKaFawloW5jJBGhboPEXs3c94+reEidPn8Z8ewsPXngAlv0p5q5fYtUt0Pc9moawPd9B27YgAgwxJhODM2dO4Oabb8HW9vZgbE28E7uWcK7Egyj0Y4ywXgwYtu/RdX6jnthmybH1etB7enkb3g0kFkNa2hTS3udt5DAR0i0N68tR1+F4/aKvMeVnBJelUBqspzjuw5W3oypDY2tyrBxpo9lfruJ/j/7DMTO1oiUTBX9tUU//HDwH4mEo0SBlAetU0YdNvkbMYWZmDYHa7K5FRB9qsawh4JpLyQsIP85WdxcjRxAtiRKauHRqzHmE6IZ1x7UpeWPZu4R8XH9I08s2brLm37tR3KYDP7lQYViAvALhNz3r1k99PnPtLqtLXnPc2dnCzvYM+3t7WHU9aDL3ik1j0DQtZhN/CqDvOxgAve0AOU3uLKbTKZhWsK5DYxo0LYHhUykwG4B77yPvGaDkfOhWHU4c28HBssf+wQqr5QLdssdiusJsPkXbTtA0LdrJFPv2Cvo+bD+Td9M97o7HoG3agVClcFq/VmTmapQtgkHeymZ50wzvgHDOgV0HQh8YmW9DggZiq+xdZmCAW4t20mJqTAhKCBB5SRfnVzN9AsX+RZCLNSGb2hBXlU6wp+AcK9GKKYTVOr6gLZkMe4fwnXUb5EB+eZkm2XV0LkJl1OVECKfXk+AHCCN696Ac+T6FWKKamkZSDqQqGKA0XV7vZkkMdfjcm8j1KKEa4ztMUtbgrGoHa75dZ6qNMeqqQBCCCf7dwSlJEuaWE4L+ozbaTVx21eI4he9KMRTPDFBQ3MhJiotq5yN9Ufi/hs1HJHmeoXHrf48HyIp28wWahIxWMAAfyu/g6adtW0xmUzgGeuYgvHxaEmd7dL0FeAVDhK7rAPJ7Ln3foyHGtDGw7PMVGRJ1wYBhwExwq95H4zQGjQHYWEyn3od+cLCCsw7OMhbNAswGTWOCUGjAbDCZTMLmMaFpCKY1OHHqhB9XgUnvoipwK9gQM7TRDiOpk/b7WL8UPhV1kBCxE83ZMNlytiAoKcKQ+77395kcP4a2DQImhiFztMoGDLPgJ/mGqiL7+AkN6qdx15XOw8o69/Mjaav+bUowQoS4pkorTkCJl4YV91BoBTTnJXpP5vByBKGQHzgT2tHERWGB6ydAEoAUFr9E1Mgo03v1McuWGaNp0mTrQUpbzEOE5ww6H0kNQfrPmg8xexIXRIaAWIvE2U+VKiNFt+/xSkk9oRA2O2Kh+G/VO0Y6WBSYbGTeyPE8rm2X4x8itDGeiRkjqgkHa4GHWqxqVrrPFnjEqUaa7lW0xQFHWKtYCK2k7j1eiUMsPoBp28BNGqxWFsQG7Hpw7yO9rHUAWzgwbO/g908Y4B7GMFoyMGxg/W4w4JVfEPnQUtv1YX+IgBZoWn+/h2MHhOsom8bTed93WK5W4T5qCgw07EU0hLZt0Datd3mNWVyk8MdAClNVSkVh9REgHAj6EGGW4iL+IpOYJo/D946lvoO1Hfb2dnFwsMDWznaaySh9QlOGgMaAuwQlyQrI6FXBpfWhEQ28/H3s2TijzvFU4zHj7q28/Vr9mktJkuNFrA6WfFhnACQdT1XBO0R5PawcKXV2bo4gMCtJuEVhwVckvmYoHOW6VkhCOyb7ljNCUK6SqDWm7I56srQpmp7rieNImOV7eaGin2O7emQ1SyxqWswwcpT+sCInmynvifSCA0GpZyr8NlPq1JL1cf5yvwQ7EwXrAGZlSqd8U0UdoxkyBS2W1X5QiMwgf7AJFfcROMGdeIqao6gZRRT4U7MsIZYFZIWAG1pgvlJSIgKtgmFNA7IOrrOg3qIBY9I4MDlYMLjvQdZHHjWNwZQmsL2FJcCYCVoAjbFYSKJGx+ClMEcfzto0/lBX1wPsDBadQ+MIO00Daw1aw5jM5O4GYNJMsFr22D3Yw97iAA0ZTCZTYOk3jZvpBM10gomZYdZOATZQsdShNFEwEBGYJNeXA9EEcXkVuDKG4Nj6pIPkGY/Hp4v3ccvEUUjU6JrgwmjCtZ0WWDVASxboOyz3r+LC+ftx4uRZtI3f58iUNvahrL0BXGvCKfDEG5g9XjTfcWKJsKuebC9/13Sxyb5ftEaqTD7VFQ19nUAp+5f+6l4L55XceP4oKBFFv/KnkbWgpCMrd58LB/2ck/58tZo7sFaOmDo77fhrQolFjTUC6JxPi3AIfxyTsuUErfPdyzthWrU6kUlAjulvJj03Ket9knVtZjPpXRNc4/0Q+Xjyvu/h460t+h4x0qP2jd7oT26QVBryoYAS3w9AbZZFyezDYSs+JL0YhEED+X3c8aCQcvcYY4auqwr8h22qE1Fm4XW9QzudgtoJll2Pi7v7YDPH1mzu9w7gMJvNsL+/D4ce0/nMRxw5YLY1R9dZuP0FVtaGKGyG7SxM04KNtzD63gtyF9eNjNeFb3xY7HQywaxpsDXzWVKXiyWWixUO9ju4zgGw2Jq1YNrB2bPHceLEiWpgxsAijj/DHHFlw/6I5J9b877NuMeHHgRgf38P5+/7KKx1OH7qFJpJCxbflfrUyy9Cw0AXD7IhWpN+pco4w/kIFqVtXDsvy6FBJBuWdVbGOr409s1YWediBmQfQilQ8OvTWhutNsPp21LYHVaOnOZCm3GZYCg09q7rskHo70tXzWFml3522OJfV0rGzMwgQxnRlCZebUPoWsVIzc2hlb3DJ41KXqve6KNyyEL9oqZcwdHo5m9JmKF7eUdEWdSYtQ6wgOt7H3JcYokq2n6lrwzO4ncNc2384eXQFZkq+ec9sOotLu/u4dLePq4ueuztrbB0HR668DCcs9jenvpDaSePYf/SFaz29tA7xqKz6PsePeBPMJOBtYxmanCl20NrCG0TEuqxg3MEv/kOGBgY4y/CmTSeoa4WKywXC+wxYz6fw+9nGLTTKdyqQwevQa56h1W3wqpbYrVaraEVGvwlNFZz63l3X47fso20JnxjBg0aOPjNc5cEe9/hypVLuHLpYSz2r2LnxGlMZ1ugpgluKwcin/JjWHxYhQk0K+cVeFBXlIiQUoMZXtNuIqy1tVyOZawclWGvW1fyU+6HaBofeVneBKnb2kSIpIuIFN8Vd1vpGqS6RbWuXENCPB+NcXBwFcePH0fbhhOhY9yqBKYwGsZ9wb7UzC95flTNfEwCl5rEocir8ZsaYYR/MavQIX0cJtjkE4E3j87Io7FKzVyHwOX4kDo53BXgsj2AJBB87ZbIX4WAPDmZakD9k3HkF6zo37M5Kea8LkSSdVFrM/XpK/XWYm+5wN5iiUVnsbJA39vQvgEZf97GLjscLBchQynQW8CyhTETTCYtgM5H4xi/t9D3DqZxaBu/90ANoXEGbP3+Rds04e6BsNlqvDbsuh7L5RLGtCBq4DfaDVbOwjCDLGOx6rFYrnxm3zUHomolO2Kq3A7+T3WwidKr4RoKGjqlefFWn5+X5dXLuHrxQezv7sKQwfaxY6DJ1Gv7QZcUCmDl0tOKpsAgVk1aJ3IwL4yG9WlhaWNDXBzCc4DyFkGBL7fwN2WyoqD5bLxDgVATNKVymuAYDCbzylBACinkHNVKugZLIQE+hG8Tt0hIGnXI95v0u+nGidQdm8jyefm7ZlCaAY3BcRS4HmnJ3COUP9/ECqP0MD4bE6Keofj3adFwEPQ+mZxjB/DwtEWKLioUhHVWwtg4a2Opjamok+Bl7O8f4OHLV3F5bx+LVY+uYzgLmNZgNptgPp/BWovVaom+t+is1/YZDZq28Qe4JMcLAHaMtm3RWwnxDA4i45P6TdoJJq2BsxZG3JtRRvpxW+sgadblfzYw3N459K7xkUyTJoSfYrQwciXBIyKna68TBBZd0MoYDRPBp552SXowGKtVh8uXLmB/9wps12My28H2zg5AjVIFxGQhxDQyopgoXHqBEBSdzEIvosmytTy+rrOxELJ0UWPjHX5b83D408olfxhTXMStqz0nJe85zHWUfRfhCgJfUEgpAKcUZJuUo928FtqcTFrMZ/P4yhQuGBlMBKKwFAZNPwKXUL1u0i4gm8U1BqfMLLnUHPJ7gNsbpxmwSidNzEabbFErEldTbDsxbspaqBXO6sVJZ/WtYpS18SdBWDadCzihnawNBW9SIj2jFneBmLEy8m61gOstiB2Gneop8CGWXLwrhcCoUCvRVAhDD35dsEmnl69cwYMXHsal3X2ADVa9DW4Rwnw+x2y2hcVyhdVq6ZOnBRoy1KCZtlhc3YPte1jrM6Q622Fra4rVykKSKxL5sN2lY2xvzzCdGKwOdgHTwsChaT0zZLmJjymk6XLB3QPANLCug3E+uqcJ5yhg5KazEjtJn45zEOkZmWBIzHpYsjWZNAcQCaM20X/ddx2WiyUuPvQgnOvRtFNMJhNsb+8U+nVoOzz08oViKC1RGo/QNxGB2ME5MXB8lM5RFciEh2DxVM4xlIqjZt7+UT6aeD88xt1BpbUVgzkqlrGup8sofwxjkn0qrxhSwmP4KcL/Yy4URHOJflkx/YnQthMAwHK5jPXNGv/3YWUT867+jcAa/gUmykrKGyhpDsU8kC8W+aXUuJglJwuXtfPvMyWGw6To58l0rjMwWdB5D+IEkORy4hbSvFEEB5w396OZrkxxIl1Rtc5AAxWFpMbhEz77UFTxlTrnwj5wh1V3FWA5rVosOglZDW0aBijchEdAugnLSB4cDXe+YHPNKmGyGEm8xS8+Y89Ye8tY2R4cFpR1Do4Yji2IDBbWgrsVyDC6ZYd9WLRmAjgD2zOmBtiaAfvO4sAyFsQ4NrW49abjeODiPvZXDOsIhBY+NcMKoB6mmWC6tYXFfoO2AYgcjPEZOfu+x3Q6DcyP4ay/84E7L3ytIVhHWHYWU2L4TduS6bkMzfGxnzyPQ8M+QWQTzsAQIVwkEuZSuYMzDVuELaFni84CcBbcH+DgYB8XLlyA6ZbAZA40czRbJ2EmM0zYwnFi5HruDIA2RObKHkEfUoO31ETB4ORbx2AjkYUuwiNzm0CtRBFRShrHNMw3pL8da8/atMo8b8lDeJMyVgsCyIVD+ax8V9apWxMJlliHAZCBjRvyEKYBuyFDPlLuI/FZlYORja/M/4UByWZlE8Z/LcIhoqtmGdSeC7PG0CzVJt94T/XJzcnkY1uuxT1Vur/kcJjX2JT5oWyYwaIRy8QFgdCH0DcC2IU8NQT4k2yHHZ/kqDHqzXbrepDx7pEU2z6cM/2zfB7/HsEDM2NxcBCjNRgMyw6u69FbxnTaYjpt0a9WWC6XmM22sThYYXGwxGrVYzJtcNNNZ7BYLuH6JWxngXkLOH8SmkznfcfWYXvnOA4OmmAR+P5XiwM0OzOcPnsas4nB7u4+HnjgAvq+w3S6Fc5KcBC+XURB0zbY2toGN220LIoJynSVnF0xmBwaFQEUmYlzMcMtiBIpSD0WRYthwVjuXcXDFx/GanGAfrVE363QkAXMDMwObdvg2PHj3ocuDBpCg9oCIcAQWC6RRgj1VoBHBm+SouDvKZdIteGtbUR5EEQZ3UlEg2jewzZ4ifxBR28dJyWUdZvazMGQTku+op9rQVbuOxx9vfPI75uVI+0plCGDZZ+592HE5Ckk5kCiV+rUvi2fRYYOZBZA/l3u28vLOPISI01/V4fHEsmBuLjy10cRcuXSlL6TGZ0RbmGOjrleEl5ysU0YaiBDHLpgATI4RNWIVcZgkJkAsANNFUA11T/l/0kpM4iyOPR8/OsFQUl35alPIoIDY7la+WshjdeUJy3BEWMy8RvMq+XKp7eg1qdZcYy2aTHZnmI2m6A1E2zNWyxWhIPFPibtDPPpDIaXMExoQOjZwVmLSUOYtAaTtglZhR1msxY721uYtAaLRRdg9zHmJmi2zjGa1oAMYdL4vEbWOp+KSRBa4jrcfZ6Eg2jVBMhdFxQuaGPRJbOFG5kouaAwwKexcOywv7uLSx+9DwcH+3ByhamyCpumxWw2x7HtrejGUFOc1ocS+CWtjq1/8VIw+1xJ+hrP2npn5niNK8t6EVrIUFTfbxyjv4FwS+AN2qy1U/tb711uAks55vxdXueoQuWaN5pzCChONIdnZsASpfoj151HJ0t+Rx2hGlmbtps/zxdQfcMLUaOpyg0xYQ/Bg9ZCijfXZCms7Uv+K/JFriFWwlo2+sStwFYOqYVPOeGdxD1V9GEiD1OCLCpXQkdGWRyHl7FFJHDXv/EMxbQNmqb1DL81QONv9gKAruthrcVsNoUxhOl0gknrEzqaltC2BtvGYH/RwhBj2vpU2xDXV+jIHyoy/pY2AtB4HE6nLRpjouvImKRRx5sBGV4okHfZAQbdqkdvHWbrkEJpJXgwRvCp3JqEYRUOdyIQW/Sux2q5xO7Fh3Gwtwd2PYC0n+Sb8weophOJzAo4AKouvghuIRhqCk1ZR/azavuYmhnGNoHojgLgXUgYWgPr6CmtB1mbpXAYCoFNfq/1WXMblWWd8NBpx8fqjpUjnWguEe1fAH5jLfyZ5IPXRLRL6RqkFlBf3DW/XF23Hn43JLpCW0JtMvLQR7E2ssiDQziZCMxs8lEfX1nyOgmfWd9FM6kfD/da94osXsWoq/0H7ZKtS5ZRbM2pb4d9+X8hOie0pau6OIQai6rAgjVaIjLjKa8bFkzbtmjaHtyHZHPks/b2fR/2SxhMBtOZATABsa/j4PMXTanB9rLB1n7jI4ti/LjffZF/bbjoHpIK2vhgDessrO2C2ygk33OeGYshYKJrxVunfe9gHY9pDHq04RtRUIbzWrEVPfxBqMmFOs6usFocYH93D3uXL8P1wY0sB87CJhEzxyzIZuA+DKJBJoV4MI9Zcjj1vJzbMUui3CAe1GdWJBf2GArmqwVDBv2oe0l/l6/no/K6TQRB2X/N0+J/Z0gw/FHhOVLuo/hbdFkEdsOFP00AvQbNfFPTKXQff24iEHIBEmLsax+O4S4aRf4jPoL0HRuTaJR5v35EA227sHhKd48eiMtwZDKLXRpIun8Om2PxaWrhz4HLyoZkmf6XQG4C6/qC46fP0yLKBXLmDkOaz3Wl1Pyyd5RGFd8qZcA5Gy91MeGuZeeAyaQBkRcK/g5fgu0tZtMJJpMJDLXedWEcZq2BmTa4YXIMk/kUdrmC7TsYNmjIgMj34ZxD27aAYVj2Zx2M8Unvum4Fxz1m8ymm0zkODg6A5Qq984yfwSBHINOE61gtJm2LSTv1IxuxJKvYK9DOzAmH8p3wTudPXBs06PsVrl66iIPdXawWB3B2BcB4uepP5Pk9JWJMmGAaHx3ltel0iFErRKVSppl4zfpe5yop60rbZWpq/Z6VcFjnus5wNSKI1rmJZA0f7hVYb6Fs8l0NNl9H//yYCwVpUx0xVxmAcq1z5PMR86lWryb9SlCOanMUoqVgTWXbSgvKP4tP5G4wrtQrNY8mC2/TdWs+Tnmy6XUXXPwsxxqYfLxKU6voFYEbNSt1NWNMy5yi0JLwIp+Kwhq0zgTIy9nhyu/K5UfhK0pfUvYuAxKgwi4r/iYQJLapIQPrLNg52K7H1WWH/ZUFkwOMP1fRGoOJ8fcm9Mb6yCPrj+KtuhbdqsNqtYfd/RUu7B5g1Wzj1JRw06ltPOrG0zh36ma860N3Ay0wJ4OZadAse0wJMM6FK2EdJtTg2M2ncfHKFdzz4AoODtPW4ITx8IqlJvf2ghoY08Awwzng6sE+dhe7OHbyVHBX6THXi5/T4OqzDDThZrkwFTHyy/loGiICoQfzEntXLmHv8hX0q95HMFnflp7KhgEwgVsCWgMYAwuGYUZPDsa6eMVpPmUpBfTYwa5NmGTJGCUgpsz1I2vRGE8PZTnM1SLv0z6VOquzlhuVnEbEMIl9HYRHPbT12ktKrwL8ZVgKpJpn3WE8lrRxU+vKOmEQtcjCZVSAubbU6g+n1A9WazrxcdQ2HRy5RCB6cZZuGso1oZqLhotviUqGrW+ayjeQPEzDsUZzGkEEEgZuB4kA0khIBkuFGUcYAiPhEPjpwsaoaq5ecnzmFRMgg3ketQgqPQietZYqPTt/cG13dxerrvNDMo3/2c68eya4fZqGYJ3D/v6+P5w2meLU2VO4uDqPbtFjjxmX9w2O7S9w683ncPbEDrquw2LFWAFoWxv7d876083TCR68eBl7K38gzTFjYYDJ1gSLg1XYWwDYGFgAM/jNZ8se1/v7B7jrnvtw9sxN4PZwhhkxG0JSfSgqQBJW3eSng73e5y0c261w+fJV9KvOb9A69haUUbHwchCNvVDxLrj8cNa6Ram1ellL69zMw7U11NRrrtbSConrvtLeYVZJzbW8Hsb0bYQn7Oa77F0aTwZr8Wysr1FvRORbo8PKypFuXssREhYcH27eXWvZuN1A38KuhiRxbaVuDiYi07fM6X/yfp1fktW/EmjxT+ZDzxnkxvsQRCCmcC4gZBwNCnIAqsrBa2a4nCglkstVvMAz1KgbtAg16qP4P2E88BuZLP5zji6ew8a0kcZTqeMco+t7XL26h+WqiwfPvCeJ0DtgsVhhsVhh2XVYrFbouw6NIcAYmOkU2ydOYuv4KfTs0044ajCdb+HilSt49C034+TOFNMm4Ckc6vRapffrL6zDwapHzwTL5HMjOYO2bXHi5Am0kzbC7pyLexvOAdYylp3Fvfc/4MNhXcEEGBGXAwahfhf3CVN6o5mQYwfrLBb7B7DLlXddOQfHKvtw/McDV7Fz6yJjSmVmeGNjdPGsWfuH0UH5ftCWYsabuqZqTHcAgwjB8E8f1M7GRxhEFCcXa153XSnrlOt2LQ5GyiNIc5GHp25qmqyTzGNtbNZHUjtjPdF81N+p37E2sp43Ijwxgcu7YNf1JYoWFXBn32cmTF0b0QEAdSCVfRHWrlxkaLWrCOOaRGyb0u+GyNsuxkfWEIVwv5D8qwJGsig5cpD0kqvTlPc/Uqo4r7Tj2GHV99jfP0Af0lb4hBxec1wuV1h1Kzjnr5ckY7A1neL4sW3sLzswEVaO/T0JzqFnh7adYDaf46MPPoCnPvHxePDB+7F3sMTBSlIre+Y+aQ0cAfvLFToHQOWNMmRwbHsLs/kMu1eB1apDb50/MR1vbfMT2XUO9z9wAbu7e7DTPlvBa7EkzCj8OZYh2AV6stZisbcfz6LUzb+hS1ALMlOhgzLwxIM2ZGJjmvG6/cZyTfiHY996CrnW4Jda/3nbGdS1D9M7Topg2eZRrOWj8uKxcnShcJj7bINSEwzA+gkfNoIi8i73nx2tf6A+sHEhpQWCcy472Kd9o7UNr/yvOtykrIdNJln4e2Z6ZsNKWvpQu8kFV037SECFvxtKjJyCJq1OI9cAJHHpiCas+0BI/0uUCfKjuI0OK85ZdN0Kq66Ds0DPLiUoYMZidxdb8xm25xNM2xbz+RzHThzHmeNz3PfgRTxweQ8PXNrFfQ9dARiYTQymE5+P6L77H8TZG8/h9IkTuHhlgauLAxCZyA7atkXPjIP9Azg2cG4VlBZGY4Abz5zEcrHC/NRxn3a767HqOjz48B466/fxmIBlZ3H+gYt4+OGHsdxZZitYorfWKYSCW1+PAXb+sBzS+rPWoluusNg/yBQdEbSs5jijFfbhtX3fDc4BjYEkDFysBWlTb7zWtPVaVFL1/Ri/WsNAD3MhhUrQDH20WqxbwAwM9iEprNNybJtGI41ZBXW32ni5NktBIXpjc35dc4dIuNHWB+rgtUosxYE3KGUu+5Lx54f8ZMGkpAv5ONdHEMSN10SD0IPOEoYdQpwD0jKsREWCrWaOAgg5oZTG6Qhy6S4FmOX2rYF4jVIuQRIJPgiVMPi0iOSLjwF9MbPPjLq/hwceuoCOLQ4WC/TOX0nUrXqcnRucOr4FhKR+E2NBqwW2JzOc2plh92CJh69cxcmdORwaPPG2G7Aza3H+ow/i8tUVOsvYOXkS84evApcPoivF4xpwPdAtGGbLzyk3PbZmDc6dPobTx+bYI3/v88HBApeX+2hch8lkgs71wSUEWMdwvcPDFx5Ee24B7AzxfCgjYZ/uw4BDYjvECbPOYdV12N/fB1Z9PpekFA2FW5kfx17o9n2fMUI5Ea2/kaJdRwJ/OXdjc6rHLM/02suCJsqiNXUSx+b6Pgd43cwbM14G3ydrfUzoZZ8f4l4r33/M3Uc+7cDQB8cUQudq2m78T6gLrxmRo6xSDIwMvs6oyYR2fXoRiownfSOtasGiB59PNlENSg2dd66YyJTkWWCGGcya3soTzkMCI2oD7oB0WRGgt3U0c8+Zs/ik/eUZTXDdOUhiL8+Iy7idFCXWwIUka7qYoKkWKxZGpalIbJzSxR0UTsRS43FlGri2QcOMvuV46CkvDqROvqaxKk0GBk1htXhJKOOATHCyODjgmCQdNeJiC6/9pUHkT0k3pkEzm6I9aDFvZ9g7WKJbdTCTFlvHtjE7tgW2PVaLJS7v7+PSfoeDg12cOH0Dzp05i84Szj98GafOnYLhHg8/dBUPXbiMtgHu+dBd4P0VWteA0KBpDLq+h2PC/oHFygFuNsUcQOP8eKeuATrgwQvncebMTTj/4MO4snuA5cph2QF9twRIbu4kmKbBAfdYWsT5SCXlQ0rWr1ZggmIS7v5mMBw5WPhrSMlZn49quY/+YBcrko1yyZqT2ktLkeAs+xTg7KfAWQd2FuBwYJEZzjpvKbbtQPNP5zuQuWL1iWU/prQm9El1KaViJQ46jv9JxEFB0w9X9wQ6kYaQiFDoK/heBxbQiHAqS65o+YYlw2q6IyLxkXJ8NSa/zhV/1L0JXTY/vCYTV5r3mV9YAV0FggF1piEapSwEqpoK1eMf2UQNTcjYg9aYGbDsIBuk0tA4gpIoSk8qdTnyzMzUlb81bPK+IRMEKMAqNbCeeC1wh9aENgP9UwOfmiEyQSQEMitBTel3ra+7AhdVbU0xWC2Gk0eJvJvE+HsCiAxAI6F1FS0of5ULiWoTrH6RoVNOU5lZrmjFWQfbW/T9PqYTi+2tGU6fmnvt2wA7kwm2Jy24JUzIWz27iw4PLle42hNMO0PTGNxy4zlMj81xYso4d2oHt9x8Az5yz0fwuj9/K86d9PsPjQGaEK9ve4fVaoWOGdOWcfb4Ds4cP47p1AvrznVYWoePfPQ89nb30fX+cp6WAGcIsDYMzCdlW67gz1JwHlY9NAfTfMbHkcFxOHCGgMfARJ2D6y26VRdujEPWqFdo8mtzCcG4Avy1pb2FE5eX0qsYGNC3MWZwI+CmTOwwq4IDE5HxC4sSNHGqFOgu3leaaF0pmPr+j01LfU9A5U3SmjPn9WqCoVYOE0JSp3ZbX60cQShENCKNKAdAgzY2paz8cHFSAlFKymqxSIhEYOTMeVMzKJBlxUwbllLLSO6Owz/eZDNoYLFsMMGZxSOMXhERVeCOMChclsZAhKOAOf9Z+DbDfwY8h0RgiJIgeBsvoxtpRrbAy3fq5DQlwRBThoT/ylPJh1nTSH34sENDwPbWBLPp1GunBKB3PnLINJi2LQCDld3DnjXoDpZoGofJZIL51hQtWezMJjhxbAdkZjj/0fO46577we4GmKZBQ4xpY9A1bcij5ANdp43B6RNbuPncSQAOB4sFruwvcLBi7F69CtgQYx+iuRxadM6FSFJvLbNz6G0Pdrn1V57UqCBe4U2ihgg6DMZZC9t38bYwXz+15k85E8quKGDe2j4c/vO45rbJmXAGTqK3sUi+UvOt7TWMrSUnHoxCQUMcFSKPqbUxxmwPtwQ218q1+5YrWDoMrjHrRD+v7cOsK5u7j7IGlQqvBIQGf8BQPKRxzDXfXCmdxTJheA1GE1FJEGMTlTPN1Jm2HEaLCCTK62WK9AhBZX0LqhBcYUqX9Qng8nEQpRQaQz8mxzQNtZKNlySFeU5E0U23fvTDcRElK0oYCQfcO+vTRRRzua7ojcXIBNR7PX4RVP5HIfAy/HhWAMpPrTInzbVt51gtViBLIOc3uNu2Qe9WaA35e5OnDSbtHA6Aa2ZwfWDG3QpXVwc4wTPQ9nG4bonlaoWuW8IRYX/VYzZltORgJi16a7C/v/KMD4QpCMfmW5hNWly+dAmXL1/F1YMFFpbAPaMxPvFdE5jkxAShIIwjHLRjx4qKFMIL0hAciUBPc0qKkL3fn53Daumv+3ROCQXdNgMMB51mNM2Pj1qytgc7C+scpgUx6I3lkrmVyQvLv0WwH6bxruMTEQaFH32eRRTSgdUhDrRDXDjlu8P8/rU2I4y8WXTU2Dh1W0cpR7tkJ/xCUXOFl7LyWvedbuBDVCXGCtVNS45WBOLfpUQ+1IWk29X/JQrEbQ79huMJL+kTxd9F8q1yYgYLVeEjuHkoMIG+7+OCGJvopkn4kUgnWTCxvgc8WRdHootxS4YU6L4LB7YAO/KO75B5tLz1i8gUG/Blu4r5DzREJRAGgryig4ovo9h0FL2Xe4BcgwsP7/q7FJxD13XYOTHFsa0Jjs23sDPfxs7OMXRdj73lRSzDvEymLU6dOQ2Cw97eAS5dvIr9/RUWB3vY2Z7BwKABYTJp0cynWNoFuDGA8yd/JzA42D/ARRAWC4vFkrB/1aJDh/n2FubT1p+LQEjaZxk729s+fJYZYIepIZy78RxobtFhf5MJVfoo/D0b6WouhOuWwdZhcbDAwcFBoMNokqUkfVr6iAKgFA29PwChycZHWKW1M4yw0ZaC3lfI2i+shfJ5Nt6K9VtljuTPk6yLXZQ9hTHmWuMbGk5Bl6+s/1hfDmP21X4wXF+jfGmkXFtIKqtUF1pry6skZi8ExCl76mGDTG3lTEAj4KgSMEJHDKIGhiboOp+2WAjxMMSVdZx2c/EGfruyeROYICTNgCKEcOXiwOoKbsYyjA9AFg4bv3P5Zt46QTbu2hJVU7HlyMThcQqAR+5lJ0ptO4Q9lhrxHraIBwjkgBDZ5JG/ES3T2BYzmobQNPtoph0M9eh6C2sY0/kWLh0wLl/Zw9ZkH8e2dnH65BJnz53F1rEGe7sLLA46sGNstxMcrK6it4zOAb0hzLd2MDUEt9pHZwGaNFg1PVZ9D9nMZ2Kg6XB1/2E07QLcNNg61qKZn8X+7sNowGgbn1do2fXY3V9iwgxHS8AYsDEw9P9j7s+aZEmyBD3sO6pq5u4R9+ZSmdXVyywY8IEQEgIKIcJ3/AH+aeKNBGcAGXBAYLqne7qnqrsqqzLzLhHhbqaqhw9HVU3N3DyWWzUk9cqN8DA3M92Onn2Br+7vN6qi9Rq+6VwUxksQ4hxN4pkjPgl5N2L6+jwucG8BbillevW7ZiWL4vxaQq+ESndKi9Y5vFYyuCURbK/dfMeLd7xubZ+7p/Bpr+use99rkXkvBS6M69tx5Bsqr+0bWbRpc6sEIQX5749HRDo930I+K5Kp9/Q9rycnBXly5eK/qGt6gbD7XkvhliwWnel6XX8hX1pHU3ZP6hi6OWtuYepi3ZVsljUPTEcIwbJJFqTY1C3UIDJZAUrNJ7UQ0kW8bRJGm+ZmXCih1v9VFjzpr/XrC4el7e0Lwpf2Psr+OnH2d59tw9XHFK8zWTIqI7i0uJhejbBye7WO8+KG51yFJVv/ul7L/qybPWelIde3OATFaYJssRNW9tGhCG4YkZi5H0YOKTLN5kL5F3/+juC+YhwCYwiEIRBc5ng48d37r3E+gDgu04Xf/z7yxIQX4eCEr4fA49OFh1mZk3BWIUiGmIpKzTVw8u5AygFxjjDAOMJ9+Jp5jkwxm/1hTuQU+RQdXjLDAIMIB+/59ttv+fbbX/Aw/oF5u8I3EJLhiEK4XXfexKJrM+aFpGRUEtmnJkXXs1o1A724uGbQqmuypQqBTJKMzxlzRigeN0ASXTmoiQjBebKkFabp8xfVvrz3KybnJZXOripmpXJc2+peWs+X+tv9u6EZRZwzCbuTHm7RmuVZaVTFcNT+WBZCWM+fa1v2Wl7hTZLCVjqoV7ffLwhu7yW6+qKpN8r9lftdNn07E22vqaqXq9bjeVnfodB00Jp1wfl7fTVbwua6LvtUf7VeCoVekTW1u5Z1WxPD2n3PFfQb2Oh//e4GUVghc7n+ftt6sdjmIxbRWghBdQXeGsC2hkapT5TJ7O1aJwSUfEv1joUiilutWvt1dQiN/cd7jybz3W/z5novmopOqluqEY3DEDiOgTQahztK5HQ4cTweGcYBsKyfd8cT796943A6IeL4x9/9k3G/MaEpEQTeffUO5wc+Pf2ElWlWYo7FE8cqhTkRBu9JSTk/TfjBEWpthsMdIsJlfiKnZLmSMA48eMc4OA6D5zQOfPfdNxzGkacbHPSi+ixEtvfU2uzNApGW1yjnUnS1Q9q5PtSphQw01p53ZgMsHmSLsq7nY5Y9LR+r22iFqa16+LUqlOe+30PiDebbTVTBcvXclpn6Y1phdWilBnr61MB9J26J5XtbXF3O57YPWTwV63CXV71O4nhTQrxbksjrulrac4traYVD82B4zUZc6/AXoGWzqcLi5bSckgWNiRQPj4L1t90veF371W5AVtVJDdnXA9OfSll07pVGbtdw12BUx3fjnq1abY9j6q/v5a93qp3+uhzUymE2JNMd3PKzvUGyGUGv1m0xJMv6FZ3q6hmOaZkEYLmXgnNErUV+C3ppJ6w/aZVs27p7yXgigxsZhhHvHZozH3/+yd4dPD5YdtIhDBwOR453d5xOJ0As4jhFYinEI8Fz/9V7wv03/OHjmenxjCZLfx1TJudkEkUI3B0Dj9MZTcqIlfDU5HDv3rU9Uk2IZEJwjCIMg2ccPIfBc3c88Be/+gWhFN9ZNne9x3apqHa6fWuMQH+YC4aJcyTHWHJSsbqnvgso9ojr/W0SsJMWS7PevGWcopTqepRnXBvjnkpz28/WJvEWPLFeIxvf3vm7RUz23vmaJjt7tPq+Sut1HQsnlbv9qgRDC45ycttO96VE7E2Swu4CbNiOlSfIKyj39p0WJh9v97d01d5/ZQuoiHazKE4TgisZpNVE2rLgWqUCrZzubcTaUE7lpOtGLTcVDrugp4KolLUe/9ba3Dby3r7ev3evpvQe11XTM/deHs65ou8vC4kCHlEpCoGKVOp7632bvm6N8ca8r+fWExZD5maNKKualel8MeJdvjMivIOwwLgrsbI3cZ4YnDdPIzI+K8EL8vU3zHFmniYE4XA4mFrDW5CelCI896d3fP3V19zdveMyXUgpMtzd8S/+8l+CjPzHv/sHfvzpZ959/RWfPj4iT4nvv3nP19+8J7jM5Xdnvv36a+7e3eG9I8eE90KME0JmCJ4hBE4Cl8sTkiMkj4SR+9M7/nf/xV/xZ3/2Sz7LcTXXtiuq62PZpL/K+qulDa9FWFRBzfMop4zLdn+qa1fUkc1YX3mqq+AxK1bkXcA5C6RTyYvkqNU/31Qo/SCrgbn+r7axrTRir3nesLq9b9cgLfXHAi+9hH3Ldrk9Q7294zmDd+1zJSRv7+lUXPWsLETrZU+mtVSzvx6vaX98Oc5Vr/ZLlKaO/NK2VqW8jeJZtshFtdTULSjmKiMFaVeDZPlfAnNyAZjK4+81ZYkg1m6M0v18Veulmj9R2wLInhF5S0h6bydXZGmRtQzTLDBqnHkDXLVkc6qC4HHkK++jfhzbcS4HdvNMB0hL4NBWSqGoO6qFRtZSGRVZWsqJaZr58PmB0ziY22WxY6Q5owwIwjxHYkxcLhdOpxPixBwS5AnvA8MwEMLIp08/8/npEfHC3Vffcnz3nv/m//R/5u70Ff/u3/07fvvbH3icZr7//ht+9ctfcDwOPDx85Dg6RJQ0z4iGxiUPw8D79/eICPM08/HDJw6nkcMQ8M5zOt3xV7/6c07jgdGZp9N6nnkXG6SyBspSAcWQdn3OEHy8TFZmFbDQxoG9HP+5xEds99OpmitqiqVQk/bl9KyvAjA9Tq6bWestvMaYW+/bIv3Xeuu0Pq95iFc355ylIZm3lp0b/RZRWN/YY2NC67zLBdlmyV0RytdLUNv2ekPzbgdmdVxomh3il4bxGgS4QrRNvSNNOqiHvzDrawDrOJpV2JguXEtvjShZYLqeF0OcZi00ZIfDr8TjVfi8SguVoNSrtciOdFf7xyoAXyPUNRLd+7yVTJbre7rShUAswXLbsYgWl0GTuew551A3IEEQnwu3O6werZGrVQpzlQj0iKBjQ43gmHE2pdS2v0pzC1bJZWkWomEcX4HFyhynzNPnz/zhhx+4RMU5xUfziAnBo1EJwZNSXHlwffr0iWEc+Pqbrzk4b8FrdwfGMfD+3XuOd3fI6E0KyQmvge+/+45/9s//OX//63/iL/7iz/nzX33PIQB55ngY+MV33zD4sRAcR5xnLtPE/f0dMU1czhdSjHzzi/e8P7wjpUgYAt9/9z3/9X/9f+BXf/aXhINHpvX2oFKMmJRg0yVR45LaAkgZJbXUNZKVeU7Fa0ihpFhX18Uq9EhXihWp46YFIaJV9uhPXYOdsrHdRYMzBxACYZqJXLeec78lSW9VTEu311JFIyZ0oPRCq5LOakxZjZDK9RnafceutLJmKPefX87joobNRULeI6K29/bcQjD/M0U0r8a5c1Mn8tB/2G8LsjaxbXfIWnxJmogldYfa8xWBC9ffrcXDru+OQ0G15GNa+HxpG9Xp8Csik8KRKohoE0Vc2aQtAakGP2mDWJMgpL5C+6ttfD0uXLX2nbE8VT1VLzXmW7ZBcFUiKG641HE30m4jrDS4sCb1c09k6nOCMoiDwSFknF/vZgiBgVIrQMzTJKXUUjUvUopvnFSvPtKS5JrO68tuqmOw5DuWsrneUXMhKTlFHqczPz894JxHVYhzIoUBBo8EU1EdxxHGEREzZIsqP/7hD02SMWNx4JtvvsaHJy5TRJ2SpsiHH3+G7Hh6snxFx7sDv/z+W46HgKaZWOoqjMOIUILTQuAwDhwOI5fLhZRKANs4cjiMhKA4F/j661/w53/+V/zZn/0Vx8M9eR38zbLpdX/XSMqk5JWfaD12qCZinMg5mnqwAZwum9CpTes1o+NLygYJrpCFiozAZUGDccmFzzV4K2dn4eMUdW4551dTWxOGLRLur61sZM8gwo4HWV/bUwPRx2rUe5XUzlj3fBvz9sy+ICNIY0dX/YKu+y5ndk9Vav0u69/OLQVXvaK9KfdRbyy8Xrjr1X2TRkQ7JN8wWn2za8i23/imo27SYAWUeq0fo4nPZkheCxYFby5/6xq52jmpu6+FI+v67eYpFOLQU2iRkqemINdurXrAkR5oeu6m/bmeT8PaK6FBW3EX2gGnELI1UDpd+Gu3LFpDKSvi5mQxDiqWIq1x67ZmTiCMAdW8Kj8K4IsDQdXDDuORGGPJvb8gq0zNrAaoFE7X44io5lbAZTUPcUUdYhKAGUoTiHFTmhIxzTzOFz7HM76oTuYYifNMHgfC4JEMh2EgDIPZEZxjmic+fPpMCJ/MpTVlwmHkq/fvQAL+6cw0TaRL5NP0kXmaeLzMfHr8zOk0cjwOLbo3ZSNalUmIMeK9ZxgODIPncnkieE8ouYC882QuDMM933zzLd99/+fc3X+DSMDyS60Bbw0ie5xrzxQYkVAU0UhKs3kflX014WtNFExSVHJhEhY1TGGK8DixUp81ZYnUWpNu3XV3fMAJmrLxe06uis+0KT6jDnmLmkRWZ+aGRMN67W6qYzaIv19u7X729++Np1efXvezL7mv8GUbZz/+5dpbcPEX2RQqatvStcZhrjj1P0HrYb/jGG4ZhOp+V+ThnGOzxlcEtlLV0sma6HRj2MhCXO3yRoxVVVLHoW0NVfUNW35mXSuChchWWtBdk+5+2Q6vro/2aqqyPpI7YpCXb0VYavWCONDqaqjm+dOTkEXSyNwdD6gqQx6uFrlXQYwinE4nVJfI1Zwtl2sIAyGYrj3GyDzPOMmmZrlMXC6XlUjsvSeEYFHJ9/dczhfmOZtqKoPiOJ9nnp7OXKap9RXjhCcxeHByWmoLo+bLHzzBHfjFMOK85/HxkZ9+/pn3X3/F97/8Fae7O5wPPDw88HSZCCFwmc58/PjApw8POJSffvyRb75+bwTTO1AzogqmFnt8fOTx8RHv7e937961CGvnHIM/8PVX3/L997/ku+9+wXAYjTvdbW8/dcY7mNOBFMRf+Ym1ZKnd/l3vKxgnPQyBMA5N752xEq23xluzZayJ1/U8XtKP72VN7cf21raH/Os4Vve9tj/ZygD9V9IY4XY+V3jCBrBrMN9pt7LHvtZu+SabwtW1m3frs9/uvn+3n8qzXhfgfu5zrRsssrh+epEbKYOM87fn+j6WEcAaST+3yKvR9/rLnXsXgqYtJGJ71+717prbPNHub8BT3WO3L2le7FfNb8eq5b0KFubUzbXopc34DB8/fkTJnP3ZCgx3c13LZjQDXSUMJoUGYkyGpIpUMY4jQ/BwUk4pEqeliEuVNFQV7z3jOJJiZI623w4lJWUq5TWnOaJqQX6nwz2Dt/um6YwfRpJmYk5M0WoZjOPIMAxQ1Ek+BB4fH/nh97/l3ftvORxO3N3dkRF++vkj9ykRwpFvvvkFOf8Vnsjj42Px9BKOY+DhKRHPT6hSJIUAotwdT3gRxnHkdDgQY+Tdu3f8t//t/4Vf/fk/4+7+va1VPRcbdYCIXiGQW02KcbsyFKnUgW4MdP/oKpPvck6uwESVEAaGMGIOAtI9xBVwSweS9axaoSVa8aOtZ1zvlXQ1pxtM4vbzn7Zptx77OG/L3z3zKtYq4Ne5xW7bS2nFX2qvVx9txKot8uv+2rl23a4HuRZJ2/fPiJL7/dtDjjUg5mfe1Y+7v+kWQn9uget325TYt55r+m+hpbm4uq/Oo+PeKpJfKr517y+HULT6p5e5tJcV4b1g+gXQrKMabXxzPL20lHU5+y2T7rp2gs3dagxU+0bts+a8WbJyFq6zUPCYZo7u1FR6gw+E0TGnSM4QfCizWg7Tu/fvuXt3z5xn8pTwDxeGjx8AizFIKeKyJxyOBG9e/NMcS32Jsi/Fs+TDhw84cZxOdwzDYGpAbxLMh58/IO4TIQTu33/N/f099+/uiHPi6Wni48cPDGG0+gyl3nOaZiRWZsFGnlXxKlyezsze4X0gBM9hPPDP/upf8IvvfsXx7t5y9OSqOrs2KphaRNbcDQVmKrHor0FRyeVVVtS6nrYPhQTVrakAxQ7HmpVxGDiMA2guHkjF8H1DT88GyRlsuNZ3TXOxdwb3jMj7TOLWpvZ8u0VMdpH0lVL2ur0aHVfJfKtNaMf6tpTwmvn9ySWFNjDpkBJW4rB+eSVaPTPIJcnibbGqv/EWp109g9a6QNAui2Plhho8700MC8Gv6QiaBeCGjvEmV6A7hG3z/QqQW0EaobC2tDN8vQyr99DNXc1y1727SCCY1GCLsl6AZiRcXe5Uf4JJE20NlrVavrc/hVJyMsUX02dXIgALUWtr1wa0Pswpp4bvXEmup2oIo9kvREpqbIOq5CHgOZ+tktjj02MjHnOceXxSjqOltBCElKHq2YmRyzTjgxAk8PT4yJMIKScSiXE84ocTzpnt4ekycziY+2pKyuUycT4/ctHMPE3EQhTiPJkx3FWXYKxWSYcIhUQCLnohqiCu1qkQs+2YXmZnXV1DUlfccgGxJgvUy9kIwzzPNA8wbX59K1iqqqVm9N/sqaIcDyOncSz39u6XPdxdCw5VKuwZnL7E7VZtvIWbq7FszuC1aul5l/cro7VydX+d83MY7CVEvNI63MA12v/c6MG3r29qqBuS1GvaG7Kk9omGFC15hCriXHGpZcD13uvRVTwoLVp2kVkXd9DWdUVeBbdR+qzIyB7vxbjSqy7v7F62NznjqoXFw+jKvnAdpHINfLoqfKLdWlQu2J7p+85NArBc+R1irwBT1qMDmfXoRdY1Bjopy95b5iPbPSlHv0y5AXeH7EvX5Xq3D+X7KxmtzW/7zYrVLBxg7yHRz1vbtjlxhevEgq4UxHuKU6TBkHN470i5pHQue+jU/PLP08Rvf/yRnz5+wrkBkZk5Jh4fL2jKyMkxjsEqb8kSsZxy5uBGRJIVyYnJYhjSzOF0xzBOJgE54el85nS8L9HgQsqZOF+Ik9k/jCCUCOhi6HYNYUVEQps6RZ0W48zTwwM5RSwnUZEO9rkbjKG5rTpaoFppnkia0ZTIcV7tz2rPVoSi38s1LDtxhGHAj4PBXXUK0J33tnPWja/BwIJ8r8prdvfuEYM6Ojp8seD1/gTtM7C93au/3j+z0u2/gGe3TOC69cx0OXS3JIHVZ9nMZudeqbvdL8DzkkRtr1cfzRPO1duFGgAmJY/MqgiPPbEZZkWexajaIdPG7Rbk23BQwTyqkFsJz0oViqWh66ZjdmmgpZUCrfme5aGKUCuR0YaAVSq33ROVcjiqaqa+Q8CCt3LbkIVguA6Bbo3z2v2sY1+8pKDL+1epXQEioXo6XeOJKtQat1bHVO5pMXtSxlUjsq1D5228PTdWl1oxQp5XV62/p/MTwzCgHYFu43EUpK5FPVUjagsCdw7nah0Ju79yjMYZlxXKStJUGBJ7X8L08OeHB9BSklIhRGG+JH7744/89W9+wz/99JGv7r9i8EqOcHnKPKnifGYYPUcfwXsul0iMGXEYIdCJOCemS+J8TpAs2+p0eSzGericPfFw5umcIDj84NFsEckA0zwxz5kUA3enEU0XxiHgXM05VO0qJU7ECd4Jn//wA3F+IvO1ZUpNtn7Sld5ctqKuSgXV9Sb0yNlVpJcTcTqjaV7KV5b7+5oKdtVyRGnzEOs5Z8G5E3kYiN7jFcakpdRntsC2ImlI/0qpHHeHCxpPtM/J70oGq0O1MHaNQKwZcdp574ho7/Rw1Y8ubqErJH9N21bP7hOEhcHsmc2FOd72sRj/fUtr0fF4m7FmETPppGU3t4z2c+1N3kcGtLYK1U+frtjHi+JJwXrKesP3bBILx7Dcd6WeYnc/lvfJvmC3JVe3DMaV+7eW2kfT5y/PWLbmjkvZciEU5FoHvOpPFyZhmUA3iu1H7VigheGjU32J+IVF0mKY3LEP3FLvWbBYoWJ+Pc9brs4iUvLxCCI1zUE//KXvYRhBzCVTMP19Xe8c1Thn5xiHA94LgkepydrsgKQUzT3WKylnPjydiyeSwUzOmWm+8PHjA//63/7P/OHnD8SYmOcL45D4+pt3pLsTT4+PfPzwiU8fP/HLv/iOy9PFEtCd7gghkFRx84QbBL0z1dDDUyTPM+c047wwBMfTY+TTxwsxqkkZ5CIRKKfjEbJyfpz48ecL4uCre+H+7sQ4epwzQnA+P5KSefCM40AOwg9/+JlPj0/cp8QRFuTJH+fhV89djJFzkWZgUbNs9eoVoRdS0oC156il0x5UmMA5U2ttYG/xliuSeJ2XSHPp3lPXrGDqCh9cE4vtXNq9vRTezfMl3fweDvrStjf+7Z5K++7562sVW0lHs1FJvba90SW1c1cDIxDSRZL2gFQCdRaXx0q5rwdpCCVwOBz49OnTqrZB26QqTdgDVfC6Cijp39l0mh0A7gKWsdQbZM1K7KpGvDXf3P/S5su/0qT2m1VvX80nN26pG1T5vSF7HQGtkoNqahKGc3XIuhBtrUTEgtVEugNRJbF+TNvPvS52JxBovZ63CP0idVgqZMW7YMbkcm/1NqLtkZLyjNOBmCrSqoxB0SurItmkoMK/NiZFNSFeucTIDz9+4PE8kVBimlCFw2Eg3J04nkbGzyPn84Xf/OEnzk8zZGEcPPf3A6fTkZM3opVVSVE5n88WFSyQVNFsnkXv3r0j+ANZE0ljUV1FVOFpupBy5O6dcHc6cDqMHMbR3FRRLudISkoIrqjVFFGPOKP8Fgdi806aVmqWW63Xw68KMDVwqpXSlkJNe2qTFRetC+pSi1axdBuAeIMBq/3dHm4UYOHVFs6+YYZ23inS0nXKi2dtlB1e2SL2Xvqpv22o17jgmjGj4ZxSEXWFoQ0Bl88745R+ktsxbxjda3f3Zez9bl9bdLZzWNayagLe0t7kfbRGoJYOuFvF1b1OpYEORS1Ug6ryxm9fRFogUzVC9gjci+sgqnCsch1hWI1V24Iy/bi211oel5Vap0fK2nZ26a7aPUrqgCrxqqBLXmvalqpb4fcrGNH2g3LKyue6q9pFhNaxaIdAy9XK5Uk/Blqw3kLN6/BSIRblgnb1d7tTJMgqrXU//pZHUNZE90r4EtCszctFcGVcLcqhVG0DajS0mi4+ZTsGixdKTxxsjb2U+Am3qPvSlPnp4yceLjOxKNRSVnL0iHc4B2Fw3N1bkNk4TVwGy3s0xcjPP5/58Gnm3eAYhwHnPaoQkxWmDyHgvcN5saA5VXxweIGgNt6YYLpM5jX1LiABxmHECwx+aEXrlZkw+IKgq2eSIethCARvxnAt3ltcGU47kFtdkyvuv4JYSol5nldxH32rhKDXs1ssyXpfs2hRa5jnmmabQybhCG1/K8JfxlJww2q8rhjW401Ofw/pLzbN8qNjImV5cIXst0i8GXs7Ysrmnn4M9Xj3CWHRa43Gc23VzxXB6eYpfVaElySaokSUepZ1Yahf0V5NFJonQMUA1DVeL3LjkHWRDaAOrHDRG+pf/Y9zzpYfpwNeAKcdl1OR0CtmeNMQdfXwMvJrfWExBEs3G63rUOsYdrCIA3FLmoyFFeJq15WyeeVz3egsC3dVfzaa2DD8avRXc4clS2zzBtKulkE3lgY7ejXEhoTbF0I3ZFZnsd4vdrhXY9welJwLcW8kofXS2AlzjaGPp+i9PZq9QSw9tB0Yk1DNUBv56eefeZxMShBXCEM0fXzWjHPKMHocjsPgmI/KJSYezhNxhkvKfJojQ9CWu2meI04cR7F0Hq5IbJY3acZ7mkpIcyanjHceP3jcCMNwQGO02ZQkjAIN9ivC3HruKAaHC0e7B8cbONhw/vWdpoJLq6zE/TN7/5ceOyBZsk2uEfMOkdlrjbmQZU/7bKl7AWm771hEE1Slw/83iEf9ZoMsF/vmeoCNWVqeXM5t97xN/XV5hnbV1nsEpfGGCyP4KlWXdvsNr0OavIEopJSKvjYAUnzYtWF/6UdfOIayWwuQZyGX9MfdFi6OTarkqkboqHfPARuOKoin3w5ZAN0Vf24Kd7+m+gWprKjwMnLdQMOCWKvLKqi65ppbZEtWwOe2q1GC6Xp60NRA2ghC5Zr2j/yyvQ2JVqS43GLjdfWO2s/istkKDKlakER9fEUo+gOwGgKLLlva2Murm0eZ47pGs5MlzXAIAWKXA4eKDEonuQYfgjh7Xy6cvkkZZQSurpUWI2kmZ0Gz2RzmeOF3P/zA4/lCFKtcBpCTI0dFXMQ5JQSrynYYBpI6LkkZxhHnAg+XyPnzhSknNFutgfMlMQRIsUgeeJSZQQU9P5q04B3OKdM8WcEcZwQlF0Yi50zKuaXkTjGTxSS1un2iBqMxzpaeu0pILyCDtl09Ql/Av/1diQIdjPfPVkZuheSr+qgV0zGIVNQIpLNI9MrZakW6jcmpcGYQ1EvoijYX417q387pVlsM1vZ33uQG6peh4ps6Rqlrw/qZVXW4ZQmXd66O/vrZbVsx0DuqqzUlWnBXx4ev+77x7hXx0gUOXtve4H1k3JHIXHRaCgx48aimwtXZvByJ5EpyrM0snOZVSgcnAiU9r6sLs+FU+zVHisfTwpraV636FuRNtt9GueuB6r6zQ+b6JA9rfLjAsBWnLxdrdHTT3ZWbEgoaTQyufSAFUa83RkSKB5Vxhb0YqbcQM4CrnhALRyOAr5BT5l+zYC5G8k0Mc1o4ezodZK0MtRWfperteg6sqDN8MSaScvOIumqlnxACMZsLpIqgYsGGiqlzFvVfoTQilsaooZBKsAEJILRaD4KQxVKLnC8X/se/+RueIng/4KPlQNL7Iz/9+JHT3cjdaWQcB3xwqDOiOsSZO5/xTvk6C+ndO3K2iN+Yhc8PEx/+8MRvpkh8mLk7eH5xf+T9/UB8eOJphvMMeb7w7m5gdILECXeBYcicP18AOAwjwziaPc3PqHhzPy2c6hAGcp55fPpMTHPLoUUjsPuc5p6RtkP3QEnzMc/kOS6Ewh6w/6XQjpR7NWdojN4EpTxrfc6rEE53pibLICGjBweEpTyrC43GZHWISmMkrG8pjhMGI1NJSVI54j27yC3jc7ND5joXXUfq58qUdci+Er2tSmvz7mav3NxXiU5ldiq/uNWM9GPsuf51spval1+YQd+551Zku0OFeoHfmClX1v0WQlm3VxOFDz//yGE8MhwODMOAD5ZrPepckJhDxeFUzfNCN1xs4firULwnJu1R0n4RGzXvNlwL5N7S4+0Zzq50hZUbKQRn+bLDf5vXN0DpdH6bnheE3ekqt2PrX73y5Lhx6Fdz6d65YQZXAAzsHqhb7fU8xbq1PZONiyCWv99lt+TTb6JFnYodeldyAKmC94HGadwC6I6JCAIpRoLA0zTx699/4MeffkblSNZkXLqHNE+cvrlnGBw5Jx4fIkrieDwyz3Ozezg3EEYhO7hccimG4zgcB959m3EXYZozMSU+/nTm84dzXYnGQaaoMDqcaOELPPNsaTou04x7fMI7MYN3CMzRbG5OTIsYdL6C3UWN8Lo9WXORBos5JVK0RH3ijC/bUxk1ewRLfjx1WN2Fcu6888yqfP3tLwjjgYQlQLQEwhnUlz3KbFPWbFtVoaWu0NYtpPrSvOs8bzalGY97eaTv87bK+fm2SGe38VzfT841D9nrEPdV20gslbbXfqzf173q9ZJCPDNrJM1PXHwgDCNjGPDHg3GkYoohE/xdy6ZZB1gZ0iai1ffuIOvburKCSLqvqrj3nGjWddZpS26llOj8kct4y0vLHq/vz+WZHrGLW5utK9dbCYijbFA13t6Eg8VjqXtb4+C073sjAW3ba41f1Xvh1nO9+qYbEVo4sdv9mHoh+MA4jjzODx0HZj+89+Qu3UIuXj3QyzgGXzaWjitTRb3DDQPT5cLvfvzAv/3rv+MxZaJPDOJbmU1GM9hWtQeYt8vj09OirhAhxUyaEposcjoMgZgT+MR49BwGYY7CJSrKiZgz5/NEjkUddQjcHwdC0LJPgpPA6XgoOZhMus5ZeZomkgZyFnKGlCOP08z78cDT+UxMqfNuo3C0L+9lTcbYxQMWBq0YjXNq2OLKfrC5bpK+MheJqtZvwA2Mh5Hj/XvC4Qjeo1jfoTCzWpwwngfDwmcXYlMdC7ZIdM/QvHpx912vgrqyMbJNxrLuY3v9pdYTkC0Pvydt1N+9LWalMXhT66hCeU/FO03hKy/bOeANRMEV4MkSIc3kNJN9YMgRHwLiA+otde6iNqqH4bq9Colvn2FBSM9R7i2VX65vYad6VC1od3n26qWNy7KxPEd81pur2rLMt72T2tczBExaT9ZWIm0HA5XprgjuSwC6rsBK//yGd9RRtgpuW+KZs3nOBAs0e9DP7Pmv26OVY1rUWMv4+t665oRJ4fPDE7//w4/89d//I3/7699xTgouEQpSUhH8UNw+C2EQB+I8ca65erTUmbbiM5ITh3FEvLGUQ/Al7iMhEnFecSFwnmcQh8uBwR0Yj8L9yaOY0TunWhlN8d5BiXxOMTGfZ6bpbLNUK4LjvBLu7hkPVkd6yx5c79HO0vRCQrd2Np7UBRSuz9SusblDdbZDDsGB83z7/a8YDifEBUy1VJmgjsVoZ6c6D6zhpKpiK0wsaS+uOffVvOuoRFpKl6qCfJEGrdbvZa+j17aeabv6bkMYWl/XQ+q+ed1Y9jQjS78vPg68gSgEzUWfaVQ/58hlEtI848OACwNuHBmGg+VH78SnNXLrXDi7iexxAc/qC68mvN7IXQ53Z7Mr59s40YWdWv5eRn4NlLLMcE+SaPdU+N8cUum76eeti9fNmhjU9Vn6rIFh2xQbL3k3bNdxIZLd9DfvWXth7Ey1iIR765+1qwTWuBdphCTnWk1KVhKlauXp2+y699o7Lznzu49P/PqHH/j73/yWv/v1b/nN7z8wZ/BZi/rIkdXhg7eo7armqoyMC9ZvTqRsKqyYwOfialzm4N1IkkTWCZHMEBx+sNxJ/uQZ3IHjcGQYHcNoaTMuF0dkRlNCcyqqMUGyZWmVaK6rOZvX0jAIYwjc399zdzqacX5nzzarf/NKY2UK8o/TRI6pSBza6lQ0otipj9aEYWGInAoinjCM/OJXf44PBxBPdYVwLZvAImnUYUjTjhY7UCe59x5Ie3r83fNfX7cnRXQw+GVc+H67JblUafs1PT3HWLaPm1sWO9HaYWf7/RaH/cmJAjVhb61Q5oqT4jwxTzNW13Dk7C4c7u4Zgsf7Un9WU2EKKqfcTaGD2udExfXCbyZ9q2m3GhskU6WD/nON1m5SThlv834pB6p6hyxcbCUsG0at45irmmsBgk7i0M2VDQERKHEA65D4yofJ6ujLqt/+3tWaXK3erTWtagrFspyu31H7cdCybbrie9835z2+6JM/f/5cdMd5dcidFHG+pD5fj8taLnak6t00TRd+/vCR/+0//pr//l//W/7mn37gw3km4TiEERcG82AqkbVaKp6pK4V5VIkxoVwY/JE5zjjxSKmtYE4DwRihkvtIMTOU6oBgtZLTZWZUj7iBEGAcZk53B2JOBDcg4okhkOO5bY93HhcCPgQ0nfn4IfH4ecJ54e5u4Jtvjnz9/j3Tebbo7wJrulmTF5sWSbLAb86ZOM2tHvNaQlhifOjuX85JgbtyS/CB9/dfcXx/j7jB8lLVvRfF1RK4wuKps3AubOFNClMgIgzDwDRNV7FHt+e5+f6VSLCOtwVQ7ny3laKeH0Z/Ppa/9+yku8+X/V0VItq8uxLZK3xT+iyi0/ULXtFe75La6t2WXmo+LUnFKJohTpan/dMnpuGEDIciRRQ3NYr/vpTC770MISWPT4XHupCY6v058bHe3xukd9Mx9NDMgnhr1kdVTyYTatWoGiiEdn4BC/IUdEnsV6D96r7CfRlZqaPrWq1M1X2zaAG7IC1ANJW+WI1JNHV9Vz5NmspKcHhZOL2+tcQEdRNytAVv3Hx/kmP3ub/uEHUEZwbV4xg4SKAvuKvJUimLGv9gK51x4lqsWkwZi3cunh0dEbRnM6MqqOPDZebf/90/8G/+/X/if/4Pv+Eff/c7zjkjHoSBAWfFyTwMKAHlEDx3pwMBR75EZokW7CaKiGdOE6m4rgkQsjIGRxY41zxAMoAqTsyGoSiZ2JYvpRkIeBeIyTMnJTi4TBculws5JYbDgMSMCx7JiqSEkyPHwwPHMVjeo+AIg3A8eY6HEcdIjrXi2gxucZFua1wRd+dxUzKTGaKRhGQlns/EOKE5WkT4yq+yyAJaoc6VCrgLOXIlfXfywuH+xHd/+VfAPSLJ0o9LoEZ0aR7w2eFy9W4zqc+pggo5gXixyO3SvVSCzdximKqtbnV+Vrrg1UIYnGmbzataU3127bZ9c73uu5oIE112799LB77F4VsT+dU4pH+gSmX15pLgUDo3/le2N0gKazJ/swuFiKLzjMYM7kwYRxMHw4EQPKHl0zHAaEe/qA8WxEfhGtciZN1qkZ2kYM+M7vady3gaot3uV5XEOmK8fe8t4t+bgG+t2w7orD6vVVTbsb204Wux+9b9bY79WdsRj2syu5roD2gRz8455nlmlnk1TucEpyUoyXum6bLysBKRIil0BtRSR7gMhJQzD3Pkh58/8N//3/8Nf/OffssPPz/x4WnmopEcSrqFwryEkoLlcDiAWrlJEXNZVollbiV62GeCD4Ti/ZJzJmm2oj2YjSGnTMzGscc84b0v9Z679fWeYfQMwZNyxIul1kZzM6JrMq+Y7DwQSuoPx/v37wvhKFKBCDHD6e4dh3HASUlEqDeYnrqPFMmtv0e0GZtjjMRkbuQL035tQ6iSQtv7wiD1hZ+C8xyOx2YPWJ3dHThrnK7Una/neS1pO7djU9AFzpZ5PcMN7yD4q7Xa2DTe2kSWiPG3PPMik7vSauxLLOUF5QHtuFwtqVLcSm332vl9UZGd9eBtQL2e2DjSmlRNyJHig63k6Ije3Nic9+a6hhRupCphuqpQWzUSCwzcRG4vfL/fnvOceVnku/nWL9RhbjRAq/63+su9Pt9iLFvNbd1pO+Q9WbO9wNJSeFeSnj1/OIzTswysIhDGIqMIVKJlEcAdz6radM2PT2d+/9MH/v63v+V/+btf8+/+wz/w4enCZU7MGbLLXc6dog8ncxjGMreamM0bYSjYtfaVYyLFiAyj9Z0tgrkCYotQbc5JvujhF5WD976kTSl6cfHEmJvUMwyBVDyZqieOlHd7PzCUNBcRI1aalcPhnvFwxAUzWBv9cjUc8vZ698i0kQk7YVWNtDUwXxmVe8azfm8gUJgTKZ+fOTuFa7/JDO3C7xqG32Ls3dodbql9XnLG2OvzygZXn3ULYVr0/WtatTf/W7bR7X48d//tZpqO/pHXPv6mhHhbfX/tfK03K1dL5KYgFjslxmmlaGJgrS4lvoiazpGrN4prUAcVQFu/ALpE+G0objWU7iHFL0HQe3N+LYH4Uxq1vqSv1wDRLUMZWrm3hTAsnl/12RLyJ+v1l55bbC+1vEbeG7CGUPMbVWTTGbnbNZrb5O9//MBf/8Ov+Z//w9/yP/3Nf+LTJbUcSVkqslrHfYhkhiEgYvDmfaAyTqkQNOuyeBulSCz1ERzgxJNStEyxC89DNYRWb07ZXlclpcxw8EzTXIrqOMbxUKQVi4h3rqpQF5vH4nVjC/3V199xON3jfKlal2WljNxtbf929ptS1e4FvUovKRTOr3uD9WGv0KZyWw/BKN6eOublthib92yMbXzPtLdw77eYqOf62FMP7T73JkR+u+/XEwRZ/ZbCbL9ah8abs6Ra29Wftc9VzWEIQzG2zOoMlKhilVKcHKJzVqQ9BCQMVjAFmsyg9R1a+6393A7Iep6Hem5i9ddLapYOQ/xnbi+JvLeeecsabAmCSWSyBGFX7lZKJLcqQZypCVPCI4QhLMndKiHvBjAMgeC8cS8CmjA1Yjn4KSdSygsXi6lKcs78/NOP/PXf/5p/93e/5t//5vd8TIr6ALGkcncmiVpdaoMVJ/b+ULx4fDD1VIyRM5YGJfjO7uI9Q0Fzznm8OHKy2BvnfEmClxaEjSP4kkOp89Dx3jPHCynNVrs5Z2JMHErQp613tqR8ukhOdh4sEE6E4oIKf/mX/5L3X33DOI5FCilqU30mKKu0tXG2IpuEakm61+35to6AaiGULExZ36rqJ6XMPM2clofN9bjr1Ty8Fsmlltiku6+Hv3oCh2FYq3c61dH6DBTC9QK3vycNVOJz65lnW0cs95B5nwTzLed47zxe98uKGV+/175sWr928XVz+yKisBpfFfU212shnQZs3kgEWjmi8nxOxJSRmCFQslcmDt6bwdcJOL/o2Gp4einHaJJKJUTduHa4+S9VAe1PnNdj3f8ftZfjR69bJQgL8bX1TqmmKijcMIZMLXuIFlfKxeDWm9xrS0VP77C6B8Y/pEVKgI4oGNrKOfPxxz/wD7/9A//whw/84fFM8iPMiaOFzpLEuOeoCU3K4ByH4BiPjmHw5BzJxcQxiLNYGlVizPjgrQ4EwiEcVnmrnHN4hMfLhay1AM5Sc1jFIneb2kiEh4dHpumM88L9/cTxeFykW81Nanh3d0KaX2ZeHeCcMnPOnO4OHO++JmctmWKLDwBVatsAYKc/7veu2uG0u14Zh6qiq9e3SCbfQCQVH2a1mtcVmVfkXyWFvsJCL5XmnFvBmPbChkAtb1RKiWEYWgQ4YLEiN1od/6s8lVhqQFdivVfs/rXS9v9/to56rH4/315NFIxD6fqpH2pRr56FF6GlCXI90lYgUeMIV746KZLymUEM8cwlGC74QPZ3iLdausNgnkwPDw+4sPTZqHLx46oA34iAA5fpvIXKvJSWf6cMyrKydgdMSqECm6aUmRQup/ivt36KJ5CtVZF1nsmY+BYitTK6sc4535CxGJIxTr/KWk2YrKu930F9RyUMVVorqiSK735WcN44f1XQDM5F0IDLqbglrvtwmnFaPXhKvqOSddQ8ZUwhonnEpwvozKyJX//8mf/b//ob/qf/9Dv+8OkBVceQo6VmOIU2F8WbncAn1Fs6C1ELEIsxojkSnIfDkcNwYo4XRh/wYt40g3NkFxuBUoSIcp4emefFRx7FKhB6h4sRzRMp2RiGYbDkev6EdwPeBR4ePyMMHA93eO+Z8hPTNHEIjiGUmNqUmMOI85lRBjQNjOHAr371F7z77iv8EBohS6Ikn80J6UariLFXudgSm5ddzNESU8q17aB/vkeR2v0HO2YiQhDXjO1V5bVomOycWNqbkvrGdUSjg12zKVX/uRLL5AQXfItZ2FOpNPUSRdnZXbulgql99YbsOt7aT7yRZmP73jrWOgbj0GtCx31tyvadr2JW947szjWbj2tqSmPY1PblTy0pyObDemHoECaNMCyEoj5nHyo3uq1I5pQSZATe9EMGnDoiKUOOpFzdWwsiLGVBG+rLrluc8l9t4H0wWAOE8tNuWcjUaouuNk3adPrLVf/ebCl1KbZruQGAPZ1+Fc+3z+wZnhag7p+pc10A/lWcT6ckX90rS2CZlJTQ4gdLG133QrDAxfJ3P/GcjCK7yimWg7kgBXtnkASinOfIDx8/8v/4N/+O/+Vvfs2PD49MKZZ1L4RFl7w8c04FjFzjUsU5YrScR8MwMpS4mfP0RNZkpTABJ5ksjkEPRf2B7aEoSB0jS8nMlCEZQsxZi9pLCMHjvSc480qa58gwDMTZDqbzgguBy8MDcbpwOh4YQjDi7SzKOfhQVFaBQzhwGg+4biHr0X4tK9E7aECpBdHHHVSp5+p/L1us+zavMGfZbFtRoz5eZjWA0kf3dxnXHi6hzE2ckFRKnrVg3lJv9PLZa/2Z6YnA9v+z7RZv1bjmjum8cW7fQhhueZpVnKWw5GCr32WhL0PzFq3GH60+aoPYICgDnuVa4zZXK1k42QI4fdYdzZlErTI0GbeTBBdNXPdiHhhOzEd+qXSxwdS6/lg53yud5GZs1/O5AfSrNajApt1Qrp95y6F+vr89QLpGG5UIvsZIt71npdO1C01aagdAlp2r+761KZiWT4rKZMlFUxFQfdYRmXPk588P/M0//CP/y1//LT/8/JlJc+HIrN/KiTUEpvZ0P1+cZ4pzkXINRmJKnC8zSmaOiXHwhCDGcMxDSXOtON9XslvWpkck4qRk3nQlmA2QAp/eFHfDMJBTJGsJknOK4phjxM1mswjOMagyz9liTrIgXhjGI0MIa3he7ewGEQj9LqzXOFuSuWmaLD195ehvct+dBNFxwm1/C1HJuskVttrrqkbiCuC1k+6vYFgqT2n5sMIQmOO8Ks711vacTr/PjdRL3fVaG/NqgHZFtukZWDN5e2ftmpm7jQ32cHqPW7ewsRriDUnlpfbFRKFH/v0ktT/hXA9sy3H3bdFHFyhSIw6ql0YRNVmuFec96gVcQMSCiXDefLk7eG766qxrjqvf7H6MV6Oq41rGK6Ue8haA1m+45aZXIH7LHT0DGFvgWauK+vVn8/tPQXqW1kZcuHzTj9eNpqkdABP7uhZCwGPqpqpu6MdY6y/nPPPp8ZH/+E+/41//v/+a3/z0iakhOzOeuQ3hV8049eaRU0J3BVAnXM6WNXWWRHSm/55nV2IIIvd3R+5OB+b5icfpMylPuCAMQ1HvuIXYAMWLaCyfzXaiKmYkjpYHyXvwSEvmF8JATmoZWHMkDCcI5kI7R4d6CArnyxMaZ4IbOI73HO/uWoRwm25XwvSqyUIwlxKYdu88z1zOTzw9PRWiQOPgV4S555jrntfztMvgdJUUKzFgDa/9tec4oj0GxxVHFO/9EtV9A8Ht4qHNe/vPzeDd/V1bL0H041k+Fhwl1+e4SmbbUd6S8vcYsP4+2TxjqLF+Xuqb9/c5t1aLrc7mC+0NRGFfDpFGNdeTXuVJr9c6VZG16m1SJ7Vkv1zQgCA5LTrFlFCXmJPZLVwJIHIuMIQR0aEVm29i2tWor2e1bVcbVP3Kb9xPN11tdpbu8YbI999/3d81N/EazsLa2oZRuerXtJsAqr44FdTl7RCzArroaHsksx4ES9bT8mxK2dYrK5oz0zTzH//xd/zbf/8f+Xd/+xsuBCDigjcpRSHn7VyWbJfBWbK7DMxzIilcLhcu04T3Du8DafaWrsXBp48XPn14QkR5f7LazX20aa2h0XsYPT09WVBbMmnjfEmcn0pgmiZOh8BhNHfW092B0/E9QzjixHGJmSlOfPr0yMPjGec879/f8Zf+PcfDic/niTldGPzZEtbdDNC8bq5JpqZOrSkrzucz58cHLudHS0md04brX/Mobf8af2cfcpX+OgOx5ozGuGgCOgmhoalMYxKE21xrz+z0MFuR2T6iXrdbBEBb59f3XqmvuudWhX5Wz15d+pO1lYqLnd1XFsK78/wfywy+kShcd9bXSX71YLpX9RviqhqpEg9VkGxui7KUqzbjmBkCJSmuVIGLMRFDJHuraeu8b8bWLaJ8bbsS21g25E1zbu94Rg3VqVbk9l03VEG3uY3lIFYQU1ZVQPbG2ek97Z25JkS3Z8Q4WCfmWpglN3E/7eSwz9kqizln5StN8BLUWRRzEiHNiY/Tmf/w69/wt//4W56SwOgJJHNPUErZ1uIa6jzNU0qrEVUIztJ3eBdwITHIkcE7xnHgOA4MIgzDO+Z4Ic8TQub+/TvuD74wKK6kg7fSm/M8k6JJAnOcEEouHklMKXKJGe8D4+lIjonBZ47HwFdfvWcYPSk5zo8Tj48XHh6fUGeqrGE8kRUep8Rvf/tbfvnL7zkcD3g8p+MR7wZymhEZrhD3raZFkjAG1nG+zDw8PBGnyebmXAt1LmVy0E6d1xM/WOxDRiMqQbenEWeSjBtWKqU2lvJE1ozTnfMnL5+fClPbNNqveWYPDvfu3VMb3br3/5tNq4rvT9DqmrymvSkh3oJUXoFgCyNZmcp2sSK7ynRU7oI99ZI1UV1XwSg6ayuvmBDJQETUoXGGYSA5UzNJqf0gaCv+IhgyMg+KJYhq6Xox3gi5jU/qjeXAuIpgiwhulc6WfElNwqOTMlRL/qflO8qYevZsL0q0rU8lmKW5qpJiyXu03QzpwkoXg13HSfXcScX7TaophEyqC3AJ+irEoPZhLpdmCZINNDvv8GJAaVHKCRFPoSmQEk4THz+c+fnjhc/nSPICRLzP+GzzTiIkDaCZoAntkY2Yo0LCgiEPATweGT3HcWTwHi/COFr/4zAQ7keCNxWFoGiO5uyQIjkr0xSZpmguoWoBbd4HhjAgLnEcj3x1Eh4fHhlHQQ4Dh9Fzfzdwf3dPAp6eLhyOI2EcOd6d+PnDzxyHwPv7kmAQq+Gcc7Zsw97jDwPjuzu8G81o2NQUBiOu4+Tb9IUSXVuN+TPT+TM5XUAt71GP7DOmBfEsGXZ94dLRhTmh1+WLAYaS23XvOs5eOseDeq09uoY3zRZ1XuNbVt9VBrDAZbXTPOdu2vM4RgBlcWG/Xq4VEbx6V7n2UpT+5sLqo15lL+qbjahqSeyhlmB/c18d40Zb84yarL9W5/iautHwZptCz+J3w7tFQXX7oXKp19b5ducKOUn/xdW9viDjZrHSjEqpvyvORG9fkrA5j3pvfvYiZiBCWqDNCplWxNtm2y18A69FfKscUS+srrdW23OtIl2by5LcY9WPLFzMdp36N7d17AjUiuAgILVKVvecFBJS59mkAiuYtL1/eWd5JdoSpS3ESLu5bUF7Ld0kFF/nLraFoo5PjzMfHs48XmYq+vJU9dAi3SyGShuzU0sgppRAuGwE2hC+swC2YnPyQSFnq6XsnHkxJ/Nech5IJhVMU2S6RKbZDpV3jhAG6895vDNPLBykQ7AwDieMg2ccAl5q1tdqjDU7g2XtzngnBdkFnHfmaeN8yZ7q8IMn+CWAS1mM6vtC3sKFKZkUZ+J8QVshHW0MVUW8WsGuV8v0HL/UM9b1oVVaL7DppD3Wt9rHNsll+5414ejtlP3f1X10z67QOP06/apyar7yz7Pae+frNdJIb0ju7SVVl/Eyi98d1K5J97N+XNTpWwLQHOOfbW+VcN6YEO/6sN/iNvf0dFurfr3W+9vvts36bZezt0EAZkgTNT9stcAq7z0yDDjvyK7URq41D0VKKtbNvJ6BqZ4kLEDdj0mvgH0F9BtgbMD0DCx9ifha3Xf33uMqZ7cai11bE5Bl/FVSqZDQ+FctnmDO7boOLm6r9dCafcA1oujJOfHjwyM/PTzydLlY0absCE6YKkIsh8PUN66kpLDo65jtnpSyqX1iZhhM9aCUYLmSaVMLFsmplKRUi1wOwZPFXC3nKRX1ESupN8aEcxl8pgpKwzCSkrmn5pwhW7BePbTTdDEbR7J1iLmkgREhDCM+eCMKxXvJMs7Sal9rq7Nd1vMWH6a5/W81Ezrj9Ev/e85ZVbvANhZYaYxNzWvUJarUBsnG45ZgxRUSvSUB7zQRaQQh59x+37r3FoF5Gc0vY3ltW3Hpb+jjLW1tnIbe3f0t7YrJfqb9kTaFDTcs62sV0CrSvwUMeyLQljPW2n1d/cJtVgRVm3kUVK7ZRH5NEHNGcsR54zrwHudLhkrnQD2rbW1qlLWfdwNgsVLx67W4Fs+uDMr0jrfrthEOr97TVEfPPr3t+/oALeLqdow7nMuGIFTCkamxCJ0EIF1qhZ20zouXiiASyKQiIQgqAw/nM//2P/wDv/v0iRnzhZes5LzEtDjvzNmg4h9VVDKpuZyJ7bcmHtyFb05f21jFDKWaFHIieEvQOATPeDhwOAyk2dSQWTNhCLy7H+B+4OHpXGwZmZjN0Kz6wGEU7u6OnE4nVGmRtyk7EonBCQ7XAjit2M7MPM8Mw8DhcGQYLKfRnGbyY+Td8UQYR/zBMgtHjQyElgr6Of8RVV0KKSe4PF1s3Tqkv72/v7S9pyf4lWNVMI+svCCnrDsqmP49VYWzg5T2kLAUGLFm57naCKrU0NJpP0NMVnaxbki3CNNz73nunipwt2+7P+pZf9Gx5Nm24Qaa9LZmsLfj/dL2RvWRpUzeR1t/fLvFWV/dR+GU8mYk9X6n9qW6EtmpoKGkE06WU0eE5L3lXSoeTN55at3kmqzsefS97bquT8epbAhf9Sjo32BctvHL2kHvS4avt7S3vKeKpruHuPys6iApBkDvl3VbidSleeeRkvMq+FIBLSecwJwSP3564L//H/5H/l9//bd8ni5kcVbwxg/EWs2rCHVSqq3XVFoOK3wU1Yh/wNJwxDTz+HjmdBjJeUZzIqfMV3cj5szkQYX5kvj482eOx4GsM5YfCHJymFIq4hyEYBzr+/eW6SfFiZQS5/OZ9++/QkSI0WwV4zDiRHi6TMyXiek8EWPEe8cw3DHPtXBOgbUQrEaDmmfQEA6c7t+XYkRl7eWFfVRnKquciXOy95ejYFX+NnC4QSBbqeFq4xtnVBCTYNK4LKRqGZ8lWZEiJeSUyDHhS4LCJlXcnI5hVnNfFpxbopArUej7fI1mYu/39pndkeytx4vtTyk37MshvZ3hubG/tb0hdTYsuVr22hqRtMH8CXBaz7FUZKR0rpEb5C25JN+r+fjF40peAC0pk6OCy9ly1/tgUoM4pBodZckC6ZArIHuOrb9l8KG8T2UvM9DyusIAb97T2PrGed3q61ZbbpUyEun0ENq+v2UcrO8QhFxUT/VNKebm1VINjn3rOaacEz4HXBYykcfzmd/88Af+7V//NYgn+JGkETQTq14ayxuUEIRQgsYStWBTCI5pyostXJwVqgmBKc6k2SqNeQdyN6IqpBSZLjMpWm3l/DRxOo0lm6p5RE2XTBikVOVy+CAcDwNJZ46HE6gQU+LDhw8cjyfj/keTOmOcLWCtk5xSUT/FOZJzQnXkdDpxOh25P4w4zZxOR756f8/3333bpX7gWZhr66wlSO1yJsdYVDj7CLPuS65Ir2VPNWeInDJ540Js48iUbDSWJoR1UrntzkOpypcTTmuMipT0C+nK0MzqTbKyKVS7wtWdG9VR/R/TfFOt/VrbQWV0tt5Mz529hrPk9SiwRoc/J/2UT8CaudzOZSl7+/b2RpvC+s9azGSl6MlaUl/L1WMNqXYMgusRkALuWvfVSpa3y6UYjqvqmI22okd0mLIDSvQhC4OiRQ2BFk8IcZCMWOCsJKO5w1YWtX++TmJrEK8/Or28avd5S8LKZmtuz1Elw169Uw6SSUm63FuJooJ5Ye2Tm6pDl0JIm/TZDd11g+yJX117qessdQ4lLV6ZU9U3lxIvV+82Sa3UG9BEJJFjJJ4nzp8+89N8ITtLB+FzMZPrYhBNudRXKPdYbYQiCQoEUTIWvJg0o1mI0WwDOZlX1DBYmU2fzd3UGA1PcIJ3Qs6elJWYlDkm5inhXCKIedl4zcVm4hqcOxWGIRDnGR88qDcpVS2HTox2v3NqPv3AMDrCEBjGgTAGAkZUvfMcDyfevfuK+/uvaBHgPSz0wLHaZCOcMU5M0xkt6eyyo7mqNh1Qg8Wyd5Qa2pYVyf6uiF4oAZ5lr0VRvAWOhhEXDg32lteXs1LhjZpcr0BOCXq5YrbaXIxhsaNhBNnV/5vazf3vNcwbLtL0dm55T/K4uqf8dusltf8N/VXPww2OeGZI18RqJ+6nIYlnWtO5Vxzy/O21fVFEc+tAxOomNK7WenW4AlhVbIUFC0HFNFWVsnBAvYy6oL2KkLbPlsFU3NxNulusgsnMC6LP2Vh4ZVUkC2hCyeCUlBUVqxAmPljZReeohcZaf/VtPQfXNmJB4msRbzN+6jPaPSPLPeXdWoUfinvpulNe3vE1919Fz4X5WEVfrNeoXum6FFXb+/JmVxmBZjdYj8eVZyqBFEnMOVoNg/PE9PjE2SmJ2OiKl8UVOCmNo/WaLbW0eByJmkZ6cDCLEYQ5CTFi3kOXiPeCHzwuCJnMJUYuTxMgDCGYHcE7pmgBaVNMXCbLm+Ql8e7g8YNDk6IpMSdQXyJHgbu7Ox4+f7aMrDmQix1rmmbmmMgqJmmYKxxhODAcRiMMzvIIzZcL490943jkdLpnOJx2FQcLYdjy5JZcL8aJOU41V+OS6TR3L6t7oSaFVU+hrLkQh0oIOogoRMRRyv34ARmO+OFArWVReKwmaSM1eV6P2Iqhf0eF1QCsMjEN+qQEqS4J8rbc8HJeFqtdrybbkxL2VEyrNX2L6qgwb5WJcVSUd+1JuelkmfdOW9REbvtFx6hu1NTQ1mJhKl/X3lxkZy1Glk3b4GBtYNhx8RWH63rqbWPF+Pqa2Kki0Apk9Vr/f8/FrTZXa8Q+sxg2jholGUtgD6habVjRhMuJoAF14FSKh42YrKKCeQPY5iwp7rt4gtKTtF26Psx15LeUSiuDWaNI23fsXVtoVK1vUQF0V7TsaHa7tMOJVcOj4aYFHizZXZnPdm9W+mpBPOiUmefEwzTz+88PPD2euVxiQWZWo0Gwyn29S+sQSilQkSJ1mHeREw+UbJxi3kjEmczM/enEcQwEZ/1//PyZh4eJacqkXDh3IASrlnaZM3PKOG/9TdHx1R28D47ROZ4+f2QYA4fxwGEYjbDc3RX1mHKeJmJKxJiKR5JJoyJWqvN0tIA6UUXjTBxGXEqEYWi1FxrTRHP2pYlue3ACpHkmNQmowEz1PqomktV+lPKkKTcVkuaFs99DU1kp5Usd4zASQqAiLFOPLi7aDUWVg1xdWdWpZSPO0mpqrGCsY3SaCi1nnF/g8aaTSsVJzkF6Oc7gJfvCTW8nXX435USb9HKYnmPoRWvoIPQbuz6fN862Db7dv5pHp2LWFU59ub0+S6rAtU1hs1g9F9JvcBOlNrfrQsVUIZecMdt7jKl4vUsV/HE6NVMnmeQgyThaFyeLoPUmQQzjAVcMngp28JBi5C6UuVYEw4yivVrrajWulI9fOPb6dC+V3fzuy3qrAtFWh7tqm25FpHF3OWemnJAEl1n54dMj/+t/+rWZB7S6HGqJKbHYAU9AG7h2/SlozUHU6XxVIWa79s37O+4PgcHbA1OGnz6emaNFQeCFmDMDIFMiJcMlGYgZdB75MUY+Pc68v5v58+/v+LM/+46a/0aAaZoa8ko5c55nPj8+gjqmaFwuqqR4Zrz7GlU4TxFRi8OYonIcQDyc7o98/c3XeDfgJJCJhVcWVG/vVNbMfJlIc8QjJDWk02xQG055a1Rec8UlGpmFP13xsyoEV+IxdiJlGyJSoQbeVWmkPv+aWvJbGFNVQgjN+2jL/fdw6DCHkl5Ftces7PX5WiePPsXXFo1fX71uawy6gxde2dr8yue6Z72L8Z+cKOxxf/t3LR+27lgVwe8+IwZAWXMz7LRnZT2hP5VXjog0uwiAVEKyor7lHgfZKSQpefeFUAxkzjm8sxq6Jjn4whw1EQdtKb13R7K7Kj3i/ZI5L2u4nnP/u31+4dV7RvacsrmIbu5TVdTvSwpQOD/JHPzI758+808//Mzf/+4PDH7gIrHlOjWpzDxyKjtmUdMLwZeCZK4gSwQvyt1xZBw8WTNTzOSU+Xy5ME1a0mRgHLx3HFzicDwwjgdEPHOKfPz4yVxNU2bK8OnhQiChMfL+3T2Hw4jznjAMlvnUOeY5khXu7+/BjejDmeli3k9jCMQZIxZTYppmpjki7sJf/Pk7koAPgePBivBoEbOrhG3IERaVY11gc4mdpjNxntCUm+G4j+y92ifdiU8wRRI9i1bPrh2FGicirdZIra+wZnALXO1UWFvgaB+n3JJkVwbtW+qncoa3xufXqoH2CMitZ0sKrYWZ1+oIoytceMX4d9qP5d2vP9+LI88aLy4Efkvkn9ea9O0N3kdVl71GDPs3s5rfyvrP7eCLBqTUDJTluHcTfA4xfgmh6BU6QqYWxqGofyzppgUzWXoHZ9di8ZUXUHGoy0WloYtU0ElIugWMG/Nf5tH/ryP9ck7i+dnDc+9dE5Kyh2VoryVWKaeVP7tKRtQzXWYezmfOKeNcsHgD6vJnXHm21eSuSpSNKnN1AMpBDQ6OB484JedkBuSoXOa4Iv5OrELdL94fuLu/QxWmmBCNfPt+ZLok5uyaRP40ZT49RE4n5VT021OXM8gM7iA4np4m5imhKhat7M0L56cfP/J4iUxRSSocOHN3r3z/3VcFhiwYsK612g8qbO4dvxjnVbyGSTHXsQh7v7PVWS1j17bPdX37ViX3PkV4VrUaKF2TupG16KmIqaecUrNGviYid9u0vrf8f+lUbG0Kr7YRvNRk+SDtvcrm6vVzG2Zv9QV711/qn/ZM06xk/eJ5vtGmAI2r3hvVprVvV4OrSGVP3WAArTljCdfqW9YTfJHq6/ZPbcn27Hkacao5+pdjppsntehzHa5yREipTFWlmALkeGq+sVqEHTAvqQYEN9aom1tPCIyYrIHZGLD9ILgeEKXbpWZgL9Sp6pvr7f3R2tvVNq7S90p3WrNgyrWNqa1k1kYU6uGZY+Lz+cKn85kkag4K2cbk2pyFlBWRbNHLIuCk09FXjtHRa2cRSv1jUw2lmElJmcv/svsEJ4yj4+408O3XI0PwTHMk54i6zOgdgzP1jjHfDnLkMifmeWaOAxQ7gqq5m87JgukG4Px4NoQZAt47oloA28fHJ85TZkpCwhGZ+PkDpATeDwzhYJx4g8J6ROQKvmvL82yFb8AIi/SISutGt31v323UR5XZWfXTMzhlvS34M1DltUqc12kt1mh/AbmapmQdHPY8gyHtnxNpFROvCsw0ieeaW/6S9iXPWzqbMoqF/7Dv6JnEZaF7/NruvbEevaqoH6eW9/RZBf6zqY+0QUnVXfWiQBlo/+eaaC6cmcnAVwstYukKtBAGyQr+lkyx2AxuLlobd9Gpet9MYaCWk1/NONoQnq4gH5WMSsRqO/pu3MZ5qhN8dZurByp61BkSa++uhlWtRKQeAHc15uY227l0auP8cjsU9bD1B6k+KRUKm7qnjqPcX1GilioyTQJcqOa+mqnuWX1XIRDO0jAIYuUW6/XN/lZCpDnjE3yeZn7/8Jnff/5MUuU4lGy4IpbCQhwJmLMwOCWIa0honhIpW91ocZYN1/lAzYCECNl7nubcUk/k0ndKjkxi9HB38nz79YE/+/49gyYenyaQzGF0DN7z+fGJEEY0J3wGdY7hcGCeLzxdzvgARz2iOLIK5/OZKc5WsnTwEGfGQyCchITw8aPw6ekRxHM4BHzKXKbIrPD5IUM+cTr8grv770hS0rFoPW8GLz5HixPZrvE8FVWbJasTl4v02xGFkgJDalSbZjzKjFWHy1qclLTCUj1IS1/JOYILODeUDKkgHSqpbFSN7XCWU4ZmUxDpCM+aIFzp/JtAUF07sZQklRBVAlTv7xBgi7/ortfvXmIy34JI26koZ6zUhSxXXeF1qzNJuVambv1srTavaw0jr0XBFQX6z2xT2LYFQezpt6oIuvy5P+HeQFLF/vZU1nahB5r6+S3qIrP/dhC0QchlKt2+VKxnF3MprSWu+qcDcQZfcvOL2DtTxHCVKymSBbJYcXnXpZ4GzA22blaHcLk+8NT7Vkv8OiDaV70VpND6/LKWW/bQDQHZDE3pdNhYfqrH8xM//fyBn3/+SNYlmyM1h1GVh1Kp8OXAe0fOsmYKyj7lOBvqLCodNHJ+uDDPNhjnhBCEscQzfHN/x3ffvuO7b++4uws8fPiIE0cYSg2DBEktCPI4DqSknM8Tc7xwd3fgm6/eczweEOdI0ThzS4dhn2OcuXt3x+HdHZf5wsePT/zw4wVQRhf56v07xsER48TvPz3w7jTy/Xff8fW3XzMcw5L2vYPJqoDdazHGZsivHL8doMUou60yljU3VagUDjMLLcCyh8q2tyXZnB+CFb33oXCmvYRb1KnVL1baN6QcERegcbZ6E3H1UserwL2TRMoL2XvwyqbG4mX0VjX0Vqjav+d5Bve5cd1qurnvT6UW+yPLcb4eKcF68NfqI8VVkau7T1MNVJJdYtAbwOr1K3RveJlb2cRX45EetDcIWqoLZP1TjDOjuEhqKhwuqGZyUlxwiAoxTjgxjlb8QiByUxEZYZFKiHaix43LX6/DWwhDHfNz7XWG7W79gRo05f2BRSe96T+vubY5zfz+5w/80x9+4g8fH6xeQraaxqkitbREropb+6nnRFsDwQLb+jl6cQzATOZ0CC1/TggBzZGDd/zim3tOh0BOM/GcGMIBnMUpxJhJOTMMB7yLUDjpMAzMs3J3f2Q4HvDDUPIAZT6frTBOnK10pHrh7u6Ed47LOfHwEJlzwOuED8LgMl+dBk7H93zzzVd8dXfPv/wv/hXff/9LhjCgRCBQM9ca6liQ+vb89fmA9jjk/lr/2da7O0sr9VJVVXS2QLEypEFKRle02DzKkFSwXGK9iqSD11q1jK6/ZZBrrVXHCN5kCDeU64qQFYZsLyL51jq9BdHmBXW8qvXqrfZz57xtpZnd72T9d8OF3b1vJRpfRBTWL78hDVwpJZ9/X9ugqkfd2Zjtwqy9UK6JglIqJ9GrWF4vDu7/VZY9a1OztARhUrw8pN4nECE7IWlJQOOMSIgvHF8X/a2qS8BQIw6y0/+aSK7HekPC6O/aQ9o3iMD1+zuEVGocWBqFvBQ22Rv3lXiemWLkHDOXrJaLqh3aBXaM611Hatd9N/WE9ZW1WBSqxFKy5B5PB8IwIAi+pEpAA4cghMERRs9hCByGgZgi8XxhnmeenmbmORFT5tuvDoyHASeOrJ559JzGI6GorXDCLJk5lroLIhzGkW/e3zPNZ0BI0dJGDF45joFREoNXgoMxON599Y5/8c//Fd999z2H4x3O+RYnUKWs8ummWWFtP2CFSG/CgRbpQykJC6tacoGJ3GCjSs4Oq4UhLaByZzSsOKw1CJl6VNdjvKUnvwVHvaPB8vpFG/AlDNNzzzyHpPfGum1vYeJe0/f2TY0h2yH+b2l/AqJwpSdYiWxb5LVnS9h/b/e9XoPdLlKsXASycvtf1AwvEXd5DgAAtDFJREFUzWXbSRXU7UAsNV0VJ2ZYXlr1XCr/xRbDNqroFV3VgQo5UYiHJZGpFpVcK0kX4rjSLFE/a/fHMkKUltv+uaZqhvcvFzYrV6JLvpbyzZ4tog5wkRZMvfDx0yeeLhcrySNCipOlTmjc5bJ3i/pDy/g9SWNJe2FV2ZpNoxJroVTtkoIksgVqiRHfpCXxgvMonpQuxDkS50RKyaqtpcR0iYzDgB8dAavR7BhW44opNXfq0XsOx5H7+zvSp4vBr1othdMh8/5+5OiFQzBYyln56t2Jv/yLv+Crr78qLrEOkWIfya/bqQrKWbcV1Lb3rTlvtHr4lXdUqsDCqG33XqTmJFpLjfX4txrR9UcTvwsB0OX+qta6iSO6zzXFxXMS7zKFDfffRn8tJbyG+NzucH9/3qKGeqvKqnV9NRRdCO8XEqA3E4XrjpYdrwNauHHdLLx0G9q2Z8Fo66vGLDeUU/pR7ZjGa4ORyEIQ6leuqYD0qp+lr/V4zFhLOxC1MpURIqUaVqttws5QmX/Jh1EJkeSEOE9N5Q0Wj2EcoINsdQgsU2rGlbxLiqySzG2Ja1v5iohfCQMNcL4MDhcdLLnUDFCGIbQ1YkeDKh2M5GxJ2377ww98/PxQELOzdzntGMw+0Zr1JUU68DXVgVZds2VKdcXry4lYcZ6cSZdSZKaobpOAqsO5gRAcwQ/klJieLpwvkxF/cXgPzg9cLjPDYFHuQwicjnfME1CQWYyJaZoQgXEc8CEwlvgFH0LJ3WPFd06j8s37A+9Od8yXiZwiSZW744nvvvsF7969YxhHU3kIaLW0tnW0/83zdLWvZZodB77st27u02J/0I6r7u6v50Wq1xrtnApG4Cy7cGDxONOlAyqDVq9rF7u5wJ+ZHNYSzTLOjcRQ4P+qglghXK7CUM7LcCoRulqr1yPMt0jWfXtJbdPjqLe0XXVbv351TVfM4+vbF9sUlgmvrxcz4u6CSMdIt+FqKv7YrIjFApZLQIxqbqmatwaZ9TV7x8LFKJZRsx9oN/CtmqoTey3orPzRATA5gBSvkNZ3sRKkJXWHFC7VlVzw1X2ulgU1z5JM1lTq3VqqjewSuFq4pgdCQdRVaoBW24OAbFIYX9ttaICSyuG+ss90wH4N9BtELwoSEfGMh7tCkE0KyLLW3669IODydOafniZ+ShNRZu50JIb3eH2yhBwlp1DOigsBdR7V3FJHhFEIwwDJAtK05BhxGq1kZvUWA2bNeMwDLGeIT8LHxzOXcWZ6n0hfZ969O6FhBJcsvbomK9wnFmPw06fPfHx84ptvvuH0zRHRybKIRmWeZmKcQRLj8YAPVkFtzoC/Z5oueJe4G4VhuGPEEQTefX0PheV5f7rnr/7ir7i/u7cU7upQRnrGqkIygPprm1PWM44BL+bYcKUWyfbfYYWIKFJXcsVAXuiCnTutAGMh5SKolMqFgB8PuGFEvSdJxjEhGhaEX4x4ktSKEaE4tZKsDvA5ozXZ5I22ZYB6qWKrEhOwc6faoowbK1ngIG/eCUuq9+fqOd9Sv926r763PrO1011Jaq/oa09yESyAtF1nYb5mYsdvl7k+O/ql/ZGG5qVtOZPnxK/txPvFWv3u9IO3NmTPMCodIVkMyAunuB1Htf6vK8DVdywShJb8QTkv9y4qJdr9Ist7cjZCtp13nU0uRj7RoqLXTCIWQmMeTC0rpAjqLDvlkmumuq5KYZiUKkG1fupBfwam38L5dFdMcHOUICbzFhKxpIjbZ6uRPKXEOQc+P16Y54xoQBVSNp28pTXy7UAZwrJ1dS4wDIrmZNXL2j6ZAi4X7hBySa3uuTseGyelCnkIxCSMQfFeSWlinoQ0w+Pjo6mAxrHtrfeeu7s7Yow8fP7MV+9LnQOBKSXOc7TkiQrH44kYI4+Pn4tKZGjqKAugy1yi4C9CCI6745H7u3tO93eWBG84WRLGxuntcHk32Usr/LR9rnrOqRb37E2gXa9yuN70wthIh8AlcXd/YDyOJtFqhQW9HpvUSnCOPhq9aFRXuOIlN/Pn2koqYh/H3Lq/r2H8pSqXvl3hu+7nrfac4H5rTDev7/T1lhV9M1HoKd3bu3tebNtyrXt/v3bT1pJEGacswH89jzUgNcLQBHYaVq2Gv2uitpL0y72Y2MtyCKoI3HTxdUxqpEe1iNVinE8qh8WMmpkZxWXfPJvMlKHU1MW1zGMb8iKArefI2ii/lb62rc2zcCC9KD/PM8fDsSHqPbjo1/rnxzMfn85cppk4W6bTlC3Gw+FBLZK5jkWKKk1Vm5ejfVf/O8SnkmvHuNmg4AeP5NSp2gDJnELgeBgI3tSBIoL3jvfv37cqa75LYwIQguX5eXx85O7ujpRLRt2SAVWcFdVp0dNzMoRYmJFaEVA08/T4yOV8Rr/9hu+//zN++Zf/HDcMrciTcXmdZxqCKUJvc7TGjFiqbd3s98JfaauaVwlPUxdtEWfbN2M2pCy4OGEcjvjiVnpjMIVIlCCzOikqIQA6BqYi5f1X3bZL9mf4JQLQ31PzcG2JUn/Pn7TdXKZ9nNZL7c/N56VW9wzWZQqea19kU1gPasE4z4k8t971khSxd9/ee1eL1wHRCtG1HzvP7I5rD7lJf2Nb8J4wwHq85mZab9+E3FOJD1CDsSpVqNJBQ/DFy0YtpYA4U2HVf7q3D/W8N+mkO/yqTT13iyBcHbj2Y4EFVYs7ECfFBrJHEKCXJH7zh5/59DQxx8XzxYcRF7xluBVBNbcSlxbIWHLKKBSdWpugljU2BG9ShcqSmqKONasy50h2QvDFNiEe74dix4F5mkohF3t3TeVQiy/lnIv0YlJjyhnJgg9uiVMoz+UMsaxNcAHns8VBZIfgGMKB+3fv+dVf/DPCMC5rv1rGnvPvowe2i7z838J2ZUjW+6b04N/xDlcvbsxGVVJ00u7Sw+Zd5f0rxmp1/xrO9vDBSgX0DJLcY/L27nlJz9/f38awHdMbiUbPEO5+L4vH5bbvL5ZcpJy15dS/ur05dfb27wbDNxD3rQV8ibrvtZWOsevvuo/nhLH9d+5df0GZ0qSAvbE1lU8jCIZ867ivAlYKElw8TartoBAeBS2cppIhYvEbrpTA6sqAViN5IxIrdRqrtdGi7qpAuXf41kRmIXD9fFNJr7Dso64JcJO6QDXzt7/5HQ9PkZgt8Z0XRxiHEpNSEb1jmqaigrN1qGsqTsipRJLIMk77b0QwOV8yJwspmurGjKuJ5CxhnpORMQxodni/9mXv99G5pQLYPEcLFFNnVdTKM86HQqds/UIYrO90tsh3Z6m5h3EguMDgRt6/t2I6v/j+l4ThQI2ARW2duoWnpSJxwp7AoAtUrq+viMAe4qxwtexxg0LX2S4az7UlB/U8+tW1qi6sqWHWPVbq5dp5MGnNc+U92D/X9vhazfQcx70d94ox0zX8PNeuGK5ugK959jnC0I/lJfz5YhMpFSO7tb+RAnzb3pQQb+lvw4V8ATV7CcGv++ulVPNecSU7Y99zraGQVc3g5NwKoPYo8Rb5Xc1lxUo1vqXYFbZibG6HcnknpcDKogpQ7bwhVpuuBREoluDAgqKqp4lTsYJA4tE8k2ZdiIITxA0E50mamwpllV9GWNlVrg/BtTeXISe1HPnl/lrStEXHQoukdc7TAgb6vfGCZIgxcz6f+Q//8e95miIigRBgADNapolC0UpuI6tqhgRTtonl4NdS4U9Kjh8vHk3SfPjVCcW8zGWauJynUvhdeHdnNQBCCGgSnh4uPH0+8+79AclaatEsMHG5XAjB430lEAMPDw9cZquVAIqOIJEuat2IbQiBnKwCm0pq+rphGLg/veP+/j2Hw9H6coFa07hueiXrdT17RmTbbjJgFbYoBXd6REmRSBtgrM+UEUbrvl734vHDgPiuhkIWsiiunueVSLlEOy/HuJceiryczOtLvMWtuPKAFF1/JRw1EG1RgW2YkRfa8wTyda2eYenI8IZGrJqpa7Xdvzr/Gxy4xa0vE4b+jfasQ6q41t7nb6jntu1P5JL69uefkyBkgyjtfqgF1e3glYUonJl9LNxGl4CuYOKmW9tVPdVuKrIWjKoK9Db7RQzOwAVXkI6VCbQi5R6KDrWye1BVPDaeWpls4b603tMIYx3QEr5kyoal2AjeXGlEDNmSFWUmu2SIuQTFqQjqpTDui1G26not534lEIBKmdUibSxcnizjrhKGeBwZJ4nBB+Ogtxb9spwkIV0y//DD7/lxAu9mBgEnniwjqdQCCINl33TeOEgv4JwFhSGO7LGkdmK7Y8ij2FwyeJxF2fon1AVSPBOC53g6cjgMzPGBS7rweDlb8jq1JHRfT0+EYhtwDkI5RB7LuRR8YAyBwwFGf+Tz40fmnAje46aMel8YFtPfeo24lCDB05O51N4fhZ8ePhPfC4fhgCcyiOI1IDlSCYAUaJqIbI+yqnY5u9bX++O4YnIUvBr4xWw1HKQQ3pwXsqHC4vlVzlrl9Wtz/oh3I45g8JKFim9UitVCU/n+AvkAeIO5wQh2DA6XFYkRgnk3Rclkl/FScj5VeaLT9YsvVR0FY4S8a+mugJvYaMvwVaPy65Du9fpD5X06ZN71Ve8zSbyq23oVdymwlNJCVG5INM+MpOt1+ezo6jxUFFTx5CvaFxma62Bvq2/W175EBHr+mQUCTPOy1hVmxcoMirR879x6n0IVn1vfK8F1+11dfPO20Y7jUdWSqKy8uG5Ie8NaIrmao5pksE2pJZTU08UzR53iRVHx5JTb1CIBnx3O5ZZ7SUTQuRiZtpxCdkXENENp7WyNXMzrSjBV1rrIixZCrc0ou3BfumaZik+81eYdzIZQVDLiTAqY50ScInGOiIcQHM4ZEsGVVCIIKUYjMiKWMkTMluPFE7xJZE5gkMAwBN7/4mtUjVu/XB6ZLkJKNWsrRtzVE58iUaTUeFbLlIowhAveOw7DwP1xNPktzQWmHDFmRDLTLKUKmYCovUPh02Pk49PEHCMfH80+cp4+4Al8dX9husxc5gv3eodzoRFjCiTUWgorDr77+WKrXHFnWG0JAtlK4su+L3FpGdStGIJhGIuqZxmQsTDFJTmDy8Y0WObbomqu8JFncpYltc2WyeuAp8czmnWF0DtIvDn9PUN1bqrEvH7/BjFv1U/XmgQKr1Q4fhbcuIcf9+wTWvHTDaS9VecadpA1j8b68V4ScTvjeK79yVxSn2tv0dm91CoXnTUXvnzpY89I11zgnuEIqhRxY/Trv8qfThZao5Xbpzqt9uNdEOUWOK4AcNVnz6F3a1c6swCrIg0UJCQlNiAnNbdDVyWDwVxbOw6z9did6qqu6ee59J9RLRJQpcl1/M6q0fUqs60QnQtHep4Tv/nhZ+J8wZcMp+aDCkgmhKJPLjjIiE3xyNKKcMpYtMgxvtgD1FmNsnJInVrpzGHw5JyYBUQ94gczFufUMroqjrtBED/ydJmYLzNzNkSXkuJTMkSH1UWI05lZLTOqcWKKnmf0IKh3OIE5Jh4ukU8PkUuMpKxMgPdKnhMfhgcevzlb3efqWaU9BK2Js02MF9qOSkSqIXNzZ+Fkux7WMNhXCuz6zTkt6sjteNb4vPy5IFinlemowZr1zOrCwNVnRK7OEmxdx9fzkX6u64cX4qiLG+pLNs89Nfn2mYyY2mxnrHt/d6tqSLsSuc0m3VLRv8gK7BCYt+DdP4H6CK4gYee+lxDzq/uv79v0tX6/jedV+kLpxKu3jqUDnOrT/pK9YsttbCUvNVad6xoKRZ9fEUXh/KSk3UBBXFHbFNVQm5gIqDdO0UlBxDXuosr9WvrdSDf1cTomrnyh5f6aWsIQf97FXVoifz8/Xvi73/yOHGeG46l4VJnCyTlwo2/Iz4iC1UnQXAlD5crsncbpKq6oFVwhSFWVZLalkipaHTI4/GkwtUlMpXC9Ifb7weOGAe8zIokZYU4ZJCAlB9Nlijg/kS4z2YUiwVhG1xxj0X8PADxdIj8/nLlMuakRFEfKShaYLhPTZbJ1SwvhW4hqlQd6UaFjDnZh8vraVsrYGksXeOyYqtUN5Q0Nf6sVPtIuOZ/IdWbcOpeuu6aBF6GldK99NmbDunQ7Z+WWcfkW0twsZSMKt/T2WwnhFg5Zr2E5JCJXtR2u7l1/UYJVq0p57Q12iwgZzO+/8lafb8G9bzA023CuEVpVKTyPVW8N6jUD3SJTLdr1etDqPeWNBXmto6rbprPPbV2Ttde3HjC3+sCXbCd7ROO6Fva6GenI7SBJmVdKClLVSXZVFSQlkxxETL0l0cqHeg+SwZkOvuf2FwZVC6GqrywcV3+KgRQTOeZizHVWJH4138TT+czvf/rA3/6n3+Eqd5+VlCIpR5wb8YXIUCRCqR6YhaMS8QxOeXiam6iumiydtoKvCQZVSDmTkhn6a/qLLAmRhA8FfjQTnHAIIz5EfMiMQ+D9O08Wz9PTE3MeSTkSp5npaebpLIAjxYSIEkLVgBsRSZj65OPjhadLtNoMobi/aiBq4qtj4DAEEJjjzBQvzR5RQVmkpEap8FJ25s38y0ZtUj8rC76ngkz3sRdS+hZCaLUXbp2lnthUsFkYtv2WNeN07Vq+x/E+x+ytvitSYDX8a/f9S0bdLVG4RYyq/QVqWc59HLfFC3U/Laqk3VmmvC8BXc+1TLLrp36h3bU9ZvS59iaisHaRa0N59rm3DOZWv6AtI2b1KDKUtE6kVZ5ohc4tm2Mnut4gCFsR9aXx9sDde0R8WcuFqLrdja9tEY3XToeVS8sdESjfLDelCOJKNlPT/+OVmCLiSiCPeEIYgWy1i936AKuypG7q+y9FXHK2tBCSzM6iV/kCM/M08enhkZ8+PxB8sNgDMa+qmISUZpKCyxZI5ry0QLJqesyamONExtJoC9EYAIQByG4gaULJ+OCJJCQqaZ55eoh8/jyTfCSI8P7+xOkwElzAqwdVghsYnUXfpjRxOAZiVlQOpOORp0Pk08MTyaaEE5PYUhFjUoogSsxwicrxOPKX33/D3QiDh+AD2cNhOHJ/PPH9N98wDI55nokxFljyX3RupEhY9bEeqRUhY30/tyXk53q+v3/P8TCaN8t2n6WczNZ3puMo2iA2AkTrdIWMOybkap7d51u2gHKhXX/teu7d17+/Vz1ZOpX12PbGY3MuBnzZea+u9+tL2oph3/nuP5NNYY34qtS013rueW9Ae1z89tmFu3el98WHex+qKgdUv1i/p49YXFFudoBp09bi5Vrc/GNsJZXomc4eRBw1ceDa86e42u6cYgE8SsTqD7gibSwSQ+mjvifNoMVlV6VomLRJV+K1xEhIIThWM2J7sI3bKX7lqR6UYhTfONLPOfHx/Mg/fv7IOWfGw9AwjxOrfyDicc5SbztxrZymEk19VIzVqnUtEloImqGeTNInvCsG0JQgeaZL5hIT5xSZJKHJIV74+DTzeI4M3jF4x/Fu5J1mDkFxZFJUZhXMmSsjHo5Oce7Ezz8/oklIoswaSQjFQo13keNB+Ge/HPjVd19h4s5ga5gT70bHu8PA4IQRLEUGzwRcav/bSn2G5vrawUHKFhSn62c0JkvtrpQ4i3kBvq36pW7vwmpu9hsmIjo4zM2vnvEKXMVO5DzmRmwBfFpyjzkX2rtyVROqtuy+krWVYhWuz2Ndnxo/0vIgtflqg6natlx/HyNU31nbtgjR9h29XaMVc3LrvqoqubB65Qv7ccXQlf6zLAb05/IwrZ99mYB8CZH5ojiF9XV46+Ceo9pbMQuW+ANKVxXtV1XQQoAqkSolHXXzHl6PvF+r6tqKm28lDtvb1zrl5Vf5dumzrkPtXzoAbPeuWJK+V1uTolIiZ/MLdw7vXHNFdL4H+OV9dcy9Sk4Ucqn8dT1uiCnz6fMTf/jpp1L7oHDYKRef80KDCpeeNaNpOcQ5STeEPfuUwcJYkQ4KvrgEeuXgA8PguTtlznPkMAZzJRXBYcT2cp5I05n7U+B0GAghEGMip4TzJSDNe+QYCP5MTLnmmLM6CjnhMhwPgV+8P/Jn373j7iBMc4elvcc7QXMCFxiHgffv3nE4HO3dV/CxNu637dxJp11lgobQTF+yQopfgiQKuLU2xRnBNaeF+t2CqMwLSUp6eRFZu9C+MIam5tmc354Bq0RhmeuaQ71SOe/Mf8sIriSrnTH2abtXzODmELdcaG1hyo8d3Laet67GvTf+5xjQFRHrrr/E8G7bH00UnmvPSQfbv58TCfc2soyqsvkNII3TXt6/Wijhirvq57c1Nj13z3MSznPPXm/sVk2zQNItMfTq3eX7zWq3b6/HJVS1lTQRXZpLoXGQnla7WcxrnqKmoR2I9XrWgKI9Ld00Zz4+PPLh4yfbI7QZprV0k3O22txVOVhTrSvN06q6UfZzB8zQXFJe12IxxjAkUBgGzxCsBsLDeYIidRk3h8UmeLOtSP+3KinaWFyRYPAOHxw6J1LVjmjGOzgMnvf3A9+8P/D+7oimi9m/NIM4nPPFeG57HYbAu3fvOR2Plh1V1sFNbT2lVw1S3GnX+7rlQq+/315bw94tCFPFmIdyQ4xpQewFBhpxKNtnxvFe+thyPyzwVf6WBWT3kWZ3FnoPpB5PvNam15/F/t3b72vbEoR6z957V7r9Lc6g1aay77drsjPfq328gXtuEYW3tj8qzcVzbW9Rq3i0TfFwa5GXxV333zKUshYZK8PQPG9YL6rUJHQ7C7qlzq9VCd3asL1n94BQ5HrePcdV12ENCBspoLTbRGqzDiIN4doXldsp6QacpWvQpCUFsrOI5q7kl9WqxgLlxJGl1rFm8dft2uMU+fjwxKeHx5IF1ERkczk1iSFnbXp1+1+RscP5YEbpGFvG1F5s997Qe2p2L0N4qorOMy4ExuAYhoAQ+Pnnj1zOF7TYWMZx4N27e+4PnrGoi2qBe1N5lHcZOWMYPBTPIdSIyd048M27A9++H3h/H3BEYsq4LMyaUWKpQeDx5X3eBe7u7zneHS0QywAa1YUD39qRnm0i7BoKduCsVxWtzuuaujTP1OZampRcGQAWBL2CzmInW1RLPQyWTvtcFv34S+vxRJWgr7h09gngnsbhFrN467ktLtjiqVtnfMVgbr4Tar2L3H9hvzbv2GtrHLV7y1V7a/bZVxOFW5z7rbYV+ergrBKWs7D/G5S8vb/jfvc2YrsBpo/L+AAVIFfvzYq6/QXv7Q2vMRrf4hJeuzYvqadeklpeeldb//JjTWg8dCjHpBJAM1r03haZWvavZZWTJpzlLOAcfnBUewQ5tr51Y1O4zDMfPj/x44cHkgwg13nxvXclydwSZBVCYJ4jlh3UJAXbH9cIf0qZh89PHE9jk2BMxeRQnRmDJ8+J5COnYeQwDIzhETkIseREmqfMw+ePjO4OLwHnKWuUuZwTWSdccAzDafGSkRKwpcoQAu/vB96dHHd3gWEMpDlyfpr4fJ7I4vFh5JCF0xga8yzOCFqtH236ZCnV5KyehqaaTkSviO0ORFzBgM1iQe6w1LdQulie7vtehmjSYzuMubikbiR8V3J1XUXrsPN3uaq6Ti1f3JNFl1xezzFeTauw+e5qDd7A0K7GtyEI/fVte+4s1v674OsmSSzE+PpMPCft9MR2NaZnpKzXtD9p8NqeqmMr2t1KT3sT+ck117l6pmNP6jtSKaS+RaxVfN4b51tURzfH0t377Jz+6HY97ufuVF0TUCkYyXX3tPo8Yr7+draLeCudtK8d5wGkaLUfkhOGXIrCcG3M+93v/8BPHz4i3vPVu6+4XD6aK2oNCpNqy/Cr6OicYTgYvdEMXlxBxixjU2WeEoejxQfYXC0mwMmBTDbvjqRogrvjjHw7ktRcSOcipUjSYleRkkVEyPPE0/nCNM+EwXP/zhGGEynP5GQqMBEl+JEhCEOwGIeksazNiAsDU0w8Pl74+PEDYf6W8Zv3ZmAWh3cDgw8l4Nw3iXdPQniOi8w547Lryp5WRGtGZtGSR6/AQ6u8Vu/rQOkmChFhTla72oz+mT4RXk19Yu60UvIt6PqNnUCydV7qheAtQjccuJ9i+znO2sa1VknXa3vPvlZte6s/kVI/fGdIqmZPq2S+lnlpZ3GHENxWpdn/12o2XksYXk0UblnlG8agLmCPQer9fczAeoCWfqFjQro31yx/hWfdn/TePHUhACvE3xmmdQNcN1Uv6gonkwrmfGbxtQSUqRbPGdfGZ3lS9ghh9TravLNivJ2uajya1M9Q/SPbHGncXfWCoARadZJb4TQa11oPjmiZa1EZUaiEOFCh5qDy3gLW7DVCns+EMDDP2byPxmXMHx6e+DTNzDjCZSZHISUBCXgHqpaszh0GcoykaHUInAiipexmVUEUV1DvLQtqNIclUgJf0ilI4TqrH7mqcokRzme+Hk54GVBNBMQ49XFA08Q4WKLDnGGeEwMH7u8dhzQYVx8c4jLhGPCPM14VL5kgyTj6FNDZKs8JDjcIp+AJ2RGTI108j/MZ/1F5f/8eDxy9w/mRxWu9HHYobsQFnisycdKkhyt4aoxSz+tT8hxZFt6sxcGg+thvjdZVpdT+6M51yoQUkTih2aT9mi9pAdxc4MtZGgsfNudQcUkt861fMzjGbCzIWuD6DBd8KGr5wLbWtEVFtb62xwRukf+KaewJ1IKFyu9uzfZqaBeJWq9UYGJw2anTKuN2S5paiOr1vPqx9/NpOdboPMNeqYT84yOatV/wDash189VQJOiv1anJbVKWe6VLk7pLpW2XoC3UPLe0LblBvZEtqbFUlhcQfc3ZhldJ410HPVzz7ypNZGxSjYLDVitWb2VNafUj0Q3v6sYvqfBlsaZLE+o9sVcIM2TZXWeE1ni6vnPT488Xi5Ezeg0WVnNXGNPoObGqZW8LDZBTEWFRT3XSCtVQTThXSiV1pxpkxpzQqGnBjzV+JyzMs/Rai6PA14pzwmDc8RskXKppDDPOeMxDyEfpCT6s068N4nGSw0kVFKC82RzstIY3qKsnecQPMchkMcR8tw84ZxY4r2e275e/I7XrhT8uZtr063EQPP8qkRHZS1J33hThxyBnLicz6Tq2trgpnXc/a+EqpPE10LJ7jne4+jrnGpAWnMJLTiiSsR1DFd8VtfPcxJDOw+lv/5F2n+7w3lX/KFYXJT2722/r+0Jy5+bsXTz0W5Nb6nVFjz75TEPfwL10XbwpVVOtpzQddlKaZWP2nXtlnu1STXCt+/v+lCs+r/NyJs+uNNh3lIbLYYc48/sY5mUro/PlXGKzldZ1ihWC5DtDXHFtcgCAM/OdXP9uTmt7oWFU9zca3RnMWgt76xEukgaVReNcUTzPKMI8xxJbm1T+PzwyMPTmZgsB1DUWAISrSKZ94J4MSNmNuTrnGW89SURkkXRLtKCiOJFyCWGyji7hTIo166QOUUu04XxOJrHklrgXYxKjCYF1XTcNuNk6hA73eYK6opHlLMgwJylBKuB5kiMyjwqzkWcCmEM3LkT42FAgufo7yAnBgmrvdqmSNjhCanRuXutIlwKAa/SQe7OqBZvr4asVsDZddqkDTqkbmuZs/L4+MC7eeKuPrrCnUuQ5W2t8IIwr4lCN96C7bcwXZmcvhTu+lzovgTe37ElmtvvZf95A7OFgGwJXHvXhoNfa1n2CFRlegoBWA2prmliDzJW4++k6i9pX1yOc3ttO7i9xTQkYp4aKaUSLm9UM+VkLn/FQ6kVqfnP0G7ZPqrNY9E/9sAmTVrYA4QF8dRfegXw28+V8FxPs7pjvn4+lVO6Gs9OWxEquSYMdUxXus1+gq0f+zsXA/90uZjkuoGRDw8PfDo/MWdwMZlbp691mG29UorMk3kfee8IzhN8iTQeB3LKxHk2LZYfyliycfCaEEyL1pszxnFsY80pmz3i6EkpM00T5/PEPEVLVZEdThLiEi7AYRhIOXOeZlRnEHDB8iClORLTbFKFg5gtG+pBlHlQzpdkgWr3B96HYMZ6Ne5RFILzRtBy5HJ5IudMya/arfBOBgFx+9cpNoVOmolackPpGmncekMVQpr33h7zUcBhmqZSFc+Szohs3qg1lgAqorvGE8vfOeeSYZbVPbfUPikl+rKpJrUuziu38FC/DltV+Fqb0U25MHp92zOlrzl1mjF+sa8tMvo1EesllaqSrXPopfhljYTrd9hjHdP5BSj0T+aS+pJhZqu6qM1KFmZyyRmzzYD4JYRB6WKab4imz9kUzF3SPFxUa6K7JWIXrgtWVAng6lob0xvGf/2q1fv6r5Y0H2si8uJ+lB97ksK2z6ZSK1Kb81YRzb4v6oCMRTUDj49PPLmndX+HEX/KDAl8XCI31+O0CmeC2ZOcAyHjvYJLFiktkVDsEJg+BHWK9MFtRb/tdeEmq2SaUKY4c54m5jnx+DTx+fMTCNwfB+7fnRjHI0OwKONPn58Ai8D2wfIrCXA6nfhWPeHxzMPTxYL/YsQdDhyC8O4kjMc77u5OpEKMjChYdYLLdObd8Z77w4Gv7u8BaekP6klRrSld0qL+Kwzk7f26xX13SOsVwHjNpxTJVUsaDqojQILGvW4Yhpe7uRpfY8bqNbeWqrec/Z4tYE9NdMXMCqV87Lbvlxdnjxj0v+2z/dhKCM97NjaurvVSCd5rNm2Z66tuv9nerj5SihhTOMQWbLQMbA9ge4AGbYe0BYU4h3ZubpWTyLrYop7jgLeGrDdN6SYgbAFwEUm3OZcqkdGcG0ZvyLTu8S5h7A1B9u3CRVyP6znOp799C+BX4nd3+613rg5WgbSaaqK/t47VpcSc1nEotc3zzJwyWlQxhtjs2azgVE2lkx05mbQw+IDqBVCmy1xgwdbHEu9B8I4gnsknqo1DczWYy/pASrFXqJLyzDAeuXvncX7EiWccM2hkmieenpTzYwT1vLsT4jwTo6WkyCLk5BmD5zSG8l3Ci8M7z2FUTic4ngLn6Ymnp4nLeOAO+Hq0JHiDc6R5IqXZclFVXNGnqwbaYr2wZ22fnkNqWyZF9m/fjKBxKQUCQJKpAWMqsCDttvb8S8zcBpnXs20EfPnOK9SsiPUIbaOZt4j3Nci9OWQ4McmvDesGIYWmTtojUtvP66n2Twi9c8maoMhyT3d9iwtuSTv9vf5qE1/f3hCn0Ik2bVBauE1Z9d/0YXbyGzD3njHV2JJaDn9diWlSlbqy50Ja3nZFErtFZfvMdbvNTXf9KKCpicHSf3tFpKpv//J9Q6hfpApbi7e31HTtnnarAdUicnZfd2KINtelHcDt8Uvd4w44e+8J8y3PTNOZyzkyRyXdbXIfJcizVbOLyRNTpN8jUUEj1CyvdThOghFaNbuOcw4vEILd4Ap2c2L1FFLu3FXL+CyorsJqdc90eBEGJ+QgRfcuzOdUUluY99P93cHEoJLjiWzERkQJTjgeAkkPfP70BCXmIAyecfBmC8lmG1EyOc3kaWYexCQbsRgLc0hIgDfVTdksp2o5lSoGb4qfW0hvzR3vIY/6KqeWPfZKMaK0K9VQ2uClQJOqFXfKMaIpFrjwNNPfRiUpHXytJE+lldrcDOGKcao/s1ryx1wYxlRSmtd3rPKbuaoCLvigStRttep1h2he460G5yzqnMJU9FKQdj+3a05e70MdR/Oia/u0rG5jALp67CrLYdT+UO4QhMoYqNSqjcs4X0sf3iQp7HGwa5zYIarcbW7VUcp6YYzjTl0IudsMXIuYus2Eei0freBKbksUdXyvuq4V+TWSthCHdm91U2VnTJUoLCPuCUmvw1/G0HW+01RXN60lq8pldoi//7ys2kLgb82bXi/bAZcUyUbACHshCkpknh6ZzpGUveX26VrKkKO54kX1zLFENDtnqqAs5FmRYOmjRcwpwJcyp86Zaso7h0ct3xogCXCZgJBwzKlUTdPFWyPnkpahzic7S66YFQ+MTphyJKdgOfQigONwcByP3iSZ4h1UjeC+eEwNg+PEwMPnx1LGUwk+4N2AZssPdDgMVohIlBwnogRLHCcU4pMQtUy2dtZ7iVLaP5XKktyAX9ZwsfqP0nsXu0rkdbEvXCGOLdyUGyzJXSEKcTYjjg+NcWwA0p5extXqjlAJ7bpVYrEiHpUuqhALMch1jwtBWBImLpHWOMtKa27ZdQ0LvGtBqhhzpM2JQVspy/6UqAjL9Ko2oBKVLi6nwZ0UolCx/ILQq+G/Y107vGr2RNenTW/v7de2JxJawLsmB7R1We2rXJH/m+2LvI+24tke12LwtOPTr9qKssDtnCKNAtZnbiHCzbVye3vfa3SE23lITeLfc8hCk27W+ZVslJXa70kEuXL8m3nuj70jrM+s6/Y5YDdJWn3X7vW9/dk03UzJuKTqWVK5lRK6n4UwjIh6XFgThZytPKU9klYpT1QVFwTVgBdX8hwpqomsmdNhgOjNc0ws8dw8Z07jiAs275wyh8EZV59yCbzzxltrIkZzaTUdrZSgs8wwBA7HA8M0MceZd6d35gkF5JSYpieG4QA4Uk6kFM3ziVACvC0I0DKBmwQhaNsnKzcqhGFg9KWEawYhlWSAE5rmgggTZnUoxLfyqdL52z7TRBdO9kpKMEBY9rTD27ucese2NiS37Caqyhxn5mkqOMpiO5xTS4kiNa7peQ6177sajRuqrOPt4LpGtpOLvOAqQxTRHC3GpRihL9PE19/8gnHwTWLxRZypEeOaMilGMwrbSd3E4td+ZTWZSqwMMWS0ZDY1xGwBfU6N+FVBxQhHKbhU2U0BYbD4pqKezlmL+3MlCvbbidU/aeuhIFUSLvZPCq6JOS08oiwM6WvaH+19tIe8KuJ4rlWk0OsGt14GCsSUGGThMG71WfstN7yJGFy3ldjRgL5Oad+2IatP/Ru0e3b1xDPj3FMb1cN9k8PfaXteXG3dK8fRlm0rwUhR5XRSR5lgU3WrBZc5FwhhJOfM6f6exzsBPrQ+zV9f8D5wme0dvlWUsdgA0YhqQFygGjLJkTCMHE7Hlon16fGBwQmH4PBiqqWYTUXjXTLvJJVSYKcm3DNxraal0ByNkwwj9/cnRE787ve/JecJkRKDEBQfsboT2da91pW2uXgjChHujifSPBOC1ZuOMTGOltKlGpmzKllcCdaDcRw4DAOh6tDbT0ulnJsBNzXEsIWJ9b4uRGWlVihcauVmcx3PM7xjvS5t2xfCIJqRFJkvT1wuTwUWqlqrBNypso28WNv9rsff4Jwl9XVV1dS1EQRHQnNR8aUEceZ8PnO5XMg5l1rcF/M8S5ks0fZzCJ2UW1TYOZFzZE5zm++WWarShBROPDUCYO9wlRlUk0pN+xHQRl2kwF/CysjOLRGkRYWb23N1kJCqWk/J0mLYhhYVV27vE6zkrJa9rOoqwysJnNhazBNTnHH+mViYrr0p91FdiKvv6gbL+uoW4npkWpH8NlnT9jc5kxoHcf2evdbzNWtCcw2M0octXs3L3ta44q7lbkxVhOuBuh+r+dBfR2f2z27Huv17kZxkRZyWkQpbR8Mtke0HZ+oE6ebZv69KSa7NVcQkPIep81ALKKv+2oLH+YFwyI2D7JvzgcxEmmemGSTnkrk0lLoOiXEMSBYLZtSE5pl39yPBCZ6Md4KMHkkB70394qkRzxlECRXsnKBOuEzKnGPhzFxJ153Iw4C6hJDwLnE8Hbk7neyw5oQmM1yPPjCrkMUysIYQTBLxVkaxaqVM2694VQZvLrXTNLetyUlJKGEwo7vGyN3dyThrkgXM49YlSyo21Fp+brETLXu+tKpFXvazIK5Oz17VCw2uVmqIrs8Ka/1gGrxkVBOXpyeePn82x4CuvsNWdbUIt0tCh54huZKSW79uZ4zK+emRh4fPPD585nJ+YrpceHz4XJBsIsZIjDOiFjvTvM+K/WZKRmRTikzTxOPTE+fzk0Gx2N6Zk4MxK7nUCsnOkefZ7BhlgW1MuRHdql4EKdkAFkk7a0kkKJ3dQ6Tlu2qqsLIOtYphk/Bytsy9JcuwlrztDX9qPdeY9FKYaTsPjuFlHhL4AqKw69VSN3ilZ2D99wvv3e2L8o4bIvFWFSMbJHf1zg5b9wi1V8n0bRHyan+L99Eucu9xtL2g/L2fm+Q10sz1PXvuhnvvWYL++rWra7oYjouiYseusKgNhBYyLBahi5NidK05cGy1hsH06cO4JgriHMMwIAKJDGkiDN5KVDqrYOWcENzQ6iyj5rtu1TlNLeNEGMdgNQlUSzYOA/jsnCVoxYaaUyIMzqrB1cp2IkgsIrhaMFuaZ9zpyPF4z3R5KoTXxHEvi06/rmWmiOSFOJrNo2Rq1WTqiGjrbHpvscIxUpChCFkTYQiE4CxdRKZYzRcrVkWP288FDV3t+5a9WQyP61vl6snuixea4WVbv3meOV/OXKYLRx/I3jXmR2tZTZXG6Wo7a8+9v8jCjVkSsxeUa5fpws8//8RPP//E+fGROF2IMZLmyZBgUR3ZGBPz5VJUM9JyQqWUyGolYGNMxDhb4SFVYs5IznyugbX13DoHw4BDLDalrKtiNrDabyOGWYsatF/Y8ozWNCD2uZWw1cW24ZwBS0tp4wTwbfNclRZqiqm2q8UuJd6kChmoauu8v+tX7c1ZUq+Rm8ANbnttdd/nXK+KZXTPbd+1fd+texfIq7r+5VIbaVnDLR6/Qtz9l4UgWKTsDmGy00BTnlUExVq66eextRH067NVq+1Ja9LNtZ+NNJZxPcPK4QBUe1m1DVwT6IVXFConYu7DIrYGRWlQSj0rLgTCcGAYhtWbnPOlwhiEkua6SX9GaUlZGYK914lD3GCFcMiFKNgsvPcMTky/X0bnXUkuJ9oMkagSHARXnpaClZ1DcjKPp5SY54k4z0agRMBbQjfVXIhMMVJmZY6xkKdlbV3hLlNyJLWCQjFFQhjKQcfSuVQE7RwSPONhYByCzU8jSTxaZA5ZKXeUxUyoxWgo6ObMFfAr21sBXOEVfu5VAumgpAcD+uynWghlzolpvnB+euB4vKs3lheu++1Tta/grCBWqXCgPWHIII5MJsXENE98+vAzP//4I58fPhPnySS6rHjnDVmLM5tQkJJ1NppKR83TS3MuKU+iqaByXWeTCEiJHGemaSarMoZAGEKLSzIVtrSjpZQEkpR0KtVl20HwvmO4pEgWQKmymIsU5yQtWgcocGcV7FwhCFIZuR7vUF2vS2R/E/bE4I2SrLDgkjmuU8/cal9EFNYFLlgAgee530WqWJD8OI7tfbGr3NUjwFvMRW+TuOacF4JgC9nVa6a7TkFqwg7SNc54cbm1zRWtdRlgG2yXKlfrGlYG1jaRW8StJzJ7a90G3c19tR7U52mHuOcy+9bWuSDqeiirQW45zCXlBB4tKpnUF2t2UjyCHKqDBXHJTqlIccRZyXE2g5nlpiYlE9GTs1jcwRu3FbxyHCyiWVMiODMaU7j34Bway56Ucdl3yfbUCQGPqHBqmbaLkdc70GgZVzUSZ2W6PJVazEVEdw5VZ/phLJ9TLNxgSlZWUlyw5IeqjMPA43nGu8H0wGIGV3PCyg0ZICCjYzweGQ8HxsFqQof0wHk4kXEEzbhcLQqFQBTuVLXuaSnv2TXjYguxUIEELhsi1Fw9VDrXRRY5sGx2Y3waQ1Own6BFYFQSdwQHkEjzhYeHn/nqF7/EJeNwK/w5DOHtxQ1VpFalOgPKQuqcwVUu6WWyZs7zhY8fPvD7X/+ax8dHnLOId5xv77rMkxn9Sxpy1ySHWDyLBBWTIqTkKq2FluoQkxMYPMFbQaRhCBwOB3wYyMVt2oXFHT4rkDPe277kEmU9hAPjeDAVa1nhagC3IMjccFvl9MVv9nMT6Nbjg0WVB1JKeWatkmk2u0+HzxbV1svtTUShtwHUayldi7Hlicad7xvFDAHN89ySiw3DwOVyad+XD+u/b7QVJ74SAaQKVS8+v/68FwexeBAYt7tHkEq3HWptvPzm3uXvl8W6SixWzP8XNJHqgaNkTY1L78e010Fe5J+rZsQo481Pk5QMgfbt6XzmfDkX5KIMLiJF9AZwLjOGWmehqFzcgAuBnGfu7u5AM5fzEy4MPJ0f8EjhsIRUmABFiweTIxf12eEwEnOZQXCkOUKp/+yc1TnwIXDnBmKKK1VgjMLlcuHpyVJRHA7HxjlLh2i9FwYBoWQOVUFkZBhgnqNlgHWAJhweb2lYkRgNvWsiWBY9zJYzlBVfR4bDYr+4gs2KyLMhUnIq9hntjsPCsS+5+3flg80OU8ZVOV7FqSPNiY8/PfDLv5w4+CNriK9Pg+xcp7uyB1lGW6ywUpzMHhXGgZPcLedBltQ4Bz1afx0SFF/VRiYRKIIWnXx/mJw3z57QvVfEglRTUrJGxHmmOHF/uG9niKw4H4o3scVqiNTzv491cknHAcUKuEHWe1qRft9655G6fzW1hYOS1bnsVbEzhhB4Nuli115NFILzrcBJztkor2AcYu58oTu3zdr2kGZPBfvCEs+1VDiRzvZyU9XU91vd63QDl8vC2vfXbX1tee/2+WvCsFftqALrtfrrmeN4Nb991NxE1E1ftb51b6zrC4v341/Ud9cchXPVW2PfKUCqaqb0xmbcmi3V9WEYQIXT6bgC7iZJRQWX8aEYdXMG8QzjyBgCx3Hk8+ODEZAOeS840uwdTgRfhpFVCMHqFOSs+MFZxtRpImtCnDBF5ZuvDlwm89gwjs9UIDnOHIfB1F8+EC+JORszI0BQJSqMB0uw572zNBllzcLg8N7hvOAChMFxEDifn/jd7//AP/zjb/gXv/xLRp+JOpsxMiu402od1+rVnTOlFHdFLehAqGmoFEhUJ4FeUtiBpsIo9Im8F2kClGQUSEDzzDQ/dtkI6n7TMtD2BubtXKQfQQfCUsbw+PmBp/PZHBcUwjgShoFYJd2iJvMFL8U0m5pIzQUaLF+VYwP7ZQ1yMsnSSS1qJKU6nmu52aR8N8doEt645IQfqLVATFUjK7HDYmaqesyLK+O2YkTN6C+C+RjIChVs1dN76retJmHBqxUP+3213TPt9S6phaOtPrJCBcAOEZRB9WkQatsi6j2ueff+7u9a4cu4sK1apVuYlSap9FO4u32epFLbfozLAdzq8E3VdD3ungjZ0bRAnDqgfcK3HKRtf1uA0EKI62uujP7uem5a1qBv/bv6Pd3OvY6nqbNKllgHJaq3B7aFF+w5034ktexliub50YvDKUekxCmYrrQkU3Nw8AMhmCQZvCOmyMNktY8t4LEuijEMdWx1OWqwlk0zmzGxRLuCkJNyeTwjX7/HO4c6C2zDZSTB6XRsiDVjMQmkkn9Jjdk4DCOQOV8uOCfkZOvhfTAEkB1zTsxxQpwwjgcSjh8+febf/Pu/5ocI7v2fAcL93R1ff/UN4/33+JGWGXa132seYNntsn0Lq1Ev2P5dweCeoNrYd1n9WRFYs2YUY26OE2m+oMOpRd8ucFylqVvwv5mBLkQNNU+tx4cHYoy4AgMxxs7d1SZQYSkw4J1HQ31fzwXamXS44va5GJ57F/kKk/VaGQrDpjbC6pzmxX277ZMXJC+qVhVzw86b80XtQddbusWRt/Im7dlq64T3JI2X2uvVR65OXFaIovRNzXV/i5O9RQR231cpZkHAS6GKInLl9f1XtoAOYa9VSssJuOpv9/rSZ+unvZtnnmlPsJidOxtHe291Ndw8tZnP6v1lXVbzvR5q13LHwW9vX1RCWwnmxsue+Ua7nzteJkUUn+dIjJmQE06s9nHOyjQlshMGZ37fVvnM1EshBLwLhOARdUzDsKjSuvEY4JdYFgotFvPgaBGpYhlNq3utlMJBKRbjY0unYZKPJeir0nGBbsGMe64UUkLwwXE8DmSNOKVERpvx2giQubg6l7m/c6QsnMlcHp74efotH+OMv/89pJn3pxPfffs9X//Zv+D7X/05wzgUlcBLSLWcm4qFt9tTvlvBjfbQ313b7t/q+PRIzbxn5mnieFoYKRpjsLZlXMNF10XP4BQniMF7Bh+KvUHAe1y2eIzlcWmT8MUWVDkUKZXstn3VWABU8aGzW8oaxy3jUsQvtT60aQIKraxBuHUspUPn12k8RAXXGDLo2aeanr32uUXktyrOXREFqVjY/m81Gy+1VxOFPnCs6tosXL2ktCiyZuUSe+6iUcbKbu0QghWCb5/t8K5rUvSblcuhXi9kW/MV4epYqG6Bem7G+lobuvcOR0X2vZRU+63bXOehgORasrA3Jm89o669jLbr0nMtV4Roc7Lr980+wgIsVZxdDupaeusloX4MVfKpb1wBdLujOxxdE4R5Mt1wBu7GkRwsODHGyDwnoleSVD9/WklDGc147Z0vRMI4xhrJbPmFHDhtkdNQEH8t2iPFXVI8c6r5iEpVPTGPKlMn2Vi9NyZIvdkgLH2CpR+ISjEgeoYwIN5ZuU7nGIYAsxKTcp4u5DkTxpFqsD8eB4SBp8vMnCKxrPkcz7jTI/PTAyEl7o4nvv+r/5L/8n//3/CX/+yvOJ3uzBV4gQD2m3ZSAgtXX6XlnSYs0kh98yJJ1s9y/b0CWckxM10upn5pzIsuv3qp4RnCttjNjIB757g7nHDvhfPlwuVyMRjMsmKnKg6o0cMiQK4qHdflFFzGpAUe0JLksDJFlfHLZc5OLDpeLUgSUdRZn1LGXAtCtXNbFklViutoPWvlbC9uQnaKyp++SLxZtaut0TGsnSagMXO6dsRpTFlV1/UE4U9NFEKwYI5qwMnZDuOUleyK37fD3MdSwqmz1MWVs5Wi82zVuvrAtZ7zoCEmMI6rod4OgdUgESWVsnylH8MAjQhoeW4V2SuL940RNpBql+n2oj96Va2ijes0jsTgcbmzudd1zxmhjCtEaWuwrSPdz205JP27mgF7y0l0B7d+vxp3JYiNm5HCEV7bPRqR7L5TNcOqPWqF52lGtdKyIq6E5+va/S2mklnUe8Z39swlm495TKYacMHh3MB4GBgGTyKTL2emIROnEQ0eN3pCEI7HIzkZMtY02/hUgYgrxCky4CQxDgErBOdhGIj6sMCeAyeZrBM/f3J8//XXjH4kq3JJT+ZtIx6nI9Nl4uPDEyKeEEamHIlTWnFwp/HApDNP88RTCjycL4zZ6igE7yA5/uEff888nYGMD4H7uxNyOiDxEXGJc5x5+PjIDz/9wP/2v/0P/Hf/3f+Vf/Wv/o989c0vSWrePIHEVaawXH3f1x5GFRFvOcUK7n0xeXVLhTnf2wGUooopSI5ASXBuBvfPD8RfVEIsLSI5a8RLMAYNEByp2WPMSWCl4ih/a/BEIAcP42DeNJpxU8YxoCxJDiujVnXylQGq+aooTJc2hq4ugDRTRx8cK1JdOkFzPc9CjQYwd9FFIPM+tDPSr3clBrBB6CUwbrV3/Z5lZSnwLFCI3ULuq9fWiqu0mAowKUqG7qs1A/dSezVRGMeRlKpOPzfjsMaMS4ksJdijDMGpieXGPNuQkrCI7Ku2cNx1gapdwlXOv7AGyzoYgLbkVR1yavkBK2VmvYBKl6lYi7tdu1gtZHuEdRmfaWRS8fXvxc0d5Nwj1p351r+fI+Q9F9/vb0/cViqDOk9VWi4nFo6QHJdVKIdl2ZZNJzWytKy/eLV1Ks/1rm6SbS3yBujRSCIxO0MG6ZKptZ5Vzb0yq+fsZlJOTBfHIcBp9CQZmRNcYiJ7OzghBOY0G7dWOGjnHIPzhbPPqBiDMqkyhBFVq2MAxuTQGALhcDAXwiklhkE5hIDGkd/9/ieeaubU4hUVQig5fyLjEBiGAedcK/oiUFxoIxmYJvOJD15BAtMcuTuM3J/uOBwOHMaRBEyXaB5EziE+WO6lOfP//Nf/GuXEf/VfveNwOjIV3HC1xLp4YNnOFK6zIfIVu7Kzz8t30hMEFqmhtqzRclwVSeDjp595H8/IYKVFRaRUeROcy80FeU8t0o+/ob6akqODb+89c7v3Rm3zm61XC12vXbtrI61v33/LLrLVeNSx9xqWl95RnXjquVieqfu0MI7bd/YMr4ipbl69NJv2JpdU0/MK1ee/hWFXZFc48GaK6jmA+nnFwa4JQC8xlAvkRsy3m4NVmWrvKVx64Tb2DMD1xsrTd6SBJhrcEMu3ahbtrl3r9TacuhZjbrvFCo6v6uOqdpLTGoD2DpKIuWHWUJomznd9LqJrXj23SAI2de0kS/t+my6D1fNNtaDXAF4P8RUnlEvKAAW9ZFwyfXy9L2fH+TLhfCZ5Rw4BsIA3nhLOTWSBMTt0npkuk8UOKGRc40y996RoBAGvkECLe6qIEEaPTtIyp1ZmwlRYkTEMjM4TnLN0FJmW6yYEj3OeeU7mvz6MhOBaoagYI+PxYGm8oxVxzRliyRhb0yGP48jpeGQYhuLGC+fLzJSVpJV5yAyY89UPP/zAP/32N/zqL/+SP7v/K0jO3Bq3kgLGADgtoW8FhzTYWO3JWs1kA+zhh8LM1dMiyxPqUDHduMFt4uHhgenpiXEYzB6TsxnsOw64wnGM0ZD8jh9+jzPq75qm4tpouqc6eV17jpjc+m57zm89W2G6VpLbkwpuvafO99rO+nyfV+MWNtdeTyHelBBvr7hFBQwLLALL1ufQXHxnrwZnHMw1Be6jLvt7y+eVhFAvXN9/kxh03wkLsVlUP/1zSxe96N1Laz1nsB1TNYRftUp7lOKlsSEe29tXhGghRpUIyBeeiJUai16gXgBoOZ+LyLodW3vf3jpvxjM4zE4g4JLlwTfkY1Gy4ut8HIon45iiuVBe5omswnlOjAFGl61ofC6RvcWCXHXEJiUJMUXilMl5IgRzFVUFjSVRnitjz0qMZ+YYOR2O3B2PjEMpFStC8KGoRcxoeb5cOIVjIQjL3C19wuLBIlg21jmZUbpATMv3pGpRtkLirMqcHI/nye7xDhktZcH5/Minh488PD2gRQ7e085r97OqYarhsfqWrhBNE/0WNsl03AvjsEc0egcF+9sSAD4+fGQcB2r1PB9KVlitruqVa+5UuVvQ0uXXqr52aX1W5W17jdTwesnibfdu77923Hj+rPfff8lYesKwfc1b5/EmQ7Mgxfe4cnd58f+F4jFQPDIcXUKoNRddLeMVQI27rJDbEwRWKX7rp+V919b4l5Cr/d1zPsAOkXp2GXUdDFT7uCYuaw+plcDSPhSkeIMrqPaQen4rMhCRZW0K8q5EuHEZLKf6NmAsZEE6BLEMcqs6WHtRbcfdG8P7dhwcY3CcEUJ2zMwlb5Fx0OI8wxjMBuccSQ3RTLNx2XOCh4sweOX+4PCaCDIU4pXNIJiWovQZmGJmuiTOl0gIVofZOyGoxTJkTSAGjZdpIuaZwfmSUK3U+3WOw8GIggIpGhNUOfzcqTlUMzmlllFVsCJSVkiqwFxJYaA5kzSj2RWuWjlPnsfH+f/T3rstSZIjZ2OfR2ZVd89hD9zlUhRpokmmw4VupDu9iZ5BD6Yn0hvoRkYj/59czsxOd1VGuC4ABxwOxykyq2e4Vj5TnZkRgMMBOPyEEwDG89OGp0sIS72+vuLl9opbXB3FLIrQWKCUn4jQpvT9qLqSmUOIR611TyvlCKCDcYQl9QDiklbh8TiHKHwJJvzw53/H5XrFwQeePn7Cxw/PkAUJeo7jsl2zwZHGjfzMk9J52bkYGv2721eFXwu8UE8/5JXHXBWudvDOvitC0nXJELnRq0crDNaDeaWg5gEYjP04sF0uuBKSWxqYagthIJJddWU9LhQvLE/GtSgYxsFqw5vOFJ9QpR6UMCaoYWDdat3YQXBusWwRYQwWjZUxkE9HqqvXySl/tlotVfk7R4uuZhSOA1H2fYTVSmE3JuJUalhqGfERUmhOrqGUsJsc3WzpFXddZD9D0ulWpoKe3BaaySjVp8yV4ftvPuLjdcdPf3kNyz8/hI1Clxh+uT4Fy/n2mbHv+Uz8p8uGp8szbp9vuN4Iz0+EL19e8PFpwxMRni/h2bZdwXzB7fYl3FPAB/i4xDsQLth3gJlw/fY5LngIG5cOzkL9++++xbcfPuECwnHbQYiXtFwu2DnsDg4b08KZOnJYWTZswm7q/faK189f8HrsuDGDiXA7EG6k24H99RU3UDhmY9twxPjvv/6XP+O3v/vbcJDb689gPIWJdBz48PyEjx8+hHm9Q4Rze6CHtRbZi5JLZagQYoE/s1HG8XgOSooVh1o9uAc0G0V/hRE3gR24EeGHf/8zvry84NN33+O73/4ef/ftt2HDX7y/Ih6FiKcL8PISVm9t2xM+Pl2w7yH8dr1eQZcLrtG4DLx4S15y4tu4KqjlIbu8PglurB7lRjEZK4hC+0JySoDyvpKrFZQcs55fKI0roVPKGB5JIYagkYlZbtXKYHayeVop8NMVx67cwMsG3nfQ5SXcB3rZQAdwvOy48HPYYS+TxQgXkIDDLssbZDkXgGKzixL2UUAzDjynht2jtROq/BrrKO5qdmrFPspqZGfChcI6C2YVCgLAFJYxXmKOAxxn8uPQUPwkcxb7EQYYaXdWBpmcdxLHbbDTnkHqLEMRrAcF4SMXy6iCoLelh7aKoRW6Kro4sgbjCYR07prQLPIAklzmXYAdT7GO2lsIt4flM2EK8zOSmNdnI+l/DpY/hcns3TDgP/zue/z4zYEffroB3z7j+6dnHLdweNh+A37+suPYCQe9FAP5+vwBjLhhDAe+fN7xl3ie/6ePH/Cbb57w3fWKL/sNoCv+y483vO7Bkr3cDtz2HR+egG8+fcDz0wXbtuPLC+HHH34CXeI5OfEP2xN+3g98/stPoJ//AgLh44cPCDulwq7Wl5cd//ZvP+F3v3vCxycGIYSMnq7P2G9XvH4hfHm94IfbFZ9/fsVtB26vQdi+7uGOh2+/AS6vwPMVeLocAO348+cLXl83/PjP/wK6bHh6fsLPfz6w7T/i7//+v8Xv//a/wW9/+3tctw23A+C4cqeAS1j+Cpb19DfI/NINO3Zi0OUazi3ieCAhbamvmGOYi6JQ4m/w3XffpQl0ALg+XfE5rjq7bHn/yPW64YWecXl+wvV6xXW74PZyw+XCOOiWjKM0d8ZhQcged4zfjh3Pz8/4zW9+h9/85rd42n6D64cLcAGuT8B+ELYdoJvIFMLOZqHFA6DphWxRESmBX9hJSaDFFafRWN1YxpbGe5MM4R3LXo7y6OwBpeovAMdxrb39vZpPHMP8klTawZcswI/o8t44XMO34cAOxisRtiNU8AIRonkiOixkCwdRBQgnRBLv2I89CleGuBIhPBFXzygNyACumzT1kSxdUQQ5ZkkpZJWu01PNmSaCESceDwrn9suyVr1LmHTZyGVDyCNc9iBEiZDO9SEC9u0vmRYK57Fs2wbaw9WQcujEFsNMBx1BYcT463ZQ2GELxuVg8EVU4B65kIDtEo4QI2mPuDpr01oiEkSEp/3HkI9y/JlAoNsVsg47A6es4VMmq0PD87HH8GEIF1yMpfP999/g208/Y0O4wwC4Rm/gSNbV6ythuxzYLmGQb7SFkzCZsNGncNTAl3BLFvbAg0/bDVfasTPh8+uBn/7ygi+v4dTI7z894Xp5wtOVANrCgXf7gZ+/AJfnoCQY4fgUYsbPP7/i+cNzOP3z5QWfP7/gj3/8G+z8Jfz+suPz5x2ffzwA/BnPzxdcY9z8hx/+K56uF+z7j3i9MQ4mXD484+++/yYsx+WwN+Lj9Rnff/sR3377EcftCy4b8PT8hI8/vuDTx0/Yo3D89PETmIDffNrwT//df4/f/v73+Nd//6/44aefAL7ixjs+b58LvfCHf/yfAPoEimeJxX3coEs0MOialXkcK9g28BZO8zz4wJZWmh2hnXGECfF48BwIuNCT+NbBoNmCgbjLXAFRyTv6RzwmPc9Hhj0kP/30I44DuFx+wmW74sPTJ1w+PKtS5C8aYVtYFv4YVVCDtdwltFVBFGyUM+JCynNW74slq1wgmFIEXlirPL4BeoAmelZhWinsFLVaXMWM7YKDd7zuQWDzRtgPQrwrCCw7+WKcUvYriGUuYRPQhmMj7EdYLw1ZpZNCIQxgwxbvcw1CM0jkC3bc4rJQILKMOmlQ5jQ2jiEUMZsRVubQFnc+pvOaojuMGAPeNoCv2OIVkSzKhYDLsYflg2o27gLCq6ySp7DCSBj42DZsly0J23AvbDg7iqIPoRVX8IrCWuyNgGOjuPmK0iYtIk5H6wKE11gntRI7HgwXFa34loihi8tTKDnVLYT3QHH9uOr/FJuMDcVg3G63eIQE4p6FODcCws1YJc//A+Mfv/uEj//xR9Dlgu2yYb/F8+cjvUe8aCwdF4zgdYEJl3jW0b7vYbkiMy7XCz48EZ6fQmjodT/wejtiDH/Dx6e423jLyjbQLZZu6KsjrkVnkjOSOM4r7Pjmm484+Ip9/4Tb7cBtZxyvwNNzPM8oCo3Pnz/geo0X2kfr8PIUjl0+OC8MCALviqfnC479GRsFb+UPL8DT0wXMAe/1uoMRToq9/OZf8MOH/8Bf6ILtCHdWH3zgL/yvWeAS8M0f/x7b9ikqeXUGDhEIsi9Abu+SM7EQQpKRl3OvM3C84tgPXK6XPKcI4HJ5Sqd8Jua/PuMqv1lW56HYqCVo9Tp+ikaJrOD68uUL/nL5CR+eP+Hjd9/GjWMpa+JFSv1p+NOxhs/MNVSTxOB8HIzWrLlaHhYlyySEVDoXI2WQveY5ulvhsjeZU3j6/veQ+OMRY75X2oD9mpbaHfuB7faSwghykTaOuJ/hskFOlA4TqKGyYTngC24vr3E9crBUwwT2AWxP2I4tnisu1ihwwQ2gsILjOILre316SnFiWYHxdLnkg6jEk0AMUR1h+R8hbGPHwZlGIhx0xfVyDeGdTfwQxnZ7iZEVTgcCbgDw/AlAXBoYz+cPruc1bNghAvgIQ3NnbPECng1hww+/hmsYN96x8S2cB0dR2Me6Y9vipOqO1yPstCQCjqdP+R4DiZVjA12yUuC4d4S3DbfLNWxQonCzWBD4VxSLFRmp7Mhd6fCw2/6ajKHtEnePxmDW/lyeknr5hwN/+ocP+BM+TDPnXzfIVZtAPjDupt7lS4q+4Ed8mcD49O33uNInkctIJ4NquZziiHmn7y59WIRgCBd6SvtAJWwIIshh2CF8Ent8u4Di/ZOs/hLoCVRDNxHh+fk5nkh6w+cvn/EfP/yAv/nT3yZElUKQ/6i9QMObHJ6Z7HVBKTORP2LwSjeySZ/SJgVaIDMhpTVINBQFlp7EWcUwrRT+/n/537FdgP3Y8fPPn/Ef//5n/OFv/whcPihhF0jb9KXY+47bywteP7+EM2yuF9AWlgvKOeCvr6/48uUzPn/+Gb/5/nt8+vhtuCAjHiD2/PwNbq+3xADHseP19RW0Ad98+w32WzgqgYjwzcdPuHG4v5UAPF2f8PGbT3h5eYkbzbZE38stXJh+iRY3Y8P++hqaN4Z4bq87rh+eQRTuF0YUhsftFcx7EJBxkux2e8G3f/r7sDJFvIothKNwPIHiJRyvLy/gPayY4W2PacIg3W833PYdW/x7fb2FM/7pEiwwPsAbgXbGy5e/4C8//ICXz2FD1vd/+nt8//1vAIQY8H4cOPawb0hO9GQOB5FeQNgvnyKjhO372+USaXxBuO83ZNiiUuRwAh2etnBkxwe6xNMx80YiigLuCf8vNv5nHGm70Tu8JVwo7MKmI+p/sdZFKOEG4IawKe2CDS/R4o1XrB7lJsfAuxdcrvn4FgE5hpyjQNwkIhBvq2Oi6PCzWq0YhAOJ8YxSiD49XbHvYbL+5eUFt9c/4+UlyAyRu7Rt8ZTkelmqtwIOmBOEvTSuJS+TyT6y6CnZjaqhTXuCHBI96ZWNst1yGrvCMs9N9BShB9NK4dM//s9g3nG7veD1Lz/j8vwjfvtP/wTeLsHqldUMwQ2Ibv8BCTrJJdYcl7UFprgBBHzkA9/J7OgRnNuDOew03Qi8H7jGeQowY+MDLz9/xs8vr/jmj3+DD8/P+ERbWpDwKcY/ZZXU6xFWPex8C26vLCOMwmw7AGLxIuLGH+ZA/3HDLS5dvIXtcuG0w7h1H1uIa34gwkci4BZWtMgyPDk860qB/oOBGxH+v3/5Z/z+93/A9uEjLvSEJ8SrJJ8YuAC36KkAoVK36CoffISllHs4OO6bP+74DiFM9OVC+CE0cmxsmSpnXKPnxcxpo5dYP2lCnjlM5Vy/x0YXPFFYW38j5NFMMTTEHGzdLRyHsB1PAG5ALOe3/Af8r/gf8f/s//csi73DSXjevsP/8cf/C0G9v8bQTV5FFjzaC4BLEig7ntM7cfeIngHs6cpQ4BYVS8gjw3vbZTm0eOTBYDlyqjgWczgpqwEV74oQoriMK13DGDmC9/1v//Zv+Nu/+1M44wpZ+I0mld9iyaoNU2Wk9dfKE8KWJF6IQO2Iy2+M4K6XewOzwryv2A7miq4WzO9ovjyDecf18oTvP3yD73/3xzAHIJWCCvAh7thNNgEBWxS0JMvidPwyhCyYduASD7tKPMAAbeF6UrUa5+n5A35HFDwP5b+Fkyr2uFqNIRPjOA5cOFysHuR90Kw7x8vnOR9EJfYSEeIZJ3GZWFRy4RKXELIB77nTdKyRGXKTlDBDeLVhu3zAH/74Jzw9PQcPIWBPg1lWLxFCrH/jECdHpG3TvUthknAHsMVYeQ7jBuvsKR0TjaAoDsWIysMDI6wki+E0mSoOsWgGeAOnI0A2XCGC4sBx/RzmPNK4ZzzjGf/b5f/ELUZKxEAg2kJYK7neKgae1t8LweG4lLwiWm8OlAvUCWJlRb8n8hcjT50iH5AHZ627+m0tPHmf5kxUaEL/aZB5ifA8L5Tgy6XsP2lhEuuuIkfhRGobuZIztBAhXMoT2iLsN1EhVMhMgrIm0w1ulOomSz/DCyrypy5JE0jBs2ZAHd62pXbPw0A0ShxDiIZIqguBKB53HfNcLgB4ww8//Ii/+cMf4uFMYSk20SXICWRh2dshXLaf700IjHCslEFxIAa5BrGVAxvwUxyjc0oqdZmlmSi2tTS2fhdkpSjyFXW4cJ+C/JNdnOIcfpM8CFXKEyukh5q4kuEe3CwYYogEZjcgl5aBDEI5YiPwl2WM6NJCiZdoeYfFOsGXDRZPGBhFKY4LuhV4Sq2efherbjINuqEIwNOHD+nuABl1FZ/GxuPUorGehbUVRmoYXiyyJ7zNxlWhrxI9RAXTcKxbuI8gvJAJPSLCUfQ/p3cyB6GXwYpS247vcZGdw3FUMAOI5+MQUSoHCAsWEo8AkBlwmfxPk+I2lsy57AIor0bL+zK2wtrsxV7l2O3Ev+qztTlIPLKnq+FjohDLcyYD7QkvGqp4dPyXizGlygAUj+Rf0g7BOLuoRRW1yKDKqhfGyopcxp2Umajk4ldD4Wb8QZlf04a80K5BwXz58gWyOCMtmnDaalUp9N7f41EU+NRnYs8LcNxUmK7gmzm8Mv4kj0ttYagukb12zIV2Z1xnhMu02YXVA1jHzahMJ+GSuuSKhpl1yVpw5MYPVicfmuEzmyZBaSuEEbNQt1fLOGeM8RfJs/oqB3QM6chh9pRsN+Rd1CEP2/yivGFaNQmynDpbv7LWVhRvxiWiRZohtQchWotKu6SySfWt6LlSUSaHpWoP/ZGVk9cP7Awy+V0KborLm3I7+ThVWzoKxCoFT6BUPJobrsLX4p1akFkBW9KrNL59kw+XjO1Q8UVRriHbekIuzSZTo06EWk6JgZENkeDNvb6+4np9Us/N6HCsf69fvPRemkcohBw50A9VE3baRmgo6TYtFn9ytwcNLQuw4CmwoYtMpZUFA7XkNL+KHaonYHSlxLfaQOpepZRU/zTW13w3NlxGZ0ImW5X5Mo4uZo1DTfJ4QBT3D9BEp6lmT5P58YrDkqlLi89j+J4iLfJGz8lrZ9LfiWJPZ3OlFwLR9WgJb+GfQC8AFeoRxafDN2KVa2FthUPxLKx3lYqixz0iDFOdPWEudeO6/d2J0JNCpxYUCXPxPfW7fWUUuW+w6fcZQbl7X0oSpVkVEcaNaY8Rn4cuyX24bWHF3e22gy6XdO9F6+wjHUpqgacgXANjQkn0lIcbmjL/sknfUmRev4eFhb3yM5udUXgLnkI8T8fUNw1MTWfXvQuTxfqEzJgCsMogQXnxzVnNroWKhYKSpGhyXB0dBqf8opnGQr47yiW0wLHF8jPOfBKpu/RO/FXyLecRiEFNOv+BFBuNsUFNaur/bPHJ5jbHcmYAuKoyyrrLUkNNryhEwgbSQXntoXTqmI4wVnaIPrqlrD+hRNjGPYpNM3Pac9HkCPZp9hRNiqoZZSDLrQ9Ie1IO5xXVkPbc0tEcPlSiC7q3V0yxFnjKO5Uef++3G67Xp0BNPJZc+F6vsNH4qvH5AOt/Biw96bnQAagVkH76HDmplbcup0fDKM0IFpQC5Q+iPJtZUASUvOIIpHhFW28wzU4C2UurXaqVMC3WGY8sf7SHi7wvZBlzOiumuZRMW+3d0vtAWiBTLWwkYnmGLcRDsu2dpxCl3o7rOuj/9IyCwAlFbdGbVgLQWLUX2orVJ4CyruTogWTx6uPQtfEg/d5WktlDzCjCb6+3Ah/3wJ0AfBAo/YBCYABZGZiIQ9lBRxRMrbFg5sYeoAQS5ngXy76HRRrPz8/F+9KQSKZcMoxcwTvhBcyM+zeHoNXyz4fRlNuGebxCqwcLSmFTviMnzitCAkDqPE0sWUFBl8hjssuNmwNHa0kbt+3FC7XGTIyUTF3ZLCQufaRbWWE5WBJWr5SXxgQcHNsiiStmI4oUbbkayfGOoiwNN1dA2d+Uy6y9g/D88PiByv5K5JCy+VKaMBlLyJfdl7MAjBQxilY1xcnuKvQpSgailEPadJpczHLEEtOucYjiiEuEJaQVEqeCOAlxAik3QMwAoU8mZTmlFR4qGglIZSP3V2W5JXcp5Su8KmkEuVe5lOCVDa6brb9wUE3mq7Ilv/CT9E0IxwlT68PYcr0k3BcuhLmosSr8HzDPyC19XLQdi9JuOo2lRQuyMF7DSjzZFaENAi0L7FjXuKVMm9aW/ygowpWxbZOZ4ii0OeVlF9oIHo2PgXheWR2FWVM+80tSxf3tCHCX2zWIZCQlEp1L5avBhXFDWrfJY5ScVhGcvnMeZxwVAxGIzWoYEVaWQkFqq6OzGYsuPXHarBuzjJXQClnvXC0URqc/RKzJGi3Zv8DQn7GfTLjIobiuuhHAJS1lW4jC06EbUo1DMTwiOYrSUlspIS3p1DvdXgDc2Ks3N+EDIxxVXgu4xOM6DEVlX2clibJRK62tXlWaRCkvxcfJ4dKWiA2JFQVS/mNFq8rbbQv1KnvlJcFeO2kBKreUWb4/9rBU/BKFrEbbisN7CkOX6YblToDlmaKc9G8e6dyTnR1663KLX4kWSgbIfcpuafWRJcWVf2IVNpmIS6Gs3zjCXisGb05D8ulP+zzhlqGomRXKmqpJBYAUp9VKuQeVReJkIZXWpR1l68y4wiGU0qZLBmppoSlPrtBUQD600AxoETBD3iuvBMyCQdo0Dx3Zp+D3fz6cT8u58JWA5qD2n1uh4XlkrUlInT98d/rCCb9ZkizPtuYUZiH0iG4lKvw7oVPj1vgvlwvSCrdEpxHqgYFqb5iQl3Y7o8kz4KxCEIs+nY4Q4djDyQgcQ4ik8o7GhDffpn9PKQMzJgSvB8VYLgSGSqMMt6qogRfTNm6zItb7P87C/NHZHSE/DX47FY1ZDkZjfaEe/z2PoH4eGLtgnkEAPgkhzuEmK0OlDrZTA3NEor3DtEjoMXXZyJ+zUbibzwwuo1mS0tZ5aMK6KAeS/I36vmROPSDlBN0qRyEkZb16bLLEG0q4TVp5BQ/Ad9nlUysGlWCqnLq8uoyZycDyXWDQIGtUKKEaHoySmRl2OYMX1snPB5vA7PgtND6AWz5mntT73hyAF+bdtmxw7Mcrjv0aVx9tiU65z1iHh0ahmVmPQPNg5vK2oB15mZ6B2PJEV+cXkoqOY3hE6wwszUbYyq3CyB0HzrtyXlm19S0nRN6JG5OqcMSQ7GPagHwUxQOhFKftRGqrU/WaGzT70Pbchjlt/03kbRkGrbQzuFYHaYsWsYhnFEKGuP9Xjn6YYzooP9R5NoaZepP5AxAOlFzkW7l/WYeOJB4fEhBe93wTnhb0nscwEz4+C8t4yPGS9OtGW7U8IZ8oOALpPtlxOnx0sLJBHBo8bTnqoM3p3DOy8Qwj1BOJAFhuaFNMBpT15RqH4LHPvMp4VEpIq2Vx6DDMqJojxmozZou6RE1Fl4evFx6ZgTzJOLdZ0Su7Vb71CJrzCFTPl/RoKGz8ThhKp/FolZVBeoVWSFf7qnqeJD4Bc5g81uV431cmIUdzXd4YmMVV0hfGwIVD+GinHXTZ0pEa3njVSlfuwPZCgytgazDyRlLd4r9VMM0k9SIMLh2EdMR7mT8ch16lv0MPLu1TiJMF8MLJ865wG723KzVkvRN3ArG8TMEtkIEYv+cspQcwPaCc0mJgILzLuiilPwszzK8jRkX0iEQQRyqKaJHUd9ZFZfVJyEdGTzqpjzHy2ugdheCFHHoCpcJB+bsW+F74qCcYIwVIIqYnkI1ADem3xnvfip7xnhJVd3iyPcURTty9BEVMlGPkfISLnBxcs3RVBloyqpTBV1KTWLzVMp5FX7WjlEP5x4onqvQ8UnNIHQBIDLxwrBN9ffo9WDv7iLNiKOLgTomeRu1D3uxUx1MfBX7og2JnedaTG2wy0t1VDETqoLAJyoRhNKk4P/gsPV4MXQ4ns1BWrzxrqYW373FkXKGPVy3/+iQeQd5r4dUYsuQ5a2GO0lnPxJZd48lHP8xD7j0ifz7Bq59Xh7OhuOb8Gtoem/oVvWS92TAKz4Ph7Rlp8aDty4IuEbCOty1jgrmMXiyPxYSbpCLB49v7Y7OGciOoM5UP3e9imETkazTjxETzWky0baEIeFp2pfFHlnoZl67d7ha+1mBN6XrvUuc5w5lnTiyB71bUqFqlOGmdQck1gzF7G1+iEGeUzNkJu7T7MFu+rX5zrS95lzy3qHSpVFu2vn1a2lAI8AlvweZrgQ5xuOHG/CD9clupU7+Rd9PyhHoejKTtjQ9bl9Zvi1N4rhVHZ46rjjr09PB7nykCMIC7Q6MkH/M8dA+sRU58ODWn8IiCHw0zri8tTjK3FUP2lPrp3hrWyyiUNFDpE28nZFI+XoavBHqfMoCoEO6jxQvtPAJ6QrMrMD0DsPF4lu4VIWQNOInL63Iq+ktST0G5aS0jDMHGyHfHEfcy+ArQ/m61szbYWrBm5IyhUP7q35X5l68JS0qhZHbjrijwrA8PV9VYxr2ejaG2nlXejecrunWbUzLDd5PWiKU1x1J9T2sFl3zK8j0iyoO9MaBmcIcD+TYwdwRUhY/U3znQOVn902uZkr7SFZ/1VFc8D2XkD9I5XjSg/B71y/DSipDqeWT2vRw9wcz48OHDRLgHrnI+K+SELznusK7xjC33GRg54p43Zd/PzCeWIauYZ/eNU88DP46wzLc1dzLq2zNwwlPg9NEaimcYIoROz7n5C6nhhVtWQ2KjspNr2uqw+Km3/Hv57j10LDEVBiEZVb7OayEHvqS9VruszH9KOTTqUJXUUFS6Sx7lHdRCMv1TQdXfHo+Ih5AUrl+XtwhDaO/AU5AevZafpV7Tk74WuBaCYtjId/1nabdlu0YqZd5hUiNtwQNbBhnfFMZ2EaI09BXzIKYebw1LcwpFQziqtq3VgzDoaTpvHKXVSE38TWoBWdGjPnu0egOhoDc8iInVkdoNHK139hll7Jl0EZ6DEJV914sfrzJU5ckxI513pcjrDn5Xa8gqCXsmVouQ4gNaNQkT1oZrL46eFZIr4Eydw6AN1ZDJ3zLbhMfovizTtUMJ7Tj2jJXq4fT4RT+zB02uCMgVYTnCr3HJXMyhLrGy421k3Ze4i1+Rk+w4jOxrbRkLjXHas+ITSuagoI7sKQJyID37toWya1vzRyuerYUTO5p9DazTBQKR/rK1I7XxVus0rE4eM5otP1wEyqVCcOi3eatnzJkR8o2KFbHaarGM2cNPlI9+k+Ly50zoyQq6MRT0iUAdDEqXqTgrLW3xaI8kez15NUnB0Q26XFoCweqKUOEtP/1YKGThktPWq5ly3QLflmj9ukg+52FhJ6UQBDrypuF1jCzxJg3qeU+oljTUYY0e/hGuqZDHkQ0K7YH06NWGqy2j8rJUHjlEZfMt06QYHPsmyJfNbw85dlO3V7giZAv3xFNwV+QO6jx2FB8qJi8NmzD+WkbCjNHQgtOb13ogsdsVcI3KpfzGluxo7JEl78fvdJ5+THA0WLUAPTFX3Cx3BDJokiWono/mb+51XcVQCLCAyzT9ChVFOz8UfAMjvW3rCpNOW4dzcLZOPS+2Zdx53+X36pyGFxaZBanzvu+FF2ONkBllpWl6a9AKwYKVMTpsZ6FSxiFs4TKOxns2SnC3UugxW++5BdcYlcoNcFYWxGLZtQLI9mgVdci5Yt4+bS24ULwQhePRxVu9cn+V/tXOX1fdOudaem9OwwPX7b1Dpj9GIbSO2gakBQuB5HgwlN3mmCvmi24CF55okdENT8yGC0bjU955lnXLQwDQPI7aAw9XT14wGLwD1+sV1+sVP/74IwDg06dP6cwjj26tMGfGzkzYaqSE2dp1kt7Br89rsuVoeoioCJN5dFlIB0x2aJ0dC/NHZy82tMdoXroSfPdQp5wKJXXq3hpUhrr8wfqZsuy8QT9Bn4B0ebI5tTV8h+vXg36sfRoLirZohBRCaKyldPqWqXd5ksYz29Yzwmomf5Dn9fp8nb18RxUPFiFJSwfCsTGhvVzryKHpMTxyL4578jeFF8JVnJfLBX/+858BAM/Pz8VEssahheisJ9WzoleMl3Tzh6YJ7X7yxskokmGVvGsAOIr7rJf8JuGjAPMuXOjY8l1WCP0JyZFl4FkmXmyyzE8pjpjid5i3QGx543fc8gYrOj0YWTzN8MAqw9SyrsBXxjx1fUL7SfHKYH6D0E6mx4Mlb2WC7/RvrUSA2o1Pk+aNwcrwukT4b10Ae3xu3wn02sWl9ax3OpOeyjEpB+bZss+UUcqc+40koaRlwHjyp5rfGITvztJ2Nu+bKIX+gAx/dZos/IsKcDjYy+LpN9r9J6Ea/6Q57evR4XVuy7oVV7OHUyu+VY+kR3PQeWesCUfRxn8phjtkjRDzAaIrdEiOC2Ubn7Y8zBMDYUYhVzzkeKWktKCXT/eHCJlAPxLPFjFelx5dHnzLwBsXp0D6hNN3Tf/IYn0LsO2aZUQIUX377bfY97055oVfpqxp9fvetkz8iujlRXZmmDHNqGSHrrPe4W7xT/eHfm48lrx6b/6KzocqhVUmks4pwgUM0KYbpNC7MV2/rCMkKCwNAG6cTtNS4owDh2KeJEjrjrrHgtuUhzCycFqxxlkPwv4eUb00cHRslcXD2wCSUzozq+m+tYM69UOI2aSzZ/Jx3n3oCQObrn6fN7aV73aUt6y1dRUlF9OzrlHHmuPXzUvfpH4Ngmfmzxt4rNsKwdgQX0sgazz604I1nnTfk3pux683RyHfRx7iqkc0AgJwRbwyNp5i6jp7yLJDyjniLu1hGU4/iKwU5K2j9rXz3to0Z+Ge++MdAvSE4lwDhw4v0zdlrIN2dEb9/bHXxzSRdKQdNG9vi30FMAOOgXhzhW8FaXCtPzxOIK7B24Syfnloteb5lvYE8L2eRR7HtbBkZvfZo8o+C8LrEvISWvT9D0VinDMkeyDeec9uWinz7pvXzlZOa8vS0kBepVvHVUTXunQkt0x9n6Gvm4bDtfEzeKz1MtU2kiaFHtohIi+EMQonDcNNDauwnUesYOOyVjTZs//jcwaCoj1U2gx6H8IMZyUvayJtD1J+1V4tSznzbhCqrgf2q9IvBKKyL9xUA89qZR5iBSrhTnIXhHcOVz23p+kgNY7sWBr1p6XFvutUoMmsLKElIGyEiOGkQl6dMFzznKsUVNbnnjDzQ8JHc5WKx8aKcaKnDSrhRwCxBOjKLVqmGDf2tlyDGnLcdWwR9Ziqy3gkKxdqqj3X3CujFWdt10n9jh3SCqNEEhWQ+d4uJ+RrD8gmSOjI0HxGAM2GkoZ4UNa8HMx1WWfmQbrl39EGAbSSRoFL99MkNdBzEawG9Ax9LX4OQ4Al1lUYYivzBfcI2hF44z6P3xIuF3W5kYS9Zdcy+bhm+TWH2VB4Hy06V2F5SartKNth+bcljFQcDEWeGlS6gwFzgby2xMuGVEWbRl5pqMLSbwj5lvBf6pA4GGz/63qt4JuJ3dryPQGWlVSLMRn5cuuQrGbohi9L4gnmvmwJ1BlR9eYGeSTVb43JozruLH4Ej7LY58rpeY/xV0dGlHnkm5qpUzwZTkXdEo5Zb7g1J9LKN3o2A7o8sdQltF3wOAGgesm1V7aeQ1yx/EftNILTR2cLsZfLxQzs+iyaAGaSQ6fpVrQtfK1AYVWOtex6YZkWfu+d937Gkmvlo0l6NHj1WLGMtKfSw1McU1zqZZxZ4dWqi263w7zLeTMR86Gu9vvWpDsVbVNV2mJN7wpak1HzCGE9b4X3oVFfzBseORxolaHMC9ZGny6/mPRM4cN8VwIrOo9GJGFWKPbCRQVVjlHbGkszfWAn4Jk5nTxLRPEea8RLIEvZ5SnR7iISNSZsHUeeSA8WlIK+RDz8XS5XMEuFhaia0Bq4rpARVOlfyvHnnDS6rMQg4lzmhIZsCXPbmNna9XdNtvCvgiiGUZpROdqqmlZYDeFKkS34kH5VXkEDvAFoQ0heeq1otVXohbS0YPPyr4AeuCRxzdKSSBbd8mm1JSvrR78w6IUN6dqXU3jycCPVblnqUxrBWXhxMdwv8TMrElEMqekpHOV9uVy6487jgZ7h0BK694RdPCtf6DqOA7fbDfu+49M334COvdisKgqQvfmpnjGr7JZH1QM4efPavu9J+z0/P9uU3fwwY68S5FIOwqAKscUbCJcyWfx3tgFmNGX1flLbesrF66SwSoAGnpFPe4vO0feutaRc9bJARr6lrhUy0LhCmnutWVb0VEK7WfYDQcqPPMppEUQOb9jQxDT/DYsuDQ/J87ha+tjSsHTKdyE3RGTlrAASz2mFUJTvIVLvlH5h9NvWWuMz0OKje8NILYVgaY0/ACIccsUoq3ZqyYxWeWb8WsN2xpj0YPmSneM4sO87Xl9fCyJbHVPKoNq9HDIjBwElWvSRwuDecFIrbStfehZ+BBqWKPbpsPM98myUT9MR8uQ32VMqy/HxBSuemcGU19xrD7IHxWoJlMwsHlCr7FmLsAdWqetQBkcPoqgvASAGH632uN97LApbQDWqu6caZng79095+Wkv3NKizSXKobEQ2Iy4QcyZKzw42zCd8nR4phceaikKD/eMwSJtpPk5hxjHdHffN5RPy1icgVM3r53VQCNo42sLby0QW5Pc91gSPcXRcml1x9i28rQ4NfCvKKRTYCxzFbTTU3/VYGkbAAFfxmTeObh6UMZYHyNkR/M+ROpSk/yileMuukYw2+s93tGg65at+jXjSAtpF/+EbOgqkdikdRqGbm8tVEm+O2HgHg1u8dpAkLQejR0cFo9VCpaGlFbpCTu/4NanU8VVT1bD8iU7RJROL7xer9U+gx5ot9g+kzJGrpy1iN0x2QjRTDdQg+E1jjCncnHfzZR11rqy7SMrHLwwizdAW0rK0pM91DKM01MIzAzsWTG0ttV3rSs1GMo6KaU1qUxGULRLJiSERlSaQjRFb1dEqoRQLM5Vg4mssHsrXWOszCBL12lueW6tPrc8WhpFqlxCsvpt/2jPNv3L8ZiJOOY1v+oTVT1aWpB4mSJBQKEgkiIdjGFdR5EVmr7aQNwKJa3fach5awMz/W7w5QwseQoacSvWW8OappqxIDVe5h29EfRW1rZMfvVwzygGAlabqMKhP1fSH84keiIn/xNfNjajIYxTe/zHvdY9kBWeDR+9JZTBkdhORz0Z/lagrcU3K+ONcq94B0QU1u0bA0/GxN5pBfFIw2R3Ht896/qswqvK1umcelk6RTkBYdLc0lXQD2C7rPG6xZUUgiV2AZaUgta6+77j559/xvfff99tGI8ZWuESL72G/FwEzhGqwCJc7YHUvtZ1BSHry2cYB4fV05UIEPoRz1iKz6CYUtpJL0+bV3a6qLEL2cOZmDFahBKe1n9w2ofIWFfR8aKiNfwVSQTEOwIYjB20SaG5DsycYqtayCYFGRgk1c+zLkew4oWR6lOBg4UGrvJkmnL/2PKWxyOFVSj2CPWD6U4h3iyu6Pth+iJsRP47IGyIdAuD8rAA3giHnHG272m37+H0W1ICBOAWl7KyWOvh/SsfBa+MjCU9Ht1xlWjl3E6CSt+0xrn/Wzyn+fz19RW8UfJ6DgAbM/C647gcAF9A17BbfpMNcE4VmI8gczKVKW2gRXk08mqyv5c2r8meBNF++twi60bbvOk7lwy5Eu+t8dvBvKZhvXBLQWtRlAwKsVLaCkbjs881I/a0uXUzYytXVRy2eRSylF+EwaeKtrFgovzM1kkdVWbKlvZQXoMMTCiBHx9o65+IYLIUsCEKaVvHRau6PyjIfC8Hm583e06l60468jClzBImonBVI3JfAHOx+oTLeDUtHvVCk0NlmuRjTcdh0lR0mfLD8pFs9Xv1KGnKnkW6w9jMMK8YX720RQhLJSnSm3Gtjc7euJTLtUI9opG07zg439amDUsbwoyYUPjnzMmiCM2pxpfkmBwsS3MKUogw2/V6RZMDHgQz4Z9KIZmks7H+wgU9QWumZ3GVlEOvhE70dvlRmTp/8c4qE2W5efmbZfRahbMLrPEffKTVSHbVikHeKFNQBbF5TxhJz1uQeb4ludS3MHWebppFMq0BkpSAlLeGLuRpWd2Yq19JoPRhVoQuTNZbC6q5ukUOiMYUJ0YrBbFXL210zNJX1rJU8lUZTjt7h/cl+mKdKcrx/ThidAJAXN1ZGmWl0S3F2Z6Q6G4yuolAypqaZclTB+KVjTIW2g6yJSafxe1ZFC2wseFRiGIl3DVFrwimw8/rMXkQusZy77nHIQW4djDcvKMJLlmO2FXQKAVZcv3Tk9zOswI+DLBtSdD26mKXA2Z/0/fE2u3UEEDkj5cpj8FY+V59RtDjia51bAywil7qWJsDXdGia3b8sLjV8dWB8srLdHMdl3H8TXuhKBVQdw4k/YMcHXChPvZdewqj0FKqL1E6QeA4Djw9PbUNwhgeMpVJY5OBELZNz6VOczw0rRQsk5aVFFFgKa2hOOcE9YDxoGV5NwX3RBhrBDN0WfpSmGcgXAHVWpSf6LwzsdAmPdkxB4hxIG79U2EvD1cZL/fxdsvVwj+OqgI/xICZ64cybxAIZfxaIR7gKbzF/ShDGQQckx5CiTdmNsADomZDpo8E6VdbtieQvbBSqQizBqDIU0tGnilrxnsPAl+3rVG0APRBsPk5gUnGwnpbW13njW1Sv2c9MSIK3ukBXLYNoA20baCtvGMm4dU0iYJs4NV068jHrFJ40FIKRhmlfiy0mKbJTA2hbBtbP28KwqaA9OmQJbpD93zw+zQoREyIF3+MsQtD7/teHOQlMGKUUlhvIcfAYp2FMIByjHTJK9V4EDbWXa/XdOzAWVzTZZq4s32m4Xq9Ovz5GKWx7ztut9sw3an2WBC2Fd+b8uxNZIwQXjmOI861GAUU3NEggSh4DBrHQY+VSnVoFtVvz5vqG1t5LmGLd1Pb9CGydGBnDruh76nEABYmmu2kVekZLA9YpdGkirbJrAvmldMSMDomNzMvoXHntI0duRqP4530YrlSjoe2OAwOQbPTpiad4oSTt3szkaA8DwYDG2ULaqJvWkoTEgstrLFMLBGpwcBIwSsKv7PtEj6FnwIetRJE1yeWLdah4CLaotNzYFZo6sm6jYHjtoOeYr22ORwevb3yPJAVad57UcizZYxotL9lrsp6Db1xUUUI1D/FGJMJYweKFVVH8CKD9St8kessIaJU92JcIeU5mPIKJA59KgSGuh7BMt4sR6HApyhTnp8T5qoaIVveHBPwFpfZynFtqbEkbAdcqERCFHdjU/guf8y5z3LYjtNdMd0+A0B8xNvYssc0qx6XlEJJCAfpVMx4T2Gq291k9Nzat3azWyGqlosroSIt6np4qrzGCqjbw1iYGqXTFHmQ6QGl6NNlpsGlUBJVdLnWTREyqTquJiy3DLJCUPVC+V2WJNb9nbWRKIfSQOmDDK4okbBRuOozhbMWTS8Z5Pn7ffzZG+iPCjfp/pwNi/plFtZHwMXqu81TyQ2lANyCVR5dd4SFC+mHoUZMBDmET5ZGayOm3X5lnVyyHGtMBLrFJDTK2BPlQBQXc2eBIXGeNA9QKeukhOZhCwhUH87nveOSHUqf2hr0hEvBgG8r25OwLih1Yqmarnb8HvAY1yoCXfYKnaFwoVkJSFVKmquQQgngKm23oOyVSds0+N9uErNCxLZse4D1qdICVfCsCNYivKC8E4uvzojU3pfLJS/3kzaK72eW7oV8ZbkjekcTvL131uvt4cv0lWklPLF6L3DZN4xwX7VLbHGkfnqM0oxIdWqVqXkeKNgp8Qrq+kt105Hv6bXUtxME7Q2MRDsnJ0Ab/JkFjaEFzaes+KzsF+HDe8OjiqRsd491XQWLO5rZ1jsQoSy20bhuewE8M75OgacESsEyHpTFb/nrQJAXjR3DDY8kvY+CqZirQBwkTOCNi0Fm8efBlDtDwhby/BJxenX1PIQNdGrWqCe4kqCLF57z5qXP6tcTjBGT+96rDx8HwCF+f0gaFc6bXcudy3X6tPCm6jpX6R0ohXCZV96PlI3FNzTYevQKnoaU4Uind+xNnig2/HYcONA4JodjvZ22rOkPvzeTRlPuGPQF9UipSk9be4MAsMdkrNJYuTLthUUczZAtyjbryin06rcGy56CKLqexz0TQvkaMOqkVc2ccLHvKUzlxdwgdgsQRmcGkz8vgQZd1V3YYwpCOi1oB5apzmOf+VQWJmAn3Rikfr0QYCpKFZnaEwAO4KDcTjMKzT7LJfQV/whGobElXnoUcHlWktCR5iu4rXwECqUtskThUgkXpFzJS6HsLb8CdXnXUDhXnCOGCwEOMRyPh8pCaVeP1wsPIf62z2ZgUSnk+FQOAZQWi9cAQ8YV6t1XpQcxNcEn6VPYJQhQfZtTqRDsuT5HdAZKC1TTxFTuPO1Wb9IqLNIZGVxZXyq9H/evacgMpZuoLVzK+gfEs1bpCLInXdY5IpgWetlIyYJcKwE9iEINKgy5bMpzzqzyMrO7Ozh/1cJAvMm2HKr5qRy8Jb/YNhd+tULQF8CW5rMQNpn5y9IvtOHl9QV7mPmdPgixFlY5MNPzZvzfm+Gn0KK0le1sQzeZEv3ZLsvSRgAohuRKvrM1bJ8wfKafMn7H+FClLq6hAHBKKZQDDgD0SpI1+1ly2Dz5rB7EicE58hjQZ8VI5yWLUJUQTUNRChvFSc74W/ns8aO0NK1b13PzPMvKYwTPitJlhirU9Hi/LcxYvxkZJaaLQwtxqcc4r6HJCuX0Tmimcl3EZujs1SsrgLLM1vcUUlCCX2IUFOsXZC3L/0khyMa9Ei+nP92nJJYppxGT84gVvV1SOTr46w3xPM7Kuveg5TG1no28GD1G9XfZLc8UDQcKtZC/EjQXpx7PmCh1B/I5Zm0eKJ8fRd8KR5UrG0s1VI5pSv3QYjnNk6RD5cwGc0WGj6/9qsnH1kBgtWaxVBFKcYkYnBy/d0w0a/CaY1E5KBTZaKdwRsiEd1AMVBVaKRi4ECIE5iO7rySridQAZs1QwgzaoB3HEGfit60BWSjLxJDNorrQYgg7saze5LLMlaj3hi5ElIZSSstmmNcoVC4lwVAhS/kF7RHPdt2UDaLxZCVRgl5KafoxMwn4yCGWPFHq93c9/1XUpspj66ifjQyFbozafec8Iwob/4jVLuKo3rhMlxQcZaOrpF0URG1Vj0NvBh9FxcPiGUdOK4bUGv9K+ipUWdsICLuL96oOttyVkGJJizZqqocKZ9Ky0yf8nlIKrZihDsE8znX1XSQXBltcteIIa9zDSZ/HsRd5qhj0QLA/oq6zlv+98zV13vJcF6BmNuY9H+FZyNJy8Hq0FdZVek+FAOzRN07Tb/uWAvPKkbBPheMQge3TNJp7YOYivKCPBO+fFLAOhcfS4ZVen/XSWhqLdz0PODwM7/qlpRTaw+wZX12hesCc3DrPDy38drex/l7++bjPQNtbKKju2s+zdJz2FGaF069l0rkFt9sNYaNLGeaQa0cBVEvGfkl4m7Y0ilcp98IK3rYh0814EcwchWx9tssof08pe6C9ufOejW/Zt0GCCfk8HqFblsKKYEkLAJzg72l6T/LIvbw1oldWe0mY1i5xHnkuZ/ownXY6k3YBvzvRWymux47VMX1xjlP9K7DSbktHZ1vX3TZMaVFnQeO5S5Ul0fz9dgpFBuS2XcI5JJzXIeuB24rFitUXcKydGOLVd9bK0zDb2e1rAKWftFIwwjkeZcl8gI/6XJYetIV8n+62J9ouw8LKAH8ssPMtgF4FlvoBSFb2SJnK5yy/zVmYfnrvXas/vXkzj0/CMeg5fORZGXqWyR574dHarVcMp4xC0D3cVmZ57e8dDUNETfqnaFdQ8oY3IR/GcvJmkY1bjWMGHjSnUAOpmERPATwCAjonzBRlnbZJvI6TM81TFvP+drvh5eUFz8/Pxaac4zhwu93cMMC5eoytoUeEjzSTE460vDXhTe0ZfyQ3OPzWRyXUMfCJuDfVKsFj3kfxyj1Cf9s2Pec5DZbujUKo0qtNCK+069lqh5nwm4bDrJbTeL0lvSMFYXGNwqikPku1ydi2a76ZzPgQjwtFl/RXcqARCu21s/2cKbcFrXrWzz1+pkLm2rwr8CCl4GnC8vkMg82kTeVRKsRQEJgs+xlcvSu+U4EmlZ9saBUj9OjTg2llELXisquW3Qh6VlYK48RwR1meMHsipsp/Rmin9DT2NlqDQ78rLaUidUWrGAi6LvFx6mu/zUMKEVY5fauWofy6XtmSExOEzGCeMQp0vbz3VlBZT9SzfL1PrxzPeyt4mii1r/ZDdS8VdEE7DT1+CudlhXrkZ0VBum1Q9unIaOmNT68dyraSOcpMgleNEc4WfXWbp2/V85K/gGyBkXtRlQen7lPQkBvBvh8zWMZxxiI81Ljn2CLyKx4oBZR8EzuQSDbhqMbjrAzCi6wYnp6e8PT0VNB/r9XSaocZRdBinDM06Rue0uXiqE1jioNSC3M3FMJlGKTVXp4laL9baCkiIltOsMorARqZgq860CwT7QVFEM7I1rUqTBTLQnMfcl2kOlpD82cvHGN/zygN7Xlpg0V/aut41F8al0sHczx+3Cg1Gh64XhtUrI2UfHSGhJWyAFbhN49W+eN8LEZbjrWVsifDSt46Ek0t3L029vraKvEVCGc/UR7FjGQUzcCbhY8E3iJcdH852T0oInKTOJg5hY6u12s66vZeF3JkzbwFCO1jWmphYZld521ZvOEZFSe9zlhL9n2pfKpglNTOZkx39QQjwckK5MHTICMJsSjVZ/pr2/IlQSMhMwc+8TpENGPA3DM2Ux+EEofptQFxHLeoGMtL7QOmQRjqDcaH9apGZWTawqe+j/0RMJqzGcE9VDxcKayGgs40IicTKweHSjzCfEorx4xk0zoCqeXmWYF4vV5dy6xPe804PStF57sHWp7JfLlUjXsv38j9FXcbeOoK3RGeTPsRu9C69v5prIW8p/CE2dLt9X/muDJZeCLHmufya7pZ/b5fsLX5tEppLM8WnDVWQmurzYEmbTIrlJJ6fd0BYlyuW81DQAgEOMbt8vyCGv894yOP+/ahnr53RXFJez1nU+L1y+/VY8Yj1NnFswpey3nRvrj6SARfOYBGzDQTr+uUDM9K5WTqJYNNcVC+09Q2/Iw292KHLmVOmGRYm2kLxH++EjpYETzLLmoDt24Pz2XWApJMnhka7SDL+Bjl+ZXxeArk8iolFKVOVTxJDqFSqQOtQBTPpfazyKxOHSi7VZg1wnpeQ0tZeHl6isF7z0HjFs9lUUatHI1X2sBJRIVncQY8Ontt0Hrmec6t8lYN5hZ9WoH5+NYWUFuYn1NoPAwauJPvhIVbNqCnEDgXDlRuucu4d7rJHo2tdD1F0YoT3sMwHm2rVslU2VxK0JbQ9+pSDDpKAZwm/SPatHKXeClDk6f5p1HOZJktGhTjpYILLPc5dxVYhegJ7UIwdKrk8eqsgLN4ZrxF+367bPWks+YnKtNb2s6EpVfDUb0xNDKKWu/Ojmuvn5jLZTSj8mdh3scojs3WLlmddMbaXdKSxaoh+466Ar8VrvEGUkXfghBtCXWtBHqu/Qx4yqYVAz3LgL1QQ7CU24IoxIr10lJ5L8dBWH1QL8SUy8c1PQUNDUXLyRVQngLKQxDrjDVe36Do4EhJJHyilJBbdnjvKVQAxd6YVt1Hnq8dpx6OXv5ReoFpD8/8YgCX6wX7HubmdDw+LGYIY1paMnWtaP2qWIqM5YdwR95RLZf8OvaMvp4nZnHNtHdPUfXHdeSvYv3RmqJYCDxxDteIhjK8LwS3XDENaxMnB5omGLc2ZbVh5BLqUgi1healn3G/vTrPMJNHox5MXn7vuZ1D6AkIv/885Szp7M18UmY+HgISaiQCcENckGlybGhIUwe3KIHSKqYoOITa9K7RxH5dtYIBPJrkPgqCxNJzjepIlQzU3Ia6uWR3dyv053nK2psuhCryuV69Oo6EU49v5XkRQjVpqufx76BQ3+tV+DEfTBm3jiZPgZH7WYwOBkDXC8B6ZRLgX6KzuzTp+thx0UvvtUPTe1XtJJ/2utVW287IKP2LCiY/kEOpF5WmPkHAgzdZffQIF+YRULnYxvrXHdTKd6bMUUy/Z33NliHl1HHZfp5z8zo+jMtVQfevAK2w2ZuVh1w775awh5YV69Fb0OAJIqDs+0dYq/cAIVzYlE8B1nQcALU3gQpdmzqq+hHQM2JbRpX3XtKMIiVn6JnxQOKv2M8Ay9Je10xpw7JSuLfCZ8Cz1L2yW4Ivf6JYfTSyslvl2Gd2EI1i4j0aNYwmrjTOVlodXpr14nyg7DqNUir8ruKSjoA3AIr7s5Ct6nog9sIrhPIs/YRuACvtc0ScxW1titdSsTosUbkQfVqKpJStZXnf80ZtPg/nKvTmw5jKUG4V0pR/SX6ZjaGUPUf1qCpfl9kKzbbmOWbGU+u3pyDC8z6uWRjJuSp9yOS+qWmap2Nt81qDTq+x7HP9rqVdW8ymog8Q17iiAXAbtMSZy2h5CRXehU4SWB2Aj06n6bAKww4mm75dOIJecN3tE4OgIbw0j5FzN+aMFfu1PFWqvgRQOi/+5pSOdJqk8+SAwHrseBa//m5ZIuHVdJ4Mq7YE8PRcQiNtNsxMeaYhJWsvJGPHt2DqCf+WvNJ09/J40AodtdKMcJ2B3N65HQofYrLfHho+mmnsEWF+KEddvK2tQems2A628ypBWOBsu4AJf5fSNRi1jX5+RviPyrS/lxURHTDLe8Z5XNoIrQnB8Lp9IqnlHz2nUON5K8Wg6tbhEDealIR4PAcpKQQAXJ8nVWatvdvczhvsMQvhe9tA60FPcLY8kVATv1zX6nZ5IPflts3RXht9QRj0xljL22kZSqvK9Gyax0I22FZHwoKnsIi5iadteVvrIfy0gqy2lmoPhlPe8BF2woRL2/tuZ4mlDDfZOgj0cVmmlTxl/hk4a/HN5NFpmkKJyoPz9IDxJ+g80ZgXDZA2naGt3DpfTf/YU7A5ehanLtJvKr/9PMs8pVe402oQZsjkp7RRCAP0z4JqPQuPD0WDbjvrRqhXDoyE/ypYhSBtxep3SVDbup+DrcKhm80L9XgQ6A509aIgvXG/OgZ1W80oIg+2bUM+YVZ4XVz8eTwnruOUQnPhs658q6JiMW10JE0vJZRLYfu7hgV/XNQX/pOBw3Jdnx8rbNO2YgX00to05wfd1wqPVHXncBa+PVK8TY4wudm1SgB4y5+g4IkErFX+gGNu5USia9KjkcGY7CmvCzel/NQ/4ZHjCZEMSlb/jvot1P84AueLpVx2QRb0RMK7B/J4bFVA53eUxYNAU5FKpHhmlimX6IJyhRRDVp7ZuROLDwgCcG4DW6mULJ6C/sIozfSG59TgwccoT/05D8ZLZjGyNgBX5M0eazQuKAWCLP/MgZVSgPfcTvu8jgVmodm2iuYaLXgPFv+8Bi7W2lu8zvczUOanUhQ+2GJr4RrhtnMR2cKbiys3J/vyk/RreGxalsZNmJlvKOhw+9DJm7w7z6CQBPWqGc+T0mV77ZgPGbxUOLSQYm5PfHohEgpaJNVxhn8tba08iWZCWuvCivag6KQR85WbJe4pPV4BO0aKU5NW7kG+uqyEMbVvWyasyotTMqXizfJT2nVFjiwec0F32xgtRgty3O+klXCJngto4ZntoCCHykHcoikP8n4HlIJEPdf04e29gTP4dXuUOILFSrSZ5w3DoBKu6gcrW22BRM+r0X1naanyg6NlVae1k8CJbhF/xfbbmi6rEHowuthJPrkSBjWU74xV2SjDyz8T06cYFwpNWLZ99mqssZbL0e0kY8nrNy906+Fy6SspH9atxFniGsmCXwLuneAWWAsfEbmd6hHmCeD+RLCP91S8zmmEXnio+S7iGuXX3+csaEBr8uLFCYaatZBn02icNi+Zy4TKAVMKwOZkH7Tg7wjqyfZchR5vuB6LuMIOiDC0yYflNBRWzzq33rWnfDVeO2fTosHHPy/cZCNlykN21YtfHoo0mf4ZIeYJaKtcLO5S8QAtmeO3S6mYRh7fLLyVArGK9E2UwiNJ10RqT6EVqmlBi4GK6/4MzlnB6Sm1c55HOegtM4qC0ArIo+OXBu9mOd13+rc3CPXzEpJfV+F9lEJYxdOyUKtQjwi7VrkISoYTc/cVYI/WHh8In2zqroaYS9zOZl5d5ojfrCCsaA+JijoEvul7HHocZWNibvxbvLYObc9r7P2UZQFWMdg8WxUerWkdlfVW4/3NlEJh1C4QVOBpWvnnG6PHzCshIw/nyI3XsDmXr8ccgnWJhl+LQliB1rWkhUX1QI/mrWDKgGDOchdaQ5h+e2BVMq+PQ1I9rmuJ3VVDhIjw/Pycy9RjgKXfj4pOGyIS0Bc3dV20E3APT0kYrHqObM3eO1pnFfJbw7RS2BhgPtJAqFZkYEyw3TBWh4/aGr8HVQink28GZ8GwMaTD+WXTqq/xADqWm63BKmUYpHMGUgWeBTdrmXjut4dfLFF9eFnh8cV0+7Fj2y7IW+tlxYZdgRT6u1qvzuWlP1lI2LDHBuCAOIUV7SoU1wuTNENc2sNpKPtMlW/UNIITkYbyd6YtPMvF154UoPcziHIQurf0PdfzyLmJ4tg1Fr7GbgyiVkzf8t22bXD2G8ZVgObZhHdd/h4J9MhPxhPP9Hl42+DzRePAvfRp9ticNEQtDa0x2YNehGME8xPNkJVHqSS3m2Yt9qryi50mOLzKaxbyJrFadDTroQRMsr66mpuSnDh4b1jP9WAnZXW4dJiyZ2CFIUbC0rPuqtiqWv1AxTk2WSGyfsJeWaUS8FxsihY582MsKH0+zHz7+tZjmcJuxpvF7cfFw3coZdgOc+W+CXVjUa567AqSRWiGnDzP2snfi3MHkgoukVKr8gG59Wx30tdUzIYmR/zUNLqcBST3Qi8E2zZGy/HzNuGjQkiWz0az8a1nBVAakrXl7zTEakWXaDmZz+ugekJRkMlH/FKEHUommG3PlkU8Yxm38FuFVuBqDFIRsKIU9n1PVi11DjyLJRRltZQvF6fj+ie0zkDKR0BzWeyC4OyFnfRgvT88NtRGZVrP4QCionCwm3k1V/iEl/n3BJ/NhXPLE2B9z8mnuYVbG4f3yA5AcCjcxZ6SNLDrnEYh2fYaGaijRRnl7/LdmygFW7BroTuF6/hnG7QL3G6wmZASOx7MDLPYZ5WiU/m1HavLymWHQUgEEOxEFxW5hJHU6m5V4jgE1GIYr0+81RmtgdxSKMUkcqSfm93L2LYLXr68YLvk0BNkXsHlFS4G1Iw7XQsQSr/y+/6lM6lOxspOeBY9Lr+NfYveQstLs96CxVfljZuZAmex1CT1QYr/H+O6tcZdOOh6DmYVQpleljrHWjCKI+M9fF4Ypvd71mgKfRCvDcCGNImf6iVI+hKvJTt76fo01eMifC097ll4k6OzZ6BsfCE8r3NvCTsvBv7oSRhPuR2Qna8wajg2PTOwUbMbCmGq9AKpf/Xwsi6g5NW47PeWsJyxSlshiJ51w6oOts7MB/bbgVe+Yb/dQNtTLgsynrx+EzHjC8b6mQhIEXrRirPspX777VG3qTUKetCbt+gpgD5NJTCz8tyyteq2CxhFgN+pwCZOkgkBtsq2dJbmjZ8+0To9X5jLCel0CSOvsW/geHl74CsbEivBkU3xlRkQj5BLI2Xl0Rq/DfNb+ApKYYaYbMWcgarRF9z9WdhaliYBoOgPEIEbVlfPm3owqQrv+ERIgXLVh4/jiJ/bgOA9Kj6KI+TDhw9hf0PMZluosm7zGye1SlpZ4GMvawSe5VaIt8XOepShIiB7Ao6jJQQeB57w7ofHWt5Evjt7TGfbCGzROGsRJz6euIfE8oHnZbczj5No3L82uOs+hbYb38vLpdUABOnB7fxjptAPgHCeTpUSchBZn76Mt/hdFlrmgwoxpJhKt6hUnnifM6Exp+gmXvnzLKaeVevTaG6IGpQfT7AJHva2hbVVFOso5hR37oBIpejBrgd/KfTLfsvtWs415BUwNkwU2uoAwa7zzxVO0Rrdt9EgaIUgV/i2benV4IWj9Lul0BSH86xaIZXVsIZrWGijT7wTqGZMMfpcL12+ngcI+Mv6b1s4M0rGkaVR833vPCX7zBsvlRct5RDFcHGkL1euwt2ir0VLC5rjGQzwDXnMBB5tLRe3cNpTWFUIKmXNywsKc1RO/5ahtRhbK7Zr6ThjpWnBLThG1khhUL+hldEcWJ16ujRHK64MJCCtyPHroE0G7YPnvptqblso/JDOVDtK3aukfjtN4z0BrbBAjx97HmMyZuCP6bMhyBFNrISpoiQ90qTUdKHK04JRSMxrK4/OYfgvkmNp7+GchVHZfgi9DMOulLmsFFoupUdozOFgyZaetuR6+PRz29H6uRye63fmXMPcNUfRGUiW/uQ5xedak7cVEqU8bzGX0qPbWnejARUzh7CaETzWAxnHtRlgfc3goC5AOCq9l0bVdxusipoNmwyNlkkDwgpUL369FCKjcm0Vi1frlOeG0BY8GS/9StrZvDocNEoza8TZfj4bLlzJtyL0TU7AmduIuZq0jeC0p2Bdql5jFFofXDzQlkqraSxztpQQg7E38KwwaW/yVt63BHJrIFm6y4Ee7lvWsc62Yszx2ZHynIHZ8ACFeEyO3pvwi+SzAmx2gqydjsuPgXDyBpC1LF0eFXxNah3KHIEjfei76m/n3Ql0vdsWNZM8MILVMdZLPTO+Rr/XjNdcZk/J9GjtweM9xxiu8tqJAbsm7KtPNPcY0fUA5OKHIsMDCFE4RoK9B6OrOuV9MNZ85k1pBqGEcr19ZkrPOlytR8vCuDfEcSbueSZvmU/w9cvJE4/6ZfzHPK69yHO0aZiN2z4K7hE2zMFAq6K5j/I88YgWjbgWLfC3DK+uwtvQMjJjzrf8m60+agudctCuRfkzeFaaoD1uu3M42By+FtiJJ013YSkbXLPlexNbYkl7CmIG1xkBrK3cVdqFTmkbPg7gGliM+KxCiIqSs4dpQ04agkJl0KaO1WgUOwyXTXghLToeCXMeVU7r0RU8aSddw5iZKcsnQDKrfmrQFwtpojrjtfWenTWEzs4ZvjV4URMJSXsqeZakUzuaW7P4Om0rBMFN+6FcHeKVawdHVYZRnjPCWeNsN3LAefABPrhUCDkhoCZJZZt+yF6HWjLkOYIWrfU7vy7j3cI+2HDPioJspon/FOdQpQ5GeQVBs108Oq1CKNuDZMaPD7CzCu0eL6d6RuR3halb+T0fF1MuilixgBnhLKlWH5SH5sWMFlHzVbf8ipYMG1FZd5tX9b8kaBovYhCZ/FW4RAwx7DCp5XWixBqSZyeVLbQMW03/TBM3e3OCnLIvSP35UZseLO9objWYDGx79keVboK0nlLwyrS/R5OGGpdVCJ61DojlWx6SV9NVDJmCrlqY5XT3GhWZ5vxsefLKmYgs3scQjLbAW8pfxBGBnMne8DYrT28DYr5rN3sFmg54P1RVSi7reVvpWZJXrH+GNG4pKLzCSsB4ZZQF5dsTu6VYqC3B2jvg6nldgmofTcVwfHsYMvKhQE1CupYUqS2bNCONO2l7+WTIVb4q1JiSlx6TBS8uf1ZBeOXMD+9oMldl+srLfi+hvOFOX4I1gtP7FCqhOaGNrPEiIJNOrCbpPIHjWZTWRaZorZB6VgrN+uwTrRCaAu/IgsX1KEIJ6huZchuVd0AZUlOQ4tgzkkxe23CVKDs0Bo7QNghlaCXahiwQdJuH9t3A7PGZukc55ZurcM8ilPKDztNeQCJVkHRr5BRqaHU8gnmWUP2lvYt5cK1szHsJkj+r64K4eZLSWOiUhRpdywDJ7zNldbLacHRJ6yhES4uP3aFr6h3L/13vyYsgtA11MRxi99D4mBeBh88pULICR81B9SP0vZFpGhruCEdrt6UQxoyXiHQKRQyJxBZgTHkss9AOuzmEOJW3QmHZRW5ESs6Ad5RyKKO0WIvfPlVdHEM6etYg98qdxC80DVPex++zMAr5fXVoVJvQMPY6cEHYmtrsU6XkZ3ikN2/1S4JXv0fITA0P27wWnwIQAj2NrDSiI2K0Ja6f6TJbIaMCT3QVrEUY/o4C37l6OqErkIqfe1oeyG1T4rHlud3L6Z82rcpf8eidZRyXRjNpeGbSrkpPpVJ+enoC0KKzT3/tcY8tLf95I8hiBl5PaLDtKxMiq8tmzB8rV9P9aMG1jJfzmLc4+vnkw3jpKr8N7zZRERpHzFgPzZctK2Bl0n3gLwAYeieVjBRjkAGSkxIUDm/FZwOmlULrbBzbeXVlqhwufr1/Ybmho2ugQzbMLO2j5GlN63Ec0+XpuGq6es+Jg66AF7q6D3IYaOQOz1hDs27skCqT5sjWAYgIl8sltsG4/BGkcFCDBnfZ6BsY0Trkpg0TT7n8GsELN9n3abwdLCZ+la5l5IEbAhFwnzdpoVKR6HIkZKxeuHUp0C30yT39R/CDDoBti2hMF0ZnT3HLO2PsNBcmlPCQ8JEfoxStlWgsdaK1plT4qI278S61Sxh05XVAcmhwnXdk7a7QMgIJ2/fKDUJDOnoeP3OOG+byznkFUCWTeaapOmMheZ6CwMz6/pYfVrB+Ugjj+heGTKfJbd3Lp+twj4XfCh/M5q3ztUJwefyQGl82vcxHcWRCl69LIiRji0gv+JnGhnzXdNRzTb6V/dYK2K+7UlRFWucHhRz5keJ4lgAyZQO6qk6QdCmNU+4MzN+8NjEJExaaxPAMiZnOAMVzODj+ZrEyFKKOl6Bdx5qpSw9DLPkgHDi5plpRam+iOXHcKdOmv4/ZeiKupCeX5YcsRmQs06nCRhrHihBynzt0tcJqrtVfpCWrFZwSoyfZrX+/bdg0BbeKauXvCCYtAN5KcLX7jFGvSpG0u6JrQ5jsV3eGCEQ+aUYLnO8U09mrc8XiD0/zBtCgDA533MmBi+O6roNnaLVkVPG7MEoj722RV48yX85rFXD+V6+KS0YMwjJ5TR8RQU73JuTFGUSEy6PDRyMQoeT3h74nwQyuGU8AdYeEz3J+4B5m6Ak7a90TrW/w0uWMyvfCKKtg6RL8dwkdLagVrjPhJJteu8ZVCAl9v2lYt5aL8Z8QzszlDDBOPEuBsE6e+yHzgfw5lHX6utX/X8NT8McCJ+Zl6LnCkyHR6fFL5nMNlpRCy6pOoO7L9Wk/ApkHgtbUWR1PoSeke++beYIZ0sUp3zUj6d/pc7pkwbmYAcju5GLe0STVTLFejllvalQmAUX/37f7nIrVKp4ytLXxy8kCjzkM4C0OqmMDjmh9FbdOTw7SvpegQiEd/tQQjK9O+y4IzByusAaYtJu0a5sePd84249FzHyQXm+U9T0FZSVbXDS/FLOi7YFKRFE6VXaNoL3PRvjQ+NoA8kVKK/phefPaGYGc85chHIthhNML3bSsF8tIMtBtWbZOK8ppBWYUnBV2um6ZH9pnIo0sqDMTaCPBd9ekXGT0lrDctm2sD1lssL6X13pXpjEb+AjqdrnHCAg/7KiE70NKmSs/KyT/1N2y2cR69+/sLkKx8lsSDXjEE+Y5EjC+f9vr/cTzoKDQT4zhGa9+BAeywpRITw6/GRzMy8a9HT+ClSnI2kPCfwzskwf9nTrmokFeQajP3nkCxH3bmDxrW3ZqQkUzZ3zNjhW0Al6+klFsPfPvcd4aXIEeXgzzDQfOgvBmoDANRXTM0DIqO80RUP7dmj+Y6bXETYtWu48oDEptgYrcvEcleF5MTasIhDUle4q3GZ17tVUi+4R1Pzo5Wn3AvMQ3zLqtRJD5hk3imaaBLQaVDYH1wRpS1mjLz0ucZZ+oYy5Y3mf1ugq+F2zS6Pc23WQfPGhOQQqdCHXYVlLQd+u9DU9lebK89EqbmX0vZ+MLcirrqHHjkmjcYpot13s0Nlv9Uk24A9AXynhCwmNOT6G2lGxvwqwiGNnqkDw94eszbqk8CQCZPlJvcj4GGBvCQgX0YxhO+StK2LZZCjeGh8NyV8puxp/9/cJNHJ7hNB2+gWrjiZBq7puW0RONNBUW0s8bFCRcti1yfVr5+5DwBWbLlPOMSC75oh/2I/h7nyIfxxUKhfEqRnPoBBT19eqS6C7p6SkJijKEaMuKcVITPUApHLFtQmPTESdgUc895IHep650SWMZgpXZZfyqrGTmyVAT66/OVzOlSxWKLivoyrQBtUvXxeoUmxeDaIXBbvoz8c9WXQuFCGPFb1ScVDqCrAySvZLxRYWgQ2JZQCA2gMo7c6lOw5Lz6erj2ba560d7cyqjsiuhDgZwg7hROa1uw7LsFk3DCVfksVha0T0oV8b4Y4aRx4QOM7VE3Q5m5PumEy2xDiy3h9V8Phpj0g4Hxyt400rIQV0Vr7VkTVmH/E4fl58OO2xUPYwD4SFgJ31PWrtOkDRd/iZsHD6z4p+XEY895qKwcO9ENfAkep3lKZ0WZbPW9EaXAtej6rkKdhA/Yr5jBrTynFdAHSsxeU4mHKCsx3mBpfIbz+nMZOFaHR8JX6/MyX1MOf10e8ym0we2cfpmuQE4z+Nfuw9t6GgFNuQDgkbQ853yXM75ui8oBbkKsWVVR7ErtNwpq9KkFdfPxvn6TaJXKlgBMDexysXEY8tanIkBtsDGKh8BHj0e7TaO6r2bg7Y1V+MUa1HsJW9wiQDZykdoK4FZAT8Kv83mnS236oukJXslSf1972EEYjVKMe2AhVPytGB22qJ4xFH4bVXoSlZ76SejMZDDRPXmx2xZS3v50YW6n3yjK59qS05KGFzj9iqM0GHqsaGjQ2Zeiq/vKTBXE5T51UrIIefxlMDK5FrVCAbnaAKw5a3kySufsc5YNu7Eo59ykG8expP5TskLcXrv9xhPciEaFhF1f3pwLsQGZAu27QHPCv5fwvNohgkRzZoiRLXOt9Nj0Vhp0q/ZPwihF72rPbW/CXt440xTIIYrcM++nGyMJhmRyQFIL2ZpyAnoDM47FSKfoqgT8n00LCiF0mrPA61M8wiYmgh9A/AmnTWs0HM/7aUgKgfDuOyWQl2lbYbp7vGIVK6YN+LspKnKYlKD8wGhH5EAhdX3S4STLJzzEASyJfmoBbYriqHIBTmqgTifWZbOT6oy+J6YlB9A7+y1REZ8U2Ry8mDkCH+vLh6qav7PjN9y/J3fhNhTdjMLHEZw6j6FcoIM5ZiReQWvLVO8q4k9plulagzc0cwSuxaG0LHswr3dGkJpgF+n82iaodt/18t3QBSLkgVCTZe27A21T6z16GzWUT1O4qiY9OP0huNSp8pPiAOpYiB5zgpn/Gz1zXBwLEjMnuK9JyRlBtUSkbM8KMKpxK/H4FjZzws2bvwMfbcRYaN4REPBGzlpQam24AvsteLkunqGtVRfseEXcVxNX6T2If0ujjcpxJS1rDsV6NDRMISuvCRdt9m+OhU+KldmHMFSYx3Lb7vbY2CUXb1m1aYJSser6TaKyJsoU7jcaVJTOaEE+gKdEayblvXHVfr5EJPQYAe3MIe2qh5z54MrMMA4sINUqOLgA9fNY7sD4QqXXdVKB25aLgQDqQydgBFO2X87GCnM+8NHTRFxApfBXHj6rt17F34dW5deYOaibw+Ol2iG6YV4jo8eiPJTLG89VoSnKI7XV5eOcF5TxFcZQ+U4JpKlo5xpSNQilefLJ0JeOi254vyYyEY9u68NpSQrenMoeb9FplsZrHp4OOGzlbD78ua1SuuwokY5COc8+POMWGhFx8qpSkrxSH3oVq1R3XpMkjkWBCuNlGnrzQW0Js1tPu3OylK6y6UvRDPDZRx9wefPvRx8gMgez0V6eJk3Y0tbP2Ygrg/vVqcJ90wwAyvW8wwYj8kpZ0Rvy4v7mvMcWV5kIdzbyFo8LTrXel917sK7b/ILR2ViF1JgILwCbhHfrOijtPva0mRdFb8vsufWAiefwktMhcoC8rjX430Ep6/jrMlq7B9YLWC5fENJzxlw3ajaxZ+gosBphXRrVU/OmcVfwUS8oVwrKFdOyvWkhgou14t7QnoUfiLqC4fSK1R5jcxtTSjPtSglnB1CBgkstpK2Ud9KO6Y4soRByfgrpp5nVjZJOfLbxzMWTG8F0+OAuamzShzO8TFS703a1jsNFwWjZc+3HsMU95aIgTOsAwtO38MbKlop2RiTodhA87Fn76CY1DfW+zjMYz19LW8OQMngnhHxcKUwikvZir01465Ad5URA+ww7ay75Vntq5ZimGtJJjX01145MwOgYoQ4Bq1rOQPBe82DN7vUnTwmxu5ZLIl+Ktdqm2Gv5nra3lF+W6eZ7c/C3gpuB/SAnFlp9jW8iEd5NLN4KtodI8XD542L0igWPszpXQu+C1rQlri8+bERtGRFWWRHJrq8SupV38uuIwBdasFJebIqKeNe8QqXlMISQ5NMHJ7rCO/50NoDgiLu824rZzcssworneCtoMh0KDGnPAOPPj0oPWHM0bJbERItT2GmTqI0epZXUY+DJ0b/+X6ZVWAPCNkPofKoJ42R3K9A8CRL40GnOUPLUt5G0vFcWsxL47TZECC36wO9wUIOTrfw+i5YfEI78qnXB9bkdRUeAOzBC6oDOpb2s1B6D5qGkYIZweNulj8Bj429DsrC1/FdHh2n9cI7rXmClrJYK+9ciKYFVgi8NTy0j78Szecnoe/n6j7PeA1Ag/dzcKBN+QwPE8yxEHwErCQhV4GGiOsYVl1FhZrutrHWq+U90Dvt9H4P9bHHXFRE1Nt+xMI5CLVVaOKFZ7yMMIFVva3sBVvGvSeqarhXMUjb6fmGkuH844vt75kwh3Vuy75S6z1MiKZVfrvu9dr4bltznMxLmY5MGwWrMdBbx6IpxnRP94K4nNUEoXjoykqbDBPN8ERzXbyLX0KHFv99dp6N1Vfv1eMUplM0aOtbLO4kwjxjn7Vgl3ySXBWk2zwm4pgnvNkUccFCP44d+kA9oSf8HVX1+nF9VFNaHt8Hb5xTBu+stcvTtat8qnBXPFeOj1rJlK1ivcj23GYP7lYKbVfLF1T2jZ14ugcKOkg/L9+PwlQroBlN/17Jn2m0QsizZMK72cnh7sRoZQQ2BJyTdAa0WJX85ZxTH2u3FXtZTxBbtIsNx6yjmyrHU+bDEGnDul2dF/AWSNS0pm8aQz3rY2MqHk4Jc5ESX0KLya7Nh+I4GdTtp8SyKde7ZlQBae7M+Vbn2dCSKWk8lwoJKO96aZVV9mlelGsK8PMbebcKdyuFyuKuGMFqtloJsGGOJj7nfYGz8X7m+Vl4HD5OAn8WvHg/medfc9mhy9zwFEIb0mDoJrWq5i2g1Q99S3oau+F/a1z0oN+OgY/sZqte+fbZeOVNQ5hPsG5hXbPfglZxFT6qP7VgaO97rinNYLK3wB8KmX7ugZ3na5VZGws5/z3yZjbv8nWcXgEjAdxVHDlxW4E0IId+Gu+F7sItffQdt3Nt0cujnnbzlF4FJK4Tv0qIzGdst+8YcUlgn87pCVo4TF54bDWuM+7trE7oueddGJLC6nPNQm/9Xql/Ly+zRNe4z04TxTV5WcIZrBBFOZvW0clv5hDZ8QxpQ4YN3WRlmXMVF9jDE5TtnfVtBTFR5+iVnBXMRfmncdXejeCWt9bbH4XEPFj2FLyK3KvBIpJU32MRV8smKppHxsgE7jPu+L0wwtOKD2brjPLVkTS3BC2dP0PtazFnwc1LVEW4Qx3W783VsDnzCDOw0q8xh/pO6pPMs3W4d4VIG1f0FDreVoh7D0KLDWBwuLDaCVnIqkjtw1flSllYaD2JOJA6/ORQ3kSiPazZbxkajxiqdZioNHS73oYyYok8fvTuotBwjndXDa+7Nq89QiBml5mLobYYSemXEZGuurcz8BCFuFxe/h5n9or3syBXmNgcMxPUZyDjYgCXacVg7XFtoFoYhj6WFcPbQ8vyv8eb+GuE3B5yG1/XDPxqfd30SNGJYri0jWhdGYvzXqyF+WMukI0D1uUN6KwbjE0m1bmkcEfLgwFsThnB0pBVwBJHFfmoLw3X4RZ23Gp1gBV8gVg9Y4CPY6gQrFub6+l1mG0Xa0v555gExaCEiITIkLNXzBnTbwiHkNlYpxdnFdzukYZNo7QfwphROFqNSDlFqxpay9/+0j1/UrUXT+4MLhPqSNRaQzqx+IQ1vqgM6v4KvFQezDZnm5c8r1c4KZr0mNJ582v1uy2cLMdr/BYnSHf+Uay2yf0epQIBstOXsQcvGATGofrBh9bczqmQUeIDOw4CnaEc7XQ1W0S9H7zVijMWJdywTfQ/sOIpkCI5Ce8Gd3RBX+tnskeG1ophEmVSCIUy0GhVWWzjjtryRs0AVqvPLV/1lGHMbQWZtKzJUsZTYV86z0rlrUtuJF+LZUsml55pNLAufncllS47ZGgQNrYM141Ganw3xbuKoUpV4Zmd5DwHWp3OK5U+rrkhqTg9K3KvjCZZ/otCoZJK57YjFcpM/xsTNulfBT90Kl8GWqgQdAOhr5TVeF7MEbKTVT61+mhFa7as6VkcrZDPmNUl3ei47ka+TuO39BUbnguHbtk9BQFDjZ9hGblVUtNS7kwaWx+kmc4qwEkXfJTOnQ9ppO+1vS2nd4nhjNC9Rxj3B2jJoaTmzB5bTp22NCbGCsHi9+YairCxKWuW/nOQxwITG3lQXoZT0kJgDp5BoHOeRs9TeCSkaIZnvXXG+9cKUy8pBd1YdtKoSjvAM3rXEnxTBXTw9hg+LYFzQihFGkVAiVczFiBCPTOuqSOzOr9IcJYhIw/GKWooVnIlwyFvrpkR6J04UeKN3lI7AYpWnueZrQuZc4pltqyQwbTfCOikEy3FdcJHus1aQnlWeLQ84lb+FJ5UTu2sYrBhmd68lZ04d40jRcOUcbhAp0fTDLTDkpZSMQAZRDmktXGIGByF0XMfnJkDfrMdzWfMIrupo2WSr3bYaCLPiyP2mEPH8Vv4PeUZ38a/o1HGWt3KsFYHXL0aRtYjQxdnJ/fOTwr2fcZHTDaek+3zZZ5tr18CmDE8rPaxtOkwyLxQXy7FKN7HLiBpqy/Nn3KTSMvo+1qLWh6iFKwATITfrebuTyR6ZdU6tBZv0Rnpa9byzbSOZvOsyFJ4tdYFcfzbinwF4lZ9Gs/DZD6DjvLgvJYFykfDezFKUnDYyfE8IVhajdu24TiOaq6h5CWnFg8eI97wHXkyZwfqCJfnxc6X1QpyTtDRNcGd+4tXPS+sKOs5nnbDvCmM1j+Ybp2mNmheBrKhG/hZCkKjWmMav8ZqqoVLdsqQSAZZPRRcy8yz4VnJw/l3xeDimSYZIKceNhopJtZrh/oWOornrTDS7PxHyL5BH77FLELb1hXICqTtgSQG2iT+3Fi2tsIXXjOQDJKMswhtST+S5t8cClsd/KHI0v6RAWstNN0upedI8Nuj9vhm5iLkmVU6MgeVDzO3DahnqULrSDgso1kJbMzBSBmU7SzlzpUvXKtzAvrYtXPhqNl3czjjCiKzoky1ekgvvUMAKBgxBKQ9FKPw0Eh+9MAaMmG411wUHrEim9Xzxwr9GZloYXFOIRWFVE0RhMTGwsjCUWEoflcCg/N44rLAAkhMbYKxXOetI0vD0jsl3LfNKhPpgPBdHh9HmOyyHb82XyJDgPLxcNMCWscptUteozgYKJbNahk4W1rDcivp6fBCBYEev09qYW9/lwrHUxqhDDEySA/Y1GfssFj2fB5hxXnGyiht7ZneT4di8dIbtjyxgrM3nke0iAJOfC+4wh1oeUWh9JEydKKisGchWWNCDiSswtgLYI0PN+Rj7Tot897eERjCglJgFLaDhAjEMSs8BC/vAEj6WQvVBiXxpb3RlHEUE4JKX1cDyHa8ZRAvj9fBfaVCkDbbipVBFocwUxOVysnVju9xrJFSkb0ystVs7C9RHEp5a9Q9XN6EYqC33H1aUOtZ+gGBW5a+A7oF3rxNT3Hld9r9DQK38KpMGclSn2ije2E+bLPuuRCckwWof2hzVeog7LZCS/ii6KmMmezWGvvMpcd7rkM998Tu+xPnQIhwKPoJCKsU6zIfEdJahaVzdu3KB2Yu6rHakMUyMs5qJwSk5nD1VjEg4nrLRm2HnKQmAYq6OmBfjdI/HIoBPE4+Q9lDJ8UGqGbCK4+fpJtT5L88jOtd+HA0xwNfE4jstj/rEVlvMTxbGUP3rDxaB1Z/wNvdvbAOC3MKjRu/iEvr3Fhkldas0syXX33v9Le4khQtCB1vttq3Di+MrDDpzJZCouiqznkVduJZ5iasEk6w2QEw157pbKSQKcc7J631AtdEeS2FLZPN2iKZvH65pCF6qjnMMbacZz0yDS18Eo4o38udub0wGDrv56FniQePMi5X6B0hzYoS9WVpCW6DJgtnjJx+nrLdJcAU8sUR+gtrN80NRX/B7kl6e5htiyWlIIjLwcfF+zEiRK/Apu+7dv67UWGEzcHrKYQlIDJzGVrje7/7YCeC5FJ3p+AJRegVgCJfatOzrulCFk9QZ2XnoD5Bz0yYIvPtY81gdyGA+qhefS0ZwEvdlLOxMvIcBGdbzjPEgPNC21vtJnMCOQS4rqS81PcYTePa9VP8EkrtxJJUvfaiFn69eJznNUgQUOLqvfR1GcOYwhQdrTIGyBXNHH9nZmyV6Skh68VkHPXGN+CMXDFzBOqxDX23mHk0iEcDx82vBy37vEO24orImXOELK7YU658FsPtvoFIZzpoCL05L/1eN1CrD3VeNkcG3Ev6KJzrwZmwsx+y9SMBS7gB8J1zChU+Niaw/V3w+Jw8bYW6vBV2qzCtFDYqw0dEUuGaSPEgWvQQUXHInZesF99L8UUzUEYTRLMKSy8ta4aWlDLI+fsdYMtoKYj8rPZAoi8xVU7CQ74APeI7KeHSxdoupyirAbo9FVHzeJTyqNINBYBVAUepDGn+WIgujVWZvwTEIMpAOGjeKyaP7yB7OME6kWc+BFiPm4eAjeXKM6w1TRrBUVZYOcIK51mPTn+W9feMq3ncSxPNj7Gw1/Kv4mtN0M4IrbNl1jDnPP7S8U4Lo2j4mwAB2OYnBPuTgS3qv17c9q1hJexyZhz8tcHlcvlV1Lme81nPY6HlLeVFLgeYdzDvOI4ds2vH5ucUBvge4W714sG6nDQw8lOEw+fmFIrngi+5nMO6+sJphTnvbc+psuJcuE6p/CEwUB23O0OXG6ZoCTOidDPeCBcQbPzCCqPVIFIPvvKKrwXwvNWRNe3l1+E6MDusagOKbXhUiOVRMApdrYxxL7zo4bPl9sqXtBIF9dLm+ZBemPaInn8nLQlt6ry6SeNocZ+CJU7RMB2Ha4eVrEs0pIfKPRJ9K7Kk89GD/9EeUg/0hLRX19bz2fI5/QMcxLI6fwnfHDDCsqPxTWxlzPzxEMrvD8jRu7cEb06hnwFK6Jeh0CJJlVHuIxjT48mAM579yrh/K+9nRnbo9ytzJ14oT881rCiViDHHIty6m1D3Iizdp5A2/v+CFoJeRUILVo2P47FpSygv0JhlulVwGU7NiXTzBo4s8oYXqnW1J9Fo4tMhP8ZQGVipVURO30BAPzaM+DawRFeLBahOEvSiKMZR3Prx8BblzI6FihaDAw0l6ClHm8Z5ONS6faO7rZAe0XYPOyV11DgZsmN2VkCS06jc+O5ByzKZtRJm0894RSrldOi771q26GrF4OtXJIqAcqoeaWc9L0LuR4u/EM7xX7mJL7yXKdUyVRBq3g17v14hPwOPsYYB3zeQp7E/irIWBd6vBKyCIaLqFIOete8pEgn9eArCw9NSRnZPzowX2Bzb0RskWWot3qEKsacck/JleZ+CfZYZLfzlUE4rb125WYVSzQMkjOaiFcrxs6KTwgO3Pq362c+08mjSZezhLR8CdqrXdZUBYPNPSW3H7xnl7SRyVZ8RqTaEFOGIr0YrWuTZbBiBouDmRECJl4ggq6Mid4WQYRGXjaEn2mNe3fe5nZJwUHWraSzVzF8XSCuWsHkKgDm3N3xvbnaiuxtbNyGtUTz9DOT7Smqvp2XMuO/kO+fIfArjNsZ6C//Gfm94Y7mFN6VL8wv5CMcg5ypzaeyVR1i+ZMd+D59V9ZLM1HmO40h3At8bRlnxDFI6Xr+FbW2e414g871vo6/R1Io9ZsE7Ao/J7xnAvbULTe/DWLIsirS2Cny8XYr+uhQCY14QzGMEZtvp1zARrZXPcRydjaFjmPEOHg193C16wruzY/MB4SNr5fcvvV4PwWSw8d6c1Qhu4qpMZnuVX5++lYkkL51n9Yw9otJqc9NS9orErvW6vmaIOpUwj5feW6G1ApVXV9QlHIhX4PWcJ52naBousrh0WvdD42vU5z/DfMI0FJFBboexmVHI+sI6Rvbk8HYqc0UGiLHQsqp7z7w0rTHWK7/IozwHeT9bfg/OtMkIZml68zuae/lXrfBeqKTluczPdfQ8oXXw8j/OohjgmXbD++GSU/MEC3lGzFwIgImQlMYX9N1jBuhfA7RYzz6m5Indx/crQurM+Gw9H63kGfJcSDRdtoWZKAgv4Jst35tDse9myzztKeQC6oKmGuZko4xi/7lxltB3ywScwXPCk7gXUixdDN5mQh1hnIPRYDlrjfkDds72fGS79uLHjy7r1wmd+ulucaYYzgylWev1TLv3cM+W20GelolaXCJfyjmvPM4e5SW0SSvbiuI/nvfk5Z29J+L0RHNunHzq5Fs0RsvSb9NTQ6LrjoH/9iJDwmHlxNhbTL4tUfUmfdp7Zxj/K9b7boHynx1s+OhrF/8raHsbkvQMzl8K6vD5UQh6z1DVymLa2+Ffuqbv8A7v8A7v8KuB81Px7/AO7/AO7/BXB+9K4R3e4R3e4R0SvCuFd3iHd3iHd0jwrhTe4R3e4R3eIcG7UniHd3iHd3iHBO9K4R3e4R3e4R0SvCuFd3iHd3iHd0jwrhTe4R3e4R3eIcG7UniHd3iHd3iHBP8/nR6RH+oD+y0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params = {\"model_path\":model_path,\n", + " \"img_input\": img_path,\n", + " \"device\":'cpu',\n", + " \"num_runs\": num_iters}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using OpenVino Execution Provider" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Use ORT providers: ['OpenVINOExecutionProvider']\n", + "Avg Inference time in ms: 32.271441\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d6BtyVUfCP9W7X3Cvffl16+D1K1utUJLSA1CEgIBIgxRIpgog0kGEwyMGWySzYBnGGNwgnFANmPZGGOBB2GCyWABIggJIZRQzuqWuvv1637xhnPO3lXr+6NqVa2qXfvcc18Lf/PHK+n1vXfv2lWrVq1aqVatImZm3Cg3yo1yo9woNwoA8/9vAG6UG+VGuVFulP/vlBtC4Ua5UW6UG+VGieWGULhRbpQb5Ua5UWK5IRRulBvlRrlRbpRYbgiFG+VGuVFulBsllhtC4Ua5UW6UG+VGieWGULhRbpQb5Ua5UWK5IRRulBvlRrlRbpRY2k0rfuLxHwMAfPU//lQ893Pn+L1/94/jO2aGnIGLZ+EIYEb4T16IaNiBs4DrQU0AiQECwKqqcy7rT/dbK/JO+iPHYAYY6RvXW1hr4ZjRtE3Wnv6diGCMARHFflerVfaeiEAA/H/rbcj36SEDkHFwGCeDYADkdZ1zYOYIh/yTfkq8luPXcPj2hnUBgBoTnxkjeoMDwujCzKRvHcO50JdhGEMg8rX0BHp4ASZW7QgQJv7U8Ea4GADSeGMNIsBQMUahRQNrbcJdgNHMZmjbNuLPGIOmSXNPQsIBD04hSuYAjmEJMI3BZDKJ76Udqdc0Dbi3fsxkQJhia2sO51xslwzFTjVMxjQyyBwXqvhhc8IfUfjd47aGS92Hx5+H2/dp4rvJZAoAWC5W6Pseli2YGYuru5geP4HHPeFO3Hzb49C0U2zNjvk5J2RrpOs6HCx2sVweYLVaRTrxsAQaCGvd/0lh+nJ9tTZ2j2dZ090IL2hBqOHN4yXRty+uUtf35cCc+E/xMnte44f5Ny5b74qaB3UH/KLyrMYP4zpR828M4Wu+/u9Ux6fLxkIBAD7us96PO556L4DHHV5ZmHrtVcHAhEAMNekbirgu6qWimaK8Xy8kMITIEAwbkEJmrR9jTGy/KtQQCMzlk+Wci4yiNlGcwSOESgDTYPzleKWP8m8tKGpjSkxOGHPePrOHKu8riLv4TLUZGAEZBKZi4Am/B6FBXghgA8CGrseMVY50wSxCUisdikDYj0kYWtO2fi7YYLVawVrr4WvC+JDmtGkaNE2TGDSRZ9KhCKO01sI5l3BpvOg35CFz8Ix1MpnAOeeZaBBI1DZoDMGYBoamCZ4o4AgMrgh6B6ImjrtO20lIkzBUymlQtytMULdlTAMiE/5RwDnguh6ds7DOgQwwoRbMjMudxZPuvAMnzpwBiOJ8GxBAaT6JCE0jbbdoGoC5D+MyAHtwGRYMCv+TuR0hCwgzNYoMyspSRwRjGrNeg7V1LHORPQuCVoRCepZwPGineJ//TRn56vrr+EsJaRprXpLiKDiiOK+blI2Fwr3PfwDnHreLR973Wlw7f3zAaOTvGlMt61ReyC+eyMLAyjHUELdOCAyQG02PQpIbAjHg1ALSi6ks8q0IilpfWnLv7u5iZ2enUi/BMvw+jWGsj7Gxai2oJjTy/vNvRCAM6YeydrWQZGaPVuKoLfolSYGZ1xbtsG8No2/HDGgsG0MwR/RcElHU0llr44oxstIOmXnApEt8a61exi/dy+LzTN8z1el0irZtsbu7i7ZtVZuegRoz1AYxQj+1ORwrfs2InZrjJI7PkGfeEScGMN6yICShAHit2TN1j1NrLQ4ODtBM59jaPo7JZBbrEjO44HRpnbRoGxcVHRGWDAaYB8qaX/8EkAOSqMjnXSiMCIDFkMaGTDkTxGNriZBZ+vEx1ddTtYkKbyyLn6q6AjrWzib9AgQTFBBZe3GeNywbC4WnPOsCmBkX3veOgQY6huB17+KAAxFToIEx6yL7ZqSvsTr5BAVtYKiGZwS9iUauNcwxeIkIfd9Da+UexlAHlBF57KsgzjHiKXF8KNEPxlfp45D2RCPu+z4wX4ZlFzUs0ai0dj8UsGOaVL7g12lhXusfzgvb4ATgXGh7K8D4f4rhi0ZbFrH0hImVePBuKxF6lFmGIjg8jTDYedcLNYm5WEU7paKTCek1jKOmMAzGHMcuSlcSYEQGTAZgBpFR9OiVfqHxvu+xXC5x+fJl3PK4u9FO5gA1EN0aQCHqU2lMA24nAMi7LDkIblgk92GEfqhCDFwGSXHQlpKvK7gIOKjgLaOfErfxy3pZp4yOWQ9jysY6JfrwdZy7nnLBZ2Co3bCdYTmS+6jW+NgAy79HtW9mGPKaOpGJPj1dTy/KGgxjZczkHpPipX8xsyZQJ4gxrUCeN02D06dPo1wu0i2DkyE4MCfrWkNJfDXBIAyqHE+tjXJuZBtA711oHIkm7IVdMNYHll1Y3DwuNOuFEm44t+hK+oluLlMSvrghkDF7EQqs5mhskY/RXkZT1MDCwfYeLmMMnHPoui6zWmzPcM7CKGHRti246wJzTKywxLX3mWstuu7eSPOaYzOO36u6aKKLMghGMsFCkGre8jGGMJkmt6e1Fl3X4eLFR/EJn/K5mGxtgUXIGOOhYhpIBb1f4xyjaTgqEhTGzcGPFOcXABFD70eVtJDPmf57qOyUVoLG80D5Q81qHxfKYPY0ta5OAJFgIK49LdRqcK0rNWVb8y4vExuQEYv7aILhSEKhxpg2Nad0GWjdEFMybIxxktg80D1IfTWETRbmOim86ZjWaRS18UXFhfPnObyFcIhvSia9GaGUggxQm6EFjDKO9C53CSVIc3O7XFB936PrOljrN+m9dtYAsIGpyHiHroTDi0PTeN+1CB39/RAXYnUNF0q56EQouMqYyoUmQrWmBEU8Irg+OLl5+r7PcBaDEYhhGVgsFjCmQdNYUGCMjnSfiPjrey+QbM8g490CIIA4FwwZ3M5lllDXdSBq0LaEJuw/T5o2CgsHQu8oMuGTOyewtbUFJsb+8hoWB0svEFYrNCDc8+Sn4OTps7Bk0TnreRy54L23YKfpSfDegIhBxDCGwdyD2AQmacDoIfsLzvUwZNAacbsloVxX8CjWCY6HQ8sYExZGzRX35hj51qyDKq0P4BoCehRtPoetoP0oHIW7eHevXk/rysZCIW5NyqKQzgsebcjAWQu4cdeGLpFJMQA2McZF2mQ4EBKT8wvRwVlG00jURwLCa8cUJzL3A7qojq9j9Jswh7ExUU5PWTv6m6T5NnEPhcLSik3oeYYDEQeUm2q7JVxj7ruaGa3fmYoQ9xpc+B8DLQGOexhyEMj9ZxbMAp+4FiRqQxixEpB+MyIubiKg574ytrGNQYUP9j16DTgCFMeVhDehYcRopKBa+b8p2hn+v1r7DIJAISb0H/R3Apqg1AiHCm5xH0lkGqABJtMWfdfBBno0TEDjABgwWd+D830ZnqAxAMGFADAK/xLjFzwZYwDjtWxDJmwgE9p2AmpM9DV7geDH1RqDadPC9haz+QxsGFf3r2K1XKIhP+9NO8X8+BaOnZ3i9KnT8O5+g6ng2hp0xgQlmIKFlNBPZKIQYnZo2wY9APQ9yDoYB7jewRDgrEPPDpisMJ/P0fdOKTKiPiZXEcI7Vpwjt5rqik2iDwroFGXSBasn9FV4GwZ/h6bWKz3luzxgI3tTUbaJoMafCym/NkUAe9pjcmA+gDHT2IXwwk3KxkJBa0gBGk/0mT9PGHc+wMMKS1uRSSmksEKUS4ueGk9sGlkFxAC0yVnl1VU4x7Rs/fcoMz5snNWaWqon14f+xtD6Ta7aGA4XCCOCzlfI6xsRCP5vx/K9X1QmEnPEfBhOKSWD2yATeKFuECHEyZ2SA5ULu5o7svZb1k9YISzeCSpq1vouLB69cJM6wlHblf6NMHDBi2OAGH3Xoe96ROsmLnIXvG2y+CWuiQRrmXOk3DtomgagBL2mfTDDhUEbHbkTFCmGhe179PBRU9Y5NK0PS20mc8y2trG1vYPZbA4DcTEmH3aCqqRrkWMS/SSweQYsocIef2GvAwCIBxYvB+IYuJFk3WhtMrizGA5svSXXtm3aBwyKgxcoQZGFMH0deipuUIxqfGNu2fS3FmrDdbdunUr7IggS3ec4lmGzXzzBpSWCUqy04b5ZrWwsFMakTLZnALUoAo87qkkUiT4iwRNLxsOii0IQnkGEapijqlMz+UbhOcTSGfRBQ81hTIjkbcffFLC1/urwbmKVjRUNXxTQRbtKXEXXSa7xaPiTYBjOTVGfeDikKu2kKJSa60fXkr4YNTxo5u3hyWh4YzdXAHQtmsWOiID68w2uh7M2ranANNn5iCn5EiasqAEjkDkohXzqNRsxc+BnJncTButU5ilFavm9iKZtMZlMMZnPsb29g+2dnTgmEWhJYfMurhrZaaEgOPYRXUE4x7EkpQ+g4JpMdKkVwOHzOKrK7x7WyWQCYwy6rkNQqqPHQyLQtCIZa5T6SUEng/Wj8Ku+Qk7/m9NZafXr/rJ1UMDKovkQw5H7yFsKJYCq6wRAAIyMAaw7ZMGk9mJL0aWSNFCvkvi49qjdUtAaFGEmF09iqJmbxvi2Su2qthlbg218/Pol0sGninWh+6i1k54l4pHv1sE5Vg5ncnk/EVfIYQ2/eK2LCWAHAxcscI9z5zYj8gweGsataKUgG4s61FYKi3y8CGxOafPyHZMYJOpTzjQwvW5rtJDNaYzmiaODpzs5eCjKkg4m8G3GTXxVr2QUzAzH3m1YjtVBa98mrQGTC3VxB1LY8J1Op+j7Pq4XaduYBmRMOHjo11lrGjTtBE07gWlbwPhZN1xo8EA851PiTwsD365EpKXDYNpQlr4dm+ywajl+/bzGlLWr0BhC27aYzWYxCIDhQ9Adu7ipk3sduODfQSmh+tobhGivFQhHUNoUP9Hjrn7OCWC/z9KAwLDW47Ft/wrcR1n/xcCJAqeO87fZoH0bFc1jgNQ2yAM56MPxG+d0PLcPk8t5T9DoHKAPstTGVjLSw9ww+WCQKY+lANqkDd//+OTVtIV1baa/axoKARgZh/qEmb3rI7xkZvQcFACW8M/hgqzheGCJAGAyXilWfWqcedrycyfaTmIYBV7MejwTm+QeikcohHHncNVwOaaRUwG3KC0sp4pDjD4ZC8hJAeawKex96szJUhAcae2POZ1mb1RobUajlISN3+BNgmlle9h97ybx5w8QXSlNI/TkI56cs+i4w8oRzm6fwKSdwDQtHIJVUMGDYYCJsznRSp6UyWSC5XIJ5xDHa8L44p5gU9vczRWjdUpXEr6E6WyCxhD29/fRd51nBWIpjKxviCkBEZxDpp7gE7pP2EhrQWh0QyEwhGLEpqgoSIYjzP6wXXgcztKsC5/X5ciWwnhJTNr/dRTzCBUCkHeEzAEN71/3Ly10dMKhmrHqSOqW5vRm8NYEF6AtBV3GmHfZTs1y0L8fzbVRK6XJmRZrJsAqsHrmYSBbx7memOZvqCWVzMFXZvItDXoLa08IOM4Pe+0yO1UcxlDdWyD5TwWuxnioXXwZ6jK0QpGtt41M74pAygYGT8scLAeieAI+7h64FN5K8AITCCengyCIgrVqOaXiTw83fi/BAnDsI6+MQW8tWjQwRqzsBsw9Ott7dDBg2hZb8xna2QTUNCHkw0C2qWWAcpjRYai9i1Dy/WjrPQkBf7bDW1eGfOqNTSg9Wo+1RSd4YX9OqAcG0dFH4FDqn/6qtq7LNbbZQduxUvtisJ7Ucyma//u1ATTNZux+Y6FgZbJTTwFopQlozRANstUVNj3EdBNNjCDagtIm2PsnhRGAnDLBJRwvuCyiwKD0IxCjLB7m9C1KxoFgyiosbqKBVBm4shSGLqJEVKI5+HMZejNIAEobeFG4MtKYghaaaysJ85pWfB2d1iKNyZh2cFpXxkaqvo/IkMXH2eqS0FlhmbnAyLWxDGdMsaKwAC0ghkKTIl5zN6P89NE7EYU1zSwsjpLlRBhDL1HpDm1YhnJPavwqhYWNeq4PVlmAjVo4JmqpQo6+ahAObYNIRNFCoizMVGveAwveWS+8C2XHEKEJDFfGaRggF5QsZr+BrNcsEXZ2djBppp4BOz/PJjnnIMEHA3bJCc5wXi0uAQfAwnl3t2l8CHJYFybSmY1jZD2j3ETwYoPs4rikb2YfDUbIaZXR+3UVaU/tlxUkU9JfLhiS5cDxv4oHESNF3WFQOLyoWSvZnFL2Y1in5E/6u+jLFiVpM6F0hI1mUshJPY8oKdGHL8BCGBjlEUu+cmKG2d8E+Bi7EOKq+mO9qsq+oRAtWmDUBiuwVtpZp+2OmpyEbE8hb4uUoZKIjEAqQVwafgwzk/aChhidChVtVvqtufpqz0tGrRdBEgxpbB6H+s8Ed5oXzpSBUktKgg/ZQpY2MqwHMpFxp1DEoWAWAZHwmO8VJIYqnfsfpIEPDyPLlW9G1hJVwpdy2mb1L2jJobJT+C1hyBY8q3nxg67QVv4dgwtaDXSBNB9G4T6654x6ZhrQZIrpdBYUtEQTRGLpCDwcGVy1KEVQlm3TtNBxq30MBRV0la1pxlwySe34QxxvjDKCyyxZIpf0GpI9INZkkeHzMOVL1kHOF7QymC/WmnJZ8pRsXtW3ZSld3bFnQg5L1D4OL5sLhaaBs0nyiaQm8gQ+3OApgU6LVqbQKUIqBx59gmEhkSHV7/qi+47WyLoPuC5cxtw5Y+Z6STnDic7bCX8krauy31H2rf8u69WE1ZjJGkMROWcg5XeaqY/uY4z0LXNcG4toc7Wx1eAfHUexqDJ6Iw1XZeFyrJavl7AhHXmzCQK8Mj5pRs9fXlJSMsZmbhGpLxZCdcwSelisGYHVsfMaPKW2vI6R9O74LBwaFeXIu3saTGdbaEIYo3U2CA5JlUQDAVUKBmbOss9GjBBh2k68R8t2cNZGruAKq1bzDVENBm5CDBP9RVqgYCGwg1cU/BmKjPZKuDU+1/CFde/WlTGazhTZDUqtVlzPKbDtyGVjoeBPKuaZCT3BNTBwsJLWuSm0rhJx2o6MBJAnTRswY26CmwrIJO/YEstMyTGfXiaORpoZMuIafKpG0qhVfa+1pEiPjBFvCEdNIzwM3rHnIfZCLcARjWMwzlzzT/5hpfVq6wBJYAz72YBcVVVxm9W0piq8UWnJ6TETDDRsq6qtjdGBsjAPG40wKKmZ0kyEtRBOBQ8KIbNkM6uh2hHgY/kdrAUmk2m0ThmeQcazxsVUePAMDBHapsHOtk/i6CxjuTpA13fY2jmOdj6PH2qUx18V3pxzQJOEagrD9QLMoAGI0NhV8ALJ+Eo68SbEUDHLRbqePx98YqPlJFYIB9gSuPnaKmlcqpdCf0xp3GQtrRMeXPS9rn6mcjsXknqOtLuhsDlC9FG2vaR+975c717SEzTc6faDNBA/9BCJhckkv1ELiv654Hs0DZzzB4DWDbam3Q/qh4VXEsdYu+veAUgHcEKdPm6O5jABYgmNC5wh/IxxjjBWtCCNPQ/6GFh7g59eU+RsEyv40o+Y48jPXzowJP0QIcOHr5D/WtL8Oksjflfw91EX4HWUzVvx9E8kmi8HzTfNhd6bKUtt7FnrRF5DDPmLphODpglpxL0fLipWlhgN2B9kC4zQMvtE5+TDWBszgbUMIp/3aNWtsHPC464M0HAqaiqDmUPkWhDsDKBpW7TOwZG/RsUrFf40NwXN3hcHEQZ+hRZnLIReeIgZoSnr7EjUzTCgolZS6G4ueA6zYGuwbFKvZoWMzXvJjZOFM6zPPC4synLkkNShW0EPoGQ0mRwLwMvkDhmwRBLVzXTK6gIcBFEF1uBn0u3oqJUEm4kEdRT+MOqmoRhsmLQRlnBZz0Bl4uM/pMkS4otajZra1Gdw2RWpN8YFWPwNUduK80RJC8dQCOSakmf+FGFO88CQE835YTVC3X3EAJyzg/6ICJJTTXDRNE3IxorA1+pCU+DVzMoV85TYSxx6fGZUGyUTWLeko76qx7CB1I6BEyqJHDPHvEzVfkbcFQKvaRq0bTizwMnPngnd8J2hEN0UYPVbgMHVE9o0Ie03GcLBwT6uXLuCs7ecAdSmt4BFpKLSCN67FZmct3QIgLM2nh5O33u/vh9jOlEsgjMZWT5kl8ifyjYh+sgRB0HCCp7Gn0lAWmtxjjzRV/FZK4I/UWLUi0Mk9VAZG7i31vQ5oHUMeeNYCzK83Fr/iFsKYaNTNoCiwurgL7LwYEfGy5LsKlkBzBz2kpOA0IJDawJAOYS4ctQ7yRcee1BfagaljqoLQSjGGIVOHFtFWq9x32QuqhJ4IuGOSAqNSAHdFqXnUHCIhluxZNaVMTcNg1KbShjVimaOMgydF0nMXN0nEZDRcmYFxA4jXAMtLM6z/4+zPj8Q+XhHf+9F0HoB+NBWscxy4L2bRI76R9Syn3lS2rMaUNpU9Vq3z/9pMr3St2lK1OYl4zmULEdygQEzgHFtNaIocEQmWS2kKIUQb6oLTBns15GJjSBaJojuHrUGSFYHg5i8IDUG3DZ+74At2Do410WrZigIE26z8QQBIxxKMzoOr+WbhiQM2VtPiYcVUUUhegjhICU5ghNFQok5CgEqzjo4SVuueJRYT8wUvdck/ohC09ZWvocj13wcCmERcKqWb/o2wCDCUkcXxrVSfgOlO5QMpqic82dOygcRNrXmNxcKYXkIc09A1N0i0DdGBSjlf5C0uJpBZhqsQjzlDFFr4OE0moIx9EcuIkXe6Nb1RJH6b3qTHyAafpXDWAqPqrYYZlRbul7Drl8/KXBJO+PM43BtJ1kdwlhEuNddKDWTWfoiUvagWuhi3YgVpsdRtiXBA1x5lwOOtKAdewtQNKDgP4VcKVlYN4nRB2YgsAlcI6a6tkbE3enHgEHqmyT3df9+1D5CZyjs4gliNa8E9veWDfDARX/CdBuI21ag8FYWIXhqIkwDxh3RwkHQhPmSazLJC11vsTDAFt1qgdbAXxTFDWhgKeerSPcRhYLze1gcTkP7nEcWHCwH2/fo+gUcW7BD4aL0vMIx4LgLSoAsIo6XZOXpo33un95asARUgP2hPzIgNOH2PIKcHWF4FzgT+SSFJKzGC9BkxUvSzSSI8lkL6rKsiTiXopAJJ3VK/xMFhQeTJfJCWKbmLfEkeYQ1CQ8OfCiSLZczVC9HTIiXa99yBywFszPzsyntJDEijZSSyeYunHXMTrtSSnNMFj5nbfhEXHJqduBjDBMfhQ8l8bHJfsVhzzR82v86vvkkpnT6rjb+0izOffOKIWUMC4P6Zb3qQS1J6UD59wLHWCZZfZ9BNldQhxCL/gdjIwKxDUwhLSQbFnxT6XdowRTBoiPwamUE8JozKGl9ZQZZ9SXUh9XX+XUD6qrE6jdFmKWspSiognZK4jqieE+Ej/+njA7EfSDgO+elO4Wlai37bKxMYOdgbedXuGMcHCwwmUxx4tiJKKfKudT4030ys7c02MFan3K9d36Pgnv/b7n0//b3r6KzXdwHaCZTGKTb35gZy64HrMuijbSrUWCqXZokFkLTNOC29fd0hyt0pR1HFA4RGlhyXucI80WYwCui6RIpA4Jl3ZcKGOBwI5zQFAufaYKCoxQTZp81NwoahU8EulOkGWlX2Cyr9eg/DELGB+k4YHAx7lg58n0K+qdzsszEbZCfQpV6NoScDS2MIq53nP+OMFsTBFWh8ZEJmmBBvOpqRmDIFDVcf1VFCHPTI+capvLn/8xCQwUmg6Nq7RQfZJf2cM5Axn7GtoxBEwSSHLgj+FDpMQZQHUfF+hn7W7TnoTVTaZvrj0Eq+wBQ0PyQ5Dex/AAHMg1kQ1nuLiAlSLRQrVt9cZBeQKKBsz1gDKbtFNvbMwBe2K9WK8yaBpO2BcPFazdLgVCOI9KH7dB3KywODrC/vw/br7DqLPo+PF8tsFwu0fdd2G9gUEPA4gBEIT8Rglss3OCWWaNBCPSWBnRYjl0EjKbFpmnQmAZN24CdPxTbaSUu2GhEBpNw7WozmfpLkwgAJt5uIwKhBQHoXQ9i592dcRM+qNIhQCYBSmC26ZhWhZBKuonWQF5LWWe+XSJ/eJLYYE32nKw8pjQX4ipAQKDcFFVO2vCbupZaWw6l5pEJEUC5LFJ973bI9BffhzHRlKzBNWRmhFoUVQ3+spRx0yUzr2n6uRtjiJ/DBEPNOtDwlt9syjjDw2gpaKtQL/54Uf0hjDc8zd5rHGhlIg0AGU7ELWnWjOOwUsX7SJ3D6kUYg5JUtLK+74qwHYWFU3UibV1T4PR1IVDu96T9weCycBZwjM459GwxmU2BYwARwzob7pqgoQuisg40jT388MPYmk3AtsPB3j5WXYflchmjmVYr/7tznYdF9lpiSgz4k9jw3gb24UqKX5A/S8HiMi6CRgrGaZ0FNQa2D2LUEPo4D17IOSZICq00TyF/kAiUrvNCgAhmMklWkfpnTLrwStZf27ZwjmMG2GyeyPMoGIMm8CpJne5AsH0frZuUENHEe0Dgckua2SsPLLZCX+x9jJSPQO4jIVRxCYiLycvXwcA9uEimsHqEIcMa10Z9/TGtuXrJdqmljWi0JZybFtFixxhJzbR+LOUoDOsoF8DrNhNBl0woFe0SG4MlKhCQ6KV21DoYfKe00qgSyOJbA/86ATiKL4GTaxbCeD/pruaiOSSm73n2kGnrOsAhVDd44R8YopBPaqh0yfxlfYg2ibBX4whwDovlEtf297B7cICzN98eD6wGnxE4aL7+UJq8yvuS4pzDdDYHuxW61RJdt4KzPfpuiW61wqpboeu7ENUjtyV6Ua8vapL0JWlqcgXSuwJFmxc/XRnjGFpjRkw/QQRYgoNPA8IcnpF3I/kBynwxKFhJVu2hEBF4dZDo0XFOm4pGiXyor7+zW/EeA28FKQXBEMFa55k5pXlug6UTPobcq52lGQej63tQQ/5kumlBpkVbsahr5YhCgRJx6Ge1KlFYhN8hxB8YQzFbRHlbPHzpnzMrJOnIBM0AJFJKGFGoo6R/xiAzy0CbdcPhyfOy7dQUJSRk3xTmX9ZntamyZQXUsM/DBVzZ7+ZFNNQERvDPh8tR9D0AQ6gDPhhxVat4r4Qv3bwwK/00kp6yUKr9hVJYVZuM2gueXCDkLpLaJJUW6VBwMvL51mOUymnD0G+aZk1UBYF2FsmT9K+ivxegyhpkxNvyCJjM5uC+h/fiMPrOwpgWxrQQ1W9sLyz910f1OGcxm02x3DtA1/XB7dfD2g59v4KzHfxteylTQuDDJUWonxk3CcUFjwEAlrDm5LEosBD26FVEGJLlmVrmZJ1GEua0b+OSReh6fyUtO7WRzja411OLAo24PkmsO4MYXovgriKElNexCULTGPQhjD6F6vpQZH9pk3TCWPW9z6NFXjA07QSTidxUub5sLhRMk2aNErLk+LgMKNGLz+WtF7PHsQMPKdYjR/ijmij/Smk/USD4SZfLIKWPyGRY9g+UhkyyF+8nWPPjBH/q289XxRKhoWBJfdTZT8mMZV/BRz9UdJoRRhaJH0NhoA9BycZiCcNRrIVyfN4ILWDVF8PUuKEK5yQoN1F47wVD0lyT2w06n1eCIcAk9Ywxwzw+SN+NWpzabafqa7djaktu6srH59NgK9qM39RdOHrcEYfMMcsKAXmEEw2oImzOEwxNssg1YsSb3YR28v7zxmLUDTxTdoZh2i3ccu42zLZ24Bxge4uD5QrtdAvtdA6fJTetD2Nk7P5vRwCFzVUGAbYDer9fsOp7OAI659DZDr3rka6YDSHAYmkDIJNw4vsI7iESWodaCEgyL+AyiKYMd4npc36eCOnbSuX4IBN9gQd66yDhgNkFgWDBrhZNSWDYBJsP9woZZhNpsAQShM1//z+D3nm3at/3QTDJ/m0TcenXlQFbG/FARFj+1VgKtVJhMhVVJS1ADjnX8+iB6ymyiEoIvNxIzGAAMedup1q0TdQuwyGrMe1IymGbx6V7obRkJIQuG8OaMrQOKgyoEkU1hutN9lmi8EVaRNmiGjaQBMIGFky5x6IjfVyQhuIG07h2zNUIpKMUr7Dk+zs1QZ9+pahd6/GNu842gyFqyWOfiEL2ESnR2wwA2JrvYDqZYjqdwBgfUbi7u4tbbrkVW/MtH3Rj8tQomeIgLhEACAdRd/f2sb+/j9VqBRvOO3jrQJQ3QhlaG89CKAEZ79GoUdqG6BgKSmj9clhfaFK0cmUxiyKU4yC412zIiB6vw9SwBusirqs0BE3TUUA4Cd4Gur5X/XGUfn5MRV/k58Op1Dqb0uFjvnlt1HVR8ff6MZg0nhFAR7XwMZhQEQwVRl7z74/5moUYjHJB1ODZ3K/PIatm7mP0msEQlkxpyfpLWon8HS01pbXq9mp4Lje81wnP2LchmMbA9TYKXifrWmuhylWSFOLDiXK4YIdav3M+HLHv+zhGKtofE4Cl4CmVA7EY1wtOShpyhKw+jlLIbFwO1QiGfUX4ahZmYHpDtyn7dSpKqfFJsW3vsLQ99navgfsU+irSKmOE4h0gxSDZgdmiW62wXCxiwEBjQgQgtWBexvoZfcuVnlwZW3gfYS+QcVT6GqMTThWq9fVPDb+14j7yycGZy9RA0r6DnJrydeXMCSI/AJTgqcAvFFvlS4VW4ZWNzVyowGMISdU3XyU/uoRAUTwYk+oOXSTr3BnrJnhToSR1UyK6zdqP74MtV2Mu5QGvGlMKlf2aZMnjktogIp8EzCRmr78rBYMfaxKoquoQdv9bhH/A4NfgfthOfBIJLClXSrNGceKZOXt/ePvpu3JOy2iu2velMNykz3ELap3CEKsM3h3Z6q18F+dKXEuovENiSNn8cnIXqKGgnIeBwmRaPHz+YUy3jmE624YhH755+uwZtJMWnkt7d0XJyH2Dwe5gB7YW1na4du0aVqtV4hVhvIQUlj2w0ADEa3P9VW6ZtalmP3VM6ZsxJWdM6Sn/phDOXnPdlXM0+g+54jYoJKphsBocEN1owKglqNun9DDjFUqVjnCIdbmp6/i6ruPU5tJQysrmXNpwk9w/pXbqf09jS31pYZOXwUQq+GKbASFJM5Sa9YVbMoaMSFmdKqYc9dm6UzBvinyPJ46Dp/QiasbrNPrUT40RDclkHRx5qWhhI71ggJsctpxZykJYz7g3KRQ0V2b2N2v1PebzeSYY1gmQSoPZ+KR61A3WtVNtO4Q1HmF8tfUx1n5S1MctsNxSkabKefIzu1yusFxZuHjzW4PZbIatra1wY1dgzoFhlvACiI5xa3ssFgscHBzA9r0XGMyI7lG541l21BOHA3O+UZ+5HzMtSQZVY+zXQ1OhrcArlO04qBkDLBSjFZeOt5R4jVCQsO7CVTSSsbj2dw5zlAuxbVlmrEZCa9vJy5HdR6UPbSCR1UlNZNqznAIU6pT/uPiUI8GpdsO8DAZEgfEX2n++sIRu/OZOmpDUsFKi1BiSJqxdPBpuI0cdk1SKzQxxEv4r8FGapKymtDFgUPlqkORf2mVUq5f1fp0LRfAp28WZqFFCKe035Fr+8KtcKIz2XDDGUhuT6x8BRtf1uHrlCma33JLVjxloE8DS+LDDQuMKo4fGH8V6gUbyxtMQQ5ig3z8DgIIetMUWPnF6s17zogKmQk0EFxpyrM/qAyUYNI3a8JCZcOnSJdx08+PRtq1vzxjM5/N41WZ028RUFUatpdAm+0i0vuv9fciyGRrWr3evMBz3YFb5iMLNb2qxAyAQF4n3QP4Su4wVBBqjJBAO8zKUCpbfFpc0Fpq2g4dDBDCJZi9clyOupO30T+YHcb37JxQOCyJaSf5agpSyRwRLtWh6YEBuafRj4ASr/g+HqKmP9B3NGpEJ6U2GiAAzAA4xt2lymqbJ0ztETYfUgjBIx+5kAH4CBpoyNyInszVHhHjvbXrIAKcopExqlosOCZcOLuY9ixvaJMJCC4mkKSQc6OeATp0R+QQDRPU8QznTFVApfkgqt1T+XvrFhkUx9oHwSVoQU0gw5zwiWvKplskYfzbFRdGXaaU5HPW0FuU4an/rb8T1YBByRzUt5tMZYB2apk3aZTGzsUlTzrhgAIO58BhngNP5ExF/RhQalb/C8/TgFjFDoV13acEvbiDy8BiuCCVyhb87BoxE8XkGzexJjJycdPaWStJlRAFJeDVhHa56xoceOI9nPPvjsH18B8bIXcktmrb190QrDd4LAxu1YVnzruuxWq2w2N/HYm/f90Y+WsY5/6+3qzC3JpyNSBupOhGDzHPEG4Re8vWe43EofMt9APk9vRN9WqSt9iz49ZkiheR7pdXDh+1KMr+QOcrzBzkzYcLHDoEx28S0gwDw/GWomFTddJGPBfU1KBLlijGGwJbTzP9VWQq1on2bCOAGzpvVq7lW9OSL/z+rUjER46vwfpyBZDVHS+lnzU3tGISnmMKwyTQ2zyhqvupMOxFtl4Mfs3R3HDK2w8o6N5Z23dQWTVmXgoAXQeV91j6HTGctXNDKx9q5XhfRuiJwERlMpy3Onj27WT9Vpjzubsr92GsKI2nTEMWXDiO9TFvNmuP8BLKuGzugcuMcCGe8wcQxC88YCNZadF2Pvutx++23YzabqbXoYgSS3IcAWQ+cFDUghfE659B1Hay1MZ1E13VgduGMAoPgU0NYLAHFiDNBXBOem85DDVfFsyGN5vMmQuEwetK417wvNR9wZRHnMnM4qOKSxMlgHUtOKY1w5ZsIm/Pfu4E6sL5sfvNagYByAXmzl5DcRDVmW+wlUDqAIa35tSQHnEQnc9n30Rcfa9SZUebGqCB13P+o/JpEafOUxWFBIDil/effjrWrx2+MgbX9YDEUAA4tiEzLWc9wN2GSAwsMwjdrWnyyhgBEbT3e5UXDeahpb+tgLQWjYQCGsnsZ9NhNkfhtLT7CKorhgLrfOI7DYR0rPvWAtBWsBFEJVT96fHG8nO+DRTcSksCo0YL+6deRhQ9F1mORNNFDv7VzDgeLBe666y60TWIHUehmPSrFINKMh9c5h261xHK5wGKxQNf5ENS+74KlICmsXUj94BEgtLZOKMTfxYJCfb3XcDP2jAUAvdb9m8F3NdoUfuicA1g8Jn58HE9nF0qCtM+yCTyukGk+kbvsBahAFxXemlfzGDvKFVjXFX2kS0aQQalPJmX+3SgTDlZFPHHM0uIh34/RhViZG2rLw7bHtBJFqBXpm9w7deY4gJ/0KAtY/IOsrXVjOYwZ18qYNTPWhwKpeAeIUNDnNTQ+jlo0UxyD5eiNln8OtVEiUXzG+qPhrxFUEQcUtXj5nuS1uD+Cub/pWKruRfldKQomts1xDdSK5OTp+x57u7s4ceL4wNLxexTFAawk9cRYie0tFiIQJJ+Rg7U2nE9wkH0EDv7zRB5jtMWQszZisdWGk7uvx5Wysm0ZSNTe4zfDUOJSCc7c5vF3ZMy+3qsyFwR2aXcdtOX63mBdxZYDn/krdR9VGw+MfZOSEO0XYZSK2jGbeqvyBiKq5sTn6I6pM70aHOXvaR8g/KfQ9nxknklVNLSsNZ08CkH3EW+Cw5DYhhqabn/cCnksJXclAcJ2Si1cs/n4zZhmt4ZwierCLNOMCDGtwBi8wpg2tZiGjIXUfyuHjeotQuzFSBOhcQJG09YHfp1x9E0Wao02y1VBzHHjHdEFK8JNNNfUhtZ0mRmTSRsFcdZyhVGnFzlcy6UXCN46kLQWDtaJRs0RPgpzm89Fwj8RAcRZevWIP6xX+DYrYimoJzWNXBUtDKQNfyfCuKKq12sGc6HocQUe+abW1tASqcPNcW3+FQiFMuGZEFDU6BQfHQtdU6BGoq0OJJPKXm/PrC/NsLLvpL6CZ4Txr+vXtxt6JT/pEnngNxXFvTVoIY1JBEqIQS7VAUMExwZkfFtN08RDWTJwQkUIaA1Gaxz5QDYec1nWuXtIHRgSUo7vC0aXtO0xpn54f7q92t/5AhkbkX5f9KWAWQNqwieJGq6IXcOmNE0unFHRkqivfQVR0F6TKRGazhmAXNAuz8Un7cAg5nBJjK9n0EQFX1wXRN7fP5vN8NR77sFkMvMb2D5dTtiLNwX9yVhNhFWUIDDQ931mJWrrUhiTKHMSf5OfUE7prIkIZCZoKQleEXoMWet5pE+aBo2rYmriczk3VeFNYID1pTrDO1Biv0yBRwCszyKJ4C2+cczxsqjEB1PPuo9B0bTDHOJp6veCAADpeQfiocvDyuaWgsvvv41MN2MGQCJsRTDxPcd3vprLGwkSN99cCcIn2RGFlpT0h8SgUj6m69cmfESAcT71LLFfLbkWlYhKfJQ+XYUgQ2lCcmxUWQ4+8iItHsk+Ke1lwtH4sL2xxHODsokwKATLYfjicF9YSoyg0jwomEufcAnOJvNSamWl+Q6k8y/DhZ0gVi2m/4q+IrBLWmjS31H1+6w4KxzP12ARl16lyFyDwarwFB18/BpS0v0lWpJ2Y0RdaMOEXJ0EgiHJ6+9vTGMKvMoEWoL1EUQKB4vFEvt717B17DjOPv5OnyAuJL0Dh+9DSGYSwtKGjEs0UABosHPsBNqQFrvvfSSSdSuAu3Bxj/Wnm63PNsrkwCE8tW2nmJgGxjRAY/x90UTooibt/0lodBIGAbtyv/QaS0/XF+vJj0vxqCD0/RLWa40hNyv4vl3mOvKtyjmMuPwH/NEAkJByfa+0eE1GAZfsqxYqspMBCQaorncX6FDa/QjnPhJpKVp0uRCjHxyAiKenPPPZeO4LPqusOWj7z175W9jfu4ZPf9GLsxq1Yb7ldX+K17/q9yISPv+rvhmnb7oZhRjFq37nV2CtxXNf8Nn4hZf+2KbDTCWYuPP5MXz5t36PajmzTfC7L/8pPHT/+yMjTKFphMfd+SR89ou/AQDw337yn2Lv6mX/VdAUSoGpBYK017Qtvvrv/l/4xZf+C1y9+EjOUMP393zM8/CCz/vywRAePf8AfuWn/uUoA/7Kb/9+/MUf/g7e/ZevS8OOzClp4QDwRd/wnTj3uCfg/Ic+gF/7z/8munc+6YVfho96zicKOiDM7l1v+DO84Y9/F1/xHT8IAPiNn/m3ePCD7wEAtO0EX/t9P5opGavlAv/lX/xAvBFNL9iv/d4fwWxrW6Hdv/ull/4YHv7wfSBDaCdTfP0/+KejWtMrfuGn8YF3vDkasDXBNZAWRaGiWroURb1Qjqim+C7+DLJY69/atSN1hSnnIHplxVE+R9ZKzH/gPI5zJuOSYHDhKtPFogM1KzTE/oCaSYJjHXMdjDoMZjbfgmknmIWINGetvzPh4ABdt4qHDIW+24nP3GkaQttMfEgtvHB25NNBr5bLIFy8+4ltusjLa+JBUVLrKVdGhwf4khFWGSNroaeVET9G7XqTQNZUb9in04IlU3KkO/JzFZRFrimzjtMHkGXGA8WvOh6x0MbeV8qRhELt9/ri8oBfeuQ8Pvjet+M5n/SZAIA3vPqV2L1yEZIK0jHj417w2Zhv7+D8A/fhXW99Az7xMz4fRIS3vv41uPDQhzMS/eiP/xQ87VnPAxHhDX/6+/jkz/kinP/wB/Hgfe9XvQJgxq13PBE3P+4JOHvLbZsOcTgO9trRudvuwGv+x69iuVjEPoiAT3rhl+LjPu2FeNtf/Cne//Y3RUJ77qe9EMeOn8SJ0zfh5sc9AQBCGlsMNHPBZ4nTJz7to3HnPffCGINbbr8LbTupwnjvx38qnvHcT8KJ02fxp7/zywCAZ7/gs3H63K1DNwuAMzffio/9pM8CANx+9z142+tedSixEBHO3Hwbbrn9LnTLhVoAjBOnzsCYBm9+1e/7xRwW72Q2w6d84VfgljueCACYzucgIhw/dQbP+8wvwNtf9yeFsCJ8xpd+Lf7kN34Bi/09AMBsaxuf8gV/HY9/4lPwl69+JR556EPYPn4Sn/TCLwUATKazqLcSEW6+/S68+nd+GfvXrg7GcOXihThvgKbZxDBqotOPsk7f6xjnOkvdKwVB+BbCIO8j9ZLRB6d1N9gQBUKahvLwHwCSswXAcrHE9vY2Tpw6BRDFvEfsGxsamuTh8QElYhn5emQIbQsQTUBNG7XovrdoJlNMJxPYrkPXdVE4AF6Qt5Mpmrbxuf5FQweDYf19ysFE6K0NFoyFlcNfsp4kp5IGt+J2065OvcGbIyn0ryzQzMOBZKV43a5QEznO2GBd1+Y4qtdKz842sQHlbhqOTyiEiudlJ4Q6n66VI20010x4/bwkwgsPfQi97aJQeOeb/xwH+9cw39rC+QfuBzPjo5/7yQAzLj96AW98zR/iEz/j8wEA7337m/Gut7w+W/R3P+1e3H73U9E0Bm98zSvx7E/+DPzsT/woHnnww2HkgTCcw+e++Btw99M/GrtXLh1liKrILPkxPfLQh3H/e96B/d1r/q1hPP+z/hruedbH4+qlR/H+t78pfnn25ttw8uzNmG/t5M3JvgStS1nhy86JU7jl9juh02GXGgQR4Sn3PhfnHn8n3vu2N+LPfu/XAQDHT53BU+59bnVU09kWbr3jLgBA045NPwVt1sN451Ofgenca+rRiiNhNITLFx7Ca//HrwIE9LYHmPGke5+DJ9/7HDAz7n/327Dc38PJs+dw9zM+Fs/99Bfhx77zq9F3XRz7bGsb3/UvX4YHPvBefPCdf4ndK5cwnc3x8Z/113Dfu9+G1//x7+LD73sXTpw5h8fd9RTcec8z01JQqHvTn7wCFx9+sD6qCqOIf2c5qzUm1IDLh1RfhDGcuvauujCTqzXXNysQRS03Vyqq92pn2mXyvzsHdF2HM2fO4vTZs5kKPYajBFEcenRfgeQubvaHk4P27phApkFrCK5t0U4maJYNujDv1LQwTeutlIyz2mBJEdp2AucYxtjwysULZaK70jlY9IM1VJtnMQTTXQflCJNiORg5Dxm9f1z+jbh+xkq29kn3m7cp7iyK807JKzO2lzBCd5sKhQ1v7awNnAf/wov4t79hSH8DPP1Zn4BPfdGLY53VaglrhxNatjuQ7AysFgu07QTT+RzT+QzT2RyC1b5bYbk4wGq5jJ+0kymmszkm09mGo/aIXC0X+OwXfz1uu/NJ8jiWbuWjLVjh6Hde/lN4+b/9p3jlr/58rGdAkORehtIdsWPlLa/9I/y/P/GP8Qs/+U8zAULh2/g9Ae976xvwa//5JzDb2sZsaxt//Jv/DW/8099Ht1zEb4h8v+fvfz9+7l//I/zcv/5H2Lt6JbyvQeDdEaZp8OJv/99x062Pj0OXvo0xQQNcxqR+Pv0H4QPveDN+87/8WywP9vHyl/wIHv7wB/FRz/1kvPCr/jYAf2JWMzLB3Rd/09/D3c94Vnjm3738JT+CCx++D7OtbSz2d/Hyl/woDnavAuABHqfz7YgH+VfTqPU4M6nC+VMrv2c0nn9yXUXfpBPa027BIZyeBTP5dMhj3RP8joWJqmz45yzY9QD7MwNkGmztHMP29rEYxaeHlZazHjMlSIg89zCqnmlAxl9bieCq0m0SEUzbYjafo53O0DStv6bFsD/xzBYx/UUYrzEG0+kUs9kMs4n/ub29jfl8jtlshul0irZtvRtK3wGOfK7lucATLS2NO2Pi3deDwgUN6FkhQkj8FP6lcwo1GOJ6DOlDyIjXPwl5PZ9AUAa19SBts7fvtIJQ66tsd105sqWwVtoEM0dkHIB0o5QAVRDby17yj5M5pvOJy/8YMX217sbaHv/uh78bX/MdPxAZ1mp5gJf80HcCAF7xyy/DK375Zdl3X/g134onPu1eXHz4Qfynf/GDa0aaxniwt4uX/MD/qtqhQCD+r1/6Dz+O+9/7jhoykuWCuJ5KBSTDRQ232VH/NZN74sxN+LYf+on495+94tfws//qh7IFUiWK6E7R8xtZQ6V+DuMrfvGn/SU3Amdo495P+DS84PNejP/7733tsI1i3AJfeiGLLb37sm/9Pjzpmc8G4F1UP/qtX+7v6y3K3/qBfzF49q++5xvifs5hRY/+sHofuUJr/pKioarsNehv2W+EUsjbwyA4cmDqAbSYz7fQrSwmk5n35UdXhN4crzOa8ACmyVNSiEvRcQhzpSBUHfvNVSIwBSZIBgaADQIOzvkNmMAfiAgNJrDxoiyGMWnvAACaxjNIay1Ma2H7ZRagMlAoS9qvrAXJ2ppXU/sHVaYaXGjUQm9AS4p3jR/Bn0lD9QoA/D3U7Kx3z5m0Vvu+BznlogrPrXOAc3BkYr6qUigCADWBBjYNUMGR9hR8QrnyDuIk3QCRCIwUp8LqLN1f++pvQTuZ4pHzDwwmjRhoVc4iwwyjbg76ur/3Qzh15hze9OpX4tWv+DUg3OD2yz/1r/D8z/oC3Pu8T8F0Nsc3fu+PAgBe+Ws/j3e/5fUeQiFaIrztL/4Uf/Kbv5jlRxqaYsrqgcRX+8m/52Ofhxd8nt8Qn8zmPuFX0Gy8qee85gWEdNmhDxesBUrhvexcZKjOOXARfSTafUSwLM4A79d+9w/jpltvBzPjptvuwP/zf34HAOALv/47EIyIoU9VC4fIdMXkVX4REE6fuxVf8b/+7/ipH/kefNHf+ru45fa7UjtI64pB8XrDBoQXftU34p5nfwJWi4PYHhHhTX/yCjz60Ifxxd/83RlcYvkkOIGnfszz8Dlf9c0AgG/+h/8Sr/iF/4TfetlP4szNt+Erv/P/8HldgqS99QlPwpd9298HEeFnf+wHcfmRh7Mxf8V3/CD+8Fd+Fu8N9KD7yf5W/6BQJAxORqvdLdFX4EeZ68ZhzgTviRMU/RLFy+mB3Iiw6EHhjuKkiQ5PXse1ZPRZC+cvpncd4Hqwtei6BV7/hjeBqMH82BbO3nwW3DdY2R7T2UxWcxiXTX1FrRMg03hmrKy0pmkABzCsXwnWgYWZMcHnKjMhLNKA4PxayQQ7Rams2XNkdLJOwnojeKZH1qBpDNrJPMOLdzP59BqyL+DXlQFzD+vC/oS4oZh9CLlzKfOakygjQE6KG+dDSxHaROOFVQrH9bh3bEBoQMbvMfkDZC4TBmC1Ud54oarveSa/qGLaJGPktkl/hqNtTBCaBJC+hzLQUR825pEr6OvKETeaPXNcXydIV1Kmayhvfu0f4dxtd2Br53hiynGyckL42E/8X/Ckj/qY+Pfr/vB3wOzw6EMPYO/alUiMu1cv402v+SN86H3vjqB92uf/dTznBZ+F7eMn8KZXvzLC9LpX/ja65QK7Vy5XfLU1hGn4PYzn738/XvVbvwgiwmd9+d/EJ3zmF+Av/+wk3vnGP8u+HLaf40j3V3PD1fyhEnEh5fips5hMZ7j/PW/H6175m7h66REAwJ/85n/DbXc+CS/4vBfjj3/j5YNR1X2OOdR33nMv7nnW8/DHv/ELuPzIwz4FcjE6rcmTkYvHGTsnTuKRB+7Ha1/x68Ef7CsuFwd44P3vxu/813+Pz/kb35L8qEBIz5xQM5nNcOL0TWBm/Olv/SI+/N534trlR7E82MOv/fS/xud9zbfhVb/xC7h04SFcvfQI/vC//xwA4Px978MyCiNfjp08jed/7hfj+KkzeNOrfq8+OdEQpIzvi+WgUVYTJrEdrWtnboB6kTpe+It0rsCnNzJG2ogasrL0DIxXXMK1qdZaTNoWd939ZJw+fSoyqCDak1DIulFWKhDvWtBaqbUWZFoYGM+0yGvKrndKK8bwoqnaeMTLULmtUK+BiLvozsyfawVLiihfDAPHDlb+Zs/o2Tof4eQs2DFMS4CTzKYBMkMRRcwIOZ0MCAZy3bBPuQ9QU643z7QzK4zghVdFafC6tldO/ft0RsSB0VvCVN29TLI3RsJaeWPrV8p1pc4+7H0ytXKT6/3vfAsIhCc8+ekBoYrpZsTsfdmaUbzjja+F7buMhJ5y73PwwXe/Dec/9AGc/9AHIqJvvf2J2Dp2HKfOnsPdT/8YvPdtbwQA3Pfut1cX5/iYfJjok5/5HLz3rW9A361w6cJ5XLpwHkSEJzzl6Xji0z8Gt3z4Ti8UouCstVTxRw7cYmtwu8YNdOnCQ3jXm/48jv8D73gzbn78nbj3Ez4NDz9wH971xj8bbZv0f8P3t999Dz7quZ+Eu5/+MbjvXW/DPc/6eGztHAMAbO0cx9Oe/XwAwPve9sa4byHfP/neZ+P4qbM4/6EP4J2vf423INSiWOzv4m1//ie46+kfnTEEE+b6PW9+Ha4++jCOnToT3739L16Fxd4uiAjdcoG3vOaP8KKv+XZcevhBvOuNr8UjD96Pt772j3DPx35C9BeX5QlPfSYuXTjvhcKGJbJiyh0rY0W7YSp+iEHbY+9Sg4lpDnzJ2ecpjDE2FSwLFjeD86mrl8sVzpw9i9tvvx3Hjh3P4E5tJbAIqHiq2J8nqIzfWzW1O7vlFHOOgIyehZ/F7wzK8wTaDTPmfpR62n0jxTkH2/u8ZY4djLPRkvDKrIMzDsYaLzDgN7KjUAgcljjBZXoGyIBNA+csYHs4MEzbhj2WpL0zOEaPJXwbOPSIB+qIw0k98UD4eWiM11aMCMugKMpGvSh2BBLTIIWzssL9IeXIIak1RjYgUi/Xqvcnr5YLHOyFCB4nbhaR8Kne6/7wd/Cuv/yL+Lf2FYIBmjR40Vd+I37pP/4rPHj/+/yGcmjgFb/8MhARnvas5+GzvuSr8Z63vsG3URlPbXxqIJjO5vj8r/02/Od//gO4dOEh2D5FzPzWz70Uf/3b/8E4vnQXnFtSZRm4eQYNDuvuX72MuYrfL8dw/NQZfPoXfRXe8+Y/H5zIVK0NrIRnffJn4glPeQYA4DO+1O8JbB87AQA4dfZmfOaXfh0A4GX3vQ9XCqHwWV/xjdg5cQoPf+iD0YKQd0QE0zTYPn4Sr/zll+Ha5Yuw4VrN2dY2nvqsn8Hv/r//AVcefRhP+ZiPw+7Vy9g5fjJqVokhepfD8z7zC9B3HS5deAgnTp/FF33Td+Hf/x9/B5cq0UcHe7tYHuyBCmurbjWlBeynMdoLQzOh8i2r36VoXX+N2uC/k5oZg6/Ap9ehOA6UBusVRS8U2Dl0XY/d3T08/s67MZvNYagBgkvHu1RSkjuEcWd7rmoOtPAACE1joktkIGQA9Q0NeIneq5BhJ69csCw437hdt5ak7ZrwBAgULAjj4K+YlVQ7jsP98QxuOZ6pYPZaucaFREAZIpCdSjLskHm2Q88rTLd24Jx3s/lU5OHbrs/wyMxg24Kc8fo/A86m8TEsQN7V7IL1B/JCr23mQTCYIS5CehF2DmzHFdayHCnNRW1SaporQXyJyDk9M/78D38Hf/7K3z7U4pA+dH8uxCfrjecv/+bvwh/++svxuj/63fidUb7HrD2Mm/FVRuypGQDwdd/zw/jVn/43ePebXzesNwZ/xS9asxZkfIPvs2dpUQiD/+l/9g/w177hO0f7f+SB+/Gf//n3V/vLS/7s13/mJWkEAYSv/e5/jMfd9WQ8eN978bIf/4fF515jmUza4vGwr5sffye+9vt+FMyM//CP/i4ufPi+KuzvftOf46EPvhff/k9eGtuSf03bggD8/L/+YTz4wffg9ic9DV/zvT8yMjZffvtl/w7vfMNrImM7rAjm/WVikudonH42KWMUT5RngU0vBr8k2HPdBcxAo11cgHcbAeCeYXuLbmnR9w633HILptM5gBZyF8PwXEUMrPVWPHurg0wDucvDp3sRmNjn2VEtOOdCBoicIel1kLmD4pUj4mWwsf7Y2imFTIajSn9AitbhInmjZGf2DgyLSdukew4gkXVJaAuPaVrhNz6Utustru3u4vTJs0hXAXsctm0LOPZWCPtNeAT4HPewto8CJ8JvCEbuISKArXcegQgNNWgmbRQAkR7gXWF9uPku+LnKSa6WI0cflTmQaloXM0UAMn9eQMzAlFYupFg3JNOqSXx9WjR07KnajZvYAPD5X/O3cfXiI/ijX/+F6tj0GMryn/7J9+Pyo+ezZ9/8D38cOydO48EPvrf6zSbM5wv/5nfg8qMX8Ae/8rK0iVZoWvJznSD+n11EUzQhBFF8zEl9DERovDYqj7353uMl3/8tONi9BiLCE576DHzJt3wvAP95ubhLfPQhAEGyej7wgXfjJ/7+N+Hbf/Tff0THGHRmT1aPRRps1FNeRBDJAS3BgXMOk8nEs7bI58K5ABI8U7C+w90eBOwfHODgYIGbz92K6WTmD4apNC1F54Ubx0fVOAaIlUVBKakHUc488/M1SeuXm+KapkG85F4xXv1NYgvraX2TdTasJ0pWE2nTWwSBoaaMFRD7haO1GJpoTAiocbEtZxkNMY5tb2MynyR+qRTMlgkIeaIMCE72E4hhJgY0aWDAAVfO/5Tb2ZjgL/HxcFMTeEJj0BiT4dEZh8l0Eg8Amg3xtLFQMLKBookl3sYUNAWXbwTd/fSPxnM/9XNiG5/+BX8db3zV7+Mdr9c+bm/y3nrnE/GCF31prPv8z/oCnDh9Bn/xh78NsBcBFDURjgLg937xv+DYqTP4kq//jszcZgYuX3gIv/VzLw0YcpjO5njas56H2dY2fvflP61Gp6ae8yW6Whzgl1764/jkF30J2uk0w8mxE6fxx7/+crznLa8PaQX8IvnML/ubOHHmnN9QD+Vz/8a34DW/+yv44LveEsfyBV/3d/CEpz4D+3/xahgQrNwmxsDTn/tJuOc5z4dcwPO5X/nN6FZLPPTB9+LVv/1L3oUG4LW/+99xx1OfgS//1r+fCZTz970fv/fffrq4upBx7vF34VO+8CsAANvHTuJ5n/H5ePpzPhGL/V38xn9+icxk/IKI8EXf9F04E06G33Tr7fiSb/pu/Op//JewIXeToQaExs+T7s+IEEPWnjEGn/91Kcx369hxtO0E/+0lP4L9a5dDfcb+7hX8wk/8MF74Nd/qT3QLY7QWL3/Jj+DRhz7sGad1WOztAgBe9DXfhm61hC6/+19fig+/753xb0vJTc6AX+ccYvsDEUSyJng/eXglQyH4i8NqJT7WzExzOYWUSM9K4MuJZDALCqNrBkSA7cBuEpmt1yAJhoPPO/i+PTMBiAx665n6uXPnvCVt/GZwk3KrRreTaMME5zdMCfDXUvoIIu8SaUCOAn36TVahHa+UWjjXg00IswzsU5DtlFuJDMOx3CSXNHrfp4sI1VZyTXGouYRLZSoJ1yDOVNvMPgLJWwchjiwosQKr3+fk9E4EIXm8EBEmkwaTydTniwt2BTvBK2CDEIl7HmwCPU6AIJjIOaAxXrEigA2B2ETmToFR+alvQjCHjMkrDE3D2XqsHnCslM2v4/RoLhSLSErhzxRPy/DRJhce+BAuPHB/fLbY3wv1WLXC6FdLXHz4ATx6/sOxuYPdK9ALxgPiMcHO4U1/+gd4z1vfiNuecDem8znC3ovs0eD8h+/Dfe9+e/zmvW99Iy4/8jD2r10pRldLZOCLsxYfeMeb8fi7n4rZLA95e9Mjv493v/kvcPmR3IK4dvkiHDMuP/owHrrvfRAi6pYHaWEDuHLpEbzj9a/Gh97z9qiVsmPAeDxdfvQCwMClC6n9vWuXFZ4JD3/oA2jbCU6euSmblYfuey8eeN+7in0UwHYrXAnwXlbtrhb7ipnF/wDMuPrIw3j75YsQVmGdv8jFEIcDPyb66v/y1X+AdjrDh9/3jsxq8HyOsNi7hje96hWZe+/KI+fxoXe/He976xsQc2Eyo+9WeN9bX48nPPWZ/mBi4IB93+N9b30jDCGmVmbn8PpX/haiTzwNBO9/+5vyDXGFEx2XL4s2MpGCKnzLnH2ZeLZYycnNV0YfcdFW2bbgOwoAXSJMgcHIOQT5VmnVcVucCc4xVqsVAGBrawvHjx+P9aAYpmxSi9JHYqGEK0VZbpHjxGzT5UpDnEd3nwmeg5BTiALzIhf2JDjcrRAWbUKZwKDEhMLnWve1EhQ1N7KuUysGPpWH46ToiVAwmgIGnhKj8JfazzDDwsgp0poIiOhSCxMhDN9bNfBKOHsLQnWqaF7OTCTLPHdDbSYUiDf0Q/z4931T5jrKGlGTYIwJIV+JeKRwkMJBVgPaBIY3n4aTyNFSAFL4WSophlsQLCYgQn95EemuEeSGi7AYWwZT2aZaWPrAmq9n4jNNHJGwXFqckiW1aUJG1gIoDn1ReQc1gjAJrbqo6dVLuUlXErFTseN5FEfjCc6YtFCM8bHiRGBnsTzYR9/1AOSe7jwdst8Ua9B3S1irzrwkhMR+mR3SJSteI2VmLJfLLCRyU3darCv9idUbP3WZVRNxEBccRVoDjM8BVDCBJBSGC3DtBrdmIiMMKxsv2giPHrmDaNaeEXedxZUrV2CMwcnTp/GkJz0FaBpw42E0ZoLJdCvOTX4ASnIihbEan6PItN5VYgI9mJBIzx+68mGvy+USy+UBHPfw5GSyufJCyZ9VENpPdBncSoDf/IWoVUN8jgkKPR+6Xukmrr2LArOC/3Ie/XyntZueqb0O+GBWOUHi05sj5xtAOvvASHmd2B/yi1FLHDa5w3o3rYn9RvqIptUQL3/rW79ngMeyHCn6aN2mqDxnSVylgCoqBYCTAa+JYVg/b6T0uQMOGhwWU0+6iv3JN1qrObwM+0utxDoQnOR48WTVR41Oie+oOcotc9Kgtd4EpUZnrIzAjAApSpzXpE3k2AreDRmn1K39zmEMxoj/UkCnEAcPr80ELUiSrEkRgSCt5QIhzU9ivEOY9BjyA2/D97UNx6H+L71uWtbTz9h+Vg2esVLbV8q+ZQbIQnKL+HWTTjkzC2Pzc37p0iWcu/UW3HTrzWBj0DRJs4znI5DTSMbAQ+z7qOKU/AheSdB3KoAhKbczgYB8veTv1FwKc65oviVOS2FQvtd4HHM7iXBat1L0RVCivDRNM3if4yipoU0QEigtjTBQv+GuTSSEVOaeT1hr0a86EBFm7cwLbNYrLeGwNvbDykf+nAIG8OQlDGDky41h2HSAVdXviGXzTd1kC6xjDlltnwMA/rQnp0t2RoE5pOsNxnu4gEi+1rKeIcK0bYG2wWQyQed8CB6vbLiLN2QLikwl3RORa22y0VnXAvNlNBQG0QdcYfzr6YODewBaDqlfat/SgGSjxfE/ubD4eEL8fgYXacHghXTf97j7rrtw+txNOHb8eHbRign2ZGTPzqIpzh/IOMVKZQCWGf6WEc7IjdQ3ogAQT0K0oDp1HYH2+B7Sorqsphz7EUtpwa0rNYE41ob81IrOqBsL8AL6EIrhdJdqMPa8EJAIJdig8HKypK21mE6nWaaJUiRswot02XxPYQNNs/Sj1ZGU7huQEjUHyidmnVYQCYwkdG4cnushprF+gcDEKkzC/1KMTd3YxkVd0YpEg22aBra3wcVGirGGhROtwgI3hZx9rJrqWDXRoMyk8YnDjN/IZPY5aBhCgAYptG9omhP5serc+puW0hVVg7FcuNn36p//IFAjiVGavo00GPzpul2xhkrCO8pYjloyjbbAm8Ajbgqhmel0ijNnz2LrmM/YKxqnEf83GHEXdCyfUhalFNwb8Ae9/HdNFC4af8YYgA1qIfKKnGs9juuOGVzjLQht1CyGBEPlncwx88Bd7uv58fuzAhTutRgCmlt2/j9UramYNmvcpj0HEQ4ghmWGaRu0rvVRSxLaWoxX0+s6HNTK5u4jyQYSb0mT/0iImhBihClUl1WntQ2GbCh6YFMvqsO06HSbWvomsZkhu3qBkZilVPSjzOLNmabWpPV3LJwloUcpRUP9kwBSJ7kZMI1Rl7cIpzIg2Nh2eUPTGGPdlOGO1eHC7BO3Tu8ciA1acoC1gLVg+MgpJ+smmP4JNV6ziRoT1zTEcfhEcA4XqocpNXV4my5ouBRvjlP0M8Lk46wGl0h0myHHHx0BjqxmOQVKm1YUFV5pQZs2ZNEgXMXphYZ1jN5ZtDN/b0HO/BCYjY9aygQEyeaqpEAVoeihoTivJHws5YfidAlO07Rgyz5anPTJZMDnAEpRPcP9yiELXa+Y1rXhyMhL1251bQRLVuhJghjiexfxnc9OxarRw1D0xcj5U6lIiyLoWGhM5jS14ZwP6W1M6w8NRhc75fQa+WZQMAdQ1ssR3EcuWwgCIqtQTL04qVRfGcglBmdSDWDEPTKldcQpDZOYGLhqR3rX/jmNgop/LwdsWK5Pq6Z462YSaMqHWjIcqLBGIYK2id5hkogPpcX5RXT4IZQx7WCd9ZVDVo4tMGf4g1AI0Uforc8TAysnvXwfcry+SflrIuXoZISHWDVp8dLgfVrwQ1j1s9yqoqRE1LWHBCnX4EzPTLA5xpabaHCPzVIt9xPSDy94Q/RO06RrO0OUChB2GtoGpvHhpKRcPhwsOsMOPqTYCZsGgcHcqLWdOpdgEW8UD90iyYprfQoJckH+iPbtT+mWNr6ec21lblaGNFLCJG0P/mZVJ56b0EJItLRYMSp9/qBuPf1GFrJMYivkkI7tgcUsD9Kt/B03mBu0bYu2bfOzYyM42FwkHEkoeOQMJyqEssWhViZS+dNES/Qlj0DSgGtemTXFuRDapFzPBt8YU13XVvL3VsiTKoyL0uSXriK/sKLaDX89qKzmw5n9YbCX46wLC5mboVUnDFksW7YOvUt7IgQfLprGYuI/YQzrGGaJf9FMD7uHojbG7L36b73O4bRCQVUMPHHUItO+3MfqwiwhFJedC5l2p02DeBNssGgaY3DH42/D9tZ22FAWnKa7OBgq4yc5AK26DV2VUIWZYdn5w2+GC8EqIZFpzH6+OT4nCqH3I6ziqCWzljQkR7GclRZOxoSDY1DMx6j1p75PGushVszRStkOh+MKrrfo+z7eIWGMF+qNaTLB/FjhOPJGc1mY04TUgUkalvaLX19fRZ6UzJ+nzMfrwMlhC3hjsHVFTtrGGB+LCxSI9fKNOAIRgzlFIxHxoRP/kfFtV8ziMIU+dNbndSciHwPtbNxQFn0TlDbjtE/eh5v6MeZjGeMW+tvHuPgywTZSZYQWxoTxuOviI18YyMJHKx37+wqYcfL4jqrjN3zFneCfIFrgHLeeAb1hLZLffyKKDwVVmHR27diXhi0JBFE0wl6E0tCzvTOk5xGGQzGih/9Y8S4b8BKazYnwIUJoaL1p2iT2zLxqjB6xGBCMacATf+EQMDyI9hGSsQCOJBSGERgRGgw1zrQZOw5q1h5zvf3QSSSQkEuFDKLrKtaKdVwy/4agDlsfuCrG4Vj7LQozTbTIje+38/VdyEPPcSEGwUvh0J87nPA3YWrR6loz7th/+FYuSZG2ZMxN00S4ITmqQLCBITRNEwnZa7hp/nOY8hOr5Qb1JhZcOZ5NLYux91zU1coH4/A2NilaDVgPkPpRCqgMKIP5fAu9A9p4LJoBagDuAfaZNWUvIFGJG7p1gpPERxABhsLekDBJZSHHb8Kcr1arTOGq4ypFog2EPtUVgby9ugtGPyvpJ8NbaWUAFZcYUDt7ovvMaDPKSo8b2WNbV2qCUb8bw6OHN21MP1YF5QjnFEYkNqPK9kujIA3W/0ttcfZRyaTSN6kQEn7XhXmlPYvNmcIog1zDhDRkpdWktbQBXDVYIYyIo/mt25cDVqWraayMvdtEIAzeEQGUsmo2jQE3jb9OUAQVI7EUIjRAFAg6dM/2lBFJmu/6IidVr4Rrk32SvwqtnQxFf/JYOapVc9he0JhbJP7uAOssQISTZ25CtofgKwer0/8uDDCl1pC1DvWd145jKyxPtfsoBZzoOUruoxx+lhTKDGwS3DsmGIg0b9pcIIy5TVMp8F0In01KLUv0uud6jofu02SB1WihvJ2yCs+Ga2BzS4HHNH8qnifiKTVBLRRyqZkQPrA4ij5J7qdl8przBvNUIRXVn3pKAqsOiRv6EnM+qYguymtkY9D9+b9qEIXvRSMIeE2mvTTqc8wnAbTePVWWdcxF3sc3QpDyX48gEDVo2wmaxsBSF+ZDHNqiqQIAx7uY9dmCTGsS5iNwFViJizNBiKCIqWr1GU7fU/F3BuJ4oexH9bVE0OQNbbqtJ2OjIRyZPlP2wQj3V0J82ukzCu4lwnxrC8mW0/qvCQgQ7o/YFse6iRnp1hG+93QSvgnzWa4LsRYAC+coY2wu8gICZ3tWIaWGUrCAkm4pW6sD5FUUuIGf3jc6nP4qHRbDlwpc1lS8r/gmBugwhzlKEzxQggf0XPRB+qd+lWY5icijR1duLhT0PaFIk5Rlu/W/hWRcotEX5pBTxCT1D5XA6b1TLiNy9TwkPh3Deu1Zw5Vr89pEy78Zs15ifcV6pA/nvKmt2x2YpiIQAlNtDAFMMfFVll4YQPJHUWQaHJnyeoZf4qDqhnHDhSFE1sCgMRNszbfho6AWPiIinjngcB8w/KadshAkptonQ1OpRVgpDqrnZOkFTTa8bVBql/XxlsJ8Xd3Bt+q/doQ+tatr6ILU6rmiubyF2BsFYS+3jSXewJEH+OLn2QVXTuk+4aZBM5liPpthOpvGLLVeQFNoTe5vZkgokbCRPPGfv35SixMvlKe+yxB/7IhBsIi5kBRO0v3BDs6JUGjB1it1oaFsvST8hZ4zuk0pHdTDpJvWaL9Y6zIPGU/XymFsVvEU5LQka9a/F3cqErys4rjEogfBMKEnBijfzo+wkAgGDX44H2QMJGGOKKFayZGfSdz6nJTx9yFmquUjsNGs74RVkK37BoiSdgNFv9Jn3c10VBfBUeoP62or4GhlzLepyBGeuCx8WF95L3a1VSSrZn3fhwMYeUXU4Sg+I8xnM7STxufXJ1E49WnlvJR5YQwR7KDWmsK5FfU/uxhK4n7gf14Hz6HErb/1GDnc3aQVC6XNi9JAwHQ2xfbOTsA7hQgljsY+kY8eSkAmOPydxr5NAw7XbEriO0CsBASFhUQDDLBp61osBZ0GP46CJNggH0c0AzWTLgTfGM7zyztTKQWCV3xUbuwBdof9rHNJcgFrdU/AJDWGbYjeIvI34ykwahvt5e96nWnvsh8/xVBYcVN5JXUA0mg58n0KGshD/XKHQVJMfq2fdbBsmgr2qO3XJkYLHT/26+p62C5yIZlpIyOEWN+Iyr8ty+iYqwp30rzKRWIMgbnD4mAfrl9isb+H1WoxEAiktE5mz1ziu8IvOrbINxFwY5ty2RAPcZmNNK4sFfInTMU8r7RXxe+h3WkG3yO6hNR7M9jc1Hpg3q8xPsW3IcKkncT3zBwCBALPjbfxmJCOmRNNSxpsRevSb3BMQbQ5Jp980ug6lMMV3aFEWUhyFAAF3kzAdUaL4SdpoaRwRMEF5eVRNLGSHFOegeyftJDRBWWW2TraHKODGg4gsAUFyjqnR1btY2xfQX4Xy0SKIX+fAjsHVwRs1BSasfKYLQVdxoTGX1UpGfVj0/yHz2qS+nrGtb4vIc46w9HC77HgdNSSqpjPGFkwXmFz6LsOnV3B9iv0q1XUdsqxjS0O2+d2Qm0D8HqsgnXzd9h3NUUgd2lt9m2t75IJjbQEIKVW8Fo2IV0KrPGUNHLdh3MOzvjsqe3E/xQG7ByjMQam0Yko5cBAcEWJ9ye4dShkIA6OpSDk2QcVNIHjeqLNXB7l3On9pHhOJX47hok0Lt9erkgkt05aQbEpoXVlwZZzcZRS0rF+Pjb3tfXGBMAOlVmd0WCs7xovYkbMZeWcg2ULiJta9BmZFhIADi9Hyn3kASkX8NEW7qbtln7aWqkRif97qOXqvg77exNXVFUzJww2vjdx+4h1HBUK5Vdbx3BKjWkTZ1xNwyl9mGPfgRnsLPq+Q2cZruvAzgZ6C4N3qn7h+Ze9GC5cCYfNr7R3mCC/XtfSWu0OkoocVUFZ/n39ilBkg1GjXzufSiNm5/flLl++jJNnb8E0prRQ/mwjLrjAoGNvIVgjZkLl2Lxyris3xBAmDv5zZkhGjAGdiZUQca3OS4ytYxGS06kfjz8YWUQRFQKhpIBRDI7RyhoSGrNAyzqH0oDUOcSCPVwxyrmcz4cVvq0MZNPVcaTU2fp3WeAaQCKdqEsDrKcuV00zBI7KmPCihmuhRlqjehTV864oe1ETRvmil3pCACPtj5h+A22j+IUIsM6Ph+A1AK1pVdso8H2Y5prBwjHCOWGOhiTFLAfrHKztw6L2ewrhQqiYL144iviio1kPwGce4uhyOKp1qccxP3kadrVEd7BfH9shZX7iFMxkKkOGgNnt78EuD/xzpDkSLEvLWydOoZnkt/ExM/rFAfrFQWwPYEx3jqGdbQWffhpnv1xgtXc1MuWmIUy2tjHbORZaTEvUdissrlzO8RHWogPj0Ucv4qZbn4Ct+Xbo2CsXfmPfoNEKarbW9KjUOhJ/P3P0VRtVS8Yb58SFbwzFCn5p+r0FSckQ3XAB8cn9k7ZOhb8459C2/pa5vu/XMuaBEqhHRfUDcoKjUAmbF80Pa++pqMM5/TDr1/GTmsJRo2VZj9KUKAFe6eIBLnKI15cju4+028MXF9VjjgP1GkACmgNhcdSKq21DbnAkoQwAHC4VV2FcujgLGOOzFnI4WJVULQEgA5mIoO8rHcxNZWJEuxGylYtFskkLa6jUlMq2NHM3qr8oaMPxdZbc7hVNto49EUACTK6B6X6jiRsVziQIRh0dpgGo8an8eQm5t5fZoCFGE+6P7Z2D4x5gRjubo4rpYHkA9djrUsuslU/4xu/GQ299Pd7x2784xEYhBGt4e97X/2+46ckfNXj+ll95Gd7zB78R/26i2EybeEzAs7/yW3DL0z5m8P07f+cX8c7/8StxmM4xPupFX44nfuJnDOp+8M9eib/4+X8PCjFVBMKTnv85+KjP/4pB3Qvvfiv+5N/9KABgSiswDJxpfA4jx3jmxzwLO8eOx81H13cAgDauj3C/hQ0WA/xlTmTkYiMHdg1MeA5YMBOY5F4MfyUnjPN7FAbhH4PRoyVJuy1xdB5Z+uIeay0cUlZdCF79L4EJGMD5ttq2wXK5CjXrMfrAOCPTNK/XURY1WazbzUpdQ/X9AKVQiHRNjCZcBSoeAS1TJaCihD/rJbMgtEIoOaM8JWneMgZxrTzGPQWq/BwmazMy6RFPFfDCo+HX6yeJKC1ZUA8/pMo30a4qBMYhJdP0pRsaiXMgZO6jRAhQQk4xqapWYJI2Fvyv5WYiAAw1nir0gyeZteGGMJTwDH5XGijB59cRTRWuh3UpS6ZPncwxDXASXDYKvHWLUIh/1ILQavwRywt/+CfxFy/7t3j1//PPMxR86t/7Rxs1KfP8wdf8Ad7yqz8bx/FJ3/r9w7ph/Off8Sa89mf+dTaAOz72+fjM7/1n+L1/9r3xGQO4+sB9+KN/80Ox3ae/6MU4fsvjkejOJOXGNCADnD59GtS0EPdEqWwQwbvujChOSO8jEiQfmbrLwoMV/vDpGn1EU0iZHUCy7LPnGsVpHfntc0MEotbfwdF13qAAhfB1oadEXlr11O7kx7KfN+6mup6iIdyMCEdp+IgluzuhplgB6aKt6yhHCt/JpfTwH5GPSy59Ycl4WHOoZ+0ANhsdFadhBVYTTtRmDEiEwwZMccgcyd+PoCyPsX9iHpOqF9uJIOQRGuXfNe1oXZ8ez3Jl+Jh563Ew5qfXcCaBoHAgxhERYAgNBUGgYZfIGbWotX95XXK7Gu6r8KHAdwU3tWftbA5ne9jVAv0y/Xv9z/4kJjvHce8XfU0acuGiIADP/8bvwoNv/nO8+w9+I/v+jb/wUwAZ3PvFX1cADb8fs9T9HYDZoZ3OAo0Y3PtFX4PJfAuv//mXol8u0C0O0C8XeO8f/hbuf92f4BO/6Xs8DEbNCxFOnjyJpjHxlHUWJoxkN1bXQPzThHsWhAEjeZFiyX1Q2eZ3yODJjHRROjgcdGzy9NiEJBBQd3fEXmQc4ipTv6+rX12PcayFsle2of7VX47TZ6qUwyQXI43Dmz8fa7t277SE/cp8PwZ96WiWwiamFREN4tKliF+tJqmpaGPMTCxLlJRk0LYteh36WCGGCsCZf7Q2nvqzdHpZM02ivB2tT2Tjk+9rygOJKahfpsVXg224zwCkC75HUlqsRcshGrw0QL59A4IjAjUNTEySl5gOgXDmzifh7JOfDmYXfeEX3vVWXPzgezLN57ZnPhsnHveEBGJ4d+X+9+Phd/4lyBg86VNfiPmJUzh79z146md+IZy1eO8f/lZVAo4KHgxp4/L978Ptz34+Ttx+p4efEwxeH/D1z951D97/qt/D3iMPZW1c+fAHcNszn4NTt9+ZtfvwO/8S7Xw7q3vbM5+D+ckzeP+rfz8+O/X4O3HxvvfgyofeH7ry49l79Dy2z9yEs0+8xz/zIUBewDUtZrNZ0rQj4opSXXOFIkW6ut641BXqzFjAjQyJvKA4f/48DBF2dnZiZteMshUjC0/S84L5s/q5CdM7jI6r1mrtm5KuCMFKWufaTbhK67GecsPIvedF32MKYfl+AK6C4Kjluu5oXlc0gqr1SxosGOqmfSXEJm2paZpMKGTthzpxPMhD5SQiRmtf4337gYzV0JNe20gVI094jBZKiQhyPSUfxpAoBoQpTKxw12WuqCPMp07Yoq0gEY4U2uPGxA1niTknIhy/6Vbc/NRn4LaPeZ5AEuacsNrfw94jD4GZcfJxd+C2ZzwbZ+++J4Nj56ZbcP+f/zEuvOstICI8/mM/AdOd4zjxuDswPXYCru/wvj/67UPHE0YwsNyKQQemZiC3VxIQk8fJNzs33YytU2ewuHIpPTt3K2YnTkY8Cb4f/MvXDVboHc/5ZHQH+3jDy1+aze/82EkcO3cbrj38AED+pPDWyTPYOXdrqOH8yX7DaNoG7XTqlbCo2pNwoQi7Fq7pmg5PI1JLlDZdkuuopt4k3AjehKgNmbD/wnj00UcxaVtsbW2h7/vBhTqR0bPfd9R8rlxHkc5RFwyavnWQRgKRootTLNiaglrFw2DAeakJBwrzwGq9i3WU9ctICpTwiRGGL4n5hopg4qXXbSbgOg6vDa59K0rf97FOjLnO1I96u3X9Ix9dYqocCF6iW/zG1WK5WsfLYxsmLJrZbIZJ22J/fx+L1QrT6TSNSwROpPNiQ7laEkFX8ROf+Q1ezhZbHdamMSEUz3gfLoVIjRFLqkbkY2373tfH2af2KS72hgxcYEL+rb9wh5oGZC36sJFGxvgggKbBx7z463Hpg+/FK3/8Bz0enNcYn/mFfwPPevE34E//3Y+Cmgaf/G3fj7f++s97NwwS437+3/4+iAsSzPiTf/V/4gXf+X/h/NvegHf97i8LhGuF+XCMdfxRHFUauoxUqjvb46O/+Gtx4tY78Jb//l/it8/5G9+KU3fcjYsfeHeOS8Wk9ZQrPgrAu5jueO4n4cTjnoDf//Ef9Ju4zHjSp70IT/m0z0d3sA+Gt7QIQNs0mM9nAAAbuJnnxYk+xGXXGJOTm+wlEGFtKt9IHnLLV+lOkwiz9IkjSdVBeMpTnwpif9fGtWvXgk88KT26RVnfhLpyGIVEpN96GbPwx4RJNtSBVZAEUQFMeh+VPWmHIGEphCRsfR0XcSNwud7CmLQfNOxKCxClSY4wI2lfnTiq1quVI280D6/NGxbxOZe6hc6rUg4l5f4JdaJgsYN6oRP41AAiHAyYgZaaEDOvfeHDSZ60La5euRJ92zpcLlYTmAmA40M160zDUFoDl3VEoWP/h35vqIUP23T+Z0wFYMPHJt5ctm7R6P4An7KAQHExHblE7ZJhYaPwMWQAQ+gN0DogbvyLTxcGL/yhn8Drfvon8Mh734GYD7zxV4++7TdfDjBjMt/C5/3of/CCBRVmLewnCEbxBV/PcIYCb32JGFXV/8cP/2/4+G/4Ltz1CZ+OOz/+U1Pb+uL74q4MfUgpCR8TcObp+NUv/ed48qe9CE9/0YvxRf/8PymYE9OWNThtDdoJgUwPxgTGTYDG042sCZgG3DQhcsy7c4wKGRU8aNah6dgY4++YgYMJp2Qdpj5qLdCx0JwFo2E5le0XjuTvkn48PgJT1CiVNREw4UaYnZRNN0PFao19i0cgCMRyvTCnwIiMnSpeInIxvhdhE9Y6K+sAAJja8DMosw4gdT0psz9H4nMbcXVd54VRC8nJ3+saPrCANsTakYXCOl9/ZuqxnvAC8UX9QSEvDEbNo6IvouT7jPtbyjzTFg7gF9VyucxMS5mIfEKCtoN8EUUzvRw/ymra6hgv2ThJxp1/k9IP57mmMqYz1k8pmAozdyO3YIkDIO0bEdAQwTRBO2IHZ22QYQZGMUqZB9Ma2L6Hv7fZCxdqGvzpT/4TXPrAeyJc2sUz2CMS/cAA5cZfiY+6W3Ns89GPN1q8FfSwc/jLX/4ZtPPtwbu7nv/pOH7r7SAK921zcLEpJvSJ3/J9+PAbX+P3SEiiuABmh/v+/I9w/h1vCofSbGBAjDN3PgX3fuFXg2DQrzr0rYOxFrxaYYIJJpNW3+8aeAHl8035mGt0kY2T2V/IRlBRZAiw5kxdZA1DDvyJSlJGDolCVyg0OISONyh6DMYY2MJ3z75SHMRan7wag+pA1xjtv4pXYRDqmHHileGeapMHl9Q7if+JPemT8Lp/Eususy7Wl+vOfVTzlevnYznDj9JPybzG+s8KAZo9a0aiCW5My9Z7CtGtpcbkXQkIGnxlEa2BrcakxuskwZDjoVjUFdxoWEAU56IUxmMbVmOwDTbWIdoegY2JxB1ddKHdt//WL+HcPc9EM5vh/NveFJ67jEZd3+Gt//1nce4pz8Bq9xq6+/fKzmPbQ6jqJkOd4WsVeVj37k97EfrlAve95vczIVErB5ceiY0IM7zrkz4TJ267I3MPSAVmRjud4Z7P+WJceNdbcPH978Ly6uVAmy7qDqvdq1heuxJytnlr8dZnPBs333NvaMyEpHUhgguA1sI4cGuJBMvihbjc1FXwVcbowGgyJSmMVFsbiudF/djLH+Ug8viYz+fY3V0pxuyfOy7ugF/DFEvLBsCAkY7xP8FNBLhWR/+ipKDwB91/Dda1ShanOmn/L/ENnS9sfVvalhnCMuAZ4xANyvVllFtT1iFkTOvTftyj9qO/zTWR1IcO8yxhGXW/VJmsHA4ZYcTXoeWMbUh7LSKvd70a1KZukvKbGo5I/hVEndxL+lsP9/v/5H/g9F1PxpknPjWNx3pV89hNt+Lk7XfB9h3e8/u/7iN/brt9oNFCtR3HROrFmjHXBMKj73sHts+cw85Nt2Tf3f7cT0a/WuLBN/95oC3g9F1Pwez4yQFeTjzuCTh27tZIg0SE2z/2+ZgdP4krH/5AQk2oP9s5jpue/HScevxduO+1f4S9R87Hb/Xcbp++CafuuDuOjcjg3JOfgZufei8eee/bARCaZoKmbf0FRuQZRBacwMjg0hgq10mtcKUeB4sl9/vob1K0UHF1s7e+glAQ2jisbGTB1niKAFgKZv2NGgCrf7VRXY96m62dmkJS+RvgarhpfMvjobg1XqaaPRLvOJJQWNdxJEBQjHVOLzHQyjSzjnWO2G+u6da/KZnDuth4jfQShdFfWLwpv1mH+lIzXzfJul7eRvqWCpwWX+YfFXDUCHQtYYn6x3mEimPOcBL3nKJg87Da1RIA0M63MJlvoZ1vwcy38IRP/F9wz+d+Wey3Xy4AY9BubWGyte3/zbe9rz50E4U8CKadoJ1t+ZPThSDTZyFKxvG6n/q/ccfHvQBP/OTPxnRrB5N56IdSZJKM+zl/41tx6zOenc4ThDae9rlfhrs/9XMxmW9hMptjMt8CGYMP/cWr8LZf+6+x3jSM49xTn4GP/evfhNf9zL8B2GEy30Y720Izm0emSUR4/LM+Ac968TdiMp8nXLUtLn/oA3jNf/wxGBB2do5hOp358TVeKHDcY4MSoCpFNg8DRSJekPvR47R76ZATghLOrHDqY+XZ35niCo07MGhJdzG2WPR6WLdeB3KJ664JPZelpyH7u9K2kHxJd7mwHFEqB4BoJRZJuVQSiYslu9bg4KSgpvMJw/FFQY4h7xorG7uPxDwr3S5jSJD6/pKZ8HCd4D+iMNZwyCY1swWzvx4SSMQ6cG1tqDln1mP4b7l0jtpmWcQUlcX1kSxGwalxscn8lUW2QmH86fRoQgfzwDghcuEA8D7o4OP+s//4L/HkT3shXvjD/zZr922/+nN43a/+13DOAfj9f/K9ePZXfSue/ZXfMoDhg488PMDRkz/jC/Dkz/gC2G6F3/2BbxlkbK2V1Abhrhd8Nu56wWePVEy/3vslfxM3PenpeNPP/SQAxLHf8XGfgjs+7lOyz86//U3Z35/47T+QWSSf80Mvyd4fXLyAV/7T7w1U7OE/cdsd+LwfeWlW75F3vw1NM8Gxk8cwbSae3zcOjhwc/OGlxrSgUilLPgtvgennzP6C+WK8gqfqzYYufGB8G0JTxph4NkUn5JTkq2J9tG0Lxz2cdQq08dxe5fuNy5jizMPzUpusvGH/QwUxtr92LcvtiaM9hZ+HQaUFm0WMxszwGFKaGIDRjLSTF+INMf1jf+/rPKjSITDIdqkJblNGnOo5QKIbyk2Tw0CMN5s1aCctTNtGf6oIJiKCvuto0Kbi9RpW+cZ7K5KI8LdNJXzki20NqOsIK/ahcMfBj8sOxhAMNepmDSW2GHBcnNGQnwUex/aDsm9LS0LGqNpiMIxp/IUhxqDruiCYPbF2zQLnb3tHbGMy38JkaydrtzvYQxeSx8m4pzvH0U7nA5j65QG6g7047NnxUzBNiOwAY3H50cE3sVTW2ezYSZhw70AJU788iH/PT5wGmQa2W2K1dy0+nx47gaadDr9f7MeEeAAwO3Eq22wfgOYsFlcvxb/b2RBPAGD7FZa7V+NJcfIeEkx4iqftfzxMQ2CzDZjGk4iZ+MOERiK2DKgJQsMYUDPxPwkh9UWIhAp7FUBubUmnjPAspOI2TcihBIYxrc8g0DS+/Sg9whkEOFy7ehWLxR6ctYBL9Bg1XubhWYZD+IjYO+sWITPHjLLxVDTWR1SuY+7luimtHPXGK0lhrNbacOcBAl2Gm+fglKtNRrXOEpEQeAPmPrz3z8M9foiWIhGoafGN3/Tto+ORcrQTzVAsrMZIjtIYcmYlRCsHTmqMa3yCCMxBAFiHydRgPp/DOYe9vT1sb29juVwqkEcIrNJ8fMT5+7KqRz/FULoxIq6PIdVlZrl+OuI7RhsHGDJdT03DJofRamUjC6Vww6UzKAEOZyHXUwLAYn4NV088CDtZxWfWrrDYvTJsu+DLB6uLwGpYDUBGsf3Bw6PvNin94sL4S9XW7v75ev+LRzb6vtffb1J/DE+hXnlrXc8rfGD+Fty5ehqMCkf18zqMVI+aMjixHb0/NFKSdcjSkA+PNvIsuZQYynEVGFx0VIlFYT188Y4FKHfWIZbBxtZ+yTdk/TAHqXpE66OAoXRJjcLG+XsOQlTslGR1H96n9JXzM+XT4KBkG3+WiMXltyGH3nhP4TCfvgC6aVu1zSHxOcq/Mg9QVl8/J9m4kknK4YihkxVH5qHEFbR1vaAONVwOR4EaN+JejHqrnmbGfhxD1PwiXoa40f2k4XD1+Sh8RVvjY85x20+WONi5vAEmbpTHWpgcLrYPoredYoISOw+keQmabMYjeZRgB/NerAVps/57oLVoYaCgpyHrqSlQH2mXqriw5OdjLZvBV0mxH79TL/Sv4omtlOHeiChjrP6L4GXwT44SqHJd9ymMvY+arpLONaQNNrlIJBn8JhSQcqQwH6pFeH2DgtlLcNbi4GAfAGEymWRXQZYwZeMKqjkBSZLrNRRdZ7kVQwKTfykvRuWyCDJAKV2qfWJpM9UXHNQ2mJP2kMZ5VII/qs+2TGedudyMiTdCxWe2DQkL/79TxHUQ7xCGd6M0kuGV6puvf3XQFPgJzIvIn1ORtWCMQds0sKYHU7LO+r5HOyk1fhLiioeqNP2IRq/pqnRaxLUtH8RNCLUe3DrXjqwFX99Ej0Zy9xzVMkjehTzUfEywRNep/zjjuOuU25qHouKJrLZzWMksuWzoOX+q7Q/VNsmzw7/xLwkj3pwnXLdQqHWw6TNgqIUQCMYAx44dw3w+xyOPPILFYjGoWwoGEw79wFHUlq1jEKdcRsvlMuSGQWLsxaZQuekkgkaLAM24x0wsERJSX1sYqlJ6F5Ou+cnzAklMwBru6lrWpqwrFyK51TBmDWocxd4K3yaQx4qXoJ87/xTMFyfiCAA7mAvpr4STALBplLxNcEQ32wb7JHHjDQ6OCcu+x6OXL+P8ww/jkUcewWw2w+nTJ3Dbzbfg7OkzmLYtGjLoxQoiJfylr0Ev1yNEGCC/UUjkTX7HFl3fw7E/Uby3t4fLly/jyqXLOH3qNJ5899146NQ7cXn2YGylbSeZdS00phU2zcg9JVGiR6ELj8QMb5E5Uc7i88zEDcAmCn8icdPkczCZzNC2S3TWQsJYpb4OybzeII6aYGC1bh2SxVCj641dU6jPv2DE91m30mvrp1av1uvA6oi/+b0bz1J0GypF+Qblug6vHRYlUGr2m7QJMJxjXLx4EcyM1WoVN4jbth3ea6q+E8HPrPZgkU+aY073FARCaNs2bI5KTT+d+Q1ienBQFsAhltPYCy0QisbJAHZgnv/PLaXAKLWwuuUH6P0EX3fYbs7MSSFBcF+nG0Nt9VRx/JTXM4L0THL3dAD36JYr7O3u4uruNbSTGdr5BAeLBe677z5cvPAInvD4x+PUqbMg6sKAkpBaV45sXWRWFmCtgw0nwi0YDz10HleuXsHe3h729vfw4MPncebEcay2lsAsNdO0ZhAO7hl34M0FjqxzYArBCxsQnexFcMwgoKKM4k+XnXyulclkAtNM4O8/SXQj7mNrh9kMDitjCo0U2bdgJhAxsEGU2mhfWD+/SSCkJ0NalHU2tALiXyNWgsjasRJ5ndCsKMMbMpbNhYIoGYoZk/wpzwjxKrhsMFxBIrM3fUk+TNEzYgEY04S9hnDLmcARO2OwC8/JMxVm0V5Eowkx68zxXgWQzwHT9T062/ttOeMi3JGktR3NKbkfhb+TcyHZFQh+MI1/n3mI47gRL0xPuPNMzF+OIQvPBeluwoR6wnLBTUQDxqtLnSnS4P2oya+EQ00YDF14XkvxCdyAdZeEExEa0waXiEqORs6HO0qfIajWQuEFyhrT6C9K0ooZcimShtdRg939fVy9tofFQYfp1g5gZjHkdn/V4wP3P4AnYIqd03N/qjeSuYy2XjyMo8Ov1GcINfVWNuwduq7DAxcv4dLVXSwWFsuOsFwS+gPGxcv7oFv6rJ2GtrylAaTzBeSNUTDiLXscUqZ4WcAxuZ6MiQCQ86GqEZfBSjAAjLMgY4I7CnDWry1PpN5SoBD4YRoKVlBak5l1Xp23+rOalSvPXbHi8rYlXt+A4TyuycQ50q5ZaU+3HV5G/lC6bpzif/JQ9gMdZIlrUZKUnyiskn0xGP/1lMilQ540zcoOK0cQCpwYmPpvMlQwHE8mLAspGFwk2VRySoQllgFJlHO50oJ2LxpQejWUQOK703ncnXNhAXLQ/jn8G3EMiQRU8iIJAs2ZKhJQ5WYaWh/KbVUQmyTQikP3lB39yjlwQy2/StwDvORFC4p1FsLY32QIztYtyNI1RCS3fCn8RYGaBLqvRXEOknKapO9QAMrzpFl5HsZRc97b38NisUQ4b+WZnml82mfnsLdY4vyFC7ilPYPt7W1M2haR1QjMG3F/RRuVRe/HYaKG6Rxj1fW4cuUqdvf3sep6rHqLVefQ9x7Y3f19zPs+p1aq3DrIJYgU6Viij7wFQNHiynXTlLYCEFmf1m7UCRngyIjLwAmZgzR2CXXlEVffWCk9EaJMZeOmfF4yLw4RwBQSbia3WM2FWQ6A1Hvtao7fRoXS/83q3XDZ54fglM6xufuq5KlxvcYnceBEFIj88HJdCfFEYjrFNGoA1jVRzn76z1Ro3LDH0TeHwYnwJbGPS3ZgwKY4eseMNmTl9MxXL95izJpRKgJJ99iMa+U6T1Iig6IusyInxEUXe2JJHaDyN+FomNlk8Y0Jj00INTH9ugWihYIxKSLDa3Wiq+YWnminMGpDf0BXQ6spKQu5wJRFzNZhf28fq27lE6dZn5zP0CRmfnUt8MjFR9BOGOYmwuTYsXjFqGeCh6Ik9JvsitEZIBNpctn1uLZ7gEcuXkZHAFvAdQ59b2HZoTEO+wf7aPse+SmJQqmAHGAkSFrTwWocCI1wFJTyv4U+HTOoMSHrbmgvaTy1gUELRQpWugkRhqzCUcsN3lrR4auxBwpXe9Z6rykv4XY6sD/wWqOpQ4XE2rI+N9IQxsRXkwQe45sjbVa7SFGZm8Ah5fqzpG5YLxXP8mJIZdGC14wxeI5SCxjpa0zr9VlTlfAKPw1ROt8XDlaSybXjahQCpTS5pMV7UXxW06H2DsFCRWprweGFWXjufWvCi4I26eJtTWtYzUalZJz6efZM5FORulvqxFPvlfkaMuh8ARINF0KmX4c/DGiAU7EE8v50C8jqgxhd12F/f4Fu2QFNA6IGbB146r8jeKunmU9x/uGHYYzPZHr82DHPbE3SlIMZ5+ELwiJPUe5EuYbLzh2mEQpse/sHuHT5Ci5duYKut9jvnM8T5RjGMbh36AhYLPaxU1pkzsXLeetKVlJJotJWPIuWRZyvykljx2DimHgz9SNnJGQOKDI5EdIyK4ZCZlgy0E4wcZ2VcyYb6M712dxGGNXwahayXteGfVCLc8W4ij4TX1EaN3ILIOsjw3HeVl4SvQz2fyItK/Uxdr9GULH8yNuV7gfW1JpyZKFQarz6+fVGCxzS4WPleaEZivnfow9QX6uV6+nDoiYqGQfrIxWiFVQRDBsX0Up5mJPpI4nv5I6qhcjlRWtWsih1GKr4Sse+pfi7wXCD2sCHPPq2rX+osw1nba2Bsj4IIjAb9OzQ2xX6fgWghSMDa41nOg0gbgYA6InwgQ8/gItXd/HEO+/EsePH0VKDxlAM55TTqRaJ14urw5gWCJo1UwNmf1+GCXtlLjDCi5cu4+FHHsXu/gKr3gGmRccr9IsebtXD9haAG13bpa8bnIefxgNtRli5P/QZNXhhPMw+W0HTDNomIvTOojUEOAc2BBM3H+TSK79B3mJkjQQB24c+S1eKFyw261fCyieTydAqLN0kIzjRdCv3tJSWhw5gISOYrJ0iGgoHv0b19Gy+LuO+jbiS4rrQu1dreNSA/0YJiUMXdFGOFn2EAukVrXqd71kQRkDmejqUsVZeR62DdaI6B4IBs4l1IjNlBnFyFQGIsdUEBkgOgWg/5XD8cRAbMfhkVaxzL6Wx5tYEEPzfzi9SZgbHCBrZT6kLm033EKrP/IscNlXfkEofAolzd2hNC4eRXPCUt2XZh855XCciZjHpQXAh5cI6WNe/K60Rimb6JCTYc+zA1sK5FXz2b8ZsOsNkMkEzab0za9Ki61d49Ool7L/7AJPWYGd+DDefPo1jYa+hnUzQTiYRL45d7NP2Xrt1zDjoeiz2F3jggQdw7tw5HD9xAsY02N2/jPs/9CB6EBwMTNvAWmC5XKFbLuAWPlcQG6Bni8lkCmM6ZDl0iitcRycgIS3hvFKrlmpC9n+ccyERn8ZvsIbgs+zIXkXpfo0uWLOZsqRd0SW/kPlk5UIcvC+sWedsPPdRtkeRtr0yFhMIIudbgjNZ3wOBPMCmhisImvC3tTZY/TFYVo/e84IMRTXhkCLCajWPojhuLBQao7Q1wGsTwfeYLGECImMVoHSKBobsyhsZqGjTcQh5KawmZNWY47eZq0Xgke8y4o4yHgJ8io4MDbM0OKaSqV8zTUi9CMKmttiAJMxyWHWfQciF58nt5sDcwWACEQxSe9Pj6bKHUf6dTPFxwU5ycxq8Vu8/MT6LqQm3plXiRw3C3oBWpRgAB4oI5m30rYYpouDPKJnLGHypJFxmAoGCCzHm9AnnXJjRr3oY8jmyKFwjahpC07RoTIPFwQL7e5fQMeNgeR4ntrdxbGsb29tb2N7ZwcnTZ3Dx0Uext7+Pru8xmbTYnm/B36lsseo67C9X6JYr7F67ivOXruD48eOYzadgOOwuVqBmAgQBslz26Bf76FedTx7nGGCHhlocP76DyXQPUM4XZzxDpjGajKhhpVkGN6eoVuxUlWQpEJLl492ZNq5xRwCbWUyz4u+CYvkl3qIo7ZigWBiYIPRNANPFqKWSccYxQnKYhUUTXVLrmV5SXBPtCm5Es86tCskmG1onUTsReJ/C5QC90i4X7qC68Fvn6tGMXuAv3VueppVLXgnKXFhsZi1sniWVVG4dxeksJXYFICouei4JwccefjfCzETL5eE3g1KOSQgns1Ao0klGJPE7FxhM8SJOfP5NBo+anHJLK9N04iYrZ31FMtaEF39S0gZIIkEkgZgAIyiQ+3nbCL7WL7ybLH5VZ5gFDBmMJIm0NIQJTv1c9ljQGJhm4mmAAo5LixE8DOPkpAyk084hfJHS0tcToQXDptpPJhBES20MmnD+xQWPjLMOdtWjCwnjDBEIfuN50rRYgbBYrHCtY3zo4YsgZzGdTrC9vY3tY8dw5qab8cADD+Dqlavoug7z+Qwnjh2DIX8/8Wq1wrLrQc5iPjW4cOkKtrbnOHnyOObzLUwmU/gjehZ9b/1G+MEebJc0YsMEQy1Onz4ON1uhQ0q8x5E5JKZaloyZKaEA+AOfHJnlcGco7QkwOGzMU+NCv55AYyhs+OcDzNIa9ToBoQlJ9wyFaC/22hmrNSw+f8/4FFPUKyfCtN7iyN+lkNTEYEs3JhXfkV6NVWVvuA/pQj/r4Sq/24SuD3MdK7EpX6znr6psLBRi50JrwfQzAYJoQjVtRUshmHABOZh9vvXKwh74A8N/eNAeICJ4DCnX428f8z/mEIl2vk7q8sj3h5SIYjEZlUYShBJxVBhFBmbmvxXtoeh7nVuvdPGJ8KwxlZIOGhNO4Worq6acAsNoHW2xqCkWYZOZ9jVBcxTcqtIYg+l0itlshrZtYbsuMtLeMuzSoXc+0mfqLBoyaNoG7bSFZQdYi+mkRbdyWCw7LLqrePTKNXzg/gcBMgA5EBx2dx0OlgdRoSIYNNygmTRwzmLRLzCbTzCdTrG/v4etLWA68VqqcxbL5RLXru6iIS+8JCeYtSucOXMGu7M9dLiacCwuDWYYOZRQ1aCHNC2/rSuyPjrrwNZbVU07QdvM/P4CGbAJ3oBA/xysvMHaJsQxJaYv7whgA4kM8n0jWHVC1/H25UPne3D3eglL4d4qS+ajl2/EslCP60KpbknU3GCblM1oPuElU843XC/XdfMaAXFQmrkPLzXRwPlnjfGXbEjCO538rlYyRqIYxMZiL/t8/JvSLzissOZV5dvr2VQW87T6pXpoikWsl0Z59WKtrPfNwzM25IuovOwkW46U00N9n2K9xaJr+ncAhw1n0DDk9HqLLPCWgGM725jPZqEvOQ/iL4liAjrn82/5w1fhkB05LFb7OH7iOJgMOgbQTECN36zmpgFMC2dauJaAtoWZTIC2BRp/MXvXM67tLXHy9GnMt7dw4dGHYdmfYu76JVbdAn3fo2kI2/MdtG0LIsAQYzIxOHPmBG699TZsbW8PxtbEO7FrCedKPIhCP8YI68WAYfseXec36oltlhxbrwe9p5e34d1AYjGkpU0h7X3eRg4TId3SsL4cdR2O1y/6GlN+RnBZCqXBeorjPlx5O6oyNLYmx8qRNpr95Sr+9+g/HDNTK1oyUfDXFvX0z8FzIB6GEg1SFrBOFX3Y5GvEHGZm1hCoze5aRPShFssaAq65lLyA8ONsdXcxcgTRkiihiUunxpxHiG5Yd1ybkjeWvUvIx/WHNL1s4yZr/r0bxW068JMLFYYFyCsQftOzbv3U5zPX7rK65DXHnZ0t7GzPsL+3h1XXgyZzr9g0Bk3TYjbxpwD6voMB0NsOkNPkzmI6nYJpBes6NKZB0xIYPpUCswG49z7yngFKzodu1eHEsR0cLHvsH6ywWi7QLXsspivM5lO07QRN06KdTLFvr6Lvw/YzeTfdE+9+AtqmHQhVCqf1a0VmrkbZIhjkrWyWN83wDgjnHNh1IPSBkfk2JGggtsreZQYGuLVoJy2mxoSghACRl3RxfjXTJ1DsXwS5WBOyqQ1xVekEewrOsRKtmEJYreML2pLJsHcI31m3QQ7kl5dpkl1H5yJURl1OhHB6PQl+gDCidw/Kke9TiCWqqWkk5UCqggFK0+X1bpbEUIfPvYlcjxKqMb7DJGUNzqp2sObbdabaGKOuCgQhmODfHZySJGFuOSHoP2qj3cRlVy2OU/iuFEPxzAAFxY2cpLiodj7SF4X/a9h8RJLnGRq3/vd4gKxoN1+gSchoBQPwofwOnn7atsVkNoVjoGcOwsunJXG2R9dbgFcwROi6DiC/59L3PRpiTBsDyz5fkSFRFwwYBswEt+p9NE5j0BiAjcV06n3oBwcrOOvgLGPRLMBs0DQmCIUGzAaTySRsHhOahmBagxOnTvhxFZj0LqoCt4INMUMb7TCSOmm/j/VL4VNRBwkRO9GcDZMtZwuCkiIMue97f5/J8WNo2yBgYhgyR6tswDALfpJvqCqyj5/QoH4ad13pPKyscz8/lrbq36YEI0SIa6q04gSUeGlYcQ+FVkBzXqL3ZA4vRxAK+YEzoR1NXBQWuH4CJAFIYfFLRI2MMr1XH7NsmTGaJk22HqS0xTxEeM6g85HUEKT/rPkQsydxQWQIiLVInP1UqTJSdPser5TUEwphsyMWiv9WvWOkg0WByUbmjRzP49p2Of4hQhvjmZgxoppwsBZ4qMWqZqX7bIFHnGqk6V5FWxxwhLWKhdBK6t7jlTjE4gOYtg3cpMFqZUFswK4H9z7Sy1oHsIUDw/YOfv+EAe5hDKMlA8MG1u8GA175BZEPLbVdH/aHCGiBpvX3ezh2QLiOsmk8nfd9h+VqFe6jpsBAw15EQ2jbBm3TepfXmMVFCn8MpDBVpVQUVh8BwoGgDxFmKS7iLzKJafI4fO9Y6jtY22FvbxcHBwts7WynmYzSJzRlCGgMuEtQkqyAjF4VXFofGtHAy9/Hno0z6hxPNR4z7t7K26/Vr7mUJDlexOpgyYd1BkDS8VQVvEOU18PKkVJn5+YIArOShFsUFnxF4muGwlGua4UktGOybzkjBOUqiVpjyu6oJ0uboum5njiOhFm+lxcq+jm2q0dWs8SipsUMI0fpDytyspnynkgvOBCUeqbCbzOlTi1ZH+cv90uwM1GwDmBWpnTKN1XUMZohU9BiWe0HhcgM8gebUHEfgRPciaeoOYqaUUSBPzXLEmJZQFYIuKEF5islJSLQKhjWNCDr4DoL6i0aMCaNA5ODBYP7HmR95FHTGExpAttbWAKMmaAF0BiLhSRqdAxeCnP04axN4w91dT3AzmDROTSOsNM0sNagNYzJTO5uACbNBKtlj92DPewtDtCQwWQyBZZ+07iZTtBMJ5iYGWbtFGADFUsdShMFAxGBSXJ9ORBNEJdXgStjCI6tTzpInvF4fLp4H7dMHIVEja4JLowmXNtpgVUDtGSBvsNy/xoePf8gTpw8i7bx+xyZ0sY+lLU3gGtNOAWeeAOzx4vmO04sEXbVk+3l75ouNtn3i9ZIlcmnuqKhrxMoZf/SX91r4bySG88fBSWi6Ff+NLIWlHRk5e5z4aCfc9Kfr1ZzB9bKEVNnpx1/TSixqLFGAJ3zaREO4Y9jUracoHW+e3knTKtWJzIJyDH9zaTnJmW9T7KuzWwmvWuCa7wfIh9P3vc9fLy1Rd8jRnrUvtEb/ckNkkpDPhRQ4vsBqM2yKJl9OGzFh6QXgzBoIL+POx4UUu4eY8zQdVWB/7BNdSLKLLyud2inU1A7wbLrcWl3H2zm2JrN/d4BHGazGfb39+HQYzqf+YgjB8y25ug6C7e/wMraEIXNsJ2FaVqw8RZG33tB7uK6kfG68I0Pi51OJpg1DbZmPkvqcrHEcrHCwX4H1zkAFluzFkw7OHv2OE6cOFENzBhYxPFnmCOubNgfkfxza963Gff40IMA7O/v4fwDD8Fah+OnTqGZtGDxXalPvfwiNAx08SAbojXpV6qMM5yPYFHaxrXzshwaRLJhWWdlrONLY9+MlXUuZkD2IZQCBb8+rbXRajOcvi2F3WHlyGkutBmXCYZCY++6LhuE/r501Rxmdulnhy3+daVkzMwMMpQRTWni1TaErleM1NwcWtk7fNKo5LXqjT4qhyzUL2rKFRyNbv6WhBm6l3dElEWNWesAC7i+9yHHJZaoou1X+srgLH7XMNfGH14OXZGpkn/eA6ve4sruHi7v7ePaosfe3gpL1+GRRy/COYvt7ak/lHbyGPYvX8Vqbw+9Yyw6i77v0QP+BDMZWMtopgZXuz20htA2IaEeOzhH8JvvgIGBMf4inEnjGepqscJyscAeM+bzOfx+hkE7ncKtOnTwGuSqd1h1K6y6JVar1RpaocFfQmM1t5539+X4LdtIa8I3ZtCggYPfPHdJsPcdrl69jKuXL2Kxfw07J05jOtsCNU1wWzkQ+ZQfw+LDKkygWTmvwIO6okSElBrM8Jp2E2GtreVyLGPlqAx73bqSn3I/RNP4yMvyJkjd1iZCJF1EpPiuuNtK1yDVLap15ToS4vlojIODazh+/DjaNpwIHeNWJTCF0TDuC/alZn7J86Nq5mMSuNQkDkVejd/UCCP8i1mFDunjMMEmnwi8eXRGHo1VauY6BC7Hh9TJ4a4Al+0BJIHga7dE/ioE5MnJVAPqn4wjv2BF/57NSTHndSGSrItam6lPX6m3FnvLBfYWSyw6i5UF+t6G9g3I+PM2dtnhYLkIGUqB3gKWLYyZYDJpAXQ+Gsf4vYW+dzCNQ9v4vQdqCI0zYOv3L9qmCXcPhM1W47Vh1/VYLpcwpgVRA7/RbrByFoYZZBmLVY/FcuUz+645EFUr2RFT5Xbwf6qDTZReDddQ0NApzYu3+vy8LK9dwbVLF7C/uwtDBtvHjoEmU6/tB11SKICVS08rmgKDWDVpncjBvDAa1qeFpY0NcXEIzwHKWwQFvtzC35TJioLms/EOBUJN0JTKaYJjMJjMK0MBKaSQc1Qr6ToshQT4EL5N3CIhadQh32/S76YbJ1J3bCLL5+XvmkFpBjQGx1Hgeqwlc49Q/nwTK4zSw/hsTIh6huLfp0XDQdD7ZHKOHcDD0xYpuqhQENZZCWPjrI2lNqaiToKXsb9/gItXruHK3j4Wqx5dx3AWMK3BbDbBfD6DtRar1RJ9b9FZr+0zGjRt4w9wSY4XAOwYbduitxLiGRxExif1m7QTTFoDZy2MuDejjPTjttZB0qzL/2xguL1z6F3jI5kmTQg/xWhh5EqCR0RO114nCCy6oJUxGiaCTz3tkvRgMFarDlcuP4r93auwXY/JbAfbOzsANUoVEJOFENPIiGKicOkFQlB0Mgu9iCbL1vL4us7GQsjSRY2Nd/htzcPhTyuX/GFMcRG3rvaclLznMNdR9l2EKwh8QSGlAJxSkG1SjnbzWmhzMmkxn83jK1O4YGQwEYjCUhg0/RhcQvW6SbuAbBbXGJwys+RSc8jvAW5vnGbAKp00MRttskWtSFxNse3EuClroVY4qxcnndW3ilHWxp8EYdl0LuCEdrI2FLxJifSMWtwFYsbKyLvVAq63IHYYdqqnwIdYcvGuFAKjQq1EUyEMPfh1wSadXrl6FRcevYjLu/sAG6x6G9wihPl8jtlsC4vlCqvV0idPCzRkqEEzbbG4tgfb97DWZ0h1tsPW1hSrlYUkVyTyYbtLx9jenmE6MVgd7AKmhYFD03pmyHITH1NI0+WCuweAaWBdB+N8dE8TzlHAyE1nJXaSPh3nINIzMsGQmPWwZGsyaQ4gEkZtov+67zosF0tceuQCnOvRtFNMJhNsb+8U+nVoOzz08oViKC1RGo/QNxGB2ME5MXB8lM5RFciEh2DxVM4xlIqjZt7+UT6aeD88xt1BpbUVgzkqlrGup8sofwxjkn0qrxhSwmP4KcL/Iy4URHOJflkx/YnQthMAwHK5jPXNGv/3YWUT867+jcAa/gUmykrKGyhpDsU8kC8W+aXUuJglJwuXtfPvMyWGw6To58l0rjMwWdB5D+IEkORy4hbSvFEEB5w396OZrkxxIl1Rtc5AAxWFpMbhEz77UFTxlTrnwj5wh1V3DWA5rVosOglZDW0aBijchEdAugnLSB4cDXe+YHPNKmGyGEm8xS8+Y89Ye8tY2R4cFpR1Do4Yji2IDBbWgrsVyDC6ZYd9WLRmAjgD2zOmBtiaAfvO4sAyFsQ4NrW4/ZbjePjSPvZXDOsIhBY+NcMKoB6mmWC6tYXFfoO2AYgcjPEZOfu+x3Q6DcyP4ay/84E7L3ytIVhHWHYWU2L4TduS6bkMzfGxnzyPQ8M+QWQTzsAQIVwkEuZSuYMzDVuELaFni84CcBbcH+DgYB+PPvooTLcEJnOgmaPZOgkzmWHCFo4TI9dzZwC0ITJX9gj6kBq8pSYKBiffOgYbiSx0ER6Z2wRqJYqIUtI4pmG+If3tWHvWplXmeUsewpuUsVoQQC4cymflu7JO3ZpIsMQ6DIAMbNyQhzAN2A0Z8pFyH4nPqhyMbHxl/i8MSDYrmzD+6xEOEV01y6D2XJg1hmapNvnGe6pPbk4mH9lyPe6p0v0lh8O8xqbMD2XDDBaNWCYuCIQ+hL4RwC7kqSHAn2Q77PgkR41Rb7Zb14OMd4+k2PbhnOmf5fP49wgemBmLg4MYrcFgWHZwXY/eMqbTFtNpi361wnK5xGy2jcXBCouDJVarHpNpg1tuOYPFcgnXL2E7C8xbwPmT0GQ67zu2Dts7x3Fw0ASLwPe/Whyg2Znh9NnTmE0Mdnf38fDDj6LvO0ynW+GsBAfh20UUNG2Dra1tcNNGy6KYoExXydkVg8mhURFAkZk4FzPcgiiRgtRjUbQYFozl3jVcvHQRq8UB+tUSfbdCQxYwMzA7tG2DY8ePex+6MGgIDWoLhABDYLlEGiHUWwEeGbxJioK/p1wi1Ya3thHlQRBldCcRDaJ5D9vgJfIHHb11nJRQ1m1qMwdDOi35in6uBVm573D09c4jv29WjrSnUIYMln3m3ocRk6eQmAOJXqlT+7Z8Fhk6kFkA+Xe5by8v48hLjDT9XR0eSyQH4uLKXx9FyJVLU/pOZnRGuIU5OuZ6SXjJxTZhqIEMceiCBcjgEFUjVhmDQWYCwA40VQDVVP+U/yelzCDK4tDz8a8XBCXdlac+iQgOjOVq5a+FNF5TnrQER4zJxG8wr5Yrn96CWp9mxTHapsVke4rZbILWTLA1b7FYEQ4W+5i0M8ynMxhewjChAaFnB2ctJg1h0hpM2iZkFXaYzVrsbG9h0hosFl2A3ceYm6DZOsdoWgMyhEnj8xpZ63wqJkFoietw93kSDqJVEyB3XVC4oI1Fl8wWbmSi5ILCAJ/GwrHD/u4uLj/0AA4O9uHkClNlFTZNi9lsjmPbW9GNoaY4rQ8l8EtaHVv/4qVg9rmS9DWetfXOzPEaV5b1IrSQoai+3zhGfwPhlsAbtFlrp/a33rvcBJZyzPm7vM5Rhcp1bzTnEFCcaA7PzIAlSvXHrjuPTpb8jjpCNbI2bTd/ni+g+oYXokZTlRtiwh6CB62FFG+uy1JY25f8V+SLXEOshLVs9Ilbga0cUgufcsI7iXuq6MNEHqYEWVSuhI6MsjgOL2OLSOCuf+MZimkbNE3rGX5rgMbf7AUAXdfDWovZbApjCNPpBJPWJ3Q0LaFtDbaNwf6ihSHGtPWptiGur9CRP1Rk/C1tBKDxOJxOWzTGRNeRMUmjjjcDMrxQIO+yAwy6VY/eOszWIYXSSvBgjOBTuTUJwyoc7kQgtuhdj9Vyid1LF3Gwtwd2PYC0n+Sb8weophOJzAo4AKouvghuIRhqCk1ZR/azavuYmhnGNoHojgLgXUgYWgPr6CmtB1mbpXAYCoFNfq/1WXMblWWd8NBpx8fqjpUjnWguEe1fAH5jLfyZ5IPXRLRL6TqkFlBf3DW/XF23Hn43JLpCW0JtMvLQR7E2ssiDQziZCMxs8lEfX1nyOgmfWd9FM6kfD/da94osXsWoq/0H7ZKtS5ZRbM2pb4d9+X8hOie0pau6OIQai6rAgjVaIjLjKa8bFkzbtmjaHtyHZHPks/b2fR/2SxhMBtOZATABsa/j4PMXTanB9rLB1n7jI4ti/LjffZF/bbjoHpIK2vhgDessrO2C2ygk33OeGYshYKJrxVunfe9gHY9pDHq04RtRUIbzWrEVPfxBqMmFOs6usFocYH93D3tXrsD1wY0sB87CJhEzxyzIZuA+DKJBJoV4MI9Zcjj1vJzbMUui3CAe1GdWJBf2GArmqwVDBv2oe0l/l6/no/K6TQRB2X/N0+J/Z0gw/FHhOVLuo/hbdFkEdsOFP00AvQ7NfFPTKXQff24iEHIBEmLsax+O4S4aRf4jPoL0HRuTaJR5v35EA227sHhKd48eiMtwZDKLXRpIun8Om2PxaWrhz4HLyoZkmf6XQG4C6/qC46fP0yLKBXLmDkOaz3Wl1Pyyd5RGFd8qZcA5Gy91MeGuZeeAyaQBkRcK/g5fgu0tZtMJJpMJDLXedWEcZq2BmTa4aXIMk/kUdrmC7TsYNmjIgMj34ZxD27aAYVj2Zx2M8Unvum4Fxz1m8ymm0zkODg6A5Qq984yfwSBHINOE61gtJm2LSTv1IxuxJKvYK9DOzAmH8p3wTudPXBs06PsVrl2+hIPdXawWB3B2BcB4uepP5Pk9JWJMmGAaHx3ltel0iFErRKVSppl4zfpe5yop60rbZWpq/Z6VcFjnus5wNSKI1rmJZA0f7hVYb6Fs8l0NNl9H//yICwVpUx0xVxmAcq1z5PMR86lWryb9SlCOanMUoqVgTWXbSgvKP4tP5G4wrtQrNY8mC2/TdWs+Tnmy6XUXXPwsxxqYfLxKU6voFYEbNSt1NWNMy5yi0JLwIp+Kwhq0zgTIy9nhyu/K5UfhK0pfUvYuAxKgwi4r/iYQJLapIQPrLNg52K7HtWWH/ZUFkwOMP1fRGoOJ8fcm9Mb6yCPrj+KtuhbdqsNqtYfd/RUe3T3AqtnGqSnhllPbeNzNp3Hu1K14+/vvA1pgTgYz06BZ9pgSYJwLV8I6TKjBsVtP49LVq7j/wgoODtPW4ITx8IqlJvf2ghoY08Awwzng2sE+dhe7OHbyVHBX6THXi5/T4OqzDDThZrkwFTHyy/loGiICoQfzEntXL2PvylX0q95HMFnflp7KhgEwgVsCWgMYAwuGYUZPDsa6eMVpPmUpBfTYwa5NmGTJGCUgpsz1I2vRGE8PZTnM1SLv0z6VOquzlhuVnEbEMIl9HYRHPbT1+ktKrwL8VVgKpJpn3WE8lrRxU+vKOmEQtcjCZVSAubbU6g+n1A9WazrxcdQ2HRy5RCB6cZZuGso1oZqLhotviUqGrW+ayjeQPEzDsUZzGkEEEgZuB4kA0khIBkuFGUcYAiPhEPjpwsaoaq5ecnzmFRMgg3ketQgqPQietZYqPTt/cG13dxerrvNDMo3/2c68eya4fZqGYJ3D/v6+P5w2meLU2VO4tDqPbtFjjxlX9g2O7S9w+63ncPbEDrquw2LFWAFoWxv7d876083TCS5cuoK9lT+Q5pixMMBka4LFwSrsLQBsDCyAGfzms2WP6/39A3zw/gdw9swt4PZwhhkxG0JSfSgqQBJW3eSng73e5y0c261w5co19KvOb9A69haUUbHwchCNvVDxLrj8cNa6Ram1ellL69zMw7U11NRrrtbSConrvtLeYVZJzbW8Hsb0bYQn7Oa77F0aTwZr8Wysr1FvRORbo8PKypFuXssREhYcH27eXW/ZuN1A38KuhiRxfaVuDiYi07fM6X/yfp1fktW/EmjxT+ZDzxnkxvsQRCCmcC4gZBwNCnIAqsrBa2a4nCglkstVvMAz1KgbtAg16qP4P2E88BuZLP5zji6ew8a0kcZTqeMco+t7XLu2h+WqiwfPvCeJ0DtgsVhhsVhh2XVYrFbouw6NIcAYmOkU2ydOYuv4KfTs0044ajCdb+HS1at4/G234uTOFNMm4Ckc6vRapffrL6zDwapHzwTL5HMjOYO2bXHi5Am0kzbC7pyLexvOAdYylp3Fhx982IfDuoIJMCIuBwxC/S7uE6b0RjMhxw7WWSz2D2CXK++6cg6OVfbh+I8HrmLn1kXGlMrM8MbG6OJZs/YPo4Py/aAtxYw3dU3VmO4ABhGC4Z8+qJ2NjzCIKE4u1rzuulLWKdftWhyMlMeQ5iIPT93UNFknmcfa2KyPpHbGeqL5qL9Tv2NtZD1vRHhiApd3wa7rSxQtKuDOvs9MmLo2ogMA6kAq+yKsXbnI0GpXEcY1idg2pd8NkbddjI+sIQrhfiH5VwWMZFFy5CDpJVenKe9/pFRxXmnHscOq77G/f4A+pK3wCTm85rhcrrDqVnDOXy9JxmBrOsXxY9vYX3ZgIqwc+3sSnEPPDm07wWw+x0MXHsbTn/IkXLjwIPYOljhYSWplz9wnrYEjYH+5QucAqLxRhgyObW9hNp9h9xqwWnXorfMnpuOtbX4iu87hwYcfxe7uHuy0z1bwWiwJMwp/jmUIdoGerLVY7O3Hsyh182/oEtSCzFTooAw88aANmdiYZrxuv7FcE/7h2LeeQq43+KXWf952BnXtw/SOkyJYtnkUa/movHisHF0oHOY+26DUBAOwfsKHjaCIvMv9Z0frH6gPbFxIaYHgnMsO9mnfaG3DK/+rDjcp62GTSRb+npme2bCSlj7UbnLBVdM+ElDh74YSI6egSavTyDUASVw6ognrPhDS/xJlgvwobqPDinMWXbfCquvgLNCzSwkKmLHY3cXWfIbt+QTTtsV8PsexE8dx5vgcD1y4hIev7OHhy7t44JGrAAOzicF04vMRPfDgBZy9+RxOnziBS1cXuLY4AJGJ7KBtW/TMONg/gGMD51ZBaWE0Brj5zEksFyvMTx33abe7Hquuw4WLe+is38djApadxfmHL+HixYtY7iyzFSzRW+sUQsGtr8cAO39YDmn9WWvRLVdY7B9kio4IWlZznNEK+/Davu8G54DGQBIGLtaCtKk3Xmvaei0qqfp+jF+tYaCHuZBCJWiGPlot1i1gBgb7kBTWaTm2TaORxqyCulttvFyfpaAQvbE5v665QyTcaOsDdfB6JZbiwBuUMpd9yfjzQ36yYFLShXyc6yMI4sZrokHoQWcJww4hzgFpGVaiIsFWM0cBhJxQSuN0BLl0lwLMcvvWQLxGKZcgiQQfhEoYfFpE8sVHgL6Y2WdG3d/Dw488io4tDhYL9M5fSdStepydG5w6vgWEpH4TY0GrBbYnM5zamWH3YImLV6/h5M4cDg2ecsdN2Jm1OP/QBVy5tkJnGTsnT2J+8Rpw5SC6UjyuAdcD3YJhtvycctNja9bg3OljOH1sjj3y9z4fHCxwZbmPxnWYTCboXB9cQoB1DNc7XHz0AtpzC2BniOdDGQn7dB8GHBLbIU6YdQ6rrsP+/j6w6vO5JKVoKNzK/Dj2Qrfv+4wRyolo/Y0U7ToS+Mu5G5tTPWZ5ptdeFjRRFq2pkzg21/c5wOtm3pjxMvg+WetjQi/7/BD3Wvn+I+4+8mkHhj44phA6V9N2439CXXjNiBxllWJgZPB1Rk0mtOvTi1BkPOkbaVULFj34fLKJalBq6LxzxUSmJM8CM8xg1vRWnnAeEhhRG3AHpMuKAL2to5l7zpzFJ+0vz2iC685BEnt5RlzG7aQosQYuJFnTxQRNtVixMCpNRWLjlC7uoHAilhqPK9PAtQ0aZvQtx0NPeXEgdfI1jVVpMjBoCqvFS0IZB2SCk8XBAcck6agRF1t47S8NIn9KujENmtkU7UGLeTvD3sES3aqDmbTYOraN2bEtsO2xWixxZX8fl/c7HBzs4sTpm3DuzFl0lnD+4hWcOncKhntcfOQaHnn0CtoGuP/9HwTvr9C6BoQGTWPQ9T0cE/YPLFYOcLMp5gAa58c7dQ3QARcePY8zZ27B+QsXcXX3AMuVw7ID+m4JkNzcSTBNgwPusbSI85FKyoeUrF+twATFJNz9zWA4crDw15CSsz4f1XIf/cEuViQb5ZI1J7WXliLBWfYpwNlPgbMO7CzA4cAiM5x13lJs24Hmn853IHPF6hPLfkxpTeiT6lJKxUocdBz/k4iDgqYfru4JdCINIRGh0FfwvQ4soBHhVJZc0fINS4bVdEdE4iPl+GpMfp0r/qh7E7psfnhNJq407zO/sAK6CgQD6kxDNEpZCFQ1FarHP7KJGpqQsQetMTNg2UE2SKWhcQQlUZSeVOpy5JmZqSt/a9jkfUMmCFCAVWpgPfFa4A6tCW0G+qcGPjVDZIJICGRWgprS71pfdwUuqtqaYrBaDCePEnk3ifH3BBAZgEZC6ypaUP4qFxLVJlj9IkOnnKYys1zRirMOtrfo+31MJxbbWzOcPjX32rcBdiYTbE9acEuYkLd6dhcdLixXuNYTTDtD0xjcdvM5TI/NcWLKOHdqB7fdehM+dP+H8JrXvgnnTvr9h8YATYjXt73DarVCx4xpyzh7fAdnjh/HdOqFdec6LK3Dhx46j73dfXS9v5ynJcAZAqwNA/NJ2ZYr+LMUnIdVD83BNJ/xcWRwHA6cIeAxMFHn4HqLbtWFG+OQNeoVmvzaXEIwrgB/bWlv4cTlpfQqBgb0bYwZ3Ai4KRM7zKrgwERk/MKiBE2cKgW6i/eVJlpXCqa+/2PTUt8TUHmTtObMeb2aYKiVw4SQ1Knd1lcrRxAKEY1II8oB0KCNTSkrP1yclECUkrJaLBIiERg5c97UDApkWTHThqXUMpK74/CPN9kMGlgsG0xwZvEIo1dERBW4IwwKl6UxEOEoYM5/Fr7N8J8BzyERGKIkCN7Gy+hGmpEt8PKdOjlNSTDElCHhv/JU8mHWNFIfPuzQELC9NcFsOvXaKQHonY8cMg2mbQvAYGX3sGcNuoMlmsZhMplgvjVFSxY7swlOHNsBmRnOP3QeH7z/QbC7CaZp0BBj2hh0TRvyKPlA12ljcPrEFm49dxKAw8Figav7CxysGLvXrgE2xNiHaC6HFp1zIZLUW8vsHHrbg11u/ZUnNSqIV3iTqCGCDoNx1sL2XbwtzNdPrflTzoSyKwqYt7YPh/88rrltciacgZPobSySr9R8a3sNY2vJiQejUNAQR4XIY2ptjDHbwy2BzbVy7b7lCpYOg2vMOtHPa/sw68rm7qOsQaXCKwGhwR8wFA9pHHPNN1dKZ7FMGF6D0URUEsTYROVMM3WmLYfRIgKJ8nqZIj1CUFnfgioEV5jSZX0CuHwcRCmFxtCPyTFNQ61k4yVJYZ4TUXTTrR/9cFxEyYoSRsIB9876dBHFXK4remMxMgH1Xo9fBJX/UQi8DD+eFYDyU6vMSXNt2zlWixXIEsj5De62bdC7FVpD/t7kaYNJO4cD4JoZXB+YcbfCtdUBTvAMtH0crltiuVqh65ZwRNhf9ZhNGS05mEmL3hrs76884wNhCsKx+RZmkxZXLl/GlSvXcO1ggYUlcM9ojE981wQmOTFBKAjjCAft2LGiIoXwgjQERyLQ05ySImTv92fnsFr66z6dU0JBt80Aw0GnGU3z46OWrO3BzsI6h2lBDHpjuWRuZfLC8m8R7IdpvOv4RIRB4UefZxGFdGB1iAPtEBdO+e4wv3+tzQgjbxYdNTZO3dZRytEu2Qm/UNRc4aWsvNZ9pxv4EFWJsUJ105KjFYH4dymRD3Uh6Xb1f4kCcZtDv+F4wkv6RPF3kXyrnJjBQlX4CG4eCkyg7/u4IMYmumkSfiTSSRZMrO8BT9bFkehi3JIhBbrvwoEtwI684ztkHi1v/SIyxQZ82a5i/gMNUQmEgSCv6KDiyyg2HUXv5R4g1+DRi7v+LgXn0HUddk5McWxrgmPzLezMt7Gzcwxd12NveQnLMC+TaYtTZ06D4LC3d4DLl65hf3+FxcEedrZnMDBoQJhMWjTzKZZ2AW4M4PzJ3wkMDvYPcAmExcJisSTsX7Po0GG+vYX5tPXnIhCS9lnGzva2D59lBthhagjnbj4Hmlt02N9kQpU+Cn/PRrqaC+G6ZbB1WBwscHBwEOgwmmQpSZ+WPqIAKEVD7w9AaLLxEVZp7QwjbLSloPcVsvYLa6F8no23Yv1WmSP58yTrYhdlT2GMudb4hoZT0OUr6z/Wl8OYfbUfDNfXKF8aKdcXksoq1YXW2vIqidkLAXHKnnrYIFNbORPQCDiqBIzQEYOogaEJus6nLRZCPAxxZR2n3Vy8gd+ubN4EJghJM6AIIVy5OLC6gpuxDOMDkIXDxu9cvpm3TpCNu7ZE1VRsOTJxeJwC4JF72YlS2w5hj6VGvIct4gECOSBENnnkb0TLNLbFjKYhNM0+mmkHQz263sIaxnS+hcsHjCtX97A12cexrV2cPrnE2XNnsXWswd7uAouDDuwY2+0EB6tr6C2jc0BvCPOtHUwNwa320VmAJg1WTY9V30M285kYaDpc27+Ipl2AmwZbx1o087PY372IBoy28XmFll2P3f0lJsxwtASMARsDQ8CJnZ3CVZTj8EjrIiheBELf9d7i6Xo0luCqJ6aH6zHRvT/gZq2Ddr+zYzhimCa30EVQceVqURnDppbBmEVQPhtt49Aam+F2XZ2gp23WmWpvU2aurcCkuB6dRx7h5rX6JgtHb65YEBSYfx0eIlJ+viQ+hclIHd1zPjgKzBODEP/krtEGoXrP4eIWR/50ptG+/iC+WKAJs0cCgxozu3hMnXx3IZul5IFRghDw2SQDU4zuFsghMsoIRfJJJUGazNtoYcRhFnCB0cr9v4zEJ5uhfz1pWBxbTwyfYnsI82vI+L91tg0jnzEa7uDIgWkKGJtCTAcQirYn9zinMDxjhJY8/gVfaX7y4r/zV0PmVQwIDMMWcP7shL/20YBBMJMpqHfYmUwxsz1WnQ+hvO3WY2jNCUwnLaZti3bSojUO89kWzh4/CdO0AP3/mPuzJlmSLEEP+46qmrl7xL25VGZ19TILBnwghISAQojwHX+Af5p4I8EZQAYcEJju6Z7uqequyqrMvEtEuJup6uHDUVVTMzeP5VYNSb1yIzzMzUy3o2dfHJfpwu9/H3liwotwcMLXQ+Dx6cLDrMxJOKsQJENMRaXmGjh5dyDlgDhHGGAc4T58zTxHppjN/jAncop8ig4vmWGAQYSD93z77bd8++0veBj/wLxd4RsIyXBEIdyuO29i0bUZ80JSMiqJ7FOToutZrZqBXlxcM2jVNdlShUAmScbnjDkjFI8bIImuHNREhOA8WdIK0/T5i2pf3vsVk/OSSmdXFbNSOa5tdS+t50v97f7d0IwizpmE3UkPt2jN8qw0qmI4an8sCyGs58+1LXstr/AmSWErHdSr2+8XBLf3El190dQb5f7K/S6bvp2JttdU1ctV6/G8rO9QaDpozbrg/L2+mi1hc12Xfaq/Wi+FQq/Imtpdy7qtiWHtvucK+g1s9L9+d4MorJC5XH+/bb1YbPMRi2gthKC6Am8NYFtDo9QnymT2dq0TAkq+pXrHQhHFrVat/bo6hMb+471Hk/nut3lzvRdNRSfVLdWIxmEIHMdAGo3DHSVyOpw4Ho8M4wBY1s+744l3795xOJ0Qcfzj7/7JuN+Y0JQIAu++eofzA5+efsLKNCsxx+KJY5XCnAiD96SknJ8m/OAItTbD4Q4R4TI/kVOyXEkYBx68Yxwch8FzGge+++4bDuPI0w0OelF9FiLbe2pt9maBSMtrlHMputoh7Vwf6tRCBhprzzuzARYPskVZ1/Mxy56Wj9VttMLUVj38WhXKc9/vIfEG8+0mqmC5em7LTP0xrbA6tFIDPX1q4L4Tt8TyvS2uLudz24csnop1uMurXidxvCkh3i1J5HVdLe25xbW0wqF5MLxmI651+AvQstlUYfFyWk7JgsZEiodHwfrb7he8rv1qNyCr6qSG7OuB6U+lLDr3SiO3a7hrMKrju3HPVq22xzH11/fy1zvVTn9dDmrlMBuS6Q5u+dneINmMoFfrthiSZf2KTnX1DMe0TAKw3EvBOaLWIr8FvbQT1p+0SrZt3b1kPJHBjQzDiPcOzZmPP/9k7w4eHyw76RAGDocjx7s7TqcTIBZxnCKxFOKR4Ln/6j3h/hv+8PHM9HhGk6W/jimTczKJIgTujoHH6YwmZcRKeGpyuHfv2h6pJkQyIThGEYbBMw6ew+C5Ox74i1/9glCK7yybu95ju1RUO92+NUagP8wFw8Q5kmMsOalY3VPfBRR7xPX+NgnYSYulWW/eMk5RSnU9yjOujXFPpbntZ2uTeAueWK+RjW/v/N0iJnvvfE2TnT1afV+l9bqOhZPK3X5VgqEFRzm5baf7UiL2JklhdwE2bMfKE+QVlHv7TguTj7f7W7pq77+yBVREu1kUpwnBlQzSaiJtWXCtUoFWTvc2Ym0op3LSdaOWmwqHXdBTQVTKWo9/a21uG3lvX+/fu1dTeo/rqumZey8P51zR95eFRAGPqBSFQEUq9b31vk1ft8Z4Y97Xc+sJiyFzs0aUVc3KdL4Y8S7fGRHeQVhg3JVY2Zs4TwzOm6cRGZ+V4AX5+hvmODNPE4JwOBxMreEtSE9KEZ770zu+/upr7u7ecZkupBQZ7u74F3/5L0FG/uPf/QM//vQz777+ik8fH5GnxPffvOfrb94TXObyuzPffv01d+/u8N6RY8J7IcYJITMEzxACJ4HL5QnJEZJHwsj96R3/u//ir/izP/sln+W4mmvbFdX1sWzSX2X91dKG1yIsqqDmeZRTxmW7P9W1K+rIZqyvPNVV8JgVK/Iu4JwF0qnkRXLU6p9vKpR+kNXAXP9X29hWGrHXPG9Y3d63a5CW+mOBl17CvmW73J6h3t7xnMG79rkSkrf3dCquelYWovWyJ9Naqtlfj9e0P74c56pX+yVKU0d+aVurUt5G8Sxb5KJaauoWFHOVkYK0q0Gy/C+BObkATOXx95qyRBBrN0bpfr6q9VLNn6htAWTPiLwlJL23kyuytMhahmkWGDXOvAGuWrI5VUHwOPKV91E/ju04lwO7eaYDpCVwaCulUNQd1UIja6mMiiwt5cQ0zXz4/MBpHMztstgx0pxRBgRhniMxJi6XC6fTCXFiDgnyhPeBYRgIYeTTp5/5/PSIeOHuq285vnvPf/N/+j9zd/qKf/fv/h2//e0PPE4z33//Db/65S84HgceHj5yHB0iSppnREPjkodh4P37e0SEeZr5+OETh9PIYQh45zmd7virX/05p/HA6MzTaT3PvIsNUlkDZamAYki7PmcIPl4mK7MKWGjjwF6O/1ziI7b76VTNFTXFUqhJ+3J61lcBmB4n182s9RZeY8yt922R/mu9dVqf1zzEq5tzztKQzFvLzo1+iyisb+yxMaF13uWCbLPkrgjl6yWobXu9oXm3A7M6LjTNDvFLw3gNAlwh2qbekSYd1MNfmPU1gHUczSpsTBeupbdGlCwwXc+LIU6zFhqyw+FX4vEqfF6lhUpQ6tVaZEe6q/1jFYCvEeoaie593komy/U9XelCIJZgue1YRIvLoMlc9pxzqBuQIIjPhdsdVo/WyNUqhblKBHpE0LGhRnDMOJtSattfpbkFq+SyNAvRMI6vwGJljlPm6fNn/vDDD1yi4pzio3nEhODRqITgSSmuPLg+ffrEMA58/c3XHJy34LW7A+MYeP/uPce7O2T0JoXkhNfA9999xz/75/+cv//1P/EXf/Hn/PmvvucQgDxzPAz84rtvGPxYCI4jzjOXaeL+/o6YJi7nCylGvvnFe94f3pFSJAyB77/7nv/6v/4/8Ks/+0vCwSPTentQKUZMSrDpkqhxSW0BpIySWuoayco8p+I1pFBSrKvrYhV6pCvFitRx04IQ0Sp79KeuwU7Z2O6iwZkDCIEwzUSuW8+535KktyqmpdtrqaIREzpQeqFVSWc1pqxGSOX6DO2+Y1daWTOU+88v53FRw+YiIe8RUdt7e24hmP+ZIppX49y5qRN56D/stwVZm9i2O2QtviRNxJK6Q+35isCF6+/W4mHXd8ehoFryMS18vrSN6nT4FZFJ4UgVRLSJIq5s0paAVIOftEGsSRBSX6H91Ta+HheuWvvOWJ6qnqqXGvMt2yC4KhEUN1zquBtptxFWGlxYk/q5JzL1OUEZxMHgEDLOr3czhMBAqRUg5mmSUmqpmhcpxTdOqlcfaUlyTef1ZTfVMVjyHUvZXO+ouZCUnCKP05mfnx5wzqMqxDmRwgCDR4KpqI7jCOOIiBmyRZUf//CHJsmYsTjwzTdf48MTlymiTklT5MOPP0N2PD1ZvqLj3YFffv8tx0NA00wsdRXGYUQowWkhcBgHDoeRy+VCSiWAbRw5HEZCUJwLfP31L/jzP/8r/uzP/orj4Z68Dv5m2fS6v2skZVLyyk+0HjtUEzFO5BxNPdgATpdN6NSm9ZrR8SVlgwRXyEJFRuCyoMG45MLnGryVs7PwcYo6t5zzq6mtCcMWCffXVjayZxBhx4Osr+2pgehjNeq9SmpnrHu+jXl7Zl+QEaSxo6t+Qdd9lzO7pyq1fpf1b+eWgqte0d6U+6g3Fl4v3PXqvkkjoh2Sbxitvtk1ZNtvfNNRN2mwAkq91o/RxGczJK8Fi4I3l791jVztnNTd18KRdf128xQKcegptEjJU1OQa7dWPeBIDzQ9d9P+XM+nYe2V0KCtuAvtgFMI2RoonS78tVsWraGUFXFzshgHFUuR1rh1WzMnEMaAal6VHwXwxYGg6mGH8UiMseTeX5BVpmZWA1QKp+txRFRzK+Cymoe4og4xCcAMpQnEuClNiZhmHucLn+MZX1Qnc4zEeSaPA2HwSIbDMBCGwewIzjHNEx8+fSaET+bSmjLhMPLV+3cgAf90Zpom0iXyafrIPE08XmY+PX7mdBo5HocW3ZuyEa3KJMQY8d4zDAeGwXO5PBG8J5RcQN55MheG4Z5vvvmW777/c+7uv0EkYPml1oC3BpE9zrVnCoxIKIpoJKXZvI/KvprwtSYKJikquTAJixqmMEV4nFipz5qyRGqtSbfuujs+4ARN2fg9J1fFZ9oUn1GHvEVNIqszc0OiYb12N9UxG8TfL7d2P/v798bTq0+v+9mX3Ff4so2zH/9y7S24+ItsChW1bela4zBXnPqfoPWw33EMtwxCdb8r8nDOsVnjKwJbqWrpZE10ujFsZCGudnkjxqoqqePQtoaq+oYtP7OuFcFCZCst6K5Jd79sh1fXR3s1VVkfyR0xyMu3Iiy1ekEcaHU1VPP86UnIImlk7o4HVJUhD1eL3KsgRhFOpxOqS+RqzpbLNYSBEEzXHmNknmecZFOzXCYul8tKJPbeE0KwqOT7ey7nC/OcTTWVQXGczzNPT2cu09T6inHCkxg8ODkttYVR8+UPnuAO/GIYcd7z+PjITz//zPuvv+L7X/6K090dzgceHh54ukyEELhMZz5+fODThwccyk8//sg3X783gukdqBlRBVOLPT4+8vj4iPf297t371qEtXOOwR/4+qtv+f77X/Ldd79gOIzGne62t5864x3M6UAK4q/8xFqy1G7/rvcVjJMehkAYh6b3zliJ1lvjrdky1sTreh4v6cf3sqb2Y3tr20P+dRyr+17bn2xlgP4raYxwO58rPGED2DWY77Rb2WNfa7d8k03h6trNu/XZb3ffv9tP5VmvC3A/97nWDRZZXD+9yI2UQcb523N9H8sIYI2kn1vk1eh7/eXOvQtB0xYSsb1r93p3zW2eaPc34KnusduXNC/2q+a3Y9XyXgULc+rmWvTSZnyGjx8/omTO/mwFhru5rmUzmoGuEgaTQgMxJkNSRaoYx5EheDgppxSJ01LEpUoaqor3nnEcSTEyR9tvh5KSMpXymtMcUbUgv9PhnsHbfdN0xg8jSTMxJ6ZotQzGcWQYBijqJB8Cj4+P/PD73/Lu/bccDifu7u7ICD/9/JH7lAjhyDff/IKc/wpP5PHxsXh6Cccx8PCUiOcnVCmSQgBR7o4nvAjjOHI6HIgx8u7dO/7b//b/wq/+/J9xd//e1qqei406QESvEMitJsW4XRmKVOpANwa6f3SVyXc5J1dgokoIA0MYMQcB6R7iCrilA8l6Vq3QEq340dYzrvdKuprTDSZx+/lP27Rbj32ct+XvnnkVaxXw69xit+2ltOIvtderjzZi1Rb5dX/tXLtu14Nci6Tt+2dEyf3+7SHHGhDzM+/qx93fdAuhP7fA9bttSuxbzzX9t9DSXFzdV+fRcW8VyS8V37r3l0MoWv3Ty1zay4rwXjD9AmjWUY02vjmeXlrKupz9lkl3XTvB5m41Bqp9o/ZZc94sWTkL11koeEwzR3dqKr3BB8LomFMkZwg+lFkth+nd+/fcvbtnzjN5SviHC8PHD4DFGKQUcdkTDkeCNy/+aY6lvkTZl+JZ8uHDB5w4Tqc7hmEwNaA3CebDzx8Q94kQAvfvv+b+/p77d3fEOfH0NPHx4weGMFp9hlLvOU0zEiuzYCPPqngVLk9nZu/wPhCC5zAe+Gd/9S/4xXe/4nh3bzl6clWdXRsVTC0ia+6GAjOVWPTXoKjk8ioral1P24dCgurWVIBih2PNyjgMHMYBNBcPpGL4vqGnZ4PkDDZc67umudg7g3tG5H0mcWtTe77dIia7SPpKKXvdXo2Oq2S+1Sa0Y31bSnjN/P7kkkIbmHRICStxWL+8Eq2eGeSSZPG2WNXfeIvTrp5Ba10gaJfFsXJDDZ73JoaF4Nd0BM0CcEPHeJMr0B3Ctvl+BcitII1QWFvaGb5ehtV76OauZrnr3l0kEExqsEVZL0AzEq4ud6o/waSJtgbLWi3f259CKTmZ4ovpsysRgIWotbVrA1of5pRTw3euJNdTNYTR7BciJTW2QVXyEPCcz1ZJ7PHpsRGPOc48PinH0VJaCELKUPXsxMhlmvFBCBJ4enzkSYSUE4nEOB7xwwnnzPbwdJk5HMx9NSXlcpk4nx+5aGaeJmIhCnGezBjuqkswVqukQ4RCIgEXvRBVEFfrVIjZdkwvs7OuriGpK265gFiTBerlbIRhnmeaB5g2v74VLFXVUjP6b/ZUUY6HkdM4lnt798se7q4FhyoV9gxOX+J2qzbews3VWDZn8Fq19LzL+5XRWrm6v875OQz2EiJeaR1u4Brtf2704NvXNzXUDUnqNe0NWVL7REOKljxCFXGuuNQy4Hrv9egqHpQWLbvIrIs7aOu6Iq+C2yh9VmRkj/diXOlVl3d2L9ubnHHVwuJhdGVfuA5SuQY+XRU+0W4tKhdsz/R95yYBWK78DrFXgCnr0YHMevQi6xoDnZRl7y3zke2elKNfptyAu0P2petyvduH8v2VjNbmt/1mxWoWDrD3kOjnrW3bnLjCdWJBVwriPcUp0mDIObx3pFxSOpc9dGp++edp4rc//shPHz/h3IDIzBwTj48XNGXk5BjHYJW3ZIlYTjlzcCMiyYrkxGQxDGnmcLpjGCeTgJzwdD5zOt6XaHAh5UycL8TJ7B9GEEoEdDF0u4awIiKhTZ2iTotx5unhgZwilpOoSAf73A3G0NxWHS1QrTRPJM1oSuQ4r/ZntWcrQtHv5RqWnTjCMODHweCuOgXoznvbOevG12BgQb5X5TW7e/eIQR0dHb5Y8Hp/gvYZ2N7u1V/vn1np9l/As1smcN16ZroculuSwOqzbGazc6/U3e4X4HlJorbXq4/mCefq7UINAJOSR2ZVhMee2AyzIs9iVO2QaeN2C/JtOKhgHlXIrYRnpQrF0tB10zG7NNDSSoHWfM/yUEWolchoQ8AqldvuiUo5HFU1U98hYMFbuW3IQjBch0C3xnntftaxL15S0OX9q9SuAJFQPZ2u8UQVao1bq2Mq97SYPSnjqhHZ1qHzNt6eG6tLrRghz6ur1t/T+YlhGNCOQLfxOApS16KeqhG1BYE7h3O1joTdXzlG44zLCmUlaSoMib0vYXr488MDaClJqRCiMF8Sv/3xR/76N7/hn376yFf3XzF4JUe4PGWeVHE+M4yeo4/gPZdLJMaMOIwQ6EScE9MlcT4nSJZtdbo8FmM9XM6eeDjzdE4QHH7waLaIZIBpnpjnTIqBu9OIpgvjEHCu5hyqdpUSJ+IE74TPf/iBOD+R+doypSZbP+lKby5bUVelgup6E3rk7CrSy4k4ndE0L+Ury/19TQW7ajmitHmI9Zyz4NyJPAxE7/EKY9JS6jNbYFuRNKR/pVSOu8MFjSfa5+R3JYPVoVoYu0Yg1ow47bx3RLR3erjqRxe30BWSv6Ztq2f3CcLCYPbM5sIcb/tYjP++pbXoeLzNWLOImXTSsptbRvu59ibvIwNaW4Xqp09X7ONF8aRgPWW94Xs2iYVjWO67Uk+xux/L+2RfsNuSq1sG48r9W0vto+nzl2csW3PHpWy5EApyrQNe9acLk7BMoBvF9qN2LNDC8NGpvkT8wiJpMUzu2AduqfcsWKxQMb+e5y1XZxEp+XgEkZrmoB/+0vcwjCDmkimY/r6ud45qnLNzjMMB7wXBo9RkbXZAUormHuuVlDMfns7FE8lgJufMNF/4+PGBf/1v/2f+8PMHYkzM84VxSHz9zTvS3Ymnx0c+fvjEp4+f+OVffMfl6WIJ6E53hBBIqrh5wg2C3plq6OEpkueZc5pxXhiC4+kx8unjhRjVpAxykQiU0/EIWTk/Tvz48wVx8NW9cH93Yhw9zhkhOJ8fSck8eMZxIAfhhz/8zKfHJ+5T4ggL8uSP8/Cr5y7GyLlIM7CoWbZ69YrQCylpwNpz1NJpDypM4JyptTawt3jLFUm8zkukuXTvqWtWMHWFD66JxXYu7d5eCu/m+ZJufg8HfWnbG/92T6V99/z1tYqtpKPZqKRe297oktq5q4ERCOkiSXtAKoE6i8tjpdzXgzSEEjgcDnz69GlV26BtUpUm7IEqeF0FlPTvbDrNDgB3ActY6g2yZiV2VSPemm/uf2nz5V9pUvvNqrev5pMbt9QNqvzekL2OgFbJQTU1CcO5OmRdiLZWImLBaiLdgaiSWD+m7edeF7sTCLRez1uEfpE6LBWy4l0wY3K5t3ob0fZISXnG6UBMFWlVxqDolVWRbFJQ4V8bk6KaEK9cYuSHHz/weJ5IKDFNqMLhMBDuThxPI+PnkfP5wm/+8BPnpxmyMA6e+/uB0+nIyRvRyqqkqJzPZ4sKFkiqaDbPonfv3hH8gayJpLGoriKq8DRdSDly9064Ox04HUYO42huqiiXcyQlJQRX1GqKqEecUX6LA7F5J00rNcut1uvhVwWYGjjVSmlLoaY9tcmKi9YFdalFq1i6DUC8wYDV/m4PNwqw8GoLZ98wQzvvFGnpOuXFszbKDq9sEXsv/dTfNtRrXHDNmNFwTqmIusLQhoDL551xSj/J7Zg3jO61u/sy9n63ry062zksa1k1AW9pb/I+WiNQSwfcreLqXqfSQIeiFqpBVXnjty8iLZCpGiF7BO7FdRBVOFa5jjCsxqptQZl+XNtrLY/LSq3TI2VtO7t0V+0eJXVAlXhV0CWvNW1L1a3w+xWMaPtBOWXlc91V7SJC61i0Q6DlauXypB8DLVhvoeZ1eKkQi3JBu/q73SkSZJXWuh9/yyMoa6J7JXwJaNbm5SK4Mq4W5VCqtgE1GlpNF5+yHYPFC6UnDrbGXkr8hFvUfWnK/PTxEw+XmVgUaikrOXrEO5yDMDju7i3IbJwmLoPlPZpi5Oefz3z4NPNucIzDgPMeVYjJCtOHEPDe4bxY0JwqPji8QFAbb0wwXSbzmnoXkADjMOIFBj+0ovXKTBh8QdDVM8mQ9TAEgjdjuBbvLa4Mpx3Ira7JFfdfQSylxDzPq7iPvlVC0OvZLZZkva9ZtKg1zHNNs80hk3CEtr8V4S9jKbhhNV5XDOvxJqe/h/QXm2b50TGRsjy4QvZbJN6MvR0xZXNPP4Z6vPuEsOi1RuO5turniuB085Q+K8JLEk1RIko9y7ow1K9oryYKzROgYgDqGq8XuXHIusgGUAdWuOgN9a/+xzlny4/TAS+A047LqUjoFTO8aYi6engZ+bW+sBiCpZuN1nWodQw7WMSBuCVNxsIKcbXrStm88rludJaFu6o/G01sGH41+qu5w5IltnkDaVfLoBtLgx29GmJDwu0LoRsyq7NY7xc73Ksxbg9KzoW4N5LQemnshLnG0MdT9N4ezd4glh7aDoxJqGaojfz08888TiYliCuEIZo+PmvGOWUYPQ7HYXDMR+USEw/niTjDJWU+zZEhaMvdNM8RJ46jWDoPVyQ2y5s04z1NJaQ5k1PGO48fPG6EYTigMdpsShJGgQb7FWFuPXcUg8OFo92D4w0cbDj/+k5TwaVVVuL+mb3/S48dkCzZJteIeYfI7LXGXMiyp3221L2AtN13LKIJqtLh/xvEo36zQZaLfXM9wMYsLU8u57Z73qb+ujxDu2rrPYLSeMOFEXyVqku7/YbXIU3eQBRSSkVfGwApPuzasL/0oy8cQ9mtBcizkEv6424LF8cmVXJVI3TUu+eADUcVxNNvhyyA7oo/N4W7X1P9glRWVHgZuW6gYUGs1WUVVF1zzS2yJSvgc9vVKMF0PT1oaiBtBKFyTftHftnehkQrUlxusfG6ekftZ3HZbAWGVC1Ioj6+IhT9AVgNgUWXLW3s5dXNo8xxXaPZyZJmOIQAscuBQ0UGpZNcgw9BnL0vF07fpIwyAlfXSouRNJOzoNlsDnO88LsffuDxfCGKVS4DyMmRoyIu4pwSglVlOwwDSR2XpAzjiHOBh0vk/PnClBOardbA+ZIYAqRYJA88ysyggp4fTVrwDueUaZ6sYI4zgpILI5FzJuXcUnKnmMliklrdPlGD0RhnS89dJaQXkEHbrh6hL+Df/q5EgQ7G+2crI7dC8lV91IrpGEQqagTSWSR65Wy1It3G5FQ4MwjqJXRFm4txL/Vv53SrLQZr+ztvcgP1y1DxTR2j1LVh/cyqOtyyhMs7V0d//ey2rRjoHdXVmhItuKvjw9d933j3injpAgevbW/wPjLuSGQuOi0FBrx4VFPh6mxejkRyJTnWZhZO8yqlgxOBkp7X1YXZcKr9miPF42lhTe2rVn0L8ibbb6Pc9UB139khc32ShzU+XGDYitOXizU6uunuyk0JBY0mBtc+kIKo1xsjIsWDyrjCXozUW4gZwFVPiIWjEcBXyCnzr1kwFyP5JoY5LZw9nQ6yVobais9S9XY9B1bUGb4YE0m5eURdtdJPCIGYzQVSRVCxYEPF1DmL+q9QGhFLY9RQSCXYgAQQWq0HQchiqUXOlwv/49/8DU8RvB/w0XIg6f2Rn378yOlu5O40Mo4DPjjUGVEd4sydz3infJ2F9O4dOVvEb8zC54eJD3944jdTJD7M3B08v7g/8v5+ID488TTDeYY8X3h3NzA6QeKEu8AwZM6fLwAchpFhHM2e5mdUvLmfFk51CAM5zzw+fSamueXQohHYfU5zz0jboXugpPmYZ/IcF0JhD9j/UmhHyr2aMzRGb4JSnrU+51UIpztTk2WQkNGDA8JSntWFRmOyOkSlMRLWtxTHCYORqaQkqRzxnl3klvG52SFznYuuI/VzZco6ZF+J3laltXl3s1du7qtEpzI7lV/cakb6MfZc/zrZTe3LL8yg79xzK7LdoUK9wG/MlCvrfguhrNuricKHn3/kMB4ZDgeGYcAHy7UedS5IzKHicKrmeaEbLrZw/FUo3hOT9ihpv4iNmncbrgVyb+nx9gxnV7rCyo0UgrN82eG/zesboHQ6v03PC8LudJXbsfWvXnly3Dj0q7l079wwgysABnYP1K32ep5i3dqeycZFEMvf77Jb8uk30aJOxQ69KzmAVMH7QOM0bgF0x0QEgRQjQeBpmvj17z/w408/o3IkazIu3UOaJ07f3DMMjpwTjw8RJXE8Hpnnudk9nBsIo5AdXC65FMNxHI4D777NuIswzZmYEh9/OvP5w7muROMgU1QYHU608AWeebY0HZdpxj0+4Z2YwTsE5mg2NyemRQw6X8HuokZ43Z6suUiDxZwSKVqiPnHGl+2pjJo9giU/njqs7kI5d955ZlW+/vYXhPFAwhIgWgLhDOrLHmW2KWu2rarQUldo6xZSfWnedZ43m9KMx7080vd5W+X8fFuks9t4ru8n55qH7HWI+6ptJJZK22s/1u/rXvV6SSGemTWS5icuPhCGkTEM+OPBOFIxxZAJ/q5l06wDrAxpE9Hqe3eQ9W1dWUEk3VdV3HtONOs667Qlt1JKdP7IZbzlpWWP1/fn8kyP2MWtzdaV660ExFE2qBpvb8LB4rHUva1xcNr3vZGAtu21xq/qvXDruV59040ILZzY7X5MvRB8YBxHHueHjgOzH957cpduIRevHuhlHIMvG0vHlami3uGGgely4Xc/fuDf/vXf8Zgy0ScG8a3MJqMZbKvaA8zb5fHpaVFXiJBiJk0JTRY5HYZAzAl8Yjx6DoMwR+ESFeVEzJnzeSLHoo46BO6PAyFo2SfBSeB0PJQcTCZd56w8TRNJAzkLOUPKkcdp5v144Ol8JqbUebdRONqX97ImY+ziAQuDVozGOTVscWU/2Fw3SV+Zi0RV6zfgBsbDyPH+PeFwBO9RrO9QmFktThjPg2HhswuxqY4FWyS6Z2hevbj7rldBXdkY2SZjWfexvf5S6wnIloffkzbq794Ws9IYvKl1VKG8p+KdpvCVl+0c8Aai4ArwZImQZnKayT4w5IgPAfEB9ZY6d1Eb1cNw3V6FxLfPsCCk5yj3lsov17ewUz2qFrS7PHv10sZl2VieIz7rzVVtWebb3knt6xkCJq0nayuRtoOBynRXBPclAF1XYKV/fsM76ihbBbct8czZPGeCBZo96Gf2/Nft0coxLWqsZXx9b11zwqTw+eGJ3//hR/767/+Rv/317zgnBZcIBSmpCH4obp+FMIgDcZ4411w9WupMW/EZyYnDOCLeWMoh+BL3kRCJOK+4EDjPM4jD5cDgDoxH4f7kUczonVOtjKZ476BEPqeYmM8z03S2WaoVwXFeCXf3jAerI71lD673aGdpeiGhWzsbT+oCCtdnatfY3KE62yGH4MB5vv3+VwyHE+ICplqqTFDHYrSzU50H1nBSVbEVJpa0F9ec+2redVQiLaVLVUG+SINW6/ey19FrW8+0XX23IQytr+shdd+8bix7mpGl3xcfB95AFILmos80qp9z5DIJaZ7xYcCFATeODMPB8qN34tMauXUunN1E9riAZ/WFVxNeb+Quh7uz2ZXzbZzowk4tfy8jvwZKWWa4J0m0eyr8bw6p9N3089bF62ZNDOr6LH3WwLBtio2XvBu267gQyW76m/esvTB2plpEwr31z9pVAmvcizRCknOtJiUriVK18vRtdt177Z2XnPndxyd+/cMP/P1vfsvf/fq3/Ob3H5gz+KxFfeTI6vDBW9R2VXNVRsYF6zcnUjYVVkzgc3E1LnPwbiRJIuuESGYIDj9Y7iR/8gzuwHE4MoyOYbS0GZeLIzKjKaE5FdWYINmytEo019WczWtpGIQxBO7v77k7Hc04v7Nnm9W/eaWxMgX5x2kix1QkDm11KhpR7NRHa8KwMEROBRFPGEZ+8as/x4cDiKe6QriWTWCRNOowpGlHix2ok9x7D6Q9Pf7u+a+v25MiOhj8Mi58v92SXKq0/ZqenmMs28fNLYudaO2ws/1+i8P+5ESBmrC3VihzxUlxnpinGatrOHJ2Fw539wzB432pP6upMAWVU+6m0EHtc6LieuE3k77VtFuNDZKp0kH/uUZrNymnjLd5v5QDVb1DFi62EpYNo9ZxzFXNtQBBJ3Ho5sqGgAiUOIB1SHzlw2R19GXVb3/vak2uVu/WmlY1hWJZTtfvqP04aNk2XfG975vzHl/0yZ8/fy6647w65E6KOF9Sn6/HZS0XO1L1bpqmCz9/+Mj/9h9/zX//r/8tf/NPP/DhPJNwHMKIC4N5MJXIWi0Vz9SVwjyqxJhQLgz+yBxnnHik1FYwp4FgjFDJfaSYGUp1QLBayekyM6pH3EAIMA4zp7sDMSeCGxDxxBDI8dy2xzuPCwEfAprOfPyQePw84bxwdzfwzTdHvn7/nuk8W/R3gTXdrMmLTYskWeA350yc5laPeS0hLDE+dPcv56TAXbkl+MD7+684vr9H3GB5qerei+JqCVxh8dRZOBe28CaFKRARhmFgmqar2KPb89x8/0okWMfbAih3vttKUc8Poz8fy997dtLd58v+rgoRbd5diewVvil9FtHp+gWvaK93SW31bksvNZ+WpGIUzRAny9P+6RPTcEKGQ5EiipsaxX9fSuH3XoaQksenwmNdSEz1/pz4WO/vDdK76Rh6aGZBvDXro6onkwm1alQNFEI7v4AFeQq6JPYr0H51X+G+jKzU0XWtVqbqvlm0gF2QFiCaSl+sxiSaur4rnyZNZSU4vCycXt9aYoK6CTnagjduvj/JsfvcX3eIOoIzg+pxDBwk0Bfc1WSplEWNf7CVzjhxLVYtpozFOxfPjo4I2rOZURXU8eEy8+//7h/4N//+P/E//4ff8I+/+x3nnBEPwsCAs+JkHgaUgHIInrvTgYAjXyKzRAt2E0XEM6eJVFzXBAhZGYMjC5xrHiAZQBUnZsNQlExsy5fSDAS8C8TkmZMSHFymC5fLhZwSw2FAYsYFj2RFUsLJkePhgeMYLO9RcIRBOJ48x8OIYyTHWnFtBre4SLc1roi787gpmckM0UhCshLPZ2Kc0BwtInzlV1lkAa1Q50oF3IUcuZK+O3nhcH/iu7/8K+AekWTpxyVQI7o0D/jscLl6t5nU51RBhZxAvFjkduleKsFmbjFM1Va3Oj8rXfBqIQzOtM3mVa2pPrt22765XvddTYSJLrv376UD3+LwrYn8ahzSP1ClsnpzSXAonRv/K9sbJIU1mb/ZhUJE0XlGYwZ3JoyjiYPhQAie0PLpGGC0o1/UBwvio3CNaxGybrXITlKwZ0Z3+85lPA3RbverSmIdMd6+9xbx703At9ZtB3RWn9cqqu3YXtrwtdh96/42x/6s7YjHNZldTfQHtIhn5xzzPDPLvBqnc4LTEpTkPdN0WXlYiUiRFDoDaqkjXAZCypmHOfLDzx/47//v/4a/+U+/5Yefn/jwNHPRSA4l3UJhXkJJwXI4HECt3KSIuSyrxDK3Ej3sM8EHQvF+yTmTNFvRHszGkFMmZuPYY57w3pd6z936es8weobgSTnixVJro7kZ0TWZV0x2Hggl9Yfj/fv3hXAUqUCEmOF0947DOOCkJCLUG0xP3UeK5NbfI9qMzTFGYjI38oVpv7YhVEmh7X1hkPrCT8F5Dsdjsweszu4OnDVOV+rO1/O8lrSd27Ep6AJny7ye4YZ3EPzVWm1sGm9tIkvE+FueeZHJXWk19iWW8oLygHZcrpZUKW6ltnvt/L6oyM568DagXk9sHGlNqibkSPHBVnJ0RG9ubM57c11DCjdSlTBdVaitGokFBm4itxe+32/Pec68LPLdfOsX6jA3GqBV/1v95V6fbzGWrea27rQd8p6s2V5gaSm8K0nPnj8cxulZBlYRCGORUQQq0bII4I5nVW265senM7//6QN//9vf8r/83a/5d//hH/jwdOEyJ+YM2eUu507Rh5M5DGOZW03M5o0wFOxa+8oxkWJEhtH6zhbBXAGxRag25yRf9PCLysF7X9KmFL24eGLMTeoZhkAqnkzVE0fKu70fGEqai4gRK83K4XDPeDjighmsjX65Gg55e717ZNrIhJ2wqkbaGpivjMo941m/NxAozImUz8+cncK132SGduF3DcNvMfZu7Q631D4vOWPs9Xllg6vPuoUwLfr+Na3am/8t2+h2P567/3YzTUf/yGsff1NCvK2+v3a+1puVqyVyUxCLnRLjtFI0MbBWlxJfRE3nyNUbxTWogwqgrV8AXSL8NhS3Gkr3kOKXIOi9Ob+WQPwpjVpf0tdrgOiWoQyt3NtCGBbPr/psCfmT9fpLzy22l1peI+8NWEOo+Y0qsumM3O0azW3y9z9+4K//4df8z//hb/mf/uY/8emSWo6kLBVZreM+RDLDEBAxePM+UBmnVAiadVm8jVIklvoIDnDiSSlaptiF56EaQqs3p2yvq5JSZjh4pmkuRXUc43go0opFxDtXVaiLzWPxurGF/urr7zic7nG+VK3LslJG7ra2fzv7Talq94JepZcUCufXvcH6sFdoU7mth2AUb08d83JbjM17NsY2vmfaW7j3W0zUc33sqYd2n3sTIr/d9+sJgqx+S2G2X61D481ZUq3t6s/a56rmMIShGFtmdQZKVLFKKU4O0Tkr0h4CEgYrmAJNZtD6Dq391n5uB2Q9z0M9N7H66yU1S4ch/jO3l0TeW8+8ZQ22BMEkMlmCsCt3KyWSW5UgztSEKeERwhCW5G6VkHcDGIZAcN64FwFNmBqxHPyUEynlhYvFVCU5Z37+6Uf++u9/zb/7u1/z73/zez4mRX2AWFK5O5NErS61wYoTe38oXjw+mHoqxsgZS4MSfGd38Z6hoDnnPF4cOVnsjXO+JMFLC8LGEXzJodR56HjvmeOFlGar3ZwzMSYOJejT1jtbUj5dJCc7DxYIJ0JxQYW//Mt/yfuvvmEcxyKFFLWpPhOUVdraOFuRTUK1JN3r9nxbR0C1EEoWpqxvVfWTUmaeZk7Lw+Z63PVqHl6L5FJLbNLd18NfPYHDMKzVO53qaH0GCuF6gdvfkwYq8bn1zLOtI5Z7yLxPgvmWc7x3Hq/7ZcWMr99rXzatX7v4url9EVFYja+KepvrtZBOAzZvJAKtHFF5PidiykjMECjZKxMH783g6wScX3RsNTy9lGM0SaUSom5cO9z8l6qA9ifO67Hu/4/ay/Gj160ShIX42nqnVFMVFG4YQ6aWPUSLK+VicOtN7rWloqd3WN0D4x/SIiVARxQMbeWc+fjjH/iH3/6Bf/jDB/7weCb5EebE0UJnSWLcc9SEJmVwjkNwjEfHMHhyjuRi4hjEWSyNKjFmfPBWBwLhEA6rvFXOOTzC4+VC1loAZ6k5rGKRu01tJMLDwyPTdMZ54f5+4ng8LtKt5iY1vLs7Ic0vM68OcE6ZOWdOdweOd1+Ts5ZMscUHgCq1bQCw0x/3e1ftcNpdr4xDVdHV61skk28gkooPs1rN64rMK/KvkkJfYaGXSnPOrWBMe2FDoJY3KqXEMAwtAhywWJEbrY7/VZ5KLDWgK7HeK3b/Wmn7/z9bRz1Wv59vryYKxqF0/dQPtahXz8KL0NIEuR5pK5CocYQrX50USfnMIIZ45hIMF3wg+zvEWy3dYTBPpoeHB1xY+mxUufhxVYBvRMCBy3TeQmVeSsu/UwZlWVm7AyalUIFNU8pMCpdT/NdbP8UTyNaqyDrPZEx8C5FaGd1Y55xvyFgMyRinX2WtJkzW1d7voL6jEoYqrRVVEsV3Pys4b5y/KmgG5yJowOVU3BLXfTjNOK0ePCXfUck6ap4yphDRPOLTBXRm1sSvf/7M/+1//Q3/03/6HX/49ICqY8jRUjOcQpuL4s1O4BPqLZ2FqAWIxRjRHAnOw+HIYTgxxwujD3gxb5rBObKLjUApQkQ5T4/M8+Ijj2IVCL3DxYjmiZRsDMMwWHI9f8K7Ae8CD4+fEQaOhzu890z5iWmaOATHEEpMbUrMYcT5zCgDmgbGcOBXv/oL3n33FX4IjZAlUZLP5oR0o1XE2KtcbInNyy7maIkp5dp20D/fo0jt/oMdMxEhiGvG9qryWjRMdk4s7U1JfeM6otHBrtmUqv9ciWVyggu+xSzsqVSaeomi7Oyu3VLB1L56Q3Ydb+0n3kizsX1vHWsdg3HoNaHjvjZl+85XMat7R3bnms3HNTWlMWxq+/KnlhRk82G9MHQIk0YYFkJRn7MPlRvdViRzSgkyAm/6IQNOHZGUIUdSru6tBRGWsqAN9WXXLU75rzbwPhisAUL5abcsZGq1RVebJm06/eWqf2+2lLoU27XcAMCeTr+K59tn9gxPC1D3z9S5LgD/Ks6nU5Kv7pUlsExKSmjxg6WNrnshWOBi+bufeE5GkV3lFMvBXJCCvTNIAlHOc+SHjx/5f/ybf8f/8je/5seHR6YUy7oXwqJLXp45pwJGrnGp4hwxWs6jYRgZStzMeXoia7JSmICTTBbHoIei/sD2UBSkjpGlZGbKkAwh5qxF7SWE4PHeE5x5Jc1zZBgG4mwH03nBhcDl4YE4XTgdDwwhGPF2FuUcfCgqq8AhHDiNB1y3kPVov5aV6B00oNSC6OMOqtRz9b+XLdZ9m1eYs2y2rahRHy+zGkDpo/u7jGsPl1DmJk5IKiXPWjBvqTd6+ey1/sz0RGD7/9l2i7dqXHPHdN44t28hDLc8zSrOUlhysNXvstCXoXmLVuOPVh+1QWwQlAHPcq1xm6uVLJxsAZw+647mTKJWGZqM20mCiyauezEPDCfmI79Uuthgal1/rJzvlU5yM7br+dwA+tUaVGDTbijXz7zlUD/f3x4gXaONSgRfY6Tb3rPS6dqFJi21AyDLztV939oUTMsnRWWy5KKpCKg+64jMOfLz5wf+5h/+kf/lr/+WH37+zKS5cGTWb+XEGgJTe7qfL84zxblIuQYjMSXOlxklM8fEOHhCEGM45qGkuVac7yvZLWvTIxJxUjJvuhLMBkiBT2+Ku2EYyCmStQTJOUVxzDHiZrNZBOcYVJnnbDEnWRAvDOORIYQ1PK92doMIhH4X1mucLcncNE2Wnr5y9De5706C6Djhtr+FqGTd5Apb7XVVI3EF8NpJ91cwLJWntHxYYQjMcV4V53pre06n3+dG6qXueq2NeTVAuyLb9Aysmby9s3bNzN3GBns4vcetW9hYDfGGpPJS+2Ki0CP/fpLan3CuB7bluPu26KMLFKkRB9VLo4iaLNeK8x71Ai4gYsFEOG++3B08N3111jXH1W92P8arUdVxLeOVUg95C0DrN9xy0ysQv+WOngGMLfCsVUX9+rP5/acgPUtrIy5cvunH60bT1A6AiX1dCyHgMXVTVTf0Y6z1l3Oe+fT4yH/8p9/xr//ff81vfvrE1JCdGc/chvCrZpx688gpobsCqBMuZ8uaOksiOtN/z7MrMQSR+7sjd6cD8/zE4/SZlCdcEIahqHfcQmyA4kU0ls9mO1EVMxJHy4PkPXikJfMLYSAntQysORKGEwRzoZ2jQz0EhfPlCY0zwQ0cx3uOd3ctQrhNtythetVkIZhLCUy7d55nLucnnp6eClGgcfArwtxzzHXP63naZXC6SoqVGLCG1/7acxzRHoPjiiOK936J6r6B4Hbx0Oa9/edm8O7+rq2XIPrxLB8LjpLrc1wls+0ob0n5ewxYf59snjHUWD8v9c37+5xbq8VWZ/OF9gaisC+HSKOa60mv8qTXa52qyFr1NqmTWrJfLmhAkJwWnWJKqEvMyewWrgQQORcYwojo0IrNNzHtatTXs9q2qw2qfuU37qebrjY7S/d4Q+T777/u75qbeA1nYW1tw6hc9WvaTQBVX5wK6vJ2iFkBXXS0PZJZD4Il62l5NqVs65UVzZlpmvmP//g7/u2//4/8u7/9DRcCEHHBm5SikPN2Lku2y+As2V0G5jmRFC6XC5dpwnuH94E0e0vX4uDTxwufPjwhorw/We3mPtq01tDoPYyenp4sqC2ZtHG+JM5PJTBNE6dD4DCaO+vp7sDp+J4hHHHiuMTMFCc+fXrk4fGMc5737+/4S/+e4+HE5/PEnC4M/mwJ624GaF431yRTU6fWlBXn85nz4wOX86OlpM5pw/WveZS2f42/sw+5Sn+dgVhzRmNcNAGdhNDQVKYxCcJtrrVndnqYrchsH1Gv2y0CoK3z63uv1Ffdc6tCP6tnry79ydpKxcXO7isL4d15/o9lBt9IFK476+skv3ow3av6DXFVjVSJhypINrdFWcpVm3HMDIGSFFeqwMWYiCGSvdW0dd43Y+sWUb62XYltLBvypjm3dzyjhupUK3L7rhuqoNvcxnIQK4gpqyoge+Ps9J72zlwTotszYhysE3MtzJKbuJ92ctjnbJXFnLPylSZ4CeosijmJkObEx+nMf/j1b/jbf/wtT0lg9ASSuScopWxrcQ11nuYppdWIKgRn6Tu8C7iQGOTI4B3jOHAcBwYRhuEdc7yQ5wkhc//+HfcHXxgUV9LBW+nNeZ5J0SSBOU4IJRePJKYUucSM94HxdCTHxOAzx2Pgq6/eM4yelBznx4nHxwsPj0+oM1XWMJ7ICo9T4re//S2//OX3HI4HPJ7T8Yh3AznNiAxXiPtW0yJJGAPrOF9mHh6eiNNkc3OuhTqXMjlop87riR8s9iGjEZWg29OIM0nGDSuVUhtLeSJrxunO+ZOXz0+FqW0a7dc8sweHe/fuqY1u3fv/zaZVxfcnaHVNXtPelBBvQSqvQLCFkaxMZbtYkV1lOip3wZ56yZqorqtgFJ21lVdMiGQgIurQOMMwkJypmaTUfhC0FX8RDBmZB8USRLV0vRhvhNzGJ/XGcmBcRbBFBLdKZ0u+pCbh0UkZqiX/0/IdZUw9e7YXJdrWpxLM0lxVSbHkPdpuhnRhpYvBruOkeu6k4v0m1RRCJtUFuAR9FWJQ+zCXS7MEyQaanXd4MaC0KOWEiKfQFEgJp4mPH878/PHC53MkeQEi3md8tnknEZIG0EzQhPbIRsxRIWHBkIcAHo+MnuM4MniPF2Ecrf9xGAj3I8GbikJQNEdzdkiRnJVpikxTNJdQtYA27wNDGBCXOI5HvjoJjw+PjKMgh4HD6Lm/G7i/uycBT08XDseRMI4c7078/OFnjkPg/X1JMIjVcM45W7Zh7/GHgfHdHd6NZjRsagqDEddx8m36Qomurcb8men8mZwuoJb3qEf2GdOCeJYMu75w6ejCnNDr8sUAQ8ntuncdZy+d40G91h5dw5tmizqv8S2r7yoDWOCy2mmeczfteRwjgLK4sF8v14oIXr2rXHspSn9zYfVRr7IX9c1GVLUk9lBLsL+5r45xo615Rk3WX6tzfE3daHizTaFn8bvh3aKguv1QudRr63y7c4WcpP/i6l5fkHGzWGlGpdTfFWeity9J2JxHvTc/exEzECEt0GaFTCvibbPtFr6B1yK+VY6oF1bXW6vtuVaRrs1lSe6x6kcWLma7Tv2b2zp2BGpFcBCQWiWre04KCanzbFKBFUza3r+8s7wSbYnSFmKk3dy2oL2WbhKKr3MX20JRx6fHmQ8PZx4vMxV9eap6aJFuFkOljdmpJRBTSiBcNgJtCN9ZAFuxOfmgkLPVUnbOvJiTeS85DySTCqYpMl0i02yHyjtHCIP15zzemScWDtIhWBiHE8bBMw4BLzXrazXGmp3BsnZnvJOC7ALOO/O0cb5kT3X4wRP8EsClLEb1fSFv4cKUTIozcb6grZCONoaqIl6tYNerZXqOX+oZ6/rQKq0X2HTSHutb7WOb5LJ9z5pw9HbK/u/qPrpnV2icfp1+VTk1X/nnWe298/UaaaQ3JPf2kqrLeJnF7w5q16T7WT8u6vQtAWiO8c+2t0o4b0yId33Yb3Gbe3q6rVW/Xuv97XfbZv22y9nbIAAzpImaH7ZaYJX3HhkGnHdkV2oj15qHIiUV62Zez8BUTxIWoO7HpFfAvgL6DTA2YHoGlr5EfK3uu3vvcZWzW43Frq0JyDL+KqlUSGj8qxZPMOd2XQcXt9V6aM0+4BpR9OSc+PHhkZ8eHnm6XKxoU3YEJ0wVIZbDYeobV1JSWPR1zHZPStnUPjEzDKZ6UEqwXMm0qQWL5FRKUqpFLofgyWKulvOUivqIldQbY8K5DD5TBaVhGEnJ3FNzzpAtWK8e2mm6mI0j2TrEXNLAiBCGER+8EYXivWQZZ2m1r7XV2S7reYsP09z+t5oJnXH6pf8956yqXWAbC6w0xqbmNeoSVWqDZONxS7DiConekoB3mog0gpBzbr9v3XuLwLyM5pexvLatuPQ39PGWtjZOQ+/u/pZ2xWQ/0/5Im8KGG5b1tQpoFenfAoY9EWjLGWvtvq5+4TYrgqrNPAoq12wivyaIOSM54rxxHXiP8yVDpXOgntW2NjXK2s+7AbBYqfj1WlyLZ1cGZXrH23XbCIdX72mqo2ef3vZ9fYAWcXU7xh3OZUMQKuHI1FiETgKQLrXCTlrnxUtFEAlkUpEQBJWBh/OZf/sf/oHfffrEjPnCS1ZyXmJanHfmbFDxjyoqmdRczsT2WxMP7sI3p69trGKGUk0KORG8JWgcgmc8HDgcBtJsasismTAE3t0PcD/w8HQutoxMzGZoVn3gMAp3d0dOpxOqtMjblB2JxOAEh2sBnFZsZ2aeZ4Zh4HA4MgyW02hOM/kx8u54Iowj/mCZhaNGBkJLBf2c/4iqLoWUE1yeLrZuHdLf3t9f2t7TE/zKsSqYR1ZekFPWHRVM/56qwtlBSntIWAqMWLPzXG0EVWpo6bSfISYru1g3pFuE6bn3PHdPFbjbt90f9ay/6FjybNtwA016WzPY2/F+aXuj+shSJu+jrT++3eKsr+6jcEp5M5J6v1P7Ul2J7FTQUNIJJ8upI0Ly3vIuFQ8m7zy1bnJNVvY8+t52Xden41Q2hK96FPRvMC7b+GXtoPclw9db2lveU0XT3UNcflZ1kBQDoPfLuq1E6tK880jJeRV8qYCWE05gTokfPz3w3/8P/yP/r7/+Wz5PF7I4K3jjB2Kt5lWEOinV1msqLYcVPopqxD9gaThimnl8PHM6jOQ8ozmRU+aruxFzZvKgwnxJfPz5M8fjQNYZyw8EOTlMKRVxDkIwjvX9e8v0k+JESonz+cz7918hIsRotopxGHEiPF0m5svEdJ6IMeK9YxjumOdaOKfAWghWo0HNM2gIB07370sxorL28sI+qjOVVc7EOdn7y1GwKn8bONwgkK3UcLXxjTMqiEkwaVwWUrWMz5KsSJESckrkmPAlQWGTKm5OxzCruS8Lzi1RyJUo9H2+RjOx93v7zO5I9tbjxfanlBv25ZDezvDc2N/a3pA6G5ZcLXttjUjaYP4EOK3nWCoyUjrXyA3yllyS79V8/OJxJS+AlpTJUcHlbLnrfTCpQRxSjY6yZIF0yBWQPcfW3zL4UN6nspcZaHldYYA372lsfeO8bvV1qy23ShmJdHoIbd/fMg7WdwhCLqqn+qYUc/NqqQbHvvUcU84JnwMuC5nI4/nMb374A//2r/8axBP8SNIImolVL43lDUoIQihBY4lasCkExzTlxRYuzgrVhMAUZ9Jslca8A7kbURVSikyXmRSttnJ+mjidxpJN1TyipksmDFKqcjl8EI6HgaQzx8MJVIgp8eHDB47Hk3H/o0mdMc4WsNZJTqmon+IcyTmhOnI6nTidjtwfRpxmTqcjX72/5/vvvu1SP/AszLV11hKkdjmTYywqnH2EWfclV6TXsqeaM0ROmbxxIbZxZEo2GksTwjqp3HbnoVTlywmnNUZFSvqFdGVoZvUmWdkUql3h6s6N6qj+j2m+qdZ+re2gMjpbb6bnzl7DWfJ6FFijw5+TfsonYM1cbueylL19e3ujTWH9Zy1mslL0ZC2pr+XqsYZUOwbB9QhIAXet+2oly9vlUgzHVXXMRlvRIzpM2QEl+pCFQdGihkCLJ4Q4SEYscFaS0dxhK4vaP18nsTWI1x+dXl61+7wlYWWzNbfnqJJhr94pB8mkJF3urURRwbyw9slN1aFLIaRN+uyG7rpB9sSvrr3UdZY6h5IWr8yp6ptLiZerd5ukVuoNaCKSyDESzxPnT5/5ab6QnaWD8LmYyXUxiKZc6iuUe6w2QpEEBYIoGQteTJrRLMRotoGczCtqGKzMps/mbmqMhic4wTshZ0/KSkzKHBPzlHAuEcS8bLzmYjNxDc6dCsMQiPOMDx7Um5SqlkMnRrvfOTWffmAYHWEIDONAGAMBI6reeY6HE+/efcX9/Ve0CPAeFnrgWG2yEc4YJ6bpjJZ0dtnRXFWbDqjBYtk7Sg1ty4pkf1dEL5QAz7LXoijeAkfDiAuHBnvL68tZqfBGTa5XIKcEvVwxW20uxrDY0TCC7Or/Te3m/vca5g0XaXo7t7wneVzdU3679ZLa/4b+qufhBkc8M6RrYrUT99OQxDOt6dwrDnn+9tq+KKK5dSBidRMaV2u9OlwBrCq2woKFoGKaqkpZOKBeRl3QXkVI22fLYCpu7ibdLVbBZOYF0edsLLyyKpIFNKFkcErKiopVCBMfrOyic9RCY62/+raeg2sbsSDxtYi3GT/1Ge2ekeWe8m6twg/FvXTdKS/v+Jr7r6Lnwnysoi/Wa1SvdF2Kqu19ebOrjECzG6zH48ozlUCKJOYcrYbBeWJ6fOLslERsdMXL4gqclMbRes2WWlo8jkRNIz04mMUIwpyEGDHvoUvEe8EPHheETOYSI5enCRCGEMyO4B1TtIC0KSYuk+VN8pJ4d/D4waFJ0ZSYE6gvkaPA3d0dD58/W0bWHMjFjjVNM3NMZBWTNMwVjjAcGA6jEQZneYTmy4Xx7p5xPHI63TMcTruKg4UwbHlyS64X48Qcp5qrccl0mruX1b1Qk8Kqp1DWXIhDJQQdRBQi4ijlfvyADEf8cKDWsig8VpO0kZo8r0dsxdC/o8JqAFaZmAZ9UoJUlwR5W254OS+L1a5Xk+1JCXsqptWavkV1VJi3ysQ4Ksq79qTcdLLMe6ctaiK3/aJjVDdqamhrsTCVr2tvLrKzFiPLpm1wsDYw7Lj4isN1PfW2sWJ8fU3sVBFoBbJ6rf+/5+JWm6s1Yp9ZDBtHjZKMJbAHVK02rGjC5UTQgDpwKsXDRkxWUcG8AWxzlhT3XTxB6UnaLl0f5jryW0qllcGsUaTtO/auLTSq1reoALorWnY0u13a4cSq4dFw0wIPluyuzGe7Nyt9tSAedMrMc+Jhmvn95weeHs9cLrEgM6vRIFjlvt6ldQilFKhIkTrMu8iJB0o2TjFvJOJMZub+dOI4BoKz/j9+/szDw8Q0ZVIunDsQglVLu8yZOWWct/6m6PjqDt4Hx+gcT58/MoyBw3jgMIxGWO7uinpMOU8TMSViTMUjyaRRESvVeTpaQJ2oonEmDiMuJcIwtNoLjWmiOfvSRLc9OAHSPJOaBFRgpnofVRPJaj9KedKUmwpJ88LZ76GprJTypY5xGAkhUBGWqUcXF+2GospBrq6s6tSyEWdpNTVWMNYxOk2FljPOL/B400ml4iTnIL0cZ/CSfeGmt5Muv5tyok16OUzPMfSiNXQQ+o1dn88bZ9sG3+5fzaNTMesKp77cXp8lVeDaprBZrJ4L6Te4iVKb23WhYqqQS86Y7T3GVLzepQr+OJ2aqZNMcpBkHK2Lk0XQepMghvGAKwZPBTt4SDFyF8pcK4JhRtFerXW1GlfKxy8ce326l8pufvdlvVWBaKvDXbVNtyLSuLucM1NOSILLrPzw6ZH/9T/92swDWl0OtcSUWOyAJ6ANXLv+FLTmIOp0vqoQs1375v0d94fA4O2BKcNPH8/M0aIg8ELMmQGQKZGS4ZIMxAw6j/wYI58eZ97fzfz593f82Z99R81/I8A0TQ15pZw5zzOfHx9BHVM0LhdVUjwz3n2NKpyniKjFYUxROQ4gHk73R77+5mu8G3ASyMTCKwuqt3cqa2a+TKQ54hGSGtJpNqgNp7w1Kq+54hKNzMKfrvhZFYIr8Rg7kbINEalQA++qNFKff00t+S2MqSohhOZ9tOX+ezh0mENJr6LaY1b2+nytk0ef4muLxq+vXrc1Bt3BC69sbX7lc92z3sX4T04U9ri//buWD1t3rIrgd58RA6CsuRl22rOyntCfyitHRJpdBEAqIVlR33KPg+wUkpS8+0IoBjLnHN5ZDV2THHxhjpqIg7aU3rsj2V2VHvF+yZyXNVzPuf/dPr/w6j0je07ZXEQ396kq6vclBSicn2QOfuT3T5/5px9+5u9/9wcGP3CR2HKdmlRmHjmVHbOo6YXgS0EyV5Alghfl7jgyDp6smSlmcsp8vlyYJi1pMjAO3jsOLnE4HhjHAyKeOUU+fvxkrqYpM2X49HAhkNAYef/unsNhxHlPGAbLfOoc8xzJCvf39+BG9OHMdDHvpzEE4owRiykxTTPTHBF34S/+/B1JwIfA8WBFeLSI2VXCNuQIi8qxLrC5xE7TmThPaMrNcNxH9l7tk+7EJ5giiZ5Fq2fXjkKNE5FWa6TWV1gzuAWudiqsLXC0j1NuSbIrg/Yt9VM5w1vj82vVQHsE5NazJYXWwsxrdYTRFS68Yvw77cfy7tef78WRZ40XFwK/JfLPa0369gbvo6rLXiOG/ZtZzW9l/ed28EUDUmoGynLcuwk+hxi/hFD0Ch0hUwvjUNQ/lnTTgpksvYOza7H4yguoONTlotLQRSroJCTdAsaN+S/z6P/XkX45J/H87OG5964JSdnDMrTXEquU08qfXSUj6pkuMw/nM+eUcS5YvAF1+TOuPNtqclclykaVuToA5aAGB8eDR5ySczIDclQuc1wRfydWoe4X7w/c3d+hClNMiEa+fT8yXRJzdk0if5oynx4ip5NyKvrtqcsZZAZ3EBxPTxPzlFAVi1b25oXz048febxEpqgkFQ6cubtXvv/uqwJDFgxY11rtBxU2945fjPMqXsOkmOtYhL3f2eqslrFr2+e6vn2rknufIjyrWg2UrkndyFr0VMTUU06pWSNfE5G7bVrfW/6/dCq2NoVX2whearJ8kPZeZXP1+rkNs7f6gr3rL/VPe6ZpVrJ+8TzfaFOAxlXvjWrT2rerwVWksqduMIDWnLGEa/Ut6wm+SPV1+6e2ZHv2PI041Rz9yzHTzZNa9LkOVzkipFSmqlJMAXI8Nd9YLcIOmJdUA4Iba9TNrScERkzWwGwM2H4QXA+I0u1SM7AX6lT1zfX2/mjt7WobV+l7pTutWTDl2sbUVjJrIwr18Mwx8fl84dP5TBI1B4VsY3JtzkLKiki26GURcNLp6CvH6Oi1swil/rGphlLMpKTM5X/ZfYITxtFxdxr49uuRIXimOZJzRF1m9I7BmXrHmG8HOXKZE/M8M8cBih1B1dxN52TBdANwfjwbwgwB7x1RLYDt4+MT5ykzJSHhiEz8/AFSAu8HhnAwTrxBYT0icgXfteV5tsI3YIRFekSldaPbvrfvNuqjyuys+ukZnLLeFvwZqPJaJc7rtBZrtL+AXE1Tsg4Oe57BkPbPibSKiVcFZprEc80tf0n7kuctnU0ZxcJ/2Hf0TOKy0D1+bffeWI9eVdSPU8t7+qwC/9nUR9qgpOquelGgDLT/c000F87MZOCrhRaxdAVaCINkBX9LplhsBjcXrY276FS9b6YwUMvJr2YcbQhPV5CPSkYlYrUdfTdu4zzVCb66zdUDFT3qDIm1d1fDqlYiUg+Auxpzc5vtXDq1cX65HYp62PqDVJ+UCoVN3VPHUe6vKFFLFZkmAS5Uc1/NVPesvqsQCGdpGASxcov1+mZ/KyHSnPEJPk8zv3/4zO8/fyapchxKNlwRS2EhjgTMWRicEsQ1JDRPiZStbrQ4y4brfKBmQEKE7D1Pc26pJ3LpOyVHJjF6uDt5vv36wJ99/55BE49PE0jmMDoG7/n8+EQII5oTPoM6x3A4MM8Xni5nfICjHlEcWYXz+cwUZytZOniIM+MhEE5CQvj4Ufj09AjiORwCPmUuU2RW+PyQIZ84HX7B3f13JCnpWLSeN4MXn6PFiWzXeJ6Kqs2S1YnLRfrtiEJJgSE1qk0zHmXGqsNlLU5KWmGpHqSlr+QcwQWcG0qGVJAOlVQ2qsZ2OMspQ7MpiHSEZ00QrnT+TSCorp1YSpJKiCoBqvd3CLDFX3TX63cvMZlvQaTtVJQzVupClquu8LrVmaRcK1O3frZWm9e1hpHXouCKAv1ntils24Ig9vRbVQRd/tyfcG8gqWJ/eypru9ADTf38FnWR2X87CNog5DKVbl8q1rOLuZTWElf904E4gy+5+UXsnSliuMqVFMkCWay4vOtSTwPmBls3q0O4XB946n2rJX4dEO2r3gpSaH1+Wcste+iGgGyGpnQ6bCw/1eP5iZ9+/sDPP38k65LNkZrDqMpDqVT4cuC9I2dZMwVln3KcDXUWlQ4aOT9cmGcbjHNCCMJY4hm+ub/ju2/f8d23d9zdBR4+fMSJIwylhkGCpBYEeRwHUlLO54k5Xri7O/DNV+85Hg+Ic6RonLmlw7DPMc7cvbvj8O6Oy3zh48cnfvjxAiiji3z1/h3j4Ihx4vefHnh3Gvn+u+/4+tuvGY5hSfvewWRVwO61GGMz5FeO3w7QYpTdVhnLmpsqVAqHmYUWYNlDZdvbkmzOD8GK3vtQONNewi3q1OoXK+0bUo6IC9A4W72JuHqp41Xg3kki5YXsPXhlU2PxMnqrGnorVO3f8zyD+9y4bjXd3PenUov9keU4X4+UYD34a/WR4qrI1d2nqQYqyS4x6A1g9foVuje8zK1s4qvxSA/aGwQt1QWy/inGmVFcJDUVDhdUMzkpLjhEhRgnnBhHK34hELmpiIywSCVEO9HjxuWv1+EthKGO+bn2OsN2t/5ADZry/sCik970n9dc25xmfv/zB/7pDz/xh48PVi8hW03jVJFaWiJXxa391HOirYFggW39HL04BmAmczqElj8nhIDmyME7fvHNPadDIKeZeE4M4QDO4hRizKScGYYD3kUonHQYBuZZubs/MhwP+GEoeYAyn89WGCfOVjpSvXB3d8I7x+WceHiIzDngdcIHYXCZr04Dp+N7vvnmK766u+df/hf/iu+//yVDGFAiEKiZaw11LEh9e/76fEB7HHJ/rf9s692dpZV6qaoqOlugWBnSICWjK1psHmVIKlgusV5F0sFrrVpG198yyLXWqmMEbzKEG8p1RcgKQ7YXkXxrnd6CaPOCOl7VevVW+7lz3rbSzO53sv674cLu3rcSjS8iCuuX35AGrpSSz7+vbVDVo+5szHZh1l4o10RBKZWT6FUsrxcH9/8qy561qVlagjApXh5S7xOIkJ2QtCSgcUYkxBeOr4v+VtUlYKgRB9npf00k12O9IWH0d+0h7RtE4Pr9HUIqNQ4sjUJeCpvsjftKPM9MMXKOmUtWy0XVDu0CO8b1riO1676besL6ylosClViKVlyj6cDYRgQBF9SJaCBQxDC4Aij5zAEDsNATJF4vjDPM09PM/OciCnz7VcHxsOAE0dWzzx6TuORUNRWOGGWzBxL3QURDuPIN+/vmeYzIKRoaSMGrxzHwCiJwSvBwRgc7756x7/45/+K7777nsPxDud8ixOoUlb5dNOssLYfsEKkN+FAi/ShlISFVS25wERusFElZ4fVwpAWULkzGlYc1hqETD2q6zHe0pPfgqPe0WB5/aIN+BKG6blnnkPSe2Pdtrcwca/pe/umxpDtEP+3tD8BUbjSE6xEti3y2rMl7L+3+16vwW4XKVYuAlm5/S9qhpfmsu2kCup2IJaarooTMywvrXoulf9ii2EbVfSKrupAhZwoxMOSyFSLSq6VpAtxXGmWqJ+1+2MZIUrLbf9cUzXD+5cLm5Ur0SVfS/lmzxZRB7hIC6Ze+PjpE0+Xi5XkESHFyVInNO5y2btF/aFl/J6ksaS9sKpszaZRibVQqnZJQRLZArXEiG/SknjBeRRPShfiHIlzIqVk1dZSYrpExmHAj46A1Wh2DKtxxZSaO/XoPYfjyP39HenTxeBXrZbC6ZB5fz9y9MIhGCzlrHz17sRf/sVf8NXXXxWXWIdIsY/k1+1UBeWs2wpq2/vWnDdaPfzKOypVYGHUtnsvUnMSraXGevxbjej6o4nfhQDocn9Va93E2QgyVQAAsxBJREFUEd3nmuLiOYl3mcKG+2+jv5YSXkN8bne4vz9vUUO9VWXVur4aii6E9wsJ0JuJwnVHy47XAS3cuG4WXroNbduzYLT1VWOWG8op/ah2TOO1wUhkIQj1K9dUQHrVz9LXejxmrKUdiFqZygiRUg2r1TZhZ6jMv+TDqIRIckKcp6byBovHMA7QQbY6BJYpNeNK3iVFVknmtsS1rXxFxK+EgQY4XwaHiw6WXGoGKMMQ2hqxo0GVDkZytqRtv/3hBz5+fiiI2dm7nHYMZp9ozfqSIh34mupAq67ZMqW64vXlRKw4T86kSykyU1S3SUDV4dxACI7gB3JKTE8XzpfJiL84vAfnBy6XmWGwKPchBE7HO+YJKMgsxsQ0TYjAOA74EBhL/IIPoeTuseI7p1H55v2Bd6c75stETpGkyt3xxHff/YJ3794xjKOpPAS0WlrbOtr/5nm62tcyzY4DX/ZbN/dpsT9ox1V399fzItVrjXZOBSNwll04sHic6dIBlUGr17WL3Vzgz0wOa4lmGedGYijwf1VBrBAuV2Eo52U4lQhdrdXrEeZbJOu+vaS26XHUW9quuq1fv7qmK+bx9e2LbQrLhNfXixlxd0GkY6TbcDUVf2xWxGIByyUgRjW3VM1bg8z6mr1j4WIUy6jZD7Qb+FZN1Ym9FnRW/ugAmBxAildI67tYCdKSukMKl+pKLvjqPlfLgppnSSZrKvVuLdVGdglcLVzTA6Eg6io1QKvtQUA2KYyv7TY0QEnlcF/ZZzpgvwb6DaIXBYmIeMbDXSHIJgVkWetv114QcHk6809PEz+liSgzdzoSw3u8PllCjpJTKGfFhYA6j2puqSPCKIRhgGQBaVpyjDiNVjKzeosBs2Y85gGWM8Qn4ePjmcs4M71PpK8z796d0DCCS5ZeXZMV7hOLMfjp02c+Pj7xzTffcPrmiOhkWUSjMk8zMc4gifF4wAeroDZnwN8zTRe8S9yNwjDcMeIIAu++vofC8rw/3fNXf/FX3N/dWwp3dSgjPWNVIRlA/bXNKesZx4AXc2y4Uotk+++wQkQUqSu5YiAvdMHOnVaAsZByEVRK5ULAjwfcMKLekyTjmBANC8IvRjxJasWIUJxaSVYH+JzRmmzyRtsyQL1UsVWJCdi5U21Rxo2VLHCQN++EJdX7c/Wcb6nfbt1X31uf2drpriS1V/S1J7kIFkDarrMwXzOx47fLXJ8d/dL+SEPz0racyXPi13bi/WKtfnf6wVsbsmcYlY6QLAbkhVPcjqNa/9cV4Oo7FglCS/6gnJd7F5US7X6R5T05GyHbzrvOJhcjn2hR0WsmEQuhMQ+mlhVSBHWWnXLJNVNdV6UwTEqVoFo/9aA/A9Nv4Xy6Kya4OUoQk3kLiVhSxO2z1UieUuKcA58fL8xzRjSgCimbTt7SGvl2oAxh2bo6FxgGRXOy6mVtn0wBlwt3CLmkVvfcHY+Nk1KFPARiEsageK+kNDFPQprh8fHRVEDj2PbWe8/d3R0xRh4+f+ar96XOgcCUEuc5WvJEhePxRIyRx8fPRSUyNHWUBdBlLlHwFyEEx93xyP3dPaf7O0uCN5wsCWPj9Ha4vJvspRV+2j5XPedUi3v2JtCuVzlcb3phbKRD4JK4uz8wHkeTaLXCgl6PTWolOEcfjV40qitc8ZKb+XNtJRWxj2Nu3d/XMP5SlUvfrvBd9/NWe05wvzWmm9d3+nrLir6ZKPSU7u3dPS+2bbnWvb9fu2lrSaKMUxbgv57HGpAaYWgCOw2rVsPfNVFbSfrlXkzsZTkEVQRuuvg6JjXSo1rEajHOJ5XDYkbNzIzism+eTWbKUGrq4lrmsQ15EcDWc2RtlN9KX9vW5lk4kF6Un+eZ4+HYEPUeXPRr/fPjmY9PZy7TTJwt02nKFuPh8KAWyVzHIkWVpqrNy9G+q/8d4lPJtWPcbFDwg0dy6lRtgGROIXA8DARv6kARwXvH+/fvW5U136UxAQjB8vw8Pj5yd3dHyiWjbsmAKs6K6rTo6TkZQizMSK0IKJp5enzkcj6j337D99//Gb/8y3+OG4ZW5Mm4vM4zDcEUobc5WmNGLNW2bvZ74a+0Vc2rhKepi7aIs+2bMRtSFlycMA5HfHErvTGYQiRKkFmdFJUQAB0DU5Hy/qtu2yX7M/wSAejvqXm4tkSpv+dP2m4u0z5O66X25+bzUqt7BusyBc+1L7IprAe1YJznRJ5b73pJiti7b++9q8XrgGiF6NqPnWd2x7WH3KS/sS14TxhgPV5zM623b0LuqcQHqMFYlSpU6aAh+OJlo5ZSQJypsOo/3duHet6bdNIdftWmnrtFEK4OXPuxwIKqxR2Ik2ID2SMI0EsSv/nDz3x6mpjj4vniw4gL3jLciqCaW4lLC2QsOWUUik6tTVDLGhuCN6lCZUlNUceaVZlzJDsh+GKbEI/3Q7HjwDxNpZCLvbumcqjFl3LORXoxqTHljGTBB7fEKZTncoZY1ia4gPPZ4iCyQ3AM4cD9u/f86i/+GWEYl7VfLWPP+ffRA9tFXv5vYbsyJOt9U3rw73iHqxc3ZqMqKTppd+lh867y/hVjtbp/DWd7+GClAnoGSe4xeXv3vKTn7+9vY9iO6Y1Eo2cId7+XxeNy2/cXSy5Sztpy6l/d3pw6e/t3g+EbiPvWAr5E3ffaSsfY9Xfdx3PC2P47966/oExpUsDe2JrKpxEEQ7513FcBKwUJLp4m1XZQCI+CFk5TyRCx+A1XSmB1ZUCrkbwRiZU6jdXaaFF3VaDcO3xrIrMQuH6+qaRXWPZR1wS4SV2gmvnb3/yOh6dIzJb4zosjjEOJSamI3jFNU1HB2TrUNRUn5FQiSWQZp/03IpicL5mThRRNdWPG1URyljDPycgYBjQ7vF/7svf76NxSAWyeowWKqbMqauUZ50OhU7Z+IQzWdzpb5Luz1NzDOBBcYHAj799bMZ1ffP9LwnCgRsCitk7dwtNSkThhT2DQBSrX11dEYA9xVrha9rhBoetsF43n2pKDeh796lpVF9bUMOseK/Vy7TyYtOa58h7sn2t7fK1meo7j3o57xZjpGn6ea1cMVzfA1zz7HGHox/IS/nyxiZSKkd3a30gBvm1vSoi39LfhQr6Amr2E4Nf99VKqea+4kp2x77nWUMiqZnBybgVQe5R4i/yu5rJipRrfUuwKWzE2t0O5vJNSYGVRBah23hCrTdeCCBRLcGBBUdXTxKlYQSDxaJ5Jsy5EwQniBoLzJM1NhbLKLyOs7CrXh+Dam8uQk1qO/HJ/LWnaomOhRdI652kBA/3eeEEyxJg5n8/8h//49zxNEZFACDCAGS3TRKFoJbeRVTVDginbxHLwa6nwJyXHjxePJmk+/OqEYl7mMk1czlMp/C68u7MaACEENAlPDxeePp959/6AZC21aBaYuFwuhODxvhKIgYeHBy6z1UoARUeQSBe1bsQ2hEBOVoFNJTV93TAM3J/ecX//nsPhaH25QK1pXDe9kvW6nj0jsm03GbAKW5SCOz2ipEikDTDWZ8oIo3Vfr3vx+GFAfFdDIQtZFFfP80qkXKKdl2PcSw9FXk7m9SXe4lZceUCKrr8SjhqItqjANszIC+15Avm6Vs+wdGR4QyNWzdS12u5fnf8NDtzi1pcJQ/9Ge9YhVVxr7/M31HPb9idySX37889JELJBlHY/1ILqdvDKQhTOzD4WbqNLQFcwcdOt7aqeajcVWQtGVQV6m/0iBmfggitIx8oEWpFyD0WHWtk9qCoeG0+tTLZwX1rvaYSxDmgJXzJlw1JsBG+uNCKGbMmKMpNdMsRcguJUBPVSGPfFKFt1vZZzvxIIQKXMapE2Fi5PlnFXCUM8joyTxOCDcdBbi35ZTpKQLpl/+OH3/DiBdzODgBNPlpFUagGEwbJvOm8cpBdwzoLCEEf2WFI7sd0x5FFsLhk8zqJs/RPqAimeCcFzPB05HAbm+MAlXXi8nC15nVoSuq+nJ0KxDTgHoRwij+VcCj4whsDhAKM/8vnxI3NOBO9xU0a9LwyL6W+9RlxKkODpyVxq74/CTw+fie+Fw3DAExlE8RqQHKkEQAo0TUS2R1lVu5xd6+v9cVwxOQpeDfxithoOUghvzgvZUGHx/CpnrfL6tTl/xLsRRzB4yULFNyrFaqGpfH+BfAC8wdxgBDsGh8uKxAjBvJuiZLLLeCk5n6o80en6xZeqjoIxQt61dFfATWy0ZfiqUfl1SPd6/aHyPh0y7/qq95kkXtVtvYq7FFhKaSEqNySaZ0bS9bp8dnR1HioKqnjyFe2LDM11sLfVN+trXyICPf/MAgGmeVnrCrNiZQZFWr53br1PoYrPre+V4Lr9ri6+edtox/GoaklUVl5cN6S9YS2RXM1RTTLYptQSSurp4pmjTvGiqHhyym1qkYDPDudyy70kIuhcjExbTiG7ImKaobR2tkYu5nUlmCprXeRFC6HWZpRduC9ds0zFJ95q8w5mQygqGXEmBcxzIk6ROEfEQwgO5wyJ4EoqEYQUoxEZEUsZImbL8eIJ3iQyJzBIYBgC73/xNarGrV8uj0wXIaWatRUj7uqJT5EoUmo8q2VKRRjCBe8dh2Hg/jia/JbmAlOOGDMimWmWUoVMQNTeofDpMfLxaWKOkY+PZh85Tx/wBL66vzBdZi7zhXu9w7nQiDEFEmothRUH3/18sVWuuDOstgSBbCXxZd+XuLQM6lYMwTCMRdWzDMhYmOKSnMFlYxos821RNVf4yDM5y5LaZsvkdcDT4xnNukLoHSTenP6eoTo3VWJev3+DmLfqp2tNAoVXKhw/C27cw4979gmt+OkG0t6qcw07yJpHY/14L4m4nXE81/5kLqnPtbfo7F5qlYvOmgtfvvSxZ6RrLnDPcARVirgx+vVf5U8nC63Ryu1TnVb78S6IcgscVwC46rPn0Lu1K51ZgFWRBgoSkhIbkJOa26GrksFgrq0dh9l67E51Vdf081z6z6gWCajS5Dp+Z9XoepXZVojOhSM9z4nf/PAzcb7gS4ZT80EFJBNC0ScXHGTEpnhkaUU4ZSxa5Bhf7AHqrEZZOaROrXTmMHhyTswCoh7xgxmLc2oZXRXH3SCIH3m6TMyXmTkboktJ8SkZosPqIsTpzKyWGdU4MUXPM3oQ1DucwBwTD5fIp4fIJUZSVibAeyXPiQ/DA4/fnK3uc/Ws0h6C1sTZJsYLbUclItWQubmzcLJdD2sY7CsFdv3mnBZ15HY8a3xe/lwQrNPKdNRgzXpmdWHg6jMiV2cJtq7j6/lIP9f1wwtx1MUN9SWb556afPtMRkxttjPWvb+7VTWkXYncZpNuqehfZAV2CMxb8O6fQH0EV5Cwc99LiPnV/df3bfpav9/G8yp9oXTi1VvH0gFO9Wl/yV6x5Ta2kpcaq851DYWiz6+IonB+UtJuoCCuqG2KaqhNTATUG6fopCDiGndR5X4t/W6km/o4HRNXvtByf00tYYg/7+IuLZG/nx8v/N1vfkeOM8PxVDyqTOHkHLjRN+RnRMHqJGiuhKFyZfZO43QVV9QKrhCkqkoy21JJFa0OGRz+NJjaJKZSuN4Q+/3gccOA9xmRxIwwpwwSkJKD6TJFnJ9Il5nsQpFgLKNrjrHovwcAni6Rnx/OXKbc1AiKI2UlC0yXieky2bqlhfAtRLXKA72o0DEHuzB5fW0rZWyNpQs8dkzV6obyhoa/1QofaZecT+Q6M26dS9dd08CL0FK61z4bs2Fdup2zcsu4fAtpbpayEYVbevuthHALh6zXsBwSkavaDlf3rr8owapVpbz2BrtFhAzm9195q8+34N43GJptONcIraoUnseqtwb1moFukakW7Xo9aPWe8saCvNZR1W3T2ee2rsna61sPmFt94Eu2kz2icV0Le92MdOR2kKTMKyUFqeoku6oKkpJJDiKm3pJo5UO9B8ngTAffc/sLg6qFUNVXFo6rP8VAiokcczHmOisSv5pv4ul85vc/feBv/9PvcJW7z0pKkZQjzo34QmQoEqFUD8zCUYl4Bqc8PM1NVFdNlk5bwdcEgyqknEnJDP01/UWWhEjChwI/mglOOIQRHyI+ZMYh8P6dJ4vn6emJOY+kHInTzPQ083QWwJFiQkQJoWrAjYgkTH3y8fHC0yVabYZQ3F81EDXx1TFwGAIIzHFmipdmj6igLFJSo1R4KTvzZv5lozapn5UF31NBpvvYCyl9CyG02gu3zlJPbCrYLAzbfsuacbp2Ld/jeJ9j9lbfFSmwGv61+/4lo+6WKNwiRtX+ArUs5z6O2+KFup8WVdLuLFPel4Cu51om2fVTv9Du2h4z+lx7E1FYu8i1oTz73FsGc6tf0JYRs3oUGUpaJ9IqT7RC55bNsRNdbxCErYj60nh74O49Ir6s5UJU3e7G17aIxmunw8ql5Y4IlG+Wm1IEcSWbqen/8UpMEXElkEc8IYxAttrFbn2AVVlSN/X9lyIuOVtaCElmZ9GrfIGZeZr49PDIT58fCD5Y7IGYV1VMQkozScFlCyRzXlogWTU9Zk3McSJjabSFaAwAwgBkN5A0oWR88EQSEpU0zzw9RD5/nkk+EkR4f3/idBgJLuDVgyrBDYzOom9TmjgcAzErKgfS8cjTIfLp4YlkU8KJSWypiDEpRRAlZrhE5Xgc+cvvv+FuhMFD8IHs4TAcuT+e+P6bbxgGxzzPxBgLLPkvOjdSJKz6WI/UipCxvp/bEvJzPd/fv+d4GM2bZbvPUk5m6zvTcRRtEBsBonW6QsYdE3I1z+7zLVtAudCuv3Y99+7r39+rniydynpse+OxORcDvuy8V9f79SVtxbDvfPefyaawRnxVatprPfe8N6A9Ln777MLdu9L74sO9D1WVA6pfrN/TRyyuKDc7wLRpa/FyLW7+MbaSSvRMZw8ijpo4cO35U1xtd06xAB4lYvUHXJE2Fomh9FHfk2bQ4rKrUjRM2qQr8VpiJKQQHKsZsT3Yxu0Uv/JUD0oxim8c6eec+Hh+5B8/f+ScM+NhaJjHidU/EPE4Z6m3nbhWTlOJpj4qxmrVuhYJLQTNUE8m6RPeFQNoSpA80yVziYlzikyS0OQQL3x8mnk8RwbvGLzjeDfyTjOHoDgyKSqzCubMlREPR6c4d+Lnnx/RJCRRZo0khGKhxrvI8SD8s18O/Oq7rzBxZ7A1zIl3o+PdYWBwwgiWIoNnAi61/22lPkNzfe3gIGULitP1MxqTpXZXSpzFvADfVv1St3dhNTf7DRMRHRzm5lfPeAWuYidyHnMjtgA+LbnHnAvtXbmqCVVbdl/J2kqxCtfnsa5PjR9peZDafLXBVG1brr+PEarvrG1bhGj7jt6u0Yo5uXVfVZVcWL3yhf24YuhK/1kWA/pzeZjWz75MQL6EyHxRnML6Orx1cM9R7a2YBUv8AaWrivarKmghQJVIlZKOunkPr0fer1V1bcXNtxKH7e1rnfLyq3y79FnXofYvHQC2e1csSd+rrUlRKZGz+YU7h3euuSI63wP88r465l4lJwq5VP66HjfElPn0+Yk//PRTqX1QOOyUi895oUGFS8+a0bQc4pykG8KefcpgYaxIBwVfXAK9cvCBYfDcnTLnOXIYg7mSiuAwYns5T6TpzP0pcDoMhBCIMZFTwvkSkOY9cgwEfyamXHPMWR2FnHAZjofAL94f+bPv3nF3EKa5w9Le452gOYELjMPA+3fvOByO9u4r+Fgb99t27qTTrjJBQ2imL1khxS9BEgXcWpvijOCa00L9bkFU5oUkJb28iKxdaF8YQ1PzbM5vz4BVorDMdc2hXqmcd+a/ZQRXktXOGPu03StmcHOIWy60tjDlxw5uW89bV+PeG/9zDOiKiHXXX2J4t+2PJgrPteekg+3fz4mEextZRlXZ/AaQxmkv718tlHDFXfXz2xqbnrvnOQnnuWevN3arplkg6ZYYevXu8v1mtdu31+MSqtpKmoguzaXQOEhPq90s5jVPUdPQDsR6PWtA0Z6WbpozHx8e+fDxk+0R2gzTWrrJOVtt7qocrKnWleZpVd0o+7kDZmguKa9rsRhjGBIoDINnCFYD4eE8QZG6jJvDYhO82Vak/1uVFG0srkgweIcPDp0TqWpHNOMdHAbP+/uBb94feH93RNPF7F+aQRzO+WI8t70OQ+Ddu/ecjkfLjirr4Ka2ntKrBinutOt93XKh199vr61h7xaEqWLMQ7khxrQg9gIDjTiU7TPjeC99bLkfFvgqf8sCsvtIszsLvQdSjydea9Prz2L/7u33tW0JQr1n770r3f4WZ9BqU9n32zXZme/VPt7APbeIwlvbH5Xm4rm2t6hVPNqmeLi1yMvirvtvGUpZi4yVYWieN6wXVWoSup0F3VLn16qEbm3Y3rN7QChyPe+e46rrsAaEjRRQ2m0itVkHkYZw7YvK7ZR0A87SNWjSkgLZWURzV/LLalVjgXLiyFLrWLP463btcYp8fHji08NjyQJqIrK5nJrEkLM2vbr9r8jY4Xwwo3SMLWNqL7Z7b+g9NbuXITxVRecZFwJjcAxDQAj8/PNHLucLWmws4zjw7t099wfPWNRFtcC9qTzKu4ycMQweiucQasTkbhz45t2Bb98PvL8POCIxZVwWZs0osdQg8PjyPu8Cd/f3HO+OFohlAI3qwoFv7UjPNhF2DQU7cNarilbndU1dmmdqcy1NSq4MAAuCXkFnsZMtqqUeBkunfS6Lfvyl9XiiStBXXDr7BHBP43CLWbz13BYXbPHUrTO+YjA33wm13kXuv7Bfm3fstTWO2r3lqr01++yricItzv1W24p8dXBWCctZ2P8NSt7e33G/exux3QDTx2V8gAqQq/dmRd3+gvf2htcYjW9xCa9dm5fUUy9JLS+9q61/+bEmNB46lGNSCaAZLXpvi0wt+9eyykkTznIWcA4/OKo9ghxb37qxKVzmmQ+fn/jxwwNJBpDrvPjeu5JkbgmyCiEwzxHLDmqSgu2Pa4Q/pczD5yeOp7FJMKZicqjOjMGT50TykdMwchgGxvCIHIRYciLNU+bh80dGd4eXgPOUNcpczomsEy44huG0eMlICdhSZQiB9/cD706Ou7vAMAbSHDk/TXw+T2Tx+DByyMJpDI15FmcErdaPNn2ylGpyVk9DU00nolfEdgcirmDAZrEgd1jqWyhdLE/3fS9DNOmxHcZcXFI3Er4rubquonXY+btcVV2nli/uyaJLLq/nGK+mVdh8d7UGb2BoV+PbEIT++rY9dxZr/13wdZMkFmJ8fSaek3Z6Yrsa0zNS1mvanzR4bU/VsRXtbqWnvYn85JrrXD3TsSf1HakUUt8i1io+743zLaqjm2Pp7n12Tn90ux73c3eqrgmoFIzkuntafR4xX38720W8lU7a147zAFK02g/JCUMuRWG4Nub97vd/4KcPHxHv+erdV1wuH80VtQaFSbVl+FV0dM4wHIzeaAYvriBjlrGpMk+Jw9HiA2yuFhPg5EAmm3dHUjTB3XFGvh1Jai6kc5FSJGmxq0jJIiLkeeLpfGGaZ8LguX/nCMOJlGdyMhWYiBL8yBCEIViMQ9JY1mbEhYEpJh4fL3z8+IEwf8v4zXszMIvDu4HBhxJw7pvEuychPMdF5pxx2XVlTyuiNSOzaMmjV+ChVV6r93WgdBOFiDAnq11tRv9Mnwivpj4xd1op+RZ0/cZOINk6L/VC8BahGw7cT7H9HGdt41qrpOu1vWdfq7a91Z9IqR++MyRVs6dVMl/LvLSzuEMIbqvS7P9rNRuvJQyvJgq3rPINY1AXsMcg9f4+ZmA9QEu/0DEh3Ztrlr/Cs+5Pem+euhCAFeLvDNO6Aa6bqhd1hZNJBXM+s/haAspUi+eMa+OzPCl7hLB6HW3eWTHeTlc1Hk3qZ6j+kW2ONO6uekFQAq06ya1wGo1rrQdHtMy1qIwoVEIcqFBzUHlvAWv2GiHPZ0IYmOds3kfjMuYPD098mmZmHOEyk6OQkoAEvANVS1bnDgM5RlK0OgROBNFSdrOqIIorqPeWBTWawxIpgS/pFKRwndWPXFW5xAjnM18PJ7wMqCYCYpz6OKBpYhws0WHOMM+JgQP3945DGoyrDw5xmXAM+McZr4qXTJBkHH0K6GyV5wSHG4RT8ITsiMmRLp7H+Yz/qLy/f48Hjt7h/MjitV4OOxQ34gLPFZk4adLDFTw1Rqnn9Sl5jiwLb9biYFB97LdG66pSan905zplQopInNBs0n7Nl7QAbi7w5SyNhQ+bc6i4pJb51q8ZHGM2FmQtcH2GCz4UtXxgW2vaoqJaX9tjArfIf8U09gRqwULld7dmezW0i0StVyowMbjs1GmVcbslTS1E9Xpe/dj7+bQca3SeYa9UQv7xEc3aL/iG1ZDr5yqgSdFfq9OSWqUs90oXp3SXSlsvwFsoeW9o23IDeyJb02IpLK6g+xuzjK6TRjqO+rln3tSayFglm4UGrNas3sqaU+pHopvfVQzf02BL40yWJ1T7Yi6Q5smyOs+JLHH1/OenRx4vF6JmdJqsrGausSdQc+PUSl4WmyCmosKinmuklaogmvAulEprzrRJjTmh0FMDnmp8zlmZ52g1l8cBr5TnhME5YrZIuVRSmOec8ZiHkA9SEv1ZJ96bROOlBhIqKcF5sjlZaQxvUdbOcwie4xDI4wh5bp5wTizxXs9tXy9+x2tXCv7czbXpVmKgeX5VoqOylqRvvKlDjkBOXM5nUnVtbXDTOu7+V0LVSeJroWT3HO9x9HVONSCtuYQWHFEl4jqGKz6r6+c5iaGdh9Jf/yLtv93hvCv+UCwuSvv3tt/X9oTlz81Yuvlot6a31GoLnv3ymIc/gfpoO/jSKidbTui6bKW0ykftunbLvdqkGuHb93d9KFb932bkTR/c6TBvqY0WQ47xZ/axTErXx+fKOEXnqyxrFKsFyPaGuOJaZAGAZ+e6uf7cnFb3wsIpbu41urMYtJZ3ViJdJI2qi8Y4onmeUYR5jiS3til8fnjk4elMTJYDKGosAYlWkcx7QbyYETMb8nXOMt76kgjJomgXaUFE8SLkEkNlnN1CGZRrV8icIpfpwngczWNJLfAuRiVGk4JqOm6bcTJ1iJ1ucwV1xSPKWRBgzlKC1UBzJEZlHhXnIk6FMAbu3InxMCDBc/R3kBODhNVebVMk7PCE1OjcvVYRLoWAV+kgd2dUi7dXQ1Yr4Ow6bdIGHVK3tcxZeXx84N08cVcfXeHOJcjytlZ4QZjXRKEbb8H2W5iuTE5fCnd9LnRfAu/v2BLN7fey/7yB2UJAtgSuvWvDwa+1LHsEqjI9hQCshlTXNLEHGavxd1L1l7QvLse5vbYd3N5iGhIxT42UUgmXN6qZcjKXv+Kh1IrU/Gdot2wf1eax6B97YJMmLewBwoJ46i+9Avjt50p4rqdZ3TFfP5/KKV2NZ6etCJVcE4Y6pivdZj/B1o/9nYuBf7pcTHLdwMiHhwc+nZ+YM7iYzK3T1zrMtl4pRebJvI+8dwTnCb5EGo8DOWXiPJsWyw9lLNk4eE0IpkXrzRnjOLax5pTNHnH0pJSZponzeWKeoqWqyA4nCXEJF+AwDKScOU8zqjMIuGB5kNIciWk2qcJBzJYN9SDKPCjnS7JAtfsD70MwY70a9ygKwXkjaDlyuTyRc6bkV+1WeCeDgLj96xSbQifNRC25oXSNNG69oQohzXtvj/ko4DBNU6mKZ0lnRDZv1BpLABXRXeOJ5e+cc8kwy+qeW2qflBJ92VSTWhfnlVt4qF+HrSp8rc3oplwYvb7tmdLXnDrNGL/Y1xYZ/ZqI9ZJKVcnWOfRS/LJGwvU77LGO6fwCFPonc0l9yTCzVV3UZiULM7nkjNlmQPwSwqB0Mc03RNPnbArmLmkeLqo10d0SsQvXBSuqBHB1rY3pDeO/ftXqff1XS5qPNRF5cT/Kjz1JYdtnU6kVqc15q4hm3xd1QMaimoHHxyee3NO6v8OIP2WGBD4ukZvrcVqFM8HsSc6BkPFewSWLlJZIKHYITB+COkX64Lai3/a6cJNVMk0oU5w5TxPznHh8mvj8+QkE7o8D9+9OjOORIViU8afPT4BFYPtg+ZUEOJ1OfKue8Hjm4eliwX8x4g4HDkF4dxLG4x13dydSIUZGFKw6wWU68+54z/3hwFf394C09Af1pKjWlC5pUf8VBvL2ft3ivjuk9QpgvOZTiuSqJQ0H1REgQeNeNwzDy91cja8xY/WaW0vVW85+zxawpya6YmaFUj522/fLi7NHDPrf9tl+bCWE5z0bG1fXeqkE7zWbtsz1VbffbG9XHylFjCkcYgs2Wga2B7A9QIO2Q9qCQpxDOze3yklkXWxRz3HAW0PWm6Z0ExC2ALiIpNucS5XIaM4NozdkWvd4lzD2hiD7duEirsf1HOfT374F8Cvxu7v91jtXB6tAWk010d9bx+pSYk7rOJTa5nlmThktqhhDbPZsVnCqptLJjpxMWhh8QPUCKNNlLrBg62OJ9yB4RxDP5BPVxqG5GsxlfSCl2CtUSXlmGI/cvfM4P+LEM44ZNDLNE09Pyvkxgnre3QlxnonRUlJkEXLyjMFzGkP5LuHF4Z3nMCqnExxPgfP0xNPTxGU8cAd8PVoSvME50jyR0my5qCqu6NNVA22xXtiztk/PIbUtkyL7t29G0LiUAgEgydSAMRVYkHZbe/4lZm6DzOvZNgK+fOcValbEeoS20cxbxPsa5N4cMpyY5NeGdYOQQlMn7RGp7ef1VPsnhN65ZE1QZLmnu77FBbeknf5ef7WJr29viFPoRJs2KC3cpqz6b/owO/kNmHvPmGpsSS2Hv67ENKlKXdlzIS1vuyKJ3aKyfea63eamu34U0NTEYOm/vSJS1bd/+b4h1C9Sha3F21tqunZPu9WAahE5u687MUSb69IO4Pb4pe5xB5y994T5lmem6czlHJmjku42uY8S5Nmq2cXkiSnS75GooBFqltc6HCfBCK2aXcc5hxcIwW5wBbs5sXoKKXfuqmV8FlRXYbW6Zzq8CIMTcpCiexfmcyqpLcz76f7uYGJQyfFENmIjogQnHA+BpAc+f3qCEnMQBs84eLOFZLONKJmcZvI0Mw9iko1YjIU5JCTAm+qmbJZTtZxKFYM3xc8tpLfmjveQR32VU8see6UYUdqVaiht8FKgSdWKO+UY0RQLXHia6W+jkpQOvlaSp9JKbW6GcMU41Z9ZLfljLgxjKinN6ztW+c1cVQEXfFAl6rZa9bpDNK/xVoNzFnVOYSp6KUi7n9s1J6/3oY6jedG1fVpWtzEAXT12leUwan8odwhCZQxUatXGZZyvpQ9vkhT2ONg1TuwQVe42t+ooZb0wxnGnLoTcbQauRUzdZkK9lo9WcCW3JYo6vldd14r8GklbiEO7t7qpsjOmShSWEfeEpNfhL2PoOt9pqqub1pJV5TI7xN9/XlZtIfC35k2vl+2AS4pkI2CEvRAFJTJPj0znSMrecvt0LWXI0VzxonrmWCKanTNVUBbyrEiw9NEi5hTgS5lT50w15Z3Do5ZvDZAEuExASDjmVKqm6eKtkXNJy1Dnk50lV8yKB0YnTDmSU7AcehHAcTg4jkdvkkzxDqpGcF88pobBcWLg4fNjKeOpBB/wbkCz5Qc6HAYrRCRKjhNRgiWOEwrxSYhaJls7671EKe2fSmVJbsAva7hY/UfpvYtdJfK62BeuEMcWbsoNluSuEIU4mxHHh8Y4NgBpTy/janVHqIR23SqxWBGPShdViIUY5LrHhSAsCROXSGucZaU1t+y6hgXetSBVjDnS5sSgrZRlf0pUhGV6VRtQiUoXl9PgTgpRqFh+QejV8N+xrh1eNXui69Omt/f2a9sTCS3gXZMD2rqs9lWuyP/N9kXeR1vxbI9rMXja8elXbUVZ4HZOkUYB6zO3EOHmWrm9ve81OsLtPKQm8e85ZKFJN+v8SjbKSu33JIJcOf7NPPfH3hHWZ9Z1+xywmyStvmv3+t7+bJpupmRcUvUsqdxKCd3PQhhGRD0urIlCzlae0h5Jq5QnqooLgmrAiyt5jhTVRNbM6TBA9OY5JpZ4bp4zp3HEBZt3TpnD4IyrT7kE3nnjrTURo7m0mo5WStBZZhgCh+OBYZqY48y70zvzhAJySkzTE8NwABwpJ1KK5vlEKAHeFgRomcBNghC07ZOVGxXCMDD6UsI1g5BKMsAJTXNBhAmzOhTiW/lU6fxtn2miCyd7JSUYICx72uHtXU69Y1sbklt2E1VljjPzNBUcZbEdzqmlRJEa1/Q8h9r3XY3GDVXW8XZwXSPbyUVecJUhimiOFuNSjNCXaeLrb37BOPgmsfgiztSIcU2ZFKMZhe2kbmLxa7+ymkwlVoYYMloymxpitoA+p0b8qqBihKMUXKrspoAwWHxTUU/nrMX9uRIF++3E6p+09VCQKgkX+ycF18ScFh5RFob0Ne2P9j7aQ14VcTzXKlLodYNbLwMFYkoMsnAYt/qs/ZYb3kQMrttK7GhAX6e0b9uQ1af+Ddo9u3rimXHuqY3q4b7J4e+0PS+utu6V42jLtpVgpKhyOqmjTLCputWCy5wLhDCSc+Z0f8/jnQAfWp/mry94H7jM9g7fKspYbIBoRDUgLlANmeRIGEYOp2PLxPr0+MDghENweDHVUsymovEumXeSSimwUxPumbhW01JojsZJhpH7+xMiJ373+9+S84RIiUEIio9Y3Yls617rSttcvBGFCHfHE2meCcHqTceYGEdL6VKNzFmVLK4E68E4DhyGgVB16O2npVLOzYCbGmLYwsR6XxeislIrFC61crO5jucZ3rFel7btC2EQzUiKzJcnLpenAgtVrVUC7lTZRl6s7X7X429wzpL6uqpq6toIgiOhuaj4UoI4cz6fuVwu5JxLLe6LeZ6lTJZo+zmETsotKuycyDkyp7nNd8ssVWlCCieeGgGwd7jKDKpJpab9CGijLlLgL2FlZOeWCNKiws3tuTpISFWtp2RpMWxDi4ort/cJVnJWy15WdZXhlQRObC3miSnOOP9MLEzX3pT7qC7E1Xd1g2V9dQtxPTKtSH6brGn7m5xJjYO4fs9e6/maNaG5Bkbpwxav5mVva1xx13I3pirC9UDdj9V86K+jM/tnt2Pd/r1ITrIiTstIha2j4ZbI9oMzdYJ08+zfV6Uk1+YqYhKew9R5qAWUVX9tweP8QDjkxkH2zflAZiLNM9MMknPJXBpKXYfEOAYkiwUzakLzzLv7keAET8Y7QUaPpID3pn7x1IjnDKKECnZOUCdcJmXOsXBmrqTrTuRhQF1CSHiXOJ6O3J1OdlhzQpMZrkcfmFXIYhlYQwgmiXgro1i1UqbtV7wqgzeX2mma29bkpCSUMJjRXWPk7u5knDXJAuZx65IlFRtqLT+32ImWPV9a1SIv+1kQV6dnr+qFBlcrNUTXZ4W1fjANXjKqicvTE0+fP5tjQFffYau6WoTbJaFDz5BcScmtX7czRuX89MjDw2ceHz5zOT8xXS48PnwuSDYRYyTGGVGLnWneZ8V+MyUjsilFpmni8emJ8/nJoFhs78zJwZiVXGqFZOfI82x2jLLANqbciG5VL4KUbACLpJ21JBKUzu4h0vJdNVVYWYdaxbBJeDlb5t6SZVhL3vaGP7Wea0x6Kcy0nQfH8DIPCXwBUdj1aqkbvNIzsP77hffu9kV5xw2ReKuKkQ2Su3pnh617hNqrZPq2CHm1v8X7aBe59zjaXlD+3s9N8hpp5vqePXfDvfcsQX/92tU1XQzHRVGxY1dY1AZCCxkWi9DFSTG61hw4tlrDYPr0YVwTBXGOYRgQgUSGNBEGbyUqnVWwck4Ibmh1llHzXbfqnKaWcSKMY7CaBKolG4cBfHbOErRiQ80pEQZn1eBqZTsRJBYRXC2YLc0z7nTkeLxnujwVwmviuJdFp1/XMlNE8kIczeZRMrVqMnVEtHU2vbdY4RgpyFCErIkwBEJwli4iU6zmixWrosft54KGrvZ9y94shsf1rXL1ZPfFC83wsq3fPM+cL2cu04WjD2TvGvOjtaymSuN0tZ21595fZOHGLInZC8q1y3Th559/4qeff+L8+EicLsQYSfNkSLCojmyMiflyKaoZaTmhUkpktRKwMSZinK3wkCoxZyRnPtfA2npunYNhwCEWm1LWVTEbWO23EcOsRQ3aL2x5RmsaEPvcStjqYttwzoClpbRxAvi2ea5KCzXFVNvVYpcSb1KFDFS1dd7f9av25iyp18hN4Aa3vba673OuV8Uyuue279q+79a9C+RVXf9yqY20rOEWj18h7v7LQhAsUnaHMNlpoCnPKoJiLd3089jaCPr12arV9qQ16ebaz0Yay7ieYeVwAKq9rNoGrgn0wisKlRMx92ERW4OiNCilnhUXAmE4MAzD6k3O+VJhDEJJc92kP6O0pKwMwd7rxCFusEI45EIUbBbeewYnpt8vo/OuJJcTbYZIVAkOgitPS8HKziE5mcdTSszzRJxnI1Ai4C2hm2ouRKYYKbMyx1jI07K2rnCXKTmSWkGhmCIhDOWgY+lcKoJ2Dgme8TAwDsHmp5EkHi0yh6yUO8piJtRiNBR0c+YK+JXtrQCu8Ao/9yqBdFDSgwF99lMthDLnxDRfOD89cDze1RvLC9f99qnaV3BWEKtUONCeMGQQRyaTYmKaJz59+Jmff/yRzw+fifNkEl1WvPOGrMWZTShIyTobTaWj5umlOZeUJ9FUULmus0kEpESOM9M0k1UZQyAMocUlmQpb2tFSSgJJSjqV6rLtIHjfMVxSJAugVFnMRYpzkhatAxS4swp2rhAEqYxcj3eortclsr8Je2LwRklWWHDJHNepZ261LyIK6wIXLIDA89zvIlUsSH4cx/a+2FXu6hHgLeait0lcc84LQbCF7Oo1012nIDVhB+kaZ7y43Nrmita6DLANtkuVq3UNKwNrm8gt4tYTmb21boPu5r5aD+rztEPcc5l9a+tcEHU9lNUgtxzmknICjxaVTOqLNTspHkEO1cGCuGSnVKQ44qzkOJvBzHJTk5KJ6MlZLO7gjdsKXjkOFtGsKRGcGY0p3HtwDo1lT8q47Ltke+qEgEdUOLVM28XI6x1otIyrGomzMl2eSi3mIqI7h6oz/TCWzykWbjAlKyspLljyQ1XGYeDxPOPdYHpgMYOrOWHlhgwQkNExHo+MhwPjYDWhQ3rgPJzIOIJmXK4WhUIgCneqWve0lPfsmnGxhVioQAKXDRFqrh4qnesiixxYNrsxPo2hKdhP0CIwKok7ggNIpPnCw8PPfPWLX+KScbgV/hyG8PbihipSq1KdAWUhdc7gKpf0Mlkz5/nCxw8f+P2vf83j4yPOWcQ7zrd3XebJjP4lDblrkkMsnkWCikkRUnKV1kJLdYjJCQye4K0g0jAEDocDPgzk4jbtwuIOnxXIGe9tX3KJsh7CgXE8mIq1rHA1gFsQZG64rXL64jf7uQl06/HBosoDKaU8s1bJNJvdp8Nni2rr5fYmotDbAOq1lK7F2PJE4873jWKGgOZ5bsnFhmHgcrm078uH9d832ooTX4kAUoWqF59ff96Lg1g8CIzb3SNIpdsOtTZefnPv8vfLYl0lFivm/wuaSPXAUbKmxqX3Y9rrIC/yz1UzYpTx5qdJSoZA+/Z0PnO+nAtyUQYXkSJ6AziXGUOts1BULm7AhUDOM3d3d6CZy/kJFwaezg94pHBYQipMgKLFg8mRi/rscBiJucwgONIcodR/ds7qHPgQuHMDMcWVKjBG4XK58PRkqSgOh2PjnKVDtN4Lg4BQMoeqIDIyDDDP0TLAOkATDo+3NKxIjIbeNREsix5myxnKiq8jw2GxX1zBZkXk2RApORX7jHbHYeHYl9z9u/LBZocp46ocr+LUkebEx58e+OVfThz8kTXE16dBdq7TXdmDLKMtVlgpTmaPCuPASe6W8yBLapyDHq2/DgmKr2ojkwgUQYtOvj9MzptnT+jeK2JBqikpWSPiPFOcuD/ctzNEVpwPxZvYYjVE6vnfxzq5pOOAYgXcIOs9rUi/b73zSN2/mtrCQcnqXPaq2BlDCDybdLFrryYKwflW4CTnbJRXMA4xd77QndtmbXtIs6eCfWGJ51oqnEhne7mpaur7re51uoHLZWHt++u2vra8d/v8NWHYq3ZUgfVa/fXMcbya3z5qbiLqpq9a37o31vWFxfvxL+q7a47Cueqtse8UIFU1U3pjM27Nlur6MAygwul0XAF3k6Sigsv4UIy6OYN4hnFkDIHjOPL58cEISIe8Fxxp9g4ngi/DyCqEYHUKclb84Cxj6jSRNSFOmKLyzVcHLpN5bBjHZyqQHGeOw2DqLx+Il8ScjZkRIKgSFcaDJdjz3lmajLJmYXB473BecAHC4DgInM9P/O73f+Af/vE3/Itf/iWjz0SdzRiZFdxptY5r9erOmVKKu6IWdCDUNFQKJKqTQC8p7EBTYRT6RN6LNAFKMgokoHlmmh+7bAR1v2kZaHsD83Yu0o+gA2EpY3j8/MDT+WyOCwphHAnDQKySblGT+YKXYppNTaTmAg2Wr8qxgf2yBjmZZOmkFjWSUh3PtdxsUr6bYzQJb1xywg/UWiCmqpGV2GExM1U95sWVcVsxomb0F8F8DGSFCrbq6T3121aTsODViof9vtrumfZ6l9TC0VYfWaECYIcIyqD6NAi1bRH1Hte8e3/3d63wZVzYVq3SLcxKk1T6KdzdPk9SqW0/xuUAbnX4pmq6HndPhOxoWiBOHdA+4VsO0ra/LUBoIcT1NVdGf3c9Ny1r0Lf+Xf2ebudex9PUWSVLrIMS1dsD28IL9pxpP5Ja9jJF8/zoxeGUI1LiFExXWpKpOTj4gRBMkgzeEVPkYbLaxxbwWBfFGIY6trocNVjLppnNmFiiXUHISbk8npGv3+OdQ50FtuEykuB0OjbEmrGYBFLJv6TGbByGEcicLxecE3Ky9fA+GALIjjkn5jghThjHAwnHD58+82/+/V/zQwT3/s8A4f7ujq+/+obx/nv8SMsMu9rvNQ+w7HbZvoXVqBds/65gcE9Qbey7rP6sCKxZM4oxN8eJNF/Q4dSibxc4rtLULfjfzEAXooaap9bjwwMxRlyBgRhj5+5qE6iwFBjwzqOhvq/nAu1MOlxx+1wMz72LfIXJeq0MhWFTG2F1TvPivt32yQuSF1Wrirlh5835ovag6y3d4shbeZP2bLV1wnuSxkvt9eojVycuK0RR+qbmur/Fyd4iArvvqxSzIOClUEURufL6/itbQIew1yql5QRc9bd7femz9dPezTPPtCdYzM6djaO9t7oabp7azGf1/rIuq/leD7VruePgt7cvKqGtBHPjZc98o93PHS+TIorPcyTGTMgJJ1b7OGdlmhLZCYMzv2+rfGbqpRAC3gVC8Ig6pmFYVGndeAzwSywLhRaLeXC0iFSxjKbVvVZK4aAUi/GxpdMwyccS9FXpuEC3YMY9VwopIfjgOB4HskacUiKjzXhtBMhcXJ3L3N85UhbOZC4PT/w8/ZaPccbf/x7SzPvTie++/Z6v/+xf8P2v/pxhHIpK4CWkWs5NxcLb7SnfreBGe+jvrm33b3V8eqRm3jPzNHE8LYwUjTFY2zKu4aLromdwihPE4D2DD8XeIOA9Lls8xvK4tEn4YguqHIqUSnbbvmosAKr40NktZY3jlnEp4pdaH9o0AYVW1iDcOpbSofPrNB6igmsMGfTsU03PXvvcIvJbFeeuiIJULGz/t5qNl9qriUIfOFZ1bRauXlJaFFmzcok9d9EoY2W3dgjBCsG3z3Z41zUp+s3K5VCvF7Kt+YpwdSxUt0A9N2N9rQ3de4ejIvteSqr91m2u81BAci1Z2BuTt55R115G23XpuZYrQrQ52fX7Zh9hAZYqzi4HdS299ZJQP4Yq+dQ3rgC63dEdjq4JwjyZbjgDd+NIDhacGGNknhPRK0mqnz+tpKGMZrz2zhciYRxjjWS2/EIOnLbIaSiIvxbtkeIuKZ451XxEpaqemEeVqZNsrN4bE6TebBCWPsHSD0SlGBA9QxgQ76xcp3MMQ4BZiUk5TxfynAnjSDXYH48DwsDTZWZOkVjWfI5n3OmR+emBkBJ3xxPf/9V/yX/5v/9v+Mt/9lecTnfmCrxAAPtNOymBhauv0vJOExZppL55kSTrZ7n+XoGs5JiZLhdTvzTmRZdfvdTwDGFb7GZGwL1z3B1OuPfC+XLhcrkYDGZZsVMVB9ToYREgV5WO63IKLmPSAg9oSXJYmaLK+OUyZycWHa8WJIko6qxPKWOuBaHauS2LpCrFdbSetXK2FzchO0XlT18k3qza1dboGNZOE9CYOV074jSmrKrreoLwpyYKIVgwRzXg5GyHccpKdsXv22HuYynh1Fnq4srZStF5tmpdfeBaz3nQEBMYx9VQb4fAapCIkkpZvtKPYYBGBLQ8t4rslcX7xggbSLXLdHvRH72qVtHGdRpHYvC43Nnc67rnjFDGFaK0NdjWke7nthyS/l3NgL3lJLqDW79fjbsSxMbNSOEIr+0ejUh236maYdUetcLzNKNaaVkRV8Lzde3+FlPJLOo94zt75pLNxzwmUw244HBuYDwMDIMnkcmXM9OQidOIBo8bPSEIx+ORnAwZa5ptfKpAxBXiFBlwkhiHgBWC8zAMRH1YYM+Bk0zWiZ8/Ob7/+mtGP5JVuaQn87YRj9OR6TLx8eEJEU8II1OOxCmtOLjTeGDSmad54ikFHs4Xxmx1FIJ3kBz/8I+/Z57OQMaHwP3dCTkdkPiIuMQ5zjx8fOSHn37gf/vf/gf+u//u/8q/+lf/R7765pckNW+eQOIqU1iuvu9rD6OKiLecYgX3vpi8uqXCnO/tAEpRxRQkR6AkODeD++cH4i8qIZYWkZw14iUYgwYIjtTsMeYksFJxlL81eCKQg4dxMG8azbgp4xhQliSHlVGrOvnKANV8VRSmSxtDVxdAmqmjD44VqS6doLmeZ6FGA5i76CKQeR/aGenXuxID2CD0Ehi32rt+z7KyFHgWKMRuIffVa2vFVVpMBZgUJUP31ZqBe6m9miiM40hKVaefm3FYY8alRJYS7FGG4NTEcmOebUhJWET2VVs47rpA1S7hKudfWINlHQxAW/KqDjm1/ICVMrNeQKXLVKzF3a5drBayPcK6jM80Mqn4+vfi5g5y7hHrznzr388R8p6L7/e3J24rlUGdpyotlxMLR0iOyyqUw7Jsy6aTGlla1l+82jqV53pXN8m2FnkD9GgkkZidIYN0ydRaz6rmXpnVc3YzKSemi+MQ4DR6kozMCS4xkb0dnBACc5qNWysctHOOwfnC2WdUjEGZVBnCiKrVMQBjcmgMgXA4mAvhlBLDoBxCQOPI737/E081c2rxigohlJw/kXEIDMOAc64VfREoLrSRDEyT+cQHryCBaY7cHUbuT3ccDgcO40gCpks0DyLnEB8s99Kc+X/+63+NcuK/+q/ecTgdmQpuuFpiXTywbGcK19kQ+Ypd2dnn5TvpCQKL1FBb1mg5rook8PHTz7yPZ2Sw0qIiUqq8Cc7l5oK8pxbpx99QX03J0cG395653XujtvnN1quFrteu3bWR1rfvv2UX2Wo86th7DctL76hOPPVcLM/UfVoYx+07e4ZXxFQ3r16aTXuTS6rpeYXq89/CsCuyKxx4M0X1HED9vOJg1wSglxjKBXIj5tvNwapMtfcULr1wG3sG4Hpj5ek70kATDW6I5Vs1i3bXrvV6G05dizG33WIFx1f1cVU7yWkNQHsHScTcMGsoTRPnuz4X0TWvnlskAZu6dpKlfb9Nl8Hq+aZa0GsAr4f4ihPKJWWAgl4yLpk+vt6Xs+N8mXA+k7wjhwBYwBtPCecmssCYHTrPTJfJYgcUMq5xpt57UjSCgFdIoMU9VUQIo0cnaZlTKzNhKqzIGAZG5wnOWTqKTMt1E4LHOc88J/NfH0ZCcK1QVIyR8XiwNN7RirjmDLFkjK3pkMdx5HQ8MgxDceOF82VmykrSyjxkBsz56ocffuCffvsbfvWXf8mf3f8VJGdujVtJAWMAnJbQt4JDGmys9mStZrIB9vBDYebqaZHlCXWomG7c4Dbx8PDA9PTEOAxmj8nZDPYdB1zhOMZoSH7HD7/HGfV3TVNxbTTdU528rj1HTG59tz3nt56tMF0rye1JBbfeU+d7bWd9vs+rcQuba6+nEG9KiLdX3KIChgUWgWXrc2guvrNXgzMO5poC91GX/b3l80pCqBeu779JDLrvhIXYLKqf/rmli1707qW1njPYjqkawq9apT1K8dLYEI/t7StCtBCjSgTkC0/ESo1FL1AvALScz0Vk3Y6tvW9vnTfjGRxmJxBwyfLgG/KxKFnxdT4OxZNxTNFcKC/zRFbhPCfGAKPLVjQ+l8jeYkGuOmKTkoSYInHK5DwRgrmKqoLGkijPlbFnJcYzc4ycDkfujkfGoZSKFSH4UNQiZrQ8Xy6cwrEQhGXulj5h8WARLBvrnMwoXSCm5XtStShbIXFWZU6Ox/Nk93iHjJay4Hx+5NPDRx6eHtAiB+9p57X7WdUw1fBYfUtXiKaJfgubZDruhXHYIxq9g4L9bQkAHx8+Mo4DtXqeDyUrrFZX9co1d6rcLWjp8mtVX7u0Pqvytr1Gani9ZPG2e7f3XztuPH/W+++/ZCw9Ydi+5q3zeJOhWZDie1y5u7z4/0LxGCgeGY4uIdSai66W8Qqgxl1WyO0JAqsUv/XT8r5ra/xLyNX+7jkfYIdIPbuMug4Gqn1cE5e1h9RKYGkfClK8wRVUe0g9vxUZiMiyNgV5VyLcuAyWU30bMBayIB2CWAa5VR2svai24+6N4X07Do4xOM4IITtm5pK3yDhocZ5hDGaDc46khmim2bjsOcHDRRi8cn9weE0EGQrxymYQTEtR+gxMMTNdEudLJASrw+ydENRiGbImEIPGyzQR88zgfEmoVur9OsfhYERBgRSNCaocfu7UHKqZnFLLqCpYESkrJFVgrqQw0JxJmtHsCletnCfP4+MMKOPgGLyppeZ5ZoozsXhHqVZCuOFAZblSkba0z/lqK1XVVDydr3vzlBOQrGRzqQeKS2uF8WJDrHCJCp8+/IwPgayZ4XjieBipDgm9jcO7sDAc7dzUPxej9OJ2XhmN52u3vxX53Wp7qp7nVV7LmbtSV++897XfrVTS1z1T8cZz87ilBnuuvZ4odHYARUk547wnCE0sNaBypgaSGlW3noeXUrC8MdeVwChZu4C3/qFyRa7IQ4eMhe4YbMXqfrENcbrSd0VhilaKtbxB9sfR5rq3ye35hWvdjmr5rIWjuwYULQexxn2Yt5JFY1JMqeZqWd4nNNVcLUNZ1W41dfN2vFVcr7hfqff1qyyr8Sxr0QOZtPmsn1ra+7sjx5B4eJzN/fNggUK+qF/CYJxzPCspLTnxB+8Y/Eg8R0IUxkG4XCaOg2MQ4f/T3rstSZIjZ2OfR2ZVT89M74F7oFakiSaZDhe6ke70JnoGPZieSG+gGxmN/H9yObM73VUZAV0ADrg7HKfIrJ7hWvlMdWZGAA4H4PATTs+X+GzbrgjhgtvtS7ynIBwIxyXdgXDBvgMhEK7fPacFD3Hj0hGKUP/0/Xf47sNHXEA4bjsI6ZKWywV7iLuD48a0eKYOH1ZWDJu4m3q/veL18xe8HjtuISAQ4XYg3ki3A/vrK26geMzGtuFI8d9//S9/xq9/84d4kNvrTwh4ihPpOPDh+QnffPgQ5/UOFs7tgR7XWhQvii+VISXEIn8Woyyk4zkoK1YcYvXgHtFslPyVgLQJ7MCNCD/8+5/x5eUFH7//hO9//Vv8/XffxQ1/6f6KdBQini7Ay0tcvbVtT/jm6YJ9j+G36/UKulxwTcZl5MVb9pIz36ZVQS0P2eX1SXBj9dAbxXisIAntC/EpAcL7yq5WVHIhyPkFbVwxnVzG8EgKNgSNTCxyq1YGs5PN00ohPF1x7MINvGwI+w66vMT7QC8b6ACOlx2X8Bx32PNkMeIFJAhxl+UNvJwLgNrsIoR9EtABB55zw+7J2olVfk11ZHe1OLVsHxU1sgfCheI6ixBEKAhAoLiM8ZJyHAhpJj8NDcFPPGexH3GAkXRneZDxeSdp3EY77RkkzjJkwXpQFD58sYwoCHJbemyrFFqhq6ArJNYIeAIhn7vGNLM8ACfneRdgx1Oqo/QW4u1h5UwYZX4mEsv6bGT9H6LlT3EyezcM+A+/+YQfvz3ww19uwHfP+PT0jOMWDw/bb8BPX3YcO+GgFzWQr88fEJA2jOHAl887/prO8//4zQf86tsnfH+94st+A+iK//LjDa97tGQvtwO3fceHJ+Dbjx/w/HTBtu348kL48Ye/gC7pnJz0h+0JP+0HPv/1L6Cf/goC4ZsPHxB3SsVdrS8vO/7t3/6C3/zmCd88BRBiyOjp+oz9dsXrF8KX1wt+uF3x+adX3Hbg9hqF7ese73j47lvg8go8X4GnywHQjj9/vuD1dcOP//wvoMuGp+cn/PTnA9v+I/70p/8Wv/3Df4Nf//q3uG4bbgcQ0sodBZe4/BWB19PfwPNLN+zYKYAu13huUUgHEtKW+yqEFOaiJJTCt/j+++/zBDoAXJ+u+JxWnV22sn/ket3wQs+4PD/her3iul1we7nhcgk46JaNozx3FuKCkD3tGL8dO56fn/GrX/0Gv/rVr/G0/QrXDxfgAlyfgP0gbDtAN5YphD2YhRYPgKYXsiVFJAS+spOyQEsrTpOxugUeWxLvjTPEd4H3cuijsweUir8IIY1r6e3v1XziGOaXpNKOcCkC/Egu7y3Ea/g2HNgR8EqE7YgVvICFaJmIjgvZ4kFUEeIJkRR27MeehGsAuxIxPJFWzwgNGABcN27qI1u6rAhKzJJyyCpfpyeaM08EI008HhTP7edlrXKXMMmyUcoGk0e47FGIEiGf60ME7NtfCy0Uz2PZtg20x6sh+dCJLYWZDjqiwkjx1+2guMMWAZcjIFxYBe6JCwnYLvEIMeL2SKuzNqklEkFEeNp/jPmoxJ8JBLpdweuwC4ScNX7yZHVs+HDsKXwYwwUXY+l8+vQtvvv4EzbEOwyAa/IGjmxdvb4StsuB7RIH+UZbPAkzEDb6GI8a+BJvycIeefBpu+FKO/ZA+Px64C9/fcGX13hq5KePT7henvB0JYC2eODdfuCnL8DlOSqJgHh8CoWAn356xfOH53j658sLPn9+we9//3fYw5f4+8uOz593fP7xAPBnPD9fcE1x8x9++K94ul6w7z/i9RZwBMLlwzP+/tO3cTluiHsjvrk+49N33+C7777BcfuCywY8PT/hmx9f8PGbj9iTcPz4zUcEAn71ccM//Xf/PX7929/iX//9v+KHv/wFCFfcwo7P22elF373j/8TQB9B6SyxtI8bdEkGBl2LMk9jBduGsMXTPI9wYMsrzY7YzjjihHg6eA4EXOiJfeto0GzRQNx5roBI8478kY5JL/ORcQ/JX/7yI44DuFz+gst2xYenj7h8eBal8F8ywra4LPwxqqAGa7lzaKuCJNioZMSFhOcs3qslq0EhmFIEXlhLH98AOUAzPaswrRR2SlotrWLGdsERdrzuUWCHjbAfhHRXEALv5EtxSt6vwJY5h01AG46NsB9xvTR4lU4OhQQAG7Z0n2sUmlEiX7DjlpaFAollxEmDPKexhRRCYbMZcWUObWnnYz6vKbnDSDHgbQPCFVu6IjKwciHgcuxx+aCYjbuA8Mqr5CmuMGIGPrYN22XLwjbeCxvPjqLkQ0jFFb2iuBZ7I+DYKG2+orxJiyjko3UBwmuqk1iJnQ6GS4qWfUuk0MXlKZac6xbDe6C0flz0f45NpoYKCLjdbukICaQ9C2luBISbsUqe/4eAf/z+I775j9+DLhdslw37LZ0/n+g90kVj+bhgRK8LgXBJZx3t+x6XK4aAy/WCD0+E56cYGnrdD7zejhTD3/DNU9ptvBVlG+lmSzf21ZHWogfiM5JCmlfY8e233+AIV+z7R9xuB257wPEKPD2n84yS0Pj8+QOu13ShfbIOL0/x2OUjlIUBUeBd8fR8wbE/Y6PorfzuBXh6uiCEiPd63REQT4q9/Opf8MOH/8Bf6YLtiHdWH+HAX8O/FoFLwLe//xO27WNS8uIMHCIQeF8A397FZ2IhhiQTL5deD8DximM/cLleypwigMvlKZ/ymZn/+owr/w68Og9qoxajlev4KRklvILry5cv+OvlL/jw/BHffP9d2jiWs2ZepNyfhj8da/jMXEM1SYxQjoORmrVUy8MiZBmHkLRzMVIGxWueo7sVLnuTOYWnT78Fxx+PFPO90gbs17zU7tgPbLeXHEbgi7RxpP0Mlw18onScQI2VjcsBX3B7eU3rkaOlGiewD2B7wnZs6VxxtkaBC24AxRUcxxFd3+vTU44T8wqMp8ulHETFngRSiOqIy/8IcRs7jlBoJMJBV1wv1xje2dgPCdhuLymyEvKBgBsAPH8EkJYGpvP5o+t5jRt2iIBwxKG5B2zpAp4NccNPeI3XMG5hxxZu8Tw4SsI+1R3bliZVd7wecaclEXA8fSz3GHCsHBvoUpRCSHtHwrbhdrnGDUoUbxaLAv8KtVgxIJeduCsfHnbbX7MxtF3S7tEUzNqf9Smpl3848Md/+IA/4sM0c/5tA1+1CZQD427iXbmk6At+xJcJjE/ffcKVPrJcRj4ZVMrlHEcsO3137kMVgiFc6CnvA+WwIYjAh2HH8Enq8e0CSvdPBvGXQU6gGrqJCM/Pz+lE0hs+f/mM//jhB/zdH/+QEVUKgf+j9gINb3J4ZrLXBaHMWP6wwcvdGEz6nDYrUIXMhJTWINOgCtSexFnFMK0U/vS//O/YLsB+7Pjpp8/4j3//M373h98Dlw9C2EXSNnkp9r7j9vKC188v8Qyb6wW0xeWCfA746+srvnz5jM+ff8KvPn3Cx2++ixdkpAPEnp+/xe31lhngOHa8vr6CNuDb777FfotHJRARvv3mI24h3t9KAJ6uT/jm2494eXlJG822TN/LLV6YfkkWd8CG/fU1Nm8K8dxed1w/PIMo3i+MJAyP2ytC2KOATJNkt9sLvvvjn+LKFPYqthiOwvEESpdwvL68IOxxxUzY9pQmDtL9dsNt37Glv9fXWzzjny7RAgsHwkagPeDly1/x1x9+wMvnuCHr0x//hE+ffgUgxoD348Cxx31DfKJnCPEg0gsI++VjYpS4fX+7XBKNL4j3/cYMW1KKIZ5Ah6ctHtnxgS7pdMyykYiSgHvC/4st/DOOvN3oHd4SLhR3YdOR9D9b6yyUcANwQ9yUdsGGl2TxpitWD73JMfLuBZdrOb6FgY8hD0kgbhwRSLfVBaLk8AexWjEKB2LjGVqIPj1dse9xsv7l5QW31z/j5SXKDJa7tG3plOR6Waq3Ag6YE4S9NK4lz5PJPrLkKdmNqrFNe4IcHD3plQ3dbiWNXWFZ5iZ6itCDaaXw8R//Z4Sw43Z7wetff8Ll+Uf8+p/+CWG7RKuXVzNENyC5/Qc46MSXWIe0rC0yxQ0g4Jtw4HueHT2ic3uEEHeaboSwH7imeQqEgC0cePnpM356ecW3v/87fHh+xkfa8oKEjyn+yaukXo+46mEPt+j28jLCJMy2A6DAXkTa+BNCpP+44ZaWLt7idrl42mHauo8txjU/EOEbIuAWV7TwMjw+POtKkf4jADci/H//8s/47W9/h+3DN7jQE56QrpJ8CsAFuCVPBYiVuiVX+QhHXEq5x4Pjvv39ju8Rw0RfLoQfYiOnxuap8oBr8rxCCHmjF1s/eUI+hDiVc/2EjS54ori2/kYoo5lSaCiEaOtu8TiE7XgCcANSOb8Ov8P/iv8R/8/+f8+y2DuchOfte/wfv/+/ENX7awrdlFVk0aO9ALhkgbLjOb9jd4/oGcCerwwFbkmxxDw8vLedl0OzRx4NlqOkSmOxhJOKGhDxrgQxihtwpWscI0f0vv/t3/4Nf/j7P8YzrlCE32hS+S2WrNowVUFaf608IWxZ4sUI1I60/MYI7nq5NzArzPuK7QihoqsF8zuaL88IYcf18oRPH77Fp9/8Ps4BcKUgAnxIO3azTUDAlgQt8bI4Gb+MIYtAO3BJh11lHggAbfF6UrEa5+n5A35DFD0P4b/Fkyr2tFotgCfGcRy4hHixepT3UbPuIV0+H8pBVGwvESGdcZKWiSUlFy9xiSEbhL10mow1hgC+SYqZIb7asF0+4He//yOenp6jhxCx58HMq5cIMda/hRgnR6Jtk71LcZJwB7ClWHkJ40br7CkfE42oKA7BiMLDQ0BcSZbCaTxVHGPRAQgbQj4CZMMVLCgOHNfPcc4jj/uAZzzjf7v8n7ilSAkbCERbDGtl11vEwPP6eyY4HpdSVkTLzYF8gTqBrazk9yT+CihTpygH5MFZ6y5+WwuP3+c5ExGakH8SeF4iPi8LJcLlovuPW5jYuqvIETiR24av5IwtRIiX8sS2iPtNRAgVPJMgrMl8gxvluvHSz/iCVP7cJXkCKXrWARCHt2253cswYI2SxhCSIZLrQiBKx12nPJcLgLDhhx9+xN/97nfpcKa4FJvoEuUEirDs7RDW7ed7EwwjHCtlUBqIUa6BbeXIBuEpjdE5JZW7zNJMlNqaG1u+i7KSFfmKOly4T4H/KS6OOoffJI9ClcrECsmhxq5kvAe3CIYUIoHZDRi0ZcCDkI/YiPxlGSO5tBDiJVnecbFO9GWjxRMHhirFcUE3hUdr9fxbrbopNMiGIgBPHz7kuwN41FV8mhov5BZN9VTWVhypcXgFlj3xbTGulL7K9BAppgmpbvE+gviCJ/SICIfq/5Df8RyEXAbLSm07PuHCO4fTqAgBQDofh4hyOUBcsJB5BADPgPPkf54Ut7HkUMpWQGU1WtmXsSlrsxd75WO3M/+Kz9bmIPbInq6Gj4liLM+ZDLQnvEio4tHp36DGlCgDEDxSfnE7ROPsIhZV1CKDKqueGasoch53XGamMqhfDYVb8Edlfs0b8mK7RgXz5csX8OKMvGjCaatVpdB7f49HofCJz8yeF+C4iTCd4ps5vDz+OI9LrTJUl8heO+ZCujOuMxJ02uLCygEs42ak03G4pC65omFmXbIUHKXxo9UZDsnwhU2zoLQVwohZqNurOs6ZYvwqeVFfekCnkA4fZk/ZdkPZRR3zBJuflTdMq2ZBVlIX65fX2rLiLbhYtHAz5PYgJGtRaJdcNom+ZT2nFWV2WKr2kB9FOXn9EJxBxr+14Ka0vKm0k49TtKWjQKxS8ARKxaOl4Sp8Ld6pBZkVsJpeofHtm3K4ZGqHii9UuYZs6wm5NJtMjToRajnFBkYxRKI39/r6iuv1STw3o8Ox/r1+8dJ7aR6hEErkQD4UTdhpG6ZB021aLP0M3R40tCzAgqcQDF1kKi0sGIglp+VV6lA5ASMrxb7VBhL3KuWk8qexvua7seEyOhMyxaosl3F0MUscYpLHA6K0f4AmOk00e57MT1ccaqbWFp/H8D1FqvImz8lrZ5LfiVJPF3OlFwKR9WgJb+afSC8AEephxSfDN2yVS2FthYN6Fte7ckXR4x4WhrnOnjDnuoW6/d2J0JNCpxYUGbP6nvvdvjKK3DfY5PuCQO/e55JYaVZFxHFj2mPE57FLSh9uW1xxd7vtoMsl33vROvtIhpJa4CkI18CYUBI95eGGpsy/waRvKTKv3+PCwl75hc3OKLwFTyGdp2PqmwempLPr3sXJYnlCZkoBWGWQQV98c1azS6FiQVGSFU2Jq6PD4FReNNNYKHdHuYQqHFsqv+AsJ5G6S+/YXyXfch4BG9Qk8x/IsdEUG5Sk5v4vFh9vbnMs5wAAV1GGrjsvNZT0skIkbCAZlJceSqeO+QhjYYfIo1t0/QkaYRv3KDYdQsh7LpocEXyaPUWTo2pGGfBy6wPcnlTCeaoa3J5bPprDh0p0Qfb2iinWAk9559LT7/12w/X6FKlJx5Iz38sVNhJfNT4fYP3PgKUnP2c6ALEC0k9fIie18pbl9GgYpRnBglKg8kFUZjMVRYDmFUcgpSvaeoNpdhLIXlrtUi2EqVpnPLL80R4u/F7JshDyWTHNpWTSau+W3geSAplqYcMRyzNswR6Sbe8yhcj1dlzXQf/nZxQFTixqS960EIDGqr3QplafAMK64qMHssUrj0OXxgP3e1tJFg+xoIi/vd6KfNwDdwLwQSD0A5TAAIoyMBEH3UFHEkytsWDmxh6gBDLmdBfLvsdFGs/Pz+q9NiSyKZcNI1fwTngBM+P+zSFqtfLzYTSVtglhvEKrBwtKYRO+Y8icp0ICQO48SSxZQUGXxGO8yy00B47UkjZu24sXSo2ZGSmburxZiF36RLewwkqwJK5e0ZfGRBwhtUUWVyEYUSRoK9XIjncSZXm4uQLK/qZSZu0dxOeHxw+k+yuTQ8Lmy2niZCyhXHavZwECcsQoWdWUJrur0CcrGbBSjmnzaXIpy5FKzLvGwYojLRHmkFZMnAsKWYgTSLgBbAYwfTwpG3Ja5iHVSEAuG6W/Ksstu0s5n/KquBH4XmUtwSsbXDZbf+GgmMwXZXN+5ifumxiOY6aWh7GVenG4L14IcxFjlfk/Yp6RW/K4aDsWud1kGkuLFGRxvMaVeLwrQhoEUhbYsS5xc5k2rS3/UaDClalts5niKLQ55WUX2jAeiS8A6byyOgqzpnzml6Sy+9sR4C63S2DJSEIkOpfKV4ML44a0bpPHKCWtIDh/D2WchaQYiEDBrIZhYWUpZKS2OjKbsejyE6fNujHLVAmpkOXOVaUwOv3BYo3XaPH+hQD5mfrJhIsciuuqGwGsadFtwQpPhm5INA6l8AjnUKXlthJCmtOJd7K9ALixV29uwoeAeFR5LeAyj8swFOm+LkoSulErrS1eVZpEKC/Bx9nhkpaIDYmpAqn8BUGryNttC/GqeOWaYK+dpADlW8os3x97XCp+SUJWom3F4T2FIct0w3InwPKMKif/W0Z66MnODr11uepXpoWyAXKfsltafWRJceUfW4VNJgpaKMs3jrCXisGb0+B88tM+z7h5KEpmhbCmalIBIMdppVLuQWWROFlIpHVph26dGVc4hlLadPFA1Raa8OSUpgLKoYVmQLOAGfKevhKwCAZu0zJ0eJ+C3//lcD4p5+JXApqD2n9uhYbnkbUmIWX++N3pCyf8ZkmyPNuaU5iF2COylUj5d0ynxC3xXy4X5BVumU4j1CMD1d4woSztdkaTZ8BZhcAWfT4dIcGxx5MRQgohksg7GhPefJv8PaUMzJhgvB6osawEhkgjDLeqqIEX0zZuiyKW+z/OwvzR2R0hPw1+O6nG1IPRWF+ox3/PI6ifR8ZWzDMIwGchFEq4ycpQroPt1MgciWjvMC1iekxdNvLnbATu5jODy2iWrLRlHpqwLvRA4r9R32vmlAOST9CtcighyevVU5Nl3hDCbdLKUzwA32XnT6kYRIKpcury6jJmJgP1u8igUdaIUEI1PAI0MwfY5QxeWKc8H2wCs+NXaXwAt3LMPIn3vTkAL8y7bcXg2I9XHPs1rT7aMp18n7EMD41CM7MegeTBwuVtQTvyMj0DseWJrs4vZBWdxvCI1hlYmo2wlVuFkTsOnHflvLJq65tPiLwTNyZV4Yghg49pA8pRFA8ELU7bicRWp+p1aNDsQ9tzG+a0/TeRt2UYtNLO4FodpC1a2CKeUQgF0v5fPvphjukg/FDn2Rhm6k3mD0A8UHKRb/n+ZRk64nh8TEB43ctNeFLQex7DTPj4LCzjIcdLkq8bbdXyhHyi4Aik+2TH6fDREYQN4tDgactRB21O556RjWcYoZ5IBBD4hjbBZICub6hxMB77zKuMRyWHtFoWhwzDjKo5Yqw2Y7aoy9RUdHn4euGRGSiTjHObFb2yW+Vbj6A5j0D1fEmPBmXjd8JQMo1HK68Mkiu0YrraV5XzJOkJQoiTx7Ic7/vKJORorssbA7O4NH1xDFxCDB/ttIMuWz5SwxuvUunyHdheaHAFbA1G3kiuW/q3CqaZpF6EwaWDkI941/njcehV+jv04NI+hTRZAC+cPO8Kt9F7u1Jj1jtxZ2DLyxTcAh6I6XvJoj2A6QHllJYCA/Fd0UU5/VmYYX4ZMVLRI2JBnKhQ0SKu76yLGsQnoRwZPemkPsbIa6N3FIIXcugJlAoHle9S4Hvho55gTBQgi5ieQDYCNabfGu99K3rGe8pU3eHJ9hRHPHH3EhUxUYmRhyNe5OTgmqWrMtCyUSUMPk1NZvFWy3gWfdWOXA6VHyueqNDzyM3BdQDAMXDlWGf6+vR7sHb2USiKQcXBnRI9jdqHstmpjqc+CvzQB6XO8qwnN9hkpLurGIjEQWETlDHDSFJxfvBZerwYOh9OZkFXT5+11MLb9zgKrtjHq5Z/fRIPI++18GoMmfOctTBH6axnYsuu8ZSjH+ah9B6RP5/g1c+rw9lQXHN+DW2PTfxKXrLcbJiE5xHg7Rlp8aDtS0UXC1jH2+YxEYKOXiyPxYybuCLR49v7Y7MGvRHUmcqH7Hc2TBLyNZpxYqJ5LSbatlAYPC270vgjS13HpWu3u4WvNVhzut673HnOcA4zJ5bAdytqVK1SnLTOoAw1g4XgbXxJQjxAM2cn7NLuw2L5tvrNtb74XfbcktIlrbZsffu0tEEJ8AlvweZrgQxxuOHG8iD/clupU7+Rd9PyhHoeDKftjQ9bl9Zvi5N5rhVHDyGtOurQ08PvfeYIwADuDo0Sf8zz0D2wFjnx4dScwiMKfjTMuL60OMncVgzFU+qne2tYL0MpaaDSJ95OyKx8vAxfCeQ+ZQBJIdxHixfaeQT0hGZXYHoGYOPxLN0rQsgacByXl+VU9GtST4HetFYQxmBj4rvjSHsZfAVof7faWRpsLVgzcsaglL/4d2X+5WvCklLQzG7cFQGe9eHhqhrLuNezMdTWs8q78XxFt25zSmb4btIasbSWWKrvaa3g4k9evkdEZbA3BtQM7ngg34YQOgKqwkfi7xzInEH802sZTZ92xWc91RXPQxj5g3SOFw0Iv0f8Mry0IqR6Hpl9z0dPhBDw4cOHiXAPXOV8VsgxX4a0w7rGM7bcZ2DkiHvelH0/M5+oQ1Ypz+4bp54HfhxxmW9r7mTUt2fghKcQ8kdrKJ5hiBg6PefmL6SGF25ZDYmNys6uaavD0qfc8u/lu/fQscxUGIRkRPkyr4US+OL2Wu0ynf+UcmjUoSqpoahklzzKO6iFZP6ngqq/PR5hDyErXL8ubxGGkN6BpyA9ei0/c72mJ30thFoIsmHD3+Wfpd2W7RqpVHgnkBhpCx7YMvD4pji2VYjS0KfmQUw93hqW5hRUQziqtq3VozDoaTpvHOXVSE38TWoBXtEjPnu0egNB0RsfpMTiSO0GjtY7+4wK9kI6C89BiMq+68WPVxmq8uRCQD7vSpDXHfyu1uBVEvZMrBYh6gNSNTET1oZrL45eFJIr4Eyd46CN1eDJX51twmN0X+p07VBCO449Y6V6OD1+kc/sQZMrAnJFWI7wS1w8F3OIS6zseBtZ9xq3+pU4yY7DxL7WlrHQGKc9Kz6jDCEqqKN4igAfSB9820LYta35oxXP1sKJHc2+BpbpIoHIf8Xa4dp4q3UaVmcYM5otP14EGrRCcOi3eatnIRRGKDcqVsRKq8UyZg8/UTn6jYsrnzOhJyvoxqDoY4E6GJQuU4WitKTFIz2S4vWU1SSKoxt0ubREgsUVocxbfvqxUCjCpaStVzOVukW+1Wj9unA+56Gyk3IIAh150/A6RpZ4kwbxvCdUNQ11WKOHf4RrKuRxFINCeiA9eqXhasuovCyRhw9R2XzLNCsGx76J8mXz24OP3ZTtFa8I2eI98RTdFb6DuowdwYeCybVhE8dfy0iYMRpacHrzWg84drsCrlG5lN/Ykh2NPbLk/fidzNOPCY4GqxSgJ+aKm+WOgAdNtgTF89H8zb2uKxsKERZwmaZfoUK180PBNzDy27auMOmkdTgHZ+vU82Jbxp33nX+vzml4YZFZ4Drv+668GGuEzCgrSdNbg1QIFqyMkWE7C5UyjmELl3Ek3rNRgruVQo/Zes8tuMYoV26As7IgFsuuFUCxR6uoQ8mV8vZpa8GF0oUoIR1dvNUr91fpX+38ddUtc66l9+Y0PHDd3jtk+mMUQuuobYBbUAkkx4Oh4janXClfchOC8kRVRjc8MRsuGI1PfudZ1i0PAUDzOGoPPFw9eREQEHbger3ier3ixx9/BAB8/Pgxn3nk0S0V5szYmQlbjZRwsHYdp3fwy/OabDmSHiJSYTKPLgv5gMkOrbNjYf7o7MWG9hjNS6fBdw9lyqlQUqfurUFlqCsfQT4Tlp036CfoY+AuzzantIbvcP160I+1T2OBaotGSCGGxlpKp2+ZepcnSTyzbT0jrGbyR3ler8+X2fU7qnhQhSQtHYjHxsT2cq0jh6bH8Mi9OO7J3xReiFdxXi4X/PnPfwYAPD8/q4lkiUMK0VlPqmdFrxgv+eYPSRPa/eSNk1Ekwyp51wBwFPdZL/lNwkcR5l242LH6XVEI/QnJkWXgWSZebFLnpxxHzPE7zFsgtrzxu9DyBis6PRhZPM3wwCrD1LJO4dMxT1mf2H5cvDCY3yC0U+jxYMlbmeA7+VsqEaB24/OkeWOwBnhdwvy3LoA9PrfvGHrt4tJ61judSU96TPKBebbsM2VomXO/kcSUtAwYT/5U8xuD8N1Z2s7mfROl0B+Q8a9OU4S/qkCIB3tZPP1Gu/8kVOOfNKd9PTq8zm1Zt+xq9nBKxbfqkfRojjrvjDXhKNr0L6VwB68RCuEA0RUyJBeUsk1PWx7miYEwo5ArHnK8UhJa0Msn+4OFTKQfmWdVjNelR5YH3zLwxsUp4D4J+bukf2SxvgXYdi0yIoaovvvuO+z73hzzzC9T1rT4fW9bZn5F8vISOweYMR1QyQ5ZZ7nD3eKf7g/53HgsZfXe/BWdD1UKq0zEnaPCBQGgTTaI0rspXb+sIyZQlgYAN04nadE408ChlCcL0rqj7rHgNuEhjCycVqxx1oOwv0dULw0cGVsN7OFtAPEpnYXVZN/aQZ37IcZs8tkz5TjvPvSEgU1Xvy8b2/S7HfqWtbauouxietY16lhz+rp56ZvUr0H0zPx5A491WyEYG+JrCWSJR35asMaT7HsSz+349eYo+PvIQ1z1iEZAAK5IV8amU0xdZw9FdnA5R9qlPSzD6QeWlYy8ddS+dN5bm+Ys3HN/vEOAnFCca+DY4Tp9U8Y6aEdn1N8fe31ME3FH2kHz9rbYVwAz4AKQbq7wrSAJrvWHxwnENXibUNbPD63WPN/SngC+17Mo47gWliEE99mjyj4LzOsc8mJa5P0PKjHOGZI9YO+8ZzetlHn3zWtnKye1pbY0UFbp1nEV1rUuHdktE99n6OumCfHa+Bk81nqZahtOk0MP7RCRF8IYhZOG4aaGVdjOw1awcVkrmuzZ/+l5AKKiPUTaAnIfwgxnZS9rIm0Pcn7RXi1LufBuFKquB/aL0i8EIt0XbqqBZ7UyD7EClXAnvgvCO4erntuTdJAYR3YsjfrT0mLfdSrQZNbAoSUgboRI4SQlr04YrmXOlQvS9bknzPyQ8NFcpdKxsWycyGmDSvgRQIEDdHqLlinGjb0t16CGEncdW0Q9puoyHvHKhZpqzzX3ymjFWdt1Er9Th7TCKIlEAWS+t8uJ+doDsgkcOjI0nxFAs6GkIR7omuvBXJd1Zh6kW/4dbRBBKmkoXLKfJqmBnIsIYkDP0Nfi5zgEAse6lCG2Ml9wj6AdgTfuy/jVcLmIy4047M27lsnHNcuvJcwG5X206FyF5SWptqNsh5XfljAScTCoPDWIdEcAzAXy0hLXDSmKNo280lDK0m8I+ZbwX+qQNBhs/8t6reCbid3a8j0BVpRUizEDyuXWMVnN0A1fltgTLH3ZEqgzourNDfJEqt8ak0d13Fn8CB5lsc+V0/Me06+OjNB5+JuYqRM8GU9F3TKOWW+4NSfSyjd6NgOyPLbUObSteJwAUL3k2itbziGuWP6jdhrB6aOzmdjL5WIGdn0WTQQzySHTdCvaFr5WoARRjrXsemGZFn7vnfd+xpJr5aNJeiR49VixjKSn0sOjjinWehlnVni16iLb7TDvSt5CxHyoq/2+NelOqm2qSlus+Z2iNRs1jxDW81Z4Hxr1xbzhUcKBVhnyvGBt9Mny1aRnDh+WuxKCoPNoRBJmhWIvXKSocoza1lia6QM7AR9CyCfPElG6xxrpEkgtuzwl2l1EIsaErePIE+nBglKQl4jHv8vlihC4wkxUTWgNoa6QEVT5Xyrx55I0uawUQBRKmRMasiXMbWMWa9ffNdnCvwqsGEZpRuVIq2paYTWEKyW2CAf3q/AKGuANQBtC8tJLRSutQi+kJQWbl38F5MAljmtqSyJbdMun1WpWlo9+ZpALG/K1L6fwlOFGot2K1Kc8govwCmq4X9JnUSSsGHLTUzzK+3K5dMedxwM9w6EldO8Ju3hWPtN1HAdutxv2fcfHb78FHbvarMoKMHjzUz1jVtgtj6oHcPLmtX3fs/Z7fn62Kbv5YcZeJci5HMRBFWOLNxAuOln6d7YBZjRl9X5S23rKxeukuEqABp6RT3uLztH3rrUkXHVdYEC5pa4VMpC4Ypp7rdkg6KmEdrPsBwKXn3g05EUQJbxhQxPT/DcsWhsenOdxtfSx5WHplO9CaYjEykUBZJ6TCkGV7yES74R+Cei3rbXGZ6DFR/eGkVoKwdKafgBEOPiK0SDaqSUzWuWZ8WsN2xlj0oPlS3aO48C+73h9fVVEtjpGy6DavRwyY4gCirXoI4XBveGkVtpWvvws/og0LFHs02Hne/jZKJ+kI+Ypb4qnpMvx8UUrPoSAQGXNvfQge6BWS0AzM3tArbJnLcIeWKUuQxkheRCqvgSAAsLRao/7vUdV2AKqUd091TDD26V/9OWnvXBLizaXKIdGJbAD0gYxZ67wCMWG6ZQnwzO98FBLUXi4ZwwWbiPJzyXEOKa7+76hfFrG4gycunntrAYaQRtfW3hLgdia5L7HkugpjpZLKzvGtpWnxamBf0UhnQJjmYugnZz6qwZL2wCI+Aom887B1QMdY32MkB3N+xCJS03Ki1aOu+gawWyv93hHgqxbserXjCMppF38E7Khq0RSk9ZpAmR7S6FK/N0JA/docIuXBgKn9Wjs4LB4rFKwNOS0Qk/Y+QW3Pp0qrnqyEpYv2SGifHrh9Xqt9hn0QLrF9hmXMXLlrEXsjslGiGa6gRoML3HEOZWL+26mrLPWlW0fXuHghVm8AdpSUpae4qHqME5PIYQQgL0ohta2+q51JQaDrpNQWpPKZASqXQohMTQi0ijRlLxdFqkcQrE4Vw0mssLurXSNsTKjLF2nueW5tfrc8qg2ikS5hGz12/6Rnm3+N6RjJtKYl/wqT1T1aGlB5mVKBAFKQWRFOhjDso4sKyR9tYG4KSUt30koeWsDM/9u8OUMLHkKEnEr1lvDmqaasSAl3hB29EbQW1nbPPnVwz2jGAhYbaIKh/xcSX84k+iZnPJPetnYjIY4Tu3xH/da90BReDZ89JaggyOpnY56MvytQFqLb1bGG+Ve8Q6IKK7bNwYej4m90wrskcbJ7jK+e9b1WYVXlS3TOfWydLJyAuKkuaVL0Q9gu6zxusWVFYIldgGWlILUuvu+46effsKnT5+6DeMxQytc4qWXUJ6zwDliFQILV3sgta91XUEY5OUzAUeIq6crEcD0I52xlJ5BMCW3k1yeNq/sZFFjF7KHMzNjsgg5PC3/4LQPkbGukuNFqjX8FUkEpDsCAgJ20MaFljqEEHJsVQrZrCAjg+T6edblCFa8MBJ9ynAEpiFUeQpNpX9secvjkeIqFHuE+hHoTiHeLE71/TC9ChuR/w6IGyLdwiA8LCBshIPPONv3vNv3cPotKwECcEtLWQNb6/H9azgUr4yMJTke3XGVaQ2lnRiVvGktlP5v8Zzk89fXV4SNstdzANhCAF53HJcDCBfQNe6W33gDnFOFEI4ocwqVOW2kRXg0/Gqyv5c2r/GeBNZ+8twi60bbvPl70Ay5Eu+t8dvBvKZhvXCLolUVxYOCrZS2gpH47HPJiD1tbt3M1MpVFYdtnoQslRdx8ImibSyYqDyzdRJHlZmyuT2E18ADE0LgpwfS+icimCwKNiQhbeu4aFX3BwWZ73qw+XmL56Rdd5KRhyllljERxasaUfoCmIvVZ1zGq2nxqBeaHCrTLB9rOg6TpqLLlB+XjxSr36uHpql4FvkOYzPDvGJ89dKqEJZIotKbcS2Nzt645Mu1Yj2SkbTvOEK5rU0aljaEmTBB+echZIsiNqcYX5xjcrAszSlwIcxs1+sVTQ54EMyEfyqFZJLOxvqVC3qC1kLP4ioph14Oncjt8qMyZX71zioTYbl5+Ztl9FolFBdY4j/CkVcj2VUrBnmjTEYVxeY9YSQ5b0Hm+ZblUt/ClHm6aRbJtAZIVgJc3hq6mKdldWOufppA7sOiCF2YrLcUVHN1SxyQjKmQGU0LYq9e0uiYpU/XUiv5qgynnb3D+zJ9qc6U5Ph+HCk6ASCt7tRGmTa6uTjbExzdzUY3EUhYU7MseepAPN0oY6HtIFti8lncnkXRAhsbHoUoVsJdU/SyYDr8vB6TR6FrLPeeexxTINQOhpt3NMHFyxG7ChpakGXXPz8p7Twr4OMA25YEba8udjlg8Td9T6zdTg0BRP54mfIYjJXv1WcEPZ7oWsfGAKvopY61OdAVLbpmx09gtzq9OqCvvMw31wUdx9+kFwqtgLpzIPkflOiAC/Wx79JTGIWWcn2J8gkCx3Hg6empbRCm8JCpTB6bAYhh2/yc6zTHQ9NKwTKpriSLAktpDeqcE9QDxoOW5d0U3BNhrBHM0GXpy2GegXAFRGtReSLzzsRCm/QUxxyggANp658Ie3m4dLzcx9stVwr/NKoUfrABM9cPOm8UCDp+LRAP8ChvcT90KIOAY9JD0HhTZgNhQNRsyPSRwP1qy/YEshdW0oqwaABKPLVk5JmyZrz3KPBl2xpFC0AeBFueEwLxWFhva6vrvLFN4vesJ0ZE0Ts9gMu2AbSBtg206TtmMl5JEyvIBl5Jt4x8zCqFBy2lCNBR6sdCi2mazNQQyrax5fOmIGwKSJ8OXqI7dM8Hv0+DQBQI6eKPMXZm6H3f1UFeDCNG0cJ6izkGFussxAFUYqRLXqnEg7ix7nq95mMHzuKaLtPEne0zCdfr1eHPxyiNfd9xu92G6U61x4KwrfjelGdvIguI4ZXjONJci1FA0R2NEoiixyBxHPRYqVSHZlH99rypvrFV5hK2dDe1TR8jSwf2EOJu6HsqMYCFiWY7aaU9g+UBKzQaV9E2mXXBvHJaAkbG5GbmJSTukraxI1ficbyTXiyXy/HQqsPgEDU7bWLSKU04ebs3MwnC8wgIwEbFgprom5bSBMdClTVWiCUiMRgCcvCK4u9iu8RP5qeIR6wEkfVJZbN1yLiItuT0HJgVmnKybgvAcdtBT6le2xwOj95eeR7wijTvPSvk2TJGNNrfPFdlvYbeuKgiBOIfNcZ4wtgBtaLqiF5ktH6ZL0qdOUSU667GFXKeI1BZgRRinzKBsa5HtIw3y1FQ+ARlwvNzwlxVIxTLO6QEYUvLbPm4ttxYHLYDLqSREKXd2BS/818Ipc9K2C7ku2K6fQaAwpFuYyse06x6XFIKmpAQpZOa8Z7CVLe7yei5tW/tZrdCVC0Xl0NFUtT18FR5jRVQt4exMCVKpynKIJMDStAny8yDS6AkquhyrRsVMqk6riastAyKQhD1gv7OSxLr/i7aiJWDNlD6wIMrSSRsFK/6zOGsRdOLB3n5fh9/9gb6o8JNsj9nw6J+mcr6iLiC+G7zVHJDKAC3YJFH1h1x4UL+YahhE4EP4eOl0dKIabefrpNLlmONsUC3mJhGHnusHIjSYu4iMDjOk+cBKmWdldA8bBGB6MP5vHdcskP5U1qDnnBRDPi2sj0La0WpE0uVdLXj94DHuFYRyLJX6IyFM81CQIpS8lwFF0pAqNJ2CypeGbdNg//tJjErRGzLtgdYnyopUBnPimBV4QXhnVh8dUbk9r5cLmW5H7dRej+zdC/m0+WO6B1N8PbeWa+3h6/Qp9NyeGL1XmDdNwHxvmqXWHWkfn4MbUbkOrXKlDwPKHbKvIK6/lzdfOR7fs317QRBewMj0x6yEyAN/sKCxtCC5NMg+Ez3C/PhveFRQVKxu8e6roLFHc3B1jsSISy20bhuewFhZnydAk8JaMEyHpTqN/91IMqLxo7hhkeS3yfBpOYqkAZJIIQtqEFm8ZfBVDqDwxb8/JJwenX1PIQNdGrWqCe4sqBLF56HzUtf1K8nGBMm971Xn3AcQIjx+4PTiHDe7FruUq7Tp8qbqutcpXdAC2Gdl9+PlI3FNzTYevQynoaUCYlO79ibMlFs+O04cKBxTE5I9XbasqY//t5MGkm5Y9Ar6pFTaU9beoMAsKdkQaSxcmXaC0s4miFb6Dbryin06rcGy54CK7qexz0TQvkaMOqkVc2ccQXfU5jKi7lB7BbAjB4CAvnzEmjQVd2FPaYgppOCdmCZyjz2mU+lMgE76cbA9euFAHNRosjcngBwAAeVdppRaPZZKaGv+EcwCo0t8dKjIOizkpiOPF8R2sqHQSltliUCl0i4IOU0L8Wyt/IK1OVdQ+FccY4YVgIcbDgeD5WF3K4erysPIf22z2ZgUSmU+FQJAWiLxWuAIeMy9e4r7UFMTfBx+hx2iQJU3uakFYI91+dIzoC2QCVNgfTO0271Jq1Clc7I4Mr6Eun9uH9NQ2Eo2URt4aLrHxHPWqUjKJ60rnNCMC30ipFSBLlUAnIQxRpUGErZVOacg8gbQnB3B5evUhiwN9mWQzU/6cGr+cW2OfOrFYK+ALY0n4W4ycxfln6hDS+vL9jjzO/0QYi1sCqBmZ434//eDD/FFqVNt7MN3RRK5Ge7LEsbAaAUktN8Z2vYPmH4TD8V/I7xIUpdXEMB4JRS0AMOAORKkjX7mXPYPOWsHqSJwTnyAiDPiuHOyxahKCGZhqwUNkqTnOm38NnTh7Y0rVvXc/M8y8pjBM+KkmXGKtT0eL8tzFi/BRllpktDC2mpxzivockK5fyOaSa9LmIzdPbqVRSALrP1PYcUhODnGAWl+kVZG/j/rBB4457GG/Kf7FNiyzTkEVPysBW9XXI5MvjrDfEyznTde9DymFrPRl6MHKPyO++WD5QMB4q14D8NkotzjxdMlLsD5RyzNg/o54fqW+YovbJRqyE9pin3Q4vlJE+SDJWHYDBXZPj42q+afGwNhCDWLGoVIRQXi8HJ8XvHRLMErzkWlYNAUYx2imeETHgHaqCK0IpiYCVECCEcxX0lXk0kBnCQDMXMIA3acQxxJn7bGpBKWWaGbBbVhRZD2Ill8aaUZa5EvTd0waI0lqItm2Feo1CDlgRDhczlK9oTnu26CRtE4ilKQoNcSmn6sTAJwlFCLGWi1O/vev5L1abKY+son40MhW6M2n3nPCOKG/8oiF3ESb0FnS4rOCpGl6adFURtVY9DbwYfJcUT2DNOnKaG1Br/cvoqVFnbCIi7i/eqDrbclZCipkUaNdVDgTNr2ekTfk8phVbMUIZgHue6+i6SC4MtrlJxxDXu8aTP49hVnioGPRDsj6jrrOV/73xNnVef6wLUzBbCXo7wVLJUD16PNmVd5fekBGCPvnGaftu3FJhXDod9KhwHC2yfptHcQwhBhRfkkeD9kwLWQXksHV7p9VkvraVRvet5wPFhfNcvLaeQHmbP+OoK1QPm5NZ5fmjht7uN5Xf95+M+A21vQVHdtZ9n6TjtKcwKp1/KpHMLbrcb4kYXHebga0cBVEvGfk54m7Y0ilcod2UFb9uQ6Wa8iBBCErL12S6j/D2l7IH05s57Nr5l3wYOJpTzeJhuXgrLgiUvAHCCv6fpPckj9/LWiF5e7cVhWrvEeeS5nOnDfNrpTNoF/O5Eb6W4HjtWx/SlOU7xL8NKuy0dnW1dd9sw2qIugsZzlypLovn77RQKD8htu8RzSEJZhywHbisWy1ZfxLF2YohX31krT8JsZ7evAeR+kkrBCOd0lGUIB8JRn8vSg7aQ79Pd9kTbZVhYGeCPheB8iyBXgeV+ALKVPVKm/DnLb3MWpp/ee9fqT2/ezOOTeAx6CR95VoacZbLHXni0duuVwimjEHQPt5VZXvt7R8MQUZP+KdoFaN7wJuTjWM7eLIpxK3HMwIPmFGogEZPoKYBHQETnhJmSrJM2iddxfKZ5zmLe3243vLy84Pn5WW3KOY4Dt9vNDQOcq8fYGnpE+EgyOeHIy1sz3tye6Ud2g+NveVRCHQOfiHtTrRI85n0Ur9wj9Ldtk3Oe02Dp3iiGKr3axPBKu56tdpgJv0k4zGo5iddb0jtSEBbXKIxK4lOrzYBtu5abyYwP8bhQtKa/kgONUGivne3nTLktaNWzfu7xMymZa/OuwIOUgqcJ9fMZBptJm8ujXIihIDJZ8TNC9U59J4Uml59taBEj9OiTg2llELXisquW3Qh6VlYO46Rwhy6PmT0TU+U/I7Rzehp7G63BId9pS0mlrmhlA0HWJT3Ofe23eUzBwqqkb9Uyll/Xq1hybIKQGcwzRoGsl/feCirriXqWr/fpleN5b4qniXL7Sj9U9pKiC9Jp6PFTPC8r1qM8UwXJtoHu05HR0hufXjvotuI5ykKCV40RzhZ9dZvnb9VzzV9AscDIvajKg1P3KUgojWDfjxms4DhjER5i3IfUIvwrHSgFaL5JHUjEm3BE44WiDOKLohienp7w9PSk6L/Xamm1w4wiaDHOGZrkDU/5cnHUpjGlQSmFuRsKCToM0movzxK03y20FBGRLSda5ZUATUwRrjLQzBPtiiIwZxTrWhTGimWhuQ++LlIcrSH5sxeOsb9nlIb0vKTBIj+ldTzqL4nLpSOEdPy4UWo0PHC9NqiCNFLK0RkcVioCWITfPFr5L5RjMdpyrK2UPRmmeevINLVw99rY62urxFcgnv1EZRQHZKNoBt4sfMTwFuGi+8sp7oGKyE3iCCHk0NH1es1H3d7rQo6smbcApn1MSy0sLLPLvC2LNz4jddLrjLVk32vlUwWjuHY2Y76rJxoJTlagDJ4GGVmIJak+01/bVi4JGgmZOfCJlyGiGQPmnrGZ+yCWOEwvDYjjuCXFqC+1j5gGYag3GB/WqxqVUWiLn/I+9kfAaM5mBPdQ8XClsBoKOtOIIZtYJTik8TDzCa2cMpJN6wiklptnBeL1enUtsz7tNeP0rBSZ7x5oeSbz5VI17r18I/eX3W3gqSt0R3gK7UfqQuva+6exKnlP8UkIlm6v/wvH6WTxCR9rXsqv6Q7i9/2Crc2nVUpjebbgrLESW1tsDjRps1khlNTr6w5QwOW61TwExECAY9wuzy+I8d8zPsq4bx/q6XtXlJa013M2Gq9ffq8eMx6hzM6eVfRazov2xdVHLPj0ABox00y8rlMyPCs1ZFMvG2yCg8qdprbhZ7S5Fzt0KXPCJMPaTFsg/vOV0MGK4Fl2URu4ZXt4LrMUkGTyzNBoB1nBF6DPr0zHU6CUVymhJHWq4olzMJVCHUgFIngut59FZnXqQNmtwqwR1vMaWsrCy9NTDN77EDWues6LMmrlaLzSBk4iUp7FGfDo7LVB65nnObfKWzWYW/RJBebjW1tAbWF+TqHxMGrgTr4TFq5uQE8hhFI4ULnlLuPe6SZ7NLbS9RRFK054D8N4tK1aJVNlBy1BW0Lfq4sadJQDOE36R7RJ5c7x0gBJnuSfRjmTZbZoEIyXC1ZY7nPuKrAK0RPaSjB0quTx6qyAs3hmvEX7frts9aSz5CfS6S1tZ8LSq+Go3hgaGUWtd2fHtddPIehlNKPyZ2Hex1DHZkuXrE46Y+0uaUm1asi+o67Ab4VrvIFU0bcgRFtCXSqBnms/A56yacVAzzJgL9QQLeW2IIqxYrm0lN/zcRBWH9QLMfnycUmPoqGhaEN2BYSnAH0IYp2xxusbFB0cOQmHT4QScsuO7z2FCkDtjWnVfeT52nHq4ejlH6VnmPbwzK8A4HK9YN/j3JyMx8fFDHFMc0vmrmWtXxVLibH8EO7IO6rlkl/HntHX88Qsrpn27imq/rhO/KXWH60pioXAUyjhGtZQhveZ4JYrJmFt4uRA0wQLrU1ZbRi5hLIUQm2heeln3G+vzjPM5NEoB5OX33tu5xB6AsLvP085czp7Mx+XWY6HAIcaiQDckBZkmhwbGtLUwc1KQFvFlAQHU5vfNZrYr6tUMIBHE99HQeBYeqlRHanigVraUDYX7+5uhf48T1l600qoopzr1avjSDj1+JafqxCqSVM9T38Hxfper8yP5WDKtHU0ewoBpZ/Z6AgA6HoBglyZBPiX6OwuTbI+dlz00nvt0PReRTvxp71utdW2MzJK/iLF5AdKKPUi0tQnCHjwJquPHuHCPAIqF9tY/7KDWvnOlDmK6fesr9kyuJw6LtvPc25ex4dxuSLo/hWgFTZ7s/JQaufdEvbQslI9egsaPEEE6L5/hLV6DxDihU3lFGBJxwFQexMo07WJo6ofAT0jtmVUee85zShScoaeGQ8k/Ur9DARe2uuaKW1YVgr3VvgMeJa6V3ZL8JVPqNVHIyu7VY59ZgfRKCbeo1HCaOJK4mylleGlWS/OByqu0yilwO8qLu4IeANA3Z+FYlXXA7EXXiHos/QzugGstM+RcKrb2gSv5WJlWKJyIfq0qKRUrGV+3/NGbT4P5yr05sMC6VBuFdLkf4l/mY2hVDxH8agqX5bZCs225jlmxlPrt6cg4vM+rlkYybkqfczkvqlpmqdjbfNag06vsexz+a6lXVvMJqIPYNe4ogFwG1TjLGW0vIQK70InMawOwEenk3RYhWEHk03fLhxRL7ju9olB0BBeksfIuRtzxor9Wp4qVV8iCJ2XfoecjmSarPP4gMB67HgWv/xuWSLjlXSeDKu2BPD0XEIjbTHMTHmmITlrLyRjxzdj6gn/lrySdPfyeNAKHbXSjHCdgdLepR2UDzHZbw8NH8009ogwP5QjLt6W1iB3VmoH23mVIFQ42y5gxt+ldA1GbSOfnxH+ozLt72VFRAfM8p5xHpc2QmtCML5un0hq+UfOKdR43koxiLp1OMSNJmUhns5BygoBQKjPk9JZa++2tPMGe8xC/N420HrQE5wtTyTWxC/XtbpdHih9uW1ztNdGXxQGvTHW8nZahtKqMj2b5rFQDLbVkbDgKSxibuJpW97Weog/rSCrraXagwk5b/yIO2Hipe19t1Nj0eEmWweGPi7LtJxH55+BsxbfTB6ZpimUSB+cJweMP0HnicayaICk6Qxp5db5avrHnoLN0bM4ZZF+U/nt51nmOb3AnVeDhACe/OQ2imGA/llQrWfx8SFokG1n3QjxyoGR8F8FqxC4rYL4rQlqW/dzsFU4ZLN5oR4PIt2Rrl4UpDfuV8egbKsZReTBtm0oJ8wyr7OLP4/nxHWcXGgpfNaVb1WULaaNjqzpuQS9FLa/a5jxp0V98T8eOIGv6/NjhW3aVqyAXlqb5vyg+1rhkaruIZ6Fb48Ub5PDTG52rRKAsJVPUPREItYqf8Qxt3Ii0zXp0fBgzPaU14WbUH7in/jI8YSIB2UQ/476Ldb/OCLns6Wsu6AIeiLm3QNlPLYqIPM7yuJBIKnIJVI6M8uUS3SBXiEVwCvP7NyJxQdEATi3gU0rJYtH0a+M0kJvfE4NHnyM8pSf82C85MBG1gbgirLZY43GBaVA4OWfJbCiBXjP7bTP61hgEZptq2iu0aL3YPHPa2C11t7idb6fAZ2ftCh8sMXWwjXCbeciioU3F1duTvaVJ/nX8Ni0Io2bMDPfoOhw+9DJm707z6DgBPWqGc+TkmV77VgOGbxUOKSQCqE98emFSChqkVzHGf61tLXyZJoJea1LELRHRceNWK7c1Lin9HgFwTFSnJq0cg/y1WVljLl92zJhVV6ckikVb+pPbtcVObJ4zAXdbWO0GC3Kcb+TVsIlci6ghWe2g6Ic0oO4RVMZ5P0O0IJEPJf04e29gTP4ZXtoHNFiJdrM84ZhUAlX8SMIW22BRM+rkX1naanyIyTLqk5rJ4Ez3Sz+1Pbbmi6rEHowutiJP0MlDGrQ74xV2SjDyz8T06cUF4pNqNu+eDXWWCvlyHbiseT1mxe69XC59GnKh3XTODWukSz4OeDeCW6GtfARkdupHmGeAO5PBPt4T8XrnEbohYea7xKuUX75fc6CBqQmVy9OMNSshTybRuK0eclcJqQHjBaAzck+SMHfEdST7bkKPd5wPRZ2hR1gYWiTD8tpKKyedW69a0/5Srx2zqZFg49/XrjxRsqch+yqF788qDSF/hkh5gloq1wsbq14gJbM8dtFK6aRxzcLb6VArCJ9E6XwSNIlkdJTaIVqWtBiIHXdn8E5Kzg9pXbO89CD3jIjKwipgDw6fm7wbpaTfSd/e4NQPteQ/boK76MUwiqeloVahXpY2LXKRVQyITN3XwH2aO3xAfPJJu5qSLnY7WzmlWWO+M0Kwor2mEjVIfJN3+OQ46gYE3Pj3+K1dWh7XmPvR5cFWMVg82xVeLSmdVTWW433N1MKyqhdIEjhaVr55xujx8wrISMP58iNl7A5l6+nHIx1iYZfikJYgda1pMqieqBH81YwZUCEUOQupIYw/fbAqhReH4ekelzXErurhggR4fn5uZQpx0Dgfj8qOm2IiEFe3NR10U7APTzFYbDqOYo1e+9onVXIbw3TSmELQAhHHgjVigyMCbYbxurwUVvj96AK4XTyzeBUDJtCOqG8bFr1NR5AxnKLNViljIN0zkCqwLPgZi0Tz/328LMlKg8vUx5fSrcfO7btgrK1nlds2BVIsb+r9epBX/pThIQNe2wADrBTWNEuQnG9MEkzxCU9nIayL1T5Rk0jOJFo0L8LbfFZKb72pAC5n4GVA9O95e+lnkfJTZTGrrHwJXZjELVi+pbvtm2Ds98wrQI0zya8a/17JNATPxlPvNDn4W2DzxeNA/fyp9ljc9IQtTS0xmQPehGOEcxPNINXHuWS3G6atdiryi92GuPwKi9ZyJvEatHRrIcQMNn66mpuynLiCHvDeq4HOwmrw6XDlD0DKwwxEpaedVfFVsXqB1Ln2BSFGOST4JWllYDnYlOyyEN4jAUlz4eZb1/fetQp7Ga8Wdx+XDx+h1CG7TBX6ZtYt8DKVY5dRrIIzZCT51k7+Xtx7kiS4hIutSof4FvPdid9TcVsaHLET02jy1lAci/0QrBtY1SPn7cJHykhqZ+NZuNbzxRQHpK15e80xGpFl2g5mc/roHpCkZHxR/qiwg6aCWbbs2URz1jGLfxWoSlcjUHKApaVwr7v2aqlzoFnqQRVVkv5BnU6rn9C6wzkfAQ0l8UuCM5e2EkO1vvDY0NtpNN6DgeQFIWD3cyrucInviy/J/hsLpyrT4D1PSef5hZuaRzeIzsAxiFwqz0leWDXOY1Csu01MlBHizL0b/3uTZSCLdi10J3CZfyzDdIFbjfYTEgpOB7MDLPYZ5WiE/mlHSvLKmXHQUgEEOxEF6lczEhidbcocRwCajGM1yfe6ozWQG4pFDWJnOgPze4N2LYLXr68YLuU0BN4XsHllaAG1Iw7XQsQyr/K+/6lM7lOxsrOeBY9Lr+NfYveQstLs96CxVflTZuZImcFrknugxz/P8Z1a427eND1HMwqBJ2elzqnWgSoI+M9fF4Ypvd71miKfZCuDcCGPImf68VI+hKvJTt76fo01eMiftUe9yy8ydHZM6Abnwkv69xbws6LgT96EsZTbgd45yuMGk5NHwKwUbMblDAVeoHEv3J4WReQ80pc9ntLWM5Ypa0QRM+6CaIOts4hHNhvB17DDfvtBtqeSlng8eT1G4sZXzDWz1hAstBLVpxlL/Hbb4+6Ta1R0IPevEVPAfRp0hBCEJ5bsVbddkGACvA7FdjYSTIhwFbZlk5t3vjpM63T84WlnJhOljDyGvsGjpe3B76yIbYSHNmUXpkB8Qi5NFJWHq3p2zC/ha+gFGaIKVbMGagafcHdn4WtZWkSAEr+ABFCw+rqeVMPJlXgHZ8IyaBXffg4jvS5DQjek+KjNEI+fPgQ9zekbLaFKuu2vHFSi6SVBT72skbgWW5KvC121qMMFQbeE3AcLSHwOPCEdz881vImyt3ZYzrbRmCLxlmLOPPxxD0klg88L7udeZxE4v6lwV33KbTd+F7eoK0GIEqP0M4/Zgr5AIjn6VQpwQeR9ekreNVvXajOBxFiyDGVblG5PPY+Z0JjTtFNvPznWUw9q9an0dwQNSg/nWATPexti2urKNWRzanQuQMilyIHuxz8WujrfivtqucaygoYGyaKbXWAYNf5lwrnaI3s22QQtEKQK3zbtvRq8MJR8t1SaCrE86xaIZXVsIZrWEijj70TiGbMMfpSL1m+nAeI+HX9ty2eGcXjyNIo+b53npJ95o2XyovmcohSuDjRVypX4W7R16KlBc3xjACEG8qYiTzaWi5u4bSnsKoQRMqalxcU5qic/i1DazG2VmzX0nHGSpOCm3GMrBFlUL+hldEcWJ16ujQnK04HEpBX5Ph1kCaD9MFL3001ty0Ufkhnqh257lVSv52m8Z6AVligx489jzEbM/DH9NkQ5IimIISpoCQ/kqTUdKHK04JRSMxrK4/OYfgvkWNp7+GchVHZfghdh2FXylxWCi2X0iM05XCwFEtPWnI9fPK57Wj5nA/P9TtzrmHumqPoDCRLf/ac0nOpydsKiXKet5hL6dFtrbvRgEqZY1jNCB7rgYzj2gEI8prBQV2AeFR6L42o7zZYFTUbNhkaLZMGhBWoXvx6KURGem1VYK/WKc8NoS14Ml76lbSzeWU4aJRm1oiz/Xw2XLiSb0Xom5yAM7eRcjVpG8FpT8G6VL3GUFofQT2QlkqraSxztpRQQMDewLPCpL3JW37fEsitgWTp1gM93rcsY51txVjisyPlOQOz4QGK8ZgSvTfhF85nBdjsBFk7XdAfA+HkDSBrWbo8yvia1DqUOQKH+9B31d/Ou2PoerctaiZ5YASrY6yXemZ8jX6vGa+lzJ6S6dHag8d7jilc5bVTAOyasK8+0dxjRNcD4IsfVIYHECJwjAR7D0ZXdfL7aKz5zJvTDEIJer19YUrPOlytR8vCuDfEcSbueSavzsf4+uWUiUf5Mv1jHtde5DnaJMzGbR8F9wibEKKBVkVzH+V54hEtmnAtWuBvGV5dhbehZWTGnG/5N1t91BY6etCuRfkLeFYaoz1uu3M42By+FtiJJ0m3spQNrtnyvYkttqQ9BTGD64wAllbuKu1MJ7dNOA7gGlmMwlmFkBRlKB6mDTlJiAo1gDZxrEaj2GG4bMILadHxSJjzqEpaj67oSTvpGsbMTFk+AZxZ9FODvlRIE9UZr6337KwhdHbO8K3Bi5pwSNpTybMkndrR3JrFl2lbIYjQtB/06hCvXDs4qjKM8pwRzhJnu5EjziMcCEfQCqEkBMQkKW/Tj9nrUEuBMkfQorV+59dlvFvYBxvuWVGQzTTpH3UOVe5g6CsImu3i0WkVgm4P4hm/cCA4q9Du8XKqZ0R+V5i66e/luBi9KGLFAg6IZ0m1+kAfmpcyWkTNV93yK1oKbES67jav6H9O0DRe2CAy+atwCRti2GFS8+tMiTUkz04qW2gZtpL+mSZu9uYEObovSPz5UZseLO9objUYD2x79keVboK0nlLwyrS/R5OGEpdVCJ61DrDlqw/Jq+lSQ0bRVQuzku5eo6LQXJ4tT145E5HqfQrBSAu8pfxZHBHImeyNb4vy9DYglrt2i1cg6YD3Q1RFc1nP28rPsrwK8mdM45YC5RVWAsYrQxdUbk/slmKhtgRr7yBUz+sSRPtIKobj28NQkA8FahbStaTIbdmkGXnccdvzZwBf5StCjTm59pgseHH5swrCK2d+eCeTuSrTV172uwZ9w528BGsEp/cpVEJzQhtZ44WBJ52CmKTzBI5nUVoXmZK1QuKZFpr12SdSITQF3lEEi+tRxBLENzLlNirvgDCkpiDHsWckGb+24SpWdmgMHKZtEMqQSrQNRSDINo/tuyEEj8/EPco531yFexYhlx91nvQCMqmMpFsjp1BDq+MRzLOE6C/pXcyDa2Vj3kvg/EVdK+LmScpjoVMWanQtA6S8L5TVyWrD0SWtoxAtLT52h66pd4H/73pPXgShbaiz4ZC6h8bHvDA8fE6BshU4ag6qH6HvjUzT0HBHQrJ2WwphzHiZSKdQpJBIaoGAKY9lFtphN4cQp/JWKCy7yI1IyRnwjlKOZWiLVf32qeriGNLRswZDr9xJ/EzTMOV9/D4Lo5DfV4dGtQkNY68DF8Stqc0+FUp+hkd681Y/J3j1e4TMlPCwzWvpKQAm0NPIQiM6IkZa4vKZLLMVMlJ4kqtgLcL4dyh85+rphK5AIn7uaXmgtI3GY8tzuzfkf9q0Cn/Fo3eWcVwazaThmUm7Kj1ppfz09ASgRWef/trjHlta/vNGkMUMvJ7QCLavTIisLjtg/li5mu5HC65lvKGMeYujn48/jJcu8tvwbhMVoXHEjPXQfNmyAlYm3Qf+AoChd1LJSDYGA0B8UoLA4a34bMC0UmidjWM7r65MlcPFL/cvLDd0cg1kyCaEwO0j5GlN63Ec0+XJuGq+es+Jg66AF7q6D0oYaOQOz1hDs27skCqT5ijWAYgIl8sltcG4/BHkcFCDBnfZ6BsY0TLkJg0TT7n8EsELN9n3ebwdgU38Kl3LyENoCETAfd6khbQikeVwyFi8cOui0C30yT39R/CDDoBti2RMK6Ozp7j5nTF2mgsTNDwkfOTHKFlrZRq1TrTWlAgftXE33uV2iYNOXwfEhwbXeUfW7gotI+Cwfa/cKDS4o+fxh1DihqW8c14BRMlknkmqzlhInqfAMLO+v+WHKdbPCmFcf2XIdJrc1l0/XYd7LPxW+GA2b52vFYIr44fE+LLpeT4qJCZ0+VoTwRlbRHrBzzw2+Luko55r8q3st1bAft2FolJpnR8Uc5RHguMDB5CpGNBVdaKky2mccmdg/ua1iUmYuNAkhWeIzfQAUDqHI6Tfga0MgajjJUjXsWZq7WGwJR+FQ8iuqVSU0ptoThx3yrTp72O2nojT9JSy/JDFiIxlOkXYSOJYEULuc4euVljNtfpVWrJawSkxeZLd+vfbJpimCK2iWvk7gkkKgLcSXO0+C6hXpXDaXdC1IU72iztDGBKfNKMFzndK6ezVuWzxx6dlA2hUBoc77vjAxXFd18EztFoySv1WRmnivS3x6qHzlbxWAZd/5aq4bMQgLpOX9BER+HRvQlmcQUS4PDp8NAIWSn5/yHsSzOCa8QRQd0j81PMD9zBDT9hZ655ofYOXLGdUvhdGWQVLF+O/S+hIQS1wnQkn2fTSNa5CSOj7TcO6tVyM/4RwZi5ngHHiWQ6EdfLcD4UP+M+hrNPXrf7/Gp6CPxZCZt4AOVd4MiQ6PX7JfK7BklJoWdUZxH25Pu1HJPNA1Joyq+Mp9IR0730zTzRDujj5u2Qk+Tt/TpfMOBczAMWdXMw7mqSaKdbLMetNjcokQPX/fbvPSa1W8ZShrY1fThF4IcQBvKVBdWzAkawvdev05CDtewkiFNLhTwnR+Oq074LALOEKa4Bxu3G7tumR842z/ahi5oP0cqOs7ykIK9niovmlmBVtD1QigtKpsmsE7X02zIfG1wZQLlJa0Q/Lm9fOCOSSX4dwLIYRTi9007JeLCPxQLdl2TqtKKcVmFFwVtjJuhV+aJ+JNLKgzkygjQTfXZNyidFbwnLbtrE+DGyD9b281judxmzgI4jb5R4jIPywoxC+DyllrvyikPxTd3WzsfXu39mtQrH8mxMNeMQT5iUSML5/2+v9zPOgqNBPjOEZr34EB4rC5EhPCb8ZHCEsG/d2/DDWQFHWHhz+C8A+edDfqWMuGuQpQn32LhMg7tvG5FnbshMTKpI50+vgWEEr4OXTjGLrWX6P89bgCvT4YphvOHAWhHcAlGnIomOGllHZeY6Ayu/W/MFMr2VuWrTafURxUEoLlOXmPSrB82JqWlkgrCnZU7wd0LlXWySyT4LsRydHqw9CWOKbEGRbsSDzDZvMM00Dmw0qGwLrgzWkrNFWnmucuk/EMReB3xf1ugq+F2zSyPc23WQfPGhOgQudCHXYVhLQd+u9DU+6PF5eeqXNzL7r2XhFTmUdNW5cYo2rptlKvUdjs9Uv1YQ7AHmhjCckPOb0FGpLyfYmzCqCUawOztMTvj7jauVJAMj0kXhT8gUgYENcqIB+DMMpf0UJ2zbL4cb4cFjuStnN+LO/X7iJwzOcpsM3EG08EVItfdMyepKRJsJC8nmDgozLtkWpTyt/HzK+yGyF8jAjkjVf9MN+BH/vU+LjtEJBGa9sNMdOgKqvV5dMt6anpyQoyRCirSjGSU30AKVwpLaJjU1HmoBFPfdQBnqfOu2SpjIYawgu41dlZTOPhxpbf3W+mildqqC6TNFVaANql66L1Sm2LAaRCiO46c/EP1t1VQoRxorfSJ1UOoKiDLK9UvAlhSBDYkVAIDWAyDtzqU7DkvPp6uPZtrnrR3tzKqOyK6GOAOAGdqNKWtmGuuwWTcMJV5SxqK3oHuiVMf6YCShjQoaZWqJuRwgo901nWlIdAt8eVvP5aIxxOxwhXcGbV0IO6ip4rSVrdB3KO3lcfj7ssFH1OA6Yh4Cd5D1p7TqB03T5m7CF+FkU/7yMeOwxF8rCvRPVwJPodZandFqUzVrTG10UrkfVcxXsIH7EfMcMSOU5r4A6VmL2nEw4QFiP8wJL5Dee05nJwrU6PhK+XpmT+5hK+un2mE0nD2wL+ZvlBuA8j3/tPrShoxXYUA4IGkHPdypzOefrvqAU+CrEllWdxC7TcqesypNWoX42ztdvErlSwQqAuYnVoCYeW9biTAywBTZW+Qjw6PFot3FU790ctK25Gidbi2wveYOLBcimH6GtBGYF/Cj8Npt3ttyqL7KW7JXE9fe9hxGw1cjFtAMWTsnTgtlpC/UoJOG3VaErXu0ln4zGQAkT1Zsfi2XN7eVHF+p+8o2ucqotOSlhcI3bSxmhw9RjQ0eGzLwUX99TCKGaoCyvVkIOJY+nBFYm16pGMDhHE4Atb6VMXvmMdcaycSce/ZSDfPMwnsx3Sl6I03u/x3iyC9GwiKj704NzITagWLBtD3hW8P8cnkczTIhk1qgQ1TrfTo9FY6Vxvxb/IIZe5K723P4m7OGNM0kBG67APftyijGaZUQhByC5mKUhJyAzOO9EiHyKok7I99GwoBS01V4Gmk7zCJiaCH0D8CadJazQcz/tWhDpwTAuu6VQV2mbYbp7PCKRK+VNODtpqrICicH5gNAPSwBl9f0c4SQL5zwEhmJJPmqB7YpiULnARzVQKGeW5fOTqgy+J8blR5A7ey2RCd8UmSF7MHyEv1cXD1U1/2fGrx5/5zch9pTdzAKHEZy6T0FPkEGPGZ5X8Noyx7ua2FO6VarGEDqamWPXzBAylq3c260hlAb4ZTqPphm6/Xe9fAdYsQhZwNR0aSveUPvEWo/OZh3F4yyO1KRfyG9CWupU+QlpIFUMxM+DwJk+W30zHBwLErOneO8JSZlBtUTkLA+ycNL45RgcK/t5wRYaP2PfbUTYKB3RoHijJFWUSgteYa8VZ6irZ1hL9FUw/MKOq+mL3D4k36XxxoWYspZ1pwAZOhqG0IWXJOs221enwkd6ZcYRLbUgY/ltd3sMAbqr16zaPEHpeDXdRmF5k2RK0DtNaionlEBfoAdE66Zl/YUq/XyIiWmwg5uZQ1pVj7nzwRUYCDiwg0So4ggHrpvHdgfiFS67qJUM3LRciADkMmSCgHjK/tvBSGHeHz5qiogTuAxm5em7du9d+GVsnXshhKD69gjpEs04vZDO8ZEDkX+y5S3HCvMUpfH66tIRz2tK+CpjSI9jIl46GgoNmVrk8nz5RChLpzlXmh9j2Shn96WhlGVFbw6l7LcodAuDVQ4PJ3y2EnZf3rxWaZ0gqBEOwjkP/jwjKq3oWDlVSTkeKQ/dqjWqW49JMseCYKWRCm29uYDWpLnNJ91ZXkp3ufSFaGG4gqMv+Py5lyMcILLHc5EcXubN2NKWjwOQ1od3q9OEeyaYgRXreQaMx+SUM6K35cV9zXmOIi+KEO5tZFVPVeda76vOrbz7Jr+EpEzsQgoMhFfEzeI7CPoo7762NFlXxe+L4rm1wMkn8FIgpbKAMu7leB/B6es4a7Ia+wdWC1gu31DScwZcN6p28SeoUDitkG6t6ik5i/hTTBQ26LWCfOUkX09qqAh6vbgnpEfhJ6K+cNBeochrZG5rQnmuRSnj7BAySGCxadpGfcvtmOPIHAYl46+Yep5Z2cTl8G8fz1gwvRVMj4MQmjpL43COj+F6b9y23mm4UIxWPN96DFPaW8IGzrAOgXH6Ht5Q0XLJxpiMxUaaj714B2pS31jv4zCP9fSlvDkAIYN7RsTDlcIoLmUr9taMuwLdVUYBCA7TzrpbntW+ainGuZZsUkN+7ZUzMwAqRkhj0LqWMxC91zJ4i0vdyWNi7J7FkuknvVbbDHsx19P2jsrbOs1sfyp7K7odkANyZqXZ1/AiHuXRzOKpaHeMFA+fNy60Ucx8WNK7FnwXpKDVuLz5sRG0ZIUusiMTXV4l8arvZdcRgC61CFl5BlFSwb3iFS4phSWGJp44PNcR3vOhtQdERdzn3VbOblhmFVY6wVtBUegQYk54Bh59clB6wjgky25FSLQ8hZk6sdLoWV6qHkeYGP3n+2VWgT0gZD+EyqOeNEZKvwLRk9TGg0xzhpalvI2k47m0lJfGaYshQG7XR3qjhRydbub1nbH4hHbkU68PrMnrKjwA2KMXVAd0LO1nQXsPkoaRghnB426WPwGPjb0OysLX8V0eHaf1wjuteYKWslgr71yIpgVWCLw1PLSPvxLN5yeh7+fqPs94DUCD93NwoE35DA8TzLEQ4YhYiUOuDA0R1zGsuooKNd1tY61Xy3ugd9rp/R7qY4+5qIiot/2whXMQaqvQxAvPeBlxAqt6W9kLtox7T1SVcK9i4LaT8w2a4fzji+3vmTCHdW51X4n1HiZE0yq/Xfd6bXy3rUOazMuZjkIbRasx0lvHoinFdE/3Aruc1QQhe+jCSpsME83wRHNdvIufQ4cW/312no3VV+/F4xymEzRI65st7izCPGM/SMHO+Ti5KEi2eUoUUp74ZhPERQv9OHbIA/WYnvh3VNXrx/VRTWl5fB+98ZAzeGetXZ6uXeVThbvSuXLhqJWMbhXrRbbnNntwt1Jou1q+oLJv7MTTPaDoIPlcvx+FqVZAMpr8vZK/0GiFkGfJxHezk8PdidHKCGwIOCfpDEixyvn1nFMfa7cVe1lPEKvaxYZj1tFNleMp82GItGHdrs4LeAskalrzN4mhnvWxMRUPJ4e5SIgvpsVkl+aDOk4GdfsJsWzK9a4ZFUCSO0u+1Xk2tGRKHs9aIQH6rpdWWbpPy6JcU4Cf38i7VbhbKVQWd8UIVrPVSiAY5mjic94rnI33M8/PwuPwhSzwZ8GL95N5/jWXHbrMDU8htCEPhm5Sq2reAlr90Lekp7Eb/rfGRQ/67Rj5yG626pVvn41X3jSE+QTrKus6+C1oFZfyUf2pBUN733PNaQaTvQp/LGT6uQd2nq9VZm0slPz3yJvZvMvXcXoFjARwV3GUxG0F0oAS+mm8Z7qVW/roO27n2qKXRzzt5tFeBTiuk75yiMxnbLfvAtKSwD6d0xO0cJhceWw1rjPu7axO6LnnXRiSEsTnmoXe+r1S/17eEDi6FvrsNFFck5c5nBEEoiRn8zo6/h1CjOx4hrQhw4ZuirIsudQF9vAEZXtnfVtBTNQ5eSVnBbMq/zSu2rth3PzWevujkJgHy56CV5F7NVhCkut7LOJq2USqeXiMTOA+447fCyM8rfhgsc6oXB1Jc0vQ8vkz1L4WcxbcvERVhDvWYf3eXAmbM48wAyv9mnKI7yQ+yTxbh3tXiLRxJU+h423FuPcgtNiAgBAvrHZCFrwqUvrwVblcFhZajyMOJA4/OYQ3kWmPa/ZbhsYjhmodJtKGbtfbEEYskceP3l0UEs7x7qrhddfmtUcIxOIyBzXUFiMp/TIS0lX3dgYeohCXyyvf08yeej8LfIWJzTEzQX0GCq4A4DKtGKw9Lg1UC8PQx7JieHtoWf73eBN/i1Dag2/j65qBX62vmx4pOlEMl7YRrStjcd6LtTB/zAWKcRBkeQM66wYLJpPoXBK4k+URAGxOGdHS4FXAHEdl+SgvDZfhluC41eIAK/gCsXoWgHAcQ4Vg3dpST6/DbLtYW8o/xyQqBiFEOESGkr1izpR+QzyEzMY6vTgr43aPNGwapf0QxozCkWqEy1GtamjVv/2le/6kai+e3BlcJtSRqbWGdGbxCWt8URnU/RV5SR/MNmeba56XK5wETXJMybzltfjdFk6W4yV+ixMkO/9Qq21KvyepQADv9A3YoxcMQsAh+sGH1tzOqZBR5gM7DiKdsRzpdDVbRLwfvJWKMxXF3LBN9D+w4imQIDkL7wZ3dEFe62eyJ4aWimESZVYIShlItKKsYOOO0vJGzQBWq88tX/WUYcptBRm3rMmi46mwL51nWnnLkhvJ12LZnMmlZxoNrIvfXUkly44ZGoSNLcN1o5Ea303xrmKoUlV4Zic5z4FUp/NKpY9rbkgKTi+K3CujSZb/QilUEuncdiSlzOS/KWGT/lXwQ6f8ZaCFlKAbCH2hrMbzYo6QnazyqdVHK1qzZU3P4miFfMaszulGx3U38nUav6WvguG5eOiW3VMQMdT4Aywjt0pqWsqdSWPrgzTTWQU46YKP0rnzIY30vba35fQuMZwRuvcI4/4A1RxKYs7sseXUabUxMVYIFr8316DCxqasWfrPQRkLgYKRB/oyHE0LIYToGUQ652n0PIVHQo5meNZbZ7x/rTD1klKQjWUnjaq0Azyjdy3BN1VAB2+P4fMSOCeEotIIAjReyVgAC/XCuKaOIYjzixinDhl5ME5Rg1rJlQ2HsrlmRqB34kSZN3pL7RgoWXmeZ7YuZM4pltmyYgbTfiOgk040F9cJH8k2awnlWeHR8ohb+XN4Uji1s4rBhmV681Z24tw1jgQNU8bhAp0eTTPQDktaStkADCAqIa0txIjBoYye++DMHPCb7Wg+YxbZTR0tk3y1w0YTeV4cscccMo7fwu8pz/Q2/R2NMtbqpsNaHXD1ahxZjwxdnJ3cOz8p2PcZHzHZeE62z5d5tr1+DggBw8NqH0ubDIPMC/XlUozifewCkrb6kvzJN4m0jL6vtajlIUrBCsBM+N1q7v5ErFdWrUNr8arOyF+Llm+mdTSbZ0Vq4dVaFxTS36byKcSt+jSex8n8ADr0wXktCzQcDe/FKEnGYSfHy4Sgthq3bcNxHNVcg+YlpxYPHiPe8B15MmcH6giX58XOl9UKck7Q0TXBnfuLVz0vrCjrOZ52w7w5jNY/mG6dpjZIXgaKoRv5mQtCo1pjGr/GaqqFS3Z0SKQArx6KrmXh2fhM83D5XTE4e6ZZBvCph41GSonl2qG+hQ71vBVGmp3/iNk3yMO3QmChbesKFAXS9kAyA20cf24sW1vhC68ZiAdJwalCW9yPJPm3hMJWB38sUts/PGCthSbbRXuOBL89ao9vZi6Cn1mlw3NQ5TBz24Byliq2DofDCpqVwMYcjJSBbmcud6585lqZE5DHrp0LR82+m8OZVhCZFWWi1WN67h0CQNGIISDvoRiFh0byowfWkInDveai+CgIsoN4/lihPyMTLSzOKeSikKvJgpCCsTCKcBQY1O9KYIQynoIuUAGxqU0wluu8dWRpWHonhPu2WWXCHRC/8+PjiJNdtuPX5kt4CFA5Hm5aQMs4pXTJaxRHANSyWSkDZ0trWG6ang4vVBDp8fukFvb2t1Y4ntKIZbCRQXLA5j4LDosVz+cRVpxnrIzS1p7p/XQIFtfesOWJFZy98TyihRVw5nvGFe9AKysKuY+EoZMUhT0LyRoTfCBhFcZeAGt8uCEfa9dJmff2jsAQFpRCgLIdOETAjpnyELy8AyDuZylUG5Skl/ZG04BDTQgKfV0NINvxlkG8PF4H95UKgdtsUyuDLA5mpiYqkTNUO77HsUbKRfbKKFazsb9YcQjlLVH3cHkTipFevftUUetZ+hGBW5a8A7oF3rxNT3GVd9L9jQJXeVWmjGypT7TRvTAftln3XAjOyQLUP7S5KnUQdluhJX4R9FTGTHFrjX3m0uM9l6Gee2L3/YlzIEY4BP0ExFWKdZmPCGmtwtI5u3blQwhB1WO1IdUyslDUTgxIzeHqrWJAwvWWjdoOOXFNIqi6OmBfjdI/HNQAHiefoeyhk2IDVDPhlcdP0s0p8p8fxvVWPhzN8cDXBCK77c96RNZbjM9WxtA9K4/WIYg/4O3uXliHhTmFxo1fFLR1biyySmtWaebLr753+ptdSUoWhIw3W+1bhxdGVhh3ZkshUXJV57wKO/HMcxNWCWfY7ACYa898NlLMVOKdk9a6wjVRXkth82SztEgmr1/WNCRPtYQ5xpbzrEcmoYWPwxH6Pd+Z2wuDofN+HnqWePQo03KF3hHSQVAiviwtwW3QZOGMkdPPo9udA0wxXxqhP7N2k9yg+gt2T9Lbw2xbLCkFRqwHX1Dvx4iQvAKbvu/a+e9GhRE2B6+nEJaAyMxlSI3v/e6DnQjiS92dgicUoVcAVL7cpmdd04UsnqAuys5BfYKemTBF4dvHmsHuQgDxUb36WjIgLHVTyRaEkecgONtyniEGnBfa3mo3nhMoIcB1JeWlvsdoGteun+LnUGonlqTKtRe18OvF4zyvgYOAHFfvpa/LGMYUpuholTFALmgO6XdhxlaZnhKyXkzBUW98A87IFTNHIB7b0HeLmUeDeDRw3Pxy0Aafd8hWXBA5c46QxZV6ypXPbLjdNxDpTAcNoTfnJd/LBmr1ocwbzJEB95I+Cud6cCbs7Ids/UjAEm4A4c45hQpfMCaw/a14fE6etkJd3gq7VZhWChvp8BERV7gmkj2IFj1EpA6585L14ns5vmgGymiCaFZhyaVlzdCSUAYlf78DbBktBVGe1R5I8iWmysl4yBegR3rHJVy6WNvlqLIaINtTEDWPRyiPKt1QAFgVcGhlSPPHQnRprMr8OSAFUQbCQfKemjy+g+zhBOtEnvkQYD1uHgI2lsvPsNY0eQQnWWHlSBA4z3p08lPX3zOu5nEvTTQ/xsJey7+KrzVBOyO0zpZZw5zz+HPHOy2MouFvAgRgm58Q7E8Gtqj/enHbt4aVsMuZcfC3BpfL5RdR53rOZz2PhZa3VBa5HAhhRwg7jmPH7Nqx+TmFAb5HuFu9eLAsJw+M8hTx8Lk5heK54Esu57CuvnBaYc5723OqrDQXLlMKfwgBqI7bnaHLDVO0hBlRvhlvhAuINr6ywmg1iNSDr7ziawE8b3VkTXv5ZbgOITisagOKbXhUiOVRMApdrYxxL7zo4bPl9srntBwF9dKW+ZBemPZInn8nLTFt4ry6SeNocZ+CJU7QMB2Ha4eVrEs0pIf0Hom+FanpfPTgf7SH1AM5Ie3VtfV8tvyQ/wEOCrw6fwnfHATEZUfjm9h0zPzxEMvvD8jRu7cEb06hnwFC6OtQqEpSZeT7CMb0eDLgjGe/Mu7fyvuZkR3y/crciRfKk3MNK0olYSyxCLfuJtS9CEv3KeSN/z+jhSBXkdCCVePjeGxaDfoCjVmmWwWX4cScSDdv5EiVN74QrSs9iUYTnw75BQyVgZVaKnL6BgL6sWHEt4ElulosQHWSqBdZMY7i1o+HtyhndixUtBgcaChBTznaNM7DodbtG91thfSItnvYKamjxilQHLOzApKcRg2N7x60LJNZK2E2/YxXJFJOh777rmWLrlYMvn5FrAiopOqRdtbzIpR+tPiVcE7/8k188T1PqepUUah5N+z9coX8DDzGGgZ834Cfpv5QZS0KvF8IWAVDRNUpBj1r31MkHPrxFISHp6WM7J6cGS+wObaTN0i81Jq9QxFizzkm5cvyPgX7rDBa/CuhnFbeunKzCqWaB8gYzUUrVOJnqpPiA7c+rfrZz7zyaNJl7OHVDwE71eu6ygCw+aektuP3Afp2Er6qz4hUG0JKcKRXoxUt/Gw2jEBJcIdMgMZLRODVUYm7YshQxWVT6In2lFf2fWmnLBxE3WoatZr52wJuRQ2bpwBCKO0N35ubnejuxtZNSGsUTz8D5b6S2utpGTPuO/4eSmQ+h3EbY72Ffwt+b3hjuYU3p8vzC+UIxyjnKnNp7JUnWL5kx36Pn1X1ssyUeY7jyHcC3xtGWfEMcrqwfgvb2jzHvUDme99GX6OpFXssgncEHpPfM4B7axea3oexZAMr0toq8PF2KfrbUggB84JgHiMw206/hIloqXyO4+hsDB3DjHfwaOjjbtET350dmw8IH1krv3/p9XoIpoCN95asRnBTqMoMwV7l16dvZSLJS+dZPWOPSFttbloqXhHbtV7X1wxRp2Lm8dJ7K7RWoPLqVF3igXgKr+c8yTyqaYLK4tJp3Q+Jr1Gf/wzzCdOgIoOhHcYOAUrWK+sYxZPD26nMFRnAxkLLqu4989K0xlivfJVHeA78frb8HpxpkxHM0vTmdzT38q9a4b1QSctzmZ/r6HlC6+Dlf5xFMcAz7Yb3wyWn5gkW8oyYWQmAiZCUxBf13WMG6N8CtFjPPqbsid3H9ytC6sz4bD0freQZ8lxMNF22hZkoSFjAN1u+N4di382WedpTKAXUBU01zMlGGcX+S+Msoe+WCTiD54QncS/kWDobvM2EMsI4B6PBctYa8wfsnO35yHbtxY8fXdYvEzr1k93iTDGcGUqz1uuZdu/hni23gzwvE7W4WL7oOa8yzh7lJbRJ021F6R/Pe/Lyzt4TcXqiuTROOXXyLRqjZem36akh03XHwH97kcHhMD0x9haTb0tUvUmf9t4Zxv+K9b5boPxnBxs++trF/wLa3oYkPYPz54I6fH4oQe8ZqlJZTHs74eeu6Tu8wzu8wzv8YuD8VPw7vMM7vMM7/M3Bu1J4h3d4h3d4hwzvSuEd3uEd3uEdMrwrhXd4h3d4h3fI8K4U3uEd3uEd3iHDu1J4h3d4h3d4hwzvSuEd3uEd3uEdMrwrhXd4h3d4h3fI8K4U3uEd3uEd3iHD/w/ICBdMXeD/4AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params = {\"model_path\": model_path,\n", + " \"img_input\": img_path,\n", + " \"device\":'CPU_FP32',\n", + " \"num_runs\": num_iters}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NNCF PTQ for YoloV7" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantize yolov7-tiny model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build PTQ API dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "import onnx\n", + "\n", + "from nncf.experimental.post_training.compression_builder import CompressionBuilder\n", + "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantization\n", + "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantizationParameters\n", + "from nncf.common.utils.logger import logger as nncf_logger\n", + "from nncf.experimental.post_training.api import dataset as ptq_api_dataset\n", + "from nncf.experimental.onnx.tensor import ONNXNNCFTensor\n", + "from utils.datasets import LoadImagesAndLabels\n", + "\n", + "class YoloV7Dataset(ptq_api_dataset.Dataset):\n", + " def __init__(self, path, batch_size, shuffle):\n", + " super().__init__(batch_size, shuffle)\n", + " self.load_images = LoadImagesAndLabels(path)\n", + "\n", + " def __getitem__(self, item):\n", + " img, _, _, _ = self.load_images[item]\n", + " # Input should be in [0,1].\n", + " img = (1 / 255.) * img\n", + " return {\"images\": ONNXNNCFTensor(img.numpy())}\n", + "\n", + " def __len__(self):\n", + " return len(self.load_images)\n", + "\n", + "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)\n", + "```\n", + "### Run PTQ\n", + "```python\n", + "original_model = onnx.load(\"yolov7-tiny.onnx\")\n", + "num_init_samples = 100\n", + "# We'll ignore detector head not to quantize them\n", + "ignored_scopes = [\n", + " # Head branch 1\n", + " \"Mul_217\",\n", + " \"Add_219\",\n", + " \"Mul_221\",\n", + " \"Mul_223\",\n", + " \"Mul_227\",\n", + " # Head branch 2\n", + " \"Mul_251\",\n", + " \"Add_253\",\n", + " \"Mul_255\",\n", + " \"Mul_257\",\n", + " \"Mul_261\",\n", + " # Head branch 3\n", + " \"Mul_285\",\n", + " \"Add_287\",\n", + " \"Mul_289\",\n", + " \"Mul_291\",\n", + " \"Mul_295\",\n", + "]\n", + "output_model_path = \"yolov7-tiny-quantized.onnx\"\n", + "```\n", + "### Step 1: Create a pipeline of compression algorithms.\n", + "```python\n", + "builder = CompressionBuilder()\n", + "```\n", + "### Step 2: Create the quantization algorithm and add to the builder.\n", + "```python\n", + "quantization_parameters = PostTrainingQuantizationParameters(\n", + " number_samples=num_init_samples,\n", + " ignored_scopes=ignored_scopes\n", + ")\n", + "quantization = PostTrainingQuantization(quantization_parameters)\n", + "builder.add_algorithm(quantization)\n", + "```\n", + "### Step 3: Execute the pipeline.\n", + "```python\n", + "nncf_logger.info(\"Post-Training Quantization has just started!\")\n", + "quantized_model = builder.apply(original_model, dataset)\n", + "```\n", + "### Step 4: Save the quantized model.\n", + "```python\n", + "onnx.save(quantized_model, output_model_path)\n", + "nncf_logger.info(\n", + " \"The quantized model is saved on {}\".format(output_model_path))\n", + "\n", + "onnx.checker.check_model(output_model_path)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Inference on INT-8 model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using CPU Execution Provider (MLAS)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model_path = 'yolov7-tiny-quantized.onnx'\n", + "img_path = 'cat.jpg'\n", + "num_iters = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Use ORT providers: ['CPUExecutionProvider']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-09-13 16:35:47.141002658 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141029422 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141033285 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141036903 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141040050 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141043119 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141046238 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141049576 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141052506 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141055899 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141058800 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141061827 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141065563 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141069029 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141072128 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141075744 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141078815 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141082006 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141085211 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141088247 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141091386 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141095091 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141098646 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141101901 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141104979 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141107965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141111030 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141114680 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141117793 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141121445 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141125163 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141128439 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141131433 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141134572 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141138337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141141532 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141145031 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141148043 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141151132 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141154911 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141158131 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141161635 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141164887 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141167965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141171009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141174053 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141177502 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141180817 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141184658 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141187835 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141191157 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141194301 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141197375 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141201091 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141204356 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141208166 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141211143 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141214748 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141217926 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141221541 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141224705 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141227871 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141230841 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141234276 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141237356 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141240411 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141243924 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141247204 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141250357 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141253527 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141256488 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141259781 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141262852 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141265937 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141269176 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141272896 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141276162 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141279221 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141282676 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141285833 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141289021 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141292236 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141295260 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141298349 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141302300 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141305291 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141308550 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141311807 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141314961 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141317895 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141320758 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141323772 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141326881 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141337023 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141340226 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141343216 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141346414 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141349480 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141352696 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141355949 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141359003 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141362069 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141365965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141368900 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141371959 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141375023 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141378206 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141381404 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141384433 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141387977 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141391237 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141394816 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141397941 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141400991 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141404093 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141407144 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141410419 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 468 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141413419 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 469 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141416565 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 470 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141419513 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 471 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141423307 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 472 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141426754 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 473 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141429882 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 474 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141432822 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 475 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141435697 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 476 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141438637 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 477 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141441857 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 478 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141446257 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 479 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141449273 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 480 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:47.141453030 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 481 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Inference time in ms: 55.627801\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params = {\"model_path\": model_path,\n", + " \"img_input\": img_path,\n", + " \"device\":'cpu',\n", + " \"num_runs\": num_iters}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference using OpenVino Execution Provider" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape:\t(1, 3, 640, 640)\n", + "Use ORT providers: ['OpenVINOExecutionProvider']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-09-13 16:35:53.140001696 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140038020 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140047716 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140056514 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140063807 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140071143 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140078795 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140086523 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140094337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140102516 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140109467 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140123086 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140130437 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140138639 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140145924 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140153472 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140161082 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140168401 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140176124 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140183337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140191499 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140199041 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140206473 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140213550 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140221237 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140228773 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140235815 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140243305 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140250576 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140259422 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140266724 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140274331 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140281545 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140288758 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140295936 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140303009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140310448 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140318268 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140326393 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140333836 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140341383 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140348435 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140355514 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140363232 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140370285 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140377485 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140384634 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140393159 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140401188 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140408233 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140415207 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140422263 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140429982 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140438081 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140445395 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140452628 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140460972 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140468354 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140475753 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140484518 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140491904 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140499733 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140507677 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140515325 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140522604 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140530379 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140537640 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140545321 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140552638 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140559539 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140567801 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140574771 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140581862 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140589124 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140607103 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140614521 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140621719 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140629487 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140636679 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140644218 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140651810 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140659320 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140666786 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140674786 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140682018 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140689087 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140696540 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140704273 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140711488 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140718732 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140725694 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140732956 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140741009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140748159 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140755405 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140762435 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140769978 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140777229 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140784688 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140791790 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140799138 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140807144 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140814378 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140821404 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140828650 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140835612 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140842669 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140850154 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140857903 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140864993 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140873690 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140880565 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140887825 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140895529 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140903349 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140911367 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140918534 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 468 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140926060 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 469 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140933141 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 470 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140941684 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 471 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140948826 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 472 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140955659 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 473 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140962692 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 474 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140969539 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 475 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140976545 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 476 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140983993 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 477 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.140991109 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 478 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.141000927 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 479 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.141010612 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 480 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", + "2022-09-13 16:35:53.141017770 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 481 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Inference time in ms: 18.871429\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9ebxtS1Ufin9H1Vxr7b1Pc++553ZwgQsoICLYgNgANj9FDYIaE/UTFY2JRo3RRDQxyc+XxoYkJpqYF1+MPjW+qFETNXZRiRrQiNKDgvRIc7ntuafdzVprzqrx/hg1qps111773Gt+vz9Owbl77zlrVo0aNWp0NWoUMTPjRrlRbpQb5Ua5UQCY/18DcKPcKDfKjXKj/P9PuSEUbpQb5Ua5UW6UWG4IhRvlRrlRbpQbJZYbQuFGuVFulBvlRonlhlC4UW6UG+VGuVFiuSEUbpQb5Ua5UW6UWG4IhRvlRrlRbpQbJZYbQuFGuVFulBvlRoml27bip575fgDAV37vp+M5n7eD3/n33xvfMTP0DFw8C0cAM8J/ykJE4w68A/wAsgEkBggAZ1W990V/eb+tou+0P/IMZoCRvvGDg3MOnhm2s0V7+e9EBGMMiCj2u16vi/dEBAIg/223od+nhwxAx8FhnAyCAVDW9d6DmSMc+k/7qfFajz+HQ9ob1wUAsiY+M0b1Bg+E0YWZSd96hvehL8MwhkAktfIJFHgBJs7aUSBM/JnDG+FiAEjjjTWIAEPVGJUWDZxzCXcBRrNYoOu6iD9jDKxNc09KwgEPPkOUzgE8wxFgrMFsNovvtR2tZ60FD07GTAaEOXZ3d+C9j+2SodhpDpMxVgdZ4iIrMmxO+CMKvwtuW7jM+xD8CdzSp4nvZrM5AGC1XGMYBjh2YGYsr+5jfuYsHvuEu3H7Yx4L282xuzgtc04o1kjf9zha7mO1OsJ6vY50IrAEGghrXf6kMH2lvtoau+BZ13Q/wQs6EFp4E7wk+pbiG3WlLw/mxH+ql8XzFj8sv/HFes+oeVR3xC8az1r8MK6TbP6NIbz0a765Ob68bC0UAOATX/hnePxTnwngscdXVqbeelUxMCUQQzZ9QxHXVb1Ucqao7zcLCYwhMgTDBpQhs9WPMSa23xRqCATmy8ny3kdG0ZooLuBRQiWAaTT+erzaR/13LihaY0pMThlz2T6zQFX2FcRdfJa1GRgBGQSmYiCEP4BgURYC2ABwoespY5UjXTCrkMyVjoxAWMakDM12ncwFG6zXazjnBD4bxoc0p9ZaWGsTgyYSJh2KMkrnHLz3CZdGRL8hgcxDGOtsNoP3XphoEEjUWVhDMMbC0DzBEwUcgcENQe9BZOO427SdhDQpQ6WSBvN2lQnmbRljQWTCPwo4B3w/oPcOznuQAWbUgZlxuXf4iLsfj7O33AIQxfk2IIDSfBIRrNW2O1gLMA9hXAZgAZfhwKDwP53bCbKAMlOTkUFdWeuoYExjztdgax3rXBTPgqBVoZCeJRyP2qnel39TQb55/U38pYY0jbUsSXFUHFGc123K1kLhmZ9yL2577D4uvO+1uPbAmRGj0b9bTLWu03ihvwiRhYHVY2ghbpMQGCE3mh6VJDcEYsBnCyhfTHXRb1VQtPrKJff+/j5OnTrVqJdgGX+fxjDVx9RYcy2oJTTK/stvVCCM6YeKdnMhycyCVuKoLcqSpMDMW4t23HcOo7RjRjRWjCGYI/lcElHU0jnXxjPGyJl2yMwjJl3jO9fqdfzavS4+YfrCVOfzObquw/7+Prquy9oUBmrMWBvEBP205nCqyJpRO7XESRyfIWHeEScGMGJZEJJQAERrFqYuOHXO4ejoCHa+g929M5jNFrEuMYMrTpfWSYfO+qjoqLBkMMA8UtZk/RNAHkiiopx3pTAiAA5jGhsz5UIQT60lQmHpx8fUXk/NJhq8sS4yVW0FdKqdbfoFCCYoILr24jxvWbYWCk/5uIfAzHjofe8YaaBTCN70Lg44EDEFGpiyLopvJvqaqlNOUNAGxmp4QdDbaOS5hjkFLxFhGAbkWrnAGOqACiKPfVXEOUU8NY6PJfrR+Bp9HNOeasTDMATmy3Dso4alGlWu3Y8F7JQmVS74TVqYaP3jeWEXnABcCm2xAoz8yxi+arR1UUtPmViNB3FbqdCjwjJUwSE0wmAvrheyibm4jHZqRacQ0hsYR0thGI05jl2VriTAiAyYDMAMIpPRoyj9SuPDMGC1WuHy5cu447FPRjfbAchCdWsAlahPxRoL7mYASFyWHAQ3HJL7MEI/ViFGLoOkOOSWktRVXAQcNPBW0E+N2/hlu2xSRqeshyllY5MSffw6Ll1PpeAzMNRt2c64nMh91Gp8aoD135PaNzMMiaZOZKJPL6+XL8oWDFNlyuSekuK1f7GwJtAmiCmtQJ9ba3Hu3DnUy0W7ZXAyBEfmZFtrqImvJRiUQdXjabVRz41uA+R7FzmOVBMWYReM9ZFlFxY3TwvNdqGEGy4tupp+opvL1ISvbggUzF6FAmdzNLXIp2ivoCmycPBwg8BljIH3Hn3fF1aLGxjeO5hMWHRdB+77wBwTK6xxLT7zXItuuzfSvJbYjOMXVRc2uiiDYCQTLAStJpaPMYTZPLk9nXPo+x4XLz6MT/60z8NsdxesQsYYgYppJBXy/RrvGdZyVCQojJuDHynOLwAiRr4fVdNCOWf532Nlp7YScjyPlD+0rPZpoQxmoalNdQKIBAN17eVCrQXXptJStnPeJTLRgoxa3CcTDCcSCi3GtK05lZeR1g01JcPGGCeJzSPdg7KvxrDpwtwkhbcd0yaNojW+qLhw+byEtxIO8U3NpLcjlFqQAdlmaAWjjiO9K11CCdLS3K4X1DAM6PsezskmvWhnFoALTEXHO3YlHF88rBXftQqd/PsxLtTqGi+UetGpUPCNMdULTYVqSwmKeERwfXBy8wzDUOAsBiMQwzGwXC5hjIW1DhQYo6e8T0T8DYMIJDcwyIhbAAQQl4KhgNv7whLq+x5EFl1HsGH/eWa7KCw8CIOnyIRvOnUWu7u7YGIcrq5hebQSgbBew4LwtI98Cm46dx6OHHrvhMeRD957B/Y5PSneLYgYRAxjGMwDiE1gkgaMAbq/4P0AQwadUbdbEsptBY9ineB4OLZMMWFl1Nxwb06Rb8s6aNL6CK4xoCfR5kvYKtqPwlG5i7h78/W0qWwtFOLWpC4K7bzi0YYMvHOAn3Zt5CUyKQbAJsa4aJsMD0JicrIQPbxjWKtRHwkI0Y4pTmTpB/RRHd/E6LdhDlNjopKeinbyb5Lma+MeCoWlFZvI5xkeRBxQbprt1nBNue9aZnT+zjSEuGhw4X8MdAR4HmDIQyGXzxyYFT51LWjUhjLiTEDKZkRc3ETAwENjbFMbgxk+WHoUDTgCFMeVhDfBMmI0UlCt5G+Kdob8N9c+gyDIEBP6D/o7ATYoNcqhgltcIomMBSwwm3cY+h4u0KNhAqwHYMDkpAcvfRmewRqA4EMAGIV/ifErnowxgBEt25AJG8iErpuBrIm+ZhEIMq7OGMxtBzc4LHYWYMO4engV69UKlmTebTfHzpldnD4/x7mbz0Hc/QZzxbUz6I0JSjAFCymhn8hEIcTs0XUWAwAMA8h5GA/4wcMQ4J3HwB6YrbGzs4Nh8Jkio+pjchUhvOOMc5RWU1uxSfRBAZ2qTPpg9YS+Km/D6O/Q1Galp35XBmwUbxrKNhGy8ZdCStamCmChPSYP5iMYM49dKC/cpmwtFHINKUAjRF/485RxlwM8rrC2FZlUhhTOEOXToicrxJYjq4IYQG5yNnl1E84pLTv/e5IZHzfOZs1cqifXR/6Noc2bXK0xHC8QJgSdVCjrGxUI8rdn/V4WlYnEHDEfhlNLyeA2KAReqBtECHFyp5RAlcKu5Y5s/Vb0E1YIq3eCqpqtviuLJ1+4SR3hqO1q/0YZuOLFM0CMoe8x9AOidRMXuQ/eNl38GtdEirXCOVLvHVhrAUrQ57QPZvgwaJNH7gRFiuHghgEDJGrKeQ/bSViqne1gsbuH3b1TWCx2YKAuxuTDTlDVdK1yTKOfFDZhwBoqLPgLex0AQDyyeDkQx8iNpOsm1yaDO4vhwU4sua7r0j5gUBxEoARFFsr089BTdYNiUuObcsumv3OhNl53m9aptq+CINF9iWMdNsviCS4tFZRqpY33zVpla6EwJWWKPQNkiyLwuJOaRJHoIxKEWAoeFl0UivACIjTDHLM6LZNvEp5jLJ1RHzTWHKaESNl2/C0DttVfG95trLKpksMXBXTVbiauouuk1Hhy+JNgGM9NVZ94PKQm7aQolJbrJ6+lfTFaeMiZt8BT0PDWbq4A6EY0qx0RAZXzDX6Ady6tqcA02UvElH4JE1bUiBHoHNRCPvVajJg58DNTugmDdarzlCK1ZC/Cdh1mszlmOzvY2zuFvVOn4phUoCWFTVxcLbLLhYLiWCK6gnCOY0lKH0DBNZnoMlcAx8/jqBq/C6yz2QzGGPR9j6BUR4+HRqDlimSsUesnFZ2M1k+G3+wrlPS/PZ3VVn/eX7EOKlhZNR9iePKPvqVQA5h1nQAIgJExgPPHLJjUXmwpulSSBioqicS1R+2WgtaQEWZy8SSGWrhpjLRVa1etzdgWbNPjz18iHXxqWBd5H6120rNEPPrdJjinyvFMruwn4golrOEX0bqYAPYw8MECF5x7vx2RF/DQOG4lVwqKsWSH2mphUY4Xgc1l2rx+x6QGSfYpFxpYvm5btFDMaYzmiaOD0J0ePFRlKQ8mkDbjJn5Wr2YUzAzP4jasx+qRa98mrQFTCnV1B1LY8J3P5xiGIa4XbdsYCzImHDyUddYZC9vNYLsZTNcBRmbdcKXBA/GcT42/XBhIuxqRlg6D5Yay9u3ZFIdV6/Hnz1tMOXcVGkPoug6LxSIGATAkBN2zj5s6pdeBK/4dlBJqr71RiPZGgXACpS3jJ/m4m59zAlj2WSwIDOcEj1335+A+KvqvBk4UOHWcv+0GLW00NI8RUrsgD/SgD8dvvM/juSVMruQ9QaPzQH6QpTW2mpEe54YpB4NCeawF0DZtSP/Tk9fSFja1mf5uaSgEYGIc2SfMLK6P8JKZMXBQAFjDP8cLsoXjkSUCgMmIUpz1meNMaEvmTrWdxDAqvJjNeCY2yT0Uj1Ao4y7hauFySiOnCm5VWlhPFYcYfTIO0JMCzGFTWHzqzMlSUBzl2h9zOs1us9DagkYpCRvZ4E2Cae0GuENxk8j5A0RXirVKTxLx5L1Dzz3WnnB+7yxm3QzGdvAIVkEDD4YBJi7mJFfytMxmM6xWK3iPOF4Txhf3BG1rc7dUjDYpXUn4EuaLGawhHB4eYuh7YQVqKUysb6gpARWcY6ae4FO6T9hIa0FpdEshMIZiwqZoKEiGI8xy2C48DmdpNoXP5+XElsJ0SUxa/jqJeYQGAeg7QuGAhvjX5aVDHp1wrGacdaR1a3N6O3hbggvILYW8TDHvup2W5ZD/fjLXRqvUJmdarIUAa8AqzMNAt45LPTHN31hLqpmDVGaSlka9hbWnBBznh0W7LE4VhzE09xZI/9OAyxqB2seXoS4jVyiK9baV6d0QSMXAILTMwXIgiifg4+6BT+GtBBGYQDg5HQRBFKxNyykVOT1sZS/BAfAskVfGYHAOHSyMUSvbgnlA7wZBBwOm67C7s0C3mIGsDSEfBrpNrQPUw4weY+1dhZL0k1vvSQjI2Q6xrgxJ6o1tKD1aj61Fp3hhOSc0AKPo6BNwqOxf/lVrXddrbLuDtlOl9cVoPWXPteT8X9YGYO127H5roeB0slNPAehME8g1Q1gUqytseqjpppoYQbWFTJtg8U8qIwD5zATXcLzgsogCg9KPQIy6eJjTt6gZB4Ipm2FxGw2kycAzS2HsIkpEpZqDnMvIN4MUoLSBF4UrI40paKGltpIwn9OK1MnTWqQxGdONTuvq2CirLxEZuvi4WF0aOqsssxQYpTZW4IwpVlQWkAuIsdCkiNfSzag/JXonorClmYXFUbOcCGPoJSrdoQ3HyNyTOX4zhYVN9jw/WOUANtnCMVFLVXKUqkE4dBaRiKKFREWYaa55jyx470R4V8qOIYINDFfHaRggH5QsZtlAztcsEU6dOoWZnQsD9jLPJjnnoMEHI3bJCc5wXi0uAQ/AwYu721gJQQ7rwkQ6c3GMnM8o2whebJB9HJf2zSzRYISSVhmDrKtIe9l+WUUyNf2VgiFZDhz/m/EgYqSoO4wKhxcta6WYUyp+jOvU/Cn/LvqyVUnaTiidYKOZMuSknieUlOjDV2ChDIzKiCWpnJhh8TcBEmMXQlyz/jhfVXXfyBCtWmDUBhuwNtrZpO1OmpyEYk+hbIsyQyURGYGyBHFp+DHMTNsLGmJ0KjS0We235eprPa8Zdb4IkmBIYxMc5n8muNO8cKEM1FpSEnwoFrK2UWA9kImOO4UijgWzCoiEx3KvIDFU7Vx+UA58eBhZrn4zsZaoEb5U0jZn/4KWHCr7DL81DMWC52xeZNAN2iq/Y3BFq4EukObDZLiP7jmTPTMWNJtjPl8EBS3RBJFaOgoPRwbXLJkiqMvW2g553OoQQ0EVXXVrOWOumWTu+EMcb4wygi8sWSKf9BrSPSDOyaLA53HKl66Dki/kymC5WFvKZc1TinnNvq1L7eqOPRNKWKL2cXzZXihYC++S5FNJTSQEPt7gqYFOi1an0GeEVA88+gTDQiJDWb+bS953tEY2fcBt4TLlzpky12vKGU902U74I2ldjf2Ouu/877peS1hNmawxFJFLBlJ/lzP1yX2Mib51jltjUW2uNbYW/JPjqBZVQW+Uw9VYuByrleslbEhH3myCAG+MT5vJ568sKSkZYzu3iNZXC6E5Zg09rNaMwurZiwZPqS3RMZLeHZ+FQ6OqHIm7x2K+2IUNYYzOuyA4NFUSjQRULRiYucg+GzFChHk3E4+W6+Gdi1zBV1ZtzjdUNRi5CTFO9BdpgYKFwB6iKMgZioL2arhzfG7gC5vebSpTNF0osluUVq24nlNg24nL1kJBTiqWmQmF4CwMPJymdbaV1lUjLrcjIwGUSdNGzJhtcFMBheSdWmKFKTnl0yvE0UQzY0bcgi+rkTTqrL5oLSnSo2DEW8LR0giPg3fqeYi9yBbghMYxGmep+Sf/cKb15tYBksAY97MFuWZV1W3W0pqa8EalpaTHQjDQuK2mtjZFB5mFedxolEFpzZRmIqyFcCp4VAiFJVtYDc2OAInl93AOmM3m0TplCIOMZ42rqRDwDAwROmtxak+SOHrHWK2P0A89dk+dQbezEz/MUR5/zfDmvQdsEqopDFcEmIEFiGDdOniBdHw1nYgJMVbMSpGez58En7hoOakVwgG2BG65tmoa1+q10J9SGrdZS5uEB1d9b6pfqNzeh6SeE+1uKWxOEH1UbC9lv4svV9xL+QSNd7plkAbqhx4jsTKZ9DfqQNE/F3yPxsJ7OQC0abAt7X5UPyy8mjim2t30DkA6gBPqDHFztIQJUEtoWuCM4WdMc4SpkgvS2POoj5G1N/opmiIXm1jBl37CHEcyf+nAkPZDhAIfUqH8tab5TZZG/K7i75MuwOso27ci9E+kmi8HzTfNRb43U5fW2IvWiURDDPmL5jMDa0MacfHDRcXKEcOC5SBbYISOWRKdk4SxWjODcwwiyXu07tc4dVZwVwdo+CxqqoCZQ+RaEOwMwHYdOu/hSa5REaVCTnNT0OyleKgwkBVanbFQeuExZpSmnHcTUTfjgIpWSaG7peA5zoJtwbJNvZYVMjXvNTdOFs64PvO0sKjLiUNSx26FfAA1oynkWABeJ3fMgDWSqG2mU1EX4CCIGrAGP1PeTh61kmAzkaBOwh8m3TQUgw2TNsIaLisMVCc+/kOaLCW+qNVkU5v6DC67KvXGtACLvyFqW3GeKGnhGAuBUlMS5k8R5jQPDD3RXB5WI7TdRwzAezfqj4igOdUUF9bakI0Vga+1habCmzMrX81TYi9x6PGZydqomcCmJR311XwMW0jtGDiRJZFj5piXqdnPhLtC4TXWouvCmQVOfvZC6IbvDIXopgCrbAEGV09o04S032QIR0eHuHLtCs7fcQuQbXorWERZVBpBvFuRyYmlQwC8c/H0cPpe/PoyxnSiWAVnMrIkZJdITmWbEH3kiYMg4QweK2cSkNZanCMh+iY+W0Xxp0pM9uIYST1WxkburQ19jmgdY9441YIOr7TWH3VLIWx06gZQVFg95CILATsyXtZkV8kKYOawl5wERC44ck0AqIcQV072TvOFxx6yL3MGlR1VV4LIGGMUOnFsDWm9wX1TuKhq4ImUOyIpNCoF8rYoPUcGh2q4DUtmU5ly0zAotZkJo1bJmaMOI8+LpGZu3icRUNByYQXEDiNcIy0szrP8xzvJD0QS7yj3XgStF4CEtqplVgIvbhI96h9RyzLzlGnP2YDSpqpo3ZL/0xR6pbRpatSWpeA5lCxH8oEBM4BpbTWiKHBEJl0tlFEKId5UF5gyWNaRiY0gWiaI7p5sDZCuDgYxiSA1BtxZ2TtgB3Ye3vfRqhkLwoTbYjxBwCiHyhkdh9f6jSUNQxbrKfGwKqooRA8hHKQkT/CqSGRijkKAinceXtOWZzxKrSdmit5rUn9EpWnnVr7AUWo+HpWwCDjNlm/6NsCgwjKPLoxrpf4Gme5QM5iqcsmfOSkfRNjWmt9eKITlocw9AdF2iyC/MSpAqf+DpsXNGWShwWaIp5Ih5hp4OI2WwRj6Ix+Rom/y1vOJouy/6U15gGj8VQljLTya2mKY0dzSFQ27ff2kwqXtTDOP47WdZHUoY1Hh3nahtExm7Ysoswezha7WjVph+TjqtjR4gBvvSsCRFrRnsQBVAwr+U+iVkpV1kxh9YAYKm8I1Yarn1oi6O2UMGKW+SXI/719GLRE6Y2EXTxBn80pgubdshAeu+lOma6FuW4VCrCxC8NREmEaMO6KFg6AJ86XXZJIIXbFYGGCHfr1EZyAXRbEFjSzlchXlfUSh4GUPi8NpaMl55MDBcnDDgH5YwrMDe1QuSuEVngHPfVACdBFxvCSrTB8tuX8G58AaUAGWQ39kQLDh9jyCnh1hiAuciSRJISmrEQGarHhNupkEUTlrQV3WNRHnUhUy5aQ+0/9UQeHRZKm8UJaZ85Z4kjzCmoQHBz4UyZbrGWqXEybEK7VvvQOWgtlZ+Nky7SQxohwpNZMtXTibmF3uSqnNMV34XLQhibj01OzIxxgmPgofSuJjm/2K457l8OX+1+nNJzWl03et8ddmcembzxhSwbAwql/Xax7U0pQOVH6vcExlks3vMyjmCtkhxKr/0diIQOwCU0gLyYUFbxv9ji2YKlh0At5cGQFEcwYlra/OIJt9iezD5uvyuoHsqsTmN1WYpa6lKKiCdkrqOqJ4T4TE/1NBB+o+UPC9F+lOYak6x5KNlQnsPZzrZYV7xtHRErPZHGdPn41yqp7LHH95n8wslgZ7OCcp1wcvexQ8yL/VSv4dHl5F7/q4D2Bncxik29+YGat+AJwvoo1yV6PC1Lo0SS0Eay246+Se7nCFrrbjicIhQgNHXnSOMF+EGUQRTZdIGRAc531lAQMcboRTmmLlMzYoOJliwixZc6OgyfCJQHcZaUbaVTbL2XqUD4OQkSAdD4wuxp0qJ75PIf/pvS4zdRuUp1C1ngshZ2MLo4rrnea/E8zWBEFVaXxkgiZYEW92NSMwZoo5XH9eRQlz2yPnOUz1z/+dhcYKTAFH09qpPigu7eGSgUz9jG0ZAxsEkh64I0io9BQDaI6jYf1M/a3a89iaabTN7cegLPsAUNH8mOS3sfwADzIWuqGsdxdQJkhyodq2+uIgRUDCwrsBMAbzbo69vQUAEfbr9RoLazHrOjB8vHazFgj1OCJ9uB5Dv8by6AiHh4dwwxrr3mEYwvP1EqvVCsPQh/0GBlkClkcgCvmJENxi4Qa3whoNQmBwNKLDeuwqYHJatNbCGgvbWbCXQ7F9rsQFG43IYBauXbWzuVyaRAAwE7uNCIQOBGDwA4i9uDvjJnxQpUOATAKUwOzSMa0GIdV0E62BslZmnUm7RHJ4kthgQ/acojyiNBfqKkBAoN4UVU/a+Ju2ltpaDrXmUQgRIHNZpPridij0F+nDmGhKtuAaMzNCK4qqBX9d6rjpmpm3NP3SjTHGz3GCoWUd5PDW32zLOMPDaCnkVmG++ONF9ccw3vC0eJ/jIFcm0gBQ4ETdkmbDOI4rTbxP1DmuXoQxKElVK5v7bgjbSVg4VSfKrWsKnL4tBOr9nrQ/GFwW3gGe0XuPgR1mizlwGiBiOO/CXRM0dkE01kFOYw8++CB2FzOw63F0cIh132O1WsVopvVafve+F1h0ryWmxICcxIZ4G1jClTJ+QXKWgtVlXAWNVIzTeQeyBm4IYtQQhjgPIuQ8EzSFVpqnkD9IBUrfixAggpnNklWU/TMmXXil66/rOnjPMQNsMU8kPArGwAZepanTPQhuGKJ1kxIimngPCHxpSTOL8sBqKwzV3sdEeRRyHymhqktAXUwiX0cDF3CRTOHsEcYMa1oblfpTWnPzku1aS5vQaGs4ty2qxU4xkpZp/UjKSRjWSS6Az9tMBF0zoVRyl9gULFGBgEYvdZPWwei7TCuNKoEuvg3wbxKAk/hSOLllIUz3k+5qrppDYvrCs8dMO68DHEN1oxfywBCFfFJjpUvnr+hDtUmEvRpPgPdYrla4dniA/aMjnL/9cfHAavAZgYPmK4fS9FXZlxbvPeaLHbBfo1+v0PdreDdg6Ffo12us+zX6oQ9RPXpbooj6/KImTV+SpqZUIMUVqNq8+unqGMfQGjNi+gkiwBE8JA0Ic3hG4kaSAep8MShYSS7bQyEi8Poo0aPnkjYzGiWSUF+5szvjPQZiBWUKgiGCc16YOaV57oKlEz6G3qtdpBkHox8GkCU5mW46kOnQNSzqVjmhUKBEHPmzVpUoLMLvUOIPjKGaLaKyLR6/lOfMGZLyyIScAWiklDKiUCeT/gWDLCyD3KwbD0+f122npighofimMv+KPptN1S1nQI37PF7A1f1uX1RDTWAE/3y4HCW/B2AMdcAHI67qLN4r4StvXplV/jSSXmahNPsLpbKqthm1CJ5SIJQuktYk1RbpWHAyyvnOx6iV04ahbJoWTTQFQe4s0ifpX0N/r0DVNciIt+URMFvsgIcB4sVhDL2DMR2M6aCq39ReWPqvRPV477BYzLE6OELfD8HtN8C5HsOwhnc95La9lCkh8OGaIrKfBTcJxQePAQDWsObksaiwEPbos4gwJMsztczJOo0kzGnfxieL0A9yJS37bCOdXXCvpxYVGnV9klp3BjG8FsFdRQgpr2MTBGsNhhBGn0J1JRRZLm3SThjrYZA8WiSCwXYzzGZ6U+Xmsr1QMDbNGiVk6fFxHVCiF8nlnS9mwbEHjylWkKP8MZsoeZVpP1EgyKTrZZDaR2QyrPsHmYZMuhcvE5zz4wR/6lvmq2GJ0FiwpD7a7KdmxrqvINEPDZ1mgpFF4sdYGOSHoHRjsYbhJNZCPT4xQitY84thWtwwC+ckZG6i8F4EQ9Jck9sNeT6vBEOASesZY8Z5fJC+m7Q4c7ddVj93O6a29KaucnySBjujzfhN24WTjzvikDlmWSGgjHCiEVWEzXmCoVkRuUaMeLOb0k7Zf9lYjLqBMGVvGKbbxR23PQaL3VPwHnCDw9FqjW6+i26+A8mSm9aHMTp2+dsTQGFzlUGA64FB9gvWwwBPQO89etdj8APSFbMhBFgtbQBkEk6kj+AeIqV1ZAsBSeYFXAbRVOAuMX0uzxMhfduoHB8Uoi/wQLEOEg6YfRAIDuxb0ZQEhkuwSbhXyDCbSIM1kCBs/sv/DAYvbtVhGIJg0v1bG3Ep68qAnYt4ICKs/nwshVZpMJmGqpIWIIec62X0wPUUXUQ1BCI3EjMYQcyl26kVbRO1y3DIako70nLc5nHtXqgtGQ2hK8awoYytgwYDakRRTeF6m32WKHyRFlGxqMYNJIGwhQVT77HkkT4+SEN1g+W49szNCKSTFFFYyv2dlqBPv1LUrvPxTbvOtoMhaslTn6hC9qiU6G0GAOzunMJ8Nsd8PoMxElG4v7+PO+64E7s7uxJ0Y8rUKIXioC4RAAgHUfcPDnF4eIj1eg0XzjuIdaDKG6EOrY1nITIBGe/RaFHalugYC0rk+uW4vtKkauWZxayKUImD4F5zISN6vA4zhzVYF3FdpSHkNB0FhNfgbaAfhqw/jtJPxlT1RTIfPkutsy0dPuKb1yZdFw1/r4zBpPFMADqphU/BhIZgaDDyln9/ytesxGAyF0QLnu39+hyyapY+RtEMxrAUSkvRX9JK9O9oqWVaa95eC8/1hvcm4Rn7NgRjDfzgouD1uq5zLTRzlSSF+HiiHC/YsdbvvYQjDsMQx0hV+1MCsBY8tXKgFuNmwUlJQ46QtcdRC5mty7EawbivCF/LwgxMb+w2ZVmnqpQaSYrtBo+VG3Cwfw08pNBXlVYFI1TvAGUMkj2YHfr1GqvlMgYMWBMiAKkD8yrWL+hbr/TkxtjC+wh7hYyT0tcUnXCq0Kyf/8zhd07dR5IcnLlODaTte+ipKamrZ04Q+QGQCZ4G/EqxTb5UaRWibGznQgUeQUhqfvNV8qNrCBTFgzGp7thFssmdsWmCtxVKWjclotuu/fg+2HIt5lIf8GoxpVBZ1iRrHpfUBhFJEjCTmH3+XS0YZKxJoGZVx7DLbxH+EYPfgPtxO/FJJLCkXGWaNaoTz8zF++PbT9/Vc1pHc7W+r4XhNn1OW1CbFIZYZfTuxFZv47s4V+paQuMdEkMq5peTuyAbCup5GClMpsODDzyI+e5pzBd7MCThm+fO34Ju1kG4tLgrakYuDQa7gz3YOTjX49q1a1iv14lXhPESUlj2yEIDEK/NlavcCmszm/3UMaVvppScKaWn/ptCOHvLdVfP0eQ/lIrbqJCqhsFq8EB0owGTlmDePqWHBa/IVOkIh1qX27qOr+s6ztxcGktZ3ZxLG26a+6fWTuX3NLbUVy5syjKayAy+2GZASNIMtWZ74daMoSBSzk4VU4n6Yt1lMG+LfMETx8FTehE1400afeqnxYjGZLIJjrI0tLCJXjDCTQlbySx1IWxm3NsUCporM8vNWsOAnZ2dQjBsEiCNBovxafWoG2xqp9l2CGs8wfha62Oq/aSoT1tgpaWiTdXzJDO7Wq2xWjv4ePObxWKxwO7ubrixKzDnwDBreAFEx7hzA5bLJY6OjuCGQQQGM6J7VO941h31xOHAXG7UF+7HQkvSQbUY+/XQVGgr8IrMdhzVjAEWGaNVl45YSrxBKGhYd+UqmshY3Pq7hDnKhdi2LjPORkIb2ynLid1HtQ9tJJGzk5ootGc9BajUqf/x8SlHgsvaDfMyGhAFxl9p/+XCUrqRzZ00IanhTInKxpA04dzFk8Nt9KhjkkqxmTFOwn8VPkqTVNTUNkYMqlwNmvwrdxm16hW9X+dCUXzqdnEhajKhlPYbSi1//FUpFCZ7rhhjrY3p9Y8Ao+8HXL1yBYs77ijqxwy0CWBtfNxhpXGF0SPHH8V6gUbKxtMQQ5ig7J8BQEUPucUWPvH5Zn3OiyqYKjURXGnIsT5nH2SCIadRFx4yEy5duoRbb78LXddJe8ZgZ2cnXrUZ3TYxVYXJ1lJokyUSbegHuQ9ZN0PD+hX3CsPzAOYsH1G4+S1b7AAIxFXiPZBcYlewgkBjlATCcV6GWsGSbXFNY5HTdvBwqAAm1eyV63LElbad/un8IK53eULhsCCilSTXEqSUPSpYmiWnBwb0lkYZAydY8/9wiJp6tO9ozhGZkG4LRASYAXCIuU2TY60t0ztETYeyBWGQjt3pAGQCRpoyW5WTxZojQrz3Nj1kgFMUUiE160WHhEsPH/OexQ1tUmGRC4mkKSQc5M+BPHVG5BMMELXzDJVMV0Gl+CFluaXK99ovtiwZYx8Jn6QFMYUEc14Q0ZGkWiZj5GyKj6Kv0EpLONppLepxtP7Ov1HXg0HIHWU77MwXgPOwtkvaZTWzsUlTz7hiAKO5EIwzwOn8iYo/owpNlr9CeHpwi5ix0G67tCCLG4g8PIYrIhO5yt89A0aj+IRBMwuJkdeTzmKpJF1GFZCEVxPW4Xpg3HPvA3jGJ3wi9s6cgjF6V3IH23VyT3SmwYswcFEb1jXv+wHr9RrLw0MsDw6lN5JoGe/l3+DWYW5NOBuRNlLzRAw6zxFvUHop13uJx7HwrfcB9Pf0TvVplba5Z0HWZ4oU0u8zrR4StqvJ/ELmKOEPembChI89AmN2iWkHASD8ZayYNN10kY8F9TUoEvWKMYbAjtPM/3lZCq2S+zYRwA2ct6jXcq3kk6/+/6JKw0SMr8L7aQZS1JwstZ+1NLVjEF7GFMZNprEJo2j5qgvtRLVdDn7M2t1xzNiOK5vcWLnrprVo6roUBLwKKvFZSw6Z3jn4oJVPtXO9LqJNReEiMpjPO5w/f367fppMedrdVPqxNxRG0qahii8dR3qFtlo0x+UJ5Lxu7IDqjXMgnPEGE8csPFMgOOfQ9wOGfsDjHvc4LBaLbC36GIGk9yFA1wMnRQ1IYbzee/R9D+dcTCfR9z2YfTijwCBIagiHFZAx4kIQt4TntvPQwlX1bEyj5bypUDiOnnLc57wvNR9w5RDnsnA4ZMUniVPAOpWcUhvhxjcRNi/f+5E6sLlsf/NahYB6AYnZS0huohazrfYSKB3A0NZkLekBJ9XJfPF99MXHGm1mVLgxGkid9j9mfk2itHnK6rAgEHym/ZffTrWbj98YA+eG0WKoABxbEIWWs5nhbsMkRxYYlG+2tPhkDQGI2nq8y4vG89DS3jbBWgtGwwAMFfcy5GM3VeK3jfgIqyiGA+b9xnEcD+tUkdQD2lawElQlzPrJxxfHy+U+WHQjIQmMFi3kP2UdOUgocj4WTRM99lt773G0XOKJT3wiOpvYQRS6RY+ZYhBpRuD13qNfr7BaLbFcLtH3EoI6DH2wFDSFtQ+pHwQBSmubhEL8XS0otNd7CzdTz1gByNe6vBl916JN5Yfee4DVYyLj43g6u1IStH3WTeBphSznE6XLXoEKdNHgrWU1wdhJrsC6ruijvBQEGZT6ZFKW300y4WBVxBPHrC0e8/0UXaiVuaW2PG57SivJCLUhfZN7p80cR/BTPsoKFnlQtLVpLMcx41aZsmam+shAqt4BKhTy8xo5Pk5acqY4BcvJG63/HGujRKr4TPVH418jqCoOKGrx+j3pa3V/BHN/27E03Yv6e6YomNg2xzXQKpqTZxgGHOzv4+zZMyNLR/YoqgNYSeqpsRLbWy5VIGg+Iw/nXDif4KH7CBz854k8pmiLoWdt1GJrDad0X08rZXXbOpCovcdvxqHEtRJcuM3j7yiYfbvXzFxQ2LXdTdDW63uLdRVbDnzmz9V91Gw8MPZtSkK0LMIoFXPHbOqtyRuIqJkTn6M7ps30WnDUv6d9gPCfStuTyDyTquTQcq7plFEIeR/xJjiMiW2soeXtT1shj6SUriRA2U6thedsPn4zpdltIFyitjArNCNCTCswBa8ypm0tpjFjoey/jcNG7Rah9mKkidA4AZNp6wO/Ljj6Ngu1RZv1qiDmuPGO6IJV4aaaa2oj13SZGbNZFwVx0XKDUacXJVyrlQgEsQ40rYWH86pRc4SPwtyWc5HwT0QAcZFePeIPmxW+7YpaCtmTlkaelVwYaBtyJ8K0opqv1wLmStHjBjz6TautsSXShpvj2vxzEAp1wjMloKjRZXx0KnQtAzUSbXMghVQWvb2wvnKGVXyn9TN4Jhj/pn6l3dAryaRr5IFsKqp7a9RCGpMKlBCDXKsDhgieDchIW9baeChLB05oCIFcg8k1jnIgW4+5LpvcPZQdGFJSju8rRpe07Smmfnx/eXutv8sFMjWi/H3VVwbMBlATPknV8IzYc9gyTZMrZ1S0JNprP4MoaK/JlAhNlwxAL2jX5+qT9mAQc7gkRuoZ2Kjgq+uCSPz9i8UCT33a0zCbLWQDW9LlhL14U9GfjtVEWFUJAgPDMBRWYm5dKmNSZU7jb8oTyimdNRGBzAwdJcGrQo+ha72M9EnTkOOqmpr4XM9NNXgTGOD8Up3xHSixX6bAIwDOzyKp4K2+8czxsqjEB1PPeR+jktMOc4inad8LAgCUzzsQD10eV7a3FHx5/21kugUzABJhZwQT33N8J9V82UiQuOXmShA+yY6otKSkPyQGlfIxXb82IREBxkvqWWJZLaUWlYhKfZSSrkKRkWlCemw0sxwk8iItHs0+qe0VwtFI2N5U4rlR2UYYVILlOHxxuC8sJUbI0jxkMNc+4Rqcbeal1spq8x1I51/GCztBnLWY/qv6isKuaaEp/46a3xfFO+V4UoNVXIpKUbgGg1UhFB18/DmklPeXaEnbjRF1oQ0TcnUSCIY0r7/cmMYUeJUJtAQnEUQZDpbLFQ4PrmH39Bmcv+tuSRAXkt6Bw/chJDMJYW1Dx6UaKABYnDp9Fl1Iiz0MEonk/BrgPlzc4+R0s5Nso0weHMJTu26OmbEwxgLWyH3RROijJi3/NDQ6CYOAXb1feoOll9dX60nGlfGoIPRlCedrjaE3K0jfvnAdSat6DiMu/xF/NAA0pDy/V1q9JpOAa/ZVhyyykwENBmiudx/oUNt9lHMfqbRULbpeiNEPDkDF01M+5hPwnBe8sK45avs1r/wNHB5cw2e+6EuLGq1hvvX1r8Yb/+B3IhJe/BV/A+duvR2VGMUf/NZ/g3MOz3nB5+C//Oj3bzvMVIKJSyzM+Eu+4duxe+o0ypMFjFf8/I/j/g/9WWSEKTRN6s0XO/jyb/5O/Nf/8H04uHpZvgqaQi0wc4Gg7dmuw1d+63fhF370X+HqxQslQyXCZ3/xV+GJH/XM5hAefuBe/Lcf/zdgZnzx174Mt9z+mFGdV/3Kz8K7AZ/5F78SAPCffuAfYXV0gI9+zvPxqZ/7xc12h36Nn/i+f4CkFSWeykR44Zf+NfSrJX7vV38Wylx1rOfvvAt/8W98e9SUKqTjZ//td2H/yiUwM/bOnMVXvuy7xhQTxv+LP/r9ePDDHwQZQjeb42v+wb+Y1Jp++7/8R7z/HX8cDdiW4BpJixF0ZbV0KUr2InNE2eq7+DPI4lz/zl07WleZcj12YoScNslSck5j/gPn8VwyGZ8Egw9XmS6XPciuYYnlgJpJgmMTcx2NOgxmsbML082wCBFp3jm5M+HoCH2/jocMlb67mWTuNJbQ2ZmE1EIIyZOkg16vVkG4iPuJXbrISzTxoChl66lURscH+JIR1hgj50IvV0ZkjLnrTQNZU71xnz4XLIWSo92RzFVQFrmlzHpOH0CXDo8Uv+Z41EKbet8oJxIKrd/bi0sAv3ThAXzgvW/Hs5/32QCAN/3hK7F/5SI0FaRnxie+4HOws3cKD9z7QbzrbW/Cp37Wi0FEeNsb/wgP3f/hgkSf9Umfho/6uOeCiPCmV/8unv+5X4QHPvwB3PfBP8t6BcCMOx//JNz+2Cfg/B1jRjhVRuPItPrzd9yF97/zrXjovg8lgJhxeO1K0PbbhEZkcNtjnxDS2GKkmSs+a5w+6aOehbuf9kwYY3DH456IrpuNYHz+i/4ynvKs52B5eIC3v/HVRb93P/UZUQgQEc7f8VhcvvgQPvjuPy2W+2Of9JG443FPwh2PeyKYGcZIKOHe6bM4ffZm/NH/+OWcYwUG5DJ7UF7PZzt4wUu+DJ4ZT/24T8SH3v322HcO82y+wG2PfTxe9d9+JuTRL7CF9WoJALjj8U/CJ3za5+L2xz0Rr/rln0G/XikIAIDP+stfhdl8AQJw8/nb8Skv/ELc8fgn4dW/+Ys4vHa1aPXTXvJl2Nk7FeCRfup9j9zMLiFCpQgEVGTftsomS12UgoDBShiUfaReCvrghNfRhigQ0jTUh/8AkJ4tAFbLFfb29nD25psBopj3iKWxsaFJAo8ElKhlJPXIELoOIJqBbBe16GFwsLM55rMZXN+j7/soHAAR5N1sDttZyfWvGjoYDCf3KQciG5wLFoyD08Nfup40p1IObsPtlrs68w3eEkmh/0xpKTwcSFaK6HaVmshxxkbrujXHUb3O9OxiExvI3E3j8SmFUPW87oTQ5tOtcqKN5pYJnz+vifCh++/B4PooFN75x6/D0eE17Ozu4oF7PwRmxrOe83yAGZcffghv/qNX4VM/68UAgPe+/Y/xrre+MRqrRIQnf9Qz8bgnPxXWGrz5j16JT3j+Z+Gn/90/w4X7PhxGHgjDe3zel/41PPnpz8L+lUsnGWJWZJaMtbjrSU/B/R/6M/zJa34P97zvXeF1Fno7wRx2dk/hric9JTWn+xK0KWWFlFNnb8Ydj7sbeTrsWoP4hOe/EKdvOoe3vPp38Zrf+bUSemPw0c9+XvHsg+/+U7zmd36tgPZTXviFuPn87RiGHve89x3hOkSpcXS4j9f8zq9mffu4IOKiC+0YY3DHE54MgLGzdzqDOcEe2/Eer/vdX8PQ98XY8/Hd+pjH4dmf8XlgZrzuf/53LA/200Ihwmf+xa+IeD9z0y147me/BADwlv/127j44H3FuD/lc7+oxE1LwypyVmfv6oHkD6m9CGM4detdc2EmnJb6ZgOiqOWWSkXzXu1Cu0z+d++Bvu9xyy3nce78+UKFbjHTovM09ET7pHdxsxxODtq7ZwIZi84QfNehm81gVxZ9mHeyHYztxEopOKsLlhSh62bwnmGMC698vFAmuiu9h8MwWkOteVZDMN11UI8wKZajkfOY0cvj+m+1Bltqxhg2przfsk11Z1Gcd0pemQkmP0V3fy6Wwja73ckfFxBYWk94+sd9Mp7wEU/Dz/3ovwIzY71ewbnxhBaSUv3LRQVgvVyi62aY7+zEh+vVEQBxcayWR1ivVmmws3k0O1Xz3FwIO7un8CXf8HfxE//iH+Lg6hXMd3bDXMjA+vUa6nvMx2DtHI+9+yn4/K/8RgAhsorVjEOMXprC41tf+3v4k9e8Ct1sjm/9lz9RLFb9fb1aYnV0iL5fx3eAaOPdbJ5GQYT1agXvhmLtEYDXv/I3cO3yRTzvL/wl/MwPflc5ejJY7O4Vz9j7qM0nzUvw/rP/5p/AeY8v/vq/V7wfa2uEnb1TcH0Pny20frWEbqB757A6OoyLQosxBvOdPdFmjabS9lgdhRO0VX/znd1i8TRdRvWfmdUQRWRGixv9m9uWwtmsP1i5fQPOIADI645Ds3t9bmq6YgfWqx29MOvdU6ext3c6RvHl7rCcsaUxk/4/CNKEA2YGTHYhfeC+dXSd6TosrIUL1/aSBdgkt5C2pWeXjCHM53Nxy3oGd9JeOvvgMQwDDFN0TcU2MiVD181oHyHjK2SM5DqLmUtz/CXBOpoVIjAnZSoX8hE3GNOeKAHBHeh1D6ryGkQXYUoqGHlAVC4RlcepPb0cjuPKiS2FjdImmDkq4wCkG6UUqEoS/tQPfW8yx/J84vo/RkxfnXfj3IB//z3fjpd+y3fi1jvvAgCsV0f4oX/6dwAAv/1LP4Xf/qWfKr77gpd+I570Uc/ExQfvw0/8q/9jw0jHwu9rvuPlzZo/93/9M9zzvneOnr/gRV+M2+56An74u/4OvuV7fzguuNa8TBENgPKof0VkP/Ld39rUXL7kG78DT/jIj8YD97w/fvPT/+YfN4ni8/7K18F2HX70u781g0Hq3XL7Y/Cyf/WTRf0Pv++d+H++/zuLZxoCDMh8F0p1gyEba/HN/+LHijZWR4f4gW99afz7HW94Nd7+htIlRkS49TGPxzd81/8pf4d5uvfP3o1/+S1fPsLf3umz+Dvf/x9HY95UMiv+2HqPXqENf2nJoWrsNeTfsmyEUsjbwyB48mAaAHTY2dlFv3aYzRbiy4+uiHxznKeZGosFHfuM61Ncwt77oP0CzrNsrhKByYTU2AYGgKOQ79972YAJ/IGIYDGDixdlMYxJewcAYG1yZZrOwQ2rIkClDlIY0X5jLWjW1rJatn/QZKrBhUYd8g1oTfGe4yfSfxqqKACQe6jZOxGGJvG7YRhAPnNRhefOe8B7eDIxX5UxZiQQyAYa2DZABSeyFEQS1ncQRw1G7KsoUTVOhTOJ+4Vf+fXoZnNceODe0aQRA12Ws8gww2Q3B331y/4pbr7lNrzlD1+JP/ztXwXCDW6/9OM/iE954UvwzOd+GuaLHXzt3/tnAIBX/urP4d1vfaNAqERLhD99w6vxv/77LxT5kcamWG5Citn6M//mn+LoYB/R0GPgq//e9+IlX/VNeOPvvQKv/Z1fC1qtD4JQxgQnIabkg7VAKbyXvZdbwzSNcBV9RJSfpk4ac4RXCY0IZ26+BV/xrf8UAHDqzE148x/8Dl79m79QfE+AXAge2vnKl30Xbr/rbrznrW8oiPbzX/pNeMozn43LFx7Af/63313QwW2PfTy+/h/9IH70e16WwpSJwv3Act+eBiNknk4QET7+BZ+D533+X4Z3Dj/+PS9D36/j2pwvdvA3X/7D+Kl/+f/FtUsPR1jUf/wFf+1v4wlP+xjY4LP+99/5Tbh26UKpMIQ5/owv+nJ8zCd9OjR9yE+8/O/iwr0fGjHbWgZT9k9JgIDI4CJtZO6WqFJDtXQu6Sebo8QJajgoXk4PoLiO02EAQYWutj0+eR3XksnPWni5mN73gB/AzqHvl3jjm94CIoud07s4f/t58GCxdgPmi4Wu5jAul/oi3cMAyFhhxiYlrLPWAh5gOLEPnAcrM2OC5CozISzSgOBlrRT7ShSlcs6eI6PTdRIsCYIwPXIG1hp0sx3kRdxMkl5D9wWEzg2YBzgf9ifUDcUsIeTep8xrXqOMVBs3MF5CSxHahBVhlcJxBfeeDQgWZGSPSQ6Q+UIYgLONcitCNb/nmWRRxbRJxuhtk3KGo7MmCE0CKL+HMtDREDbmUSrom8oJN5qDbb2xTpCu4QKPXCL/8Wt/D7c95vHYPXUmMeU4WSUhfPyn/n/wER/9sfHv17/qt8Ds8fD99+Lg2pVIjPtXL+Mtf/R7uOd9746gfcaLvwzPfsELsXfmLN7yh6+MML3+lb+JfrXE/pXLDV9tC2GM9fIIv/mffxQX7v8whuCmUQb6ip/7cXzK534RFrt7hRbx/M//UqyODvHa3/nVTMKXOMr7y/2jm0xNkzH08DB+vzw6xP/69f8SX5295VZ8/PNfiN//9Z8fjUrbPnPzLXjb6/4X3va63w9NyfO3vfb38YF3vRWroyNcvXSh+PbMzbfg3G134sUv/Sb87n/7KRxcvSyL1ujF45qGBCHFcIqPvue9b8er/tvPgJlx+eEH454CACx293DTLbfhhV/21/Ga//EruOc9b48+YCLC217zKnzgnX8ScfT8z/8S/MGv/xdceuj+UjMC8J4/fj0uPnBvfPbxn/Y5eNPvvQL3f+C9qVJRMmYdXCXR8oGa7CO0F33GdnJdu3ADtIvWMcGtJsy4AV8mYKfaSG5Wjt8ZGMlUGq5Ndc5h1nV44pM/EufO3RwZlNgTUcWrusmsVCDetZBrpc45kOlgYIRpkWjKfvCZVozxRVOt8aiXoXFbYb4GIu6CcDKmfJ4rWFpU+WIYePZw+jcLo2fnxZXlHdgzTEeA18ymATJDEUXM6voxIBjodcOSch8gW6/loC7lVhhBhFdDaRAFVJRreZ/OiHgwBkeYZ3cvk+6NkbJW3tr61XJdqbOPe59MrdLk+rN3vhUEwhM+8ukBoZnQKIhZXAw2y8Xyjje/Fm7oCxJ6yjOfjQ+8+0/xwD3vL1wldz7uSdg9fQY3n78NT376x+K9f/pmAMAH3/325uKcHpPAP/T9yARlZrzjTX+Ej/3UzwSYsdjdwxOf9jEAGB/9nOfhQ+95Oy49eB+e8qxPBAA8+Rkfh6P9fYCAYb3Cu//kDYWGdyxuM/98Xu+xT3oK/OBw3wffi7e97vfj8+d+1kvwzE/+DDx47wfxrje/pvjGGIunfuwnYjZf4MPvewfuee87kC/8D7zrrTh32x04d+udDThkbj7mkz4Nf/Cbv4DDa1cyEHPy4+o5cOG+e7B/5bKE0E4M9Wkf/8l455teg3ve83Z0szk+8pnPxrvf8jq8/x1/Eut4z3jRS78Jlx68D+9682tx4b4PgYzB0z7+k/G+t70J9/7Zu3Hvn7071v/ML/4qrI6OQES47/3vmcZxVSIrptKxMlVyN0zDDzFqe+pdajAxzdo3Xn6e/OexqWBZsLoZvKSuXq3WuOX8eTzucY/D6dNnCrhTWwksAhqeKolSa41frJrWnd16irlEQEHPys/idwb1eYLcoi2EbuWmVAFSv/Peww2St8yzh/EuWhKizHp442GcEYEB2ciOQiGQOHGCywwMkAEbKxF1boAHw3Sd7FNQ0t51DyEfA5GBx4B4oI44bGmkvRWx8kVbMSosg6KoG/Wq2BFITYMUzsoZ7o8pJw5JbTGyEZGKXGven7xeLXF0cE3aCpqkmjX52nj9q34L7/qTN8S/i40iBmhm8aK/8rX4xR/7Qdz3offJhnJo4Ld/6adARPioj3suXvjFX4n3vO1N0kZjPK3xZQPBfLGDF3/V38RP/svvxKWH7ocbknZ76sxNsJ2g8MxN5/CZX/QV8d3dT/0Y3P3Uj4nM/FM+94ujX+/g6mW8Oxtb3W9z34bHdXdPn8WnfM5fxMHVy7jvZ947GsPN52/HS77qb+Ff//HrY/gnM6Obz/EFX/O3oZu+uZUAALunTuOjPuFT8YxPfAHe9z0vi/0Tpfnfv3ppdCe1WgjSmp5KTQtzvrODx9z9EXjxX/1m/JuXvS7Ck4/34OplDP0as/kCtz7mcfiiv/Ht+MFv+6tYHu5nDFHG8hl/8SthrMUf/ub9OHvuPL7o674NP/KPvxmXqugjAPikF34BdvdO4b9/8H2TzKR+pntaSdeKK2+yFDjImW2G4bYISEpRFD8Fg2/Al69DdRxkGqwoiiIU2Hv0/YD9/QPcdfeTsVjswJAFgktHXCopyR3CuIucj9GFRIXwAAjWmugSGQkZIPuGJpm8rt+g4GZ0ybFePfYpRWpKeAIEChaE8ZBgBU214zncHy8b2kN2J7IHF7jQCChDBHJzTYYdMs/2GHiN+e4peC9uNklFHr7thwKPzAx2Hcgb0f8Z8C6Nj+EAElezD9YfSIReZ3eCYDBjXIT0Iuw92DG2tRdOlOaiNSm1kAAAgvoSUXJ6ZrzuVb+F173yN4+1OLSPvD8f/Mu5H/lL/sa34VW/9vN4/e+9In5nMt9j0R6mzfgmIxZqBgB89d/9HvzKf/w/8e4/fn18/df/4fdhvrOLe977Tly4/8P44X/8LYiH8UPf851dfMs//7/x0z/wj3D10oWRxdFa4Pn4c+gV/8qM/+p3/HOcOnMT/uSPXtkcU3L5leMcj7X8+8Vf9bfw5I/+ODycuWBiDZbIrv/rO/9mgi9oLLNZl+VaGeP041/wufj0L/pyeDfERVWXn/znfx9XHn4QT3/O8/CFX/uyEdxEcqAvWpoAHnP3R+Clf+/l7TkscJHaOq5obQ9lbKRW+XWXKYonKrPAphejXxLspe4CZsBmzwgQtxEAHhhucOhXDsPgcccdd2A+3wHQQe9iGJ+riIG1YsWzWB1kLPQuD0n3kixE3VfS4r0PGSBKOsx5RuEOileOqJfBxfpNPlM9n6K78lvxxxMRuEreqNmZxYHhMOtsuucgwJpbb8pjbKf8RkJp+8Hh2v4+zt10HukqYMFh13WAZ7FCWDbhEeDzPMA11oZE2QW0EMBOnEcggiULO+uiAIj0AHGFDeHmu+Dnqie5WdohDBNFGXPOcGtfuDwjudzBl899o27eRi5AtB/tq2inBoyooOo24wNe/NJvwAs+/y9PMuBNguon/vk/xHvf9ubJ91PlOAb0BX/1W/DpX/DlANAWZA08a5s/9r3fhveGzfRWeejeD+GHvvMbG4fENpdf+YkfxCt/+WdKOIDisKcKHGMI1pjCxxzdSJEIxYR+46t+Ez+bhb22lQx5/u63vA4/VkREpX6HYQAD+Nkf/Kd4zSt+Gfe+/934d3//60aWS15+/Sf/Hf7Hz//Y5PtWISQr/M+3jGlELWIGStoPUS2lRctg5+DjxfGKezldzwQcHh3h8PAQt992J+azhRwMy9K0VJ1DlZDwAOLzrtYi6UG2bM6hPv78fI1EYJsQQkyUcn2F5hsMv8TFprWZ092m9VbXkd8tjOniPxgLtuIKkt8t2Hbyk4JIUTeYNTCduLhkT0M20y0ZnN7bw2xnBjPrYGYd7GKGbncBzCy6+Qy2szDWSBQXhf1UYpiZQbczx2J3jvnOArPFDLabAZgD6ACegWFBNIOhDlE+WwPbdTCdlcOAXQc767C7t4u9vV3s7e3h9Jkzk7jJy9aWgtENlNznF29jCpqCLzeCnvz0Z+E5n/65sY3PfMmX4c1/8Lt4xxtzH7eYvHfe/SS84EV/Kdb9lBe+BGfP3YI3vOo3AbZpEqXjuFH9O7/wn3D65lvwxV/zLYW5zQxcfuh+/MbP/Kg88x7zxQ4+6uOei8XuHl7x8/8xG11aHMzlEl0vj/CLP/oDeP6LvhjdfI68dLM5XvXL/xnveesbQ1qBMjfS7XfdjU//QmH4n/flX4+hX+ND7307XvM/fgVEhJd89TfjCU99Bg7f8IcwIDi9TYyBpz/neXjasz8FGkHzeX/lb6Bfr3D/B96LP/zNXwQY6I8O4d2AJ33Us/Al3/j3C4Fx0/nbMaxXWB0cFBuhzOK200IomR4B6JdHGNYrnD13Hl/yjX+/eHl45Qp++Uf+NSxZyN0rkntnsXMaL/6qbwB7xm133Q03DPjSv/1/gAH88o/9a7h+jaFfY708gjEWf/lv/v1iobthwH/9oZfj8NplEAHerbEMbsYv/NqXwbshcgrRzjqsjg4xrGXzf3mwDwB40Uv/5ugMys7eafTrJfrVCiCCo6QNcRgXcRbbz3o4KLyDiThSXBLk4rBWSVZVjlga/x3rJoWIiOKJZDDDJF9UgIkA14P9LKxF1SAJhvV8gPxkJrAHiAwG5+EZuO2228SSNrIZbFNu1eh2Um2Y4GXDlAC5llKYnrhELMhToE8DzU2mLje5aW0AmxBmGeIRFdk+cyuR4SBw4oyEnwYyAEUBFZp9/XNK2Wztx3g9J5G1zSwRSGIdUBLIGayyz8mZsA6CkAQvRITZzGI2m0u+uGBXsFe8Ai4KEc1tZQI9zgAOp0m8B6wR4U4AGwopd8RTQoFRydTbEMyhYxJrx1ouZH7zgGOjbH8dp6C5UiwiKYU/UzwtA1gtj/DQvffgoXs/FJ8tDw9CvcyyAGNYr3DxwXvx8AMfjs0d7V9BvmAEEMEEe4+3vPp/4j1vezMe84QnywG2sJbCHg0e+PAH8cF3vz1+8963vRmXLzxYbI4qBFP6hXcO73/HH+OuJz8Vi0UZ8vaWC7+Ld//xG3D5wgPNb4d+jUsP3o9LD94XMXV07WokzCuXLuAdb/xDibRRTHoGjODp8sMPAQxceii1f3DtcoZnwvvf/sc4uHoFKPAJXL7wAPYvXaz2UQIzcwPe/HuvAAO4+MC947EzcOHDH8Bb/+iVlSJAuHrhIXzgnW+NKY3JmLhvcPnCg3DDgAv33xtxyiDxaQeBtTy4hrf8wW8XVhEBGPoe73vbm5C739arI7zxVb8R6iQO6JzHpQfvC+MOIHuPN77yNyKcCROiHFx68P5YNx9vHpevizbBVbkhAJS7Jpkekgmslrsjr1vDUPwdED6ek4QryfcYziHot3EJctxfABO8Z6yD4Nzd3cWZoC0qsyst0TTXFCQEhStFWW+R48Rs0+VKY5xHrdyIcFIzkwLzIh/2JDjcrRAWbUKZwpCJicIbkfppuZX0Z8v6zuu0ioFYQJ6ToqdCweQUUM9xOK9TWywFZlgZOUVaUwERXWphIpThi9UGUcKZBZ+p04zm9cxEOjdUuqG2EwrE2zj3AfzAd0yb5/kkGGNCyNfY7OMghYOsBkAZEYj5NJ5EjpYCgLHpnMVwK4KD0SxEPRqdSvccQX68CKuxFTDVbWYLK6baiPUM8pQYOQRA0NoDnjRLqrUhI2sFFIe+ck0/vvOpVR81vXapN+lqIs7dTcx5FIcVgjMmLRRjJFacCOzlFPLQDwD0nu4yHbIJrqahX8G57MxLQkjsl9kjXbIiGikzY7VajdxV25BxrKv9qbCLn/rCbRFxEBccRVoDjLhOKiaQhMJ4AW7c18iZyATDKsaLLsKTj9xDNWthxH3vcOXKFRhjcNO5c/iIj3gKYC3YCozGzDCb78a5KQ9AaU6kMFYjOYpMF9wugR5MSKQnh64k7HW1WmG1OoLnAUJOppgrEUpyVkFpP9GluMFkQLoj0aD5Bn/J8ZTXadF83Ubxk8c9tniBzHdau+lZttcBCWbVEySS3hwl3wDS2QdGyuvEcsgvRi1x2OQO6910JvYb6SOaVmO8/PVv/LsjPNblutJcTC1ADr7NKN1btB39kcmAz4lhXL9sJIdDikcODqupp13F/vSbXKs5voz7S63EOlCclHgRshqiRpeJ76g56i1z2qBzYoKSzTNWRmAmgFQlTjRpEzl2Bu+WjFPrtn7nMAZjjByCi6BTiIOHaDNBC9Ika1pUIGhrpUBI85MY7ximfAy5Odx639pwHOv/2uu2ZTP9bPJrH7e/pKWmuRENMgPkZA1RnpbBxNfC2GTOL126hNvuvAO33nk72BhYmzTLeD4CJY0UDDzEvk8qTsmPIEpCfqcCGJpyuxAIKNdL+S6bS2XODc23xml7j6qNxym3U9zDnBgrUF4EpcqLtXb0vsRRUkNtEBKoLY0wUNlwz00khFTmwieccxjWPYgIi24hApvzlZZw2Br7ceXRP6eAETxlCQOY+HJrGLYdYFP1O2HZlpnmtsBxm16xtuQAgJz25HTJziQwx3S9xXiPFxDJ11rXM0SYdx3QWcxmM/ReQvB47UI+GidARqaS7okotTbd6GxrgeUyGguD6ANuMP7N9MHBPYBcDmW/tL6lEcnW+0f/uwqrjwcpOWECKhcMIqSHYcCTn/hEnLvtVpw+c6a4aMUEezKyZ+9gq/MHOk61UhmAY4bcMlKlNMm+UQWAeBaiBbNT1xFowfeYFrPLauqxn7DUFtym0hKIU23oz1zRmXRjASKgj6EYTnepBmNPhIBGKMEFhZeTJe2ci7mhIpxAwYK34UV52X5PYQtNs/ajtZFU3jeAWE8wsY2vMH2DGAbX1P6OsWy2LTVCW4eTYp0q22Z+YxtXdVUrUg3WWgs3uOBio4yxhoUTrcIKN5WcfaSa6lQ11aDMzMoFLkY2MpklBw1DCdAghfaNTXMiGWueW3/bUruiWjDWC7f4PvsnHwRqJDVK07eRBoM/PW9XraGa8E4ylpOWQqOt8KbwqJtCaWY+n+OW8+exe1pSh6vGadT/DUbcBZ3Kp1REKQX3BuSgl3xno3DJ8WeMAdigFSKfkXOrx2ndsYBrugWljZbFkGBovNM5Zh65y6WejF/OClC412IMaGnZyX+oWTNj2pzjNu05qHAAMRwzTGfR+Q6eU3RmPd6cXjfhoFW2dx9pIGi8JU3/o4delBAjTKG6rrpc22DkgaUJ1gxlUVqmx5RVju8oMzFjn60BBCCo6iczi7dnmrkmnX/HylkSejKlaKx/EkDZSW4GjDVZtkrlVAYEF9uub2iaYqzbMtypOlyZferWGbwHsUFHHnAOcJKB0yBE5Kgw4EyTDJpN1Ji4pSFOw6eCc7xQBabU1PFt+qDhUrw5LqOfCSYfZzW4RKLbDCX+6ARwFDXrKci06Yyiwqtc0KYNWViEqzhFaDjPGLxDt5B7C0rmh8BsJGqpEBCkm6saMqpCUaBJSQ9J+VjKD8XpEhxrO7BjGIIk5IvMCZAcQCmqZ7xfOWahmxXTtjYcGXnt2m2ujWDJKj1p5tH43kd8l7PTsGryYWT0xSj5U61IqyLoWWlM5zS14b1cyGVNJ4cGo4udSnqNfDMomCMo2+UE7iNfLAQFkYtQzFwoVKKegVJicCHVAEbcI8u0jjilYRITA8/a0d5z/1yOgoZ/rwRsXK5Pq6Z462YSaJkPtWY4yMIalQg6G73DpBEfmRYni+j4QyhT2sEm66uErB5bYM6Qg1AgA0MMDE7yxMDpSS/pQ4/X25S/JlJOHhJ7jFWTFi+N3qcFP4Y1f1ZaVZSUiLb2kCDlFpzpmQk2x9RyUw3ukVmq9X5C+iGCN0TvWJuu7QxRKkDYaegsjJVwUspcPhwsOsMeBAuwVzYNAoPZZms7da7BImIUj90iyYrrJIUE+SB/VPuWU7q1jZ/PeW5lblfGNFLDpG2P/uasDns1BjIhpFparBiVPjmo206/UYQsk9oKJaRTe2Axy4N2q3/HDWY5i9B1XSFQp2hxe5FwIqEgyBlPVAhli0NtTGTmT1MtUUoZgZQDnvPKoikuhdA25Xo2+KaY6qa2kr+3QZ7UYFyUJr92FcnCimo3NNGcdHQ8sz8O9nqcbWGhczO26pQhq2XLzmPwaU+EILHbaSwm/lPGsIlh1vhXzXQcfTY95in3UYsR1TU2FQqqYuCJkxZZ7st9pC7MGkJ12fmQaXduLeJNsMGiscbg8Xc9Bnu7e2FDWXEacEiyHmPUC3kAXXYbelZCFWaGYy+H3wxXglVDItOYZb45PicKofcTrOKkpbCWckhOYjlnWjgZA6PKbZwzk62/7PuksR5jxZys1O1wOK7gB4dhGDCfz9F1nawFEKyxhWB+pHCceKO5LsxpQtrAJA0r94tfX19VnpTCn5eZj9eBk+MW8NZg5xU5aRtTfCwuUCDWKzfiCEQM5hSNRMTHTvyj49tumMVhCiV0NqS2JpIYaO/ihrLqm6C0GZf75CXcVMZYjmWKW+TfPsLFVwi2iSoTtDAljKddF49+YaAIH210LPcVMOOmM6eyOrLhq+4EeYJogXPcegbyDWuV/PKJKj4UVGHKs2vHvnLYkkBQRSPsRWQaerF3hvQ8wnAsRvLhP1K86wa8hmZzInyoEBpbbzltEgszfzROwxvIaWmeGczDAdp6P+1RkrEATiQUxhEYERqMNc60GTsNatEec7v90EkkkJBLhQyi6yrWinV8Mv/GoI5bH7kqpuHY+C0qM021yBMkE2HmkIoX4soNjFPWUzj0548n/G2YWrS6Now79h++1UtStC0ds7U2wg3NUQU5PUxUpjUQDTfNfwlTeWK13qDexoKrx7OtZTH1nqu6ufLBOL6NbUquBmwGKPtRC6gCKIOdnV0MHujisWiGXHU2ACyZNXUvIFGJH7t1gpNEIogAQ2FvSJlkZiHHb8Kcr9frQuFq4ypFoo2EPrUVgbK9tgsmf1bTT4G32soAGi4xoHX2JO+zoM0oKwU3use2qbQEY/5uCo8Cb9qYfqQKygnOKUxIbEaT7ddGQRqs/EttcfFRzaTSN6kQEn43hXmlPYvtmcIkg9zAhHLIaqsp19JGcLVghTIijuZ33r4esKpdTVNl6t02AmH0jgiglFXTWgO2FmQ0nYJwmMhSiGCBKBDy0D03UEEkab7bi5yyejVc2+yT/Hlo7WQo+pOnykmtmuP2gqbcIvF3DzjvACLcdMutKPYQpHKwOuV3ZYAptYaudWTfiXYcW2F9mruPUsBJPkfJfVTCz5pCmYFtgnunBANRzpu2FwhTbtNUKnxXwmeb0soSvel5Psdj92mywFq0UN9O2YRnyzWwvaXAU5o/Vc8T8dSaYC4USqmZED6yOKo+iYIYYBLNeYt5apBK1l/2lBTWPCRu7Ess+WRGdFFeoxhD3p/81YIofK8aQcBrMu21UUnAlQTQZvdUXTYxF30f3yhB6n8FQSCy6LoZrDVw1If5UIe2aqoAILdD5a6OqBwkqR7WG2d9JazExZkgRFDEsmrtGU7fU/V3AeJ0oeJH87VG0JQNbbutp2OjMRyFPlP3wQj3V0J92ukzCu4lws7uLpItl+u/JiBAuT9iWxzrJmaUt47wvdBJ+CbMZ70u1FoAnNwLnTE2H3kBgYs9q5BSI1OwgJpuqVirI+Q1FLiRn14aHU9/kw6r4WsFrmtmvK/6JgboMIc5ShM8UoJH9Fz1QfnP/FWa5SQiTx5dub1QyO8JRZqkItut/BaScalGX5lDPiMmrX+sBE7vfeYyIt/OQyLpGDZrzzlcpTafm2jlN1PWS6yfsR7tw3sxtfN2R6apCoTAVK0hgCkmvirSCwNI/iiKTIMjU97M8GscNN0wfrwwlMgsDKyZYXdnDxIFtZSIiHjmgMN9wJBNu8xC0JhqSYaWpRbhTHHIek6WHscrTgFhh9s4Bmthvqnu6Nvsv26CPnNX19gFmavnGc2VLcTeiDXbpkRrJd7AkQdIkXn2wZVTu0/YWtjZHDuLBeaLOWDkzgQR0BRa0/ubGRpKpGykTPwn10/m4kSE8ly6DPHHnhgEh5gLKcNJuj/Yw3sVCh3YiVIXGirWS8Jf6Lmg25TSIXuYdNMW7VdrXeeh4Om5chibzXgKSlrSNSvv1Z2KBC9ncVxq0YNgmDAQA1Ru50dYSAVDDn44H2QMNGGOKqG5kqM/k7iV5Jrx9zFmmuVR2GjO74TNINv0DRAl7RaKfqPPtpvppC6Ck9Qf182tgJOVKd9mRo4Q4nKQsL76Xuxmq0hWzea+jwcw8oqow1F8RthZLNDNrOTXJ1U489PKZanzwhginCiZN5dW1P/uYiiJ+5H/eRM8xxJ3/m26BGmbbwpdMKMnJmC+mGPv1KmAdwoRShyNfSKJHkpAJjjkTmNp04DDNZua+A5QKwFBYSHVAANsuXWtloKmwK/3eSTYoBxHNANzJl0Jvimcl5d3plILBFF8fBr+CLvjfja5JLmCtbknYJIawy5EbxHFi7fiO26Ps3aXRqU84/QyfoqhsOqmEiV1BNJkOZFQaGma9fOiHAdJNfmtfjbBsm0q2JO235qYXOjI2K+r63G7KIVkoY1MEGJ7I6r8ti6TY24q3EnzqheJMQTmHsujQ/hhheXhAdbr5UggUKZ1Mgtzie8qv+jUIt9GwE1tyhVDPMZlNtF4ZqlQvDxIrd+6vSZ+j+0uZ/ADoksoe29Gm5u5Hlj2a4yk+DZEmHWz+J6ZQ4BA4LnxNh4T0jFzomlNg53RuvYbHFNQbY5Jkk+avA6VcEV3KFERkhwFQIU3E3Bd0GL4SblQynBEwQUl8iiaWEmOZZ6B4p+2UNAFFZbZJtqcooMWDqCwBQXKeZ+PrNnH1L6C/q6WiRZDRqwXL3dflN+MFZqp8ogthbxMCY0/r1Iz6kem+Y+ftST19Yxrc19KnG2Gkwu/R4LTSUuqYT5jYsGIwuYx9D16t4Yb1hjW66jt1GObWhxuKO2E1gbg1Hzu3nweH/uXvhqv/cl/K8kXG/1O/Q0Ai9Nn8XFf9rWpTviPdx6v+8l/G6yfCv7s+9neKXz8l35dwofC7Rmv/+kfgtdzGkQwtsOzv+Ibiop5W+/+3V/HxQ/ondGiFehBpFPnb8ezvuAr8Iaf/vdg7xDdCqGuauSx3eB68Uayp3Yz+akM2HuGNQbG5oko9cBAcEWp9ye4dShkIA6OpSDkWYIKbOC4QrSFy6Oeu3w/KZ5Tid+Opqh4rHSrGXK1/eTWSSsoNqW0nlmwOZ6ud/22NrqnlJLWemMC4MbKbJ7RYKrvFi9iRsxl5b2HYweom1r1GZ0WUgCOL1ur2q1FOvaRnrxMtTv1btR/Zq0Uf2/oqxYk9T99txnuRp1cwWn0WfehH4kGmr3Lmc0E0Y3h227Cx9pG0qqO/Y4Z7B2GoUc/9Bj6Huxd1MZyaiJlNlkbMj8+Mt58sbUWa/2ciDDb3cVjP/a58eL4Kfy25u/0bXfiro/7JAzLo/ivXx6BTIe7Pva5KG8LS+1wJhzsbI67Pva5YDdgWC4xLJcgMnjsx34i6pBFBqNflX3xMOCuZ32i3JRW3Yj3hGc/H0/8pM/AE5/7Gbj7Ez8Ndz3zE0vJUyIn/RpuOLx06RIIBvOY0iL56WWtMvRcTGS60YerTFYEQqmM53t3Y3pMazBzqlZ01krLrTSPxjcKnboeu65rzqv61aPFPWphoqil0ljDU2uhpq1trNSpvhnHC6hNtCyl/NaHOU4BL5WSdDxkAE6YOjv/vd5sFdMxT9SVOx9yWV6qpgVSan9F/aLJ6ZGZjBOqR1W97Kpkiq1JL81DracawUT7E6bfSNuofiECnJfxEMrrF6fcdTW+jyPWAhaOEc4JczQ2aEXzASQz4wDJ7Cp7CuFCqJgvPvghoi86mvUAJPMQR5fDSa3LXGhSjbx6bFU5/xFPx1M/+wvwm//km4vnZ+98HM7ceRf2zt+Gw4cfEs08a1lb7+YL7Nx0DocXH8Kb/uuPYzg6BEA4fesdOPvYx2Pvlltx8PCDYBdSObgBb/rZ/xvKZM1sjtO33YlbnviRePMv/iTW+9cS9MR42md/Abq5XORkOl2alRZZ01tYix6Mhx++iFvvfAJ2d/YCvoVLy8a+gc1lVrHW8rWcrSP19zNHX7XJaimeI2358I1JcyRLkyJjj3e9a4+Uu38Sc1f+4r1H18ktc8MwTCqQOUz537mQUvoqaaOQZNi+5Pyw9Z6qOikhXlwP9XcNRXNqTeh61KZU0IolxyNclBBvLid2H+VuDyke6jzmOFCRwAloDoQVBjIBHQHh+kFSygDA4frlLIwrL94BxkjWQhYzc6QBKFIjQ6fMD9qYm8bEiKacdvz1YpFi0sIaIkxPZs3cTdZfFLTh+Dpn91NvYnYJeyqAFJgkmGqrKpq4Kk8zz+ak/WcsQFZS+fMKcm8vwGxgiWFZFvfgPTwPADO6xU6IoUZiMqE/nZepvSGFs/U+CocpWqqEYFpEY83r2gMfxm+//Nvwhd///+B3v+8f4Oq9Hyze24Cbu57xCXjGF70Uv/FPvilLWggcPPwgfuef/V28+J//GH7/h74blz/4vkh+RHr1I+OOpz0Dn/BXvh6//n98fXiZOD3B4He+7zuihnfz4+7Gp//t74pRSeqd0S/mtAbDwBsrOYw842M+9uNw6vSZuPnohx4A0MX1Ee63cMFigFzmREYvNvJgb2HCc8CBmcCk92LIlZwwXvYoDMI/BmNApxcGR3tDkJBbCM45eKSsujp6vS1RujGAl7a6zmK1Woea7Rh9YJqR1Z4E/a6ImqzW7XalraFKP0BNnHH9EsOGq0DVSstlqgZU1PAXvRTWQ64QhmACltWc85YpiFvlEe4pUOPnOFmb0UmPeGqAFx6Nv948SUS6ZBmgATKkxjf5Kj2BRlBo+toNTcQ5EIpzE4kQkAm5TDA0tQKTtLHgf603EwFgrPE0oR89KawNP4ahhmf0e6aBEiS/jmqq8AOcT1kyJXUy4y981w+hy64y9W7Ar37H18Y7bQGgW+zi81/+w02Yf+sf/y2sDq7hSc/7LDzri78aRAYvevmPAADe+Ypfwrv+xy8fg4fxeKbe5ZbBxrY4p438+/HXRIRnftFL8aRP+SyY2QwvefmP4RUv/1as9q9qjUzdrL/Pzn8UxSTlxliQAc6dOweyHUClT1uVDSKI686o4oT0PuJG85Fld1nkYLGka5SIppAyO4DmWLLnmozTepLtc0MEok7u4Oh7MShAIXxd6SmRV656pn2FR7af19qTuP6SQ7gdP7m+YIRxKe5OyBSrfJ/FbA/WqJw4+ihNzvg9EQoTMX4XIKVoijbKBq1v29ERV1wZQaqq6pQD3bIk6vYq10/xjLMUzPn7qo00N2nhRU0d49QYNcFOnWA8VqMJkoixIX0IjbXmjf2oRkUU50ojRSwzOFzF6sN3ezffgud+zd/B63/6h8PeQ8QEPu2bvxNv+Jn/gIMLD+Dmxz8JH/MFX44/+OF/AXU9AcDi9Bl88td+W+z+/re9CX4Y8Oyv+Ea89sf/Nfww4PDiQ03LrkBFZJA0mqB6jqlSGsTASXM3P3UaL/im78Qf/vgPwC2PQAD2zt2KT/jyb4CxaTnVG43vf/Vv4763vh7d7h4++Wtehk/+ay/D23795/Dw+96RjXnjIghthsBDvTtZgMZNZ8/KCfNwxoU4s/iIoljJLeSkICl9Geieg67xCFX8rPRB5bhlz2I1MCS3XliLXTcD2GO97rO+E8NPNsX0uPPfj+N3OaOcepesx7YHIn8y6iuzBKYFTPlM6vjmWowwZWGrCmOr5C7l/FmZLfX6y4mEwjamFRGN4tK1qF+thUiq2pgyE+sSCYAMuq7DkIc+0nEbNRDGWLVVj6f9LJ1eTlq0rLGWn7Oe7LgZ1BSuagrmL8ea5CYzU+BIveeLYARcoxynVUe9mqR9A4InAlkL4z1uuutu3PWs5+DSB96Lh9/7DrBzUFnCAC499Rnw/Rq3PfUZePxzno/zT3oqLrz7T4t53735lgC9wL28cgmXPvBeMBgX3/dOuH59LKz5+2QsNoQ84stkFUrnwdtF2H/wPnzgj16JJz3vs/GUz3gR3HoFYmBx5ibc+hFPT7hpwLP/0P3Yf+h+mPkc7/6fv4YnP++FWJw6sxFuaTC3FLJ/EgIEIkJnOywWi6Rpy4DGpbnmKkFU6ErJb12qPRNKFBDxpThjz3jggQdgiHDq1KmY2bWg7BGjT9bsKHoo+7kN4zuOjltRQk3rueYNQcnd7NrNBa6ux3bKDaP3njcUmnocx7mXADS4xfbluu5o3lRyBDXr1zRYMdRt+0qITYvZWlsIhaL9UCeOB2WoXB0R0ySMopmp6OJSqLU2UtXIo9BWLpQSEZQug3IYY6IYESZRpgTyqD5QaY0bxiK/cGwm4ikTjhTaYyunLm+5+yPxpOd9Nn7ru78V4uaQMSvn+tNf+1l47/GUz3oJHv/s5+HKPe8fjS1iuHLVQJs6gfKQl8k9CiD5lYN2rbdXEoCr930Q7/itX8AtT3wKHvOMTyi+v/LhD+DsYx8/gqVYtAS4fo23/frP4gnPeUGaeCLQ5DIO15sCkAuZhL590MptZ9HN56KERd8LKRdKYwr9ANA7cyKNaC1V2vISleKmelNBrMRMcr7CBynx8MMPY9Z12N3dxTAMowt1IqPnsWVbr6NI52gLhhzfLY2aiKKLE9zW9CO+GjCWAy5LSzhQmAfO1rtaR+Mgm6RkbnIPa5RbO+AEbcScoJzYfTS69q0qwzDEOjr5BfucMJ/a+kc5usRUORC8RrfIxtVytd7Ey2MbJiyaxWKBWdfh8PAQy/Ua8/k8jUsFTqTzakO5WRJBN/ETn8kGLxeLrQ2rtSbcUWDEh0shUmOCGW7rL8015E0WUmqf4mK3ZOADE5K3cuEOWQtyDkPYWGXvYWazcDOb0gFnDIkA73Hxz96FV/+HfzHWkpRdmbGwLkJ4ty71mFIxXQc/yB5H62pDHWl/uI9X/evvjIxSWzKzGf7Cd/1wARNZC9f3SYBm7eVjQKaR1zB6z/C+cW930Mg7a7GzswAAuMDNhBcn+tAxWWNKclO3GBE2pvKN5KG3fJWWcBRpGRl50lQdhKc89akglrs2rl27FtzLSenJW9T1TWgrh1FIZEK8VaYs/ClhUgx1ZBUkQVQBk95XbnEOWJG+krCVOj7iRuHyg4MxaT9o3FUuQDJNcoIZafvZiaNmvVY58ZHg2nfVKuJekHue8gwfZV6VsgjwPv7TyAaGG/2LEU/kAOqh29PMgIWFCYw/asLM5T8As67D1StXcOnSJfR9P7rBSOGMWxSeR+MZjRuaLQawRLCUssFQXoelXZPdVJbcYF04xSpLhdmFBeTCeJNAOJZ4Yt8hWykINjD1PHP+VkUNA2I4pA1iQwbGdhhmM7DpQN0c1M1wzxtejdf8yPfhJf/sR9EtdgVvjEDQBrAWZtbhT//7z+M9//PX8aLv+Q9ZOgkV3unQXsrDI25JYzpIHpyTqUSt2jfddTc+97v+PX7rH30jrt1/z+i9MpJximWB6cztd+FF3/MjMN0MSgXn7n4qPvef/BBMNweZDoABK3XETdwwJrLhX1e0rmOvLQ/d2O86g25GIDOA4WG8hYEHYUAM2TAWbLsQORb8/iOel1tnJb0aY2AsYI3HDD0MVlIv0LDoZ7KuHKvPPDH8ek6lLx8VwbheOPwDwW4xp/rdcUU5ChPFnBDq/mwJDsEtCm7E+n1maeXvQXKWRZ+lcy0iDjx18NTBGZsi+Ko5JdNQRiZL4AeYcC0GyDxc+MfwBPCWOfxPLBQ2mTV1+Ff2opC+hVbQaosA752ErTX8ivm33pfvfOwunPB043a891itVoVp2Wa0oe0axFrIhH/1UAqroxJKrbGIluTgWUNRUx0dpyZhi6jKmMYkMVVt1Ywm33uZ0r4pqqCpWGtjJIslA2Mtus6m/STvYWwQcmRigryum+EzvvW7cfq2OxG4ilwXGRZe3X/KtGrDBmsaawyLzDTi1uUzRIQH3vYGvOXnfwyf/u0vR7fYycYrsBMnF+K5uz8Sz/+WfyxtGROtlZ0zN+Ezvu3lmO+cCkq2CDkig//1774b1x64FyDCtfvvwR/96L/Cp33LP8beufMRtsKSoHSAS9KLZ3UyzMuZkCBMmAA2GNYOg/MYnMN6vcYwDKI0eYR/paVQ4CxnSEjkPcUk9WrVXCiOSJmBpMro/TvB0s7mJY4pMrSiiY38ZZuSj3d0cli1+ZzBT/GyAGZ7v2GzdR8tw1A30ln8vQpQYVlfPovc2zxI/U+CQ5V1HWPCbqAZT1NGxahcd+6jlq88fz6VM/wk/Wxi2JOEI7az/lIwupzgpkzT3E0R3VrZmKLCy+0kdYwNhFbhbHOdzLwu8DDWHOu2c1hAFOeCq2+mfN9TsI021pG5D4yJxK0uuv7wAH/6qz+Hp37OF1ZWCePDb/5DDIeHIAAHF+7Hu17xS3jGF31l0V83X6ROZCghtNHg6S/+UrD3eOidf4wL7/qTuMgLeCvBNxwd4vDiQzj72Cfg6Z//ZfBO3DKL02fTCMM33WIHNz/+SfjoL/hyvOt3fwX94QEAwNgOZx/zeHzUX/iScA6AMN87BQZj//57wH0vlwv1a+w/cC/OPubxeOpnfyH6o8MwcsHz+37/Fbh2/z2BAYST3i2yYYsUqM3QLKGStC4IwPBO8cQsvxsVlHlzPBG9M8EzPBg24pER77vIDqjFfsP4dAlSbDPRzc7ODvb312m+WJ57ru6A3yAY1A2UdT262nWKbStuIsCtOvkvsW6KtMr7b8G60aXJ2RgK92TgP1GPHK/Rsqj4rZpv8s4T+QQe3dxHCsz0BkkCdDTYaHaerB+VwNpueBvrtMzvHJa6RNiaTJZR3Dddj6PyK25TWkJKxjaOUJA6J+wAm+dk0zfN5/ovw78+VKHZL5YYsMQK1/C21/48nvvX/w7sbJ7G4hze+GM/IieHdxnL5TVcfcO9+KSv+/YRc7/nw6/B0fwyel4Jg+vmuOfDr8HsyTdJW5cMjj54rQlrsaUftG/uDO758GvQPelsVi/0s3Ml5nG6yvfjw/e/AbOPOIfVaw+x8nKmwM9Yvr/7dNHXh+95DY4WV8BWBA2TCJB7Pvwa0GPnmGNe1H/rf/oZERQ7CoEcFNOlbs2DuOfDr8Fydx/sh0iPskwYg+1xarGbXXMqactznaLQTnO8RDqaJibth+KMBxA0mU7jU0ayeIs4eUo0s7Ozg4ODa1tpjdvQbS34E/CIOGh9k4fsbu7h+lTb2hoDjze1x+Pj4mqAESQbFLeN3oIw1o3CKm+Lt+QW//JlX9UErgCwFJ+FJJQfbfNU6jHAPj5rlUlhE32zEpYKomjub4Pg+pkJLhECmofRpLT3VTYbl+N+WxMtxOLDv/Re7ybQUNNado1cXwESA46no8fjaJex2YyID2MMhrw9S0BnYTzg0OPB8+/C4e6lY/u4UR5Zeez+R+Lm/g7ZXzFzzBYLgAN9EKGbLUBmDmPFBUdkQbo+yMLaGcgaMCULhIyVuuHE/sgdRwSYWXT3kTGwnXzrXA9jZ+i6GTo7A3cSZmmYQm5VCQi5ePEChmEdzVd16QLpzo2WQqSlJQjifysFWq4ySQxT92PgfMoYgNIomNK8xp6L2EvR/sgDkQYS3HHrcB0tRzcfkK68Fr4Vey3wMC4Zj2gaDyHzAsQF+jVf97eaY6u/2KqUF3EfH/lR+BBz38VUOaFALohGDVd2hXnYshJOojFz9XuyA6YJ9qRF/Y9xI+t6TIGJIlubSRDkPu3j5q8ucnaVgHDRR/SbhkNUJhD5hx7zRhzu3BAI/zvKvafeg3vPvAfWdgClOwtipFEs0WcRlZ34PN8rqPWAoFGPijeZ0zoLkgh7L0LPqXq6ekdopOs6ydaa1ZlyZbbeb10mPmkpR9u0Pl7rJWPb5Moty3FsdxuGKfVSXyl0Od879d5BsuH6rVnsiW5eA5LmzEBKM8yJ6BS5o0ieDZMqPrpkTk7tKUy2F80jK5LWmOhPVeSIb7VwflYNJktGoioy1wOCCzWjdJ+8JnkT11E4ayclp1PzngDR/NjLyVrHcbM1mfcBBzxhvajg2cqEbRfPXDGUIBOMlQtDjEHfhxOrj55cu1E2lUCTHWZgdjB+AGMOmEzTJAfAhvXlAuEaEHk5kQ+W83FG0lcASWtmZrAZ2/eMHsyy8U1h81spUSLrPMBOUl6AgmoiKpXprJz87sfuD6XPmF678W4r4UDVrxwZC+AZukvDABBO4ZcDnHbTbOx2Yi1R2O/RV47FPewjP9H9yeOjOsfti5ckOls4PeXsndN051uUk51oRmkKtd6fqL1qj4HIxAMnLca1adNFffDeeczmBjs7O/De4+DgAHt7e1itViNzr+UimRwTY0xsVT3J8VRqC1O+v7Kkuhw0N3XdSrectlwy4SX9pFa2OYzWKtsttNJkT2dQAhyqkWTFuA7nLjwhwVzgz8dEcdD/hjHHfYoM56zpF6L4LIVyigrXwsj/rHd7KCKTkUCz6ZsM5lqHSDDw6FmBFDSXSYKvAEjg9ewjMvQeY5HHQhuD73HtjntzX4cwZc/gGOes7lQqoMy1dQo4iDisXL2tEjdY026ouD+MPktzw8iSzmUKDkAxmksOVnAhBEoX6rSysi2zHvENndeg5GyYoGNLDeNG9yyX75lyilW8bten9lXyM0q/q4Jo5CwRBzredrt5a6HQmqSR72wj425/l+9HEKFIj9FyzbTaj/p13Jwtv4ltRi/75nFVgyr6rfdJmp9Mvyr6Te23REw+zYlxsmp3xVmG9sZhPh+1aXvcPE1t0E2V5JnN6nuLU/u3xm+Leed0srVWNPK6EX4yIXss4jfK0GRTc/M8JoGl0kZxGg5LEcPQQvaiouErdOX0s9hCQyiMFIzj4KmFwtinLv/CHd+hvbVbilCo2pLUEQxjNS15OlAWBaDSisnmAYzyMFQ+hHIO6rUQHk78HuhP3ViRKencGgDj7AOtvYNH4p6ti+AkUOuj0O52lnabd454Va4ERRoctzYWRPp34hMq6DlomMzbj/e67lOYeh813YwZNZl4RVyqGRIkoR6AlCOF+VgtQsg9xJsbgncORyHX/Ww2K66CrGEqxhX4BQFJknO2XpSxVsxAtduozcuLSbkR/fFA4Y6Li461zVQ/MtAoALL+4+JJ47yeaKOTfFPHUjeFCMa4jrBmfSalt92G1i0Ks8wRK9o2w17c3AUPzwRPjH5wWPc9PDss5sB8NguppgMDi9COASPQRsa1tftTiS7QcDzcRQRwF5AQtPLR7VnCFLz3YD9gNq+VFoqWBwfNuPK8iqshe07550jzFtHMuh+QrQc/rTRQhccoJ9QixMktg9ydlCuPLcs8bzuusw0uoprpTm0ctxTMk5TCkiuG3l4zee/lnqp+lfNESrPDJxOu1y0UNkXvHPcMGGshBIIxwOnTp7Gzs4MLFy5guVyO6taCQVxNALz4UYkIznNxEGm1WoXcMEiMPftZE44uCk2+UcjhUGdqq0iFhNaPvxfCJ+luMBS1uRiSSGoCtnCnWlZdtpvwUoiUmvmUddDy54433LY4dBO+y3uZ0g7z/gwQT4zW71R4br9Pkp73vcPDly/jgQcfxIULF7BYLHDu3Dk85vY7cP7cLZh3IWuoWhaUCf+qFLjZ8G6yBKHQdR3ADM8O/TDI+Q8DHBwc4PLly7h07SLOPiVnGxTH381mRTBBtA8yhS1n5EJJlOgxE9io5joyJ6pceEXaCwvZZ8jWdqFVSVuz2QJdt0LvHDSMVevnqeK3tWpHqGwIBs7WbTwHPEHXW7um0DSwki1aeQEK91Fj/bTqtXodGZnxt7CTQIlrkVqN1RrZVK7r8NqmXfbC37wFclMbEqN78eJFMZPX67hB3HVd83SifqeCnzlpIfImIcwzp3sKAiF0XYe+77PJk+ksbxDLB4fMAjjGcpp6kQuEqnEygOOxi+t/Z2m5m2rhURfB/fGbZMXfhctCcd+mG0NdSK7WahjCrzcwgvRMc/f0AA/oV2sc7O/j6v41dLMFup0ZjpZLfPCDH8TFhy7gCXfdhZtvPg+iPjDJJIg2jhXbiugIWBqrAZzzcM4F1xXj/vsfwJWrV3BwcICj/hBnkdJ7EDEsiYXddWJp1AJKrakaR857MBFMCNA4rqhAZ0ruylHkEvlgZU+X2WwGY2eQ+0/KDWVrbcxAcJJynLtT9y2Y5UQxjknVs7EvbJ7fJBDSkyk3OBeW31g4tKwElbVTJfI6pVlVhrdkLNsLBVUyMmZM+md0gCFeBVcMhhtIZAaTjxoSGPDB/aEWgDEhEJI01hZZQ4IZ9uE5CVNhVu1FNZpwqpMllYKeQWDP6IcBvRtkW874CHck6cQHoGco4lv2SEeNkl2B4AcrtOEQfaHjRrwwPeFOmFiI3oAsPB+kuwkTKoTlg5soj2UelzZTpNH7SZM/Ew4tYTB24bUvHpparNZ0IXVHlhyNvIQ7ap8hoNYhwwsyayxHf1WSVpzuIMjh9WSxf3iIq9cOsDzqMd89BZgFYORCqMP1gPd/6F48AXOcOrcjp3ojmU+NNvQNbJybcX2GUtPgdMPeo+973HvxEi5d3cdy6bDqCevVuC9nCGTnMNQBet4gYwRGBScHhuJlD0VkAYM45SGK6pHnmKKJOXxI4USQdyBjgjsK8E7WlhCpWAoU9veMJUgEVFqThXXenLf2s5aVq899teLKtoPiCAOGF1yTiXOUu2a1vbzt8DLyh9p14zP+pw/DscGYdqcUJUn5icIq2Rej8V9PiVxao0bRXCbNcgKhwImBZf9NhgrG4ymEZSUFg4ukmEpGjN5RyyCmlKtXWtDuVQNKr8YSSH13eR53731YgBy0f01fNeECUQmYyYskCHLO1JCAUbMa4wG526oiNg4qXhy6UHaM0CqBG2v5TeIe4aUsrc3pKaFwXFub+pV/estXhj/K6YvCgg8qQcBBUk6T9B0LQH2eNCvhYRw154PDAyyXK3gOEddEMOHwlvceB8sVHnjoIdzR3YK9vT3Mug6R1SjMW3H/jDZaghMEkIkapveMdT/gypWr2D88xLofsB4c1r3H4Br0QxTCUDuM7EyuQaRIxxp9JBYARYur1E1T2gogGFpIazfqhIzMxZcpVgnMYo70HBNvdPWNS+2JUGWq4CRUzkvhxSECmMIGeHKLtVyY9QAoe5+7muO3UaGUvzl7N172eZ/BBbip/0aZcukXvDDnDX47PJ84zYWakEQUJWRLK603nLM3xU/5LI/VH/U4+eY4OBG+JJbwPjnJmJLjeWZ0NuRk5Dw2aTyWglFmBJLusZnWyvM8SYkMqrrMGTkhLrp0DkHzomT5m3AyzGyz+DYx8RN/S9PtGUNIa0nZk1qESSCodgqTbeiP6GpsNSVloRSYuojZeRweHGLdr2GMgXMDmD0MzSSBnyH4Drhw8QK6GcPcSpidPh2vGBUmeCxKQr/JrpicgbAR7pmx6gdc2z/ChYuX0RPkeEHvMQwOrrGwKexL5QEQKn6MUklIazpajSOhEeLbqPxb6dMzg6yBiUoUsgZao8tXdmDAXiwLay04C0etN3hbpT7DoN3rzs+o95byYgKNsRx4bdHUsUJiY9mcG2kMY+KrSQJP8c2JNptd6LoolbzjynUJhdTN8fVSEZanoYu1JiGaMUbPUWsBE31Nab1yIXgmvMJPQ5qEGUAIDSdTasfNKITQRooOacMkOUzG2jsUC63FnQkOEWbhufjWlBcFbdLH25o2sJqtSs048+fFM5VPXgV66VoyJj+7mtqoLRfd/NIi7YwXQqFfhz8MaIRTtQTKfvMWUNQHMfq+x+HhEv2qB6ykrmbnwXP5jiDM1u7M8cCDD8IYuY/6zOnTwmxN0pSDGSfwBWHBBS69KtfwMXg/Aolc0B8cHuHS5Su4dOUK+sHhsPdgJ/NvvAizuqhbSNKjcoJ/VDOpJFFpq55FyyLOaxa5o/gLZyJ0Wyj1kw7ACVooMjkV0jorhsL93mSQ3xahrrP0d8Br2ED3fijmNsKYDa9lIec0aFiCWryvxlX1mfhKpnGjtACKPgocl22VJdHLaP8n0nKmPsbuNwgq1h9lu9r9yJraUE4sFGqNN39+vdECx3T4SHleaIZi/vfoA8yv1Sr19HHJJioZB5sjFaIV1BAMWxfVSsMibmkgjwa+kzuqFSJXllyz0kUp7oDxBmNT0MTfDcapwEOK6NC2nBGgeJiv9BJsGvfEfBKB2WBgj8GtJQcPOngycM4I07GAuhkAYCDC+z98Ly5e3ceT7r4bp8+cQUcW1lAM59RzeA6J16urw5gOCJo1kwWzB8PHezN8YIQXL13Ggxcexv7hEuvBA6ZDz2sMywF+PcANDhjhi2CsgXc+7udBR851AkUTNWVl58UVkcp4WHJlkY1qU0Frg3foDAHegw3BxM0HvfRKNsg7TKyRIGCH0GftSsnPMOhzDSufzWZjq7B2k+TvKuat8Hgv7dWWRx7AItcPJCEb20FbOMgazUl0+3UZ923UlRTnOd+92sCjRvw3Skgcu6CrcrLoI1RIb2jVm3zNijACCtfTsYy18TpqHRwzHwHwIBgwp8s0IjNlBnFyFQGIsdVyDD0cFELupxyPPw5iKwafrIpN7qU01tKaAIL/26eEdhwjaHQ/pS1stt1DaD6TFyVsWX0T8Oq9j0uY2aMz3XiugvVXb845ltA5wXUiYlaTHgRPFnr14BSsm9/V1kg6FzEzNigIHuwcvF9Dsn8zFvMFZrMZ7KwTZ9asQz+s8fDVSzh89xFmncGpndO4/dw5nA57Dd1shm42i3jROzGICG4Q7dYz46gfsDxc4t5778Vtt92GM2fPwhiL/cPL+NA992EAwcPAdBbOAavVGv1qCb8c4J2HWdRjVCujEAcbcZEhLeG8UWt0bSanvrz3RdoEDgJIVqGkktC9itr9Gl2w1d0YUyV3Rdf8QueTMxfi6H1lzXrv4v0kdXsUaVuUsXjxDUq+pTjT9V3T9xibOVxB0IS/nXPB6s8vzUmt5SmAUrs1ztoHWKOdcwLFcWuhYE2mrQGiTQTfY7KEKWgy2QTlmicJkcS4kjj+LHKnKpXVhKIac/y2cLUoPPpdQdxRxkOBT9GRoWHWBicQmcFTakLZiyBsWosNSMKshLVe3D7tI6iQgAdzDwO55Suah9g+u6HuYdR/J1N8WrBTOF0rz0MEBxmQ3ipVFRMHr+4JLofIgSI41YlzzmE+qYxaaY5nVBIuC4FAwYUYs39q3hjGsB7kxj7IRqSxFsYSrO1gjcXyaInDg0vomXG0egBn9/ZwencPe3u72Dt1CjeduwUXH34YB4eH6IcBs1mHvZ1dAJKYbN33OFyt0a/W2L92FQ9cuoIzZ85gsTMHw2N/uQbZGRAEyGo1YFgeYlj38M4DnkEjt6OIZQ7SWTbSJ2gyooYzzTK4OVW1ipmKAc2cqr2o5SPuTBfXuCeAzSKmWSGGbGpSoOEsKIKAdDNiyGwcAJe6RVaCscIoal+mq0eX1GamlxTXRLuKG9WsS6tCb0ELrZOqnQi8L8PlCL3aLlfuoLbw2+TqyRm9wl+7t4SmM5d8JihLYbGdtbC1UDCU5dbJOJ2jxK4ARHdgPpeE4GOHkjBFC0D9mPU3o1KPSQmnsFAo0klBJPE7HxhM9SJOfPlNAU82OfWWVqHpUOaHzF0lOoSc8OJPStoAaSSIJmBQYBQFPoQQdhH8XL8QN1n8qs0wKxgKGAlZeF+tdZTPdY8F1sDYGbhoLTEAxdGILDkpAynZYAhfpLT084nIBcO22k8hEFRLtQY2nH/xITLaOw+3HtDrLXFEIMjG88x2WIOwXK5xrWfc8+BFkHeYz2fY29vD3unTuOXW23Hvvffi6pWr6PseOzsLnD19GobkfuL1eo1VP4C8w87c4KFLV7C7t4ObbjqDnZ1dzGZzWLGjMAxONsKPDuD6hD/ra9EvuGKIn1+j6EoFI0N5hvuoVAUpTOzDlY3Fii7wKD0yOGzMk/Uh6kgINIbChn8SYJbWqOgE4aY+I/eOGzKigYfEerr21OcvjC9jivnKiTBttjjKdykkNTHYdgLP3K1VppuJ2C++Kd1JPvSzGa76u23o+jjXcSY29YvN/DUrJ8p9FNrW1Q4gaYLRhLJdQ0shGMNJU/TthT3yB4b/8Kg9QEXwFFKux98+5X8sIVLtfJPU5YnvjykRxWoyZhpJEErE4XbEcMKOA9xaz6n2UPW9ya1Xu/hUeLaYSk0H1hhM35VMIbJHTq42uEwSUNkUq7ApTHsaa43Xu5dijcF8PsdisUDXdXB9Hxnp4Bhu5TF4B8cec+/kXuvOopt3cOwB5zCfdejXHstVj2V/FQ9fuYb3f+g+yN2gHgSP/X2Po9VRVKgIBpYt7MzCe4flsMRiZ4b5fI7DwwPs7gLzmWip3jusVitcu7oPS128S2PWuGeXVTOH8mKGibvP7XnJvo5/H6dH6vronQc7sapsN0NnF7K/QAZsgjcg0D8HK2+0tindD5KYvr4jgA00MkjHpalK5JkeMT2eBvQQbBx9DUvl3qpL4aPXb9SyyB63hVLbkmi5wbYp29F8wkuhnG+5Xk58R3Psslq0ROWFHFFzz7RKIoI1Fl3XhTtphSj091Ypwv4yBrG12Cs+n/6m9guOK2x41fj2ejaV1Txtfpk9NNUizpdGffViq2z2zUMYG8pFVN97XCxHwojI8+eTpQlfEjocNpxB45DT6y26wDsCTp/aw85iEfrS8yAEQ+KO6b3k35LDV+GQHXks14c4c/YMmAx6BmBnICub1WwtYDp408F3BHQdzGwGdB1gDTwY/cC4drDCTefOYWdvFw89/CAcyynmflhh3S8xDAOsJeztnELXdSACDDFmXVtQp/Ulhz5bS7vFIFSItPHULgYMNwzoe9moJ3bxEh1llrmLo7U+THADqcWQljaFtPdlGyVMhPKWhuly0nU4Xb/qKzcXjvm+tW8xWk9x3McrbydVhpprc0M50UazXK4iv0f/4ZSZ2tCSiYK/tqqX/xw9h5yY1O+hGkgGQ+v7uuSIOc7MbCEwN7tbEdHHWiwbCLjlUhIBIePs8u5i5AiiJVFDE5dOA6YpohvXndam9I3jkLGdTEzTW30E5xxc8HNPwhQN3VLRYDiARIGQTc+29dOez1K7K+qSaI6nTu3i1N4ChwcHWPcDaLYjio01sLbDIlwhOgw9DIDB9YCeJvcO8/kcTGs438MaC9sRGJJKQe4bGMRHPjBAyfnQr3ucPX0KR6sBh0drrFdL9KsBy/kai505um4Gazt0szkO3VUMQ9h+JgNQuW+jDCbiYIM7oU2FHAWDvtXNcmvHe0SSeK8HYQiMTNrQoIHYKovLDAxw59DNOsyNCUEJASKRdHF+c6ZPoNi/CnK1JnRTG+qqyhPsZXBOlWjFVMJqE1/ILZkCe8fwnU0b5ADi3AldIpLsJjofzXlVX9145V4FYULvHpUT36cQS1RT00jqgTQFAzJNlze7WRJDHT8XE7kdJdRifMdJyhacTe1gw7ebTLUpRt0UCEowwb87OiVJytxKQsj/aI12G5dds3hO4btaDMUzAxQUt9YmKJHEhU/LRAr/z2GTiCThGTlu5fd4gCy8aAuHJGRyBQOQswQeQj9d12G2mMMzMLBstDKLj967Af3gAF7DEMklQiR7LsMwwBJjbg0cS74iQ6ouhDvvmODXg0TjWANrADYO87n40I+O1vDOwzvG0i7BbGCtCULBgtlgNpvJZThMsJZguoYFgCkaz5kQRKuzucNI66TdIM5fKp+KOkiI2MluXROuH84WBCVFGfIwDHKfyZnT6MKVnYhhyBytshHDrPhJuaGakX38hEb107jbSudxZZP7+ZG01f42JRghQlxTtRWnoOQ37OWnu3MFtOQl+Z7M8eUEQqE8cKa0kxMXoVz8caFr/bD4NaJGR5neZx9ziG4Cw9o02fkgtS3mMcJLBl2OpIWg/M+WD7F4EhdEgYBYSzaK07st2G7RvuCVknpCIWx2wkKRb7N3jHSwKDDZyLxR4nla267HP0aoNcLEjFHVpAEfUp6gatrLBR5xmiMt71W1xRFH2KhYKK2kUQleiUMsPoB5Z+FnFuu13BbGfgAPEunlnNwi5sFwg4fsnzDAA4xhdGRg2MDJbjBAiFqzh4Hrh7A/REAH2E7u9/Ds5TosBqwVOh+GHqv1WiK5mAIDDXsRltB1FtZUSzZoCaSrkTL8MRAP5+RKRWX1EaAcCPkhwiLFRfxFJzFNHofvPWt9D+d6HBzs4+hoid1Te2kmo/QJTRkCrAH3CUodS0mvGVy5PjShgde/Tz2bZtQlnlo8Ztq9Vbbfqt9yKcW716VWPm1aK64xTcfTVPCOUV6PKydKnV2aIwjMShNuUVjwDYmfMxSOcj1XSEI7pviWC0LIXCVRa0zZHfPJyk3R9DyfuGSq1e/1RRb9HNvNR9ayxKKmxRwOcm0xCapdU9kT5QsOhEw9y8JvC6UuW7IS56/3S7A3UbCOYM5M6ZRvqqpjcoZMQYvlbD8oRGaMiE5uwlMAKT3OBBai6Rz4Uhwck54vacRgVwJubIFJpaREBFoFwxkLch6+d6DBwYIxsx5MHg4MHgaQk8gjaw3mNIMbHBwBxszQAbDGYamJGj2DV8ocJZzVWjnU1Q8Ae4Nl72E94ZS1cM6gM4zZwoQ9AGBmZ1ivBuwfHeBgeQRLBrPZHFjJprGdz2DnM8zMvJ7AQI0ZvalWHe/l9SCaIS6vClfGEDw7STpIwngEnz7dxx0mjkKiRm+DC8NK38YBawt05IChx+rwGh5+4D6cvek8Oiv7HIXSxhLKOhjAdyacAk+8gVnwkvMdr5YI++bJ9vr3nC622feL1kiTyae6qqFvEih1/9pf26LzouTG80dBiaj61T+NroVMOnLm7vPhoJ/32p9Ua7kDW+WEqbPTjn9OKLFkY40AejlpeRx/nJKy9QRt8t3rO2VarTqRSUCP6W8nPbcpm32SbW1mO+ndElzT/RBJPPkwDJB4a4dhQIz0aH2Tb/QnN0gqliQUUOP7AWSbZVEy1y2PmbnCGH7Pzd94UChz9xhjxq6rBvzHbaoTUWHh9YNHN5+DuhlW/YBL+4dgs4PdxY7sHcBjsVjg8PAQHgPmOwuJOPLAYncHfe/gD5dYOwe9P871DsZ2YCMWxjCIIPdx3eh4ffhGwmLnsxkW1mJ3IVlSV8sVVss1jg57+N4DcNhddGA6hZtv3a3wOb7TOL2Js4AgZcdy+4TkX1rz0mbc48MAAnB4eIAH7r0fznmcuflm2FkHVt9V9qkYNgTLQB8PsiFak7JSlS7D+QhWpW1aO6/LsUEkW5ZNVsYmvjT1zVTZ5GIGdB+iXG6WKET5QZRSTt/Wwu64cuI0F7kZVwiGSmOPl7ijvnyFR66a48yu/Nn1RNS06kT/qKGCaGoTr7UhdL1ipOXmyN3tx0+aMrbWm/yoHIpQv6gpN3A05XYZEWboXt8RURE15pyvb1cs2wlZcVtcqDaB0zfl7znMozYywcQN+EMleT4A68Hhyv4BLh8c4tpywMHBGivf48LDF+G9w97eXA6l3XQah5evYn1wgMEzlr3DMAwYADnBTAbOMezc4Gp/gM4QOhsS6rGH9wRmJ9syMDBGLsKZWWGo6+Uaq+USB8zY2dkJ+xkG3XwOv+7RQzTI9eCx7tfo+zWAeROPcZDVX0pjXHMSxReX+K3bSGtCGjOwsPCQzXOfBPvQ4+rVy7h6+SKWh9dw6uw5zBe7IGuD28qDSFJ+jEu4TjTQrJ5X4FFdVSJCSo2wWaIH7abWcj2WqXJShr1pXelPvR/CWom8rG+CzNvaRoiki4gyvqsKWO0apLZFtalcR0I8icY4OrqGM2fOoOvCidApblUDUxkN075gKS3zS5+fVDOfksC1JnEs8lr8pkUY4V/MKnRMH8cJNv1E4S2jM8porJwYVAuviSPX8gsFsNU5lZt8SSBI7Y4Io3NVBfCAWplpPOUFK/nvxZxUc94WIsm6aLWZ+pRKg3M4WC1xsFxh2TusHTAMLrRvQEbO27hVj6PVUjKUMjA4wLGDMTPMZh2AXqJxjOwtDIOHsR6dlb0HsgTrDdjJ/kVnbbh7IGy2GtGGfT9gtVrBmA5EFrLRbrD2DoYZ5BjL9YCj1QoiFMIYUS38SfTLwEmRMFpXqcEkh+s1FDT0dIl1sPpkXlbXruDapYdwuL8PQwZ7p0+DZnPR9oMuqRTAmUsvVzTjoLjeHNVTu2E0nJ8W3jTyBi6O4TlAUgLT2BONKW62ZbKqoOmZnbq0BE2tnCY4RoMpvDIUkEIZck5qJV2HpZAAH8O3jVskJI065vtt+t1240TrTk1k/bz+PWdQOQOaguMkcD3SUrhHqHy+jRVG6WF8NiVEhaHI+7RoOAh6SSa3AdLQZqUgbLISpsbZGktrTFWdBC/j8PAIF69cw5WDQyzXA/qe4R1gOoPFYoadnQWcc1ivVxgGh96Jts+wsJ2VA1ya4wUAe0bXdRichngGB5GRpH6zboZZZ+Cdg1H3ZpSRMm7nPDTNuv7PBYY7eI/B25TMMR9si1egVBKkbknXohMEFl3RyhQNE0FST/skPRiM9brHlcsP43D/Klw/YLY4hb1TpwCymSqgJgshppFRxSTDpQiEoOgUFnoVTVbgYnpdF2Mh5ElYJ8c7/rbl4ZDTyjV/mFJc1K2be05q3nOc66j4LsIVBL6ikFIATi3Itiknu3kttDmbddhZ7MRXpnLB6GAiEJWlMGr6EbiE2nWTdgHdLG4xuMzM0kvNob8HuMU4LYDNdNLEbHKTLWpF6mqKbSfGTUULrcJFvTjpnH2bMcrW+JMgrJsuBZzSTtFGBm9SIoVRq7tAzVgdeb9eou6MKGIFaV4kxJKrerUQmBRqxVjKB21rqKoP4MrVq3jo4Yu4vH8IsMF6cMEtQtjZ2cFisYvlao31eiXJ0wINGbKw8w7LawdwwwDnJEOqdz12d+dYrx00uSKRhO2uPGNvb4H5zGB9tA+YDgYethNmyHoTH1NI0+WDuweAsXC+h/ES3WNt2xzLtero4KwsLcFVxiRqXOZoKjhg+oVIGbWJ/uuh77FarnDpwkPwfoDt5pjNZtjbO9WUWZr/UORLOLSlc6VCFhkNsIf3auBIlM5JFciEh2DxtPZgKsUxZ94cLd3Ub7wfvuU3zdpLbWTBHA3LOK+Xl0n+GMak+1SiGFLCY/ipwv9RFwqquUS/rJr+ROi6GQBgtUp3BZoN/u/jyjbmXfsbhTX8C0yUMylvkElzZMwD5WLRX2qNi1lzsnBdu/y+UGI4TEr+PJnObQamC7rsQZ0AJrSrbqGcN6rggBdzP5rpmSlOlFfMWmfAIotCysYhCZ8lFFV9pd77sA/cY91fq3zADImaqgqH6zXDTXgEpJuwjObByeEuF2ypWSVMVl3EW/ziMxbGOjjG2g3gsKCc9/DE8OxAZLB0DtyvQYbRr3ocwqEzM8AbuIExN8DuAjj0DkeOsSTG6bnD4+44gwcvHeJwzXCeQOggqRnWAA0wdob57i6WhxadBYg8jJGMnMMwYD6fB+bH8E7ufOBehK8zBOcJq7UbjTNKEPIgNqPIYKGFgEPDkiDShjMwRAgXiYS5zNzBhYatwpYwsEPvAHgHHo5wdHSIhx9+GKZfAbMdwO7A7t4EM1tgxg6eEyPP584A6EJkru4RDJBEVB3ZKBi8fusZbDSy0Ed4dG4TqI0oIkpJ45jG+Ybyb6facy6tMhXC5T0g2l/rNHkpHOpn9bu6TtuaSLDEOgyADFzckIcyDbgtGfKJch+pz6oezHq9TiZeNCk3acHbMf7rEQ4RXS3LoPVcmTXGZmlu8k331J7cWjd+NMv1uKdq95ceDhONLTM/MhtmtGjUMvFBIAwh9I0A9q4BF7XbEYiixphvtjs/gIwFmezse2PO8p/187z3Fh6YGcujoxitwWA49vD9gMEx5vMO83mHYb3GarXCYrGH5dEay6MV1usBs7nFHXfcguVqBT+s4HoH7HSAl5PQZHrxHTuPvVNncHRkg0Ug/a+XR7CnFjh3/hwWM4P9/UM8+ODDGIYe8/luOCvBQfj2EQW2s9jd3R2PMUqBTBGjcg1KwjwPm0UARWbiPWBs1Dxr7V6zIxMYDozVwTVcvHQR6+URhvUKQ7+GJQeYBZg9us7i9Jkz4kNXBg2lwdwCIcAQWC+RRgj1zgCPDN4kRUHuKddItfGtbURlEEQd3UlEBc3V38c6VZtd1wXrOCmhnLeZmzkY02nNV/LnuSCr9x1Ovt554vftyon2FOqQwbrP0vswYfJUEnMk0Rt1Wt/Wz5LprIpTW7JOM/pp5CVGmv5u8zmN5EBcXOXrkwi5emlq38mMLgi3MkenXC8JL6XYJow1kDEOfbAAGRyiatQqYzDIzJqjAFH7prnyPyllBlERh16Of7MgqOmuPvVJRPBgrNZruRbSiKY86wieGLOZbDCvV2tJb0GdpFnxjM52mO3NsVjM0JkZdnc6LNeEo+UhZt0CO/MFDK9gmGBBGNjDO4eZJcw6g1lnQ1Zhj8Wiw6m9Xcw6g+WyD7BLjLkJmq33DNsZkCHMrOQ1cvUdzRFzweWkUV5ROKhWTQDCPhCJpQZWXbJYuJGJkg8KAySNhWePw/19XL7/XhwdHcLrFaaZg9XaDovFDk7v7UY3RjbFaX1kAr+m1an1r14KZsmVlF/j2VrvzByvcWVdL0oLBYra+41T9DcSbgm8UZutdlp/53uX28BSj7l8V9Y5qVC57o3mEgKKE83hmRmxRK3+yHXnycnS39FGaI6sbdstn5cLqL3hhajRTOjH0GiNTSXXQqo312UpbOxL/6vyRa8hzoS1bvSpW4Gd3AKm08/cwDvS3bkcXFNJdOsgEZ4oHYUoqS2HOLWIFO72N8JQTGdhbScMvzOAlZu9AKDvBzjnsFjMYQxhPp9h1klCR9MRus5gzxgcLjsYYsw7SbUNdX2FjuRQkZFb2giAFRzO5x2sMdF1ZEzSqONmMkOEAonLDjDo+wFAedMOBSUkKQiZuYDgYmmbTYEpqyVQvQ53IhA7DH7AerXC/qWLODo4APsBQNpPkubkANV8ppFZAQdA08WXz1PNRNsWfXqu+1mtfcycGcY2geiOAhDSjI+tgU30lNaDrs1aOIyFwDa/t/psuY3qskl45GnHp+pOlROdaK4RLS8A2VgLfyb5IEwgdyldh9QC2ou75Zdr69bj78ZEV2lLaE1GGfqo1kYReXAMJ1OBWUw+2uOrS1kn4bPou2om9SNwb3Sv6OLNGHWz/6BdsvPJMoqt+REGDPRiFvXphuic0FYOiI9DaLGoBiwVDvJ3Mpbyu1g3LJiu62C7ATyIL92QZO0dhiHslzCYDOYLA2AGYqnjIfmL5mSxt7LYPbQSWRTjx2X3Rf914aJ7aCpoI8Eazjs41we3UUi+54UZa3YKE10rYp26odrUFOmjM5whVb9RBWU8rw1bUeAPQk0v1PFujfXyCIf7Bzi4cgV+CG5kPXAGBkJqfM2CbEZ+9SAadFKIR/NYJIfLntdzO2VJ1BvEo/rMGckFeqyYby4YCugn3Uv5d+V6Pimv20YQ1P23PC3yO0OD4U8Kz4lyH8XfokYS2A1X/jQF9Do0821Np9B9/LmNQCgFSIixb304hbtoFMlHfALpOzUm1SjLfmVENXpqi6d29+QD8QWOTGGxawNJ9y9h86yMJxf+HLisbkjW6X8J5Mfuo7GJXwvgFKKsmvJmkZAgyzW/4h2lUcW3mTLgvYuXuphw17L3wGxmQSRCQe7wJbjBYTGfYTabwVAnrgvjsegMzNzi1tlpzHbmcKs13NDDsIElAyLpw3uPrusAw3AsZx2MkaR3fb+G5wGLnTnm8x0cHR0BqzUG7+E0SMATyNhwHauLQR2NQServYW9Cu3MSYRESlTe6eXEtYHFMKxx7fIlHO3vY708gndrAEbkqpzIkz0lYsxY7os2Nl1gk59EUIWoVspyJt6yvje5Suq62nadmjp/z5lw2OS6LnA1IYg2uYl0DR/vFdhsoWzzXQs2qZP/fNSFgraZHTHPMgCVWufE5xPmU6teS/rVoJzU5qhES8Wa6rYzLaj8LD7Ru8G4Ua/WPGwR3pbXbfk49cm2111w9bMea2Dy8SrNXEVvCNyoWWVXM5pwtwFSFFoSXiSpKFyZ457BIQKqxk/qP41ZxkuUHI9UvCuABKiyy6q/CQSNbbJk4LwDew/XD7i26nG4dmDygPEAe3TGYGbk3oTBOIk8cmLZrPsO/brHen2A/cM1Ht4/wtru4eY54Y6b9/DY28/htpvvxNv/7INAB+yQwcJY2NWAOQHG+3AlrMeMLE7feQ6Xrl7Fhx5aw8Nj3hmcNQKvWmp6by/IwhgLwwzvgf2jQwDZZnNImCf5rtpLT+Y0uPocAzbcLBemIkZ+eYmmISIQBjCvcHD1Mg6uXMWwHiSCyUlb+VRaFji4I6AzgDFwYBhmDORhnI9XnJZTllJATx3s2oZJ1oxRA2LqXD+6Fo0ReqjLca4WfZ/2qbKzOhu5Uc1pVAyHEG+oTG+Htl5/SelVgD8PS4Gy5jnvkOIQH42ySRhEPahyGVVgbiyt+uMplcHmmk58HLVND08+EUhGQ2N/aKkJtVw0XH1LVDPs/KapcgNJYBqPNZrTCCKQkMwMraMIyJCQDJYGM44wBEbCIfDTUxWqW44rlRKfZYUEyGieJy2CcYl4zrVU7dnLwbX9/X2s+16GZKz87BYYBg8X3D7WEpz3ODw8lMNpszluPn8zLq0fQL8ccMCMK4cGpw+XeNydt+H82VPo+x7LNWMNoOtc7N97J6eb5zM8dOkKDtZyIM0zY2mA2e4My6N12FsA2Bg4yO6Bdw6OBdfL5QrXUziEpCKccyCdK1ueDha9Tywc169x5co1DOteNmg9iwVlslh4PYjGIlTEBVceztq0KHOtXtfSJjfzeG2NNfWWq7W2QuK6b7R3nFXSci1vhjF9G+EJu/m+eJfGU8BaPZvqa9IbEfnW5LCKcsKEeLU+rTxms1Z/veU4ayFVDBA1qj0SiMYTkRCbE/G2DKswiYu6rX7rdyeX+NEd4xNDlNUQ3EYWSA7+NvyF1Qa1NGTTVBaViQTHZvo2rCRcldgVH4F56+/HjG1rGovulFS8Z/TDgGvXDrBa93LwTCEiwuCB5XKN1XqN3g3wDNkk3p1jAMHM59g7exN291e4dPQwlusBnizmO7u4dPUq7nrMnThaHsI7h36gKq+W+PWXzuNoPWDgDo5JmDUk3PHsTTtYLiVUFhzOJzgn11yyXGrUD62ouTA/HPizus4mlCdmTgnp4jrONmnBcN5heXgEt1qL6ypj1qXoF4GQt+P9psiYtHeQu3ryGxu3caMcVy93R2q/ZQUFfTOPmdrfyL8pnldCUNljreS0Lbrt3FmbYDjODbZNeQRpLsrw1JMwqvrvbSdmcx9J7Yz1VPPJ/k79TrVR9Hysmys3gacFROvbXCcutYSs+1xtH/UNJM1lEk7K7IvA/5V1u9xVhGlNIrZN6XdDJLaLkcgaIhqdEq1tnfhUiTPfS+HmNJX9T5QmzhvtePZYDwMOD48whLQVIhREc1yt1lj3a3gv10uSMdidz3Hm9B4OVz2YCGvPck+C9xjYo+tmWOzs4P6HHsTTn/IReOih+3BwtMLRWlMrC3OfdQaegMPVGr0HkOWNMmRwem8Xi50F9q8B63WPwXk5MR1vbZOJ7JshqY3BjpFUMslMIJQ4EnpyzmF5cBjPolSSoNGp/K6CzHtxH42+yGg1X9flNb7TGvum/cZ6TcjDqW+FQq43+KXVf9l2AXXrw/SOa0WwrQAep3yelBdPlZMLhePcZ1uUlmAANk/4uBFUkXel/+xk/QPtgU0LqVwgeO+Lg325b7S14VX+1YabMo66zSQrfy9Mz2JYFJn0qD3KaBRj4ZSEQqaFWEqMnAjQlNpV03UyQMo685Uma4nksFPdV1Wul+i9d+j7NdZ9D++AgX1KUMCM5f4+dncW2NuZYd512NnZwemzZ3DLmR3c+9AlPHjlAA9e3se9F64CDCxmBvOZhQfj3vsewvnbb8O5s2dx6eoS15ZHIDKRHXRdh4EZR4dH8Gzg/TooLQxrgNtvuQmr5Ro7N5+RtNv9gHXf46GLB+idaO9MaFgKUFMnpg/apBAqbkVJYIDlFDQjzZFzDv1qjeXhUaHoqKDVCCWdi6SESXjtMPSjc0BTICkDV2tB2ywsl4a23opKar6f4lcbGOg2lorQZ2Lok9Vi3QpmYLQPSWGd1mPbNhppypW0rdWh5foshQzRI+32epo7RsJNtj5SB69XYrV12qliqg2zmvGXh/x0waSkC7XPc3N0QxY5FD096X2RMOwY4hyRluFMVCTYaoEQhXaQVFHj9AS9dJe2INzMZoltx41txWlmvSj2Hg36YmbJjHp4gAcvPIyeHY6WSwxetmj79YDzOwY3n9kFWDafZ8aB1kvszRa4+dQC+0crXLx6DTed2oGHxVMefytOLTo8cP9DuHJtjd4xTt10E3YuXgOuHEVXCgCJ0hmAfskwuya47wbsLixuO3ca507v4IDk3uejoyWurA5hfY/ZbIbeDwBLlJZrHAJM2blChtfjGAlLug8DDontEEnAeY913+Pw8BBYDyV1UKZoZLjV+fEsQncYhoIR6ono/BstuesIGM/1JjdUBCvrK197RdBEXXJNnXTLd3OfI7xu542ZLqPvk7U+JfSKzzfMcYsGHnX3kaQdqEwzQG7HQrUhq9/E/4S6EM2IPBWVYmAkc/TvqiQlUEioSInxxG+01Vyw5IMvJ5uoBWUOnThXTGRK+iwwwwLmnN7qE84tk64LuAOYc+ugjErKrZBEDD5gTi7PsMF156GJvcT9UcftpCgxC986QxA01WrFwsBAr+lKbJzSxR0UTsSSFVwZC99ZWOYxfllPE6NQYdNYM00GBrayWoBMK9WG1IcdfHCy+DUdNeJiUxedIQKTnJK2xsIu5uiOOux0CxwcrdCve5hZh93Te1ic3gW7AevlClcOD3H5sMfR0T7OnrsVt91yHr0jPHDxCm6+7WYYHnDxwjVcePgKOgt86M8+AD5co/MWBAtrDfphgGfC4ZHD2gN+MccOAOtlvHNvgR546OEHcMstd+CBhy7i6v4RVmuPVQ8M/QogvbmTMLf1kjWAmQHejcau9JxKUEzC3d8MhicPB7mGlLyTfFSrQwxH+1iTbpRr1pzUXlqKBO9YUoCzTIF3HuxlX8SE+fHOS4LIrhtp/ul8BwpXbB7OLGNKa6J1sVCtWMVrYAvzKVdAWa/uCXSiDSERodJX8L2OLKAJ4VSXUtGShjXDarojIvGRenwtJr/JFV/j7CSK1faH13TiavO+8AtnQDeBYCA70xCNUlYCzZoK1eMfxUSNTcjYQ64xM+BYDk4pEQCbEJREUXrSqMuRZxamrv6dw6bvLZkgQAHOUgPnE58L3LE1kZuB8tRAUjNERoCEQOZMUFP6nbJ/vsJFU1vLmEwuhpNHicRNYvSegA3E19CCylelkGg2wdkvOnQqaaowyzNa8c7DDQ7DcIj5zGFvd4FzN+/AeYY3wKnZDHuzDtwRZiT+9f1lj4dWa1wbCKZbwFqDx9x+G+and3B2zrjt5lN4zJ234p4P3YM/eu1bcNtNsv9gjWxSEwFu8Fiv1+iZMe8Y58+cwi1nzmA+F2Hd+x4r53HP/Q/gYP8Q/SCX83QEeEOAc2FgFK9abCJ2ZA+m+YxPI4PjcOAMAY+BiXoPPzj06z7cGIeiTVFoymtzCcG4ghyuc4ODV5dXplcxMKJvY8zoRsBtmdhxVgUHJqLjVxalWOJUKdBdvK800XqmYOb3f2xb2nsCWd6kXHPmsl5LMLTKcUJI69QejqlyAqEQ0Yg0ohKAMTk22sn8cHFSAlFqymq1SIhUYJTMeVszKJBlCdhEqbUMoqQjn+TbKR/lyGLZYoILi0cZfUZE1IA7wpDhsjYGIhwVzOXPyrcZ/jMyiEgFxsSMNx5PbqRV0Uv5IspQEQVDTBkS/qtP49nphkYq4cMeloC93RkW87lopwRg8JhbOSw27zoABmt3gANn0B+tYK3HbDbDzu4cHTmcWsxw9vQpkFnggfsfwAc+dB/Y3wpjLSwx5tagt13IoySBrnNrcO7sLu687SYAHkfLJa4eLnG0Zuxfuwa4EGNP4lbx6NB7HyJJ83HGkZXK2GbEZ3gLCohejhyKdw5u6ONtYaGH2JqeTi+aJ10pBOeGcPhPcM2dLZlwAU6itzr6SP/Vmm9rr2FqLXn1YFQKWsSbfjvhep1itsdbAttr5bn7lhtYOg6uKeskf97ah9lUtncfFQ1mKnwmIHLwRwxFII1jbvnmaumslglDNJiciGqCmJqokmmmznLLYbKoQKKyXqFITxBU0beiCsEVlumykgCuHAcRFfHaJa44pmlolWK8pCnMSyKKbrrNox+PiyhZUcpIOODeO/AQAzy3KvnGYmQC2ft8/Cqo5Ecl8Ar8CCsAladWmZPm2nU7WC/XIEcgLxvcXWcx+DU6Q3Jv8txi1u3AA/B2AT+Iq27o17i2PsJZXoD2zsD3Kwlh7VfwRDhcD1jMGR15mFmHwRkcHq6F8YEwB+H0zi4Wsw5XLl/GlSvXcO1oiaUj8MCwRhLf2cAkZyYIhYD3rmtbx4rHEXMIOFKBnuaUMkIWvz97j/VqhfVaIrDiOkzVggLnkacZTfMjUUvODWDv4LyXO+Kq9aJaa83c6uSF9d8q2I/TeDfxiQhDhp/8PIsqpCOrQx1ox7hw6nfH+f1bbUYYebvoqKlx5m2dpJzskp3wC0XNFSJl9XXed7qBD1GVmCrUNi05WhGIf9cS+VgXUt5u/l+iQNzm2G84nvDSPlH9XSXfqiemArHQtIKbhwITGIYhLoipibY24UcjnXTBxPoCeLIuTkQX05YMZaBLFx7sAPYEuPoGg7YGtUkDUyun1G4ygTAS5A0dVH0Z1aaj6r08AOQtHr64L3cpeI++73Hq7Bynd2c4vbOLUzt7OHXqNPp+wMHqElZhXmbzDjffcg4Ej4ODI1y+dA2Hh2ssjw5wam8BAwMLwmzWwe7MsXJLsDWAl5O/MxgcHR7hEgjLpcNyRTi85tCjx87eLnbmHWxwbnvvYRzj1N6ehM8yo5udbIFH/OZY8xyyqYa25LplsPNYHi1xdHQU6DCaZNmNb5mEUGUuUzTy/QEoTVqJsEprZxxhk1sK+b5C0X5lLdTPi/E2rN8mcyQ5T7IpdlH3FKaYa4tv5HAquqRy/sfmchyzb/aD8fqa5EsT5fpCUjlLdZFrbWWVxOyVgDhlTz1ukKmtkgnkCDipBIzQEYPIwtAMfS9pi/MDNRu/rup4/TvTgDaWunkTmCA0zUBGCCHEc2R1BTdjHcYHoAiHjd/5cjNvkyCbdm2pqpmx5cjEIThtDE/a0gtd5G+PsMfSIt7jFvGoBw4I0U0e/RvRMo1tMcNagrWHsPMehgb0g4MzjPnOLi4fMa5cPcDu7BCnd/dx7qYVzt92HrunLQ72l1ge9WDP2OtmOFpfw+AYvQcGQ9jZPYW5Ifj1IXoH0MxibQeshwG6mc/EgO1x7fAibLcEW4vd0x3sznkc7l+EBaOzkldo1Q/YP1xhxgxPK8AYORzYuMClxuGJ1kVQvAiEoR/E4ukHWEfwDaukFspc0L2HZy/XiuaZMDzDE8NYpQdpQ+mFG6HMOoZtLYMpi6B+NtnGsTW2w+2mOkFP266zrL1tmXluBSbF9eQ88gQ3r7U3WTh6OdWCoMD82/AQUebnS+JTmYzWyXsuB0eBeWIU4p/cNXWCg/CYw8UtnuDZg0zu6w/iixWaMHukMGRjZh+PqZN0F7JZah6YTBACkk0yMMToboEeIqOCUDSfVBKkETvJwojDrOACo9P7fxmJT9qxfz1pWBxbTwyfYnsI82vIyN95tg2jnzEs9/D1LWskfVOu5UUzXF1NKQzPGKUlwb/iK81P1TwJFvXClVRFEnYbdoCXm9zk2kcDBsHM5qDB49RsjoUbsO4lhPIxd55GZ85iPusw7zp0sw6d8dhZ7OL8mZtgbAeQwWq9woULA46whiXCwhBumnU4PFrhoGf0jrBkQkceGFyI2jKRnKxZwPkOZAy6GTCfA6e6m9D3A9aDl/2H3sG7AdcGA0sesxkwC321EEGY1pojatSqN9l6Iznf4CFRSAwPJgdvXbSida2qZyA3F0sFTUOTJVUI4OHIw3oPCUYIETcAHHFxQxwRoTMWnlzBafL8RdqXtbZQco5z6TRdMfk3ak03uPWUJ2JTf82/I5thkDFiYWfWw5SsSd9SlCrCo9qwJEGogtTEKdtWVzhZmovKOtCn9fvE4FqNcPEiujdCfdV+06TXI+HYjLpeRiXn81TWYCD6oNlz4vmtvuJeQvWc0zzpj9hLkNCFWGOplfBWCkPtPtcK8gmM8l/fTQiFgpnT+H1dcrNYxkNyojUIAg0FrjfA6o1G0i9aSnykmexxxLe+D2KpYHgJuWM/uVC5tRbsUux+ikAq5yK66EjDUkVoLGYdduYd3Fw03DkN2F3sYmdnB7P5DIBk/dzb2cXp06ex2N0FkcF9D94v2u/gwM6hI+D02dP/L3P/+iRLjiX4Yb8DwD0iMu+tR1f19EzP7lJLEyWaSUaZaKbv/Af0N8tMNH0RqV3SlpoVuTM7szPbPdNdXVX3lZkR7gCOPhwADvfwyJt5u1ciyupmhIe743Vw3g+cH/j49DNWplmJORZPHKsU5kQYvCcl5fw04QdHqLUZDneICJf5iZyS5UrCOPDgHePgOAye07g9spUR2+xrWQcDPWWlhr1eZRTLa5RzKbraIe1cH+rUQgYaa887swEWiXBR1l1LkN1wq9tohamtuvGlKpTnft9D4g3m202wWcYrIvtlmomuXwpmqKUGevrUwH0nbonld1tcXc7ntg9ZPBXrcJdXPb9+tb0qId4tSeRlXS3tucW1tMKheTC8ZCOudfhd7petjo/Fy2k5JQvSEymcbcH62+4XvK4rTFeBrKqTGrKvB6Y/lSJLLIRyfWj25gRtTlsisX3m1iHaXt/LX+9Um/66GhOlcpgNyXQHt/x7c5fyYidoc1i/olNdPcMxLZMALPdScI6otchvQS/thPUnrZJtW3cvGU9kcCPDMOK9Q3Pmw7uf7d3B44NlJx3CwOFw5Hh3V0phikUcp0gshXgkeO6/eku4/4YfP5yZHs9osvTXMWVyTiZRhMDdMfA4ndGkjFgJT00O9+ZN2yPVhEgmBMcowjB4xsFzGDx3p3Xq7Lq0Rt83SIyi2un2rTECKyoCiBLnSI7RPA2V1T31XcBS3W01jgV5Oyctlma9ebTnRCnV9SjPuDbGPZXmtp+tTeI1eGK9Rja+vfN3i5jsvfMlrZlobqqXZMUEtQp83X5VgqEFR7lNuqG+fSkRe5WksLsAG7Zj5QnyAsq9faeFycfb/S1dLYhmQ1kr07qNsnWaEFzJIG3Rn1oWXKtUUOB9XypakP+Kk64btdxUOOyCngqiUtZ6/Ftrc9vIe/t6/969mtJ7XFdNz9x7eTjnir6/LCQKeESlKAQqUqnvrfftDuw6ffGNeV/PrXNDLcjcrBFlVbMynS8lsZv9ZkR4B2GBcVdiZW/iPDE4b55GZHxWghfk62+Y48w8TQjC4XAwtYa3ID0pRXjuT2/4+quvubt7w2W6kFJkuLvjX/z6PwMZ+Q9/9w/89PM73nz9FR8/PCJPie+/ecvX37wluMzl92e+/fpr7t7c4b0jx4T3QowTQmYIniEETgKXyxOSIySPhJHTcV2j2dbOsU5nretj2aS/yvqrpQ2vRVhUQc3zKKeMy3Z/qmunhUjU91ae6ip4zIoVeRdwzmJWVPIiZ2r1zzcVSj/IamCu/1fb2FYasdc8b1jd3rdrkJb6zwIvvYR9y3a5PUO9veM5g3ftcyUkb+/pVFyV+VuI1uc9mdZSzf56vKT98eU4V73aH1GaOvJL21qV8jqKZ9kiF9VSU7egmKuMFKRdDZLl/xKYkwvALLztdVOWCGLtxijdvy9qvVTzJ2pbANkzIm8JSe/t5IosLbKWYZoFRo0zb4CrlmxOdT0HwRh4bXbfa8lmbd/YrEEHSEvg0FZKoag7qoVG1lIZlcBbyolpmnn/6YHTOJjbZbFjpDmjDAjCPEdiTFwuF06nE+LEHBLkCe8DwzAQwsjHj+/49PSIeOHuq285vnnLf/V/+j9zd/qKv/qrv+J3v/uBx2nm+++/4Ve//AXH48DDwweOo0NESfOMaGhc8jAMvH17j4gwTzMf3n/kcBo5DAHvPKfTHX/xZ78Czut1KvuWSbvgmsoaKEsFFEPadX0MwcfLZGVWy9uEgb0c/xarcL2fTtVcUVMshZq0L6dnfRWA6XFy3cxab+Elxtx63xbpv9Rbp/V5zUO8uDnnLA1JcVb5XNMi0ukre2xMaJ13uSAb1/Q1oXy5BLVtLzc073ZgVseFptkh/twwXoIAV4i2qXcWNUQ9/IVZXwNYx9GswsZ04Vp6a0TJAtP1vBjiNGuhITscfiUeL8LnVVqoBKVerUV2pLvaP1YB+BqhrpHo3uetZLJc39OVLgRiCZbbjkW0uAyazGXPOYe6AQnbMUEIAzl1roXWe8mgKSu30Z4NNYJjxtmaSrphkv4zuSzNQjSM4yuwWJnjlHn69Ikff/iBS1ScU3w0j5gQPBqVEDwpxZUH18ePHxnGga+/+ZqD8xa8dndgHANv37zleHeHjN6kkJzwGvj+u+/4Z//8n/P3v/kn/uIv/pw//9X3HAKQZ46HgV989w2DHwvBccR55jJN3N/fEdPE5Xwhxcg3v3jL28MbUoqEIfD9d9/zX/4f/wt+y393BQuqmPODs88WbLokalxSW1Bch1NLXSNZmedUvIbUVH6qqOtiFXqkK8WK1HHTghDRKnv0p67BThlsP3JECtSHQJhmItet59xvSdJbFdPS7bVU0YgJHSh9plVJZzWmrEZI5foM7b5jV1pZM5T7z/fBqzWeJxcJeY+I2t7bcwvB/E8U0bwa585NnchD/2G/LcjaxLbdIWvxJWkiltQdas9XBC5c/7YWD7u+Ow4F1ZKPaeHzpW1Up8OviEyqtweIaBNFXNmkLQGpBj9pg1iTIKS+QvurbXw9Lly19puxPFU9VS815lu2QXBVIihuuNRxN9JuI6w0uLAm9XNPZOpzgjKIW515EWEMA1FSO4QUPWlw3lIsbzg8h2+cVK8+apUPOq8vu6mOwZLvWMrmekfNhaTkFHmczrx7esA5j6oQ50QKAwweCaaiOo4jjCNSVF+iyk8//tgkGTMWB7755mt8eOIyRdQpaYq8/+kdZMfTk+UrOt4d+OX333I8BDTNxGwHdRxGhBKcFgKHceBwGLlcLqRUAtjGkcNhJATFucDXX/+CP//zv+TP/uzX/HYFA3Y2tLg2V/iqe7wgbWXjJ1qPHaqJGCdyjqYebACnyyZ0atN6zej4krJBgitkoSIjcFnQYFxy4XMN3srZWfg4RZ1bzvmmbQnDFgn311Y2smcQYceDrK/tqYHoYzXqvUpqZ6x7vo15e2Y/IyNIY0dX/YKu+y5ndk9Vav0u69/OLQVXvaC9KvfRQqXYWbjr1X2VRkQ7JN8wWn2za8i23/iGaJo0WAGlXuvHaOKzGZLXgkXBm8t3XSNXOyd19w0xVbtmu6d7l9uItE7MWFRJZr/xPeBIDzQ9d9O+rufTsPaKQddW3IV2wCmEbA2UThf+2i2L1lDKirg5WYyDiqVIa9y6rdmet6QvCdx6dZVzjmE8EmMsufcXZJWpmdUAlcLpehwR1dwKuKzmIa6oQ0wCMENpwqoLCZoSMc08zhc+xTO+qE7mGInzTB4HwuCRDIdhIAyD2RGcY5on3n/8RAgfzaU1ZcJh5Ku3b0AC/unMNE2kS+Tj9IF5mni8zHx8/MTpNHI8Di26N2UjWpVJiDHivWcYDgyD53J5InhPKLmAvPNkLgzDPd988y3fff/n3N19AxuNTnWKYHVu9jjX/jcjEooiGklpNu+jsq8mfK2JgkmKSi5MwqKGKUwRHidW6rOmLJFaa9Ktu+6Oj0k3KRu/5wTdgaM6l+fsBy9tsjozW7y1lgb6y7v9bxB/v9za/dvfvzeeXn163c++5L7Cl22c/fiXa6/BxV9kU6iobUvXGoe54tT/BG3DfW51iVvbQ93vijxMX75+3xaEKlUtnayJTjeGjSzE1S5vxFhVJXUc2tZQVd+w5WfWtSJYiGylBd016e6X7fDq+mivpirrI7kjBnn5VYSlVi9mF6iuhmqePz0JWSSNawO35rWXU/1/FOF0OqG6RK7mbLlcQxgIwXTtMUbmecZJNjXLZeJyuaxEYu89IQSLSr6/53K+MM/ZVFMZFMf5PPP0dOYyTa2vGCc8icGDk9NSWxg1X/7gCe7AL4YR5z2Pj4/8/O4db7/+iu9/+StOd3c4H3h4eODpMhFC4DKd+fDhgY/vH3AoP//0E998/da8pbwDNSOqYGqxx8dHHh8f8d6+v3nzpkVYO+cY/IGvv/qW77//Jd999wuGwwiPG1gp8JNlS/Y/34x3MKcDKYi/8hNrybLfv+077EJWZRgCYRya3jujrF0N1iOv2TLWxOsae3xOP76XNbUf22vbHvKv41jd99L+ZCsD9D9Vt+KFYVzjCRvArsF8p93KHvtSu+WrbApX127erc/+uvv+3X4qz3pdgPu5z7VusMji+ulFbqQM0spqrYC9Udn6vUPSzy3yavS9/nLn3oWgaQuJ2N61e7275jZPtPsb8FT32O1Lmhf7VfPbsWp5r4KFOXVzLXrpUlfyeo6kjnVYU7pqoKuEwaTQQIzJkFSRKsZxZAgeTsopReK0FHGpkoaq4r1nHEdSjMzR9tuhpKRM88x5mpjmiKoF+Z0O9wze7pumM34YSZqJOTFFq2UwjiPDMEBRJ/kQeHx85Ic//I43b7/lcDhxd3dHRvj53QfuUyKEI9988wty/ks8kcfHx+LpJRzHwMNTIp6fUKVICgFEuTue8CKM48jpcCDGyJs3b/iv/+v/C7/683/G3f1bou7XaDbEukhvn0OiUozblaFIpQ50Y6D7R1eZfJdzcgUmqoQwMIQRcxCQ7iGu4EM6kKxn1QotLcLQ1jOu90q6mtMNJnH7+U/btFuPfZy35e+eedVGBfwyt9ht+1xa8c+1l6uPNmLVFvl133auXbfrQa5F0vb7M6Lkfv/2kGMNiPmZd/Xj7m+6hdCfW+D62zYl9q3nmv5baGkuru6r8+i4t4rkl4pv3fvLIRSt/ullLu1lRXgvmH4BNOuoRhvfHE8vLdW6z9D82/dFZF9k8LWUV3PeLFk5C9dZKHhMM0d3aiq9wQfC6KyGcoZQ1FP9YXrz9i13b+6Z80yeEv7hwvDhPWAxBilFXPaEw5HgzYt/mmOpL1H2pXiWvH//HieO0+mOYRhMDehNgnn/7j3iPhJC4P7t19zf33P/5o44J56eJj58eM8QRqvPME3EeSZNMxIrs2Ajz6p4FS5PZ2bv8D4QgucwHvhnf/kv+MV3v+J4d29qwRuF11JVPwhr7oYCM5VY9NegqOTyKitqXU/bh+KcUbemAhQ7HGtWxmHgMA6guXgguUJIrvFBlUqvcEutF1LyUu1WL9wQgDqnfSZxa1N7vt0iJrtI+kope91ejI6rZL7VJrRjfVtKeMn8/uSSQhuYdEgJK3FYf7wSrZ4Z5JJk8bZY1d94i9OunkFrXSBol8WxckMNnvcmhoXg13QEzQJwQ8d4kyvQHcK2+X0FyLkiZ6GwtrQzfL0Mq/fQzV3Ncte9u0ggmNRgi7JegGYkXF3uVH+CSRNtDTYcfx1TGW8IYYcb7AhVd61yfH25R9tPaa/vD3PKibrNrqSVVjWE4asxUaSkxjaoSh4CnvPZKok9Pj024jHHmccn5ThaSgtBSBmqnp0YuUwzPghBAk+PjzyJkHIikRjHI3444ZzZHp4uM4eDua+mpFwuE+fzIxfNzNNELEQhzpMZw121sWC1SjpEKCQScNELUQVx3hClUX62Tcr1to7scMsFxJosUC9nIwzzPNM8wLT59a1gqaqWmtF/MwZFOR5GTuNY7u3dL3u4u+YdqlTYMzh9idut2ngLN1dj2ZzBa9XS8y7vV0Zr5er+OufnMNjnEPFK63AD12j/70YPvn19U0PdgpMXtFdkSe0TDSla8ghVxHl9+DcIZDW6igelRcsuMuviDtq6rshLlzNRAXgB216MK73q8s7uZXuTM65aWDyMruwL10Eq18CnxaC8vs+4754r7/vOTQIQVTR3iL0CTFmPDmTWoxdZ1xjopCx7b5mPbPekHP3GZC7PSXfbMo1uH8rvn+e9enjoJYFsuY7KHq0kkkrBpURsajbVX7Y9Fu8pTpEGQ87hvSPlktK57KFT88s/TxO/++knfv7wEecGRGbmmHh8vKApIyfHOAYzlMsSsZxy5uBGRJIVyYnJYhjSzOF0xzBOiHjECU/nM6fjfYkGF1LOxPlCnMz+YQShREAXQ7drCCsiEtrUKeq0GGeeHh7IKWI5ifa9cwQjHFqC0m5xjQtUK03k0IymRI7zan+WvdsSiu46a1h24gjDgB8Hg7vqFKA7723nrBtfg4EF+V6V1+zu3SMGdXR0+GLB6/0J2mdge7tXf71/ZqXb/wye3TKB69Yz0+XQ3ZIEVp9lM5ude6Xudr8Anz+t8Br10TzhXL1dqAFgUvLIrIrw2BObYVbkWYyqHTJt3G5Bvg2NFMyjCrmV8KxUoVgaum46ZpcGWlop0JrvWR6qCLUSGW0IWKVy2z1RKYejqmbqOwRUBSn+w3TitYjrEOjWOK/dv3Xsi5cUdHn/KrUrQCRUT6flICxrUd6pirYxlXtazJ6UcdWIbOvQeRtvz43VpVaMkOfVVevv6fwEw/5BEdcbKjNLZtOCwJ3DuVpHAhbGuNg+KnxlJWkqDIm9L2F6+PPDA2ip/qYQojBfEr/76Sf++re/5Z9+/sBX918xeCVHuDxlnlRxPjOMnqOP4D2XSyTGjDiMEOhEnBPTJXE+J0iWbXW6PBZjPVzOnng483ROEBx+8Gi2iGSAaZ6Y50yKgbvTiKYL4xBwruYcqnaVEifiBO+ETz/+QJyfyHxdDOdXLgkFhh01EWBD3XtqpLrHFenlRJzOaJqX8pXl/r6mgl21HFHaPMR6zllw7kQeBqL3eIUxaSn1mS2wrUga0r9SKsfd4YLGE+1z8ruSwepQLYxdIxBrRpx23jsppHd6uOpHF7fQFZK/pm2rZ/cJwrKHPbO5MMfbPhbjv29pLToebzPWLGImnbTs5pbRfq69yvvIgNZWofrpkxcO4rPiScF6ynrD92wSC8ew3HelnmJ3P5b3yb5gtyVXtwzGlfu3tkSLSjmI7V6FWkt0TX5qfwW51gGv+tOFSVgm0I1i+1E7Fmhh+OhUXyJ+YZHUUjuwYx+4pd6zYLFCxfx6nrdcnUUssdsuQdj0OwwjiLlkCqa/r+udoxrn7BzjcMB7QfAoNVmbHZCUornHeiXlzPunc/FEMpjJOTPNFz58eOBf/Zv/iR/fvSfGxDxfGIfE19+8Id2deHp85MP7j3z88JFf/sV3XJ4uloDudEcIgaSKmyfcIOidqYYeniJ5njmnGeeFITieHiMfP1yIUU3KIBeJQDkdj5CV8+PET+8uiIOv7oX7uxPj6HHOCMH5/EhK5sEzjgM5CD/8+I6Pj0/cp8Rxd+EXzvE1rZ67GCPnIs3AombZ6tUrQi+kpHXXc9TSaQ/qvuMcIu4KBhZvuSKJd3BSXbr31DWrqV/hg2tisZ1Lu7eXwrt5fk43v4eDvrTtjX97fKT99vz1tYqtpKPZqKRe2l7pktq5q4ERCFl8UVaAVAJ1FpfHSrmvB2kIJXA4HPj48eOqtkHbpCpN2ANV8LoKKOnf2XSaHQDuApax1BtkzUrsanrbbi3Wf7T58q80qf1m1dtX88mNW+oGVf5uyF5HQKvkoJqahOFcHbIuRFsrEbFgNZHuQFRJrB/T9nOvi90JBFqv52ZtWbyjqsHQciEp3gUzJpc5VW8j2h4pKc84HYipIq3KGBS9siqSTQoq/GtjUlQT4pVLjPzw03sezxMJJaYJVTgcBsLdieNpZPw0cj5f+O2PP3N+miEL4+C5vx84nY6cvM0iq5Kicj6fLSpYzMCr2TyL3rx5Q/AHsiaSxqK6iqjC03Qh5cjdG+HudOB0GDmMo7mpolzOkZSUEFxRqymiHnFG+S0ORFoCtFVzchW7UPemnqNVAaYGTrVS2lKoaU9tsuKidUFdatEquBrH7G3XrfZ3e7hRAO3OYVe4r2hN6nmnSEvXKS+etVF2eGWL2Hvpp/61oV7jgmvGjIZzSkXUFYY2BFw+74xT+klux7xhdPeIex37wh6zY9HZzmFZy6oJeE17lffRGoFaOuBuFVf3OpUGOhS1UA2qyhu/fRFpgUzVCNkjcC+ug6jCscp1hGE1Vm0LyvTj2l5reVxWap0eKWvb2aW7avcoqQOk3iK0/D+NGCqoW+H3KxjR9g/llJXPdVe1iwitY9EOgZarlcuTfgy0YL2FmtfhpUIsygXt6u92p8h01mty2LjB8qUZ/LfQ7xaOrCIhI5CujKtFOUBWozt+yeMf59lsBWjnhdITB1tjLyV+wi3qvjRlfv7wkYfLTCyKlZSVHD3iHc5BGBx39xZkNk4Tl8HyHk0x8u7dmfcfZ94MjnEYcN6jCjFZYfoQAt47nBcLmlPFB4cXCGrjjQmmy2ReU28CEmAcRrzA4IdWtF6ZCYMvCLp6JhmyHoZA8GHZm65VQvqcV8qW+68gllJinudV3EffKiHo9ewWS9J3AFm0qDXMc02zzSGTcIS2vxXhL2MpuGE1XlcM6/Emp7+H9BebZvmnYyJleXCF7LdIvBl7O2LK5p5+DPV4r+j0jkbjubbq54rgdPOUPivC5ySaonKVepZ1Yahf0F5MFJonQMUA1DVeL3LjkHWRDaAOrHDRG+pf/Y9zzpYjvwNeAKcdl1OR0AtmeNMQdfXwMvJrfWExBEs3G63rUOsYdrCIVcdqaTIWVoirXVfK5pXPdaOzLNxV/bfRxIbhV6O/mjssWWK1Imvtahl0Y2mwo1dDbEi4/SB0Q2Z1FrdNrB5BTjvGz5wLcW8kofXS2AlzjaGPp+i9PZq9QSw9tB0Yk1DNUBv5+d07HieTEsQVwhDN7pA145wyjB6H4zA45qNyiYmH80Sc4ZIyH+fIECwOQoF5jjhxHCXjvNVJUE0lb9KM9zSVkOZMThnvPH7wuBGG4YDGaLMpSRgFGuxXhLn13NEbm73sxXXkyZbzr+9UNaLQZyXun9n7f9nnDkiWbJNrxLxDZPZaYy5k2dM+W+peQNruOxbRBFXp8P8N4lF/2SDLxb65HuCaIC/nZnscbeovyzO0q7beIyiNN1wYwRepurTbb3gZ0uQVRCGlVPS1AZDiw64N+3f8IJVjKLu1AHkWckl/3G3h4tikSq5qhI569xyw4SgpfXYLKAugm8Gy9KkbalyRyooKLyPXDTQsiLW6rIKqa665y0ntgM9tV6ME0/X0oKmBtBGEyjVJv5HLE+1qQ6IVKS632HjdwrFbP4vLZiswpGpBEvXxFaG45kjb+9veSRt7efUS4NY967xvebPqHoQQIHY5cKjIoHSSa/AhiLMkJ7lw+iZllBG4ulZajKSZnM2XP6XIHC/8/ocfeDxfiGKVywBycuSoiIs4p4RgapnDMJDUcUnKMI44F3i4RM6fLkw5odlqDZwviSFAikXywKPMDCro+dGkBe9wTpnmyQrmOCMouTASOWdSzi0ld4qZLCap1e0TNRiNcbb03JX7e2FbIfQF/Nv3ShToYLx/tjJyKyRf1UetmI5BpKJGIJ1FolfOVivSbUzOAiDS/qP9Vl2Me6l/O6dbbTFY2/e8yQ3UL0PFN3WMUteG9TOr6nDLEi7vXB399bPbtmKgd1RXa0q04K6OD1/3fePdK+KlCxy8tL3C+8i4I5G56LQUGPDiUU2Fq7N5ORLJleRYm1k4zauUDk4ESnpeVxemn99Kz4chNue6COOC/Fr1Lcjb3DCVcldRu/vNxG/XJ3lY48MOyWlewKJGRzfdXbkpoaDRxODaB1IQ9XpjRKR4UBlX2IuRegsxA7jqCbFwNAL4Cjll/jUL5mIk33CSqc6fwoHU+RYvkY34LFVv13NgJRjNF2PizTHXQYrZj2I2F0gVQcWCDRVT5yzqv0JpRCyNUUMhlWADYrERtdaDIGSx1CLny4X/4W/+hqcI3g/4aDmQ9P7Izz994HQ3cncaGccBHxzqjKgOcebOZ7xTvs5CevOGnC3iN2bh08PE+x+f+O0UiQ8zdwfPL+6PvL0fiA9PPM1wniHPF97cDYxOkDjhLjAMmfMni0o+DCPDOJo9zc+oeHM/LZzqEAZynnl8+kRMsxGQ7eE2SrMssewbaXX1QEnzMc/kOS6Ewh6w/0sgopR7NWeWqPUJSnnW+pxXIZzuTE2WQUJGDw4I4FIRnUKjMVkdotJc063vGpxnMDKVlCSVI96zi9wyPjc7ZK5z0XWkfmVUWEC2Eb2tSmvz7mav3NxXiU5ldiq/uNWM9GPsuf51spval1+YQd+551Zku0OFeoHfmClX1v1lDMWLicL7dz9xGI8MhwPDMOCD5VqPOhck5lBxOFXzvNANF1s4/ioU74lJe5S0X8RGzbsN1wK5t/R4e4azK11h5UYKwVl+7PDf5vUNUDqd36bnBWF3usrt2PpXrzw5XJcm4Mac+ndumMEVAAO7B+pWezlPsW577+4jUlUX9ZU00aJOxQ69KzmAVGsyvQr8N8bdMRFBIMVIEHiaJn7zh/f89PM7VI5kTcale0jzxOmbe4bBkXPi8SGiJI7HI/M8N7uHcwNhFLKDyyWXYjiOw3HgzbcZdxGmORNT4sPPZz69r3UOpHGQKSqMDiclYaB65tnSdFymGff4hHdiBu8QmKPZ3JyYFjHo/CyH+ZI9WXORBos5JVK0RH3ijC/bUxk1ewRLfjx1WN2Fcu6888yqfP3tLwjjgQTG7StWzEd92aPMNmXNtlUVWuoKbd1Cqp+bd53nzaY043Evj/R9PufB9FxbpLPbeK7vJ+eah+x1+7sMmpXEUml77cf6fdmrXi4pxDOzRtL8xMUHwjAyhgF/PBhHKqYYMsHftWyadYCNidQqZZT37gD8bV1ZQSTdT1Xce9HB0aXnxdtBru5p/shlvOWlZY/X9+fyTI/Yxa3N1pXrrQTEUTaoGm9vwsHisdS9rXFw2ve9o0/u20uRSfVeuPVcr77pRoRuObHSHNIcC5x3BB8Yx5HH+aHjwOwf7z25S7eQi1cP9DKOwZeNpePKVFHvcMPAdLnw+5/e82/++u94TJnoE4P4VmaTUVDRpvYA83Z5fHpa1BUipJhJU0KTEbYwBGJO4BPj0XMYhDkKl6goJ2LOnM8TORZ11CFwfxwIQcs+CU4Cp+Oh5GAy6Tpn5WmaSBrIWcgZUo48TjNvxwNP5zMxJfNuyztI5sbWikhLxtjFAxYGrRiNc2rY4sp+sLlukr4yF4nKsgU7cAPjYeR4/5ZwOIL3KNZ3KMysFieM58Gw8NmF2PTMRJ3Pni5dGxDVC8tvvQrqysaIsLVYrDn39fXPtZ6AbHn4PWmj/u1tMSuNwataRxXKeyreaQrfPc+1nfZiouAK8GSJkGZymsk+MOSIDwHxAfWWOndRGyk9wuzbl3A/vZHxOcq9pfLL9S3sVI+qBe0uz169tHFZNpbniM96c1Vblvm2d1L7eoaASevJ2kqk7WCgMt0VwX0JQNcVWOmfX/GORju3zzlpunHNigQLNHvQT+z5ry9qK5tg/b6Mr++ta06YFD49PPGHH3/ir//+H/nb3/yec1JwiVCQkorgh+L2WQiDOBDniXPN1WNjVbXiM5ITh3FEvLGUQ/Al7iMhEnFecSFwnmcQh8uBwR0Yj8L9yaOY0TunTBX5vXdQIp9TTMznmWk62yzViuA4r4S7e8aD1ZHmCtW8QKrrhYRu7Ww8qUSJd/rrtg87xuauf9shh+DAeb79/lcMhxPiAqZaqkxQx2K0s1OdB9bwX1WxFSaWtBfXnHvf2lGo6jWRpoL8LA3qv+4QhNdKCFdj2nl+SxhaX9dD6n552Vj2NCNLv599HHgFUQiajYMWo/o5Ry6TkOYZHwZcGHDjyDAcSvWnRXxaI7fOhbObyB4X8Ky+8GrC643c5XB3Nrtyvo0TXdip5fsy8muglGWGe5JEu6fC/+aQSt9NP29dvG7WxKCuz9Kn0PntP7MG7d2bNei/9x5ee+/Zc4tcvWPbn3NI40q7SmCNe5EWl5JzrSYlK4lStfL0ctVLTeh2yZnff3jiNz/8wN//9nf83W9+x2//8J45g89a1EeOrA4fvEVtS1HzVEbGBes3J1I2FVZM4HNxNVZT7Xg3kiSRdUIkMwSHHyx3kj95BnfgOBwZRscwWtqMy8URmdGU0JyKasw4/6wg0VxXczavpWEQxhC4v7/n7nQ04zy7OGa1T1frv1qxRaqO00SOxujZ2lfOcp3mfOuSWsmCiKUREfGEYeQXv/pzfDiAeKorhGvZBBZJow5Dmna02IE6yb33QNrT4++e//q6PSlis0Z/qnZLcqnS9kt6eo6xbB+vlBk9caV93v6+xWF/cqJQYuSKsVVMlAV0npinGatrOHJ2Fw539wzB432pP6upMAWVU+6m0EHtc6LieuFv8aWbpt1qbJBMlQ76zzVau0k5ZbzN+6UcqOodsnCxlbBskGInCVQ11wIEncShmysbAiJQ4gDWIfGVD5PV0ZdVv/29qzW5Wr1ba1ptI4rge3Z9WVtKPv+ddL0BT3RrIv/p06eiO86rQ+6kiPMl9fl6XNZysSPVvEHTdOHd+w/8L//hN/y3/+rf8Df/9APvzzMJxyGMuDCYB1OJrNVS8UxdKcyjSowJ5cLgj8xxxolHSm0FcxoIxgiV3EeKmaFUB4QDDke6zIzqETcQAozDzOnuQMyJ4AZEPDEEcjy37fHO40LAh4CmMx/eJx4/TTgv3N0NfPPNka/fvmU6zxb9vXuq1+dlt2mRJAv85pyJ09zqMa8lhCXGh+7+5ZwUuCu3BB94e/8Vx7f3iBssL1UdpyiulsAVFk+dhXNhC29SmAIRYRgGpmm6ij262ba/vxAJ1vG2AMqd37ZS1PPD6M/H8n3PTrr7fNnTVSGizbsrkb3CN6XPIjpdv+AF7eUuqa3ebeml5tOSVIyiGeJkedo/fmQaTshwKFJEcVOj+O9LKfzeyxBS8vhUeKwLianenxMf6/29QXo3HUMPzSyIt2Z9VPVkMqFWjZL6Tu38AhbkKeiS2K9A+9V9hfsyslJH17Vamar7ZdECdkFagGgqfbEak2jq+q58mjSVleDwsnB6fWuJCeom5GgL3rj5/iTH7nN/3SHqCM5tZ4dgwYcpxUYAnQdb6YwT12LVYspYvHPx7OiIYFbLoTOqgjreX2b+3d/9A//63/1H/qd//1v+8fe/55wz4kEYGHBIAjwMKAHlEDx3pwMBR75EZokW7CaKiGdOE6m4rgkQsjIGRxY41zxAMoAqTsyGoSiZ2JYvpRkIeBeIyTMnJTi4TBculws5JYbDgMSMCx7JiqSEkyPHwwPHMVjeo+AIg3A8eY6HEcdIjgHYKRJfPe8q4u48bmo2JHPISEhW4vlMjBOao0WEr/wqiyygFepcqYDb3oLL9jd54XB/4rtf/yVwj0iy9OMSqBFdmgd8drhcvdtM6nOqoEJOIF4scrt0L5VgM7cYpmqrW52flS64Ww+1c1k9rl+KF6vE2rdniW3rTq8Q/ecMzXvpwLc4fGsivxqH9A9UqazeXBIcSufG/8L2CklhTeZvdqEQUXSe0ZjBnQnjaOJgOBCCJ7R8OgYY7egX9cGC+Chc41qErFst4m+MZH90t+9cxtMQ7Xa/qiTWEePte28R/16ov7VuO6Cz+rxWUW3H9rkNX4vdt+5vc+zP2o54XJPZ1UR/wCrieTu2egjADp7znmm6rDysRKRICl3gUKkjXAZCypmHOfLDu/f8t//Pf83f/Mff8cO7J94/zVw0kkNJt1CYl1BSsBwOB1ArNyliLssqscytRA/7TPCBULxfcs4kzVa0B7Mx5JSJ2Tj2mCe896Xec7e+3jOMniF4Uo54sdTaaG5GdE3mFZOdB0JJ/eF4+/ZtIRzWh4oQM5zu3nAYB9yNmrxXa06R3Pp7RZuxOcZITOZGvjDt1zaEKim0vS8MUl/4KTjP4Xhs9oDV2d2Bs8bpSt35ep7XkrZzOzYF3YGzFWK86mxz6/V4VqrRL1AticiVhPySZz7L5K60GvsSS3lBeUA7LldLqhS3Utu9dH5fVGRnPXgbUK8nNo60JlUTcqT4YCs5OqI3NzbnvbmuIYUbqUqYrirUVo3EAgM3kdtnft9vO55Im/l/KdB8SdtogFb9b/WXe32+xli2mtu603bIe7Jme4GlpfCuJD2TVpBlGQcMhwFQUkGmzlv+pTAWGUWgEi1XisgsdECbrvnx6cwffn7P3//ud/zbv/sNf/Xv/4H3Txcuc2LOkF3ucu4UfTiZwzCWudXEbN4IQy73lb5yTKQYkWG0vrNFMFdAbBGqzTnJFz38onLw3pe0KUUvLp4Yc5N6hiGQiidT9cSR8m7vB4aS5iJixEqzcjjcMx6OuGAG65dCk/bItJEJO2FVjbQ1MF8ZlXvGs/5uIFCYEymfnzk7hWu/yQztwu8ahl9j7N3aHW6pfT7njLHX55UNrj7rFsK06PvXtGpv/rdso9v9eO7+2800Hf0jL338VQnxtvr+2vlab1aulshNQSx2SozTStHEwFpdSnwRNZ0jV28U16AOKoC2fgF0ifDbUNxqKN1Dil+CoPfm/FIC8ac0an1JXy8BoluGMrRybwthWDy/6rMl5E9uz9VZ1g9EDOl7b8AaQs1vVJFNZ+Ru12huk3/46T1//Q+/4X/693/L//g3/5GPl9RyJGWpyGod9yGSGYaAiMGb94HKOKVC0KzL4m2UIrHUR3CAE09K0TLFLjwP1RBavTlle12VlDLDwTNNcymq4xjHQ5FWLCLeuapCXWwe9R1V1fLV199xON3jvLfztF9Tdo102v7t7Delqt1n9Cq9pFA4v+4N1oe9QpvKbT0Eo3h76pjPt8XYvGdjbON7pr2Ge7/FRD3Xx556aPe5VyHy232/nCDI6q8UZvvFOjRenSXV2q7+rH2uag5DGIqxZVZnoEQVq5Ti5BCdsyLtISBhsIIp0GQGre/Q2m/t53ZAVo8YXjex+ud5ItJLRf+p2+dE3lvPvGYNtgTBJDJZgrArdyslkluVIM7UhCnhEcJgahDZvPdyfiopUlxJ/mYEXROmRiwHP+VESnnhYjFLT86Zdz//xF///W/4q7/7Df/ut3/gQ1LUB4gllbszSdTqUhusOLH3h+LF44Opp2KMnLE0KMF3dhfvLY0EinMeL5azKZfvlgQvLQgbR/Alh1LnoeO9Z44XUpqtdnPOxJg4lKBPW5dsSfmURpjsPFggnAjFBRV+/ev/jLdffcM4jiUZ3ctP99o4W5FNQrUk3ev2fFtHQLUQShamrG9V9ZNSZp5mTsvDqKz9xLSqlWSJTLYMA9ceOtWGp8AwDGv1Tqc6Wp+BQrg+w+3vSQOV+Nx65tnWEcs9ZN4nwXzNOd47j9f9smLG1++1H5vWr1182dy+iCisxldFvc31WkinAZs3EoFWjqg8nxMxZSRmCJTslYmD92bwdQLOLzq2Gp5eyjGapFIJUTeuHW7+S1VA+xPn5Vj3/0/t8/Gj160ShIX42nqnVFMVFG4YQ6auSAHmSnkNdKmmRlDMJ18zDqt7YPxDWqQE6IiCoa2cMx9++pF/+N2P/MOP7/nx8UzyI8yJo4XOksQ85qMmNCmDcxyCYzw6hsGTcyRb4D2DOIulUSXGjA+eEIxjP4TDKm+Vcw6P8Hi5kLUWwFlqDqtY5G5TG4nw8PDINJ1xXri/nzgej4t0q7lJDW/uTkjzy8yrA5xTZs6Z092B493X5KwlU+wziKQt3novl78Lam/SYfmcu/u2SOYWEar4MKvVvK7IvCL/Kin0FRZ6qTTn3ArGtBc2BGp5o1JKDMPQIsABixW50er4X+SpxFIDuhLrPe+5l0rb/+tsHfVY/X2+vZgoCLohNuVDLerVs/AitMBL1yNtBRI1jnDlq5MiKZ8ZxBDPXILhgg9kf4d4q6U7DObJ9PDwgAtLn40qFz+uCvDtEDlwmc5bqMxLafl3yqAsK2t3wKQUKrBpSplJ4XKK/3rrp3gC2VoVWeeZjImvIVIroxvrnPN1rva+mlitylpNmKyrvd9BfUclDFVaK6okiu9+VnA+EJylktYMzkXQDTgpeK1BRJYkUQt8qIgly4PiKWP6cs0jPl1AZ2ZN/ObdJ/7v//Nv+R//4+/58eMDqo4hR0vNcAptLoo3O4FPqLd0FqIWIBZjRHMkOA+HI4fhxBwvjD7gxbxpBufILjYCpQgR5Tw9Ms+LjzyKVSD0DhcjmidSsjEMw2DJ9fwJ7wa8Czw8fkIYOB7u8N4z5SemaeIQHEMoMbUpMYcR5zOjDGgaGMOBX/3qL3jz3Vf4ITRCtg1orjkpt7rnSqQqXNgSm5ddzNESU8q17aB/vkeR2v0PdsxEhCCuGdurymvRMNk5sbQ3JfWN64hGB7tmU6r+cyWWyQku+BazsKdSaeolirKzu3ZLBVP76g3Zdby1n3gjzcb2vXWsdQxUOGd9tp/j/l/ErO4d2Z1rNh/X1JTGsKnty59aUpDNh/XC0CFMGmFYCEV9zj40JLGpSOaUEmQE3vRDBpw6IilDjqRc3VsLIixlQRvqK+UK62YbkrOB98FgDRDKv3bLQqZWW3S1adKm01+u+vdmS6lLsV3LDQDs6fSreL59Zs/wtAB1/0yd6wLwL+J8OiX56l5ZAsukpIQWP1ja6LoXV3Bt3LET13zAXeUUy8FckIK9M0gCUc5z5IcPH/jv/vVf8W//5jf89PDIlGJZ90JYdMnLM+dUwKgm5hPEOWK0nEfDMDKUuJnz9ETWZKUwASeZLI5BD0X9ge2hKEgdI0vJzJQhGULMWYvaSwjB470nOPNKmufIMAzE2Q6m84ILgcvDA3G6cDoeGEIw4u0syjn4UFRWgUM4cBoP9I6+r+VJewcNKLUg+riDKvVc/d/LFkvfJiGUWio5Lyom7eNlVgMofXTfy7j2cAmU8+mEpFLyrAXzlnqll89e689MTwS2/z/bbvFWjWvumM4b5/Y1hOFWtcOKsxSuEiVqFvoyNK/RavzR6qM2iA2CauIsPdLb6rUKJ1sAp8+6ozmTqFWGJuN2kuCiietenB0eMR/5pdLFBlPr+mPlfK90kpuxXc/nBtCv1qACm3ZDuX6mk5T/qLYPSPXoLtcrEXyJkW57z0qnaxeatNQOgMgVAlnGyIo7NJXJkoumIqA6ckdkzpF3nx74m3/4R/7tX/8tP7z7xKS5cGTWb+XEGgJTe7qfL84zxblIuQYjMSXOlxklM8fEOHhCEGM45qGkuVac7yvZLWvTIxJxUvI9uRLMBkiBT2+Ku2EYyCmStQTJOUVxzDHiZrMRBOcYVJnnbDEnWRAvDOORIYQ1PD/TFl5wDcfVPpBiZJomS09fOfqb3HcnQXSccD3Xlahk3eQKKx96pqwTVVf9NNfW7fyk8pSWDysMgTnOq+Jcr23P6fT73Ei91F2vtTGvBmhXZJuegTWTt3fWrpm52/u7h9N73HoTNjbr+hoV1xcThR7595PU/oRzPbAtx923pgKpUKRGHFQvjSJqslwrznvUC7iAiAUT4TyuGEMXfrn0mXXNcfWb3Y/xalR1XMt4pdRD3gLQ+g233PQKxG+5o2cAYws8a1VRv/5s/v4pSM/S2ogLl2/68brRNwCvE9UrAq/qhn6Mtf5yzjMfHx/5D//0e/7V/+ev+e3PH5lkkXtUi8PyCq4yTr05bJbQXQHUCZezZU2dJRGd6b/n2ZUYgsj93ZG704F5fuJx+kTKEy4Iw1DUO24hNkDxIhrLZwsMVBUzEkfLg+Q9eKQl8wthICe1DKw5EoYTBHOhnaNDPQSF8+UJjTPBDRzHe453dy1CuE13Z40rsV4Vgmq1PwxG53nmcn7i6empEAUaB78izD3HXPe8nqddBqerpFiJAWt47a89xxHtMTiuOKJ471tU9y0Et4uHNu/tPzeDd/e9tl6C6MezfCw4Sq7PcZXMtqO8JeXvMWD9fbJ5xlBj/bzUN+/vc26tFqsqwZe0VxCFfTlEGtVcT3qVJ71e61RF1qq3SZ3Ukv1yQQOC5LToFFNCXWJOZrdwJYDIucAQRkSHVmy+iWlXo76e1bZdbVD1K79xP910tdlZuscbIt9//3V/19zESzgLa2sbRuWqX9JuAqj64lRQl7dDzAqo2602VRFSLTvZsp6WZ1PKtl5Z0ZyZppn/8I+/59/8u//AX/3tb7kQgIgL3qQUhXyVKXTJdhmcJbvLwDwnksLlcuEyTcUDKpBmb+laHHz8cOHj+ydElLcnq93cR5vWGhq9h9HT05MFtSWTNs6XxPmpBKZp4nQIHEZzZz3dHTgd3zKEI04cl5iZ4sTHj488PJ5xzvP27R2/9m85Hk58Ok/M6cLgz5aw7maAZp16ZTLMqSAXwNPOhnM+nzk/PnA5P1pK6pw2XP+a1jQi0fg7+2DF4KGvP6k5ozEumoBOQmhoKmO64TKT55B6U3N2MFKR2T6i3i7HPgHQ1vn1vVfqq+65VaGf1bNXl/5kbaXiYmf3lYXw7jz/xzKDryQK1531dZJfPJjuVf2GuKpGqsRDFSSb26Is5arNOGaGQEmKK1XgYkzEEMneato675uxdYsoX9quxDaWDXnVnNs7nlFDdaoVuX3XDVXQbW5jOYgVxJRVFZC9cXZ6T3tnrgnR7RkpSF7MtTBLfnYtUnHndM7KVzbu1lkUcxIhzYkP05l//5vf8rf/+DueksDoCSRzT1BK2dbiGuo8zVNKqxFVCM7Sd3gXcCExyJHBO8Zx4DgODCIMwxvmeCHPE0Lm/u0b7g++MCiupIO30pvzPJOiSQJznBBKLh5JTClyiRnvA+PpSI6JwWeOx8BXX71lGD0pOc6PE4+PFx4en9ASvDGMJ7LC45T43e9+xy9/+T2H4wGP53Q84t1ATjMiwxXivtW0GBWNgXWcLzMPD0/EaSqqPNdCnUuZHLRT5/XEDxZ7kdGIStDtacSZJOOGlUqpjaU8kTXjdOf8yefPT1UhbdNov+SZ9Fwthe7ePbXRrXv/f9m0qvj+BK2uyUvaqxLiLUjlBQi2MJKVqWwXK7KrTEflLthTL1kT1XUVDDVQtvKKCZEMREQdGmcYBpIzNZOU2g+CFi8j61NLgFLLr7PSSCzGGyG38Um9sRwYVxFsEcGt0tmSL6lJeHRShmrJ/7T8RhlTz57tRYm29akEszRXVVIseY+2myFdWOlisOs4qZ47qXi/STWFkEl1AS5BX4UY1D50R+db51APNlCilBMinkJTICWcJj68P/Puw4VP50jyAkS8z/hs804iJA2gmaAJ7ZGNmKNCwoIhDwE8Hhk9x3Fk8B4vwjha/+MwEO5HgjcVhaBojubskCI5K9MUmaZoLqFqAW3eB4YwIC5xHI98dRIeHx4ZR0EOA4fRc383cH93TwKeni4cjiNhHDnenXj3/h3HIfD2viQYxGo455wt27D3+MPA+OYO70YzGjY1xYar1TUDbNG11Zg/M50/kdMF1PIe9cg+Y1oQz5Jh1xcuHV2YE/p9LZKJktt17zrOXjrHg27/2Xyudo5MblLk6rfKABa4rHaa59xNex7HCKAsLuxXK7cmglfvKteeU7lcPbdSD4FeZS/qm42oaknsoZZgf3NfHeNGW/OMmqy/Vuf4krrR8GqbQs/id8O7RUF1+6FyqdfW+XbnCjlJ/8PVvb4g42ax0oxKqb8rzkRvb/pT5zzqvfnZi5iBCGmBNitkWhFvm2238A28FvFNWd5R57veWm3PtYp0i5K4kwr6DV64mO069W9u69gRqBXBQUBqlazuOSkkpM6zSQVWMGl7//LO8kq0JUpbiNHzYn0v3SQUX+cuBbmp4+PjzPuHM4+XmYq+PFU9tEg3i6HSxuzUEojVCNuUjUAbwncWwFZsTj4o5Gy1lJ0zL+Zk3kvOA8mkgmmKTJfINNuh8s4RwmD9OY935omFg3QIFsbhhHHwjEPAS836Wo2xpj6zrN0Z76Qgu4DzzjxtnC/ZUx1+8AS/BHBVZHvVtFtfqXdmUpyJ8wVthXS0MVQV8Wp5vnH6ZbwNwUk9Yx0gaJXWC2w6aY+thlX62Ca5XIa9Jhy9nbL/XiXMPbtC4/TL0JrKqfnKP89q752vl0gjvSG5t5dUXcbnWfzuoHZNun/rx0WdviUAzTH+2fZaCeeVCfHWqG+5bu2Woae/tjWW9hTs5mZs1m+7nL0NAjBDmlhkpXEDxmnIMOC8I7tSG7nWPBQpqVg383oGpnqSsAB1Pya9AvYV0G+AsQHTM7D0JeJrdd/de4+rnN1qLHZtTUCW8VdJpUJC41/VPMFuta14njH7gGtE0ZNz4qeHR35+eOTpcrGiTdkRnDDRu0kWDk9cSUlh0dcx2z0pZVP7xMwwmISilGC5kmlTCxbJqZSkVItcDsGTxVwt5ykV9RErqTfGhHMZfKYKSsMwkpK5p+acIVuwXj2003QxG0eydYi5pIERIQwjPngjCsV7KTiHE1rta+3qbG/beh9y+7/VTCgqJX3B/z3nrKpdYBsLrDTGpuY16hJVaoNk43FLsOIKid6SgHea2aGWAMH699a9twjM59H8MpaXthWX/oo+XtPWxmno3d1f066Y7GfaH2lT2HDDsr5WAa0i/VvAsCcCbTljrd3X1S/cZkVQtZlHQeWaTeTXBDFnJEecLwZR73G+ZKh0DtSz2tamRln7eTcAFisVv16La6R4ZVDmGffN7k1772mqo2ef3vZ9W6XTSwm3et4ShEo4cuVaewlgZ+BVfF2tgwgigUwqEoKgMvBwPvNv/v0/8PuPH5kxX3gr0LPEtDjvzNmg4h9VVDKpuZyJ7bcmHtyFb05f21jFDKWaFHIieEvQOATPeDhwOAyk2dSQWTNhCLy5H+B+4OHpXGwZmZjN0Kz6wGEU7u6OnE4nVGmRtyk7EonBCQ7XAjit2M7MPM8Mw8DhcGQYLKfRnGbyY+TN8UQYR/zBMgtHjQyElgr65u5XxF59YxNcni62bh3Sv37m+h3te3e9cqwK5pGVF+SUdUcF07+nqnB2kNIeEpYCI9ZyyZnlV3aplk77GWKysot1Q7pFmJ57z3P3VIG7/dp9qWf9s44lz7Z+k6ST3tYM9na8X9peqT6ylMn7aOuPb7c466v7KAgob0ZS73dqP6orCElBQ0knnCynjgjJe8u7VDyYvPPUusk1Wdnz6HvbdV2fjlPZEL7qUdC/wbhs45e1g97PGb5e017zniqa7h7i8m+1eUgxAPrd9AMLIalGrpwzwZcKaDnhBOaU+OnjA//tf/8/8P/+67/l03Qhi7OCN34g1mpeRaiTUm29ptJyWOGjqEb8A5aGI6aZx8czp8NIzjOaEzllvrobMWcmDyrMl8SHd584Hgeyzlh+IMjJYUqpiHMQgnGsb99app8UJ1JKnM9n3r79ChEhRrNVjMOIE+HpMjFfJqbzRIwR7x3DcMc818I5BdZCsBoNap5BQzhwun9bihGVtZedfRQsNUeyG7wEI15zsveXo2BV/jZwuEEgW6nhauMbZ1QQk2DSuCyMxzI+S7IiRUrIKZFjwpcEhU2quAmWhlnNfVlwbnFtrkSh7/Mlmom9v9tndkeytx6fbX9KuWFfDuntDM+N/bXtFamzYcnVstfWiKQN5k+A03qOpSIjpXON3CBvySX5Xs3HLx4npcpUSZkcFVzOlrveB5MaxCHV6ChLFkiHXAHZc2z9LYMP5X0qctNU3wlCm/c0tr5xXrf6utWWW6WMRDr2folIvmUcrO8QxFwfG4FTUsympjg8D4QmOSR8DrgsZCKP5zO//eFH/s1f/zWIJ/iRpBE0E6teGssblBCEUILGErVgUwiOacqLLVycFaoJgSnOpNkqjXkHcjeiKqQUmS4zKVpt5fw0cTqNJZuqeURNl0wYpERkO3wQjoeBpDPHwwlUiCnx/v17jseTcf+jSZ0xzhawpqZqAUhF/RTnSM4J1ZHT6cTpdOT+MOI0czod+ertPd9/922X+oFn8UxVh6mWILXLmRxjUeHsI0zK3uWK9Fr2VHOGyCmTNy7ENo5MyUZjaUJYJ5Xb8OAARYJKOK0xKlLSL6QrQzOrN8nKplDtCntwtSfVxjTfVGu/1HZQXWG33kzPnb2Gs+TlKLBGhz8n/ZRPwJq53M7lSjp/RXulTWH9tRYzWSl6spbU13L1WEOqHYPgegSkWJnPzWSqVny5XIrhuKqOaWeu/NwhOkzZASX6kIVB0aKGQIsnhDhIRixwVpLR3GEri9o/XyexNYjXf9YBR8vnLQkrm625PUeVDHv1TjlIJiXpcm8ligrmhbVPbirSkEJIm/TZDd11g+yJX117qessdQ4lLV6Z0/UhK0GF0gQwSyyHIJqIJHKMxPPE+eMnfp4vZGfpIHwuZnJdDKIpl/oK5R6rjVAkQYEgSsaCF5NmNAsxmm0gJ4uPHwYrs+mzuZsao+EJTvBOyNmTshKTMsfEPCWcSwQxLxuvuXhvuQbnToVhCMR5xgcP6k1KVcuhE6Pd75yaTz8wjI4wBIZxIIyBgBFV7zzHw4k3b77i/v4rWgT4whPcaNUmkIhxYprOaElnlx3NVbXpgBoslr3DgtDsv/K9InqhBMaVvRZF8RY4GkZcODTYW15fzkqFN2pyvQI5Jejlitlq0zGGxY6GEWRX/9/Ubu7/rl6hhos0vZ5b3pM8ru4pf916Se3/hv6q5+EGRzxL4K/P0TX90ueAob6Iug/Pq57X7YsimlsHIlY3oXG11qvDFcCqYissWAgqpqmqlIXr7mXUBe1VhLR9tgym4uZu0t1iFUxmXhB9zsbCK6siWUATSganpKyoWIUw8cHKLjpHLTTW+qtv66WGthELEl+LeJvxU5/R7hlZ7inv1ir8UNxL153y+R1fc/9V9FyYj1X0xXqN6pWuS1G1vS9vdj0jsOrVVDutpGohkCKJOUerYXCemB6fODslEYtB2NwjK91KSuNovWZLLS0eR8KSEMLgYBYjCHMSYsS8hy4R7wU/eFwQMplLjFyeJkAYQjA7gndM0QLSppi4TJY3yUvizcHjB4cmRVNiTqC+RI4Cd3d3PHz6ZBlZcyAXO9Y0zcwxkVVM0jBXOMJwYDiMRhic5RGaLxfGu3vG8cjpdM9wOO0oDp7hTjXbesaJOU41V+OS6XQJ9WkEorpdV0+hrLkQh0oIOogoRMRRyv34ARmO+OFArWVReKwmaSM1eV6P2Iqhf0eF1eZYmZgGfVKCVJcEeVtueDkvi9WuV5PtSQl7Kqb1mr5CdVSYt8rEOOqRuPak3HSyzHunLWoit/2hY1Q3ampoa7EwlS9rry6ysxYjy6ZtcLA2MOy4+IrDdT31trFifH1N7FQRaAWyeq3/f8/FrbbqCfPchto4apRkLIE9oGq1YUUTLieCBtSBUwvWEicmq6hg3gC2OdqkS2VNmRcOvfJmm5Utv9zi8vtAsjry7Tv2ri00qta3qAC6K1p2NLtd2uHEquHRkPsCD27nnSnt5OlXQTzolJnnxMM084dPDzw9nrlcYkFmVqNBsMp9fdzGEEopUJEidZh3kRMPlGycYt5IxJnMzP3pxHEMBGf9f/j0iYeHiWnKpFw4dyAEq5Z2mTNzyjhv/U3R8dUdvA2O0TmePn1gGAOH8cBhGI2w3N0V9ZhyniZiSsSYikeSSaMiVqrzdLSAOlFF40wcRlxKhGFotRca00SJUN5uzmZdEYjzTGoSUIGZ6n1UTSSrvSjlSVNuKiTNC2e/h6ayUsqXOsZhJIRARVimHl1ctBuKKge5urKqU8tGnKXV1FjBWMfoNBVazji/wOMWBzRYrTjJOejgb2/d+r9968dy09tJl79NOdEmvRym5xh60Ro6CP3ers/njbNtg2/3r+bRqZh1hVM/316eJVXg2qawWayeC+k3uIlSm9t1oWKqkEvOmO09xlS83KUK/jidmqmTTHKQZByti5NF0HqTIIbxgCsGT4VSEUuKkbtQ5loRDDOK9mqtq9W4Uj5+4djr071UdvO3L+utCkRbHe6tVj1FKneXc2bKCUlwmZUfPj7yP//H35h5QKvLoZaYEosd8AS0gWvXn4LWHESdzlcVYrZr37y94/4QGLw9MGX4+cOZOVoUBF6IOTMAMiVSMlySgZhB55GfYuTj48zbu5k///6OP/uz76j5bwSYpqkhr5Qz53nm0+MjqGOKxuWiSopnxruvUYXzFBG1OIwpKscBxMPp/sjX33yNdwNOAplYeOV95FDXIufMfJlIc8QjJDWk02xQG055a1Rec8UlGpmFP13xsyoEV+IxdiJlGyJSoQbeVWmkPv+SWvJbGFNVQggNprbcfw+HDnMo6VVUex5Ye32+1Mmj9wjbovHrq9dtjUF38MILW5tf+Vz3rHcx/pMTBXiZGKXdh607VkXwu8+IAVDW3Aw77VlZT+hP5ZUjIs0uAiCVkKyob7nHQXYKSUrefSG0fD4O76yGrkkOvjBHTcRBW0rv3ZHsrkqPeL9kzssarufc/22fP/PqPSN7TtlcRD/z3PbwWtWtzMGP/OHpE//0wzv+/vc/MviBi8SW69SkMvPIqeyYFapZCL4UJHMFWSJ4Ue6OI+PgyZqZYianzKfLhWnSkiYD4+C94+ASh+OBcTwg4plT5MOHj+ZqmjJTho8PFwIJjZG3b+45HEac94RhsMynzjHPkaxwf38PbkQfzkwX834aQyDOGLGYEtM0M80RcRf+4s/fkAR8CBwPVoRHi5hdJeybunMRpslsCXGe0JSb4biP7N3bF7NFdPEJpkiiZ9Hq2bWjUONEpNUaqfUV1gxugaudCmsLHO3jlFuS7MqgfUv9VM7w1vj8UjXQHgG59WxJobUw81odYXSFC68Y/077sbz75ed7ceRZ48WFwG+J/PNak769wvuo6rLXiGH/ZlbzW1n/uR180YCUmoGyHPdugs8hxi8hFL1CR8jUwjgU9Y8l3bRgJkvv4OxaLL7yAioOdbmoNHSRCjoJSbeAcWP+yzz6/+tIv5yTeH728Nx714Sk7GEZ2kv2pHpu9MReJSPqmS4zD+cz55RxLli8AXX5Mw5IOS01uasSZaPKXB2AclCDg+PBI84MsCkrMSqXOa6IvxNLJveLtwfu7u9QhSkmRCPfvh2ZLok5uyaRP02Zjw+R00k5Ff321OUMMtsJCI6np4l5SqiKRSt788L5+acPPF4iU1SSCgfO3N0r33/3VYEhCwasa632D9uD13+LMa7iNUyKuY5F2Pubrc4q1e5T93nbR/0uIvQpwrOq1UDp975uZC16KmLqKafUrJEvicjdNq3vLf9/7lRsbQovthF8rsnyQdp7lc3V6+c2zN7qB/auf65/2jNNs5L1i+f5SpsCNK56b1Sb1n5dDa4ile2Myj+KeXeI7/Tn6wl+lurr9qu2ZHv2PI041Rz9i0eQbp7Uos91uMoRIaUyVZViCpDjqfnGahF2wLykGhDcWKNubj0hMGKyBmZjwPaD4HpAlG6XmoG9UKeqb66390drb1fbuErfK91pzYJ5gzjU/VonWzPvnk/nCx/PZ5KoOShkG5NrcxZSVkSyRS+LgJNOR185RkevnUUo9Y9NNZRiJiVlLv+X3Sc4YRwdd6eBb78eGYJnmiM5R9RlRu8YnKl3jPl2kCOXOTHPM3McoNgRVM3ddE4WTDcA58ezIcwQ8N4R1QLYPjw+cZ4yUxISjsjEu/eQEng/MISDceJUKKxHZLvG9otoJsfZCt+AERbpEZXWjW773n7bqI8qs7MCr57BKettwZ+BKq9V4rxOa7FG+wvI1TQl6+Cw5xk7af85kVYx8arATJN4rrnlL2lf8rylsymjWPgP+42eSVwWusev7d7nztRmbE2aqzh0M/4/ufpIG5RU3VUvCpSB9l/XRHPhzEwGvlpoEUtXoIUwSFbwt2SKxWZwc9HauItO1ftmCgO1nPxqxtGG8HQF+ahkVCJW29F34zbOU53gq9tcPVDRo86QWHt3NaxqJSL1ALirMTe32S4yTxvnl9uhqIetP0j1SalQ2NQ9dRzl/ooStVSRaRLgQjX31Ux1z+q7CoFwloZhb7dUlXEc1xWucsYn+DTN/OHhE3/49ImkynEo2XBFLIWFOBIwZ2FwShDXkNA8JVK2utHiLBuu84GaAQkRsvc8zbmlnsil75QcmcTo4e7k+fbrA3/2/VsGTTw+TSCZw+gYvOfT4xMhjGhO+AzqHMPhwDxfeLqc8QGOekRxZBXO5zNTnK1k6eAhzoyHQDgJCeHDB+Hj0yOI53AI+JS5TJFZ4dNDhnzidPgFd/ffkaSkY9F63hx7VbdVFJcTbpqKqs2S1YnLRfrtiEJJgSE1qk0zHmXGqsNlLU5KWmGpddL6S84RXMC5oWRIBelQSWWjamyHs5wyNJuCSEd41gThSuffBILq2omlJKmEqBKgDt4q3Lb4i+56/e1zTOZrEGk7FeWMlbqQ5aorvG51JinXytStn63V5mWtYeS1KLiiQP+JbQrbtiCIPf1WFUGXr/sT7g0kVexvT2VtF3qgqZ9foy4y+28HQXt5elbcUcV6djGX9AHiqn86EGfwJTe/iL0zRQxXuZIiWSCLFZd3XeppwNxg62Z1CLe/px/eRvf/Gh3pNRdWkELr88tabtlDnwe6lQ4by0/1eH7i53fveffuA1mXbI7UHEZVHkqlwpcD7x05y5opKPuU42yos6h00Mj54cI82zo5J4QgjCWe4Zv7O7779g3ffXvH3V3g4f0HnDjCUGoYJEhqQZDHcSAl5XyemOOFu7sD33z1luPxgDhHisaZWzoM+xzjzN2bOw5v7rjMFz58eOKHny6AMrrIV2/fMA6OGCf+8PGBN6eR77/7jq+//ZrhGJa07z1M7iIOJWkmxrkZ8ivHbwdoMcpuq4xlzU0VKoXDzEILsOyhkvbZCLcfghW996Fwpr2EW9Sp1S9W2i+kHBEXoHG2ehNx9VLHi8C9k0TKC9l78MqmxuJl9Fo19Fao2r/neQb3uXHdarq570+lFvsjy3G+HCnBevDX6iPFVZGru09TDVSSXWLQG8Dq9St0b3h5h8da3tHeKT1obxC0VBfI+lWMM6O4SGoqHC6oZnJSXHCICjFOODGOVvxCIHJTERlhkUqIdqLHjctfr8NrCEMd83PtZYbtbv0B1FwuvT/s9runx57TzB/eveeffvyZHz88WL2EbDWNU0VqaYlcFbf2U8+JtgaCBbb1c/TiGICZzOkQWv6cEAKaIwfv+MU395wOgZxm4jkxhAM4i1OIMZNyZhgOeBehcNJhGJhn5e7+yHA84Ieh5AHKfDpbYZw4W+lI9cLd3QnvHJdz4uEhMueA1wkfhMFlvjoNnI5v+eabr/jq7p7/7H/zL/n++18yhAElAoGaudZ8sq7TMVeOs88HtMch99f6z7be3VlaqZeqqqKzBYqVIQ1SMrqixeZRAEIFyyXWq0g6eK1Vy+j66ybTQ3TPCN5kCDeU64qQFYZsLyL51jq9BtHmBXW8qPXqrfbvznnbSjO7v8n6e8OF3b2vJRpfRBTWL78hDewYxZ57X9ugqkfd2Zjtwqy9UK6JglIqJ9GrWF4uDu5/K8uetalZWoIwKV4eUu8TiJCdkLQkoHFGJMQX57wu6EtVl4ChRhxkp/81kVyP9YaE0d+1Axy3iMD1++vzaqdBaxqFkhd/b313xfPMFCPnmLlktVxU7dAusGNc7zpSu+67qSdsjbIWi0KVWEqW3OPpQBgGBMGXVAlo4BCEMDjC6DkMgcMwEFMkni/M88zT08w8J2LKfPvVgfEw4MSR1TOPntN4JBS1FU6YJTPHUndBhMM48s3be6b5DAgpWtqIwSvHMTBKYvBKcDAGx5uv3vAv/vm/5LvvvudwvMM53+IElMUOc6ullMo+LPf1iPR6L8s+qql6TEArkf8shKaqYZo0K4IxQd5qb7uOK1+/nRWH1V8GU4/qeoy39ORXY65QUs/N6vWLNuBLGKbnnnkOSe+Nddtew8S9pO/tm+p+VsnoS+0pfwKisOnUWPY2sC3y2rMl7L+3+12vwW4XKVYuAlm5/S9qhs/NZdtJ1anagVhquipOzLC8tOq5VP4XWwzbqKJXdFUHKuREIR6WRKZaVHKtJF2I40qzRP2s3ZdlhCgtt/1zTdUM718ubFauRJd8LTfuvJLqCuJSzXz4+JGny4WMGQxTnCx1QuMul71b1B9axu9JGkvaC6vKJoghqkqspRb3kYIksgVqiRHfpCXxgvMonpQuxDkS50RKyaqtpcR0iYzDgB8dAavR7BhW44opNXfq0XsOx5H7+zvSx4vBr1othdMh8/Z+5OiFQzBYyln56s2JX//FX/DV118Vl1iHSLGP5M/vVKqZYzEivTbqb3Zvw3mj1cOvHNtKFVgYte3ei9ScRGupsR7/ViO6/tPE70IAtBMsynhv4ojuc01x8ayqsk1hw/230V9LCS8hPrc73N+f16ihXquyal1fDUUXwvuFBOjVROG6o2XH64AWblE3C99H07btWTDa+qoxyw3llH5UO6bx2mAkshCE+pNrKiC96mfpaz0eM9bSDkStTGWESGmGVVmMRhXSpeTDqIRIckKcp6byBovHMA7QQbbyj5YpNeNK3iVFGkLYI65t5asU9EIYaIDzZXC46GDJpWaAMgzBDHs776wEqEfsKUZ+98MPfPj0UBCzs3c57RjMPtGa9SVFOvA11YFWXXNNp2FIw4lYcZ6cSZdSZKaobpOAqsO5gRAcwQ/klJieLpwvkxF/cXgPzg9cLjPDYFHuQwicjnfME1CQWYyJaZoQgXEc8CEwlvgFH0LJ3WPFd06j8s3bA29Od8yXiZwiSZW744nvvvsFb968YRhHU3kIaLW0PrcfVInKwCV3HPiy3z2CXBBxLi6svSSiC2VozMkCL6ZGck5KduFA80ZbsJHdV58t526J3Vzgz0wOa4lmGedGYijwf1VBrBAuV2Eo52U4lQixfeTlCPM1knXfPqe26XHUa9quuq1fv7qmG/jHdQAAsUlJREFUK+bx5e2LbQrLhNfXixlxd0GkY6TbcDUVf2xWxGIByyUgRjW3VM1bg8z6mr1j4WIUy6jZD7Qb+FZN1Ym9FnRWvnQATA6mFjF9Rem7WAnSkrpDCpfqip9+dZ+rZUHNsySTNZV6t5ZqI7sExVddXA+Egqir1ACttgcB2aQwvrbb0AAllcO9x8k3VdsV0K+/WyK6iIhnPNztHhLvPU4Cc5o6MR0uT2f+6Wni5zQRZeZOR2J4i9cnS8hRcgrlrLgQUOdRzS11RBiFMAyQLCBNS44Rp9FKZlZvMWDWjMc8wHKG+CR8eDxzGWemt4n0debNmxMaRnDJ0qtrssJ9YjEGP3/8xIfHJ7755htO3xwRnSyLaFTmaSbGGSQxHg/4YBXU5gz4e6bpgneJu1EYhjtGHEHgzdf3UFiet6d7/vIv/pL7u3tL4a4OZaRnrPaaQ/E5k+KFnJ8QLGdU6jjhxhUXiuEo6UeK1JVcVT9RmLoKJwV5u7KWUioXAn484IYR9Z4kGceEaFgQfjHiSVIrRoTi1OHFvAB9zmhNNnmjbRmgXqrYqsQE7NyptijjxkpKl75xc9ZvZUDt2y3126376nvrM1s73ZWk9oK+9iQXwQJI23UWhnwmdvx2meuzo1/aH2loXtqWM3lO/NpOvF+s1d9OP3hrQ/YMo9IRksWAvHCK23FU6/+6Alx9xyJBaMkflPNy76JSot0vsrwnZyNk23nX2VQOT7So6DWTiIXQmAdTywopgjrLTrnkmqmuq1IYJqVKUK2fetCfgenXcD7dFRPcHCWIaWtREJJafEclaPUAnnPg0+OFec6IBlQhZdPJW1oj3w5U1ZdbGczAMCiak1Uva/tkCrhcuEPIJbW65+54bJyUKuQhEJMwBsV7JaWJeRLSDI+Pj6YCGse2t9577u7uiDHy8OkTX70tdQ4EppQ4z9GSJyocjydijDw+fioqkaGpoyyALnOJgr8IITjujkfu7+453d9ZErzhZEkYG6f3OS6vIJ20FH3aPlc951SLe/Ym0K5XOey8vnjbdQhcEnf3B8bjaBKtVlhYSyR2b60E5+ij0YtGdYUrPudm/lxbSUXs45hb9/c1jL9U5dK3K3zX/XurPSe43xrTzes7fb1mRV9NFHpK9/runhfbtlzr3veXbtpakijjlAX4r+exBqRGGJrqiYZVq+HvmqhdS/pVtKtcS73XSkRqQ9pAl4K6iNVinE8qh8WMmpkZxWXfPJvMlKHU1MW1zGMb8iKArefI2ii/lb62rc2zcCC9KD/PM8fD8Yrwuh1VIsC7xzMfns5cppk4W6bTlC3Gw+FBLZK5jkWKKk1Vm5ej/Vb/d4hPJdeOcbNBwQ8eyalTtQGSOYXA8TAQvKkDRQTvHW/fvm1V1nyXxgQgBMvz8/j4yN3dHSmXjLolA6o4K6rToqfnZAixrEmtCCiaeXp85HI+o99+w/ff/xm//PU/xw3DkmNcFlioBPUWr5dVmWLqfs9tfdqatz/aquZVwtPURVvE2fbdmA0pCy5OGIcjvriV7rZ6hrQEmdVJUQkB0DEwFSnvv+q2XbI/w58jAP09NQ/Xlij19/xJ281l2sdpvdT+3Hw+1+qewX7Cyr32RTaF9aAWjPOcyHPrXZ+TIvbu23vvavE6IFohuvbPzjO745L1A8tb6o1twXvCAOvxmptpvX0Tck8lPkANxqpUoUoHDcEXLxu1lALiTIVV/9O9fajnvUkn3eFXbeq5WwTh6sC1fxZYULW4A3FyTRRqPEhLHmc+/L/98R0fnybmuHi++DDigrdnRFDNrcSlBTKWnDIKRafWJqhljQ3Bm1ShsqSmqGPNqsw5kp0QfLFNiMf7odhxYJ6mUsjF3l1TOdTiSznnIr2Y1JhyRrLgg1viFMpzOUMsaxNcwPlscRDZITiGcOD+zVt+9Rf/jDCMy9qvWMeF89/KYhWp5zZRmmS9Qp7dXq6lhOVdHe+waQsSr0xSL+0uPWzeVd6/YqxW96/hbA8f1DFtNQmrN3XXn+Oqt6qc59pzmo7XEo2eIdz9XRaPy23fXyy5SDlry6l/cXt16uzt9wbDNxD3rQX8HHXfaysdY9ffdR/PCWP779y7/hllSpMC9sbWVD6NICyRzxWxrMZQkODiaVJtB4XwKFZ2sfB6RCx+w5USWF0Z0Gok1w6RLOo0VmujRd1VgXLv8K2JzELg+vmmml5htUL12VxHUZ7J/O1vf8/DUyRmS3znxRHGocSkVETvmKapqOBsHeqaihNyKpEksozT/jcimJwvmZOFFE11Y8bVRHKWMM/JyBgGNDu8X/uy9/vo3FIBbJ4jMUayOquiVp5xPhQ6ZesXwmB9p7NFvjtLzT2MA8EFBjfy9q0V0/nF978kDAdqBCxq69QtPGvZrv9Fi0rIvl39viICe4izwtWyxw0KXWdT66Tsbf8GM351rcbU1NQw6x4r9XLtPJi0Zm7NK+/B/rm2x9dqpuc47u24V4yZruHnuXbFcHUDfMmzzxGGfiyfw5+fbSKlYmS39jdSgG/bqxLiLf1tuJAvoGafQ/Dr/nop1bgiV7Iz9j1XrjSrmsHJuRVA7VHiLfK7msuKlWp8S7ErbMXYXElF905KgZVFFaDaeUOsNl0LIlAswYEFRdUcZ07FCgKJR/NMmnUhCk4QNxCcJ2luKpRVfpmKn7u5r4Hu2pvLkJNajvxyfy1p2qJjoUXSrpYOJecZh2s5oWLMnM9n/v1/+HuepohIIAQYwIyWaaJQtJLbyKqaIcGUbWI5+LVU+JOS48eLR5MhE8UIaDEvc5kmLuepJOUT3txZDYAQApqEp4cLT5/OvHl7QLKWILEFJi6XCyF4vK8EYuDh4YHLnEq9CEVHkEgXtW7ENoRATlaBTSU1nD4MA/enN9zfv+VwOFpfLlBrGtdNr2T9FpOjZX9SkcD2jmIvk2bb0AU+KRJpA4z1mTLCaN3X6148fhgQ39VQyEIWxdXzvBIpl2jn5Rj3cyrycjKvL/EWt+LKA1J0/ZVw1EC0RQXWn+nP46LnCeTLWj3D0k78FY1YNVPXart/df43OHCLWz9PGPo32rMOqeJae5+/oZ7btj+RS+rrn39OgpANorT7oRZUt4NXFqJwZvaxcBtdArqCiZtubVf1VLupyFowqirQc2aLGJyBC64gHSsTaEXKPRQdamX3oKp4bDzl8HVqAq33NMJYB7SEL5myYSk2gjdXGhGxusRZUWayS5a7vwTFqQjqbZ0WiUGoul7LuV8JBKBSZrVIGwuXJ8u4q4QhHkfGSWLwYafEhnJ2GZ/BJSFdMv/wwx/4aQLvZgYBJ54sI6nUAgiDZd903jhIL+CcBYUhjuyxpHZiu2PIo9hcMnicRdn6J9QFUjwTgud4OnI4DMzxgUu68Hg5W/I6tSR0X09PhGIbcA5COUQey7kUfGAMgcMBRn/k0+MH5pwI3uOmjHpfGBbT33qNuJQgwdOTudTeH4WfHz4R3wqH4YAnMojiNSA5UgmAFGiaiDcsCd0Kq5ZUFRt1UA/vCl4N/GK2Gg5SCG9VPSm2ps3zq5y1yuvX5vwR70YcweAlC65pCYvVQlP5/QL5AHiDucEIdgwOlxWJEYJ5N0XJZJfxUnI+VXmi0/WLL1UdBWOEvGvprlj+XLUtw9fn4notN95sEMDKftf1Ve8zSbyq23oVdymwlNJCVG5INM+MpOt1+ezo6jxUFFTx5AvaFxma62Bvq2/W175EBHr+mQUCTPOy1hVmxcoMirR879x6n0IVn1vfK8F1+1tdfPO20Y7jUTUOp724bkh7w1oiuZqjmmSwTaklmNE1F88cdYoXRcWTU25TiwR8djiXW+4lEUHnYmTacgrZFRHTDKW1M1XtpmxeV4KpsnTlwqSFUGtXfH0zJzGpjWR01mrzDmZDKCoZcSYFzHMiTpE4R8RDCCZhqLOx1yJPKUaThEUsZYiYLceLJ3hDjE5gkMAwBN7+4mtUjVu/XB6ZLkJKJe+PYsRdPfEpEkVKjWe1TKkIQ7jgveMwDNwfR5Pf0lxgyhFjRiQzzVKqkAmI2jsUPj5GPjxNzDHy4dHsI+fpPZ7AV/cXpsvMZb5wr3c4FxoxpkBCraWwe6TV4kWeRR6VK+4Mqy1BIFtJfNn3JS4tg7oVQzAMY1H19OOo0dHZJOlsTINlvi2q5sq55pmcZUlts2XyOjjq8YxmXSH0DhJvTn/PUJ2bKjGv379BzFv107UmgcIrFY6fBTfu4cc9+4RW/HRjD7fqXMMOsubRWD/eSyJuZxzPtT+ZS+pz7TU6u8+1ykVnzYUvX/rYM9I1F7hnOIIqRdwY/fpb+epkoTVauX2q02o/3sUAtgWOKwBc9dlz6N3alc4swKpIAwUJWQQs5KSmY3ZVMhjMtVW1ZW5tPXanuqpr+nku/WdUiwRUaXIdv7NqdPa9J6DgxRGzGV/JwnlO/PaHd8T5gi8ZTs0HFZBMCEWfXHCQERttapLq1qha1hXjFr13JHVWo6wcUqdWOnMYPDknZgFRj/jBjMU5FYQrKI67QRA/8nSZmC8zczZEl5LiUzJEh9VFiNOZWS0zqnFiip5n9CCodziBOSYeLpGPD5FLqXUwAd4reU68Hx54/OZsdZ+rZ5X2ELQmzmVi19Cp6ytXiEuqIXN9uXKy/X6tYLCvFNh1m3Na1JHbY7PG5+XrgmCdVqajBmvWM6sLA1efEbk6S7B1HV/PR/q5rh9eiKMubqifs3nuqcm3z2TE1GY7Y9373q2qIe1K5DabdEtF/1l+f4fAvAbv/gnUR3AFCTv3fQ4xv7j/+r5NX+v323hepC+UTrx67Vg6wKk+7Z+zV2y5ja3kpcaqc11DoejzK6IonJ+UtBsoiCu6m6IaahMTAfXGKTopiLjGXVS5X0u/G+mmPk7HxJUftNxfU0s0D5hucQVBc4KspCh8erzwd7/9PTnODMdT8aiyZG/OgRt9QX6VKFidBM2VMFSuDJsPIKK4olYw7nZRJZltqaSKVocMDn8aTG0SUylcb4j9fvC4YcD7jEhiRphTBglIycF0mSLOT6TLTHahSDCW0TXHWPTfAwBPl8i7hzOXKTc1guJIWckC02ViukyWsjothK+p+Jp8+byosDaaXt+xfXRrLF3gsWOqVjeUNzT8rVb4SJeMq4hcnaE2l667poEXoaV0r302ZsO6dDtn5ZZx+RbS3CxlW6tbevuthHALh6zXUBvB3tZ2uLp3/UMJVq0q5bX67xYRMpjff+WtPl+De19haLbhXCO0qlJ4HqveGtRLBrpFplq06/Wg1XvKGwvyWkdVt00vYtdVH+xeflHrAXOrD/yc7WSPaFzXwl43Ix25HSQp80pJQXKHVErsRDLdjYqYekuilQ/1HiSDMx38wu33DKoWQlVfWTiu/hQDKSZyrMDdZml1kzWiWXk6J/7w83v+9j/+Hle5+6ykFEk54tyIL0SGIhFKzd9cOCoRz+CUh6e5ieqqydJpK/iaYFCFlDMpmcqqpr/IkhBJ+FDgRzPBCYcw4kPEh8w4BN6+8WTxPD09MeeRlCNxmpmeZp7OAjhSTIgoIVQNuBGRhKlPPjxeeLpEq80QivurBqImvjoGDkMAgTnOTPHS7BEVlEVKapQKL3tQobT4jdsAs5yDVepsFny/3rcNIdl0GkJotRdunaWe2FSwWRi2/ZY143TtWr7H8T4319VvWtmSgqe63z9n1N0ShVvEqNpfoJbl3MdxW7xQ99PRm+EWD8VtX3t4pOLkvp/6g3bX9pjR59qriMLaRa4N5dnnXjOYW/2CtoyY1aPIUNI6kVZ5ohU6t2yOneh6gyBsRdTPjbcH7t4j4staLkTV7W58bYtoLKtjVbm03BGB8styU4ogrmXR9N6DV2KKiCuBPOIJYQSy1S526wOsypK6qe+/FHHJ2dJC7EWNi5q0ME8THx8e+fnTA8EHiz0Q86qKSUhpJim4bIFkzksLJKumx6yJOU5kLI22EI0BQBiA7AaSJpSMD55IQqKS5pmnh8inTzPJR4IIb+9PnA4jwQW8elAluIHRWfRtShOHYyBmReVAOh55OkQ+PjyRMAbPiUlsqYgxKUUQJWa4ROV4HPn1999wN8LgIfhA9nAYjtwfT3z/zTcMg2OeZ2KMBZb8q85NQ16yeLmtrted3ICXcFtCfq7n+/u3HA+jebNs80JKOZmt70zHUbRB3CJwK2TcMSGrcW/UsLdsAeVCu/6a9bx1zSTiRfVk6VTWY9sbj825GPBl57263q8vaSuGfee3/0Q2hTXiq1LTXuu5570B7XHx22cX7t6V3hcf7n2oqhxQ/WH9nj5icUW52QGmTVuLl2tx84+xlVSiZzp7EHHUxIFrz5/iartzigXwKBGrP+CKtLFIDKWP+p40gxaXXZWiYdImXYnXEiMhheDUaNn1wTZup/iVp2tjpwIR8zyacubn8yP/+OkD55wZD0PDPE6s/oGIx7lkUoG4Vk5TMUlDSwI31boWCS0EzVBPJukT3hUDaEqQPNMlc4mJc4pMktDkEC98eJp5PEcG7xi843g38kYzh6A4MikqswrmzJURD0enOHfi3btHNAlJlFkjCaFYqPEucjwI/+yXA7/67itM3BlsDXPizeh4cxgYnDCCpcjgmYBLXf66DdVVLQyTKsRse6nrZzSa+s4ytxsBasC3Vb/U7V1Yzc1+w0REB4e5+dUzXoGr2Imcx9yILYBPS+4x50J7V65qQtWW3VeytlKswvV5rOtT40daHqQ2X20w1a9Rj3C3rtP9em+LEG3f0ds1WjEnt+6rqpILq1d+sH+uGLrSf5bFgP5cHqb1s58nIF9CZL4oTmF9HV47uOeo9lbMgi4qtnRV0X5VBfX6VHu8lHTUzXt4OfJ+qaprK26+ljhsb1/rlJc/5delz7oOtX/pU0rUe1csSd+rrUlRKZGz+YU7h3euuSI63wP88r465l4lJwo5xoV2tJ7sS0yZj58e+PHnn0vtg8Jhp9zSPotQdPLZPIPScohzkm4Ie/Ypg4WxIh0UfHEJ9MrBB4bBc3fKnOfIYQzmSiqCw4jt5TyRpjP3p8DpMBBCIMZETgnnS0Ca98gxEPyZmHLLSppyhpxwGY6HwC/eHvmz795wdxCmucPS3uNdsbO4wDgMvH3zhsPhaO++go+1cX/bFoS3SM8NoZm+ZIUUvwRJFHBrbYozgmtOC/W3BVGZF5KU9PIi0pW95Yrzv5pTfdfm/PYMWCUKy1zXHOqVynln/ltGcCVZ7YyxT9u9YgY3h7jlQmsLU/7ZwW3reetq3Hvjf44BXRGx7vrnGN5t+6OJwnPtOelg+/05kXBvI8uoKpvfANI47eX9q4WSBUntzW9rbHrunucknOeevd7YrZpmgaRbYujVu8vvm9Vuv16PS6hqK2kiujSXQsMwnla7WcxrnqKmoR2I9XqmlCz19WpwlgzuMic+PDzy/sNH2yNKTeAaiStFFVdTdaJNYhKleVpVN8p+7oAZmkvK61osxhiGBArD4BmC1UB4OE9QpC7j5rDYBG+2Fem/q5KijcUVCQbv8MGhcyJV7YhmvIPD4Hl7P/DN2wNv745oupj9SzOIwzlfjOe212EIvHnzltPxaNlRZR3cVNUoIr1qcN1aLWJZ8O0eAdArWFjD3i0IU8WYh3JDjGnpqMBAIw5l+8w43ksfW+6HBb7Kd1lAdh9pdmeh90Dq8cRLbXr9Wezfvf29ti1BqPfsvXel29/iDFptKvt9uyY7873axxu45xZReG37o9JcPNf2FrWKR9sUD7cWeVncdf8tQylrkbEyDM3zhvWiSk1Ct7OgW+r8UpXQrQ3be3YPCEWu591zXHUd1oCwkQJKu02kNusg0hCu/VC5nZJuwFm6Bk1aUiA7i2iu4cJQalVjgXLiyKJXYjmq5HjmPGc+nWc+PDzx8eGxZAE1EdlcTk1iyFmbXt3+r8jY4Xwwo3SMLWNqL7Z7b+g9NbuXITxVRecZFwJjcAxDQAi8e/eBy/mCFhvLOA68eXPP/cEzFnVRLXBvKo/yLiNnDIOH4jmEGjG5Gwe+eXPg27cDb+8DjkhMGZeFWTNKLDUIPL68z7vA3f09x7ujBWIZQKO6cOBbO9J2j7VfdxF2DQU7cNarilbndUV1tXmmNtfSpOQSUQwLgl5BZ7GTLaqlHgZLp30ui378pfXwVCXoKy69rsEOUu+f7f++VFOxxQVbPHXrjK8YzM1vQq13kfsf7M/mHXttjaN2b7lqr80++2KicItzv9W2Il8dnFXCchb2f4OSt/d33O/eRmw3wPRxGR+gAuTqvVlRt7/gvb3hJUbjW1zCS9fmc+qpz0ktn3tXW//yz5rQeOhQjkklgGa06L0tMrXsX0u2Jk04y1nAOfzgqPYIcuyHgGomPp3J2XOZJt5/euKn9w8kGUCu8+J770qSuSXIKoTAPEcEK1WXtWbTdI3wp5R5+PTE8TQ2CcZUTA7VmTF48pxIPnIaRg7DwBgekYMQS06keco8fPrA6O7wEnCeskaZyzmRdcIFxzCcFi8ZKQFbqgwh8PZ+4M3JcXcXGMZAmiPnp4lP54ksHh9GDlk4jaExz+KMoNX60aZPllJNzuppaFpSYt/koDcMQA8DNosFuQPLGtPF8nS/9zJEkx7bYczFJXUj4buSq+sqWoed7+Wq6jq1fHFPFl1yeT3HeDWtwua3qzV4BUO7Gt+GIPTXt+25s1j774KvmySxEOPrM/GctNMT29WYnpGyXtL+pMFre6qOrWh3Kz3tTeQnsjvJ9kzHntR3pFJIfYtYV/rWTZ+vUR3dHEt377Nz+qPb9bifu1N1TUClYCTX3dPq84j5+tvZLuKtdNK+dpwHkKLVfkhOGPK4EmKMV8zECL/74Q/8/P4D4j1fvfmKy+WDuaLWoDCptgzfoqNNqoThYPRGswXDGTJmGZsq85Q4HC0+wOZqMQFODmTMAKtJ0QR3xxn5diSpuZDORUqRpMWuIiWLiJDniafzhWmeCYPn/o0jDCdSnsnJVGAiSvAjQxCGYDEOSWNZmxEXBqaYeHy88OHDe8L8LeM3b83ALA7vBgYfSsC5bxLvnoRwk4MEkxiUFgjX7ldtBuhUbq4Se0tx0SN9uOp3AShhTla72oz+mT4RXk19Yu60UvIt6PqNnUCydV7q4WeL0A0H7qfYfo6ztnGtVdL12t6zL1Xb3upPpNQP3xmSqtnTKpmvZV7aWdwhBLdVafb/SzUbLyUMLyYKt6zyDWNQF7DHIPX+PmZgPUBLv9AxId2ba5a/wrPuT3pvnroQgBXi7wzTugGum6oXdYWTSQVzPrP4RZQX1eI549r4LE/KHiGsXkebd1aMt9NVjUeT+hmqf2SbI427q14QlECrTnIrnEbjWuvBES1zLSojCpUQByrUHFTeW8CavUbI85mrDRFIc+Tdp0c+TjMzjnCZyVFISUAC3oGqJatzh4EcIylaHQIngmgpu1lVEMUV1HvLghrNYYmUwJd0ClK4zupHrqpcYoTzma+HE14GVBMBMU59HNA0MQ6W6DBnmOfEwIH7e8chDcbVB4e4TDgG/OOMV8VLJkgyjj4FdM4WD4HDDcIpeEJ2xORIF8/jfMZ/UN7ev8UDR+9wfmTxWi+HHYobcYFnDKGsQU6LDaWDlyoe9lykFqKRS3oPkQIvDRBWe0ajEbL8r0DKhBSROKHZpP2aL2kB3Fzgy1kaCx8251BxSS3zrV8zOMZsLMha4PoMF3woavnAtta0RUW1vrbHBG6R/4pp7AnUgoXK327N9mpoa0eot2PYJM6sjNstaWohqtfz6sfez6flWKPzDHuhpeGPj2jWfsE3rIZcP1cBTYr+Wp2W1CpluVe6OKW7VNp6AV5DyXvxe8sN7IlsTYulsLiC7m/MMrpOGuk46ueeeVVrImOVbBYasFqzeitrTqkfiW7+VjF8T4MtjTNZnlDti7lAmic6CCxIzXb74fGJx8uFqBmdJiurmWvsCdTcOLWSl8UmiKmosKjnGmmlKogmvAul0pozbVJjTij40YCnGp9zVuY5Ws3lccAr5TlhcI6YLVIulRTmOWc85iHkg5AX+QTvTaLxUgMJlZTgPNmcrDSGtyhr5zkEz3EI5HGEPDdPOCeWeK/ntq8Xv+O198CoMhVic1mubyUGmudXJToqHULc7PvesVOAnLicz6Tq2trgpt/5DomJLOfauLxrXfstpgzWv6lSA9KaS2jBEVUirmO44rO6fp6TGNp5KP31L9L+1x3Ou+IPxeKitH9v+3ttT1i+bsbSzUe7Nb2lVlvw7JfHPPwJ1EfbwZdWmZZyQtdlK6VVPmrXtVvu1SbVCN++v+uTser/NiNv+uBOh3lLbbQYcow/s49lUro+PlfGKTpfZVmjWC1Atnu2e65FFgB4dq6b68/NaXUvLJzi5l6jO4tBa3lnJdJF0qi6aIwjmuf5ipykaJUiPz488PB0JibLARQ1loBEq0jmvSBezIiZDfk6ZxlvfUmEZFG0Bd6yEWovQi4xVMbZLZRBuXaFzClymS6Mx9E8ltQC72JUYjQpqKbjthknU4fY6bZylq54RDkLAsxZSrAaaI7EqMyj4lzEqRDGwJ07MR4GJHiO/g5yYpCw2qttioQdnnD36uq3Mk6KakJzbtKFFklWKxdbP/QbL93rmh6wInVby5yVx8cH3swTd/XRFe5cgixva4UXhHlNFLrxFmy/henK5PSlcNfnQvcl8P6OLdHc/i77zxuYLQRkS+DauzYc/FrLskegKtNTCMBqSHVNE3swsBp/J1V/Sfvicpzba9vB7S2mIRHz1EgplXB5o5opJ3P5Kx5KrUjNf4J2y/ZRbR6L/rEHNmnSwh4gLIin/tErgN9+roTneprVHfPl86mc0tV4dtqKUMk1YahjutJt9hNs/dj33Az8/bgs/8/f/eb3/O6nn/l4fmTO4GIyt05f6zDbeqUUmSfzPvLeEZwn+BJpPA7klInzbFosP5SxZOPgNSGUTKwdIzaOYxtrTtnsEUdPSplpmjifJ+YpWqqK7HCSEJdwAQ7DQMqZ8zSjOoOAC5YHKc2RmGaTKhzEbNlQD6LMg3K+JAtUuz/wNgQz1qtxj6IQnDeCliOXyxM5Z0p+1W6FdzII7EgUWohdXxMBMKkMWrRsbevUCt2ry94377095qOAwzRNpSqeJZ0R2bxRayyBjWdfT758zzmXDLPred1S+6SU6MummtS6OK/cwkP9OmxV4WttRjflwuj1bc+UvubUacb4xYtqkdGviVgvqVSVbJ1DL8UvayRcv8Me65jOL0ChfzKX1M8ZZraqi9qsZGEml5wx2wyIX0IYlC6m+YZo+pxNwdwlzcNFtSa6q6HtZdwbY1eVAK6utTG9YvzXr1q9r/9pSfOxJiKf3Y/yz56ksO2zqdSK1Oa8VUSz34s6INO8ZFbP41EcHA7404EhgY9L5OZ6nFbhTDB7knMgZLxXcMnSh0skFDsEpg9BnSJ9cFvRb3tduMkqmSaUKc6cp4l5Tjw+TXz69AQC98eB+zcnxvHIECzK+OOnJ8AisH2Qog6D0+nEt+oJj2ceni4W/Bcj7nDgEIQ3J2E83nF3dyIVYmREwaoTXKYzb4733B8OfHV/D0hLf1BPimpN6ZIWzvgzp7yqUJ6D+5cA4zWfUiRXLWk4qI4ACRr3umEYPt/N1fgaM1avubVUveXs92wBe2qiK2ZWWJWP3RKT59oeMej/2mf7ZyshPO/Z2Li61ksleC/ZtGWuL7r9Znu9+kgpYkzhEFuw0TKwPQRTdYmVFtZD2oJCnEM7N7fKSWRdbFHPccBbQ9arpnQTELYAuIik25xLlchozg2jN2Ra93iXMPaGIPt14SKux/Uc59PfvgXwK/G7u/3WO1cHq0BaTTXR31vH6lIX1IR9jDHyux//wMPjI3PKaFHFmGrBns0KTtVUOtmRk0kLgw+oXgBluswFFmx9rIoaBO8I4pl8oto4NFeDuawPpBR7hSopzwzjkbs3HudHnHjGMYNGpnni6Uk5P0ZQz5s7Ic4zMVpKiixCTp4xeE5jKL8lvDi88xxG5XSC4ylwnp54epq4jAfugK9HS4I3OEeaJ1KaLRdVxRV9umqgLRb7TF9DOsWu8SxO2zIpwu79mxE0LqVAAEgyNWAsKdGrNasf5+eYuQ0yr2fbCPjym1eoWRHrEdpGM28R70uQe3PIcGKSXxvWDUIKTZ20R6S2n9dT7Z8QeueSNUGR5Z7u+hYX3JJ2+nv91Sa+vL0iTqETbdqgtHCbsuq/6cPs5DcE1HvGVGNLajn8dSWmVcMZsudCWt52RRK7RWX7zHW7zU13/SigqYnB0v96RaSqb//ye0OoX6QKW4u3t9R07Z52qwHVInJ2P3diiDbXpR3A1Q5h1D3ugLP3njDf8sw0nVdidk6JP/z+93ycM+eo5DmDQEyemCL9HokKGqFmea3DcRKKq6XZdZxzeIEQ7AZXsJsTq6eQcueuWsaXc6ayn0J1z3R4EQYn5CBF9y7M51RSW5j30/3dwcSgkuOJbMRGRAlOOB4CSQ98+vgEJeYgDJ5x8GYLyWYbUTI5zeRpZh7EJBuxGAtzSEiAN9VN2SynajmVKgbf5hABqtF1Kfa0rydfiIfd5tSyx14pRpR2pRpKG7wUaFK14k45RjTFAheeZvrbqCSlg6+V5Km0UpubIVwxTvXfrJb8MReGMZWU5vUdq/xmrqqACz6oEnW3dnbdIZrXeKvBOYs6pzAVvRSk3b/bNSev96GOo3nRtX1aVrcxAF09dpXlMGp/KHcIgp1HRaVWbVzG+VL68CpJYY+DXePEDlHlbnOrjlLWC2Mcd+pCyN1m4FoAfpsJ9Vo+WsGV3JYo6vhedF0r8mskbSEO7d7qpsrOmCpRWEbcE5Jeh7+Moet8p6mublpLVpXL7BB//3lZtYXA35o3vV62Ay4pko2AEfZCFJTIPD2uuVHNnJ8eeUKYspCjueJF9cyxRDQ7Z6qgLORZkWDpo0XMKcCXMqfOmX7cO2cKqZKcUhLgMgEh4ZhTqZqmi7dGzkWCqfPJzpIrZsUDoxOmHMkpWA69COA4HBzHozdJpujyqxHcF4+pYXCcGHj49FjKeCrBB7wb0Gz5gQ6HwQoRiZLjRJRgieOEQnwSopbJ1s76sl8L2pdCMDZ7JdJyg4kuKP6Ki0bpvYtdJfK6tkTo5t0ruCk3WJK7QhTibEYcHxrj2ACkPb2MudUdoRLaDegVYrEiHpUuqhALMch1jwtBWBImLpHWOMtKa27ZdQ0LvGtBqhhzpM2JQVspy/6UqAjL9Ko2oBKVLvq6wZ0UolCx/ILQq+G/Y107vGr2RNenTW/v7de2JxJawLsmB7R1We2rXJH/m+2LvI+24tme2GTwtOPTr9qKssDtnCKNAtZnbiHCzbVye3vfS3SE23lITeLfc8hCk27W+ZVslJXa70kEuXJvm3nuj70jrM+s6/Y5wDxjdtptu8JLAl7WUzIuqXqWVG6lhO7n9bvCMPBf/O/+t/w//m//HXOcSfWAa1qlPFFVXBBUA15cyXOkqCayZk6HAaI3zzGxxHPznDmNIy7YvHPKHAZnXH3KJfDOm1FVEzGaS6vpaKUEnWWGIXA4HhimiTnOvDm9MU8oTNKZpieG4QA4Uk6kFM3ziVACvC0I0DKBmwQhaNsnKzcqhGFg9KWEawYhlWSAE5rmgggTZnUoxLfyqdL52+7srXhfkH2V8K4NqMbpduejw9u7nHrHtjYk15rt2Rxn5mkqOMpiO5xTS4kiNa7peQ6177sajRuqrOPt4LpGtpOLvOAqQxTRHC3GpRihL9PE19/8gnHwTWLxlYCWiHFNmRSjGYXtpLKXo7ThgUYYlj1Gs9UNoSJmC+hzasSvCipGOErBpcpuCgiDxTcV9XTOWtyfK1Gwv06s/klbDwWpknCxf1JwTcxp4RFlYUhf0v5o76M95FURx3OtIoVeN7j1MlAgpsQgC4dxq8/ab7nhVcTguq3Ejgb0dUr7tg1ZferfoN2zqyeeGeee2qge7psc/k7b8+Jq6145jrZsWwlGiiqnkzrKBJuqWy24zLlg9Rg6lZ6q8unhzG9/+3vOl6m4ngYus73Dt4oyFhsgGlENiAtUQyY5EoaRw+nYMrE+PT4wOOEQHF5MtRSzqWi8S+adpFIK7NSEeyau1bQUmi2jawgj9/cnRE78/g+/I+cJkRKDEBQfsboT2da91pW2uXgjChHujifSPBOC1ZuOMTGOltKlGpmzKllcCdaDcRw4DAOh6tDbv5ZKOTcDbmqIYdsEIUhNR51p8lGvVihcauVmcx3PM7xjvS5t2xfCIJqRFJkvT1wuTwUWTGLWwsWjytZPam33u4bdBucsqa+rqqaujSA4EpqLii8liDPn85nL5ULOudTivpjnWcpkibafQ+ik3KLCzomcI3Oa23y3zFKVJqRw4qkRAHuHq8ygmlRq2o+ANuoiBf4SVkZ2bokgLSrc3J6rg4RU1XpKlhbDNrSouHJ7n2AlZ7XsZVVXGV5J4MTWYp6Y4ozzz8TCdO1VuY/qQlz9VjdY1le3ENcj04rkt8matn/JmdQ4iOv37LWer1kTmmtglD5s8Wpe9rbGFXctd2OqIlwP1P1YzYf+Ojqzf3Y71u33RXKSFXFaRipsHQ23RLYfnKkTpJtn/74qJbk2VxGT8BymzkMtoKz6awse54fNGikfP15QHOIDOSfSPDPNIDmXzKWh1HVIjGNAslgwoyY0z7y5HwlO8GS8E2T0SAp4b+oXT414ziBKqGDnBHXCZVLmHAtn5kq67kQeBtQlhIR3iePpyN3pZIc1JzSZ4Xr0gVmFLJaBNYRgkoi3MopVK2VunopXZfDmUjtNc9uanJSEEgYsniNG7u5OxlmTLGAety5ZUrGh1vJz1wFZ4kB8CQbt1BK2nwVxdXr2ql5ocLVSQ3R9VljrB9PgJaOauDw98fTpkzkGuCWyeKu6WoTbJaFDz5BcScmtX7czRuX89MjDwyceHz5xOT8xXS48PnwqSDYRYyTGGVGLnWneZ8V+MyUjsilFpmni8emJ8/nJoFhs78zJwZiVXGqFZOfI82x2jLLANqbciG5VL4KUbACLpJ21JBKUzu4h0vJdNVVYWQdzpnCLhJezZe4tWYa15G1v+FPrucakl8JM23lwDJ/nIYEvIAq7Xi11g1d6BriC4Gfeu9sX5R03ROKtKkY2SO7qnR227hFqr5Lp2yLk1f4W76Nd5N7jaHtB+b6fm+Ql0sz1PXvuhnvvWYL++rWra7oYjouiYseusKgNhBYyLBahi5NidK05cKp0uH5P0eTgnGfwtZ5xhjQRBm8lKp1VsHJOCG5odZZR81236pymlnEijGOwmgSqJRuHAXx2DidVVDb1TxgckowgGKwKEosIrubfn+YZdzpyPN4zXZ4K4TVx3Mui069rmSkieSGOZvMomVo1mToi2jqb3luscIwUZChC1kQYAiE4SxeRKVbzxYpV0eMWVW52uRDIHfit+768sMHALuS9AGkYXrb1m+eZ8+XMZbpw9IHsXWN+tJbVVGmcrraz9tz7iyzcmCUxe0G5dpkuvHv3Mz+/+5nz4yNxuhBjJM2TIcGiOrIxJubLpahmpOWESimR1UrAxpiIcbbCQ6rEnJGc+VQDa+u5dQ6GAYdYbEpZV8VsYLXfRgyzFjVov7DlGa1pQOxzRf71OUv6aMDSUto4AXzbPFelhZpiqu1qsUuJN6lCBqraepsi5VZ7dZbUa+QmcIPb7vXj/d/+81WxjO657bu277t17wJ5Vde/XGojLWu4xeNXiLv/sRAEi5TdIUx2GmjKs4qgWEs3/Ty2NoJ+fbZqtT1pTbq59rORhp/XM6wcDkC1l1XbwDViWXhFoXIi5j4sYmtQlAal1PN6LwwxzyUdtytxBxBKmusm/RmlJWVlCPZeJw5xgxXCIReiYM977xmcmH6/jM67klxOtBkiUSU4CK48LQUrO4fkZIbZlJjniTjPRqBEwFtCN9VciEwxUmZljrGQp2VtXeEuU3IktYJCMUVCGMpBx9K5VATtHBI842FgHILNTyNJSkxH8a9ZlDvKTTOhLHYqoSKaut+1z8/7uVd1bQclPRjQZz/VQihzTkzzhfPTA8fjXb2xvHDdb5+qfQVnBbFKhQPtCUMGcWQyKSameeLj+3e8++knPj18Is6TSXRZ8c4bshZnNqEgJetsNJWOmqeX5lxSnkRTQeW6ziYRkBI5zkzTTFZlDIEwhBaXZCpsaUdLKQkkKelUqsu2g+B9x3BJkSyAUmUxFynOSVq0DlDgzirYuUIQpDJyPd6hul6XyP4m7Empa1KSFRZcMsd1FuNb7YuIwrrABQsg8Dz3u0gVC5Ifx7G9L8Z4lUW1iZ87rbdJXHPOC0GwhezqNdNdpyA1YQfpGme8uNza5orWugywDbZLlat1a665t4ncIm49kdlb6zbobu6r9aA+TzvEt7jMts6l2lc9lBW5LIe5pJzAo0Ulk/pizU6KR5BDddhwgpk0P5CyuVvG2Q6ck1KuEUjJRPTkrNDk4I3bCl45DhbRrCkRnBmNKdx7cA6NZU/KuOy3ZHvqhIBHVDi1TNvFyOsdaLSMqxqJszJdnkot5iKiO4eqM/0wkOZELNxgSlZWUlyw5IeqjMPA43nGu8H0wGIG15xsHSoyQEBGx3g8Mh4OjIPVhA7pgfNwIuMImnG5WhQKgdAah7BWESrFtbSo9mIh3KhAApcNEWquHiqd6yKLHFg2uzE+jaEp2E/QIjAqiTuCA0ik+cLDwzu++sUvcck43Ap/DkN4e3FDFalVqc7ApRjpncFVLullsmbO84UP79/zh9/8hsfHR5yziHecb++6zJMZ/Usactckh1g8iwQVkyKk5CqthZbqEJMTGDzBW0GkYQgcDgd8GMjFbdqFSuCMASFnvLezlkuU9RAOjOPBVKxlhasB3IIgc8NtldMXvw5s2wa69fhgUeWBlFKeWatkms3u0+GzRbX1+fYqotDbAOq1lDay6fJEQxC3RFsRYZ7nllxsGAYul0v7vXxYf7/RVpz4SgSQKlR99vn152Xj+1Y9CIzb3SNIpdsOtTZefnPv8v3zYl3PDb5QCrz5HvPAUbKmxqX3Y9rrIC/yz1UzYpTxfu1HLwhjCOSUebpMxMLxI8rgIlJEbwDnMmOodRaKysUNuBDIeebu7g40czk/4cLA0/kBjxQOS0iFCVC0eDA5clGfHQ4jMZcZBEeaIxSVi3NW58CHwJ0biCmuVIExCpfLhacnS0VxOBwb5ywdovVeGASEkjlUBZGRYYB5jpYB1gGacHi8pWFFYrTqzZoIlkUPs+UMZcWfXraxSqvoZfn8zIhq9hntjsPCsS+5+3flg80OU8ZVOV7FqSPNiQ8/P/DLX08c/JE1xLehITvX6a7sQZbRFiusFKfJDPnjwEnulvMgS2qcgx6tvw4Jiq9qo2qEF7To5PvD5Lx59oRe8hILUk1JyRoR55nixP3hvp0hsuJ8KN7EFqshUs//PtbJJR0HFCvgBlnvaUX6feudR+r+1dQWDkpW53oW7d0hBJ5Nuti1FxOF4HwrcJJzNsorGIeYO1/ozm2ztj2k2VPBvrDEcy0VTqSzvdxUNfX9Vvc63cDlsrD2+3XbqkPqe7fPXxOGvWpHFViv1V/PHMer+d3QLS/6olVf1Ye9N9b1hcX78S/qu2uOwrnqrbHvFCBVNdOPHWWOCe8LsvaewzCACqfTcQXcTZKKCi7jQzHq5gziGcaRMQSO48inxwcjIB3yXrRnZu9wIviiPckqhGB1CnJW/OAsY+o0kTUhTpii8s1XBy6TeWwYx2cqkBxnjsNg9Q98IF4SczZmRoCgSlQYD5Zgz3tnaTLKmoXB4b3DecEFCIPjIHA+P/H7P/zIP/zjb/kXv/w1o89Enc0YmRXcqWOj92HdOMXyWWnlTA0diNk/yjIlqpNALynsQFNhFPpE3os0AUoyCiSgeWaaH7tsBOW2YlO2mIvFwLydi/Qj6EBYyhgePz3wdD4zTxMohHEkDAOxSrpFTeYLXoppNjWRKqn04UIoJVE72C9rkJNJlk5qUSMp1fFcy80m5bc5RpPwSj4twAh6ycJrdSQqMAIlZqaqx7y4Mm4rRtSM/iKYj4GsUMFWPb2nfttqEha8WvGw31fbPdNe7pJaONrqIytQPjfU0gbVp0GobYuo97jm3fu777XCl3FhW7VKtzArTVLpp3B3+zxJpbb9GBckutXhm6rpetw9EbKjaYE4dUD7hG/tUbLlEq4M/LLgiSujv7uem5Y16Fv/rn5Pt3Ov42nqrJIl1kGJ6u2B7VpJYEbQgSoO1LKXKZrnRy8OpxyREqdgutKSTM3BwQ+EYJJk8I6YIg+T1T62gMe6KMYw1LHV5ajBWjbNbMbEEu0KQk7K5fGMfP0W7xzqXLGOZyTB6XRsiDVjMQmkkn9Jjdk4DCOQOV8uOCfkZOvhfTAEkB1zTsxxQpwwjgcSjh8+fuJf/7u/5ocI7u2fAcL93R1ff/UN4/33+JGWGfbmoS5Ii7qnDf5sfnbB9u8KBvcE1ca+y+prRWDVvlONuTlOpPmCDqcWfbvAcZWmPi/tWxcLUUPNU+vx4YEYI67AQIyxc3e1CVRYCgx459FQ39dzgXYmHa64fS6G595FvsJkvVaGwrCpjbA6p3lx327nywuSF1Wrirlh5835ovagrLDTFkfeypu0Z6utE96TND7XXq4+cnXiskIUpW9qrvtbnOwtIrD7vkoxCwJeClUUkSuv77+yBXQIe61SWk7AVX+715c+Wz/t3TzzTHuCxezc2Tjae6ur4eapzXxW7y/rsprv9VC7lq84+OX2RSW0lWCelV5ecdUV3WwVxec5EmMm5IQTq32cszJNieyEwZnft1U+M/VSCAHvAiF4RB3TMCyqtK5nA/wSy0KhxWIeHC0iVSyjadXBSykclGIxPrZ0Gib5WIK+Kh0X6BbMuOdKISUEHxzH40DWiFNKZLQZr40AmYurc5n7O0fKwpnM5eGJd9Pv+BBn/P0fIM28PZ347tvv+frP/gXf/+rPGcahqAT2YWzl9aVUDHy9PeW3FdxoD/3dtS3IrI5Pj9TMe2aeJo6nhZGiqazWtoyr924Yona5OEEM3jP4UOwNAt7jsgX5LY9Lm4QvtqAq3kipZLftq8YCoIoPnd1S1jhuGZcifqn1oU0TUGhlDcKtYykdOr9O4yEquMaQ0SR4+422b1spAfaJwhavVhy1wMTzavy99mKi0AeO1QNu4eolpUWRNav+sucuGmWs7NYOIVgh+E5NI07otRnrzcrlUK8Xsq35inB1LFS3QD03Y32tDd17h6Mi+15Kqv3Wba7zUEByLVnYG5O3nlHXXkbbdem5litCtDnZ9fdmH2EBlirOLgd1Lb31klA/hir51DeuALqNbD0mEWUIJo5fJtMNZ+BuHMnBghNjjMxzInolSfXzp5U0lNE8O7zzhUgYx1gjmS2/kANnBKaqDcRVfTNkKe6S4plTzUdUquqJeVSZOqlKOMYEqTcbhKVPsPQDUSkGRM8QBsQ7K9fpHMMQYFZiUs7ThTxnwjhSDfbH44Aw8HSZmVMkljWf4xl3emR+eiCkxN3xxPd/+Z/zn//v/yt+/c/+ktPpzlyBt62cfSdCFqE6Fyx4UNtZuEXnhUUaqVC9SJL1s1z/rkBWcsxMl4upXxrzosufXmp4htlY7GZGwL1z3B1OuLfC+XLhcrkYDGZZsVMVB9ToYVuGqtJxXU7BZUxa4AEtSQ4rU1QZv1zm7MSi49WCJBFFnfUpZcy1IFQ7t2WRVEtWW6lnrZztxU3ITlH56ovEm1W72hodw9ppAhozp2tHHG2/uuVxWOb2gvZym0KwYI5qwMnZDuOUleyK37fD3MdSwqmz1MWVsxVzw16qdfWBaz3nQUNMYBxXQ70dAqtBIkoqZflKP4YBGhHQ8twqslcW7xsjbCDVLtPtRY/2q1pFG9dpHInB43Jnc6/rnjNCGVcylK3Bto50P7flkPTvagbsLSfRHdz6+2rclSA2bkYKR3ht92hEsvtN1Qyr9qgVnqcZ1UrLC9EF43zucmIc1eIVkmf0nvGNPXPJ5mMek6kGXHA4NzAeBobBk8jky5lpyMRpRIPHjZ4QhOPxSE6GjDXNNj5VIOKKkiAy4CQxDgGJAB6GgagPC+w5cJLJOvHuo+P7r79m9CNZlUt6Mm8b8TgdmS4THx6eEPGEMDLlSJzSioM7jQcmnXmaJ55S4OF8YcxWRyF4B8nxD//4B+bpDGR8CNzfnZDTAYmPiEuc48zDh0d++PkH/pf/5b/nv/lv/q/8y3/5f+Crb36Jpp2D7RyIR1N1SV17GFVEvOUUK7j3xeTVLRXmfG8HUGhJ9wSUQElwbgb3Tw/EX1RCLC0iOWvESzAGDRAcqdljzElgpeIo3zV4IpCDh3EwbxrNuCnjGKhZYZczK00nXxmgmq+KwnRpY+jqAkgzdfTBsSLVpRM01/Ms1GgAcxddBDLva0T5er0rMYANQi+BcX1b7VlWlgLPRujtuFZyX722VlylxVSASVEydD/ddGjebS8mCuM4klLV6edmHNaYcSmRpQR7lCE4NbHcmGcbUhIWkX3VFo67LlC1S7jK+RfWYFkHA9CWvKpDTi0/YKXMrBdQ6TIVa3G3axerhWyPsC7jM41MKr7+vbi5g5x7xLoz3/r9OULec/H9/vbEbaUyqPNUpeVyYuEIyXFZhXJYlm3ZdFIjS8v6i1dbp/LcLVc3FZh8yQlEIqHMzpBBumRqrWfVAXBk9ZzdTMqJ6eI4BDiNniQjc4JLTGRvByeEwJxm49YKB+2cY3C+cPYZFWNQJlWGMKJqdQzAmBwaQyAcDuZCOKXEMCiHENA48vs//MxTzZxavKJCCCXnT2QcAsMw4JxrRV8EigttJAPTZD7xwStIYJojd4eR+9Mdh8OBwziSgOkSzYPIlQjwlJjmzP/rX/0rlBP/5X/5Bn/cAMlCkRfE0vjFwnU2RC6bB7f7vPwmPUFAYdNt1oiot/OnyoeP73gbz8hgpUVFpFR5E5zLzQV5Ty3SemnSBE1i7+Hbe8/c7r1R2/xm69VC66OyumsjrW/ff8sustV41LH3GpbPvaM68dRzsTxT92lhHLfv7BleEVPdvHhpNu1VLqmm5xWqz38Lw67IrnDgzRTVcwD184qDXROAXmIoF8iNmG83BxyZBeEWLr1wG3sG4Hpj5ek70kATDbbQ3x5bq1m0u3at19tw6lqMue0WKzi+qo+r2klOawDaO0gi5oZZQ2maON/1uYiuefXcIgnY1HXZqvL7Nl0Gq+ebakFvA3hdSTd4fvH2nuF3DyS1mgh6ybhk+vj6fM7O8iP5TPKOHALgzVXwKeHcRBYYs0PnmekyWeyAQsY1ztR7T4pGEPAKyVQFWQxmw+jRSVrm1MpMmAorMoaB0XmCc5aOItNy3YTgcc4zz8n814eREFwrFBVjZDweLI13tCKuOUO0YIWWDnkcR07HI8MwFDdeOF9mpqwkrcxDZsCcr3744Qf+6Xe/5Ve//jW/uPv+epXF8ljlsj9OS+hbwSENNlZ7tfCdqw1r8ENh5uppkeUJdaiYbtzgNvHw8MD09MQ4DGaPydkM9h0HXOE4xmhIfscPv8cZ9W9NU3FtNN1TnbysPUdMbv22Pee3nq0wXSvJ7UkFt95T53ttZ32+z6txC5trL6cQr0qIt1fcogKGBRaBZetzaC6+s1eDMw7mmgL3UZf9veXzSkKoF67vv0kMut+Ehdgsqp/+uaWLXvTupbWeM9iOqRrCr1qlPUrx0tgQj+3tK0K0EKNKBOQLT8RKjUUvUC8AtJzPRWTdjq2979ZBEdNs/PLtW+6GH3k/zyYtJsuDb8jHomTF1/k4FE/GMUVzobzME1mF85wYA4wuW9H4XJJfFAty1RGblCTEFIlTJueJEMxVVBU0mk3AdMMCWYnxzBwjp8ORu+ORcSilYkUIPhS1iBktz5cLp3AsBGGZu6VPWDxYBMvGOiczSlflQs33pGpRtkLirMqcHI/nye7xDhktBPx8fuTjwwcenh74ll9crTFOTCXR9oumhqmGx+pbukI0TfRb2CTTcS+Mwx7R6B0U7LslAHx8+MA4DtTqeT6UrLBaXdUr19ypcregpcufVX3t0vqsylfg9gLW+OWSxevu3d5/7bjx/Fnvf/+SsfSEYfua187jVYZmQYrvceXu8uL/C8VjoHhkOLqEUGsuulrGK4CaiFghtycIrFL81k/L+66t8Z9Drva953yAHSL17DLqOhio9nFNXNYeUiuBpX0oSPEGV1DtIfX8VuWAiCxrU5BBJcKNy2A51bcBYyEL0iGIZZBb1cHai+pz3Iw44c/evOWr08iP08QZIWTHzFzyFtk94jzDGMwG5xxJDdFMs3HZc4KHizB45f7g8JoIMhTilc0gmJai9BmYYma6JM6XSAhWh9k7IajFMmRNIAaNl2ki5pnB+ZJQrdT7dY7DwYiCAikaE1Q5/NypOVQzOaWWUVWwIlJWSKrAXElhoDmTNKPZFa5aOU+ex8cZUMbBMXhTS83zzBRnYo6dJ16/yEIYAmfp2aRyVtrnfLWVqmoqns7XvXnKCUhWsrnUA8WltcJ4sSFWuESFj+/f4UMga2Y4njgeRqpDQm/j8C4sDEc7N/XrYpRe3M6rtPN87fbXIr9bbU/V87zKazlzV+rqnfe+9LeVSvq6ZyreeG4et9Rgz7WXE4XODqAoKWec9wShiaUGVA6xkkpcIW0FL6VgeWOuK4FRsnYBb/1D5YpckYcOGQvdMdiIa/SLbYjTlb4r96ZopVjLG2R/HG2ue5vcnl+41u2ols9aOLo9EdN+r3Ef5q1k0ZgUU6q5Wpb3CU01V8tQVrVbTd28HW8V1yvuV+p9/SrLajzLWvRAJt069leFwQ18d3fPL97c848PFx4eZ3P/PFigkC/qlzAY5xzPSkpLTvzBOwY/Es+REIVxEC6XiePgGEQYvV1zLqDqifFidQo0o9mXGggeqxQqhPuxODxY4FLWBam/fXPP/eGER8gxIZQiLd6T1KKDLTDNcurUZGULY2PR1CnOzOcLc05EVVSEmGGOaq6q80xELM2Gc+Si//3Dj+/5+ptfWiK3+QllMEM6mcM4cDwcSgaBdROBYQirHTFfi0WKqkVlZIXE7OGFKdOSnkMaYSV33oPJXuNESwpyShBYJorw8d17LtPE6c1b3nz9Lb+6v7eAv1K/oqRCZPAwTea95dzAcfCkZOq3EALiPaEwlwaLsUnJDW6LV9AtCXkX1l/YdnX1rAPF6lmhIG0vNUtAJ301UcuInGpvX1gzV3WctY/PpqSojOAGJy5465oYvNTY/GKioEMgp04M9A5NCfGT1QP1DsmQp4TX0SLsq7EYMzaiFmUZqe5cwCrYpUP2BUErmbEtbCrcjk15LnOs4uoi1Fb+aCEjSYX/b3vv0itLjqSJfeYe59x8VlV3VbemBY16NiMJ0kra6h/otwsCBO0EaKGNhEFjUKqurMrMe8KdWpBGmhmNL484N7MLxzLPjQh30mgkjfbia6e4ziIEEQoCECguY9xTjhMhzeSnoSH4iecsjjMOMJLuLA8yPu8kydRop72Cr11nAQoQTjpSBIAAOadCBLktPbZVCq3QTdAVEmsEvICQz11jmlkegJPzvAtw4CXVUXoL8fawciaMMj8TiWV9NrL+DyDLxwRstxd8+/0b/v0fvse//PlH/Pkvd+DbV3z/8orzHg8PO+7Ajz8fOA/CSZ/VQL69fkJA2jCGEz//dOCv6Tz/r7/6hN9884Lvbjf8fNwBuuE//3DH2xEt2f1+4n4c+PQCfPP1J7y+7Ni2Az9/Jvzw57+A9nROTvrD9oIfjxM//fUvoB//CgLhq0+fEHdKxQ1inz8f+OMf/4Lf/e4FX70EEGLI6OX2iuN+w9vPhJ/fdvz5fsNPP77hfgD3tyhs3454x8O33wD7G/B6A172E6ADf/ppx9vbhh/+07+A9g0vry/48U8ntuMH/NM//Zf4u3/4d/jtb/8urmCSTRyA/aS4w/sWcNtuQOD19Hfw/NIdBw4KoP0Wzy0K6UBC2nAwR4YU5qIklMI3+O677/IEOoDokaRVZ/tW9o/cbhs+0yv21xfcbjfcth33z3fse8BJ92wc5bmzEBeEHGnH+P088Pr6it/85nf4zW9+i5ftN7h92oEduL0Ax0nYDoDuLFMIRzALLZ4ATS9kS4pICHxlJ2WBllacJmN1Czy2JN47Z4jvAu/l0EdnDygVfxFCGtfS2z+q+cQxzC9JpQNhLwL8TC7vPcRr+DaccXUJEbYzVnAHC9EyER0XssWDqCLEEyIpHDjOIwnXAHYlYngirZ4RGjAAuG3c1Ge2dPNWnhyzpByyytfpiebME8FIE48nxXP7eVmr3CVMsmyUssHkEfYjClGivJEXRMCx/bXQQvE8lm3bQEe8GpIPndhSmOmkMyqMFH/dToo7bBGwnwFhZxWY1iGCgG2PR4gRt0danbVJLZEIIsLL8UPMRyX+TCDQ/QZeh10g5KzxkyerY8OH80jnvRWG/ny743//5/8b5xnw9T8D/9Pnv8f/cP9tOvURwjthz0pMZsZSwJe4Z37OaUOarKR8kilAOM7vilJJaWM3Mh/E5mLrmK3lqHPL2u6sU9MVmcUbBt7evsK+3+Jx2DkdoWyqRDqHPwq9wIoUzBeFFq7XcaYjKAQ+2jZQ+C1uLy/48dv/A//bT/8X6GfdK/fzxA/nHfjqN/j9v/+POGgHpbPE0j7ueN8C7QDdijJnirYNYYuneZ7hxJZXmp3pIMMzToinDYggYKcX9q2jQbNFA/HguQIWTrky4ns6Jr3MR8Y9JH/5yw84T2Df/4J9u+HTy9fYP72KUvgvGWFbXBb+HFVQg7XcObRVQRJsVDJip+I5y/dqyWpQCKYUgRfW0sc3QA7QTM8qTCuFg5JWS6uYse04w4G3IwrssBGOMy48BAIC7+RLcUrer8CWOeUBueHcCMcZ10uDV+nkUEgAsGFL97nGwR0H6o4D97QsFEgsIywpntPYQgqhsNmMuDKHtrTzMZ/XhOgOJ0ESV0/csKUrIgMrFwL284jLB8Vs3A7CG6+Sp7jCiBn43DZs+5aFbbwXNp4dRcmHkIorekVxLfZGwLlR2nxFeZMWUchH6wKEt1QnKZjjwXDEEhI8uHbaEPaXWHKuWwzvgdL6cdH/OTaZGiog4H6/pyMkkPYs6KMuAgF//fQ50vE18C1u+PbaDbALMHfo1/uX8Sw6Ynud+BF/OevD8Wh/wctXv8H2DeJcDAvlHO4907jjfQF8exefiYUYkky8XHo9AOcbzuPEnjYf8rt9f8mnfGbmv73ixr8Dr86D2qjFaOU6fkpGCa/g+vnnn/HX/S/49Po1vvru27RxLGeN2bIRo5/JT9VGC6GjVp6AUI6DkZq1VMvDImRZ/BPiQimKFhSveY7uVrjsXeYUXr7/O3D88Uwx3xttwHHLS+3O48R2/xzDCIR8kTbOtJ9h38AnSscJ1FjZuBzwM+6f39J65GipxgnsE9hesJ1btjBZ+Oy4AxRXcJxndH1vLy85TswrMF72vRxExRYbUojqjMv/CHEbO85QaCTCSTfc9lsM72zshwRs988pshLygYAbALx+DSBOkm3pfP7oet7ihh0iIJxxaB4BW7qAZ0Pc8BPe4jWMWziwhXs8D46txlR3bFuaVD3wdsadlkTA+fI1Xl7S7WccK8cG2otSCGnvSNg23Pdb3KBE8WaxKPBv2loPyGUn7sqHh92Pt2wMbXvcPfob+hn/ij/iDZ+nmfADrsE3++/x3ad/h5dvvku7nSkOaA4h8smgUi7nOGLZ6XtwH6oQDGGnl7wPlMOGIAIfhh29vLRDfttB6f7JIP4yyAlUUw8iwuvrazqR9I6ffv4J//rnP+Pv//EfMqJKIfB/1F6g4U0Oz0z2uiCUWTZ+WIlSTqLS57RZgSpkJqS0BtYAEx0bf4k5RJlnBqaVwj/9t/8jth04zgM//vgT/vX/+xN+/w9/APZPQthF0jZ5KfZx4P75M95++hzPsLntoC0uF+RzwN/e3vDzzz/hp59+xG++/x5ff/VtvCAjHSD2+voN7m/3zADneeDt7Q20Ad98+w2OezwqgYjwzVdf4x7i/a0E4OX2gq+++RqfP39OG822TN/ne7wwfU8Wd8CG4+0tNm8K8dzfDtw+vYIo3i+MJAzP+xtCOKKATJNk9/tnfPuP/xRXprBXscVwFM4XULqE4+3zZ4QjrpgJ25HSxEF63O+4Hwe29Pf2do9n/NMeLbBwImwEOgI+//xX/PXPf8bnn+KGrO//8Z/w/fe/ARBjwMd54jziviE+0TOEeBDpDsKxf50YJW7f3/Y90fgZ8RL5mGFLSjHEE+jwssUjOz7Rnk7HLBuJ/jv8R/yf4X/Ff8b/w6yIlh3Fb9fBHjNSnnpQCaEHBqNDyi8G//U3/zP+4av/Pu7DSNbodiZhz9Y6CyXcAdwRN6Xt2PA5WbzpitVTb3KMvLtjv5XjWxj4GPKQBOLGEYF0W10gSg5/EKsVo3DgsJlVGi8vNxxHnKz//Pkz7m9/wufPUWaw3I0XNZG7LNWu2mF4dJmqa8nzZLKPLHlKdqNqbNOeIAdHT3plQ7dbSWNXWJa5iZ4i9GBaKXz9X/03COHA/f4Zb3/9EfvrD/jtP/8zwrZHqzevWomNcqazQjjoxJdYh7SsLTLFHSDgq3DiO54dPaNze4YQd5puhHCcuKV5CoSALZz4/ONP+PHzG775w9/j0+srvqYtL0j4OsU/eZXU2xlXPRzhHt1eXkaYhNl2AhTYi0gbf0KI9J933NPSxXvcLhdPO0xb97HFuOYnInxFBNzjihZehseHZ90o0n8G4E6E//df/hP+7u9+j+3TV9jpBS9IV0m+BGAH7slTAWKl7slVPsMZl1Ie8eC4b/5w4DvEMNHPO+HPsZFTY/NUecAteV4hhLzRi62fPCEfQpzKuX2PjXa8UFxbfyeU0UyEe2L8AwBt8TiE7XwBcAdow38I/wv+OcRVLH/dNnyDH3ES4dziWvqX+0/A8VW6CCT+5bFBmiWjxRNXtTHvYNtxhBAvuUHsp2jEhhi8C9Eb2+gNJ15ifBxA2OIqpZ1u5qIoaVWGNE0U0iVtO0Jqa4BX3Zx43QjHfsN2e0mblLY86RmSUM7HlcT1TElghrhSCjEkiBSapPMOnvcp82EhdZMwlZnm2y0K+BDpQVqwcFI5AiGjISBgB7BnNAde8zt294heARz5ylDgnhRL6pr0z3bwcuhSP4SQfwG8OKiEk4oayB2d6xOjuAE3usUxckbv+49//CP+4b/4x3jGVaY8DCeV32PJqg1TFaT119oI2bLEixGoA2n5jRHc9XJvYFaY9xXbyRPjEzC/o3l/RQgHbvsLvv/0Db7/3R/iHABXCiRaI+3YzTYBAVsStMTL4mT8MoYsAh3Ang67yjwQANri9aRiNc7L6yf8jih6HsJ/iydVHGm1WgBPjOM8sYd4sXqU91EQHCFdPh/KQVRsL1Ecs+ClZGdScvESlxiyQThKp8lYYwjgm6SYGeKrDdv+Cb//wz/i5eU1eggRex7MvHqJEGP9WzhxJARpoY/sGKRpcmxpkUcJ40Zh8pKPiUZUFKdgROHhISCuJEvhNJ72jLHoAIQNIR8BsuEGFhQnzttPcc4jj/vYv98hzhcRAbfznvTKS/I6eHktSgw874JkvkrHpSRSAaTrF4G4iqPwHPsKgZCW7r7E8BltcdEDb0BjG07EoctgJ9DNeCDZWqV4tWcIODkPlSWlRFvmG2tNBhBCdNlYBuclwxQIW5q85fHCAlhVDyzs00KCtFElpr6lPqS030SEUMEzCcKaDOVWPuT6ywuGSOXPpOUJJCBw3+V6blxTMQxYo6QxhGSIZO+DQJSOu0559h1A2PDnP/+Av//979PhTJFXiPYoJ1CEZW+HsISWN5GbeIBjpQxKAzEk4wIsGgJA4SWN0TklRaLv7QtC8QiU1E+ykvloRR0u3KfA/5AanOq1gDg4qEys8ADktyEK+RDOjJs4RAKzGzBoy4AHMR+xEfnLMkYclKyWgLTsE+lc/bTIPI6rODBUKY4Luik8Wqvn32p9caFBNhQBePn0Kd8dwKOu4tPUeGwv8rOiTLl2aXByu/LbYlwpfZXpIVJME1Ld4n0E8QVP6BERTtX/Ib9jYSaXwWYa84bGMirOdOAXtzvyZ8j3/5b6UhJAYrBtJpYsO5nKnBGw50PCyrLh+Nae+qu6SPzmY7cz/4r2sMokt6MQDErZsJWRiN1kuYHLdYav4kWg2v8j8eRxpjUKY87tRrtYVFGXSZVVz4xF+ZPHHZeZqQzql6KvSIGCPzqht7SohPkqttPPP/8MXpyRF004Ju+qUui9f8SjUPjEZ2bPHTjvIkynQj5zeHn8cR6XWmWoLpG9thREujOuMxJ02uLCyskgGTcjna41KMSzLKAn1iVLwaEG5waEUzK8kCskh5OuY59ZqNurwQzsfd/VtgQp2fSATiEdPsw+C03GWYRAsPlZecO0ahZwJXUJofBaW1a8BReLFm6G3B6EZC0K7ZLLJtG3rOe0oswOS9Ue8kMLYwvBGWT8W69MiUpFKi4fp2hLwWvWu7AuvsRT8WhpuApfi3dqQWYFrKZXaHz7phwumdqh4gtVriGbnNJqK0ZnatSJUMspVrbMd2xIvL294XZ7Ec/N6HCsf69fvPRemmcoBGWs5IeiCTttwzRouk2LpZ/evFqTlgVY8BSCoYtMpYs9m+PUht8puTuetZD1KW0gu5zP1Ft1nGGSPjRcRmdChq3KHERZsTJC6HYGUdo/QBOdJpo9T+anKw41U2uLz2P4niJVeZPl7rUzye9EqaeLucIbcVIyW5VcVkt4M/9EegFel8508VxNTi/mBBiPFQ7qWYrjJ4TocQ8Lw1xnT5hz3ULd/u5E6EWhUwuKjFl9z/1uXxlF7hts8n1BoHfvc0msNKsi4rgx7THi89glpQ+3La64u98P0L7ney9aZx/JUFILPAXhGhgTSqKnPNzQlPk3mPQtReb1e1xY2Cu/sNkVhbfgKZSNORLywJR0dt27OFksT8hMKdBe260vvrmq2aVQsaAoyYqmxNXRYXAqL5ppLJS7o1xCFY4tlV9wnvm9u/SO/VXyLecRsEFNMv+JHBtNsUFJau7/YvHx5jbHcg4AcBNl6LoTrHVfFCJhA8lJFemhdOqYw0XCDpFHt+j6EzTCNu5RbDqEuGCiXnkikfg0e4omR9WMMuDl1vGk1Ei0vXBPCSbiifEWVZXoguztZ6zg8pR3Lj39Pu533G4vkZp0LDnzvVxhI/FV4/MJ1v8MWHryc6YDECsg/fQlclIrb1lOj4ZRmhEsKAUqH0RlNlNRBGhecQRSuqKtN5hmJ4HspdUu1UKYqnXGI8sf7eHC75UsCyGfFdNcSiat9m7pfSApkKkWNhyxvMIW7CHZ9i5TiFxvx3Ud9H9+RlHgxKK25E0LAWis2p02tfoEENYVHz2QLd5NpJPGA/d7W0kWD7GgiL+93op83AN3AvBJIPQDlMAAijIwEQfdQWcSTK2xYObGnqAEMuZ0F8txxEUar6+v6r02JLIplw0jV/BOeAEz4/7dIWq18vNpNJW2CWG8QqsHC0phE75jyJynQgJA7jxJLFlBQXviMd7lFpoDR2pJG7ftxQulxsyMlE1d3sjGLn2iW1hhJVgSl5yeqqyII6S2yOIqBCOKBG2lGtnxTqIsDzdXQNnfVMqsvYP4/PT4gXR/ZXJI2Hw5DSHt+c6X3etZgIAcMUpWNaXJ7ir0yUoGrJRj2nyaXMpyphLzrnGw4khLhDmkFRPngkIW4gQSbgCbAUxf4LJyWuYh1UhALhulvyrLLbtLOZ/yqrgR+F5lLcErG1w2W3/hoJjMF2VzfuYn7psYjmOmloexlXpxuC9eCLOLscr8HzHPyC15XLQdi9xuMo2lRQqyOF7jSjzeFSENAikL7FiXuLlMm9aW/yxQ4crUttlMcRTanPKyC20Yj8QXgHReWR2FWVM+80tS2f3tCHCX2yWwZCQhEp1L5avBhXFDWrfJY5SSVhCcv4cyzkJSDESgQErMcCUrChmprY7MZiy6/MRps27MMlVCKmS5c1UpjE5/sFjjNVq8GiZAfqZ+MuEih+K66kYAa1p0W7DCk6EbEo1DKTzCOVRpua2EkOZ04p1sLwBu7NWbm/Ah7ofwBFzmcRmGIt3XRUlCN2qltcWrSpMI5SX4ODtc0hKxITFVIJW/IGgVebttIV4Vr1wT7LWTFKB8S5nl+/OIS8X3JGQl2lYc3lMYskw3LHcBLM+ocvK/ZaSHnuzs0FuXq35lWigbII8pu8sH0Ug7ST7LVmGTiYIWyvKNI+ylYvDmNDif/LTPM24eipJZIaypmlQAyHFaqZR7UFkkThYSaV3aoVtnxhWOoZQ2XTxQtYUmPDmlqYByaKEZ0CxghrynrwQsgqHcEsbYeZ+C3//lcD4p5+JXApqD2n9uhYbnkbUmIWX++N3pCyf8ZkmyPNuaU5iF2COylUj5d0ynxC3x7/uOvMIt02mEemSg2hsmlKXdzmjyDDirENiiz6cjJDiPeDJCSCFEEnlHY8Kbb5O/p5SBGROM1wM1lpXAEGmE4VYVNfBi2sZtUcRy/8dVmD86uyPkp8FvJ9WYejAa6wv1+O95BPXzyNiKeQYB+CyEQgk3WRnKdbCdGpkjEe0dpkVMj6nLRv6cjcDdfGZwGc2SlbbMQxPWhR5I/Dfqe82cckDyCbpVDiUkeb16arLMG0K4TVp5igfgu+z8KRWDSDBVTl1eXcbMZKB+Fxk0yhoRSqiGR4Bm5gC7nMEL65Tng01gdvwqjQ/gXnamk3jfmwPwwrzbVgyO43zDedzS6qMt08n3Gcvw0Cg0M+sRSB4sXN4WtCMv0zMQW57o6vxCVtFpDI9onYGl2QhbuVUYuePAdVfOK6u2vvmEyAdxY1IVjhgy+Jg2mI1NTwItTtuJxFan6nVo0OxD23Mb5rT9N5G3ZRi00s7gWh2kLVrYIp5RCAXS/l8++mGO6SD8UOfZGGbqTeYPQDxQcpFv+f5lGTrieHxMQHg7yk14UtB7HsNM+PgqLOMhx0uSrxtt1fKEfKLgCKTHZMfl8NEZhA3i0OBpy1EHbU7nXpGNVxihnkgEEMqpCypWKmkKNQ7GY595lfGo5JBWy+KQYZhRNUeM1WbMFnWZmoouD18vPDIDZZJxbrOiV3arfOsRNOcRqJ4v6dGgbPxOGEqm8WjllUFyhVZMV/uqcp4kPUEIZzo9tZTjfV+ZhBzNdXljYBaXpi+OgT3E8NFBB2jf8pEa3niVSpfvwPZCgytgazDyRnLd0r9VMM0k9SIMLh0ULy2zb+PRP7Wh+4geXNqnkCYL4IWT513hNnpvV2rM+iDuDGx5mYJbwAMxfS9ZtAcwPaCc0lJgIL4ruiinvwozzC8jRip6RCyIExUqWsT1nXVRg/gkxINsCNNO6nOMvDZ6RyF4IYeeQKlwUPkuBb4XPuoJxkQBsojpCWQjUGP6rfHet6JnvKdM1QOebE9xxBN396iIiUqMPJzxIicH1yxdlYGWjSph8GlqMou3Wsaz6Kt25HKo/FjxRIWeR24OrgMAjoErxzrT16ffg7Wzj0JRDCoO7pToadQ+lM1OdTz1WeCHPih1lmc9ucEmI91dxUAkDgqboIwZRpKK64PP0uPF0PlwMgu6evqspRbevsdRcMU+XrX865N4GHmvhVdjyJznqoU5Smc9E1t2jacc/TAPpfeI/PkEr35eHa6G4prza2h7bOJX8pLlZsMkPM8Ab89IiwdtXyq6WMA63jaPiRB09GJ5LGbcxBWJHt/RH5s16I2gzlQ+ZL+zYZKQr9GMCxPNazHRtoXC4GnZlcYfWeo6Ll273S18rcGa0/Xe5c5zhnOYObEEvltRo2qV4qR1BmWoGSwEb+NLEuIBmjk7YZd2HxbLt9VvrvXF77LnlpQuabVl69unpQ1KgE94CzZfC2SIww03lgf5l9tKnfqNvJuWJ9TzYDhtb3zYurR+W5zMc604eghp1VGHnh5+7zNHAAbwcGiU+GOehx6BtciJD5fmFJ5R8LNhxvWlxUnmtmIonlI/3XvDehlKSQOVPvF2Qmbl42X4QiD3KQNICuExWrzQzjOgJzS7AtMzABuPZ+leEULWgOO4vCynol+Tegn0prWCMAYbE9+dZ9rL4CtA+7vVztJga8GakTMGpfzFvyvzL18SlpSCZnbjrgjwrA8PV9VYxr2ejaG2nlXejecrunWbUzLDd5PWiKW1xFJ9T2sFF3/y8j0iKoO9MaBmcMcD+TaE0BFQFT4Sf9dA5gzin17LaPq0Kz7rqa54HsLIH6RzvGhA+D3il+GlFSHV88jsez56IoSAT58+TYR74Crnq0KO+TKkHdY1nrHlPgMjR9zzpuz7mflEHbJKeQ7fOPU88PPkC6RaBxf2+/YKXPAUQv5oDcUrDBFDp9fc/IXU8MItqyGxUdnZNW11WPqUW/69fI8eOpaZCoOQjChf5rVQAl/cXqtdpvNfUg6NOlQlNRSV7JJneQe1kMz/VFD1t8cj7CFkhevX5T3CENI78BSkR6/lZ67X9KSvhVALQTZs+Lv8s7Tbsl0jlQrvxDs8ckFj+nBR6fH4pji2VYjS0KfmQUw93huW5hRUQziqtq3VozDoaTpvHOXVSE38TWoBXtEjPnu0egNB0RsfpMTiSO0GjtY7+4wK9kI6C89BiMq+68WPVxmq8uRCQD7vSpDXHfyu1uBVEvZMrBYh6gNSNTET1oZrL45eFJIr4Eyd46CN1eDJX51twmN0X+p07VBCO449Y6V6OD1+kc/sQZMrAnJFWI7wS1w8F3OKS6zseBtZ9xq3+pU4yY7DxL7WlrHQGKc9Kz6jDCEqqLN4igAfSB9820LYta35oxXP1sKFHc2+BpbpIoHIf8Xa4dp4q3UaVmcYM5otP14EGrRCcOi3eatnIRRG4LPNHGKl1WIZs4efqBz9xsWVz5nQkxV0Y1D0sUAdDEqXqUJRWtLikR5J8XrKahLF0Q26XFoiweKKUOYtP/1YKBThUtLWq5lK3SLfarR+XTif81DZSTkEgY68aXgdI0u8SYN43hOqmoY6rNHDP8I1FfI4i0EhPZAevdJwtWVUXpbIw4eobL5lmhWDY99E+bL57cHHbsr2ileEbPGeeIruCt9BXcaO4EPB5NqwieOvZSTMGA0tuLx5rQccu10B16hcym9syY7GHlnyfvxO5unHBEeDVQrQC3PFzXJHwIMmW4Li+Wj+5lHXlQ2FCAu4TNOvUKHa+angGxj5bVtXmHTSOpyDq3XqebEt4877zr9X5zS8sMgscJ2P41BejDVCZpSVpOm9QSoEC1bGyLCdhUoZx7CFyzgS79UowcNKocdsvecWXGOUKzfAWVkQi2XXCqDYo1XUoeRKefu0tWCndCFKSEcXb/XK/VX6Vzt/XXXLnGvpvTkND1y39wGZ/hyF0DpqG+AWVALJ8WCouM0pV8qX3ISgPFGV0Q1PzIYLRuOT33mWdctDANA8jtoDD1dPXgQEhAO43W643W744YcfAABff/11PvPIo1sqzJmxMxO2GinhYO06Tu/gl+c12XIkPUSkwmQeXRbyAZMdWmfHwvzR2YsN7TGal06D7x7KlFOhpE7dW4PKUFc+gnwmLDtv0E/Qx8Bdnm1OaQ0/4Pr1oB9rn8YC1RaNkEIMjbWUTt8y9S5Pknhm23pGWM3kj/K8Xp8vs+t3VPGgCklaOhCPjYnt5VpHDk3P4ZFHcTySvym8EK/i3Pcdf/rTnwAAr6+vaiJZ4pBCdNaT6lnRK8ZLvvlD0oR2P3njZBTJsEreNQAcxX3VS36X8FGEeRcudqx+VxRCf0JyZBl4lokXm9T5KccRc/wO8xaILW/8LrS8wYpOD0YWTzM8sMowtaxT+HTMU9Ynth8XLwzmdwjtFHo8WPJWJvhO/pZKBKjd+Dxp3hisAV6XMP+tC2CPz+07hl67uLRe9U5n0pMek3xgni37Shla5jxuJDElLQPGkz/V/MYgfHeVtqt530Up9Adk/KvTFOGvKhDiwV4WT7/RHj8J1fgnzWlfjw6vc1vWLbuaPZxS8a16JD2ao867Yk04ijb9SyncwWuEQjhBdIMMyQWlbNPTlod5YSDMKOSKhxyvlIQW9PLJ/mAhE+lH5lkV43XpkeXBtwy8cXEJuE9C/i7pH1ms7wG2XYuMiCGqb7/9FsdxNMc888uUNS1+P9qWmV+RvLzEzgFmTAdUskPWWe5wt/in+0M+Nx5LWb03f0XnU5XCKhNx56hwQQBokw2i9G5K1y/rjAmUpQHAjdNJWjTONHAo5cmCtO6oRyy4TXgIIwunFWuc9SDs7xHVSwNHxlYDe3gbQHxKZ2E12bd2UOd+iDGbfPZMOc67Dz1hYNPV78vGNv3ugL5lra2rKLuYnnWNOtacvm5e+ib1axA9M3/ewGPdVgjGhvhaAlnikZ8WrPEk+57Eczt+vTkK/j7yEFc9ohEQgBvSlbHpFFPX2UORHVzOmXZpD8tw+oFlJSNvHbUvnffWpjkLj9wf7xAgJxTnGjh2uE7flLEO2tEZ9Y/HXp/TRNyRdtC8vy32BcAMuACkmyt8K0iCa/3heQJxDd4nlPXLQ6s1r7e0J4Af9SzKOK6FZQjBffassq8C8zqHvJgWef+DSoxrhmQP2Dvv2U0rZT5889rVykltqS0NlFW6dVyFda1LR3bLxPcZ+rppQrw2fgaPtV6m2obT5NBDO0TkhTBG4aRhuKlhFbbzsBVsXNaKJnv2f3oegKhoT5G2gNyHMMNZ2cuaSNuDnF+0V8tSLrwbharrgf2q9AuBSPeFm2rgWa3MQ6xAJdyJ74LwzuGq5/YkHSTGkR1Lo/60tNh3nQo0mTVwaAmIGyFSOEnJqwuGa5lz5YJ0fR4JMz8lfDRXqXRsLBsnctqgEn4EUOAAnd6iZYpxY2/LNaihxF3HFlGPqbqMR7xyoabac829Mlpx1nadxO/UIa0wSiJRAJnv7XJivvaAbAKHjgzNVwTQbChpiAe65now12VdmQfplv9AG0SQShoKl+ynSWog5yKCGNAz9LX4OQ6BwLEuZYitzBc8ImhH4I37Mn417Lu43IjD3rxrmXxcs/xawmxQ3keLzlVYXpJqO8p2WPltCSMRB4PKU4NIdwbAXCAvLXHdkKJo08grDaUs/YaQbwn/pQ5Jg8H2v6zXCr6Z2K0t3xNgRUm1GDOgXG4dk9UM3fBliT3B0pctgTojqt7dIE+k+q0xeVTHg8WP4FkW+1w5Pe8x/erICJ2Hv4mZOsGT8VTULeOY9YZbcyKtfKNnMyDLY0udQ9uKxwkA1UuuvbLlHOKK5T9qpxFcPjqbid333Qzs+iyaCGaSQ6bpVrQtfK1ACaIca9n1wjIt/N477/2MJdfKR5P0SPDqsWIZSU+lh0cdU6z1Mq6s8GrVRbbbad6VvIWI+VBX+31r0p1U21SVtljzO0VrNmqeIaznrfA+NOqLecOjhAOtMuR5wdrok+WrSc8cPix3JQRB59mIJMwKxV64SFHlGLWtsTTTB3YCPoSQT54lonSPNdIlkFp2eUq0u4hEjAlbx5En0oMFpSAvEY9/+35DCFxhJqomtIZQV8gIqvwvlfhzSZpcVgogCqXMCQ3ZEua2MYu16++abOFfBVYMozSjcqRVNa2wGsKVEluEk/tVeAUN8AagDSF56aWilVahF9KSgs3LvwJy4BLHNbUlkS265dNqNSvLR78wyIUN+dqXS3jKcCPRbkXqUx7BRXgFNdz39FkUCSuG3PQUj/Le97077jwe6BkOLaH7SNjFs/KZrvM8cb/fcRwHvv7mG9B5qM2qrACDNz/VM2aF3fKsegAXb147jiNrv9fXV5uymx9m7FWCnMtBHFQxtngHYdfJ0r+zDTCjKav3k9rWUy5eJ8VVAjTwjHzaW3SOvnetJeGq6wIDyi11rZCBxBXTPGrNBkFPJbSbZT8RuPzEoyEvgijhDRuamOa/YdHa8OA8z6uljy0PS6d8F0pDJFYuCiDznFQIqnwPkXgn9EtAv22tNT4DLT56NIzUUgiW1vQDIMLJV4wG0U4tmdEqz4xfa9jOGJMeLF+yc54njuPA29ubIrLVMVoG1e7lkBlDFFCsRZ8pDB4NJ7XStvLlZ/FHpGGJYp8OO9/Dz0b5JB0xT3lTPCVdjo8vWvEhBAQqa+6lB9kDtVoCmpnZA2qVPWsR9sAqdRnKCMmDUPUlABQQzlZ7PO49qsIWUI3q7qmGGd4u/aMvP+2FW1q0uUQ5NCqBHZA2iDlzhWcoNkynPBme6YWHWorCwz1jsHAbSX4uIcYx3d33DeXTMhZn4NLNa1c10Aja+NrCWwrE1iT3I5ZET3G0XFrZMbatPC1ODfwrCukSGMtcBO3k1F81WNoGQMRXMJl3Dq4e6Bjrc4TsaN6HSFxqUl60cjxE1whme73HOxJk3YpVv2YcSSHt4p+QDV0lkpq0ThMg21sKVeLvThi4R4NbvDQQOK1HYweHxWOVgqUhpxV6ws4vuPXpVHHVk5WwfMkOEeXTC2+3W7XPoAfSLbbPuIyRK2ctYndMNkI00w3UYHiJI86p7O67mbKuWle2fXiFgxdm8QZoS0lZeoqHqsM4PYUQQgCOohha2+q71pUYDLpOQmlNKpMRqHYphMTQiEijRFPydlmkcgjF4lw1mMgKu/fSNcbKjLJ0neaW59bqc8uj2igS5RKy1W/7R3q2+d+QjplIY17yqzxR1aOlBZmXKREEKAWRFelgDMs6sqyQ9NUG4qaUtHwnoeStDcz8u8GXM7DkKUjErVhvDWuaasaClHhDONAbQe9lbfPkVw/3jGIgYLWJKhzycyX96UyiZ3LKP+llYzMa4ji1x388at0DReHZ8NF7gg6OpHY668nw9wJpLb5bGe+Ue8U7IKK4bt8YeDwmjk4rsEcaJ7vL+O5Z11cVXlW2TOfUy9LJygmIk+aWLkU/gG1f43WLKysES+wCLCkFqXWP48CPP/6I77//vtswHjO0wiVeegnlOQucM1YhsHC1B1L7WtcVhEFePhNwhrh6uhIBTD/SGUvpGQRTcjvJ5Wnzyk4WNXYhezgzMyaLkMPT8g9O+xAZ6yo5XqRaw1+RREC6IyAg4ABtXGipQwghx1alkM0KMjJIrp9nXY5gxQsj0acMZ2AaQpWn0FT6x5a3PB4prkKxR6ifgR4U4s3iVN8P06uwEfnvgLgh0i0MwsMCwkY4+Yyz48i7fU+n37ISIAD3tJQ1sLUe37+FU/HKyFiS49EdV5nWUNqJUcmb1kLp/xbPST5/e3tD2Ch7PSeALQTg7cC5n0DYQbe4W37jDXBOFUI4o8wpVOa0kRbh0fCryf5e2rzGexJY+8lzi6wbbfPm70Ez5Eq8t8ZvB/OahvXCLYpWVRQPCrZS2gpG4rPPJSP2tLl1M1MrV1UctnkSslRexMEniraxYKLyzNZJHFVmyub2EF4DD0wIgZ8eSOufiGCyKNiQhLSt46JV3R8UZL7rwebnLZ6Tdt1JRh6mlFnGRBSvakTpC2AuVp9xGa+mxaNeaHKoTLN8rOk4TZqKLlN+XD5SrH6vHpqm4lnkO4zNDPOK8dVLq0JYIolKb8a1NDp745Iv14r1SEbSceAM5bY2aVjaEGbCBOWfh5AtiticYnxxjsnBsjSnwIUws91uNzQ54EkwE/6pFJJJOhvrVy7oBVoLPYurpBx6OXQit8uPypT51TurTITl5uVvltFrlVBcYIn/DGdejWRXrRjkjTIZVRSbj4SR5LwFmedblkt9C1Pm6aZZJNMaIFkJcHlr6GKeltWNufppArkPiyJ0YbLeUlDN1S1xQDKmQmY0LYi9ekmjY5Y+XUut5KsynHb2Du/L9KU6U5Ljx3mm6ASAtLpTG2Xa6ObibE9wdDcb3UQgYU3NsuSlA/F0o4yFtoNsiclncXsWRQtsbHgUolgJd03Ry4Lp9PN6TB6FrrHce+5xTIFQOxhu3tEEFy9H7CpoaEGWXf/8pLTzrICPA2xbErS9utjlgMXf9D2xdjs1BBD542XKYzBWvlefEfR4omsdGwOsopc61uZAV7Tomh0/gd3q9OqEvvIy31wXdBx/k14otALqzoHkf1CiAy7Ux75LT2EUWsr1JconCJzniZeXl7ZBmMJDpjJ5bAYghm3zc67THA9NKwXLpLqSLAospTWoc05QDxgPWpZ3U3BPhLFGMEOXpS+HeQbCFRCtReWJzDsTC23SUxxzgAJOpK1/Iuzl4dLxch9vt1wp/NOoUvjBBsxcP+i8USDo+LVAPMCjvMXj1KEMAs5JD0HjTZkNhAFRsyHTZwL3qy3bE8heWEkrwqIBKPHUkpFnyprx3qPAl21rFC0AeRBseU4IxGNhva2trvPGNonfs54YEUXv9AT2bQNoA20baNN3zGS8kiZWkA28km4Z+ZhVCk9aShGgo9TPhRbTNJmpIZRtY8vnTUHYFJA+HbxEd+ieD35fBoEoENLFH2PszNDHcaiDvBhGjKKF9RZzDCzWWYgDqMRIl7xSiQdxY93tdsvHDlzFNV2miTvbZxJut5vDn89RGsdx4H6/D9Ndao8FYVvxvSnP3kQWEMMr53mmuRajgKI7GiUQRY9B4jjpuVKpDs2i+u15U31jq8wlbOluaps+RpZOHCHE3dCPVGIACxPNdtJKewbLA1ZoNK6ibTLrgnnltASMjMnNzEtI3CVtY0euxON4J71YLpfjoVWHwSFqdtrEpFOacPJ2b2YShOcREICNigU10TctpQmOhSprrBBLRGIwBOTgFcXfxXaJn8xPEY9YCSLrk8pm65BxEW3J6TkxKzTlZN0WgPN+gF5SvbY5HB69vfI84BVp3ntWyLNljGi0v3muynoNvXFRRQjEP2qM8YSxA2pF1Rm9yGj9Ml+UOnOIKNddjSvkPGegsgIpxD5lAmNdz2gZb5ajoPAJyoTn54S5qkYolndICcKWltnycW25sThsB+ykkRCl3dgUv/NfCKXPStgu5Ltiun0GgMKZbmMrHtOselxSCpqQEKWTmvGewlS3u8noubXv7Wa3QlQtF5dDRVLU9fBUeY0VULeHsTAlSqcpyiCTA0rQJ8vMg0ugJKrocq0bFTKpOq4mrLQMikIQ9YL+zksS6/4u2oiVgzZQ+sCDK0kkbBSv+szhrEXTiwd5+f4Yf/YG+rPCTbI/Z8OifpnK+oi4gvhu81RyQygAt2CRR9YdceFC/mGoYROBD+HjpdHSiGm3n66TS5ZjjbFAt5iYRh57rByI0mLuIjA4zpPnASplnZXQPGwRgejD+bwPXLJD+VNag55wUQz4vrI9C2tFqRNLlXS14/eAx7hWEciyV+iMhTPNQkCKUvJcBRdKQKjSdgsqXhm3TYP/7SYxK0Rsy7YHWJ8qKVAZz4pgVeEF4Z1YfHVG5Pbe970s9+M2Su9nlu7FfLrcEb2jCd7eO+v19vAV+nRaDk+s3gus+yYg3lftEquO1M+Poc2IXKdWmZLnAcVOmVdQ15+rm498z6+5vp0gaG9gZNpDdgKkwV9Y0BhakHwaBJ/pfmE+fDQ8KkgqdvdY11WwuKM52HpHIoTFNhrXbS8gzIyvS+ApAS1YxoNS/ea/DkR50dgx3PBI8vskmNRcBdIgCYSwBTXILP4ymEpncNiCn+8Jp1dXz0PYQJdmjXqCKwu6dOF52Lz0Rf16gjFhct979QnnCYQYvz85jQjnza7lLuU6faq8qbrOVXoHtBDWefn9SNlYfEODrUcv42lImZDo9I69KRPFht/OEycax+SEVG+nLWv64+/NpJGUOwa9oh45lfa0pTcIAEdKFkQaK1emvbCEoxmyhW6zrpxCr35rsOwpsKLredwzIZQvAaNOWtXMGVfwPYWpvJgbxG4BzOghIJA/L4EGXdVd2GMKYjopaAeWqcxjn/lUKhOwk24MXL9eCDAXJYrM7QkAJ3BSaacZhWaflRL6in8Eo9DYEi89C4I+K4npyPMVoa18GJTSZlkicImEC1JO81IseyuvQF3eNRTOFeeIYSXAwYbj+VRZyO3q8bryENJv+2wGFpVCiU+VEIC2WLwGGDIuU+++0h7E1AQfp89hlyhA5W1OWiHYc33O5AxoC1TSFEjvPO1Wb9IqVOmMDK6sL5Hej/vXNBSGkk3UFi66/hHxrFU6guJJ6zonBNNCrxgpRZBLJSAHUaxBhaGUTWXOOYi8IQR3d3D5KoUBe5NtOVTzkx68ml9smzO/WiHoC2BL81WIm8z8Zek7bfj89hlHnPmdPgixFlYlMNPzZvzfm+Gn2KK06Xa2oZtCifxsl2VpIwCUQnKa72wN2ycMX+mngt8xPkSpi2soAFxSCnrAAYBcSbJmP3MOm6ec1YM0MThHXgDkWTHcedkiFCUk05CVwkZpkjP9Fj57+tCWpnXrem6eZ1l5jOBZUbLMWIWaHu+3hRnrtyCjzHRpaCEt9RjnNTRZoZzfMc2k10Vshs5evYoC0GW2vueQghD8HKOgVL8oawP/nxUCb9zTeEP+k31KbJmGPGJKHraitz2XI4O/3hAv40zXvQctj6n1bOTFyDEqv/Nu+UDJcKBYC/7TILk493jBRLk7UM4xa/OAfn6qvmWO0isbtRrSY5pyP7RYTvIkyVB5CAZzRYaPr/2qycfWQAhizaJWEUJxsRicHL8PTDRL8JpjUTkIFMVop3hGyIR3oAaqCK0oBlZChBDCWdxX4tVEYgAHyVDMDNKgHccQZ+K3rQGplGVmyGZRXWgxhJ1YFm9KWeZK1EdDFyxKYynashnmNQo1aEkwVMhcvqI94dlum7BBJJ6iJDTIpZSmHwuTIJwlxFImSv3+rue/VG2qPLaO8tnIUOjGqN13zjOiuPGPgthFnNRb0OmygqNidGnaWUHUVvU49GbwUVI8gT3jxGlqSK3xL6evQpW1jYC4u/io6mDLXQkpalqkUVM9FDizlp0+4feSUmjFDGUI5nmuq+8iuTDY4ioVR1zjHk/6PM9D5ali0APB/oy6zlr+j87X1Hn1uS5AzWwhHOUITyVL9eD1aFPWVX5PSgD26Bun6bd9S4F55XDYp8JxssD2aRrNPYQQVHhBHgnePylgHZTH0uGVXp/10loa1bueBxwfxnf90nIK6WH2jK+uUD1hTm6d54cWfrvbWH7Xfz7uK9D2FhTVXft5lo7LnsKscPq1TDq34H6/I2500WEOvnYUQLVk7JeE92lLo3iFcldW8LYNmW7GiwghJCFbn+0yyt9Tyh5Ib+66Z+Nb9m3gYEI5j4fp5qWwLFjyAgAn+HuZ3os88ihvjejl1V4cprVLnEeey5U+zKedzqRdwO9O9FaK67ljdUxfmuMU/zKstNvS0dnWdbcNoy3qImg8d6myJJq/30+h8IDctj2eQxLKOmQ5cFuxWLb6Io61E0O8+s5aeRJmO7t9DSD3k1QKRjinoyxDOBHO+lyWHrSFfJ/utifaLsPCygB/LgTnWwS5Ciz3A5Ct7JEy5c9ZfpuzMP303rtWf3rzZh6fxGPQS/jIszLkLJM99sKjtVuvFE4ZhaB7uK3M8trfOxqGiJr0T9EuQPOGNyEfx3L2ZlGMW4ljBp40p1ADiZhETwE8AyI6J8yUZJ20SbyO4zPNcxbz/n6/4/Pnz3h9fVWbcs7zxP1+d8MA1+oxtoaeET6STE448/LWjDe3Z/qR3eD4Wx6VUMfAJ+LeVKsEj3mfxSuPCP1t2+Sc5zRYujeKoUqvNjG80q5nqx1mwm8STrNaTuL1lvSOFITFNQqjkvjUajNg227lZjLjQzwvFK3pr+RAIxTaa2f7OVNuC1r1rJ97/ExK5tq8K/AkpeBpQv18hsFm0ubyKBdiKIhMVvyMUL1T30mhyeVnG1rECD365GBaGUStuOyqZTeCnpWVwzgp3KHLY2bPxFT5rwjtnJ7G3kZrcMh32lJSqSta2UCQdUmPc1/7bR5TsLAq6Vu1jOXX9SqWHJsgZAbzjFEg6+W9t4LKeqKe5et9euV43pviaaLcvtIPlb2k6IJ0Gnr8FM/LivUoz1RBsm2g+3RktPTGp9cOuq14jrKQ4FVjhLNFX93m+Vv1XPMXUCwwci+q8uDSfQoSSiPY92MGKziuWISnGPchtQj/SgdKAZpvUgcS8SYc0XihKIP4oiiGl5cXvLy8KPoftVpa7TCjCFqMc4UmecNTvlwctWlMaVBKYe6GQoIOg7Tay7ME7XcLLUVEZMuJVnklQBNThJsMNPNEu6IIzBnFuhaFsWJZaO6Tr4sUR2tI/uyFY+zvGaUhPS9psMhPaR2P+kvicukIIR0/bpQaDQ9crw2qII2UcnQGh5WKABbhN49W/gvlWIy2HGsrZU+Gad46M00t3L029vraKvEViGc/URnFAdkomoF3Cx8xvEe46PFyinugInKTOEIIOXR0u93yUbePupAja+Y9gGkf01ILC8vsMm/L4o3PSJ30OmMt2fda+VTBKK6dzZjv6olGgpMVKIOnQUYWYkmqz/TXtpVLgkZCZg584mWIaMaAeWRs5j6IJQ7TSwPiPO9JMepL7SOmQRjqHcaH9apGZRTa4qe8j/0ZMJqzGcEjVDxdKayGgq40YsgmVgkOaTzMfEIrp4xk0zoCqeXmWYF4u91cy6xPe804PStF5nsEWp7JfLlUjXsv38j9ZXcbeOkK3RGeQvuZutC69v5prEreU3wSgqXb6//CcTpZfMLHmpfya7qD+P24YGvzaZXSWJ4tuGqsxNYWmwNN2mxWCCX19nYAFLDftpqHgBgIcIzb5fkFMf57xkcZ9+1DPX3vitKS9nrORuP1y+/VY8YjlNnZs4pey3XRvrj6iAWfHkAjZpqJ13VKhmelhmzqZYNNcFC509Q2/Iw292KHLmVOmGRYm2kLxH++EjpYETzLLmoDt2wPz2WWApJMnhka7SAr+AL0+ZXpeAqU8iollKROVTxxDqZSqAOpQATP5fazyKxOHSi7VZg1wnpeQ0tZeHl6isF7H6LGVc95UUatHI1X2sBJRMqzuAIenb02aD3zPOdWeasGc4s+qcB8fGsLqC3Mzyk0HkYN3Ml3wcLVDegphFAKByq33GXcB91kj8ZWup6iaMUJH2EYj7ZVq2Sq7KAlaEvoe3VRg45yAKdJ/4g2qdw5XhogyZP80yhnsswWDYLxcsEKy2POXQVWIXpCWwmGTpU8Xp0VcBbPjLdo32/7Vk86S34ind7SdiUsvRqO6o2hkVHUend1XHv9FIJeRjMqfxbmfQx1bLZ0yeqkM9bukpZUq4bsO+oK/Fa4xhtIFX0LQrQl1KUS6Ln2M+Apm1YM9CoD9kIN0VJuC6IYK5ZLS/k9Hwdh9UG9EJMvH5f0KBoaijZkV0B4CtCHINYZa7y+QdHBkZNw+EQoIbfs+N5TqADU3phW3Ueerx2nHo5e/lF6hmkPz/wKAPbbjuOIc3MyHh8XM8QxzS2Zu5a1flUsJcbyQ7gj76iWS34de0ZfzxOzuGbau6eo+uM68Zdaf7SmKBYCT6GEa1hDGd5ngluumIS1iZMTTRMstDZltWHkEspSCLWF5qWfcb+9Os8wk0ejHExefu+5nUPoCQi//zzlzOnszXxcZjkeAhxqJAJwR1qQaXJsaEhTBzcrAW0VUxIcTG1+12hiv65SwQAeTXwfBYFj6aVGdaSKB2ppQ9lcvLu7FfrzPGXpTSuhinKuV6+OI+HU41t+rkKoJk31PP2dFOt7uzE/loMp09bR7CkElH5moyMAoNsOBLkyCfAv0TlcmmR97Ljopffaoem9inbiT3vdaqttZ2SU/EWKyU+UUOou0tQnCHjwLquPnuHCPAMqF9tY/7KDWvmulDmK6fesr9kyuJw6LtvPc21ex4dxuSLo/gWgFTZ7t/JQaufdEvbUslI9egsaPEEE6L5/hrX6CBDihU3lFGBJxwlQexMo07WJo6qfAT0jtmVUee85zShScoWeGQ8k/Ur9DARe2uuaKW1YVgqPVvgKeJa6V3ZL8JVPqNVHIyu7VY59ZgfRKCbeo1HCaOJK4mylleGlWS/OByqu0yilwO8qLu4IeANA3Z+FYlXXA7EXXiHos/QzugGstM+ZcKrb2gSv5WJlWKJyIfq0qKRUrGV+3/NGbT4P5yr05sMC6VBuFdLkf4l/mY2hVDxH8agqX5bZCs225jlmxlPrt6cg4vM+rlkYybkqfczkvqlpmqdjbfNag06vsexz+a6lXVvMJqIPYNe4ogFwG1TjLGW0vIQK70InMawOwGenk3RYhWEHk03fLhxRL7ju9oVB0BBeksfIuRtzxor9Up4qVV8iCJ2XfoecjmSarPP4gMB67HgWv/xuWSLjlXReDKu2BPD0XEIjbTHMTHmmITlrLyRjxzdj6gn/lrySdPfyeNAKHbXSjHBdgdLepR2UDzHZb08NH8009ogwP5QjLt6W1iB3VmoH23mVIFQ42y5gxt+ldA1GbSOfXxH+ozLt72VFRCfM8p5xHpc2QmtCML5un0hq+UfOKdR43ksxiLp1OMSNJmUhns5BygoBQKjPk9JZa++2tPMGe8xC/N420HrQE5wtTyTWxC/XtbpdHih9uW1ztNdGXxQGvTHW8nZahtKqMr2a5rlQDLbVkbDgKSxibuJpW97Weog/rSCrraXagwk5b/yIO2Hipe19t1Nj0eEmWweGPi7LtJxH55+BqxbfTB6ZpimUSB+cJweMP0HnicayaICk6Qxp5db5avrHnoLN0bM4ZZF+U/nt51nmOb3AnVeDhACe/OQ2imGA/llQrWfx8SlokG1n3QjxyoGR8F8FqxC4rYL4rQlqW/dzsFU4ZLN5oR4PIt2Rrl4UpDfuV8egbKsZReTBtm0oJ8wyr7OLP4/nwnWcXGgpfNaVb1WULaaNzqzpuQS9FLa/a5jxp0V98T8eOIGv6/NjhW3aVqyAXlqb5vqg+1LhkaruIZ6Fb48Ub5PDTG52rRKAsJVPUPREItYqf8Qxt3Ii0zXp0fBgzPaU14WbUH7in/jI8YSIB2UQ/476Ldb/PCPns6Wsu6AIeiLm3RNlPLYqIPM7yuJJIKnIJVI6M8uUS7RDr5AK4JVndu7E4gOiAJzbwKaVksWj6FdGaaE3PqcGDz5HecrPeTBecmAjawNwQ9nssUbjglIg8PLPEljRArzndtrndSywCM22VTTXaNF7sPjnNbBaa2/xOt+vgM5PWhQ+2WJr4RrhtnMRxcKbiys3J/vKk/xreGxakcZNmJlvUHS4fejkzd6dZ1BwgnrVjOdJybK9diyHDO4VDimkQmhPfHohEopaJNdxhn8tba08mWZCXusSBO1R0XEjlis3Ne4pPV5BcIwUpyat3IN8dVkZY27ftkxYlReXZErFm/qT23VFjiwec0EP2xgtRoty3O+klXCJnAto4ZntoCiH9CBu0VQGeb8DtCARzyV9eH9v4Ap+2R4aR7RYiTbzvGEYVMJV/AjCVlsg0fNqZN9ZWqr8CMmyqtPaSeBMN4s/tf22pssqhB6MLnbiz1AJgxr0O2NVNsrw8s/E9CnFhWIT6rYvXo011ko5sp14LHn95oVuPVwufZryYd00To1rJAt+CXh0gpthLXxE5HaqR5gngPsTwT7eS/E6pxF64aHmu4RrlF9+n7OgAanJ1YsLDDVrIc+mkThtXjKXCekBowVgc7IPUvB3BPVke65Cjzdcj4VdYQdYGNrkw3IaCqtnnVvv2lO+Eq+ds2nR4OOfF268kTLnIbvqxS8PKk2hf0aIeQLaKheLWyseoCVz/HbRimnk8c3CeykQq0jfRSk8k3RJpPQUWqGaFrQYSF33Z3DOCk5PqV3zPPSgt8zICkIqII+OXxq8m+Vk38nf3iCUzzVkv67C+yyFsIqnZaFWoR4Wdq1yEZVMyMzdV4A9Wnt8wHyyibsaUi52O5t5ZZkjfrOCsKI9JlJ1iHzT9zjkOCrGxNz4t3htHdqe19j70WUBVjHYPFsVHq1pHZX1XuP93ZSCMmoXCFJ4mlb+9cboMfNKyMjDOXLjJWzO5espB2NdouHXohBWoHUtqbKonujRvBdMGRAhFLkLqSFMvz2xKoXXxyGpHte1xO6qIUJEeH19LWXKMRC438+KThsiYpAXN3VdtAvwCE9xGKx6jmLNPjpaZxXye8O0UtgCEMKZB0K1IgNjgu2GsTp81Nb4PahCOJ18MzgVw6aQTigvm1Z9jQeQsdxiDVYp4yCdM5Aq8Cy4WcvEc789/GyJysPLlMeX0h3ngW3bUbbW84oNuwIp9ne1Xj3oS3+KkLBhjw3ACXYKK9pFKK4XJmmGuKSH01D2hSrfqGkEJxIN+nehLT4rxdeeFCD3M7ByYLq3/L3U8yy5idLYNRa+xG4MolZM3/Ldtm1w9humVYDm2YR3rX+PBHriJ+OJF/o8vG3w+aJx4F7+NHtsLhqilobWmOxBL8IxgvmJZvDKo1yS202zFntV+cVOYxxe5SULeZNYLTqa9RACJltfXc1NWU6c4WhYz/VgJ2F1uHSYsmdghSFGwtKz7qrYqlj9QOocm6IQg3wSvLK0EvBcbEoWeQjPsaDk+TDz7etbjzqF3Yw3i9uPi8fvEMqwHeYqfRPrFli5yrHLSBahGXLyPGsnfy/OHUlSXMKlVuUDfOvZ4aSvqZgNTY74qWl0OQtIHoVeCLZtjOrx8z7hIyUk9bPRbHzrmQLKQ7K2/J2GWK3oEi0X83kdVE8oMjL+SF9U2EEzwWx7tiziGcu4hd8qNIWrMUhZwLJSOI4jW7XUOfAslaDKainfoE7H9U9onYGcj4DmstgFwdkLO8nB+nh4bKiNdFrP4QCSonCwm3k1V/jEl+X3BJ/NhXP1CbC+5+TT3MItjcNHZAfAOARutackD+w6p1FItr1GBupoUYb+rd+9i1KwBbsWulO4jH+2QbrA7QabCSkFx4OZYRb7rFJ0Ir+0Y2VZpew4CIkAgp3oIpWLGUms7hYljkNALYbx+sRbndEayC2FoiaRE/2h2b0B27bj88+fse0l9ASeV3B5JagBNeNO1wKE8q/yvn/pTK6TsbIznkWPy29j36K30PLSrLdg8VV502amyFmBa5L7IMf/z3HdWuMuHnQ9B7MKQafnpc6pFgHqyHgPnxeG6f2eNZpiH6RrA7AhT+LnejGSvsRryc5euj5N9biIX7XHPQvvcnT2DOjGZ8LLOveWsPNi4M+ehPGU2wne+QqjhlPThwBs1OwGJUyFXiDxrxxe1gXkvBKX/d4SljNWaSsE0bNugqiDrXMIJ477ibdwx3G/g7aXUhZ4PHn9xmLGF4z1MxaQLPSSFWfZS/z226NuU2sU9KA3b9FTAH2aNIQQhOdWrFW3XRCgAvxOBTZ2kkwIsFW2pVObN376TOv0fGEpJ6aTJYy8xr6B4+Xtga9siK0ERzalV2ZAPEMujZSVR2v6Nsxv4QsohRliihVzBapGX3D3Z2FrWZoEgJI/QITQsLp63tSTSRV4xydCMuhVHz6OM31uA4KPpPgojZBPnz7F/Q0pm22hyrotb5zUImllgY+9rBF4lpsSb4ud9SxDhYH3BJxnSwg8Dzzh3Q+PtbyJcnf2mM62EdiicdYiznw8cQ+J5QPPy25nHieRuH9t8NB9Cm03vpc3aKsBiNIjtPOPmUI+AOJ5OlVK8EFkffoKXvVbF6rzQYQYckylW1Quj73PmdCYU3QTL/95FlPPqvVpNDdEDcpPJ9hED3vb4toqSnVkcyp07oDIpcjBLge/Fvq630q76rmGsgLGholiW50g2HX+pcI5WiP7NhkErRDkCt+2Lb0avHCUfLcUmgrxPKtWSGU1rOEaFtLoY+8EohlzjL7US5Yv5wEifl3/bYtnRvE4sjRKvu+dp2SfeeOl8qK5HKIULk70lcpVuFv0tWhpQXM8IwDhjjJmIo+2lotbuOwprCoEkbLm5QWFOSqnf8vQWoytFdu1dFyx0qTgZhwja0QZ1O9oZTQHVqeeLs3JitOBBOQVOX4dpMkgffDSd1PNbQuFH9KZakeue5XUb6dpvBegFRbo8WPPY8zGDPwxfTUEOaIpCGEqKMmPJCk1XajytGAUEvPayqNzGP5L5FjaezhnYVS2H0LXYdiVMpeVQsul9AhNORwsxdKTllwPn3xuO1o+58Nz/c6ca5iH5ig6A8nSnz2n9Fxq8rZCopznPeZSenRb6240oFLmGFYzgsd6IOO4dgCCvGZwUBcgHpXeSyPquw1WRc2GTYZGy6QBYQWqF79eCpGRXlsV2Kt1ynNDaAuejJd+Je1sXhkOGqWZNeJsP18NF67kWxH6JifgzG2kXE3aRnDZU7AuVa8xlNZHUA+kpdJqGsucLSUUEHA08KwwaW/ylt+3BHJrIFm69UCP9y3LWGdbMZb47Eh5zsBseIBiPKZE7034hfNZATY7QdZOF/THQDh5A8hali6PMr4mtQ5ljsDhPvRd9ffz7hi63m2LmkkeGMHqGOulnhlfo99rxmsps6dkerT24PmeYwpXee0UALsm7ItPNPcY0fUA+OIHleEJhAgcI8Heg9FVnfw+Gms+8+Y0g1CCXm9fmNKzDlfr0bIwHg1xXIl7Xsmr8zG+fjll4lG+TP+Yx7UXeY02CbNx22fBI8ImhGigVdHcZ3meeEaLJlyLFvh7hldX4X1oGZkx11v+3VYftYWOHrRrUf4CnpXGaM/74RwONoevBXbiSdKtLGWDa7Z8b2KLLWlPQczguiKApZW7SjvTyW0TzhO4RRajcFUhJEUZiodpQ04SokINoE0cq9Eodhgum/BCWnQ8E+Y8qpLWoyt60k66hjEzU5ZPAGcW/dSgLxXSRHXFa+s9u2oIXZ0zfG/woiYckvZU8ixJl3Y0t2bxZdpWCCI07Qe9OsQr1w6OqgyjPGeEs8TZbuSI8wwnwhm0QigJATFJytv0Y/Y61FKgzBG0aK3f+XUZ7xb2wYZ7VhRkM036R51DlTsY+gqCZrt4dFqFoNuDeMYvnAjOKrRHvJzqGZHfFaZu+ns5LkYvilixgAPiWVKtPtCH5qWMFlHzVbf8ipYCG5Guu80r+p8TNI0XNohM/ipcwoYYDpjU/DpTYg3Jq5PKFlqGraR/pombvTlBju4LEn9+1KYHyzuaWw3GA9ue/VGlmyCtpxS8Mu3v0aShxGUVgmetA2z56kPyarrUkFF01cKspHvUqCg0l2fLk1fORKR6n0Iw0gJvKX8WRwRyJnvj26I8vQ2I5a7d4hVIOuD9EFXRXNbztvKzLK+C/BnTuKVAeYWVgPHK0AWV2xO7pVioLcHaOwjV87oE0T6SiuH49jAU5EOBmoV0LSlyWzZpRh533Pb8GcBX+YpQY06uPSYLXlz+qoLwypkf3slkrsr0lZf9rkHfcCcvwRrB5X0KldCc0EbWeGHgSacgJuk8geNZlNZFpmStkHimhWZ99olUCE2BdxbB4noUsQTxjUy5jco7IAypKchx7BlJxq9tuIqVHRoDh2kbhDKkEm1DEQiyzWP7bgjB4zNxj3LON1fhnkXI5UedJ72ATCoj6dbIKdTQ6ngE8ywh+kt6F/PgWtmY9xI4f1HXirh5kvJY6JSFGl3LACnvC2V1stpwdEnrKERLi4/doWvqXeD/u96TF0FoG+psOKTuofExLwxPn1OgbAWOmoPqR+h7I9M0NNyRkKzdlkIYM14m0ikUKSSSWiBgymOZhXbYzSHEqbwVCssuciNScgW8o5RjGdpiVb99qro4hnT0rMHQK3cSP9M0TPkYv8/CKOT3xaFRbULD2OvAjrg1tdmnQsnP8Ehv3uqXBK9+z5CZEp62eS09BcAEehpZaERHxEhLXD6TZbZCRgpPchWsRRj/ToXvWj2d0BVIxM89LQ+UttF4bHlu94b8T5tW4a949M4yjkujmTS8MmlXpSetlF9eXgC06OzTX3vcY0vLf94IspiB1xMawfaVCZHVZQfMHytX0/1swbWMN5Qxb3H08/GH8dJFfhvebaIiNI6YsR6aL1tWwMqkx8BfADD0TioZycZgAIhPShA4vBWfDZhWCq2zcWzn1ZWpcrj45f6F5YZOroEM2YQQuH2EPK1pPc9zujwZV81X7zlx0BXwQlePQQkDjdzhGWto1o0dUmXSnMU6ABFh3/fUBuPyR5DDQQ0a3GWj72BEy5CbNEw85fJrBC/cZN/n8XYGNvGrdC0jD6EhEAH3eZMW0opElsMhY/HCrYtCt9Anj/QfwQ86ALYtkjGtjM6e4uZ3xthpLkzQ8JTwkR+jZK2VadQ60VpTInzUxt14l9slDjp9HRAfGlznHVm7K7SMgMP2vXKj0OCOnscfQokblvKueQUQJZN5Jqm6YiF5ngLDzPr+lh+mWD8rhHH9lSHTaXJbd/10HR6x8Fvhg9m8db5WCK6MHxLjy6bn+aiQmNDla00EZ2wR6QU/89jg75KOeq7Jt7LfWwH7dReKSqV1flDMUR4Jjg8cQKZiQFfViZIup3HKnYH5m9cmJmHiQpMUniE20wNA6RyOkH4HtjIEoo6XIF3Hmqm1h8GWfBQOIbumUlFKb6I5cdwp06Z/jNl6Ik7TU8ryQxYjMpbpFGEjiWNFCLnPHbpaYTXX6ldpyWoFp8TkSXbr32+bYJoitIpq5e8IJikA3ktwtfssoF6VwmkPQdeGONkv7gxhSHzSjBY43ymls1fnssUfn5YNoFEZnO644wMXx3VdB8/Qasko9VsZpYn3tsSrp85X8loFXP6Vq+KyEYO4TF7SR0Tg070JZXEGEWF/dvhoBCyU/P6Q9ySYwTXjCaDukPip5wceYYaesLPWPdH6Bi9Zzqh8L4yyCpYuxv+Q0JGCWuC6Ek6y6aVrXIWQ0PebhnVruRj/BuHKXM4A48SzHAjr5HkcCh/wn0NZp69b/f8lPAV/LITMvAFyrvBiSHR6/JL5XIMlpdCyqjOI+3J92s9I5omoNWVWx1PoCene+2aeaIZ0cfJ3yUjyd/6cLplxLmYAiju5mHc0STVTrJdj1psalUmA6v/Hdp+TWq3iKUNbG7+cIvBCiAN4S4Pq3IAzWV/q1unJQdr3EkQopMOfEqLx1WnfBYFZwhXWAON243Zt0yPnG2f7UcXMB+nlRlnfUxBWssVF80sxK9qeqEQEpVNl1wja+2yYD42vDaBcpLSiH5Y3r10RyCW/DuFYDCOcXuimZb1YRuKBbsuydVpRTiswo+CssJN1K/zQPhNpZEFdmUAbCb6HJuUSo7eE5bZtY30Y2Abre3mtdzqN2cBHELfLPUdA+GFHIXyfUspc+UUh+afu6mZj692/s1uFYvk3JxrwiCfMSyRgfP+21/uZ50FRoV8YwzNe/QhOFIXJkZ4SfjM4Qlg27u34YayBoqw9OfwXgGPyoL9Lx1w0yFOE+uxdJkDct43Js7ZlJyZUJHOm18GxglbAy6cZxdaz/B7nrcEV6PHFMN9w4CwI7wAo05BFxwwto7LzHAGV3635g5ley9y0aLX7iOKglBYoy81HVILnxdS0skBYU7KXeDugc6+2SGSfBNmPTo5WH4SwxDchyLZiQeYbNplnmgY2G1Q2BNYHa0hZo6081zh1n4hjLgK/L+p1FXwv2KSR7226yT540pwCFzoR6rCtJKDv1nsbnnR5vLz0RpuZfdez8Yqcyjpq3LjEGldNs5V6j8Zmq1+qCXcA8kIZT0h4zOkp1JaS7U2YVQSjWB2cpyd8fcbVypMAkOkj8abkC0DAhrhQAf0YhlP+ihK2bZbDjfHhsNyVspvxZ3+/cBOHZzhNh28g2ngipFr6pmX0JCNNhIXk8wYFGZdti1KfVv4+ZHyR2QrlYUYka77oh/0I/t6nxMdphYIyXtlojp0AVV+vLpluTU9PSVCSIURbUYyTmugJSuFMbRMbm840AYt67qEM9D512iVNZTDWEFzGr8rKZh4PNbb+6nw1U7pUQXWZoqvQBtQuXRerU2xZDCIVRnDTX4l/tuqqFCKMFb+ROql0BEUZZHul4EsKQYbEioBAagCRd+ZSnYYl59PVx7Ntc9eP9uZURmVXQh0BwB3sRpW0sg112S2ahhOuKGNRW9E90Ctj/DETUMaEDDO1RN2BEFDum860pDoEvj2s5vPRGON2OEO6gjevhBzUVfBaS9boOpR38rj8fNhho+pxHDAPAQfJe9LadQKn6fI3YQvxsyj+eRnx3GMulIX7IKqBJ9HrLE/ptCibtaY32hWuZ9VzFewgfsZ8xwxI5TmvgDpWYvacTDhAWI/zAkvkN57TlcnCtTo+E75cmZP7mEr66faYTScPbAv5m+UG4DqPf+k+tKGjFdhQDggaQc93KnM51+u+oBT4KsSWVZ3ELtPyoKzKk1ahfjbO128SuVLBCoC5idWgJh5b1uJMDLAFNlb5DPDo8Wi3cVTv3Ry0rbkaJ1uLbC95g4sFyKYfoa0EZgX8KPw2m3e23KovspbslcT1972HEbDVyMW0AxZOydOC2WkL9Sgk4bdVoSte7SWfjMZACRPVmx+LZc3t5UcX6n7yja5yqi05KWFwjdtLGaHD1GNDR4bMvBRf3lMIoZqgLK9WQg4lj6cEVibXqkYwOEcTgC1vpUxe+Yx1xbJxJx79lIN88zCezHdKXojTe7/HeLIL0bCIqPvTg2shNqBYsG0PeFbw/xKeRzNMiGTWqBDVOt9Oj0VjpXG/Fv8ghl7krvbc/ibs4Y0zSQEbrsAj+3KKMZplRCEHILmYpSEnIDM470SIfIqiTsj32bCgFLTVXgaaTvMMmJoIfQfwJp0lrNDzOO1aEOnBMC67pVBXaZthukc8IpEr5U04O2mqsgKJwfmE0A9LAGX1/RLhJAvXPASGYkk+a4HtimJQucBHNVAoZ5bl85OqDL4nxuVHkDt7LZEJ3xSZIXswfIS/VxcPVTX/Z8avHn/XNyH2lN3MAocRXLpPQU+QQY8Znlfw2jLHu5rYU7pVqsYQOpqZY9fMEDKWrdzbrSGUBvhlOo+mGbr9d718J1ixCFnA1HRpK95Q+8Raj85mHcXjLI7UpF/Ib0Ja6lT5CWkgVQzEz4PAmT5bfTMcHAsSs6d4HwlJmUG1ROQsD7Jw0vjlGBwr+3nBFho/Y99tRNgoHdGgeKMkVZRKC15hrxVnqKtnWEv0VTD8wo6r6YvcPiTfpfHGhZiylnWnABk6GobQhZck6zbbV5fCR3plxhkttSBj+W13ewwBuqvXrNo8Qel4Nd1GYXmTZErQO01qKieUQF+gB0TrpmX9hSr9fIiJabCDm5lDWlXPufPBFRgIOHGARKjiDCdum8d2J+IVLoeolQzctFyIAOQyZIKAeMr++8FIYT4ePmqKiAu4DGbl6bt270P4ZWydeyGEoPr2DOkSzTi9kM7xkQORf7LlLccK8xSl8frm0hHPa0r4KmNIj2MiXjoaCg2ZWuTyfPlEKEunOVeaH2PZKGf3paGUZUVvDqXstyh0C4NVDg8nfLYSdl/evFZpnSCoEQ7CNQ/+OiMqrehYOVVJOR4pD92qNapbj0kyx4JgpZEKbb25gNakuc0n3VleSrfvfSFaGK7g6As+f+7lDCeI7PFcJIeXeTO2tOXjAKT14d3qNOGRCWZgxXqeAeMxOeWM6G15cV9ynqPIiyKEextZ1VPVudb7qnMr777JLyEpE7uQAgPhFXGz+A6CPsq7ry1N1lXx+6J4bi1w8gm8FEipLKCMezneR3D5Os6arMb+gdUClss3lPScAdeNql38CSoUTiukW6t6Ss4i/hQThQ16rSBfOcnXkxoqgl4v7gnpUfiJqC8ctFco8hqZ25pQnmtRyjg7hAwSWGyatlHfcjvmODKHQcn4K6aeV1Y2cTn828czFkzvBdPjIISmztI4nONjuN4bt613Gi4UoxXPtx7DlPaWsIEzrENgnL6HN1S0XLIxJmOxkebzKN6BmtQ31vs4zGM9fSlvTkDI4J4R8XSlMIpL2Yq9N+OuQHeVUQCCw7Sz7pZnta9ainGuJZvUkF975cwMgIoR0hi0ruUMRO+1DN7iUnfymBi7Z7Fk+kmv1TbDXsz1tL2j8rZOM9ufyt6KbgfkgJxZafYlvIhneTSzeCraHSPFw+eNC20UMx+W9K4F3wUpaDUub35sBC1ZoYvsyESXV0m86nvZdQSgSy1CVp5BlFRwr3iFS0phiaGJJw6vdYT3fGjtAVER93m3lbMbllmFlU7wVlAUOoSYE56BR58clJ4wDsmyWxESLU9hpk6sNHqWl6rHGSZG//V+mVVgTwjZD6HyqCeNkdKvQPQktfEg01yhZSlvI+l4Li3lpXHaYgiQ2/WR3mghR6ebef1gLD6hHfnU6wNr8roKDwCO6AXVAR1L+1XQ3oOkYaRgRvC8m+UvwHNjr4Oy8GV8l2fHab3wTmueoKUs1sq7FqJpgRUC7w1P7eMvRPP1SejHubrPM14D0OD9HJxoUz7DwwRzLEQ4I1bikCtDQ8R1DKuuokJNd9tY69XyEeiddvq4h/rcYy4qIuptP2zhnITaKjTxwiteRpzAqt5W9oIt49ETVSU8qhi47eR8g2Y4//hi+3smzGGdW91XYr2HCdG0ym/XvV4b323rkCbzcqaz0EbRaoz01rFoSjHdy73ALmc1QcgeurDSJsNEMzzRXBfv4ufQocX/mJ1nY/XVe/E4h+kEDdL6Zos7izDP2A9SsHM+Ti4Kkm2eEoWUJ77ZBHHRQj/PA/JAPaYn/p1V9fpxfVRTWh7fR2885AzeWWv7y62rfKpwVzpXLpy1ktGtYr3I9txmDx5WCm1XyxdU9o2deHoEFB0kn+v3ozDVCkhGk79X8hcarRDyLJn4bnZyuDsxWhmBDQHnJJ0BKVY5v55z6mPttmIv6wViVbvYcMw6uqlyPGU+DJE2rNvVeQFvgURNa/4mMdSzPjam4uHkMBcJ8cW0mOzSfFDHyaBuPyGWTbneNaMCSHJnybc6z4aWTMnjWSskQN/10ipL92lZlGsK8PMbebcKDyuFyuKuGMFqtloJBMMcTXzOe4Wz8X7m+VV4Hr6QBf4sePF+Ms+/5LJDl7nhKYQ25MHQTWpVzXtAqx/6lvQ0dsP/1rjoQb8dIx/ZzVa98u2z8cqbhjCfYF1lXQe/Ba3iUj6qP7VgaO97rjnNYLJX4Y+FTD/3wM7ztcqsjYWS/xF5M5t3+TpOr4CRAO4qjpK4rUAaUEI/jfdMt3JLn33H7Vxb9PKIp9082qsAx3XSVw6R+Yzt9l1AWhLYp3N6ghYOkyuPrcZ1xb2d1Qk997wLQ1KC+Fyz0Fu/V+rfyxsCR9dCn50mimvyMoczgkCU5GxeR8e/Q4iRHc+QNmTY0E1RliWXusAenqBs76xvK4iJOiev5KpgVuVfxlV7N4yb31pvfxQS82DZU/Aq8qgGS0hyfc9FXC2bSDUPj5EJ3Ffc8UdhhKcVHyzWGZWrI2luCVo+f4ba12LOgpuXqIpwxzqs35srYXPmEWZgpV9TDvGdxCeZZ+vw6AqRNq7kKXS8rRj3HoQWGxAQ4oXVTsiCV0VKH74ql8vCQutxxIHE4Sen8CYy7XHNfsvQeMZQrcNE2tDtehvCiCXy+NG7i0LCNd5dNbwe2rz2DIFYXOaghtpiJKVfRkK66t7OwFMU4nJ55Xua2VPvZ4GvMLE5Ziaor0DBFQDs04rB2uPSQLUwDH0sK4b3h5bl/4g38bcIpT34Nr6uGfjF+rrpkaITxXBpG9G6MhbnvVgL88dcoBgHQZY3oLNusGAyic4lgTtZHgHA5pQRLQ1eBcxxVJaP8tJwGW4JjlstDrCCLxCrZwEI5zlUCNatLfX0Osy2i7Wl/HNMomIQQoRDZCjZK+ZM6TfEQ8hsrNOLszJu90jDplHaD2HMKBypRrgc1aqGVv3bX7rnT6r24smdwWVCHZlaa0hnFp+wxheVQd1fkZf0wWxztrnmebnCSdAkx5TMW16L323hZDle4rc4QbLzT7XapvR7kgoE8E7fgCN6wSAEnKIffGjN7VwKGWU+sOMg0hnLkU5Xs0XE+8FbqThTUcwN20T/AyueAgmSs/BucEcX5LV+JntiaKkYJlFmhaCUgUQrygo27igtb9QMYLX63PJVTxmm3FaQccuaLDqeCvvSeaaVtyy5kXwtls2ZXHqm0cC6+N2VVLLsmKFB2NgyXDcaqfHdFO8qhipVhWd2kvMaSHU6r1T6uOaGpOD0osi9Mppk+S+UQiWRzm1HUspM/psSNulfBT90yl8GWkgJuoHQF8pqPC/mCNnJKl9afbSiNVvW9CyOVshnzOqcbnRcdyNfp/Fb+ioYnouHbtk9BRFDjT/AMnKrpKal3Jk0tj5IM51VgJMu+CidOx/SSN9re1tO7xLDGaH7iDDuD1DNoSTmzJ5bTp1WGxNjhWDxe3MNKmxsypql/xqUsRAoGHmgL8PRtBBCiJ5BpHOeRs9TeCbkaIZnvXXG+5cKUy8pBdlYdtKoSjvAM3rXEnxTBXTw9hg+L4FzQigqjSBA45WMBbBQL4xr6hiCOL+IceqQkQfjFDWolVzZcCiba2YEeidOlHmjt9SOgZKV53lm60LmmmKZLStmMO03ArroRHNxnfCRbLOWUJ4VHi2PuJU/hyeFUzurGGxYpjdvZSfOXeNI0DBlHC7Q6dE0A+2wpKWUDcAAohLS2kKMGJzK6HkMrswBv9uO5itmkd3U0TLJVztsNJHnxRF7zCHj+C38nvJMb9Pf2ShjrW46rNUBV6/GkfXM0MXVyb3rk4J9n/EZk43XZPt8mVfb65eAEDA8rPa5tMkwyLxQXy7FKN7nLiBpqy/Jn3yTSMvo+1KLWp6iFKwAzIQ/rOYeT8R6ZdU6tBav6oz8tWj5ZlpHs3lWpBZerXVBIf1tKp9C3KpP43mczA+gUx+c17JAw9nwXoySZBx2crxMCGqrcds2nOdZzTVoXnJq8eQx4g3fkSdzdaCOcHle7HxZrSDnBB1dE9y5v3jV88KKsp7jaTfMm8No/YPp1mlqg+RloBi6kZ+5IDSqNabxS6ymWrhkR4dECvDqoehaFp6NzzQPl98Vg7NnmmUAn3rYaKSUWK4d6lvoUM9bYaTZ+Y+YfYM8fCsEFtq2rkBRIG0PJDPQxvHnxrK1Fb7wmoF4kBScKrTF/UiSf0sobHXwxyK1/cMD1lposl2050jw26P2+GbmIviZVTo8B1UOM7cNKGepYutwOKygWQlszMFIGeh25nLnymeulTkBeezatXDU7Ls5nGkFkVlRJlo9pufeIQAUjRgC8h6KUXhoJD96YA2ZONxrLoqPgiA7iOfPFfozMtHC4pxCLgq5miwIKRgLowhHgUH9rgRGKOMp6AIVEJvaBGO5zltHloald0K4b5tVJtwB8Ts/Ps842WU7fm2+hIcAlePhpgW0jFNKl7xGcQZALZuVMnC2tIblpunp8EIFkR6/T2phb39rheMpjVgGGxkkB2zus+CwWPF8nmHFecbKKG3tmT5Oh2Bx7Q1bnljB2RvPI1pYAWe+Z1zxDrSyopD7SBg6SVHYs5CsMcEHElZh7AWwxocb8rF2nZR57+8IDGFBKQQo24FDBOyYKQ/ByzsA4n6WQrVBSXppbzQNONWEoNDX1QCyHW8ZxMvjdXBfqRC4zTa1MsjiYGZqohI5Q7XjexxrpFxkr4xiNRv7ixWHUN4SdQ+XN6EY6dW7TxW1nqUfEbhlyTugW+DN2/QUV3kn3d8ocJVXZcrIlvpEGz0K82Gbdc+F4JwsQP1Dm6tSB2G3FVriF0FPZcwUt9bYZy493nMZ6nkkdt+fOAdihEPQT0BcpViX+YyQ1iosnbNrVz6EEFQ9VhtSLSMLRe3EgNQcrt4qBiRc79mo7ZAT1ySCqqsD9tUo/dNBDeBx8hnKnjopNkA1E155/iTdnCL/5WFcb+XD0RwPfEkgstv+rEdkvcX4bGUMPbLyaB2C+APe7+6FdViYU2jc+EVBW+fGIqu0ZpVmvvzqe6e/2ZWkZEHIeLPVvnV4YWSFcWe2FBIlV3XOq7ATzzw3YZVwhs0OgLn2zGcjxUwl3jlprStcE+W1FDZPNkuLZPL6ZU1D8lRLmGNsOc96ZBJa+Dgcod/znbm9MBg67+ehZ4lHjzItV+gdIR0EJeLL0hLcBk0Wrhg5/Ty63TnAFPOlEfoLazfJDaq/YPckvT/MtsWSUmDEevAF9X6MCMkrsOn7rp3/blQYYXPwegphCYjMXIbU+N7vPtiJIL7U3Sl4QhF6BUDly2161TVdyOIJ6qLsHNQX6JkJUxS+fa4Z7C4EEB/Vqy8lA8JSN5VsQRh5DoKrLecZYsB1oe2tduM5gRICXFdSXupHjKZx7fopfgmldmFJqlx7UQu/XjzO8xo4CMhx9V76uoxhTGGKjlYZA+SC5pB+F2ZslekpIevFFBz1xjfgilwxcwTisQ19t5h5NIhHA8fNLwdt8HmHbMUFkTPnCFlcqadc+cyG22MDka500BB6c17yvWygVh/KvMEcGfAo6aNwrgdXws5+yNaPBCzhBhAenFOo8AVjAtvfisfn5Gkr1OWtsFuFaaWwkQ4fEXGFayLZg2jRQ0TqkDsvWS++l+OLZqCMJohmFZZcWtYMLQllUPL3O8CW0VIQ5VntgSRfYqqcjId8AXqmd1zC3sXaLkeV1QDZnoKoeTxCeVTphgLAqoBTK0OaPxaiS2NV5i8BKYgyEA6S99Tk8QNkDydYJ/LMhwDrcfMUsLFcfoa1pskjOMkKK0eCwHnVo5Ofuv6ecTWPe2mi+TkW9lr+VXytCdoZoXW1zBrmnMdfOt5pYRQNfxcgANv8hGB/MrBF/ZeL2743rIRdroyDvzXY9/1XUed6zmc9j4WWt1QWuZwI4UAIB87zwOzasfk5hQG+Z7hbvXiwLCcPjPIU8fC5OYXiueBLLuewrr5wWmHOR9tzqqw0Fy5TCn8IAaiO252hyw1TtIQZUb4Zb4QLiDa+ssJoNYjUgy+84msBPG91ZE17+WW4DiE4rGoDim14VojlWTAKXa2McS+86OGz5fbK57QcBfXSlvmQXpj2TJ5/Jy0xbeK8uknjaHGfgiVO0DAdh2uHlaxLNKSH9B6JvhWp6Xz24H+2h9QDOSHt1bX1fLb8kP8BTgq8On8J3xwExGVH45vYdMz8+RDL7w/I0bv3BG9OoZ8BQujrUKhKUmXk+wjG9Hgy4IpnvzLu38v7mZEd8v3K3IkXypNzDStKJWEssQi37ibUvQhL9ynkjf+/oIUgV5HQglXj43huWg36Ao1ZplsFl+HEnEg3b+RIlTe+EK0rPYlGE18O+QUMlYGVWipy+g4C+rlhxPeBJbpaLEB1kqgXWTGO4tbPh/coZ3YsVLQYHGgoQU852jTOw6HW7RvdbYX0jLZ72impo8YpUByzqwKSnEYNje8etCyTWSthNv2MVyRSToe++65li65WDL5+RawIqKTqkXbV8yKUfrT4lXBO//JNfPE9T6nqVFGoeTfs/XqF/Aw8xxoGfN+An6b+UGUtCrxfCVgFQ0TVKQY9a99TJBz68RSEh6eljOyenBkvsDm2kzdIvNSavUMRYs85JuXL8j4F+6wwWvwroZxW3rpyswqlmgfIGM1FK1TiZ6qT4gO3Pq362c+88mjSZezh1Q8BO9XrusoAsPmnpLbj9wH6dhK+qs+IVBtCSnCmV6MVLfxsNoxASXCHTIDGS0Tg1VGJu2LIUMVlU+iJjpRX9n1ppywcRN1qGrWa+dsCbkUNm6cAQijtDd+bm53o7sbWTUhrFE+/AuW+ktrraRkz7jv+HkpkPodxG2O9hX8Lfm94Y7mFN6fL8wvlCMco5ypzaeyVJ1i+ZMd+j59V9bLMlHnO88x3Aj8aRlnxDHK6sH4L29o8x6NA5nvfRl+jqRV7LIJ3BB6TPzKAe2sXmt6HsWQDK9LaKvDxdin621IIAfOCYB4jMNtOv4aJaKl8zvPsbAwdw4x38Gzo427RE99dHZtPCB9ZK79/6fV6CKaAjfeWrEZwU6jKDMFe5denb2UiyUvnWT1jj0hbbW5aKl4R27Ve19cMUadi5vHSeyu0VqDy6lRd4oF4Cq/nPMk8qmmCyuLSad0Pia9Rn38L8wnToCKDoR3GDgFK1ivrGMWTw/upzBUZwMZCy6ruPfPStMZYr3yVR3gO/H62/B5caZMRzNL07nc09/KvWuG9UEnLc5mf6+h5Quvg5X+eRTHAM+2G98Mll+YJFvKMmFkJgImQlMQX9d1zBujfArRYzz6m7Ik9xvcrQurK+Gw9H63kGfJcTDRdtoWZKEhYwDdbvjeHYt/NlnnZUygF1AVNNczFRhnF/kvjLKHvlgk4g+eCJ/Eo5Fg6G7zNhDLCOAejwXLVGvMH7Jzt+cx27cWPn13WrxM69ZPd4kwxXBlKs9brlXbv4Z4tt4M8LxO1uFi+6DmvMs6e5SW0SdNtRekfz3vy8s7eE3F5ork0Tjl18j0ao2Xpt+mpIdP1wMB/f5HB4TA9MfYek29LVL1Ln/beGcb/gvV+WKD8WwcbPvrSxf8K2t6GJD2D85eCOnx+KkHvGapSWUx7O+GXrukHfMAHfMAH/Grg+lT8B3zAB3zAB/zNwYdS+IAP+IAP+IAMH0rhAz7gAz7gAzJ8KIUP+IAP+IAPyPChFD7gAz7gAz4gw4dS+IAP+IAP+IAMH0rhAz7gAz7gAzJ8KIUP+IAP+IAPyPChFD7gAz7gAz4gw/8PWMRzer8FhCwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params = {\"model_path\": model_path,\n", + " \"img_input\": img_path,\n", + " \"device\":'CPU_FP32',\n", + " \"num_runs\": num_iters}\n", + "\n", + "run_inference(**params)" + ] + }, + { + "cell_type": "markdown", + "id": "45ea764a", + "metadata": {}, + "source": [ + "# Benchmarking" + ] + }, + { + "cell_type": "markdown", + "id": "38c93e68", + "metadata": {}, + "source": [ + "- Benchmarks can be performed using:\n", + " - openvino's [benchmark app](https://github.com/openvinotoolkit/openvino/tree/master/tools/benchmark_tool)\n", + "```\n", + "./benchmark_app -m /yolov7-tiny.onnx --shape [1,3,640,640]\n", + "```\n", + " \n", + "\n", + "\n", + "\n", + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('yv7')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "ea635b6725f857ac32fe5a69d2a976b6cb34422ba04243780c7fe011e9e618a5" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1e7bab9890ea24f5b27f58c2dc8a68f51f1d64a3 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Thu, 22 Sep 2022 11:17:44 +0530 Subject: [PATCH 11/15] yolov7 sample inital 0.01 --- .../README.md | 85 +- .../OVEP_yoloV7-tiny_object_detection.ipynb | 540 ++------ .../ptq_yolov7.py | 1092 +++++++++++++++++ .../yolov7.py | 217 ++++ 4 files changed, 1486 insertions(+), 448 deletions(-) create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py create mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index a0736aa3f..e1fe78609 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -1,53 +1,84 @@ -# FP32/INT8 YOLOv7 Sample - +# Object detection with YOLOv7 in Python using OpenVINO™ Execution Provider ## Virtual Environement Create a virtual environment either using a the `conda` virtual environment or `python venv`. +### Python venv +``` +$ python3 -m venv yv7-pyenv +$ source yv7-pyenv/bin/activate +$ pip install --upgrade pip +``` + ### Conda +If system python3 version is < 3.8 it's recommended to either upgrade to python3.8 or use create virtual environment python3.8 using conda. ``` $ conda create -n yolov7 python=3.8 $ conda activate yolov7 ``` -### Python venv -``` -$ python3 -m venv yolov7 -$ source yolov7/bin/activate -``` ## Install required packages After creating and activating virtual environment, install the required packages: -1. Jupyter Notebook -``` -$ pip install --no-cache-dir jupyter -``` -2. NNCF Experimental +### NNCF Experimental ``` $ git clone https://github.com/openvinotoolkit/nncf.git $ cd nncf && python setup.py install --onnx -$ pip install --no-cache-dir onnxruntime-openvino==1.11.0 -$ pip install --no-cache-dir onnxconverter_common +$ pip install --no-cache-dir onnxconverter_common onnxruntime-openvino==1.11.0 $ cd .. && rm -fR nncf ``` -3. YoloV7 requirements +### YoloV7 requirements ``` -$ cd notebooks -$ git clone https://github.com/WongKinYiu/yolov7 +$ cd notebooks && git clone https://github.com/WongKinYiu/yolov7 $ cp -R yolov7/* . $ pip install --no-cache-dir -r requirements.txt $ rm -fR yolov7 ``` -Launch the notebook from here. -## Dataset -The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. -## Outputs +# Steps to perform NNCF Quantization for YoloV7 + +## Export Model to onnx +The models are to be exported using the export script present in the yolov7 repo. Download desired yolov7 model from [here](https://github.com/WongKinYiu/yolov7/releases). +``` +$ wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt +``` +Export Model using the below command. (As mentioned in the official public [repo](https://github.com/WongKinYiu/yolov7#export).) +**Note: Adjust the values of `iou-thres` and `conf-thres` while exporting to get better bounding boxes.** +``` +$ python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640 +``` -- `yolov7-tiny.onnx` -- `yolov7-tiny-quantized.onnx` -- `cat-yolov7-detected.jpg` +## Download Data +``` +$ cd .. && wget -O tmp.zip 'https://ultralytics.com/assets/coco2017val.zip' +$ unzip -q tmp.zip -d datasets && rm tmp.zip +``` + + +## Quantization + +The quantization script is specific to yolov7 model. All the dependencies (helper functions & loader objects, taken from the public [repo](https://github.com/WongKinYiu/yolov7/)) are present within the `ptq_yolov7.py` script. + +``` +python ptq_yolov7.py --data datasets/coco/images/val2017 \ + --input-model notebooks/yolov7-tiny.onnx \ + --sample-size 100 +``` + +## Run Inference + +### Run the sample on default CPU Execution Provider (MLAS) +``` +$ python3 yolov7.py --device cpu --video classroom.mp4 --model +``` +### Run the sample with video as Input +``` +$ python3 yolov7.py --device CPU_FP32 --video classroom.mp4 --model +``` +### Run the sample with Image as Input +``` +$ python3 yolov7.py --device CPU_FP32 --image cat.jpg --model +``` -## References -### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) -### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file +### Run inference using notebook +Install jupyter notebook in the corresponding env and run the notebook present in the notebooks directory. \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index ff2a025ad..71069971f 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -56,36 +56,39 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# import os\n", - "# import torch\n", - "# import warnings\n", - "# warnings.filterwarnings(action=\"ignore\")\n", + "import os\n", + "import torch\n", + "import warnings\n", + "warnings.filterwarnings(action=\"ignore\")\n", "\n", - "# if not os.path.exists(\"../datasets\"):\n", - "# # Download COCO val\n", - "# torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", - "# !unzip -q tmp.zip -d ../datasets && rm tmp.zip" + "if not os.path.exists(\"../datasets\"):\n", + " # Download COCO val\n", + " torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", + " !unzip -q tmp.zip -d ../datasets && rm tmp.zip" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Export yolov7-tiny model to ONNX format\n", + "## Export yolov7-tiny model to ONNX format with NMS\n", + "\n", "```python\n", "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", - "```" + "```\n", + "\n", + "**Note: Adjust the values of `iou-thres` and `conf-thres` according to requirements.**" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -103,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -135,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -177,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -203,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -268,15 +271,14 @@ "It performs the following tasks:\n", "- Pre-process the input image as per model requirements\n", "- Creates the appropriate onnxruntime session as per the device arguement\n", - "- Runs inferences according to the number of runs passed\n", - "- Performs non-max suppression on the predictions\n", + "- Runs inferences along with non-max suppression on the predictions for the number of runs passed\n", "- Adds bounding boxes on the detected objects\n", "- Saves a copy of the inferred image." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -307,7 +309,7 @@ " ori_images = cv2.imread(img_input)\n", " ori_images = [cv2.cvtColor(ori_images, cv2.COLOR_BGR2RGB)]\n", " \n", - " # NMS (Non-Max Supression)\n", + " # Add bounding box to detected samples\n", " for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(pred):\n", " image = ori_images[int(batch_id)]\n", " box = np.array([x0,y0,x1,y1])\n", @@ -340,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -351,29 +353,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Use ORT providers: ['CPUExecutionProvider']\n", - "Avg Inference time in ms: 37.153132\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\":model_path,\n", " \"img_input\": img_path,\n", @@ -392,29 +374,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Use ORT providers: ['OpenVINOExecutionProvider']\n", - "Avg Inference time in ms: 32.271441\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\": model_path,\n", " \"img_input\": img_path,\n", @@ -446,10 +408,11 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "```python\n", "import onnx\n", "\n", "from nncf.experimental.post_training.compression_builder import CompressionBuilder\n", @@ -474,10 +437,22 @@ " def __len__(self):\n", " return len(self.load_images)\n", "\n", - "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)\n", - "```\n", - "### Run PTQ\n", - "```python\n", + "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run PTQ" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "original_model = onnx.load(\"yolov7-tiny.onnx\")\n", "num_init_samples = 100\n", "# We'll ignore detector head not to quantize them\n", @@ -501,34 +476,81 @@ " \"Mul_291\",\n", " \"Mul_295\",\n", "]\n", - "output_model_path = \"yolov7-tiny-quantized.onnx\"\n", - "```\n", - "### Step 1: Create a pipeline of compression algorithms.\n", - "```python\n", - "builder = CompressionBuilder()\n", - "```\n", - "### Step 2: Create the quantization algorithm and add to the builder.\n", - "```python\n", + "output_model_path = \"yolov7-tiny-quantized.onnx\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1: Create a pipeline of compression algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "builder = CompressionBuilder()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 2: Create the quantization algorithm and add to the builder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "quantization_parameters = PostTrainingQuantizationParameters(\n", " number_samples=num_init_samples,\n", " ignored_scopes=ignored_scopes\n", ")\n", "quantization = PostTrainingQuantization(quantization_parameters)\n", - "builder.add_algorithm(quantization)\n", - "```\n", - "### Step 3: Execute the pipeline.\n", - "```python\n", + "builder.add_algorithm(quantization)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 3: Execute the pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "nncf_logger.info(\"Post-Training Quantization has just started!\")\n", - "quantized_model = builder.apply(original_model, dataset)\n", - "```\n", - "### Step 4: Save the quantized model.\n", - "```python\n", + "quantized_model = builder.apply(original_model, dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 4: Save the quantized model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "onnx.save(quantized_model, output_model_path)\n", "nncf_logger.info(\n", " \"The quantized model is saved on {}\".format(output_model_path))\n", "\n", - "onnx.checker.check_model(output_model_path)\n", - "```" + "onnx.checker.check_model(output_model_path)" ] }, { @@ -547,7 +569,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -558,173 +580,11 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Use ORT providers: ['CPUExecutionProvider']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-09-13 16:35:47.141002658 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141029422 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141033285 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141036903 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141040050 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141043119 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141046238 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141049576 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141052506 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141055899 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141058800 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141061827 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141065563 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141069029 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141072128 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141075744 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141078815 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141082006 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141085211 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141088247 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141091386 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141095091 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141098646 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141101901 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141104979 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141107965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141111030 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141114680 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141117793 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141121445 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141125163 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141128439 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141131433 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141134572 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141138337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141141532 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141145031 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141148043 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141151132 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141154911 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141158131 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141161635 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141164887 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141167965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141171009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141174053 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141177502 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141180817 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141184658 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141187835 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141191157 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141194301 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141197375 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141201091 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141204356 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141208166 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141211143 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141214748 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141217926 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141221541 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141224705 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141227871 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141230841 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141234276 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141237356 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141240411 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141243924 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141247204 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141250357 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141253527 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141256488 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141259781 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141262852 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141265937 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141269176 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141272896 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141276162 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141279221 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141282676 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141285833 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141289021 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141292236 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141295260 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141298349 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141302300 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141305291 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141308550 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141311807 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141314961 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141317895 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141320758 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141323772 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141326881 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141337023 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141340226 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141343216 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141346414 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141349480 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141352696 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141355949 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141359003 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141362069 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141365965 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141368900 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141371959 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141375023 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141378206 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141381404 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141384433 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141387977 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141391237 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141394816 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141397941 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141400991 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141404093 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141407144 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141410419 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 468 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141413419 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 469 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141416565 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 470 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141419513 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 471 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141423307 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 472 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141426754 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 473 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141429882 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 474 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141432822 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 475 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141435697 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 476 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141438637 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 477 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141441857 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 478 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141446257 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 479 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141449273 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 480 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:47.141453030 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 481 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Avg Inference time in ms: 55.627801\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "params = {\"model_path\": model_path,\n", " \"img_input\": img_path,\n", @@ -743,171 +603,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape:\t(1, 3, 640, 640)\n", - "Use ORT providers: ['OpenVINOExecutionProvider']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-09-13 16:35:53.140001696 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140038020 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.0.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140047716 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140056514 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.1.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140063807 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140071143 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.2.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140078795 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140086523 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.3.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140094337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140102516 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.4.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140109467 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140123086 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.5.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140130437 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140138639 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.7.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140145924 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140153472 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.9.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140161082 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140168401 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.10.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140176124 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140183337 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.11.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140191499 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140199041 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.12.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140206473 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140213550 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.14.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140221237 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140228773 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.16.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140235815 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140243305 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.17.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140250576 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140259422 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.18.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140266724 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140274331 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.19.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140281545 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140288758 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.21.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140295936 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140303009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.23.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140310448 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140318268 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.24.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140326393 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140333836 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.25.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140341383 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140348435 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.26.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140355514 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140363232 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.28.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140370285 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140377485 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.29.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140384634 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140393159 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.30.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140401188 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140408233 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.35.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140415207 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140422263 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.37.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140429982 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140438081 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.38.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140445395 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140452628 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.40.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140460972 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140468354 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.42.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140475753 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140484518 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.43.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140491904 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140499733 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.44.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140507677 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140515325 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.45.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140522604 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140530379 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.47.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140537640 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140545321 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.48.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140552638 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140559539 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.50.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140567801 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140574771 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.52.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140581862 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140589124 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.53.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140607103 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140614521 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.54.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140621719 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140629487 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.55.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140636679 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140644218 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.57.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140651810 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140659320 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.58.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140666786 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140674786 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.60.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140682018 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140689087 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.61.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140696540 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140704273 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.62.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140711488 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140718732 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.63.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140725694 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140732956 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.65.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140741009 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140748159 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.66.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140755405 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140762435 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.68.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140769978 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140777229 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.69.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140784688 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140791790 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.70.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140799138 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140807144 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.71.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140814378 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140821404 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.73.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140828650 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140835612 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.74.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140842669 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140850154 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.75.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140857903 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140864993 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.76.conv.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140873690 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140880565 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.0.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140887825 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140895529 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.1.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140903349 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.weight appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140911367 [W:onnxruntime:, graph.cc:1271 Graph] Initializer model.model.77.m.2.bias appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140918534 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 468 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140926060 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 469 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140933141 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 470 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140941684 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 471 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140948826 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 472 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140955659 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 473 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140962692 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 474 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140969539 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 475 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140976545 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 476 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140983993 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 477 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.140991109 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 478 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.141000927 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 479 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.141010612 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 480 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n", - "2022-09-13 16:35:53.141017770 [W:onnxruntime:, graph.cc:1271 Graph] Initializer 481 appears in graph inputs and will not be treated as constant value/weight. This may prevent some of the graph optimizations, like const folding. Move it out of graph inputs if there is no need to override it, by either re-generating the model with latest exporter/converter or with the tool onnxruntime/tools/python/remove_initializer_from_input.py.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Avg Inference time in ms: 18.871429\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "params = {\"model_path\": model_path,\n", " \"img_input\": img_path,\n", diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py new file mode 100644 index 000000000..7de019ef0 --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py @@ -0,0 +1,1092 @@ +import argparse +import glob +import logging +import math +import os +import random +from itertools import repeat +from multiprocessing.pool import ThreadPool +from pathlib import Path + +import cv2 +import numpy as np +import onnx +import torch +import torch.nn.functional as F +from tqdm import tqdm +from nncf.common.utils.logger import logger as nncf_logger +from nncf.experimental.onnx.tensor import ONNXNNCFTensor +from nncf.experimental.post_training.algorithms.quantization import ( + PostTrainingQuantization, PostTrainingQuantizationParameters) +from nncf.experimental.post_training.api import dataset as ptq_api_dataset +from nncf.experimental.post_training.compression_builder import \ + CompressionBuilder +from PIL import ExifTags, Image +from torch.utils.data import Dataset + +# from utils.datasets import LoadImagesAndLabels +help_url = 'https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data' +img_formats = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', + 'dng', 'webp', 'mpo'] # acceptable image suffixes +vid_formats = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', + 'm4v', 'wmv', 'mkv'] # acceptable video suffixes +logger = logging.getLogger(__name__) + +# Get orientation exif tag +for orientation in ExifTags.TAGS.keys(): + if ExifTags.TAGS[orientation] == 'Orientation': + break + + +def bbox_ioa(box1, box2): + # Returns the intersection over box2 area given box1, box2. box1 is 4, box2 is nx4. boxes are x1y1x2y2 + box2 = box2.transpose() + + # Get the coordinates of bounding boxes + b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3] + b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3] + + # Intersection area + inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \ + (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0) + + # box2 area + box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + 1e-16 + + # Intersection over box2 area + return inter_area / box2_area + + +def copy_paste(img, labels, segments, probability=0.5): + # Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy) + n = len(segments) + if probability and n: + h, w, c = img.shape # height, width, channels + im_new = np.zeros(img.shape, np.uint8) + for j in random.sample(range(n), k=round(probability * n)): + l, s = labels[j], segments[j] + box = w - l[3], l[2], w - l[1], l[4] + ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area + if (ioa < 0.30).all(): # allow 30% obscuration of existing labels + labels = np.concatenate((labels, [[l[0], *box]]), 0) + segments.append(np.concatenate((w - s[:, 0:1], s[:, 1:2]), 1)) + cv2.drawContours(im_new, [segments[j].astype( + np.int32)], -1, (255, 255, 255), cv2.FILLED) + + result = cv2.bitwise_and(src1=img, src2=im_new) + result = cv2.flip(result, 1) # augment segments (flip left-right) + i = result > 0 # pixels to replace + # i[:, :] = result.max(2).reshape(h, w, 1) # act over ch + img[i] = result[i] # cv2.imwrite('debug.jpg', img) # debug + + return img, labels, segments + + +def get_hash(files): + # Returns a single hash value of a list of files + return sum(os.path.getsize(f) for f in files if os.path.isfile(f)) + + +def xyxy2xywh(x): + # Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right + y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) + y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center + y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center + y[:, 2] = x[:, 2] - x[:, 0] # width + y[:, 3] = x[:, 3] - x[:, 1] # height + return y + + +def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0): + # Convert nx4 boxes from [x, y, w, h] normalized to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right + y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) + y[:, 0] = w * (x[:, 0] - x[:, 2] / 2) + padw # top left x + y[:, 1] = h * (x[:, 1] - x[:, 3] / 2) + padh # top left y + y[:, 2] = w * (x[:, 0] + x[:, 2] / 2) + padw # bottom right x + y[:, 3] = h * (x[:, 1] + x[:, 3] / 2) + padh # bottom right y + return y + + +def xyn2xy(x, w=640, h=640, padw=0, padh=0): + # Convert normalized segments into pixel segments, shape (n,2) + y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) + y[:, 0] = w * x[:, 0] + padw # top left x + y[:, 1] = h * x[:, 1] + padh # top left y + return y + + +def segment2box(segment, width=640, height=640): + # Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy) + x, y = segment.T # segment xy + inside = (x >= 0) & (y >= 0) & (x <= width) & (y <= height) + x, y, = x[inside], y[inside] + # xyxy + return np.array([x.min(), y.min(), x.max(), y.max()]) if any(x) else np.zeros((1, 4)) + + +def sample_segments(img, labels, segments, probability=0.5): + # Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy) + n = len(segments) + sample_labels = [] + sample_images = [] + sample_masks = [] + if probability and n: + h, w, c = img.shape # height, width, channels + for j in random.sample(range(n), k=round(probability * n)): + l, s = labels[j], segments[j] + box = l[1].astype(int).clip(0, w-1), l[2].astype(int).clip(0, h - + 1), l[3].astype(int).clip(0, w-1), l[4].astype(int).clip(0, h-1) + + # print(box) + if (box[2] <= box[0]) or (box[3] <= box[1]): + continue + + sample_labels.append(l[0]) + + mask = np.zeros(img.shape, np.uint8) + + cv2.drawContours(mask, [segments[j].astype( + np.int32)], -1, (255, 255, 255), cv2.FILLED) + sample_masks.append(mask[box[1]:box[3], box[0]:box[2], :]) + + result = cv2.bitwise_and(src1=img, src2=mask) + i = result > 0 # pixels to replace + mask[i] = result[i] # cv2.imwrite('debug.jpg', img) # debug + # print(box) + sample_images.append(mask[box[1]:box[3], box[0]:box[2], :]) + + return sample_labels, sample_images, sample_masks + + +def load_samples(self, index): + # loads images in a 4-mosaic + + labels4, segments4 = [], [] + s = self.img_size + yc, xc = [int(random.uniform(-x, 2 * s + x)) + for x in self.mosaic_border] # mosaic center x, y + # 3 additional image indices + indices = [index] + random.choices(self.indices, k=3) + for i, index in enumerate(indices): + # Load image + img, _, (h, w) = load_image(self, index) + + # place img in img4 + if i == 0: # top left + # base image with 4 tiles + img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) + # xmin, ymin, xmax, ymax (large image) + x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc + # xmin, ymin, xmax, ymax (small image) + x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h + elif i == 1: # top right + x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc + x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h + elif i == 2: # bottom left + x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) + x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h) + elif i == 3: # bottom right + x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) + x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) + + # img4[ymin:ymax, xmin:xmax] + img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] + padw = x1a - x1b + padh = y1a - y1b + + # Labels + labels, segments = self.labels[index].copy( + ), self.segments[index].copy() + if labels.size: + # normalized xywh to pixel xyxy format + labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) + segments = [xyn2xy(x, w, h, padw, padh) for x in segments] + labels4.append(labels) + segments4.extend(segments) + + # Concat/clip labels + labels4 = np.concatenate(labels4, 0) + for x in (labels4[:, 1:], *segments4): + np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() + # img4, labels4 = replicate(img4, labels4) # replicate + + # Augment + #img4, labels4, segments4 = remove_background(img4, labels4, segments4) + sample_labels, sample_images, sample_masks = sample_segments( + img4, labels4, segments4, probability=0.5) + + return sample_labels, sample_images, sample_masks + + +def resample_segments(segments, n=1000): + # Up-sample an (n,2) segment + for i, s in enumerate(segments): + s = np.concatenate((s, s[0:1, :]), axis=0) + x = np.linspace(0, len(s) - 1, n) + xp = np.arange(len(s)) + segments[i] = np.concatenate( + [np.interp(x, xp, s[:, i]) for i in range(2)]).reshape(2, -1).T # segment xy + return segments + + +def box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.1, eps=1e-16): # box1(4,n), box2(4,n) + # Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio + w1, h1 = box1[2] - box1[0], box1[3] - box1[1] + w2, h2 = box2[2] - box2[0], box2[3] - box2[1] + ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio + # candidates + return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) + + +def random_perspective(img, targets=(), segments=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0, + border=(0, 0)): + # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10)) + # targets = [cls, xyxy] + + height = img.shape[0] + border[0] * 2 # shape(h,w,c) + width = img.shape[1] + border[1] * 2 + + # Center + C = np.eye(3) + C[0, 2] = -img.shape[1] / 2 # x translation (pixels) + C[1, 2] = -img.shape[0] / 2 # y translation (pixels) + + # Perspective + P = np.eye(3) + # x perspective (about y) + P[2, 0] = random.uniform(-perspective, perspective) + # y perspective (about x) + P[2, 1] = random.uniform(-perspective, perspective) + + # Rotation and Scale + R = np.eye(3) + a = random.uniform(-degrees, degrees) + # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations + s = random.uniform(1 - scale, 1.1 + scale) + # s = 2 ** random.uniform(-scale, scale) + R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s) + + # Shear + S = np.eye(3) + S[0, 1] = math.tan(random.uniform(-shear, shear) * + math.pi / 180) # x shear (deg) + S[1, 0] = math.tan(random.uniform(-shear, shear) * + math.pi / 180) # y shear (deg) + + # Translation + T = np.eye(3) + T[0, 2] = random.uniform(0.5 - translate, 0.5 + + translate) * width # x translation (pixels) + T[1, 2] = random.uniform(0.5 - translate, 0.5 + + translate) * height # y translation (pixels) + + # Combined rotation matrix + M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT + if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed + if perspective: + img = cv2.warpPerspective(img, M, dsize=( + width, height), borderValue=(114, 114, 114)) + else: # affine + img = cv2.warpAffine(img, M[:2], dsize=( + width, height), borderValue=(114, 114, 114)) + + # Visualize + # import matplotlib.pyplot as plt + # ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel() + # ax[0].imshow(img[:, :, ::-1]) # base + # ax[1].imshow(img2[:, :, ::-1]) # warped + + # Transform label coordinates + n = len(targets) + if n: + use_segments = any(x.any() for x in segments) + new = np.zeros((n, 4)) + if use_segments: # warp segments + segments = resample_segments(segments) # upsample + for i, segment in enumerate(segments): + xy = np.ones((len(segment), 3)) + xy[:, :2] = segment + xy = xy @ M.T # transform + # perspective rescale or affine + xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] + + # clip + new[i] = segment2box(xy, width, height) + + else: # warp boxes + xy = np.ones((n * 4, 3)) + xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape( + n * 4, 2) # x1y1, x2y2, x1y2, x2y1 + xy = xy @ M.T # transform + xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] + ).reshape(n, 8) # perspective rescale or affine + + # create new boxes + x = xy[:, [0, 2, 4, 6]] + y = xy[:, [1, 3, 5, 7]] + new = np.concatenate( + (x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T + + # clip + new[:, [0, 2]] = new[:, [0, 2]].clip(0, width) + new[:, [1, 3]] = new[:, [1, 3]].clip(0, height) + + # filter candidates + i = box_candidates( + box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10) + targets = targets[i] + targets[:, 1:5] = new[i] + + return img, targets + + +def segments2boxes(segments): + # Convert segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh) + boxes = [] + for s in segments: + x, y = s.T # segment xy + boxes.append([x.min(), y.min(), x.max(), y.max()]) # cls, xyxy + return xyxy2xywh(np.array(boxes)) # cls, xywh + + +def img2label_paths(img_paths): + # Define label paths as a function of image paths + sa, sb = os.sep + 'images' + os.sep, os.sep + \ + 'labels' + os.sep # /images/, /labels/ substrings + return ['txt'.join(x.replace(sa, sb, 1).rsplit(x.split('.')[-1], 1)) for x in img_paths] + + +def load_mosaic(self, index): + # loads images in a 4-mosaic + + labels4, segments4 = [], [] + s = self.img_size + yc, xc = [int(random.uniform(-x, 2 * s + x)) + for x in self.mosaic_border] # mosaic center x, y + # 3 additional image indices + indices = [index] + random.choices(self.indices, k=3) + for i, index in enumerate(indices): + # Load image + img, _, (h, w) = load_image(self, index) + + # place img in img4 + if i == 0: # top left + # base image with 4 tiles + img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) + # xmin, ymin, xmax, ymax (large image) + x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc + # xmin, ymin, xmax, ymax (small image) + x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h + elif i == 1: # top right + x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc + x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h + elif i == 2: # bottom left + x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) + x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h) + elif i == 3: # bottom right + x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) + x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) + + # img4[ymin:ymax, xmin:xmax] + img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] + padw = x1a - x1b + padh = y1a - y1b + + # Labels + labels, segments = self.labels[index].copy( + ), self.segments[index].copy() + if labels.size: + # normalized xywh to pixel xyxy format + labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) + segments = [xyn2xy(x, w, h, padw, padh) for x in segments] + labels4.append(labels) + segments4.extend(segments) + + # Concat/clip labels + labels4 = np.concatenate(labels4, 0) + for x in (labels4[:, 1:], *segments4): + np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() + # img4, labels4 = replicate(img4, labels4) # replicate + + # Augment + #img4, labels4, segments4 = remove_background(img4, labels4, segments4) + #sample_segments(img4, labels4, segments4, probability=self.hyp['copy_paste']) + img4, labels4, segments4 = copy_paste( + img4, labels4, segments4, probability=self.hyp['copy_paste']) + img4, labels4 = random_perspective(img4, labels4, segments4, + degrees=self.hyp['degrees'], + translate=self.hyp['translate'], + scale=self.hyp['scale'], + shear=self.hyp['shear'], + perspective=self.hyp['perspective'], + border=self.mosaic_border) # border to remove + + return img4, labels4 + + +def load_mosaic9(self, index): + # loads images in a 9-mosaic + + labels9, segments9 = [], [] + s = self.img_size + # 8 additional image indices + indices = [index] + random.choices(self.indices, k=8) + for i, index in enumerate(indices): + # Load image + img, _, (h, w) = load_image(self, index) + + # place img in img9 + if i == 0: # center + # base image with 4 tiles + img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) + h0, w0 = h, w + c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates + elif i == 1: # top + c = s, s - h, s + w, s + elif i == 2: # top right + c = s + wp, s - h, s + wp + w, s + elif i == 3: # right + c = s + w0, s, s + w0 + w, s + h + elif i == 4: # bottom right + c = s + w0, s + hp, s + w0 + w, s + hp + h + elif i == 5: # bottom + c = s + w0 - w, s + h0, s + w0, s + h0 + h + elif i == 6: # bottom left + c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h + elif i == 7: # left + c = s - w, s + h0 - h, s, s + h0 + elif i == 8: # top left + c = s - w, s + h0 - hp - h, s, s + h0 - hp + + padx, pady = c[:2] + x1, y1, x2, y2 = [max(x, 0) for x in c] # allocate coords + + # Labels + labels, segments = self.labels[index].copy( + ), self.segments[index].copy() + if labels.size: + # normalized xywh to pixel xyxy format + labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady) + segments = [xyn2xy(x, w, h, padx, pady) for x in segments] + labels9.append(labels) + segments9.extend(segments) + + # Image + # img9[ymin:ymax, xmin:xmax] + img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:] + hp, wp = h, w # height, width previous + + # Offset + yc, xc = [int(random.uniform(0, s)) + for _ in self.mosaic_border] # mosaic center x, y + img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s] + + # Concat/clip labels + labels9 = np.concatenate(labels9, 0) + labels9[:, [1, 3]] -= xc + labels9[:, [2, 4]] -= yc + c = np.array([xc, yc]) # centers + segments9 = [x - c for x in segments9] + + for x in (labels9[:, 1:], *segments9): + np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() + # img9, labels9 = replicate(img9, labels9) # replicate + + # Augment + #img9, labels9, segments9 = remove_background(img9, labels9, segments9) + img9, labels9, segments9 = copy_paste( + img9, labels9, segments9, probability=self.hyp['copy_paste']) + img9, labels9 = random_perspective(img9, labels9, segments9, + degrees=self.hyp['degrees'], + translate=self.hyp['translate'], + scale=self.hyp['scale'], + shear=self.hyp['shear'], + perspective=self.hyp['perspective'], + border=self.mosaic_border) # border to remove + + return img9, labels9 + + +def load_image(self, index): + # loads 1 image from dataset, returns img, original hw, resized hw + img = self.imgs[index] + if img is None: # not cached + path = self.img_files[index] + img = cv2.imread(path) # BGR + assert img is not None, 'Image Not Found ' + path + h0, w0 = img.shape[:2] # orig hw + r = self.img_size / max(h0, w0) # resize image to img_size + if r != 1: # always resize down, only resize up if training with augmentation + interp = cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR + img = cv2.resize(img, (int(w0 * r), int(h0 * r)), + interpolation=interp) + return img, (h0, w0), img.shape[:2] # img, hw_original, hw_resized + else: + # img, hw_original, hw_resized + return self.imgs[index], self.img_hw0[index], self.img_hw[index] + + +def exif_size(img): + # Returns exif-corrected PIL size + s = img.size # (width, height) + try: + rotation = dict(img._getexif().items())[orientation] + if rotation == 6: # rotation 270 + s = (s[1], s[0]) + elif rotation == 8: # rotation 90 + s = (s[1], s[0]) + except: + pass + + return s + + +def letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32): + # Resize and pad image while meeting stride-multiple constraints + shape = img.shape[:2] # current shape [height, width] + if isinstance(new_shape, int): + new_shape = (new_shape, new_shape) + + # Scale ratio (new / old) + r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) + if not scaleup: # only scale down, do not scale up (for better test mAP) + r = min(r, 1.0) + + # Compute padding + ratio = r, r # width, height ratios + new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) + dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - \ + new_unpad[1] # wh padding + if auto: # minimum rectangle + dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding + elif scaleFill: # stretch + dw, dh = 0.0, 0.0 + new_unpad = (new_shape[1], new_shape[0]) + ratio = new_shape[1] / shape[1], new_shape[0] / \ + shape[0] # width, height ratios + + dw /= 2 # divide padding into 2 sides + dh /= 2 + + if shape[::-1] != new_unpad: # resize + img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR) + top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) + left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) + img = cv2.copyMakeBorder( + img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border + return img, ratio, (dw, dh) + + +def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5): + r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains + hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV)) + dtype = img.dtype # uint8 + + x = np.arange(0, 256, dtype=np.int16) + lut_hue = ((x * r[0]) % 180).astype(dtype) + lut_sat = np.clip(x * r[1], 0, 255).astype(dtype) + lut_val = np.clip(x * r[2], 0, 255).astype(dtype) + + img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT( + sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype) + cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed + + +def pastein(image, labels, sample_labels, sample_images, sample_masks): + # Applies image cutout augmentation https://arxiv.org/abs/1708.04552 + h, w = image.shape[:2] + + # create random masks + scales = [0.75] * 2 + [0.5] * 4 + [0.25] * 4 + \ + [0.125] * 4 + [0.0625] * 6 # image size fraction + for s in scales: + if random.random() < 0.2: + continue + mask_h = random.randint(1, int(h * s)) + mask_w = random.randint(1, int(w * s)) + + # box + xmin = max(0, random.randint(0, w) - mask_w // 2) + ymin = max(0, random.randint(0, h) - mask_h // 2) + xmax = min(w, xmin + mask_w) + ymax = min(h, ymin + mask_h) + + box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32) + if len(labels): + ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area + else: + ioa = np.zeros(1) + + # allow 30% obscuration of existing labels + if (ioa < 0.30).all() and len(sample_labels) and (xmax > xmin+20) and (ymax > ymin+20): + sel_ind = random.randint(0, len(sample_labels)-1) + # print(len(sample_labels)) + # print(sel_ind) + #print((xmax-xmin, ymax-ymin)) + #print(image[ymin:ymax, xmin:xmax].shape) + #print([[sample_labels[sel_ind], *box]]) + # print(labels.shape) + hs, ws, cs = sample_images[sel_ind].shape + r_scale = min((ymax-ymin)/hs, (xmax-xmin)/ws) + r_w = int(ws*r_scale) + r_h = int(hs*r_scale) + + if (r_w > 10) and (r_h > 10): + r_mask = cv2.resize(sample_masks[sel_ind], (r_w, r_h)) + r_image = cv2.resize(sample_images[sel_ind], (r_w, r_h)) + temp_crop = image[ymin:ymin+r_h, xmin:xmin+r_w] + m_ind = r_mask > 0 + if m_ind.astype(np.int).sum() > 60: + temp_crop[m_ind] = r_image[m_ind] + # print(sample_labels[sel_ind]) + # print(sample_images[sel_ind].shape) + # print(temp_crop.shape) + box = np.array( + [xmin, ymin, xmin+r_w, ymin+r_h], dtype=np.float32) + if len(labels): + labels = np.concatenate( + (labels, [[sample_labels[sel_ind], *box]]), 0) + else: + labels = np.array([[sample_labels[sel_ind], *box]]) + + image[ymin:ymin+r_h, xmin:xmin+r_w] = temp_crop + + return labels + + +class LoadImagesAndLabels(Dataset): # for training/testing + def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False, + cache_images=False, single_cls=False, stride=32, pad=0.0, prefix=''): + self.img_size = img_size + self.augment = augment + self.hyp = hyp + self.image_weights = image_weights + self.rect = False if image_weights else rect + # load 4 images at a time into a mosaic (only during training) + self.mosaic = self.augment and not self.rect + self.mosaic_border = [-img_size // 2, -img_size // 2] + self.stride = stride + self.path = path + #self.albumentations = Albumentations() if augment else None + + try: + f = [] # image files + for p in path if isinstance(path, list) else [path]: + p = Path(p) # os-agnostic + if p.is_dir(): # dir + f += glob.glob(str(p / '**' / '*.*'), recursive=True) + # f = list(p.rglob('**/*.*')) # pathlib + elif p.is_file(): # file + with open(p, 'r') as t: + t = t.read().strip().splitlines() + parent = str(p.parent) + os.sep + # local to global path + f += [x.replace('./', parent) + if x.startswith('./') else x for x in t] + # f += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib) + else: + raise Exception(f'{prefix}{p} does not exist') + self.img_files = sorted( + [x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in img_formats]) + # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in img_formats]) # pathlib + assert self.img_files, f'{prefix}No images found' + except Exception as e: + raise Exception( + f'{prefix}Error loading data from {path}: {e}\nSee {help_url}') + + # Check cache + self.label_files = img2label_paths(self.img_files) # labels + cache_path = (p if p.is_file() else Path( + self.label_files[0]).parent).with_suffix('.cache') # cached labels + if cache_path.is_file(): + cache, exists = torch.load(cache_path), True # load + # if cache['hash'] != get_hash(self.label_files + self.img_files) or 'version' not in cache: # changed + # cache, exists = self.cache_labels(cache_path, prefix), False # re-cache + else: + cache, exists = self.cache_labels( + cache_path, prefix), False # cache + + # Display cache + # found, missing, empty, corrupted, total + nf, nm, ne, nc, n = cache.pop('results') + if exists: + d = f"Scanning '{cache_path}' images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupted" + # display cache results + tqdm(None, desc=prefix + d, total=n, initial=n) + assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {help_url}' + + # Read cache + cache.pop('hash') # remove hash + cache.pop('version') # remove version + labels, shapes, self.segments = zip(*cache.values()) + self.labels = list(labels) + self.shapes = np.array(shapes, dtype=np.float64) + self.img_files = list(cache.keys()) # update + self.label_files = img2label_paths(cache.keys()) # update + if single_cls: + for x in self.labels: + x[:, 0] = 0 + + n = len(shapes) # number of images + bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index + nb = bi[-1] + 1 # number of batches + self.batch = bi # batch index of image + self.n = n + self.indices = range(n) + + # Rectangular Training + if self.rect: + # Sort by aspect ratio + s = self.shapes # wh + ar = s[:, 1] / s[:, 0] # aspect ratio + irect = ar.argsort() + self.img_files = [self.img_files[i] for i in irect] + self.label_files = [self.label_files[i] for i in irect] + self.labels = [self.labels[i] for i in irect] + self.shapes = s[irect] # wh + ar = ar[irect] + + # Set training image shapes + shapes = [[1, 1]] * nb + for i in range(nb): + ari = ar[bi == i] + mini, maxi = ari.min(), ari.max() + if maxi < 1: + shapes[i] = [maxi, 1] + elif mini > 1: + shapes[i] = [1, 1 / mini] + + self.batch_shapes = np.ceil( + np.array(shapes) * img_size / stride + pad).astype(np.int) * stride + + # Cache images into memory for faster training (WARNING: large datasets may exceed system RAM) + self.imgs = [None] * n + if cache_images: + if cache_images == 'disk': + self.im_cache_dir = Path( + Path(self.img_files[0]).parent.as_posix() + '_npy') + self.img_npy = [ + self.im_cache_dir / Path(f).with_suffix('.npy').name for f in self.img_files] + self.im_cache_dir.mkdir(parents=True, exist_ok=True) + gb = 0 # Gigabytes of cached images + self.img_hw0, self.img_hw = [None] * n, [None] * n + results = ThreadPool(8).imap( + lambda x: load_image(*x), zip(repeat(self), range(n))) + pbar = tqdm(enumerate(results), total=n) + for i, x in pbar: + if cache_images == 'disk': + if not self.img_npy[i].exists(): + np.save(self.img_npy[i].as_posix(), x[0]) + gb += self.img_npy[i].stat().st_size + else: + self.imgs[i], self.img_hw0[i], self.img_hw[i] = x + gb += self.imgs[i].nbytes + pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB)' + pbar.close() + + def cache_labels(self, path=Path('./labels.cache'), prefix=''): + # Cache dataset labels, check images and read shapes + x = {} # dict + nm, nf, ne, nc = 0, 0, 0, 0 # number missing, found, empty, duplicate + pbar = tqdm(zip(self.img_files, self.label_files), + desc='Scanning images', total=len(self.img_files)) + for i, (im_file, lb_file) in enumerate(pbar): + try: + # verify images + im = Image.open(im_file) + im.verify() # PIL verify + shape = exif_size(im) # image size + segments = [] # instance segments + assert (shape[0] > 9) & ( + shape[1] > 9), f'image size {shape} <10 pixels' + assert im.format.lower( + ) in img_formats, f'invalid image format {im.format}' + + # verify labels + if os.path.isfile(lb_file): + nf += 1 # label found + with open(lb_file, 'r') as f: + l = [x.split() for x in f.read().strip().splitlines()] + if any([len(x) > 8 for x in l]): # is segment + classes = np.array([x[0] + for x in l], dtype=np.float32) + # (cls, xy1...) + segments = [ + np.array(x[1:], dtype=np.float32).reshape(-1, 2) for x in l] + l = np.concatenate( + (classes.reshape(-1, 1), segments2boxes(segments)), 1) # (cls, xywh) + l = np.array(l, dtype=np.float32) + if len(l): + assert l.shape[1] == 5, 'labels require 5 columns each' + assert (l >= 0).all(), 'negative labels' + assert (l[:, 1:] <= 1).all( + ), 'non-normalized or out of bounds coordinate labels' + assert np.unique( + l, axis=0).shape[0] == l.shape[0], 'duplicate labels' + else: + ne += 1 # label empty + l = np.zeros((0, 5), dtype=np.float32) + else: + nm += 1 # label missing + l = np.zeros((0, 5), dtype=np.float32) + x[im_file] = [l, shape, segments] + except Exception as e: + nc += 1 + print( + f'{prefix}WARNING: Ignoring corrupted image and/or label {im_file}: {e}') + + pbar.desc = f"{prefix}Scanning '{path.parent / path.stem}' images and labels... " \ + f"{nf} found, {nm} missing, {ne} empty, {nc} corrupted" + pbar.close() + + if nf == 0: + print(f'{prefix}WARNING: No labels found in {path}. See {help_url}') + + x['hash'] = get_hash(self.label_files + self.img_files) + x['results'] = nf, nm, ne, nc, i + 1 + x['version'] = 0.1 # cache version + torch.save(x, path) # save for next time + logging.info(f'{prefix}New cache created: {path}') + return x + + def __len__(self): + return len(self.img_files) + + # def __iter__(self): + # self.count = -1 + # print('ran dataset iter') + # #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF) + # return self + + def __getitem__(self, index): + index = self.indices[index] # linear, shuffled, or image_weights + + hyp = self.hyp + mosaic = self.mosaic and random.random() < hyp['mosaic'] + if mosaic: + # Load mosaic + if random.random() < 0.8: + img, labels = load_mosaic(self, index) + else: + img, labels = load_mosaic9(self, index) + shapes = None + + # MixUp https://arxiv.org/pdf/1710.09412.pdf + if random.random() < hyp['mixup']: + if random.random() < 0.8: + img2, labels2 = load_mosaic( + self, random.randint(0, len(self.labels) - 1)) + else: + img2, labels2 = load_mosaic9( + self, random.randint(0, len(self.labels) - 1)) + r = np.random.beta(8.0, 8.0) # mixup ratio, alpha=beta=8.0 + img = (img * r + img2 * (1 - r)).astype(np.uint8) + labels = np.concatenate((labels, labels2), 0) + + else: + # Load image + img, (h0, w0), (h, w) = load_image(self, index) + + # Letterbox + # final letterboxed shape + shape = self.batch_shapes[self.batch[index] + ] if self.rect else self.img_size + img, ratio, pad = letterbox( + img, shape, auto=False, scaleup=self.augment) + # for COCO mAP rescaling + shapes = (h0, w0), ((h / h0, w / w0), pad) + + labels = self.labels[index].copy() + if labels.size: # normalized xywh to pixel xyxy format + labels[:, 1:] = xywhn2xyxy( + labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1]) + + if self.augment: + # Augment imagespace + if not mosaic: + img, labels = random_perspective(img, labels, + degrees=hyp['degrees'], + translate=hyp['translate'], + scale=hyp['scale'], + shear=hyp['shear'], + perspective=hyp['perspective']) + + #img, labels = self.albumentations(img, labels) + + # Augment colorspace + augment_hsv(img, hgain=hyp['hsv_h'], + sgain=hyp['hsv_s'], vgain=hyp['hsv_v']) + + # Apply cutouts + # if random.random() < 0.9: + # labels = cutout(img, labels) + + if random.random() < hyp['paste_in']: + sample_labels, sample_images, sample_masks = [], [], [] + while len(sample_labels) < 30: + sample_labels_, sample_images_, sample_masks_ = load_samples( + self, random.randint(0, len(self.labels) - 1)) + sample_labels += sample_labels_ + sample_images += sample_images_ + sample_masks += sample_masks_ + # print(len(sample_labels)) + if len(sample_labels) == 0: + break + labels = pastein(img, labels, sample_labels, + sample_images, sample_masks) + + nL = len(labels) # number of labels + if nL: + labels[:, 1:5] = xyxy2xywh(labels[:, 1:5]) # convert xyxy to xywh + labels[:, [2, 4]] /= img.shape[0] # normalized height 0-1 + labels[:, [1, 3]] /= img.shape[1] # normalized width 0-1 + + if self.augment: + # flip up-down + if random.random() < hyp['flipud']: + img = np.flipud(img) + if nL: + labels[:, 2] = 1 - labels[:, 2] + + # flip left-right + if random.random() < hyp['fliplr']: + img = np.fliplr(img) + if nL: + labels[:, 1] = 1 - labels[:, 1] + + labels_out = torch.zeros((nL, 6)) + if nL: + labels_out[:, 1:] = torch.from_numpy(labels) + + # Convert + img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 + img = np.ascontiguousarray(img) + + return torch.from_numpy(img), labels_out, self.img_files[index], shapes + + @staticmethod + def collate_fn(batch): + img, label, path, shapes = zip(*batch) # transposed + for i, l in enumerate(label): + l[:, 0] = i # add target image index for build_targets() + return torch.stack(img, 0), torch.cat(label, 0), path, shapes + + @staticmethod + def collate_fn4(batch): + img, label, path, shapes = zip(*batch) # transposed + n = len(shapes) // 4 + img4, label4, path4, shapes4 = [], [], path[:n], shapes[:n] + + ho = torch.tensor([[0., 0, 0, 1, 0, 0]]) + wo = torch.tensor([[0., 0, 1, 0, 0, 0]]) + s = torch.tensor([[1, 1, .5, .5, .5, .5]]) # scale + for i in range(n): # zidane torch.zeros(16,3,720,1280) # BCHW + i *= 4 + if random.random() < 0.5: + im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2., mode='bilinear', align_corners=False)[ + 0].type(img[i].type()) + l = label[i] + else: + im = torch.cat( + (torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2) + l = torch.cat( + (label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s + img4.append(im) + label4.append(l) + + for i, l in enumerate(label4): + l[:, 0] = i # add target image index for build_targets() + + return torch.stack(img4, 0), torch.cat(label4, 0), path4, shapes4 + + +class YoloV7Dataset(ptq_api_dataset.Dataset): + def __init__(self, path, batch_size, shuffle): + super().__init__(batch_size, shuffle) + print("Path to dataset", path) + self.load_images = LoadImagesAndLabels(path) + + def __getitem__(self, item): + img, _, _, _ = self.load_images[item] + # Input should be in [0,1]. + img = (1 / 255.) * img + return {"images": ONNXNNCFTensor(img.numpy())} + + def __len__(self): + return len(self.load_images) + + +############################################################### +# Quantization Process --> main() +############################################################### + +def main(arg): + dataset = YoloV7Dataset(arg.data, 1, True) + + original_model = onnx.load(arg.input_model) + num_init_samples = len( + dataset) if args.sample_size == -1 else args.sample_size + # We'll ignore detector head not to quantize them + ignored_scopes = [ + # Head branch 1 + "Mul_217", + "Add_219", + "Mul_221", + "Mul_223", + "Mul_227", + # Head branch 2 + "Mul_251", + "Add_253", + "Mul_255", + "Mul_257", + "Mul_261", + # Head branch 3 + "Mul_285", + "Add_287", + "Mul_289", + "Mul_291", + "Mul_295", + ] + + output_model_path = arg.input_model.split('.')[0] + "-quantized.onnx" + + # Step 1: Create a pipeline of compression algorithms. + + builder = CompressionBuilder() + + # Step 2: Create the quantization algorithm and add to the builder. + + quantization_parameters = PostTrainingQuantizationParameters( + number_samples=num_init_samples, + ignored_scopes=ignored_scopes + ) + quantization = PostTrainingQuantization(quantization_parameters) + builder.add_algorithm(quantization) + + # Step 3: Execute the pipeline. + + nncf_logger.info("Post-Training Quantization has just started!") + quantized_model = builder.apply(original_model, dataset) + + # Step 4: Save the quantized model. + + onnx.save(quantized_model, output_model_path) + nncf_logger.info( + "The quantized model is saved on {}".format(output_model_path)) + + onnx.checker.check_model(output_model_path) + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument('--data', type=str, + help='data path') + parser.add_argument('--input-model', type=str, + help='model path') + parser.add_argument('--sample-size', type=int, + default=-1, + help='model path') + + args = parser.parse_args() + main(args) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py new file mode 100644 index 000000000..06bad1825 --- /dev/null +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py @@ -0,0 +1,217 @@ +import argparse +import logging +import os +import random +import sys +import time +import warnings + +import cv2 +import matplotlib.pyplot as plt +import numpy as np +import onnxruntime +from PIL import Image + +warnings.filterwarnings(action="ignore") + + +# Inference for ONNX model +def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32): + # Resize and pad image while meeting stride-multiple constraints + shape = im.shape[:2] # current shape [height, width] + if isinstance(new_shape, int): + new_shape = (new_shape, new_shape) + + # Scale ratio (new / old) + r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) + if not scaleup: # only scale down, do not scale up (for better val mAP) + r = min(r, 1.0) + + # Compute padding + new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) + dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - \ + new_unpad[1] # wh padding + + if auto: # minimum rectangle + dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding + + dw /= 2 # divide padding into 2 sides + dh /= 2 + + if shape[::-1] != new_unpad: # resize + im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR) + top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) + left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) + im = cv2.copyMakeBorder(im, top, bottom, left, right, + cv2.BORDER_CONSTANT, value=color) # add border + return im, r, (dw, dh) + + +random.seed(42) +names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', + 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', + 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', + 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', + 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', + 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', + 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', + 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', + 'hair drier', 'toothbrush'] +colors = {name: [random.randint(0, 255) for _ in range(3)] + for i, name in enumerate(names)} + + +def set_logging(rank=-1): + logging.basicConfig( + format="%(message)s", + level=logging.INFO if rank in [-1, 0] else logging.WARN) + + +set_logging(0) # run before defining LOGGER +LOGGER = logging.getLogger("yolov7") + + +def preProcess_image(image): + image, ratio, dwdh = letterbox(image, auto=False) + image = image.transpose((2, 0, 1)) + image = np.expand_dims(image, 0) + image = np.ascontiguousarray(image) + + im = image.astype(np.float32) + im /= 255 + + return im, ratio, dwdh + + +def create_session(model_path, device='CPU_FP32'): + + if device == 'CPU_FP32': + providers = ['OpenVINOExecutionProvider'] + elif device == 'cpu': + providers = ['CPUExecutionProvider'] + else: + LOGGER.info(f'No provider passed, using default CPU EP ...') + providers = ['CPUExecutionProvider'] + + LOGGER.info(f'Use ORT providers: {providers}') + sess = onnxruntime.InferenceSession(model_path, + providers=providers, + provider_options=[{'device_type': device}]) + + outname = [i.name for i in sess.get_outputs()] + inname = [i.name for i in sess.get_inputs()] + + return sess, outname, inname + + +def main(args): + + model_name = args.model.split('.')[0] + + if (args.image): + # Open the image file + if not os.path.isfile(args.image): + print("Input image file ", args.image, " doesn't exist") + sys.exit(1) + cap = cv2.VideoCapture(args.image) + output_file = args.image[:-4]+f'_{model_name}_{args.device}.jpg' + elif (args.video): + # Open the video file + if not os.path.isfile(args.video): + print("Input video file ", args.video, " doesn't exist") + sys.exit(1) + cap = cv2.VideoCapture(args.video) + output_file = args.video[:-4]+f'_{model_name}_{args.device}.avi' + else: + # Webcam input + cap = cv2.VideoCapture(0) + + # Get the video writer initialized to save the output video + if (not args.image): + vid_writer = cv2.VideoWriter(output_file, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, (round( + cap.get(cv2.CAP_PROP_FRAME_WIDTH)), round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))) + + sess, outputs, inputs = create_session(args.model, args.device) + + while cv2.waitKey(1) < 0: + # get frame from the video + has_frame, frame = cap.read() + # Stop the program if reached end of video + if not has_frame: + print("Done processing !!!") + print("Output file is stored as ", output_file) + has_frame = False + # cv2.waitKey(3000) + # Release device + cap.release() + break + + original_image = frame + original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) + # original_image_size = original_image.shape[:2] + + image_data, proces_ratio, dwdh = preProcess_image( + original_image.copy()) + + inp = {inputs[0]: image_data} + start = time.time() + pred = sess.run(outputs, inp)[0] + end = time.time() + inference_time = end - start + + original_image = [original_image] + image = original_image[0] + if pred.any(): + for i, (batch_id, x0, y0, x1, y1, cls_id, score) in enumerate(pred): + image = original_image[int(batch_id)] + box = np.array([x0, y0, x1, y1]) + box -= np.array(dwdh*2) + box /= proces_ratio + box = box.round().astype(np.int32).tolist() + cls_id = int(cls_id) + + score = round(float(score), 3) + name = names[cls_id] + color = colors[name] + name += ' '+str(score) + cv2.rectangle(image, box[:2], box[2:], color, 2) + cv2.putText(image, name, (box[0], box[1] - 2), + cv2.FONT_HERSHEY_SIMPLEX, 0.45, [225, 255, 255], thickness=1) + cv2.putText(image, 'FPS: {:.8f}'.format(1.0 / inference_time), + (10, 40), cv2.FONT_HERSHEY_COMPLEX, 0.45, (255, 255, 255), 0) + + # Write the frame with the detection boxes + if (args.image): + cv2.imwrite(output_file, cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) + print(f"saving image..{output_file}") + else: + vid_writer.write(image.astype(np.uint8)) + + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + if args.view_img: + win_name = "test_yolov7" + cv2.imshow(win_name, image) + + +def parse_arguments(): + parser = argparse.ArgumentParser( + description='Object Detection using YOLOv7 in OPENCV using OpenVINO Execution Provider for ONNXRuntime') + parser.add_argument('--device', default='CPU_FP32', + help="Device to perform inference on 'cpu (MLAS)' or on devices supported by OpenVINO-EP [CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VAD-M_FP16].") + parser.add_argument('--image', + help='Path to image file.') + parser.add_argument('--video', default="person-bicycle-car-detection.mp4", help='Path to video file.') + parser.add_argument('--model', default="notebooks/yolov7-tiny.onnx", + help='Path to model.') + + parser.add_argument('--view-img', action="store_true", + help='Path to model.') + + args = parser.parse_args() + return args + + +if __name__ == "__main__": + + args = parse_arguments() + main(args) From 9cc8cac2619d69011bd21440a6116f48a6d9b196 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Thu, 22 Sep 2022 11:39:27 +0530 Subject: [PATCH 12/15] yolov7 sample inital 0.02 --- python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md | 2 +- .../notebooks/OVEP_yoloV7-tiny_object_detection.ipynb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index e1fe78609..c680d7f84 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -42,7 +42,7 @@ The models are to be exported using the export script present in the yolov7 repo ``` $ wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt ``` -Export Model using the below command. (As mentioned in the official public [repo](https://github.com/WongKinYiu/yolov7#export).) +Export Model using the below command. (As mentioned in the official public [repo](https://github.com/WongKinYiu/yolov7#export).) **Note: Adjust the values of `iou-thres` and `conf-thres` while exporting to get better bounding boxes.** ``` $ python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640 diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index 71069971f..ee4a9d58f 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -82,7 +82,7 @@ " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", "```\n", - "\n", + " \n", "**Note: Adjust the values of `iou-thres` and `conf-thres` according to requirements.**" ] }, From 41afc255768435ac8ea82270c91341e87bdb8bd3 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Tue, 27 Sep 2022 12:00:35 +0530 Subject: [PATCH 13/15] Notebook Sample update --- .../README.md | 61 +- .../OVEP_yoloV7-tiny_object_detection.ipynb | 23 - .../ptq_yolov7.py | 1092 ----------------- .../yolov7.py | 217 ---- 4 files changed, 13 insertions(+), 1380 deletions(-) delete mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py delete mode 100644 python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index c680d7f84..cc0e5dcfa 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -8,14 +8,12 @@ $ python3 -m venv yv7-pyenv $ source yv7-pyenv/bin/activate $ pip install --upgrade pip ``` - ### Conda If system python3 version is < 3.8 it's recommended to either upgrade to python3.8 or use create virtual environment python3.8 using conda. ``` $ conda create -n yolov7 python=3.8 $ conda activate yolov7 ``` - ## Install required packages After creating and activating virtual environment, install the required packages: @@ -26,59 +24,26 @@ $ cd nncf && python setup.py install --onnx $ pip install --no-cache-dir onnxconverter_common onnxruntime-openvino==1.11.0 $ cd .. && rm -fR nncf ``` + ### YoloV7 requirements ``` -$ cd notebooks && git clone https://github.com/WongKinYiu/yolov7 +$ cd notebooks +$ git clone https://github.com/WongKinYiu/yolov7 $ cp -R yolov7/* . $ pip install --no-cache-dir -r requirements.txt $ rm -fR yolov7 ``` +Launch the notebook from here. +## Dataset +The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. -# Steps to perform NNCF Quantization for YoloV7 - -## Export Model to onnx -The models are to be exported using the export script present in the yolov7 repo. Download desired yolov7 model from [here](https://github.com/WongKinYiu/yolov7/releases). -``` -$ wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt -``` -Export Model using the below command. (As mentioned in the official public [repo](https://github.com/WongKinYiu/yolov7#export).) -**Note: Adjust the values of `iou-thres` and `conf-thres` while exporting to get better bounding boxes.** -``` -$ python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640 -``` - -## Download Data -``` -$ cd .. && wget -O tmp.zip 'https://ultralytics.com/assets/coco2017val.zip' -$ unzip -q tmp.zip -d datasets && rm tmp.zip -``` - +## Outputs -## Quantization - -The quantization script is specific to yolov7 model. All the dependencies (helper functions & loader objects, taken from the public [repo](https://github.com/WongKinYiu/yolov7/)) are present within the `ptq_yolov7.py` script. - -``` -python ptq_yolov7.py --data datasets/coco/images/val2017 \ - --input-model notebooks/yolov7-tiny.onnx \ - --sample-size 100 -``` - -## Run Inference - -### Run the sample on default CPU Execution Provider (MLAS) -``` -$ python3 yolov7.py --device cpu --video classroom.mp4 --model -``` -### Run the sample with video as Input -``` -$ python3 yolov7.py --device CPU_FP32 --video classroom.mp4 --model -``` -### Run the sample with Image as Input -``` -$ python3 yolov7.py --device CPU_FP32 --image cat.jpg --model -``` +- `yolov7-tiny.onnx` +- `yolov7-tiny-quantized.onnx` +- `cat-yolov7-detected.jpg` -### Run inference using notebook -Install jupyter notebook in the corresponding env and run the notebook present in the notebooks directory. \ No newline at end of file +## References +### [ONNX Rruntime](https://onnxruntime.ai/docs/install/) +### [NNCF](https://github.com/openvinotoolkit/nncf/tree/develop) \ No newline at end of file diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index ee4a9d58f..ec1df5275 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -560,13 +560,6 @@ "## Run Inference on INT-8 model" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inference using CPU Execution Provider (MLAS)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -578,22 +571,6 @@ "num_iters = 100" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "params = {\"model_path\": model_path,\n", - " \"img_input\": img_path,\n", - " \"device\":'cpu',\n", - " \"num_runs\": num_iters}\n", - "\n", - "run_inference(**params)" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py deleted file mode 100644 index 7de019ef0..000000000 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/ptq_yolov7.py +++ /dev/null @@ -1,1092 +0,0 @@ -import argparse -import glob -import logging -import math -import os -import random -from itertools import repeat -from multiprocessing.pool import ThreadPool -from pathlib import Path - -import cv2 -import numpy as np -import onnx -import torch -import torch.nn.functional as F -from tqdm import tqdm -from nncf.common.utils.logger import logger as nncf_logger -from nncf.experimental.onnx.tensor import ONNXNNCFTensor -from nncf.experimental.post_training.algorithms.quantization import ( - PostTrainingQuantization, PostTrainingQuantizationParameters) -from nncf.experimental.post_training.api import dataset as ptq_api_dataset -from nncf.experimental.post_training.compression_builder import \ - CompressionBuilder -from PIL import ExifTags, Image -from torch.utils.data import Dataset - -# from utils.datasets import LoadImagesAndLabels -help_url = 'https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data' -img_formats = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', - 'dng', 'webp', 'mpo'] # acceptable image suffixes -vid_formats = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', - 'm4v', 'wmv', 'mkv'] # acceptable video suffixes -logger = logging.getLogger(__name__) - -# Get orientation exif tag -for orientation in ExifTags.TAGS.keys(): - if ExifTags.TAGS[orientation] == 'Orientation': - break - - -def bbox_ioa(box1, box2): - # Returns the intersection over box2 area given box1, box2. box1 is 4, box2 is nx4. boxes are x1y1x2y2 - box2 = box2.transpose() - - # Get the coordinates of bounding boxes - b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3] - b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3] - - # Intersection area - inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \ - (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0) - - # box2 area - box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + 1e-16 - - # Intersection over box2 area - return inter_area / box2_area - - -def copy_paste(img, labels, segments, probability=0.5): - # Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy) - n = len(segments) - if probability and n: - h, w, c = img.shape # height, width, channels - im_new = np.zeros(img.shape, np.uint8) - for j in random.sample(range(n), k=round(probability * n)): - l, s = labels[j], segments[j] - box = w - l[3], l[2], w - l[1], l[4] - ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area - if (ioa < 0.30).all(): # allow 30% obscuration of existing labels - labels = np.concatenate((labels, [[l[0], *box]]), 0) - segments.append(np.concatenate((w - s[:, 0:1], s[:, 1:2]), 1)) - cv2.drawContours(im_new, [segments[j].astype( - np.int32)], -1, (255, 255, 255), cv2.FILLED) - - result = cv2.bitwise_and(src1=img, src2=im_new) - result = cv2.flip(result, 1) # augment segments (flip left-right) - i = result > 0 # pixels to replace - # i[:, :] = result.max(2).reshape(h, w, 1) # act over ch - img[i] = result[i] # cv2.imwrite('debug.jpg', img) # debug - - return img, labels, segments - - -def get_hash(files): - # Returns a single hash value of a list of files - return sum(os.path.getsize(f) for f in files if os.path.isfile(f)) - - -def xyxy2xywh(x): - # Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right - y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) - y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center - y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center - y[:, 2] = x[:, 2] - x[:, 0] # width - y[:, 3] = x[:, 3] - x[:, 1] # height - return y - - -def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0): - # Convert nx4 boxes from [x, y, w, h] normalized to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right - y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) - y[:, 0] = w * (x[:, 0] - x[:, 2] / 2) + padw # top left x - y[:, 1] = h * (x[:, 1] - x[:, 3] / 2) + padh # top left y - y[:, 2] = w * (x[:, 0] + x[:, 2] / 2) + padw # bottom right x - y[:, 3] = h * (x[:, 1] + x[:, 3] / 2) + padh # bottom right y - return y - - -def xyn2xy(x, w=640, h=640, padw=0, padh=0): - # Convert normalized segments into pixel segments, shape (n,2) - y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) - y[:, 0] = w * x[:, 0] + padw # top left x - y[:, 1] = h * x[:, 1] + padh # top left y - return y - - -def segment2box(segment, width=640, height=640): - # Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy) - x, y = segment.T # segment xy - inside = (x >= 0) & (y >= 0) & (x <= width) & (y <= height) - x, y, = x[inside], y[inside] - # xyxy - return np.array([x.min(), y.min(), x.max(), y.max()]) if any(x) else np.zeros((1, 4)) - - -def sample_segments(img, labels, segments, probability=0.5): - # Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy) - n = len(segments) - sample_labels = [] - sample_images = [] - sample_masks = [] - if probability and n: - h, w, c = img.shape # height, width, channels - for j in random.sample(range(n), k=round(probability * n)): - l, s = labels[j], segments[j] - box = l[1].astype(int).clip(0, w-1), l[2].astype(int).clip(0, h - - 1), l[3].astype(int).clip(0, w-1), l[4].astype(int).clip(0, h-1) - - # print(box) - if (box[2] <= box[0]) or (box[3] <= box[1]): - continue - - sample_labels.append(l[0]) - - mask = np.zeros(img.shape, np.uint8) - - cv2.drawContours(mask, [segments[j].astype( - np.int32)], -1, (255, 255, 255), cv2.FILLED) - sample_masks.append(mask[box[1]:box[3], box[0]:box[2], :]) - - result = cv2.bitwise_and(src1=img, src2=mask) - i = result > 0 # pixels to replace - mask[i] = result[i] # cv2.imwrite('debug.jpg', img) # debug - # print(box) - sample_images.append(mask[box[1]:box[3], box[0]:box[2], :]) - - return sample_labels, sample_images, sample_masks - - -def load_samples(self, index): - # loads images in a 4-mosaic - - labels4, segments4 = [], [] - s = self.img_size - yc, xc = [int(random.uniform(-x, 2 * s + x)) - for x in self.mosaic_border] # mosaic center x, y - # 3 additional image indices - indices = [index] + random.choices(self.indices, k=3) - for i, index in enumerate(indices): - # Load image - img, _, (h, w) = load_image(self, index) - - # place img in img4 - if i == 0: # top left - # base image with 4 tiles - img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) - # xmin, ymin, xmax, ymax (large image) - x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc - # xmin, ymin, xmax, ymax (small image) - x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h - elif i == 1: # top right - x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc - x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h - elif i == 2: # bottom left - x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) - x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h) - elif i == 3: # bottom right - x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) - x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) - - # img4[ymin:ymax, xmin:xmax] - img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] - padw = x1a - x1b - padh = y1a - y1b - - # Labels - labels, segments = self.labels[index].copy( - ), self.segments[index].copy() - if labels.size: - # normalized xywh to pixel xyxy format - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) - segments = [xyn2xy(x, w, h, padw, padh) for x in segments] - labels4.append(labels) - segments4.extend(segments) - - # Concat/clip labels - labels4 = np.concatenate(labels4, 0) - for x in (labels4[:, 1:], *segments4): - np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() - # img4, labels4 = replicate(img4, labels4) # replicate - - # Augment - #img4, labels4, segments4 = remove_background(img4, labels4, segments4) - sample_labels, sample_images, sample_masks = sample_segments( - img4, labels4, segments4, probability=0.5) - - return sample_labels, sample_images, sample_masks - - -def resample_segments(segments, n=1000): - # Up-sample an (n,2) segment - for i, s in enumerate(segments): - s = np.concatenate((s, s[0:1, :]), axis=0) - x = np.linspace(0, len(s) - 1, n) - xp = np.arange(len(s)) - segments[i] = np.concatenate( - [np.interp(x, xp, s[:, i]) for i in range(2)]).reshape(2, -1).T # segment xy - return segments - - -def box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.1, eps=1e-16): # box1(4,n), box2(4,n) - # Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio - w1, h1 = box1[2] - box1[0], box1[3] - box1[1] - w2, h2 = box2[2] - box2[0], box2[3] - box2[1] - ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio - # candidates - return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) - - -def random_perspective(img, targets=(), segments=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0, - border=(0, 0)): - # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10)) - # targets = [cls, xyxy] - - height = img.shape[0] + border[0] * 2 # shape(h,w,c) - width = img.shape[1] + border[1] * 2 - - # Center - C = np.eye(3) - C[0, 2] = -img.shape[1] / 2 # x translation (pixels) - C[1, 2] = -img.shape[0] / 2 # y translation (pixels) - - # Perspective - P = np.eye(3) - # x perspective (about y) - P[2, 0] = random.uniform(-perspective, perspective) - # y perspective (about x) - P[2, 1] = random.uniform(-perspective, perspective) - - # Rotation and Scale - R = np.eye(3) - a = random.uniform(-degrees, degrees) - # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations - s = random.uniform(1 - scale, 1.1 + scale) - # s = 2 ** random.uniform(-scale, scale) - R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s) - - # Shear - S = np.eye(3) - S[0, 1] = math.tan(random.uniform(-shear, shear) * - math.pi / 180) # x shear (deg) - S[1, 0] = math.tan(random.uniform(-shear, shear) * - math.pi / 180) # y shear (deg) - - # Translation - T = np.eye(3) - T[0, 2] = random.uniform(0.5 - translate, 0.5 + - translate) * width # x translation (pixels) - T[1, 2] = random.uniform(0.5 - translate, 0.5 + - translate) * height # y translation (pixels) - - # Combined rotation matrix - M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT - if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed - if perspective: - img = cv2.warpPerspective(img, M, dsize=( - width, height), borderValue=(114, 114, 114)) - else: # affine - img = cv2.warpAffine(img, M[:2], dsize=( - width, height), borderValue=(114, 114, 114)) - - # Visualize - # import matplotlib.pyplot as plt - # ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel() - # ax[0].imshow(img[:, :, ::-1]) # base - # ax[1].imshow(img2[:, :, ::-1]) # warped - - # Transform label coordinates - n = len(targets) - if n: - use_segments = any(x.any() for x in segments) - new = np.zeros((n, 4)) - if use_segments: # warp segments - segments = resample_segments(segments) # upsample - for i, segment in enumerate(segments): - xy = np.ones((len(segment), 3)) - xy[:, :2] = segment - xy = xy @ M.T # transform - # perspective rescale or affine - xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] - - # clip - new[i] = segment2box(xy, width, height) - - else: # warp boxes - xy = np.ones((n * 4, 3)) - xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape( - n * 4, 2) # x1y1, x2y2, x1y2, x2y1 - xy = xy @ M.T # transform - xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] - ).reshape(n, 8) # perspective rescale or affine - - # create new boxes - x = xy[:, [0, 2, 4, 6]] - y = xy[:, [1, 3, 5, 7]] - new = np.concatenate( - (x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T - - # clip - new[:, [0, 2]] = new[:, [0, 2]].clip(0, width) - new[:, [1, 3]] = new[:, [1, 3]].clip(0, height) - - # filter candidates - i = box_candidates( - box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10) - targets = targets[i] - targets[:, 1:5] = new[i] - - return img, targets - - -def segments2boxes(segments): - # Convert segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh) - boxes = [] - for s in segments: - x, y = s.T # segment xy - boxes.append([x.min(), y.min(), x.max(), y.max()]) # cls, xyxy - return xyxy2xywh(np.array(boxes)) # cls, xywh - - -def img2label_paths(img_paths): - # Define label paths as a function of image paths - sa, sb = os.sep + 'images' + os.sep, os.sep + \ - 'labels' + os.sep # /images/, /labels/ substrings - return ['txt'.join(x.replace(sa, sb, 1).rsplit(x.split('.')[-1], 1)) for x in img_paths] - - -def load_mosaic(self, index): - # loads images in a 4-mosaic - - labels4, segments4 = [], [] - s = self.img_size - yc, xc = [int(random.uniform(-x, 2 * s + x)) - for x in self.mosaic_border] # mosaic center x, y - # 3 additional image indices - indices = [index] + random.choices(self.indices, k=3) - for i, index in enumerate(indices): - # Load image - img, _, (h, w) = load_image(self, index) - - # place img in img4 - if i == 0: # top left - # base image with 4 tiles - img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) - # xmin, ymin, xmax, ymax (large image) - x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc - # xmin, ymin, xmax, ymax (small image) - x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h - elif i == 1: # top right - x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc - x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h - elif i == 2: # bottom left - x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) - x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h) - elif i == 3: # bottom right - x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) - x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) - - # img4[ymin:ymax, xmin:xmax] - img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] - padw = x1a - x1b - padh = y1a - y1b - - # Labels - labels, segments = self.labels[index].copy( - ), self.segments[index].copy() - if labels.size: - # normalized xywh to pixel xyxy format - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) - segments = [xyn2xy(x, w, h, padw, padh) for x in segments] - labels4.append(labels) - segments4.extend(segments) - - # Concat/clip labels - labels4 = np.concatenate(labels4, 0) - for x in (labels4[:, 1:], *segments4): - np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() - # img4, labels4 = replicate(img4, labels4) # replicate - - # Augment - #img4, labels4, segments4 = remove_background(img4, labels4, segments4) - #sample_segments(img4, labels4, segments4, probability=self.hyp['copy_paste']) - img4, labels4, segments4 = copy_paste( - img4, labels4, segments4, probability=self.hyp['copy_paste']) - img4, labels4 = random_perspective(img4, labels4, segments4, - degrees=self.hyp['degrees'], - translate=self.hyp['translate'], - scale=self.hyp['scale'], - shear=self.hyp['shear'], - perspective=self.hyp['perspective'], - border=self.mosaic_border) # border to remove - - return img4, labels4 - - -def load_mosaic9(self, index): - # loads images in a 9-mosaic - - labels9, segments9 = [], [] - s = self.img_size - # 8 additional image indices - indices = [index] + random.choices(self.indices, k=8) - for i, index in enumerate(indices): - # Load image - img, _, (h, w) = load_image(self, index) - - # place img in img9 - if i == 0: # center - # base image with 4 tiles - img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) - h0, w0 = h, w - c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates - elif i == 1: # top - c = s, s - h, s + w, s - elif i == 2: # top right - c = s + wp, s - h, s + wp + w, s - elif i == 3: # right - c = s + w0, s, s + w0 + w, s + h - elif i == 4: # bottom right - c = s + w0, s + hp, s + w0 + w, s + hp + h - elif i == 5: # bottom - c = s + w0 - w, s + h0, s + w0, s + h0 + h - elif i == 6: # bottom left - c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h - elif i == 7: # left - c = s - w, s + h0 - h, s, s + h0 - elif i == 8: # top left - c = s - w, s + h0 - hp - h, s, s + h0 - hp - - padx, pady = c[:2] - x1, y1, x2, y2 = [max(x, 0) for x in c] # allocate coords - - # Labels - labels, segments = self.labels[index].copy( - ), self.segments[index].copy() - if labels.size: - # normalized xywh to pixel xyxy format - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady) - segments = [xyn2xy(x, w, h, padx, pady) for x in segments] - labels9.append(labels) - segments9.extend(segments) - - # Image - # img9[ymin:ymax, xmin:xmax] - img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:] - hp, wp = h, w # height, width previous - - # Offset - yc, xc = [int(random.uniform(0, s)) - for _ in self.mosaic_border] # mosaic center x, y - img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s] - - # Concat/clip labels - labels9 = np.concatenate(labels9, 0) - labels9[:, [1, 3]] -= xc - labels9[:, [2, 4]] -= yc - c = np.array([xc, yc]) # centers - segments9 = [x - c for x in segments9] - - for x in (labels9[:, 1:], *segments9): - np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() - # img9, labels9 = replicate(img9, labels9) # replicate - - # Augment - #img9, labels9, segments9 = remove_background(img9, labels9, segments9) - img9, labels9, segments9 = copy_paste( - img9, labels9, segments9, probability=self.hyp['copy_paste']) - img9, labels9 = random_perspective(img9, labels9, segments9, - degrees=self.hyp['degrees'], - translate=self.hyp['translate'], - scale=self.hyp['scale'], - shear=self.hyp['shear'], - perspective=self.hyp['perspective'], - border=self.mosaic_border) # border to remove - - return img9, labels9 - - -def load_image(self, index): - # loads 1 image from dataset, returns img, original hw, resized hw - img = self.imgs[index] - if img is None: # not cached - path = self.img_files[index] - img = cv2.imread(path) # BGR - assert img is not None, 'Image Not Found ' + path - h0, w0 = img.shape[:2] # orig hw - r = self.img_size / max(h0, w0) # resize image to img_size - if r != 1: # always resize down, only resize up if training with augmentation - interp = cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR - img = cv2.resize(img, (int(w0 * r), int(h0 * r)), - interpolation=interp) - return img, (h0, w0), img.shape[:2] # img, hw_original, hw_resized - else: - # img, hw_original, hw_resized - return self.imgs[index], self.img_hw0[index], self.img_hw[index] - - -def exif_size(img): - # Returns exif-corrected PIL size - s = img.size # (width, height) - try: - rotation = dict(img._getexif().items())[orientation] - if rotation == 6: # rotation 270 - s = (s[1], s[0]) - elif rotation == 8: # rotation 90 - s = (s[1], s[0]) - except: - pass - - return s - - -def letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32): - # Resize and pad image while meeting stride-multiple constraints - shape = img.shape[:2] # current shape [height, width] - if isinstance(new_shape, int): - new_shape = (new_shape, new_shape) - - # Scale ratio (new / old) - r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) - if not scaleup: # only scale down, do not scale up (for better test mAP) - r = min(r, 1.0) - - # Compute padding - ratio = r, r # width, height ratios - new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) - dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - \ - new_unpad[1] # wh padding - if auto: # minimum rectangle - dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding - elif scaleFill: # stretch - dw, dh = 0.0, 0.0 - new_unpad = (new_shape[1], new_shape[0]) - ratio = new_shape[1] / shape[1], new_shape[0] / \ - shape[0] # width, height ratios - - dw /= 2 # divide padding into 2 sides - dh /= 2 - - if shape[::-1] != new_unpad: # resize - img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR) - top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) - left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) - img = cv2.copyMakeBorder( - img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border - return img, ratio, (dw, dh) - - -def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5): - r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains - hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV)) - dtype = img.dtype # uint8 - - x = np.arange(0, 256, dtype=np.int16) - lut_hue = ((x * r[0]) % 180).astype(dtype) - lut_sat = np.clip(x * r[1], 0, 255).astype(dtype) - lut_val = np.clip(x * r[2], 0, 255).astype(dtype) - - img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT( - sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype) - cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed - - -def pastein(image, labels, sample_labels, sample_images, sample_masks): - # Applies image cutout augmentation https://arxiv.org/abs/1708.04552 - h, w = image.shape[:2] - - # create random masks - scales = [0.75] * 2 + [0.5] * 4 + [0.25] * 4 + \ - [0.125] * 4 + [0.0625] * 6 # image size fraction - for s in scales: - if random.random() < 0.2: - continue - mask_h = random.randint(1, int(h * s)) - mask_w = random.randint(1, int(w * s)) - - # box - xmin = max(0, random.randint(0, w) - mask_w // 2) - ymin = max(0, random.randint(0, h) - mask_h // 2) - xmax = min(w, xmin + mask_w) - ymax = min(h, ymin + mask_h) - - box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32) - if len(labels): - ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area - else: - ioa = np.zeros(1) - - # allow 30% obscuration of existing labels - if (ioa < 0.30).all() and len(sample_labels) and (xmax > xmin+20) and (ymax > ymin+20): - sel_ind = random.randint(0, len(sample_labels)-1) - # print(len(sample_labels)) - # print(sel_ind) - #print((xmax-xmin, ymax-ymin)) - #print(image[ymin:ymax, xmin:xmax].shape) - #print([[sample_labels[sel_ind], *box]]) - # print(labels.shape) - hs, ws, cs = sample_images[sel_ind].shape - r_scale = min((ymax-ymin)/hs, (xmax-xmin)/ws) - r_w = int(ws*r_scale) - r_h = int(hs*r_scale) - - if (r_w > 10) and (r_h > 10): - r_mask = cv2.resize(sample_masks[sel_ind], (r_w, r_h)) - r_image = cv2.resize(sample_images[sel_ind], (r_w, r_h)) - temp_crop = image[ymin:ymin+r_h, xmin:xmin+r_w] - m_ind = r_mask > 0 - if m_ind.astype(np.int).sum() > 60: - temp_crop[m_ind] = r_image[m_ind] - # print(sample_labels[sel_ind]) - # print(sample_images[sel_ind].shape) - # print(temp_crop.shape) - box = np.array( - [xmin, ymin, xmin+r_w, ymin+r_h], dtype=np.float32) - if len(labels): - labels = np.concatenate( - (labels, [[sample_labels[sel_ind], *box]]), 0) - else: - labels = np.array([[sample_labels[sel_ind], *box]]) - - image[ymin:ymin+r_h, xmin:xmin+r_w] = temp_crop - - return labels - - -class LoadImagesAndLabels(Dataset): # for training/testing - def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False, - cache_images=False, single_cls=False, stride=32, pad=0.0, prefix=''): - self.img_size = img_size - self.augment = augment - self.hyp = hyp - self.image_weights = image_weights - self.rect = False if image_weights else rect - # load 4 images at a time into a mosaic (only during training) - self.mosaic = self.augment and not self.rect - self.mosaic_border = [-img_size // 2, -img_size // 2] - self.stride = stride - self.path = path - #self.albumentations = Albumentations() if augment else None - - try: - f = [] # image files - for p in path if isinstance(path, list) else [path]: - p = Path(p) # os-agnostic - if p.is_dir(): # dir - f += glob.glob(str(p / '**' / '*.*'), recursive=True) - # f = list(p.rglob('**/*.*')) # pathlib - elif p.is_file(): # file - with open(p, 'r') as t: - t = t.read().strip().splitlines() - parent = str(p.parent) + os.sep - # local to global path - f += [x.replace('./', parent) - if x.startswith('./') else x for x in t] - # f += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib) - else: - raise Exception(f'{prefix}{p} does not exist') - self.img_files = sorted( - [x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in img_formats]) - # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in img_formats]) # pathlib - assert self.img_files, f'{prefix}No images found' - except Exception as e: - raise Exception( - f'{prefix}Error loading data from {path}: {e}\nSee {help_url}') - - # Check cache - self.label_files = img2label_paths(self.img_files) # labels - cache_path = (p if p.is_file() else Path( - self.label_files[0]).parent).with_suffix('.cache') # cached labels - if cache_path.is_file(): - cache, exists = torch.load(cache_path), True # load - # if cache['hash'] != get_hash(self.label_files + self.img_files) or 'version' not in cache: # changed - # cache, exists = self.cache_labels(cache_path, prefix), False # re-cache - else: - cache, exists = self.cache_labels( - cache_path, prefix), False # cache - - # Display cache - # found, missing, empty, corrupted, total - nf, nm, ne, nc, n = cache.pop('results') - if exists: - d = f"Scanning '{cache_path}' images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupted" - # display cache results - tqdm(None, desc=prefix + d, total=n, initial=n) - assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {help_url}' - - # Read cache - cache.pop('hash') # remove hash - cache.pop('version') # remove version - labels, shapes, self.segments = zip(*cache.values()) - self.labels = list(labels) - self.shapes = np.array(shapes, dtype=np.float64) - self.img_files = list(cache.keys()) # update - self.label_files = img2label_paths(cache.keys()) # update - if single_cls: - for x in self.labels: - x[:, 0] = 0 - - n = len(shapes) # number of images - bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index - nb = bi[-1] + 1 # number of batches - self.batch = bi # batch index of image - self.n = n - self.indices = range(n) - - # Rectangular Training - if self.rect: - # Sort by aspect ratio - s = self.shapes # wh - ar = s[:, 1] / s[:, 0] # aspect ratio - irect = ar.argsort() - self.img_files = [self.img_files[i] for i in irect] - self.label_files = [self.label_files[i] for i in irect] - self.labels = [self.labels[i] for i in irect] - self.shapes = s[irect] # wh - ar = ar[irect] - - # Set training image shapes - shapes = [[1, 1]] * nb - for i in range(nb): - ari = ar[bi == i] - mini, maxi = ari.min(), ari.max() - if maxi < 1: - shapes[i] = [maxi, 1] - elif mini > 1: - shapes[i] = [1, 1 / mini] - - self.batch_shapes = np.ceil( - np.array(shapes) * img_size / stride + pad).astype(np.int) * stride - - # Cache images into memory for faster training (WARNING: large datasets may exceed system RAM) - self.imgs = [None] * n - if cache_images: - if cache_images == 'disk': - self.im_cache_dir = Path( - Path(self.img_files[0]).parent.as_posix() + '_npy') - self.img_npy = [ - self.im_cache_dir / Path(f).with_suffix('.npy').name for f in self.img_files] - self.im_cache_dir.mkdir(parents=True, exist_ok=True) - gb = 0 # Gigabytes of cached images - self.img_hw0, self.img_hw = [None] * n, [None] * n - results = ThreadPool(8).imap( - lambda x: load_image(*x), zip(repeat(self), range(n))) - pbar = tqdm(enumerate(results), total=n) - for i, x in pbar: - if cache_images == 'disk': - if not self.img_npy[i].exists(): - np.save(self.img_npy[i].as_posix(), x[0]) - gb += self.img_npy[i].stat().st_size - else: - self.imgs[i], self.img_hw0[i], self.img_hw[i] = x - gb += self.imgs[i].nbytes - pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB)' - pbar.close() - - def cache_labels(self, path=Path('./labels.cache'), prefix=''): - # Cache dataset labels, check images and read shapes - x = {} # dict - nm, nf, ne, nc = 0, 0, 0, 0 # number missing, found, empty, duplicate - pbar = tqdm(zip(self.img_files, self.label_files), - desc='Scanning images', total=len(self.img_files)) - for i, (im_file, lb_file) in enumerate(pbar): - try: - # verify images - im = Image.open(im_file) - im.verify() # PIL verify - shape = exif_size(im) # image size - segments = [] # instance segments - assert (shape[0] > 9) & ( - shape[1] > 9), f'image size {shape} <10 pixels' - assert im.format.lower( - ) in img_formats, f'invalid image format {im.format}' - - # verify labels - if os.path.isfile(lb_file): - nf += 1 # label found - with open(lb_file, 'r') as f: - l = [x.split() for x in f.read().strip().splitlines()] - if any([len(x) > 8 for x in l]): # is segment - classes = np.array([x[0] - for x in l], dtype=np.float32) - # (cls, xy1...) - segments = [ - np.array(x[1:], dtype=np.float32).reshape(-1, 2) for x in l] - l = np.concatenate( - (classes.reshape(-1, 1), segments2boxes(segments)), 1) # (cls, xywh) - l = np.array(l, dtype=np.float32) - if len(l): - assert l.shape[1] == 5, 'labels require 5 columns each' - assert (l >= 0).all(), 'negative labels' - assert (l[:, 1:] <= 1).all( - ), 'non-normalized or out of bounds coordinate labels' - assert np.unique( - l, axis=0).shape[0] == l.shape[0], 'duplicate labels' - else: - ne += 1 # label empty - l = np.zeros((0, 5), dtype=np.float32) - else: - nm += 1 # label missing - l = np.zeros((0, 5), dtype=np.float32) - x[im_file] = [l, shape, segments] - except Exception as e: - nc += 1 - print( - f'{prefix}WARNING: Ignoring corrupted image and/or label {im_file}: {e}') - - pbar.desc = f"{prefix}Scanning '{path.parent / path.stem}' images and labels... " \ - f"{nf} found, {nm} missing, {ne} empty, {nc} corrupted" - pbar.close() - - if nf == 0: - print(f'{prefix}WARNING: No labels found in {path}. See {help_url}') - - x['hash'] = get_hash(self.label_files + self.img_files) - x['results'] = nf, nm, ne, nc, i + 1 - x['version'] = 0.1 # cache version - torch.save(x, path) # save for next time - logging.info(f'{prefix}New cache created: {path}') - return x - - def __len__(self): - return len(self.img_files) - - # def __iter__(self): - # self.count = -1 - # print('ran dataset iter') - # #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF) - # return self - - def __getitem__(self, index): - index = self.indices[index] # linear, shuffled, or image_weights - - hyp = self.hyp - mosaic = self.mosaic and random.random() < hyp['mosaic'] - if mosaic: - # Load mosaic - if random.random() < 0.8: - img, labels = load_mosaic(self, index) - else: - img, labels = load_mosaic9(self, index) - shapes = None - - # MixUp https://arxiv.org/pdf/1710.09412.pdf - if random.random() < hyp['mixup']: - if random.random() < 0.8: - img2, labels2 = load_mosaic( - self, random.randint(0, len(self.labels) - 1)) - else: - img2, labels2 = load_mosaic9( - self, random.randint(0, len(self.labels) - 1)) - r = np.random.beta(8.0, 8.0) # mixup ratio, alpha=beta=8.0 - img = (img * r + img2 * (1 - r)).astype(np.uint8) - labels = np.concatenate((labels, labels2), 0) - - else: - # Load image - img, (h0, w0), (h, w) = load_image(self, index) - - # Letterbox - # final letterboxed shape - shape = self.batch_shapes[self.batch[index] - ] if self.rect else self.img_size - img, ratio, pad = letterbox( - img, shape, auto=False, scaleup=self.augment) - # for COCO mAP rescaling - shapes = (h0, w0), ((h / h0, w / w0), pad) - - labels = self.labels[index].copy() - if labels.size: # normalized xywh to pixel xyxy format - labels[:, 1:] = xywhn2xyxy( - labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1]) - - if self.augment: - # Augment imagespace - if not mosaic: - img, labels = random_perspective(img, labels, - degrees=hyp['degrees'], - translate=hyp['translate'], - scale=hyp['scale'], - shear=hyp['shear'], - perspective=hyp['perspective']) - - #img, labels = self.albumentations(img, labels) - - # Augment colorspace - augment_hsv(img, hgain=hyp['hsv_h'], - sgain=hyp['hsv_s'], vgain=hyp['hsv_v']) - - # Apply cutouts - # if random.random() < 0.9: - # labels = cutout(img, labels) - - if random.random() < hyp['paste_in']: - sample_labels, sample_images, sample_masks = [], [], [] - while len(sample_labels) < 30: - sample_labels_, sample_images_, sample_masks_ = load_samples( - self, random.randint(0, len(self.labels) - 1)) - sample_labels += sample_labels_ - sample_images += sample_images_ - sample_masks += sample_masks_ - # print(len(sample_labels)) - if len(sample_labels) == 0: - break - labels = pastein(img, labels, sample_labels, - sample_images, sample_masks) - - nL = len(labels) # number of labels - if nL: - labels[:, 1:5] = xyxy2xywh(labels[:, 1:5]) # convert xyxy to xywh - labels[:, [2, 4]] /= img.shape[0] # normalized height 0-1 - labels[:, [1, 3]] /= img.shape[1] # normalized width 0-1 - - if self.augment: - # flip up-down - if random.random() < hyp['flipud']: - img = np.flipud(img) - if nL: - labels[:, 2] = 1 - labels[:, 2] - - # flip left-right - if random.random() < hyp['fliplr']: - img = np.fliplr(img) - if nL: - labels[:, 1] = 1 - labels[:, 1] - - labels_out = torch.zeros((nL, 6)) - if nL: - labels_out[:, 1:] = torch.from_numpy(labels) - - # Convert - img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 - img = np.ascontiguousarray(img) - - return torch.from_numpy(img), labels_out, self.img_files[index], shapes - - @staticmethod - def collate_fn(batch): - img, label, path, shapes = zip(*batch) # transposed - for i, l in enumerate(label): - l[:, 0] = i # add target image index for build_targets() - return torch.stack(img, 0), torch.cat(label, 0), path, shapes - - @staticmethod - def collate_fn4(batch): - img, label, path, shapes = zip(*batch) # transposed - n = len(shapes) // 4 - img4, label4, path4, shapes4 = [], [], path[:n], shapes[:n] - - ho = torch.tensor([[0., 0, 0, 1, 0, 0]]) - wo = torch.tensor([[0., 0, 1, 0, 0, 0]]) - s = torch.tensor([[1, 1, .5, .5, .5, .5]]) # scale - for i in range(n): # zidane torch.zeros(16,3,720,1280) # BCHW - i *= 4 - if random.random() < 0.5: - im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2., mode='bilinear', align_corners=False)[ - 0].type(img[i].type()) - l = label[i] - else: - im = torch.cat( - (torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2) - l = torch.cat( - (label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s - img4.append(im) - label4.append(l) - - for i, l in enumerate(label4): - l[:, 0] = i # add target image index for build_targets() - - return torch.stack(img4, 0), torch.cat(label4, 0), path4, shapes4 - - -class YoloV7Dataset(ptq_api_dataset.Dataset): - def __init__(self, path, batch_size, shuffle): - super().__init__(batch_size, shuffle) - print("Path to dataset", path) - self.load_images = LoadImagesAndLabels(path) - - def __getitem__(self, item): - img, _, _, _ = self.load_images[item] - # Input should be in [0,1]. - img = (1 / 255.) * img - return {"images": ONNXNNCFTensor(img.numpy())} - - def __len__(self): - return len(self.load_images) - - -############################################################### -# Quantization Process --> main() -############################################################### - -def main(arg): - dataset = YoloV7Dataset(arg.data, 1, True) - - original_model = onnx.load(arg.input_model) - num_init_samples = len( - dataset) if args.sample_size == -1 else args.sample_size - # We'll ignore detector head not to quantize them - ignored_scopes = [ - # Head branch 1 - "Mul_217", - "Add_219", - "Mul_221", - "Mul_223", - "Mul_227", - # Head branch 2 - "Mul_251", - "Add_253", - "Mul_255", - "Mul_257", - "Mul_261", - # Head branch 3 - "Mul_285", - "Add_287", - "Mul_289", - "Mul_291", - "Mul_295", - ] - - output_model_path = arg.input_model.split('.')[0] + "-quantized.onnx" - - # Step 1: Create a pipeline of compression algorithms. - - builder = CompressionBuilder() - - # Step 2: Create the quantization algorithm and add to the builder. - - quantization_parameters = PostTrainingQuantizationParameters( - number_samples=num_init_samples, - ignored_scopes=ignored_scopes - ) - quantization = PostTrainingQuantization(quantization_parameters) - builder.add_algorithm(quantization) - - # Step 3: Execute the pipeline. - - nncf_logger.info("Post-Training Quantization has just started!") - quantized_model = builder.apply(original_model, dataset) - - # Step 4: Save the quantized model. - - onnx.save(quantized_model, output_model_path) - nncf_logger.info( - "The quantized model is saved on {}".format(output_model_path)) - - onnx.checker.check_model(output_model_path) - - -if __name__ == "__main__": - - parser = argparse.ArgumentParser() - parser.add_argument('--data', type=str, - help='data path') - parser.add_argument('--input-model', type=str, - help='model path') - parser.add_argument('--sample-size', type=int, - default=-1, - help='model path') - - args = parser.parse_args() - main(args) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py deleted file mode 100644 index 06bad1825..000000000 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/yolov7.py +++ /dev/null @@ -1,217 +0,0 @@ -import argparse -import logging -import os -import random -import sys -import time -import warnings - -import cv2 -import matplotlib.pyplot as plt -import numpy as np -import onnxruntime -from PIL import Image - -warnings.filterwarnings(action="ignore") - - -# Inference for ONNX model -def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32): - # Resize and pad image while meeting stride-multiple constraints - shape = im.shape[:2] # current shape [height, width] - if isinstance(new_shape, int): - new_shape = (new_shape, new_shape) - - # Scale ratio (new / old) - r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) - if not scaleup: # only scale down, do not scale up (for better val mAP) - r = min(r, 1.0) - - # Compute padding - new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) - dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - \ - new_unpad[1] # wh padding - - if auto: # minimum rectangle - dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding - - dw /= 2 # divide padding into 2 sides - dh /= 2 - - if shape[::-1] != new_unpad: # resize - im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR) - top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) - left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) - im = cv2.copyMakeBorder(im, top, bottom, left, right, - cv2.BORDER_CONSTANT, value=color) # add border - return im, r, (dw, dh) - - -random.seed(42) -names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', - 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', - 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', - 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', - 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', - 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', - 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', - 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', - 'hair drier', 'toothbrush'] -colors = {name: [random.randint(0, 255) for _ in range(3)] - for i, name in enumerate(names)} - - -def set_logging(rank=-1): - logging.basicConfig( - format="%(message)s", - level=logging.INFO if rank in [-1, 0] else logging.WARN) - - -set_logging(0) # run before defining LOGGER -LOGGER = logging.getLogger("yolov7") - - -def preProcess_image(image): - image, ratio, dwdh = letterbox(image, auto=False) - image = image.transpose((2, 0, 1)) - image = np.expand_dims(image, 0) - image = np.ascontiguousarray(image) - - im = image.astype(np.float32) - im /= 255 - - return im, ratio, dwdh - - -def create_session(model_path, device='CPU_FP32'): - - if device == 'CPU_FP32': - providers = ['OpenVINOExecutionProvider'] - elif device == 'cpu': - providers = ['CPUExecutionProvider'] - else: - LOGGER.info(f'No provider passed, using default CPU EP ...') - providers = ['CPUExecutionProvider'] - - LOGGER.info(f'Use ORT providers: {providers}') - sess = onnxruntime.InferenceSession(model_path, - providers=providers, - provider_options=[{'device_type': device}]) - - outname = [i.name for i in sess.get_outputs()] - inname = [i.name for i in sess.get_inputs()] - - return sess, outname, inname - - -def main(args): - - model_name = args.model.split('.')[0] - - if (args.image): - # Open the image file - if not os.path.isfile(args.image): - print("Input image file ", args.image, " doesn't exist") - sys.exit(1) - cap = cv2.VideoCapture(args.image) - output_file = args.image[:-4]+f'_{model_name}_{args.device}.jpg' - elif (args.video): - # Open the video file - if not os.path.isfile(args.video): - print("Input video file ", args.video, " doesn't exist") - sys.exit(1) - cap = cv2.VideoCapture(args.video) - output_file = args.video[:-4]+f'_{model_name}_{args.device}.avi' - else: - # Webcam input - cap = cv2.VideoCapture(0) - - # Get the video writer initialized to save the output video - if (not args.image): - vid_writer = cv2.VideoWriter(output_file, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, (round( - cap.get(cv2.CAP_PROP_FRAME_WIDTH)), round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))) - - sess, outputs, inputs = create_session(args.model, args.device) - - while cv2.waitKey(1) < 0: - # get frame from the video - has_frame, frame = cap.read() - # Stop the program if reached end of video - if not has_frame: - print("Done processing !!!") - print("Output file is stored as ", output_file) - has_frame = False - # cv2.waitKey(3000) - # Release device - cap.release() - break - - original_image = frame - original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) - # original_image_size = original_image.shape[:2] - - image_data, proces_ratio, dwdh = preProcess_image( - original_image.copy()) - - inp = {inputs[0]: image_data} - start = time.time() - pred = sess.run(outputs, inp)[0] - end = time.time() - inference_time = end - start - - original_image = [original_image] - image = original_image[0] - if pred.any(): - for i, (batch_id, x0, y0, x1, y1, cls_id, score) in enumerate(pred): - image = original_image[int(batch_id)] - box = np.array([x0, y0, x1, y1]) - box -= np.array(dwdh*2) - box /= proces_ratio - box = box.round().astype(np.int32).tolist() - cls_id = int(cls_id) - - score = round(float(score), 3) - name = names[cls_id] - color = colors[name] - name += ' '+str(score) - cv2.rectangle(image, box[:2], box[2:], color, 2) - cv2.putText(image, name, (box[0], box[1] - 2), - cv2.FONT_HERSHEY_SIMPLEX, 0.45, [225, 255, 255], thickness=1) - cv2.putText(image, 'FPS: {:.8f}'.format(1.0 / inference_time), - (10, 40), cv2.FONT_HERSHEY_COMPLEX, 0.45, (255, 255, 255), 0) - - # Write the frame with the detection boxes - if (args.image): - cv2.imwrite(output_file, cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) - print(f"saving image..{output_file}") - else: - vid_writer.write(image.astype(np.uint8)) - - image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) - if args.view_img: - win_name = "test_yolov7" - cv2.imshow(win_name, image) - - -def parse_arguments(): - parser = argparse.ArgumentParser( - description='Object Detection using YOLOv7 in OPENCV using OpenVINO Execution Provider for ONNXRuntime') - parser.add_argument('--device', default='CPU_FP32', - help="Device to perform inference on 'cpu (MLAS)' or on devices supported by OpenVINO-EP [CPU_FP32, GPU_FP32, GPU_FP16, MYRIAD_FP16, VAD-M_FP16].") - parser.add_argument('--image', - help='Path to image file.') - parser.add_argument('--video', default="person-bicycle-car-detection.mp4", help='Path to video file.') - parser.add_argument('--model', default="notebooks/yolov7-tiny.onnx", - help='Path to model.') - - parser.add_argument('--view-img', action="store_true", - help='Path to model.') - - args = parser.parse_args() - return args - - -if __name__ == "__main__": - - args = parse_arguments() - main(args) From 39f1b3baf37c740b4d8293d3e59a733c5b7ac2a6 Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Wed, 28 Sep 2022 14:08:29 +0530 Subject: [PATCH 14/15] nncf installation update in README --- .../README.md | 6 +- .../OVEP_yoloV7-tiny_object_detection.ipynb | 94 +++++++++++++++---- 2 files changed, 80 insertions(+), 20 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md index cc0e5dcfa..f75db255d 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/README.md @@ -9,7 +9,7 @@ $ source yv7-pyenv/bin/activate $ pip install --upgrade pip ``` ### Conda -If system python3 version is < 3.8 it's recommended to either upgrade to python3.8 or use create virtual environment python3.8 using conda. +If system python3 version is < 3.8.13 it's recommended to either upgrade to python3.8 or use create virtual environment python3.8 using conda. ``` $ conda create -n yolov7 python=3.8 $ conda activate yolov7 @@ -18,9 +18,10 @@ $ conda activate yolov7 After creating and activating virtual environment, install the required packages: ### NNCF Experimental + ``` $ git clone https://github.com/openvinotoolkit/nncf.git -$ cd nncf && python setup.py install --onnx +$ cd nncf && python setup.py develop --onnx $ pip install --no-cache-dir onnxconverter_common onnxruntime-openvino==1.11.0 $ cd .. && rm -fR nncf ``` @@ -34,6 +35,7 @@ $ cp -R yolov7/* . $ pip install --no-cache-dir -r requirements.txt $ rm -fR yolov7 ``` + Launch the notebook from here. ## Dataset The dataset used in this sample is the coco-validation2017 dataset. It will be downloaded automatically in the desired location while running the notebook. diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index ec1df5275..62506ce17 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "markdown", - "id": "b6157254", + "id": "af482d97", "metadata": { "id": "b6157254" }, @@ -40,23 +40,20 @@ }, { "cell_type": "markdown", + "id": "fbf1db77", "metadata": {}, "source": [ "**Before starting with this notebook please make sure to perform the required installations as mentioned below:**\n", "1. [YoloV7 installation requirements](https://github.com/WongKinYiu/yolov7#installation)\n", - "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "2. [NNCF Onnx (Experimental Requirements)](https://github.com/openvinotoolkit/nncf/tree/54a444fb6ef1806c7ab8e647f762e2547ceb95bf#installation)\n", + "\n", "## Download COCO validation dataset" ] }, { "cell_type": "code", "execution_count": null, + "id": "1c97ae99", "metadata": {}, "outputs": [], "source": [ @@ -73,32 +70,39 @@ }, { "cell_type": "markdown", + "id": "660fc7b3", "metadata": {}, "source": [ "## Export yolov7-tiny model to ONNX format with NMS\n", - "\n", - "```python\n", + "**Note: Adjust the values of `iou-thres` and `conf-thres` according to requirements.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98b58e62", + "metadata": {}, + "outputs": [], + "source": [ "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", - " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640\n", - "```\n", - " \n", - "**Note: Adjust the values of `iou-thres` and `conf-thres` according to requirements.**" + " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640" ] }, { "cell_type": "code", "execution_count": null, + "id": "1d702110", "metadata": {}, "outputs": [], "source": [ - "import os\n", "if not os.path.exists('cat.jpg'):\n", " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" ] }, { "cell_type": "markdown", + "id": "a22f6b6a", "metadata": {}, "source": [ "## Import Required Libraries" @@ -107,6 +111,7 @@ { "cell_type": "code", "execution_count": null, + "id": "5ec4fb7c", "metadata": {}, "outputs": [], "source": [ @@ -126,6 +131,7 @@ }, { "cell_type": "markdown", + "id": "435fb7dd", "metadata": {}, "source": [ "## Define necessary helper functions\n", @@ -139,6 +145,7 @@ { "cell_type": "code", "execution_count": null, + "id": "0bed58f8", "metadata": {}, "outputs": [], "source": [ @@ -173,6 +180,7 @@ }, { "cell_type": "markdown", + "id": "d9c15307", "metadata": {}, "source": [ "## Labels and Colors for Lables" @@ -181,6 +189,7 @@ { "cell_type": "code", "execution_count": null, + "id": "f9ed9518", "metadata": {}, "outputs": [], "source": [ @@ -199,6 +208,7 @@ }, { "cell_type": "markdown", + "id": "32da9963", "metadata": {}, "source": [ "## Read & Pre-Process Image" @@ -207,6 +217,7 @@ { "cell_type": "code", "execution_count": null, + "id": "1d35b1a3", "metadata": {}, "outputs": [], "source": [ @@ -231,8 +242,30 @@ " im = image.astype(np.float32)\n", " im /= 255\n", " print(\"Image Shape:\", im.shape, sep='\\t')\n", - " return im, ratio, dwdh\n", + " return im, ratio, dwdh" + ] + }, + { + "cell_type": "markdown", + "id": "bf37989c", + "metadata": {}, + "source": [ + "## Create a session for inference based on the device selected\n", + "Inferencing using OpenVINO Execution provider under ONNX-Runtime, is performed using the below simple steps:\n", + "\n", + "1. Create a ONNX Runtime Inference Session instance using `onnxruntime.InferenceSession()`\n", + "2. To create an Inference Session object pass the model and the execution provider as arguments. Execution Providers are the hardware device options e.g. CPU, Myriad, GPU, etc. on which the session will be executed.\n", "\n", + "The below create_sess function actually takes care of the above steps. All we need to do is pass the device arguement to it. It'll return the appropriate session according to the selected device along with the input name for the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d217bb8b", + "metadata": {}, + "outputs": [], + "source": [ "def create_session(model_path, device='CPU_FP32'):\n", " \n", " if device == 'CPU_FP32':\n", @@ -245,7 +278,7 @@ " \n", " # LOGGER.info(f'Use ORT providers: {providers}')\n", " print(f'Use ORT providers: {providers}')\n", - " \n", + " onnxruntime.set_default_logger_severity(4)\n", " sess = onnxruntime.InferenceSession(model_path,\n", " providers=providers,\n", " provider_options=[{'device_type': device}])\n", @@ -258,6 +291,7 @@ }, { "cell_type": "markdown", + "id": "976db139", "metadata": {}, "source": [ "# Run Inference Function\n", @@ -279,6 +313,7 @@ { "cell_type": "code", "execution_count": null, + "id": "62c95da2", "metadata": {}, "outputs": [], "source": [ @@ -335,6 +370,7 @@ }, { "cell_type": "markdown", + "id": "572f353e", "metadata": {}, "source": [ "### Inference using CPU Execution Provider (MLAS)" @@ -343,6 +379,7 @@ { "cell_type": "code", "execution_count": null, + "id": "2d976d50", "metadata": {}, "outputs": [], "source": [ @@ -354,6 +391,7 @@ { "cell_type": "code", "execution_count": null, + "id": "2a729964", "metadata": {}, "outputs": [], "source": [ @@ -367,6 +405,7 @@ }, { "cell_type": "markdown", + "id": "4a1714ff", "metadata": {}, "source": [ "### Inference using OpenVino Execution Provider" @@ -375,6 +414,7 @@ { "cell_type": "code", "execution_count": null, + "id": "af79760a", "metadata": {}, "outputs": [], "source": [ @@ -388,6 +428,7 @@ }, { "cell_type": "markdown", + "id": "8cfa14f7", "metadata": {}, "source": [ "# NNCF PTQ for YoloV7" @@ -395,6 +436,7 @@ }, { "cell_type": "markdown", + "id": "4afe9d00", "metadata": {}, "source": [ "## Quantize yolov7-tiny model" @@ -402,6 +444,7 @@ }, { "cell_type": "markdown", + "id": "624178f9", "metadata": {}, "source": [ "### Build PTQ API dataset" @@ -410,6 +453,7 @@ { "cell_type": "code", "execution_count": null, + "id": "b149b53d", "metadata": {}, "outputs": [], "source": [ @@ -442,6 +486,7 @@ }, { "cell_type": "markdown", + "id": "4d8e8007", "metadata": {}, "source": [ "### Run PTQ" @@ -450,6 +495,7 @@ { "cell_type": "code", "execution_count": null, + "id": "c7562f51", "metadata": {}, "outputs": [], "source": [ @@ -481,6 +527,7 @@ }, { "cell_type": "markdown", + "id": "30d85dd4", "metadata": {}, "source": [ "### Step 1: Create a pipeline of compression algorithms." @@ -489,6 +536,7 @@ { "cell_type": "code", "execution_count": null, + "id": "d75116cd", "metadata": {}, "outputs": [], "source": [ @@ -497,6 +545,7 @@ }, { "cell_type": "markdown", + "id": "3fbeb310", "metadata": {}, "source": [ "### Step 2: Create the quantization algorithm and add to the builder." @@ -505,6 +554,7 @@ { "cell_type": "code", "execution_count": null, + "id": "5d6f0c82", "metadata": {}, "outputs": [], "source": [ @@ -518,6 +568,7 @@ }, { "cell_type": "markdown", + "id": "a71d7715", "metadata": {}, "source": [ "### Step 3: Execute the pipeline." @@ -526,6 +577,7 @@ { "cell_type": "code", "execution_count": null, + "id": "96272e26", "metadata": {}, "outputs": [], "source": [ @@ -535,6 +587,7 @@ }, { "cell_type": "markdown", + "id": "90590d88", "metadata": {}, "source": [ "### Step 4: Save the quantized model." @@ -543,6 +596,7 @@ { "cell_type": "code", "execution_count": null, + "id": "faa8caea", "metadata": {}, "outputs": [], "source": [ @@ -555,6 +609,7 @@ }, { "cell_type": "markdown", + "id": "8b602028", "metadata": {}, "source": [ "## Run Inference on INT-8 model" @@ -563,6 +618,7 @@ { "cell_type": "code", "execution_count": null, + "id": "4b4c78d0", "metadata": {}, "outputs": [], "source": [ @@ -573,6 +629,7 @@ }, { "cell_type": "markdown", + "id": "6059c1c0", "metadata": {}, "source": [ "### Inference using OpenVino Execution Provider" @@ -581,6 +638,7 @@ { "cell_type": "code", "execution_count": null, + "id": "72e93755", "metadata": {}, "outputs": [], "source": [ @@ -644,5 +702,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } From dc777c817b4f7fee0565a892c97f66b3fa557d1e Mon Sep 17 00:00:00 2001 From: krishnendukx Date: Fri, 14 Oct 2022 12:21:27 +0530 Subject: [PATCH 15/15] sdl compliance changes --- .../OVEP_yoloV7-tiny_object_detection.ipynb | 77 +++++++++++++++---- 1 file changed, 62 insertions(+), 15 deletions(-) diff --git a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb index 62506ce17..e29b3c004 100644 --- a/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb +++ b/python/OpenVINO_EP/yolov7_object_detection_fp32_int8/notebooks/OVEP_yoloV7-tiny_object_detection.ipynb @@ -58,14 +58,25 @@ "outputs": [], "source": [ "import os\n", - "import torch\n", + "import sys\n", "import warnings\n", + "from urllib import request\n", + "from zipfile import ZipFile\n", + "import torch\n", + "\n", "warnings.filterwarnings(action=\"ignore\")\n", + "operating_platform = sys.platform\n", "\n", - "if not os.path.exists(\"../datasets\"):\n", - " # Download COCO val\n", + "# Download COCO val\n", + "if not os.path.exists(\"datasets\"):\n", " torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n", - " !unzip -q tmp.zip -d ../datasets && rm tmp.zip" + " if operating_platform == \"win32\":\n", + " with ZipFile(\"tmp.zip\", \"r\") as zipped_data:\n", + " zipped_data.extractall(path=\"datasets\")\n", + " zipped_data.close()\n", + " os.remove(\"tmp.zip\")\n", + " else:\n", + " !unzip -q tmp.zip -d datasets && rm tmp.zip\n" ] }, { @@ -73,7 +84,7 @@ "id": "660fc7b3", "metadata": {}, "source": [ - "## Export yolov7-tiny model to ONNX format with NMS\n", + "## Export yolov7 model to ONNX format with NMS\n", "**Note: Adjust the values of `iou-thres` and `conf-thres` according to requirements.**" ] }, @@ -84,9 +95,14 @@ "metadata": {}, "outputs": [], "source": [ - "if not os.path.exists(\"yolov7-tiny.onnx\"):\n", - " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-tiny.pt\n", - " !python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640" + "if not os.path.exists(\"yolov7.onnx\"):\n", + " if operating_platform == \"win32\":\n", + " model_url = \"https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt\"\n", + " request.urlretrieve(model_url, \"yolov7.pt\")\n", + " else:\n", + " !wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt\n", + " \n", + " !python export.py --weights yolov7.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640" ] }, { @@ -97,7 +113,11 @@ "outputs": [], "source": [ "if not os.path.exists('cat.jpg'):\n", - " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" + " if operating_platform == \"win32\":\n", + " img_url = \"https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg\"\n", + " request.urlretrieve(img_url, \"cat.jpg\")\n", + " else:\n", + " !wget https://storage.openvinotoolkit.org/data/test_data/images/cat.jpg" ] }, { @@ -230,6 +250,17 @@ "LOGGER = logging.getLogger(\"yolov7\")\n", "\n", "def preProcess_image(img_path):\n", + " \n", + "\n", + " if img_path.split('.')[-1] not in ['jpg', 'png']:\n", + " raise Exception(img_path, \"is an unknown file format. Use the image of .jpg or .png format\")\n", + " \n", + " if not os.path.exists(img_path):\n", + " raise FileNotFoundError(img_path, \"File Not Found: Please enter a valid image file path!\")\n", + "\n", + " if os.path.islink(img_path):\n", + " raise Exception(img_path, \"is a symbolic link. Please provide a valid image file path!\")\n", + "\n", " img = cv2.imread(img_path)\n", " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", "\n", @@ -266,19 +297,35 @@ "metadata": {}, "outputs": [], "source": [ + "def check_model_extension(fp):\n", + " # Split the extension from the path and normalise it to lowercase.\n", + " ext = os.path.splitext(fp)[-1].lower()\n", + "\n", + " # Now we can simply use != to check for inequality, no need for wildcards.\n", + " if(ext != \".onnx\"):\n", + " raise Exception(fp, \"is an unknown file format. Use the model ending with .onnx format\")\n", + " \n", + " if not os.path.exists(fp):\n", + " raise Exception(\"[ ERROR ] Path of the onnx model file is Invalid\")\n", + " \n", + " if os.path.islink(fp):\n", + " raise Exception(fp, \"is a symbolic link. Please provide a valid .onnx model path!\")\n", + "\n", "def create_session(model_path, device='CPU_FP32'):\n", " \n", + " check_model_extension(model_path)\n", + "\n", " if device == 'CPU_FP32':\n", " providers = ['OpenVINOExecutionProvider']\n", " elif device == 'cpu':\n", " providers = ['CPUExecutionProvider']\n", " else:\n", - " LOGGER.info(f'No provider passed, using default CPU EP ...')\n", + " print('Invalid or No provider passed, using default CPU Execution Provider.')\n", " providers = ['CPUExecutionProvider']\n", " \n", - " # LOGGER.info(f'Use ORT providers: {providers}')\n", " print(f'Use ORT providers: {providers}')\n", " onnxruntime.set_default_logger_severity(4)\n", + "\n", " sess = onnxruntime.InferenceSession(model_path,\n", " providers=providers,\n", " provider_options=[{'device_type': device}])\n", @@ -383,7 +430,7 @@ "metadata": {}, "outputs": [], "source": [ - "model_path = 'yolov7-tiny.onnx'\n", + "model_path = 'yolov7.onnx'\n", "img_path = 'cat.jpg'\n", "num_iters = 100" ] @@ -458,7 +505,6 @@ "outputs": [], "source": [ "import onnx\n", - "\n", "from nncf.experimental.post_training.compression_builder import CompressionBuilder\n", "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantization\n", "from nncf.experimental.post_training.algorithms.quantization import PostTrainingQuantizationParameters\n", @@ -481,7 +527,7 @@ " def __len__(self):\n", " return len(self.load_images)\n", "\n", - "dataset = YoloV7Dataset(\"../datasets/coco/images/val2017\", 1, True)" + "dataset = YoloV7Dataset(\"datasets/coco/images/val2017\", 1, True)" ] }, { @@ -582,6 +628,7 @@ "outputs": [], "source": [ "nncf_logger.info(\"Post-Training Quantization has just started!\")\n", + "nncf_logger.setLevel(4)\n", "quantized_model = builder.apply(original_model, dataset)" ] }, @@ -679,7 +726,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('yv7')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" },