diff options
Diffstat (limited to 'megapixels/notebooks/face_analysis/3d_face_plot_cpdp.ipynb')
| -rw-r--r-- | megapixels/notebooks/face_analysis/3d_face_plot_cpdp.ipynb | 2967 |
1 files changed, 2967 insertions, 0 deletions
diff --git a/megapixels/notebooks/face_analysis/3d_face_plot_cpdp.ipynb b/megapixels/notebooks/face_analysis/3d_face_plot_cpdp.ipynb new file mode 100644 index 00000000..ba6f97b1 --- /dev/null +++ b/megapixels/notebooks/face_analysis/3d_face_plot_cpdp.ipynb @@ -0,0 +1,2967 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3D Face Plot\n", + "\n", + "Attenzione visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import os\n", + "from os.path import join\n", + "import sys\n", + "import time\n", + "from random import randint\n", + "import random\n", + "\n", + "import cv2 as cv\n", + "import numpy as np\n", + "import imutils\n", + "import matplotlib.animation\n", + "%matplotlib notebook\n", + "from glob import glob\n", + "from matplotlib import cbook\n", + "from matplotlib import cm\n", + "#from matplotlib.colors import LightSource\n", + "import face_alignment\n", + "import numpy as np\n", + "\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import matplotlib.pyplot as plt\n", + "import mpl_toolkits.mplot3d.axes3d as p3\n", + "from matplotlib import animation\n", + "\n", + "from skimage import io\n", + "from tqdm import tqdm_notebook as tqdm\n", + "from IPython.display import clear_output\n", + "from pathlib import Path\n", + "\n", + "sys.path.append('/work/megapixels_dev/megapixels/')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate random hex colors\n", + "def rhex():\n", + " r = lambda: random.randint(0,255)\n", + " return '#%02X%02X%02X' % (r(), r(), r())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# init 3d face\n", + "# Run the 3D face alignment on a test image, without CUDA.\n", + "fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._3D, device='cuda:0', flip_input=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [], + "source": [ + "fp_im = '/home/adam/Nextcloud/files-ahprojects-com/ahprojects/cpdp_politicians/may/may_1.jpg'\n", + "im = cv.imread(fp_im)" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_3d_face_plain(im, lm):\n", + " preds = lm\n", + " fig = plt.figure(figsize=plt.figaspect(.5))\n", + " ax = fig.add_subplot(1, 2, 1)\n", + " ax.imshow(im)\n", + " ax.plot(preds[0:17,0],preds[0:17,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[17:22,0],preds[17:22,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[22:27,0],preds[22:27,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[27:31,0],preds[27:31,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[31:36,0],preds[31:36,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[36:42,0],preds[36:42,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[42:48,0],preds[42:48,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[48:60,0],preds[48:60,1],marker='o',markersize=6,linestyle='-',color='w',lw=2)\n", + " ax.plot(preds[60:68,0],preds[60:68,1],marker='o',markersize=6,linestyle='-',color='w',lw=2) \n", + " ax.axis('off')\n", + "\n", + " ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + " surf = ax.scatter(preds[:,0]*1.2,preds[:,1],preds[:,2],c=\"cyan\", alpha=1.0, edgecolor='b')\n", + " ax.plot3D(preds[:17,0]*1.2,preds[:17,1], preds[:17,2], color='blue' )\n", + " ax.plot3D(preds[17:22,0]*1.2,preds[17:22,1],preds[17:22,2], color='blue')\n", + " ax.plot3D(preds[22:27,0]*1.2,preds[22:27,1],preds[22:27,2], color='blue')\n", + " ax.plot3D(preds[27:31,0]*1.2,preds[27:31,1],preds[27:31,2], color='blue')\n", + " ax.plot3D(preds[31:36,0]*1.2,preds[31:36,1],preds[31:36,2], color='blue')\n", + " ax.plot3D(preds[36:42,0]*1.2,preds[36:42,1],preds[36:42,2], color='blue')\n", + " ax.plot3D(preds[42:48,0]*1.2,preds[42:48,1],preds[42:48,2], color='blue')\n", + " ax.plot3D(preds[48:,0]*1.2,preds[48:,1],preds[48:,2], color='blue' )\n", + " \n", + " # pad\n", + " xmm = (np.min(lm[:,0]),np.max(lm[:,0]))\n", + " ymm = (np.min(lm[:,1]),np.max(lm[:,1]))\n", + " zmm = (np.min(lm[:,2]),np.max(lm[:,2]))\n", + " \n", + " print(xmm, ymm, zmm)\n", + "# ax.set_xticks([])\n", + "# ax.set_yticks([])\n", + "# ax.set_zticks([])\n", + " plt.setp( ax.get_xticklabels(), visible=False)\n", + " plt.setp( ax.get_yticklabels(), visible=False)\n", + " #ax.set_xlim(xmm[0]-50, xmm[1]+50)\n", + " #ax.set_ylim(ymm[0]-50, ymm[1]+50)\n", + " #ax.set_ylim(zmm[0]- .1*zmm[0],zmm[1] + .1*zmm[1])\n", + " #ax.set_ylim(103, 275)\n", + " #ax.set_zlim((-100,100))\n", + " ax.view_init(elev=15., azim=135.)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "from app.utils import im_utils" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [], + "source": [ + "im = cv.imread(fp_im)\n", + "im_resized = im_utils.resize(im, width=600, height=600)\n", + "im_rgb = cv.cvtColor(im, cv.COLOR_BGR2RGB)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "#import dlib\n", + "from app.processors import face_detector" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [], + "source": [ + "#face_detector = face_detector.DetectorDLIBCNN(gpu=0) # -1 for CPU\n", + "face_detector = face_detector.DetectorCVDNN()" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "detecting face...\n" + ] + }, + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m--------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m<ipython-input-165-58b60b291666>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mst\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mbboxes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mface_detector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_resized\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlargest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpyramids\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_resized\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" + ] + } + ], + "source": [ + "print('detecting face...')\n", + "st = time.time()\n", + "bboxes = face_detector.detect(im_resized, largest=True, pyramids=3)\n", + "bbox = bboxes[0].to_dim(im_resized.shape[:2][::-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'tuple' object has no attribute 'to_xyxy'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m--------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m<ipython-input-166-fe88f3cbe84b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_xyxy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'to_xyxy'" + ] + } + ], + "source": [ + "bbox = bbox.to_xyxy()\n", + "print(bbox)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [], + "source": [ + "points = fa.get_landmarks_from_image(im_resized, [bbox] )" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA1sAAAGtCAYAAADgaG4oAAAgAElEQVR4nOzdd1iUV+L28REYhm6PMT1Zs4lZ09sm2WRT3k2vmh5jjIlGEzXGLog06b33XqS3GXpvItXeEHsvVAXGNvf7x8j8BFFhhoGQ3J/rOlcCzsMAZuea757znCMAERERERERDTrBcH8DREREREREf0WMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtERERERERqwNgiIiIiIiJSA8YWERERERGRGjC2iIiIiIiI1ICxRUREREREpAaMLSIiIiIiIjVgbBEREREREakBY4uIiIiIiEgNGFtEREREI5BMJsOVK1cgk8mG+1shoptgbBERERH9yclkMly9ehVXrlzBpUuXIJVK0dHRgebmZrS2tuL8+fPo6urCpUuXcPXqVQYY0Z8EY4uIiIjoT0QmkylmrS5duoSLFy+iq6sLnZ2d6OjoQGdnp+Lfz507h9bWVrS0tODIkSOoqqpCc3Mz2tracOHCBUilUly+fJnxRTRMGFtEREREw6h71ury5cu4ePEipFKpIqi6R1dXF7q6uiCVShWjo6MDTU1NaGtrQ3t7O44cOYKioiK0tbWhpaUFzc3NitHS0oL29nZ0dnbi4sWLXH5INEQYW0RERERDpPdywObmZpw6dapfcdV79BVbxcXFaG9v7zHa2toUs1/XB1j38sPOzk4uPyRSE8YWERERkRr0Zzngnj17UF9ff9uwUiW2+ho3C7Deyw+vXr063L9GohGNsUVEREQ0CHovB+wOq+vjqveM1d69e1FfXz/g0FI1tvqKr5stP2xra+PyQyIlMbaIiIiIBuj65YBdXV1obm6+YSlgf5YD/lliayCzX72XHzLAiG6OsUVERER0C7daDtjZ2Ynjx4+juLi4X/dZqTO2Dh8+PKixdasAO3nyJLKzs3sEGJcfEt2IsUVERER0nYEuBzx58iSKi4uVCqaGhgbU1dWNmNjqHqdPn0Z2drZi+WFra2ufyw87Ojpw8eJFbj9Pf1uMLSIiIvrb6uuw4IEuBzx58iSKior+lrHF5YdEt8bYIiIior+F3ssBpVKpYtbqyJEjqKys7Pe269ePU6dOMbZUuP/rwoUL6OrqUmw/T/RXwtgiIiKiv6SBLAc8evQoKioqlIqev2NsnTp1Cjk5OSp9DS4/pL8DxhYRERGNeKouBzx69CjKy8sZW0MYW/2d/WppaUF7ezuXH9KIxNgiIiKiEaWvsOrq6sKePXtw7Nixfm+73ju2ysrKlIqe06dPo7Cw8G8XW7m5uWp/nut3P8zKyrrl8kMGGP0ZMbaIiIjoT62/ywGrq6vR2NioVLgcO3Zs2GKrtrZ2xMXWyZMnhyS2usf194j1tfywubmZyw/pT4mxRURERH8a/VkO2D1j1XvWqqamRunYOn78+LDE1r59+xhb/Ri3WrbYvf38rZYfXrx4kcsPaVgwtoiIiGhY9A6r9vb2HssAB7ocsLa2Fvv27VM6tkpLS5W69syZMygoKGBsDVNs3SzA+rv7IQOM1ImxRUREREOie9v1my0HPH78OIqLiwe07fr1o66uDg0NDYytIYqtvLy8IYutwYi72y0/lEqlXH5Ig46xRURERIOu931WUunNlwN2x4Mqu/qpGlsnTpxASUkJY6uf48SJE0MeW4P9fFx+SEOBsUVEREQqudnugANdDqjKvU9SqRT19fXYu3fvkMfW2bNnkZ+fP+Sx1draisOHD6O5ufkvH1tD9XzXLz88duwYKioquPyQVMLYIiIiogHpXg546dKlHssBm5ubkZeXN+Bt1wcrtjZv3ow9e/Yode3JkydRXFw85LHV2NjYr9jq6urCuXPnFI/Pz8+HWCxGbm4uxGIxCgsLUVFRgdzcXJw5c2ZI4ic/P39IY2son6+9XX7/YEFBAZcfkkoYW0RERHRTA1kO2NraiqysLKVjSZXleCM5tmpqam74/IULF3D8+HHs3LkTFRUVyMjIQE5ODqqqqrB3716cOXMG58+fR1NTE5qbm3HkyBFUV1dDIpEgIyMDWVlZ2LhxI3bu3Iljx46htbV1UEPk+PHjQxo/Q/187e3tOHr0KAoLC2/4PJcf0kAwtkaQ0dqjeg6hVo9hpN1zGAo1ewx9obDH0NPS6jW0bzN6Pt5As+fo/XiRsOcQamrddNzusb3/fKDjVs+tjqGhoQGRSAShUAiBQAB9fX0YGRnhzjvvhJGREQwMDKCjowOhUAgtLS2MGjUKQqEQIpEI2tr/9z1rawmhrSXs8bOMNjTCfffcq/hYc5QGREJt6Ip0briue2hpaEJLQ1PxZ+r82Xv/7nW0RRAJtdX2vIP934Kq/63d+PNqD9oQCXV6DdW+19sNbe2e48bnv92Qfx0aOVRdDtjW1obMzEylY0mVaJFKpdiyZQt2796t1LWq3C927tw55OXlKR1b1dXVaG5uxoEDB1BfX4/CwkKIxWIUFxdjy5YtOHz4MNra2m649mb3bLW1teHUqVPYu3cvampqFLNgxcXFqK+vx/79+3Hu3LkRFT/ds0xDGVtHjhxBUVFRvx57q90Pz58/z+WHf2OMrRGEsTWCYktLE4JRAujo6WL8xAkYO3YsJkyQ/3PUqFEQ6erAcLQRjMaMhr6hAbS0tKCjowMNDQ3cdddd0NfVg76uHkRCbejr6kFPRxdaGprQ09HF5El3YtyYsdDX1cP4seNwx4SJ0NfVU7zJ7/7n9UNXpAMdbZHaQ4uxxdhibI0cMpnshuWA586dw/79+5Xadl0qlaK9vR0ZGRlKx5Iq0SKVSrF169YREVudnZ04efIkdu/ejcLCQqSnpyMrKwuVlZXYvXs3Tp06hc7Oztt+nYFskNHc3IxDhw5h69atKC0thUQiQU5ODjZt2oTdu3fjxIkTiq/D2Gq/7e9TlQBra2vDhQsXIJVy+eHfAWNrBGFsjZzY0jU0wKPT/oXn/v0innz2GTz33HP44IMP8Nlnn+GTTz7Bv//zCh574nE88q/H8K8nn8B9990HQ0NDaGlpwcjICP+c8jC0tYQwMjDEKIEAIqE2DPUNMNrQCBPGjceEceMh1NTC/ffeh0kT78BoQyPFLJaBnj50tEU9xhij0Yp4657hYmwxthhbfy/9WQ545MgRpQ/2lUqlOH/+PCQSidLXNzU1ITc3V6XY2rVrl1LXqnK/2O1iq7W1FYcOHcKWLVtQXFysuMeqvr4etbW1qKysVGq7e1V2I2xra8OJEyewe/duVFVVKe79KikpwZYtW3Dw4EE0NTXdMraGMn5utqRPnePQoUMoKSkZtK/H5Yd/T4ytEWSMSKPH+LPFlr5QBD0tbehqCqGjodqb1j9bbPX+egKBALoiHegK5T+vtkgf2iJ9PP3MC3j8iWfw/Isv4LkXnsfb776DDz76EHPn/oTFixdi1qyZmDVrJn799VfMnTsXS5cuxdKlS/H5l1/go08+xt333gPBKAGmTZsGfX193HnnnRAIBNDT01PMij322GMQiUSYNGkS3nrrLdx55524c/LdePW11zF9xhd4/oV/Y8qUKXj44YfxxBNP4MUXX8QTTzwBAwMDaGpqQldXF+PHj1cscxSJ5EGmOUoDOtqiQQmg7qWP3bF3fXwMdfyo+t9Wf2Ky9+j58/YMkMGNr95DuRgarNjS1u570NBTdjng8ePHVYqtCxcuQCwWD1tsbdu2DTt37hyW2Or+vjs7O3H69Gns3bsXVVVVyMnJQUZGBioqKrBz506cOHFCMashld78ni11x1Zfo6mpCQcOHMDmzZsVUZiXl4fq6mrs3bsXp06dUjzXUM80DUdsHTx4cFBj62YB1nv26/jx42hsbLxh+SGNTIytEYSx9eeJrbE6+hBpakGgpQmjCePw75dfwu9/LMHL/3kF733wPt59/z388ONsLFuxHL//sQRzFy/AF7O+wctvvYbnX3sJ777/Hr77fiZee/2/+HT6Z5g3/xesMTGGielazP1lHiZPnoxXX30VU6dOxbRp0zBlyhQ88sgjePLJJ/HUU0/h/vvvx0cffYT7778fDz30EH76eR6efuY5PPHk0/jf2+/is88+w8svv4xnnnkGTz/9NObOnYuJEydi4sSJePDBBzF58mRMmjQJ48aNg0gkDy19XT1ojtJgbDG2GFt/AVeuXFEcFDyQ5YCqbH/e/eY/PT1d6eubm5uRk5MzLLGl7OYc7e3taGhogEQiQWlpKcRiMfLz81FbW4vGxkY0NTXd8vfefc/WnyG2eo/W1lYcP34cu3btQmVlJbKzs5GRkYGysjLU1NQgJydHMSuj7jGQ+6cGM7ZKS0uH9Dnb29vR2NiIsrKyHgH24IMP4tChQ8P90kJKYGyNIIytP09saWpqQktLC48//RS++O4bzJz1HaZ//hmWrVgKy/UWsHd0gI2dLVatWQ1zSwust7eGX7A/4pLjkZWfDf/gIEz/8gt898MsLF+9CnN+/gkmpmuxcvUqzJz1PYyNjTF37ly88soreOmll/DOO+/g4YcfxqxZszB58mRMnjwZL730Ev773//iq6++wj8fmYpPPp2O3xYuxpdffYNXXnkFb731FmbMmIHPPvsMv/32G95880384x//wKhRoxRvnnV0dHDXXXdBT0cXowQCGOjpM7YYW4ytv4Du2Brom3dVduSTSuWzOmlpaUpf39LSguzsbKWv3759O3bs2KG22Orq6sLZs2exb98+1NTUIC8vDxKJBMXFxZBIJDh27BjOnz8/oOfdv3//nza2+hpnz55FY2MjKisrIRaLIRaLUVBQgNraWjQ0NOD06dMDuverv2MozxDrHgcOHEBZWdmwxFZFRYXi47a2NkyePBnHjh0b7pcWUgJjawRhbP15Ysvorjvw8luv48cff8R3X32NJUsX4cefZuH7H76F5XozrF1nCgsrS5iYrsWKVSux5PdFMDFejd8XL8Ss77/D4uVL4RcSBEluNn5dslgRZSama2G81gS2trZwc3ODpaUlZs2ahe+++w6ffvopZs+ejY8++ggzZ87E1KlT8e677+Ktt97CRx9/irf+39uYO28+Fi76HQsXLsTs2bPx4Ycf4scff8ScOXPw5Zdf4rnnnoNAIICWlhZEIpFiaeET0x6HloYmdEU6jC3GFmPrL0DZ2FJlk4juGElNTVX6elW3jt+xYwe2b9+u1LV97YR44cIFHDt2DDt27EB5eTkkEglyc3NRXV2NhoYGnD17Fl1dXSrNyI202Ooe3cv6WltbcfToUezYsQMVFRXIzMxEZmYmKioqsGPHDhw9enRQtp0fjtjav38/ysvLhzy29u3bh40bN/b43B133IHTp08P90sLKYGxNYIMNLZ6D31tzR7j9nE1uBtkDGYM3e5N42BtytB9vUCkBYFAAENdPdw35SG8+uZreP/D9zDnxx+w+NcFsDBfBxtrK3z5xQy8/947WDT3J7zx0ot4/d8vYMYH7+Htt17DW6+/gumfvI83//syZs2aCWPj1fD29oRYnIbMvEIkpWdgvb0T1lqsh5mVJZzd3RCfnISImGi4eXnC1MIcP8//Bb/89iu++u5b/Lp4Eb75fiY+/XwGnNxc4eTmirXmZggMDYF/aCBMLEzxx6plWG68Eh99+D6mf/YJ3nj9Ndxz92T5VvQGhhitq4/R2rowMjLCSy+9hDFjxqgcoqrH1u2C4tajr/C5dZAMNFh6PV4kumFoa2srtvUfeACpEksDu753FN0+tm79fDd+PfmgoadsbKl6qLBUKkVqaqpSmz1IpapvHa9KbJ05cwa5ubnYv38/6urqUFBQoNgwYuvWrThy5Aja29v7vHa4Ykss7sL0z6V458NL8PTsQmPj0MdW78+3tbXh9OnTaGhoQG1treL3WFRUhPr6ejQ2NuLs2bOKx7e0tMPRsQtPPH8Fjz51BcbGUpw82fNrtra2w87uHKY+1YZpz13B2rVSnDql/p+x9wzTUI2GhgZs2rSpx+fGjh2Lpqam4X5pISUwtkYQxtbQxdb114mE2tC+toX7Pffdi+f+/SK+/HoGjE1WYtGCeVi3ZiU+/ugDfPjBe5gx/VO89uoreP/DdzBz1jeYPed7zJ7zPdYYr4CTsx1sbC3h5u4EFx8/eAeHIigqBnFpYuQVFaKwtATF5WVIEacjKSkBERFh8Pb2hLu7K8LCQmBtbQVHR3uYm6+Di4sT1qxZBROTNTAzM4WZmSkWLPgFM2d+i88/n45/v/oSPv/mC1jZrcevv/+G35cvwVczv8Yrr/8H9zx4L8aMGyuPAi0h9EU6mDBhAqZOnQqBQMDYYmwxtv4ClI0tVQ8VlkqlSEtLU+q5pVLVt47fuXMntm3b1q/HdnR04MSJE9i1axc2btyIjIwMpKWlYdOmTdizZw9Onz7d759jOGLLzu4yRmnKoPm5DIKfZdAaLcNrb3aiqEi9GzrcLrb6Gi0tLTh8+DC2bduGsrIySCQSZGdno7KyEtO/aIHWaBkEqwGBFSC8R4bnX7mC1tb/u37e/IvQNJBB8IcMAjNAeLf8MS0t6v0Z+5phGoqxZ88eVFVV9ficgYEB2tvbh/ulhZTA2BpBGFtDH1s62iKMNjTCHRMmYuzECZjy2KNYsGABzMxXY9my3/DTrK/x0jPT8NK/X8B3336Nr7/6Ah9+8B5+nvcjHJxsERTij+DQAISGh8HZ1QVxCfHYuKkSFVXV2LZrNzbV1iG3sAjZ2ZnIzJQgLy8HhYX5KCzIQeyGSAQH+cHD3Rk+3u6IjAiBrY0lAgN8EBjgAy9PVzg72WHRwvkwXrMCP8z6FrY2llixfAkiI8MRHh6KmJgohIQEwdRsLaysLeHh5Q7L9RZ456MP8I+Hp0BHR0e+C6GODkaNGoV33nmHscXYYmz9BSgbW6oeKiyVSpGeno6Ojo5hia1du3Zh69atff5ZS0sLDh48iM2bN6OoqEgx27J582YcOnQIx48fV/qMr+bmZqXvNesdWy0tUnh6XsKXX13BkiWXsW3bxRuuOXVKCm1dGQTB8jdyAgCCvYCGUAYHh22D9qb/3Ll2mJhIcddDVzHuzquYNfsiGhvPo71dtQ0r2tracPLkSeTn74dglAyCout+jsPAKC0ZfvutE/7+nbC378QoDRkEWT0fo6EtQ3x8h1qjp6GhAZWVlUMeW7t370Z1dXWPz+no6KCrq2sYX1VIWYytEYSxNbTLCLvPrJo08Q6MMTDEfVMewm8rl8LBwQFz5nyL3xfOxQ9fT8faZYvx808/wtXFCcFBAXBzdYarox2iwoJhumYl0pLiUV2/GfnFJajdshXV9Zuxc8cWFORnIzUlASnJ8dgQEwEPd2ekpiTA3c0JaclxSIqPRkigD/x93OHt4Qxz09VYu2Y5lv7+KxYu+BnL/1iIJYvmw2ztKtiuN8PqFUvgYGuJtWuWw9LCDLY26+Fgbwt3NxdYma3D0sWL8ME7b2PJwt9g5+4CMytLfP3tN3juueegq6sLoVCIxx57jLHF2GJs/QUoG1uqHioslUohFot7bG0+kKHqOV3dsdXZ2YlTp05hz5492LRpE7Kzs5GZmYmNGzdi9+7dOHny5A1BqMq286ps7HHgwAFFbDU1SfHk81chHC+D4AcZhC/KoCWSQSK5iM5OKbZtu4iwsEuYMeOKPFIuXRcgALRfk+H77w8r9QY/KKgTTzx/BZPuv4rPv7qEzZvP44tvLkF4hwwCJ0AQBAiflOHBR67i7NnB2R1ww4ZO+YyVrOfPIXgcEAiuG0Lc8Bjtf8tgYiJVa/Ts3bt3WGJr165dqKmp6fE5TU1NXL58edheU0h5jK0R5Haxdbv4ujG2em+QodqGGarE1lCPvoKh+1BgbS0hNDU1IRKJMG7cOOjr62Py49OwePUSrDdfjh+++hDzf/gWP3//BVav/BUrVs5HSGgAfHw9ELMhApFRoUjPEmNTXRXE2RLUb9+M8rJC7NyxGRsripGTLUaQvxdio8MQGx2G6IhgxMWEIyk+GpFhgQgN8kXshkiEhwUhwN8bHu7OiI4KQ4C/t2I2y9PLFe4eznBytoOPrwfsbK1gvd4cy5f9jkUL52PR0sWwsLGEsZkJ1lmZYd6vC2BqYY5UiRjm660wc/YPWL3WBF9++w1cPNwxbsJ4TP3XY7jnvnshEomgpSW/R01HR0cRT90B1f3vN4utvmKkZ3zc+u+i9xv82/357WLrZgFwu0Dob6D0HjrauvLHaYkg1NS+7eMH+vyqxdTAfpbBup6GnrKx1dzcrNI5V1KpFBKJROnYUvacrra2Nhw+fBilpaXIyspS7JBXV1eHAwcOoLm5+bb3kQ1nbFVVVUEqlcLF5VrcnL4WFTJAMF8GkZEM+vqyngEiAATbrwuQS4DWnTIsWdIw4Df3Dg5d0BBeW6YXAGi9KoPhOBkEAhkEpdc9RzOgZShDUFDnoMRWVdUF+c+x5brnaAJG6cjw6aeXsGRJO77+uln+mPrrHtMGCPRk+Oijizhxoh0+Pp14/X+X8fr/LsPHp3PQlhfu3bv3hnunhmLs3LkTtbW1io/b2togEAh40PEIxdgaQRhb6ostLQ1NRUwINbWgo6MNIyMDGBjo4emnn8Qa4+VYuWQOPn3rGXz3yRuYN3s6Vi9fAFcXB6SnpyM4xB+eXq7w9fNEUnIcQsMCkZObgcKiXOTkZqC0KBN52SlIT4lBWXEWxBnxiEsIQ1JKFGJigxEV5gtvdztEhfmiKC8diXFRiIsJR0RoAGKjw5CUGIuU5HhkSFIhEadgQ2wkLCxNsXTZYphbrIXZOmOYrl0Ns3XGWGuyCo6OzoiJicWGDXFISkpBWFgIHBzssGrVCqxYsQxeXh4IDQ3GV199gR9++B7mlhb4f2//D08/+wxee+013HfffTA0NMTEiROhK9JRHHbcfQ7X9fHF2GJsMbb+fJSNLVW3XpdKpcjIyEB7e98bSdxu9Oecrq6uLpw5cwYNDQ2orq5Gbm4uJBIJysvLUV5ejo0bNyoVe6qE5mDF1gefXIFgfq9Znq3ysNLXl+HVV6/i998vIzT0Ep57+SqEj8kgyAAElYDgY2CUtgwBAbUDemPf1NSOMRNlELj2DDfBlGux1WtGSfRfGVaulA7a7oD/773LEN4ng8APEEQBwqfls2fnzv3fY97+4JL8MUGAIB4Y9ZwMAm15fOroX4aGngyCBTII5sugZSDDt99fHJTo6eveqaEYO3bsQF1d3XV/R03Q0tIavhcUUgljawRhbKkvtrpnarqja+IdY/HgQ/fi9Tf+gxmff4KFc77Bgm8+xNI50zH3++mY+c10mJqugK+/F1abroG9gzUcHG3g7eOO6JhwlJbmIicnDVVVJcjJSUNxTgrKC8RIiw9DdIgXxClRyMmIR1FeKiSp0UiODkJ6XBjiwnzh52oDH1dbuNlbwNNpPYJ9XBAeFoTIiBBsiIlAZEQIwsKD4OXtBg9PF/j6eSIlOR6hIQFwsLeGleU6ODrYwcPdFW6uzrCxtsKK5Utga2OJdaZr4O7mBHc3J0RGhMDF2R4W5mvx+x9L8NPcn7HGxBhvvvkmHn74Ydx3330YO3YsJowbj7Gjx8BQ3wB6OrqK+Oqe5WJsMbYYW38+V69eVSq2VN16XSqVIjMzU+nY6uucrvPnz+Po0aPYvn27YnOFvLw81NTUoLGxEefOnVPMWu3ZswebN29W6rlV2eRCld/b9bE15+crEP5P1jO2kgAtkQznzvW87uRJKaZ/cRkaWvLomHj3VQgEwOTJnWhoON/vN/b79p2Xzxzt6hV5CwGBlgyCvOs+dwbQ1JMhPLxz0GLr1Kl2LFx0EWMnyaA/Voavv7uEfft6fv8nT7Zj9o+t0B97GSJ9GT77/BLy8y/gjTcuyb/3yuu+xwp5nCYnN+DIkSMqHbrc171TQzG2b9+O+vr6635Hp6CrqztcLyekIsbWCMLYUl9siYTa0BylAZFQG+PHjsPUx6bgkUcfwiv/eQEffvQOfpj+IYwX/ICP33/3OXIAACAASURBVHwB3303A2EhkXB1dYWbjxM8Apzh5++FuPholJQWIC8/C8UFmajaWISk+EjkZqViQ7g3rM2WISrEAzUVOagpzEBCiDeifF2QGhmA7OQopG0IRtqGYCSE+2JDmA+SYoKQnhCO2HBfxESHIzoqDFGRoQgK9IWXtxvMzE1g72CNwCBfRIQHw8baArY2ljAxXglvD3ssWfQzzE2Xw9HODO4u9vBwdYC7iz283J3g4eoAZwdrBPh6wMvdCW4e7rBzsMeKVSthZWWFN998E1OmTMGdd94JkVAbuiIdGOjpY7ShEQz09KGnowuRUBtaGpqMLcYWY+tPSNnYUnXrdalUiqysLLS2tip1bUdHB1JTU9HY2Ija2lrk5+dDLBajtLQU27dvx9GjR28Zcnv37kV9fb3SsaXs7NRgxVZl5UVoaMogMAYEjYBALN+db87cKzf9fR050oRDh9rQ2tqOjz+WL8ubNu0Kjhzp3xv7pqZ2GE2QQeB5XbBcBoT/kmHaE1egNUa+A6DAFRD+U4ZHn7iCc+eG/tyrvrZh9/Tsks94oWcoat93FevWHUJhYSHEYjEKCwtRV1eHxsZGnDlzpt/P2de9U0Mxtm3bhi1btig+PnbsGIyMjIbxFYVUwdgaQVSNrd6HHKseW7ce6o6j3n+uyqYM2kJD6OoYwdBwNO69917848GH8MYrr+DNf7+Abz5+F8sWzsGnH74FczNjBIX4w8XBAtYWq+Hr6YCEDSEQp8RAkhaL3KxUlJfnIy8rGYkxAYjwd0CYpxV8XM1QmpeA2HB3RIe4IMJzHfLSw1FRkomMjCQkJUUiOTkKGRkJyMpKQnxCDGLjoiDJSMXGylIUlhVBnC1BRm4myqsqkJ+fi4SEOAQG+sPV1RnOTnYIDPCBp4cLTNeuhuna1TBeswJL/1iE+b/8hD8WzoOjjTmcbC1gaboKNhYmcLQxh7nJCjhYm8HB3hr2duvh7GQHb29PmJuvwxdfzMB//vMynnnmGTzwwAPQ09ODrq5uj39239+lpaUFoVCoCCqhUCgPoT42jrj+76E/M2NaWj3H7eOk13NoD2wMNChueP5ecTnQ63tuDjK4cTTUccbYGj7KxlZ7u2q7AUqlUmRnZ/c7ti5cuIDjx49j586dqKioQEZGBlJTU1FVVYWGhgacOXNmQD+HKrGlylLAwYotqVSK2NhLmHSffLZKUyjDrB+voKWl72t7H2rc0HAIL7zQBIEAePnly8jPvwAHhy5ERXXi7Nkb39SXll7A3LkX8di0KxBoyiBYAQjCAa035fds7dhxHra2XXjkySu49+GrWLjoIg4fll976NAhlJQMzTbzN4utlJQO+b1mp66LrZPyXRlTU+U7Fba0tODIkSPYvn07ysvLkZGRgaysLGzcuBE7d+7EsWPHbnrocu97p4ZqbNmyBVu3blV8fPDgQYwbN264X1ZISYytEYSxpb7Y0hEZQCDQwCOPPIJ77rkLb7z2PD545z+Y+fVH+P6bj7D8j19hb2MGb29nWFqshZ+XI4L8XBEXHQRbK2MEB7gjLSkCqfEhCPFxhJ/HegR62iAq2BlRgU6ICnFDSlwgCrPjIU4KRXJUIGJD/ZCfJUZZUT7y83KQn5eDnOxMFOTnoriwCFvqN2NL/WZUVW7CpqpybNlai63b6lBQmIPQkABER4XB388LgQE+CAsNhJurI1xdHODh7gxXFwc4O9nB0cEGq1Yuxbo1y2C6eilsLEzg5mgNTxc7eLnaIzLED/5e8mWK/n5ecLC3hoWFGSwszODp6Y7Vq1fi008/xf/+9z9MnDgRhoaGEAqF0NXVhUgkgo6Ozv/NQN0ktnR1daGjI48QoVAILQ3NHss3GVuMLRp8V69eRUdHx4APF75w4YJKuwF2x1Zzc/MNn+/q6kJzczMOHDiA+vp6xaxDcXExtmzZgsOHD6OtrU2lQ5EbGhpQV1endDApG1uqzAgeOHAAmzZt6hVRUuzeLcXp07e+tndsHTp0CNnZZXj22SsQaMqX04kelUFTX4a7HriKLVv+b3lecLB8S3XhWzIIZskg0AM09WUYM+kqPp5+CbW1F24ZBEMdW32dedXS0o6H/3UFwudlEIgBQTogeBLQMZLdcDBy92hra8OpU6ewd+9e1NTUKGZPuw9d3r9/P86dO4f29hvvnRqqsXnzZmzbtq3Hzz5p0qThflkhJTG2RhDGlvpiSyDQwNSpU3HHHRPw0D/uxVcz3sUnH72B999/E8YmK5CZLYavnwe83B0Q6OsCf28nRIb6IDzYC5LUDRCnxiEh2h+xQS7wsVmJQLd1CA+wQ4ifHaLCPZCWFIENkX4oyElGfnYSxMmxyM9Kw5aaCmwsyUN1VTmqq8pRW7MR5WWF2FhWiPwcCXIy05AlSUFiYhSiooKQlBSNuLhwiFPjIEmLR1xMKPKy05CUGAt/Py94ebrC28sNzk528PP1hJ+vJ2xtLPHr3B/wy5yZWLzgJzjZWiDE3xP+Xi4I8HaFr4cT/Hw9EREejLhY+blcvr7eioOULS0tsWrVKixatAjTpk3DPffcAyMjI0VsdYeUtrZ2j1muvma2dHR0YKhvAEN9Axjo6UNfV4+xxdgiNeie2RpotHR0dCi1G+D1Izc3F83Nzejo6MDJkyexe/duVFZWIisrC1lZWaisrMSePXtw6tSpPmetVDkUed++faitrVU6tpSdnVIltg4ePHhDbA3k76t3bJWUlMDNrRMCkez/7mVqk89W/efNy2hvl5+fNWaiDALL62aEDsljKySks19BMNSx1dDQ0OcBww0N5/HRZ5egqSWDhpYMYyfK712bPv1Sj4ORbzWam5tx6NAhbN26FaWlpZBIJMjJyUFBQQFKSkpw4sQJxe94KEZ9fT22b9+u+Hj37t24++67h/lVhZTF2BpBGFvqi6277roL9913D556ehpm//gNli38GWtW/oHg4ED4BQXDO8AHHl6uCAv2QbCPE5zszJCwIQSJsaHIliQgMjIQXk4W8LdfA8c1c7F+9Ry4269EaJAjAvzskZQQCkl6DBLjQ7C5rgRVVQWoqszD1roS5OfEo6AgDUVFYqSnxyAnJwklBWlISwpHRlo0CnOTUVKYhcI8CfJz0pElSUJuRgoiQ/zg6+EE09VLsdZkFfz9vBRbxNvaWGLVyqVYsXwJzM1M4OVqjxVLfsVv82Zj0fw5WDR/Dpb8NhcWa1fCzHg5PD1c4ObqCG8vN0RHRyI0NFhxKHJKSgpsbW1hamoKMzMzvPnmm7jnnnswfvx4jBs3Dnp6eooZrr5iS1dXF/r6+jAyMsKYMWMGfM8XY4uxRQOnbGz1tUHFQGLl0KFDkEgkKCgoUNwrU19fj4MHD6KlpaVf3096ejpjS8XY+uCTSxg1u9e9TCXyma59+9pRWXlty/WTPe910pguw5w5/dvJbzhi61ZnXjU1ycfBg+fx4IPy4Fq+XLlzuLoPXS4vL0deXh5yc3MhFotRUlKCLVu24ODBg2hqalLbz1pXV4cdO3YoPt62bRseeOCB4XxJIRUwtkaQ3rHVe9zuUOPu4DLQ0oCBlgb0hcIeYzhjqz8xdas/7z1ud6ixSCRSnKVlaGiICaP18fS0R/HtF59h7uyZWP3HL7A0+QMWxkuw3nQZnK3WwN1+Hfy97eHpvh6RYf5IjA1FmJ8znCxXwtbkN6xeOBNWq35BTIADIoOcsCHMDc42K+FiuwpZadEozk1GYXYiNhZLUJwvRkFOKory0lFTWYiSvCRkpUWiICsOmakRSE0MQ0SIBySpUSgvliAjJRK+7tawt1oFW4sVMF25GJYmy+BgZYKEqCAEeLvC0cYc683W4OcfvsHXH72DP+bNxi8zv8Rvs7/F7O++xrLFv2HR/LlwtLGCucVarDFeAav1ZrCxtYSznSW8XO3h4+4ID2cHeLk6wc/TDfHREQgLDURkRAhcXRxgY20Bd3dXfP75dDz66D8xceJ4GBoaYvz48bjrrrswZswYaGtrQ0dHR/H7FYlEMDAwUETIhAkTMHHiRIhEImhoaAw4vG8XS0KhCEKhfGMMkUgXIpEutLV1enz+1uN2z9Hz8Trauj2GqrGlSuyoHk+qhefNvh4NPWVjq6urC6mpqf2KstOnT2Pv3r2oqqpCdnY2MjIyUFFRgczMTOzfv1/ps7bEYvENBw73dzQ2NqKmpmbIg6m9Xfl73dQRWx9PvwSNmb1iK18eW0KhDC++eFl+KHLZdX8uA4RTZXjiqSswHC/D6AkyzPvlIo4d6zsIDh48iNLS0iGLrYGceVVXdx5jxsjve/P17d9MXV9j27Zt2Lx587WYa8KBAwewefNmFBcXQywWIy8vD9XV1di7dy9Onjw5aLNftbW12Llzp+Lj+vp6TJkyZVhfU0h5jK0RhLE1eLGlra0NDQ0NCIVCTJo0CY/84y588dm7mPXtZ5g35xtYr1sOS5M/4GyzFn7utvB3tYav63pEh3sjOtIHcTGhiI0KhLv9Otia/gHzNQvg5WwKT6e1cLBaBmeblfB2WQdfN3MkRnsjMSZAEVyVJRkoLUpGSWES0lNCkCWJRGF2IipLMlBdno1ttcXIEscjMtQH3u52sDJbCTcnK3i4WMPX0wHB/m7YEBGEpNgI2FquhYezLcxNVsB4xe9Y+cdvsLVci1/mzMS3X3yCt994BcsWz8eaFUvxy0+z8ftv87F8ySI4OtnC28cdzi72sHewhv36dbA2N4at5Vr4uLsg0McTkSGBCA3wRVRkqHy7+dBA+UHLAX6IiYnC8uVL8dhjj2Ly5MnQ09ODtra2YvZqwoQJuPPOOzF58mRMnDgR48ePx5gxYzB+/HhMmDBBcf+Wrq6uWmKrO7R0dPSgo6PXI7gYW4ytvwNlY0sqlfZ5z1R7ezuOHDmCbdu2obS0FGKxGPn5+aitrcX+/fvR1NSkuCY/Px9nz55VKh66Y0vZUNu/fz+qq6uVDqa/SmxFR3dCQ/vaGVwyQHAc0Hxehkn3XMX48fJZH4EWIHgAEORc2/Z9ngwCkQxaU2UQhAGCIEA4RYYXX72MtrbBia3W1nYcOHC+xxla6oit9vZ2SCQd0NKSQVNThqeev4Jxk6/ihf9cQVJSR7+/xtatW3vsCtjzZ2nF8ePHsWvXLlRWVir+D4eysjJs27YNhw8fVnrb+ZqaGuzevVvxcXV1NR599NHhflkhJTG2RhDG1uDFlpaWlmLm5bHHHsP0j9/CD999ioXzv4eN5So4WZvA3cEcEYHuiAn1RnSgOzaEeiEsyA1eHtbwcLVDaKAH/N1tEOC2Hq72JnC0XgUvF3N4uZgj2McGqXH+yEgOQXFOHDJTo5CfGY+CrAQkbQhElngDKsuyUFdVgLqqAhTnpKEoOxV5kkQEejnBw9kWqQnRKMwRIzkuEjExIQgP90dCQiQiIwPh5+sBN1cHpKclwnq9GWwsTOBka4Hlvy/AujXL8NPPs/DbwnlwdXPA5198gjk/zcJvC3+BhaUpLCxNIZakwMnZDpZW6+Dj6wE3R2vYWJjA0nQV1q5aDhuLdbBYuwahAb5wcbaHn68nggJ9ERkRArE4DWJxGuLjY+Hp6Y5vv/0WTz31lCKmjIyMFDsWikQiRYhdv4Nh9+++r63gVY2t60NLV1f/huBibDG2/g5kMplKsXXmzBns27cPNTU1yMvLg0QiQVlZGbZv345jx47h/PnzN72+sLAQZ86cUTq2JBLJLb++OmNL2WD6s8VWW1s7Fi6+iFGjZBBOlGGUpgyPPH4Fe/eex8mT7XjuucsQCAAtXZl8hqs7vjTlYaaY7doHCEbJkJ9/42YZBw8eRFlZWb8DIjy8E5MfkIee3mgZlq+QoqVF/mepqR14+sUr0NaT4Z+PX0Fo6I2zUcocMLxyZRcEGoBghgyCSGDUzzKM0pAhLq5/wdV7V8DbjbNnz6KxsRF1dXUoKiqCWCxGQUEBamtr0dDQgNOnT/dr9quqqgp79uxRfFxRUYHHH398uF9WSEmMrRGEsTV4sSUUCqGnp4c77rgD7733HmZ+/SGMV/4KJ7u18PW0hb+HHfzcbeHpZAlXu3VwtzVFoKcdPF2tEBrshvAQX4hTYhDu7wI/F0v4edkhyM8JibFBiInwgZ+7BbycTeFssxJezqZI2hCI5NggZKREYt/OKuzeVov8rDSEBXojMy0B9ZUlKM4Rw8/dEVWl+dhUVoRscQrSk+IQGxmKzIxUJCbEICY6DIkJMSgsyIGvjwdCQwJgY20BOytTLPltLqzWrcaKJb/C3dMFYRHBWLl6GSys1sHV3QnOrg5YtWY5VhuvgI2tJcwt1sLZxR6eXq4IDfCCq8N6eLnaY9XS3+HuZA9PF0d4ujjC388L/n5eSEmOR+yGSKSnpyIhIQ5paSkIDg6EWCyGj48PZs2ahfvvvx9jx47tsSFG9/1choaG0NPT67FroUgkGvTYuj60ukd3bPUvuBhbjK2RbyCxdeHCBRw7dgw7duxAeXk5UlNTkZubi+rqauzbtw9nz54dULQVFhbi9OnTSsdWRkYG2tuVOxS59zbqQxVM58+fV3oXx0OHDg16bHW/Sd++/Tz8/DqRnNyB1tZ2nD3bjrfflofWU0/Jz+I6cKAdUVGd+N//LmHUQ32cWXWXDP7+N8bPgQMH+h1b2dkdGKVx7fywrYAgBNAaLYOJiRQ5OR3Q0JRh1E8y+W6Cy+VxGBbW8zmVia33P7mEUR/2+pkWyPDEc1f6dX3vXQEHOlpbW3H06FHs2LFDscQ2MzMTFRUV2LFjB44ePdrntvObNm3C3r17FR+XlJTgmWeeGcZXFFIFY2sEUTW2em+QoXps9Xz8QILqxj/vvUlAH4F0i3G72NLRFvXYLEOorYfRo0fjv6+9hC9nvA8n6xVwszOBs7Uxwnxd4OtiC383W3g5mcHL2QRWFivg6myBmCg/JMQFozw7HtZrFyHQ2xqJcX6ITwxHVIQ3YsLc4O9hDieL32FjuhhuDusQFuKB1PQk1NSWIzc7EXGRvogI84I4LRp5OUkozE9FeXEG9jdsRXlFATJz0pGXm4HkpFgkJsQgMyMVGZIU5GSLUVqSj7TUBKQmRCPQxw1Bvu7w93JBRKgfAgK9ERMbjej4GIREhWGt5TpY2FohKj4GPr4ecHG2h42lGRxtrLB40QJ4uDvD3m49vDxdkZ6WhOAgPwQF+iIw2A/ePu7w9XSDi72NYglhRHgw0tOSkJmVjg2xkcjOkUAsSUFiWhI8/bwQGhWGub/Ow6PT/oVxE+TLBvVFOoqdB3VFOjeP31uMgb7B19HRUcyi6enpQV/fsMfofQ/X7TfguHXs9d5x8cZDnFXccKPHtQPb3GOgcTXwmGJs/VndLLa6urrQ1NSE/fv3o66uTrGRRUlJCbZu3YojR44gPT1d6WV8UqkURUVFOHXqlNLXZ2Zmoq2tTalrVZklUiWYVI2tysrKQY+tgwfb8dnn8l36BALgldcv4/XXL0EgAB577AoOHuz5Bj83t0M+y7X7ujCpld/ntXHjjTNb/YmtU6fkZ2G98uplaHzaK3q8AW19Ge596CpGfd7rz5bJ8OiTPYNo9+7dqK6uHlDs3P/I1Z6HNQMQpAC6RrJ+Xd97V0BVR1tbG06fPo2GhgbU1tYq/vfXve18Y2Mjzp49i8rKSjQ0NCiuy8/PxwsvvDBMryakKsbWCMLYUj62uv9dW0sIHW35xgz/euyfmPXtZ1jx+08wXzUP61bMg63pH3C0WAWn9WvgYLkKViaLYW26BFFhXogM9UR8TABCAlzgYrkcId42CA90hJP9aoQEucLe1hjBAY6IifSCt7cj/PzcUFaej7LyfJSXZCM1OQKS9BiUFKSjtDAdWeINqKnMQ1mRGJvy0lGRl47ctHhsLMpBTmYSsiQJKMxLR1lxFgpy05Apjoc4dQOiwv2QlhiDuKgQeDjbwtnOEimJ0cjKTkd4ZBiCI0IQEhmKDYmxCI2Sf+zj6wFnJzu4Otph5R+LsXrVMvj7ecFsnTGCg/yQnpaEyIgQ5GRL4OruhIjIEPh5ucPZzhqOdlYICfSBJC0RyQkxiNkQAUlGKpJT4pGTm4GS0gL4+XshKNgPAYE+cPVyw0NTHoSRkQHGGOgrQksRK9f+HrrHUMdW73u4eg/GFmPrr6A7ti5cuIATJ05g165d2LhxIzIzM5GdnY1NmzZhz549OH369A07/2VkZCi9jE8qlaK4uBgnT55U+vqsrKx+H4rM2OrAuXPncOxYG0xMpJj2nBTP/rsZ4eGdePalKxA+fu38qUJg1BsyCITAP/5xBY2N5/sIgXa88fZlCO+UQWAOCNYCwvEyfDLjUp/hcLvYio3tgMFYmfzQYQ0ZBOMBQf214DkACBzlIScQAQL3XkGUCugY9Ayi3bt3o6amZkBx88Gnl6D1sUx+39q1rz1qvgxPPt+/ma3euwKqY7S0tODw4cPYtm0bysrKkJGRgfT0dBQVFWHXrl2KHT5feeWV4XxJIRUwtkYQxpbysaV4464lhK5IB5MmjMYH77wG4+XzYLzsR5iv+BFrFs+E+fJ5sFz5K4yX/QSz1fPhaLUakQHuiA5xQaifHXzdzBHgaYUAF3P4upjB2ux3BPrZwsVuNRJi/REZ6YuICB/EJkShqDgbKSnR2LQxF8U5cdhYnI7SQjE2bczFlqocbCxKQa44EpKkYOSnRiAp0hebijJRmJWCyuJM1JTnoqJQgpTYEOSK41CYlYQ8STxS40IREeyL0AAvJG4IR0ZqPIIDPOHq5oD4xDikZ4kRGRmO0NBgpKYmw8ZmPdaZGSMyIgTO9jawWmeCsNBAWFmug62NJVJTEhAVGQpXFwcUF+XBwckWiUmx8PV0Q2RIIKKCvbEhzA9Rwd5IiApCQuIGZGalIyk5DjEbIlBRUYDMzGTY2ZnD09MRds62cHFzxKNTp+COcaMx2tAIow2NYGRgqNjy/VZLRIcitgZyDxdji7E1EslkMjQ0NCj+X/PNmzfj0KFD/YoYVWaWpFKp4lyi4YgtVcLlwoULSp8xpsq1A/2eW1tbceDAAdTV1SEvLw+JiWL8Y2o7hPdehWA5IPhQBsG12SxBw3UB0wEIDGRwcOi66Rv/M2faYW4uxdSnr+Bfz16BjU0Xmpr6fuyBAwdQXl7e55/t23ceQpEMgjXXnvccIPhcBsG9gODra5GlIb9fbNLdV+UheH0Q/SjDsy/1DKJdu3YNOLaKiy9ASySDxgwZBKGAYLb8nq2EhP7dszUUsXVj9LahpKQENTU1qK6uho2NDXR1dXHHHXfA2NgY2dnZw/raQgPH2BpBGFuqxZaWhqYitqZNfQC/zvsW61bNhZXJPDiaLYDlijkwWTwLxgt/gLPNMvi4msk3wHB3QIi3DSL8HeBqswqeDiZIifRGoIcVIoKc4Oe9HjGhzoiN9kFUlB9y8sVIFycgMT4ExdkJSI72QmK4KzaVpGHvzmrU1JSgPC8RZbkJKM2JR2lOPLJSQ5CVFo783CTs2LEJm0ozkZch31gjIsgNkcHuiIv0RdKGQKTEBSMzLQFJsRGIDgtAclwkJGnx2FhZAkmmGKFRYUiIj0VkRBjc3VyQIUmHu4czQoL9EeTnjbiocNhYW0AiToGzkx2CAn3h5GgLJ0dbFORnwy/AG+niZCTFxcB09Qr4udvC2WYtAr0cEBnkgajoMEgyUpGdI8GG2EhUVxajamMRgvw94OFqB59ALwSG+GLZ8sV46vFH8eD9D+ChBx7EXXdOhp6OruIctO4x1LHV+x6u3oOxxdj6K5DJZGhra1NqOaAqsSOVSlFaWorjx48rfX12djZaWlqUuvbw4cN/qdjqXvbZ2NiI6upq5OTkIDMzs8fB0L6+bdA0lEGwFhDoXgsZASAQyiA43Ov+q2dlMDdX7uyp3mP//v03jS1Hxy5o3y+D4Op1z98ECAQyCCYCgvJruyRmAJoGMmiJZNB6SwaBGyD4BNDQkkEs7hlEO3fuRG1t7YC/z4KCC3jr3cvQMpBBoD2wreB7b8E+VKO8vBz79+9XfBwVFYVnn30W69atw+LFi4f1tYUGjrE1ggx9bN0uvgYvtlSNq9vFlra2NjQ1NaGpKcTdd9+Lr754F9YWK2BrthzL5n2PebOnY/26JQj0toXD+pXwcLSAp5MlIgLdkRQThGBfR3i7WiEmzAuh/s4I9LZHiJ8TwgNdUZidiEB/ZyTEBSNTEou0lEhEh3oiPTEMGSmRSE8Mw/59tdhUkY7EDZ5IS/BGcc4GbKnKQsP2EuzaXIDKonhU5MQhzMMaPtYm8LVehdggF0hSo5CQGIL0lFhEhvkj0M8d9jZmSEyORHFJDjIyUxEZFYrsLDEyM9KQnBSHpMRYxMdFIzIiBMlJcZCIU5CRnYLMzGTERYXA38MJKSkb4OS0HiEhPggM9ISd/XpEx4QjMSkWSWIxSstLkBgXBcs1y2FnZQp3Jxv4uDsiOiwAvj4eSE6KQ13tJpQU5yMpMRbVVRVIT0tCYIAPQsND4O/vC083R8z4+F1MnDAaY8fI79syMhjdRyAMLGZuu2HFtc0x9PQMoKdn0Eds6fYa+j0309DWlYeJlgh9HSzc139r1w91xtbtvhdVN7RQ/ev3/XdLQ0+V3QhViR2pVIqysjIcO3ZM6etzcnLQ3NysdGxt3LhRqWs7OjqQnp4+rLHV1dWFs2fPKrY5z8rKQnZ2tmKzknPnzvX4O+3o6MD8+V3QeE4m300wDBBcAgTVkM8ivXBd7OyQzya5u7eiuVn186B6x1Zbm3xXwfnzL+K11y5D+Giv+7A6ry0Z7H0P1Srgn49fwedfXcK4u69CoAV8882NBysrG1vd49dfL0IgAIKD+x9bNTU12LVr15DHVllZGQ4ePKj4OCEhAe+9957KrwtnzpzB+PHj8eyzzyo+d+zYMbzzzjvQ09PD/fffj6ioKJWfh3pibI0gjC3lY6v7jbqRkQFmfP4JXKxXHa0f/wAAIABJREFUYtXiHzB/5seY9+2HsLdeAye7tbAw/QPrzZcjwNMeCVEBiA33RWy4L9ITwxDk44CMlEiE+DkhIdoX/p7WCPFzgLPtGqQmhiMmwhchAa6QpEYjPsoP0aGeKCtIQ0FWAuJifCFODkT9RjFqihNRkhaB/MRgpIS6ISHQCT6Oq+DhuAb5eXGo2JSFkpxkZKZvQGJiFMSSZJSWFaKwKBdp6UmIi49GaKg34uMjkCFJQVZmOlKS4+Hj7Y6w0EBkZ4mRkhyP1JQExMdFIzcnAwEBHvIlftbr4OPphNzcdERHByMszA/+/u7w8nZDZFQoUtMSUVJegKzsdBivWgoz4+VY/vsCLF7wE0xWLoGZ8XK4uToiMMAH+XlZyMxIQ2ZGGqo2lSM7S4yI8GDEJ8Zh9eqVyJKkYOUfv2HGjA8wZrQeRhvpQUckHPTY6j0zxdhibJFqsaVK7EilUpSXl+Po0aNKX5+bm4umpialrj1y5AgqKiqGPLaUvbazsxM7d+5Efn4+KioqkJGRgby8PNTW1uLAgQO3jN66uouIj5di5coOjDKQQTCzV8TEXdvK/TtAMB8Q6F/b3l0AjJvc9f/Ze+/wps7z/1/GNtOMNKtNm/TTb5sm/XSkyadpkrbZCSQBQiBss4fBBu+9lyzbkiVZsiRLli3vvffGC9vsDYGQEEgYIRNIALP0+v0h27ENBGOn8KPV+7ruy5yj5znnyDLPpdd138/7RqnczwcffDDkZrwff/wx7e3tvaC1ZPklLCyNWE0xYvmn7jLGnO5nuQaCoO5sW8aA54yC3/7xGufOmdwTBQJ44onr91Tt27eP7du3DxlgEhMvIBCAg8P1IHez2LJlS79+V3cqWlpaOHr0aO9xdnY206dPH/a6YGtry0svvdQPtl566SXs7e25cOECTU1N2NjYsHPnzmHfy6wfZIate0hm2Bo6bI0YYYWNjQ3P/v2vuHs64O6wnLVL5+Lpaoefz3ocHJYhFPoRHy8lOzuJ2rIcMg0qyvJTSU9UoldHU1eRg0oWRnaqGr0mHI0iiJz0WIrz4knVykmME5OfpiM/TUdmchxVJRkkxUuoq8ihIEtLVWEiNYV6SjMUNJSkUFdkoL44mYocLbVFCXQ0FrB3eyMHdrXS1lhMa0MJTTUldDRVs3v7RnZsaaGtqYoNdaVsam+gvqaU5sYaGmurqKkup7amgpLifJISteRkp6NP0BAhDEGnVREZFkBMdBjePi6UVxWi0ynIz09HLo9EpYpBnxhPbl4mHZ2t1DcUkZmpIyZGiDA8iFhJBMF+HkSE+BEa4IVMGo1SISU1JZGS4nxamhtoa93AhsZa8vOyaGxqICMjjdKiXFL0aqZM+SfPPPMko0eNYOwYM2yZYcusO6HhwNZwYKerq4v29nY+/fTTYcHWV199dcdh68KFC5SWlg4ZtvLzKzl1qovDh7uIiLiCr+8Vmpsv9Y7ZsuUSoaGXEArP0Nz8AW1tbZSXl1NbW0ttbS1Hjx4d1F65L7/s4rUpVxEIwHKcaQ+SYJQRgcsAiNnQXU74HggmgeAxI4JNIPgUBA5GRo65Rnn5Dmpra6msrKS9vZ39+/dz/PjxG9qRD4yPPvqoF7Z6nQw7+tz/bdP9R/6vkZG/MWI10sgL/7qC1d+MCM52j/kcrP+fEQ+PH0obn3rK9N62bu3vgDhc2Nq50wRyzz9/ZdBzBva7ulPR3NzMsWPHeo/T0tKYNWvWsNaE2tpaXnzxRQwGQy9sffTRR1hZWfH111/3jlu4cCEuLi7DupdZ/WWGrXtIZtgaRhmh9Vh+//vfM3PWO4SGeyIKDcLXx4PQ8CC8g7xJTdWh18dRU1NCaWkuapmQTIOK6pIsirKTiFdEkJ2qRhMrJCVBhkEXQVpSNOIIVzKSJWQnqchOUqGJCUeviCI9SUFLfTH1lbnkZ+rIS1OTkxhDqiocTaQHxXnxlBUmkJYkJitVRqImhNIMFVVp8dSl66kq0tNYmsqGknRq8pIpSlORkygjJ1FGenw0iVo5Gck6UvTxhAf5o4qTU1KcT1ZmKiHB/ni4O6OKk6NWxeLkaI88Kgx5TAQdm5vJzE8lJycFB4cVGAwaEhKUlJQW0NRcT3VNOfl5WkKD3UhMVBIZFUasJIIUvRqlNJIkrRKJWISHuzMSsYj8vCzq60ywt6mzjfaNzVTVVNLa2ozTOjuStErWrl3Ea689z4MPjmfMaMufHLZ6DC/6hhm2zLBlFly8eHFIsNXQ0DBk2Onq6qKjo4Njx44NeX59ff2Q7//ZZ5+xcePGOwpbp093MWf+FUZYXet21zNi/ZiRkf8wZXeWrTzHylWnEQjA+s9Xsf7VNUaOuYZG8yXR0V2sW3cGmewAFy4M7n52a69i/f+MCPZ073uq6c5YTeKHPVqXQPCWEcHvQDC/O8t0sA8IXYORjxsJCzNBzpdffnldE+vW1lb27NnDp59+ekP46gtb3t5djHphQNngRRBYGFm27BJRURc5ePA7Dh78jkd/ew2rSUZGvWLEcqyRPz1zlc8+++G6AQFdCAQQFNR/b9nevXvZsWPHkAHm7NlzTJpkZMwY401NPwbGwH5Xdyqampr49NNPe48NBgPz5s0b8lpw/vx5nnjiCfbt20dycnIvbBUVFfE///M//caKxWLeeOONId/LrOtlhq17SLeCrYkjLfrFrWDr9uFqeLB1O3FL0wQr6x++nPcAVfe50SNHMcFmfO+/rS2t+NsLzzJn3izksVF4uTvguHI5dktsCQn0IcmgpaK8iJrKAvIyNCTHC0lSh1CVH09tXjzpyhBEwc6Iw93Jz1CRpBERG+lFdIgz6hh/EhQhJKtCiA5aT5omikydFFHwemIlPmg1kWRlxKOJDSFFJyLXIKYsK5aaAgOtVTk0lqZTmhlPc3UWm5uLKcvV0lSVSWN+EkWJMvJ1EspT40hXhZKijCBHryYzQYteE4dSKkYlj8Gg06CNj0McHYGToz3rHOwICw9CJhcTr40jMUlLakoiGxprqKzMJzFRiUIloaS8gLyCXDo6N1NRnEtDdSnpBi0aeQQBno7ERAuJ15j6cyXq49EnaDAk6QgO9iY+Xo5KFYNCEU12VhrVVWV0drSyedNGSquKqSzLJ9THFV9Pe8RCH5754294e/KLjLAQ9H5mPZ/XrUwf+kJXT5PkvjEQlq6Dp+tg7Ppr9I1bw9LNgXD06NE33C84VFOLW8/9cRi63bjd6w/2szPr7miosNXY2MiXX345ZFjq7Ozk6NGjQ57f0NAw5PsfP36ctra2Ic29ePEiJSUltz3vtbeumvYnVWDKHM0yIvgZCL4EQbMJOAQCkxlEb0mdixHBSCPWjxoZ+co1LKyMvDPjKt9/3/M+urBdfJXRNkbGTjCydPlVTp0yvTZukhFB6oAslgOMGGtkxGgjVq9dw/LnJpt3m/uv8ednTE2MBd8PMMt41Yir643NMm7Ui625uZldu3Zx9OhRvv32236wJRJdZOT/DDDEOGLKbLW19c9QnT59Dp3uAp6eXaSlXbgOfDo6vkcggEk/u8aSpZeoqzMZZezZs4edO3cOC2Jef930u9i48fq+YTeKzs7OuwJbGzZs4LPPPus91ul02NraDnkt8PT0xMfHB6AfbKWlpfHUU0/1G5uQkMBzzz035HuZdb3MsHUPyQxbg4ctC4GAUSOtuP9nk3jj9VdZvmQBdsttcVq9hGVzp7Nq8RyCvJ3JydBTlJdKeUEaSfESNPJgkjTh5CbGoBF5E7RuMZGuq4gMcUEtCyLMfx0RQU5Ihe6oY/xRRvsg9HdAJVyHOsIJse8aon3sUIj9SEmIoawojeYNZZRka8jSR6OJdMMg80bivw51hCdx4e7EhriQrBCil4ZQYFAQF+FDrN96EoReaMM8iPFaS7jjCnzWLCXYwwlft/WIo4XESETIpFGIo4UoZNGUFedRVpxHRWkBhiQt4mgh4WGB5GSnUV6RhUwmIkGnJjszi8a6cvbs3EJpUS7ZGclIo8JQx4rRqWTIIgOJDvNDJhEhEYvIzkojTikjXqMkJVlPaWkuWm0sMpkIhSIajVpBdlYanR2tHNi/m/KaUuqqS2isKEQS6U9WigphoDvPPvMHJowfzZhRo3ubTJthywxbZv37NFTY2rBhA6dPnx4yLG3atIlPPvlkyPMbGxv54osv7gnY2rHjnAlkdvSBjCvd5hSx3cfPguDhAXD0bXeJ34sgaAPBAbCyMWIwXObChS7++PQ1rP9iRJANgkyw/oORp5+/xsWLXViPNiIoHHA9f3jq71fR6U6zcOExnnjCVIpXUHCe06fPYXOfEYGoz/gdYGFppKxscBbo33zzDZ988gm7du2iubm5t/yxrq6OI0eOcODAN4waa8TC3ojghMmMw+olI//79FXOnh08ZHz77Tlef+sKgrFGBEvA8m1TmWRs7MWfBLY8PU1ZM6Xy5vb3A2Grb3PhOxWNjY0cP36891itVrNs2bIhrQO7du3i8ccf58KFCwDXZbZ+85vf9BsvkUjMma2fWGbYuodkhq3Bw9boUZY8+quf88f//T3PP/d/TH71nzg5LMd21tu42y/G3XkVKmk4GXolmXolqkhvVFE+GNRCUnSRqGVBJCjCUEf6oQzzRBTsTJj/OmKjfYmLCUAR5Y0iypuIgHVEBKzDZ/1s3NfMRBy4HnGgI5Ge6/B3WIG3wyq87e3wdl9LqL8zoT72BLuvJk7sjzLaj/QECS01ubTUFtBQkU1rXSEttQUUFqeRm28gJy+JpGQlkeJgpLERKNViZAoRGUlqMg0aqoqzqa8oIEWnQCkJRxjoidu6lYQFe6GJE5ORqiVeJSElRUN1dTEd7c3UVJeTFKegLDeDpqpCFNFBaOOkGHRx5KQnoVeJCfRyIioihAhhCLFyCbk5GSgVUnJzMigvzyczM4nQUF+USjHRUUJqqsvZvGkjGxprKa4opLqikMxENTUVOfi42RHguY5ZMybzhyd/e32TYzNsmWHLrH+LhgpbTU1NfP7550OGpc2bN3PkyJEhzx8O7J04cYLW1tYh37ukpOSmv7Mb2bCLxZ0maOoaAD9vgMCru8zvt0YE9/fvIyX4rBu23uw2sagBwSIjNhOMPPnkNVOfrJN9xh8FwQgj7713hf977hqWzxoRnPkhg2T9c1NJ4NGjR8nP34SFhZFHHrnGt9+avqwnJl7AYoSRkc8bsZxuZMRII7PnXb4tEOoPRd+ya9cu6uvraW1tpby8HIlkOw88cqnXev6Z56+yf//1zZN/LHJzzzNipBHBoT7vXQFjJhjp7NzLrl27hgUxubnnEQhg6dLBmWR0dHRw+PDhOw5bDQ0NnDx5svdYoVCwatWqIa0DcrmcsWPH8vDDD/Pwww8zYcIErKysePjhh9m2bdt1e7ZsbW3Ne7Z+Yplh6x6SGbYGD1u/++1j/PKRB3npxef5+7N/5e2pr2Bvv5i1q+bj5bKM2JgQtEoRyWoJinA/EqK9yVAJSYkXIRd7E6+NQiEPQRTihiTcC4nQA4XYD6nIixBfe0J91iAVuhPstRovx0UE+6wmxNeeAI81iMO8CZP4kVWaStP2DTRsaWT33l00NdeTmaansjSH7Vta2Lmtjbbmajo31rNjZwudm+po21jF7j0b2b9tO83VNXRuaGJLSyttrY101FeTrZQT7+9DgKMd3muXExPohVoUjDwqqLcPVkluMllp8Shl4RTmGlArRMTKpSTqNbi52eHuYYdGEk2olwsudotwd7AlI1lHQ3UpSVolcTFhBPu4IIkKRxoThU6rorSkAJ1WRWpKIqWluaSm6khOjic1VUdIsD9Fhbls3dJBaUkBLR1N1FYV4+O8ls3ttSRqxIT5uxItCuStKa8xfpxNv+bGZtgyw5ZZ/x5dvHiRCxcu3DZwNDc3c+rUqSEDy5YtW/j444+HPL+pqWnIsHXy5ElaWlp+EtgajA376dMXsRptRKDtAwcfg2AkJjfAQLC07jaxiOjex/Q5CKaC4MluGFuDyaJ9svGHHlmPDoA3QPCQkRF/NZpMMUYZTT21/gwWVkb+8coVTp8+x9GjR1mx4hMEAvqZTpw7d47Nm7/HxaWLlSsvkZt7njNnhgcEhw8fpqOjg3PnznHmzBmOHz/O7t37SEnZQWJiE7W1tWzevJlDhw5x+vTpQTkeOjtfwvqNG1jGCyAl5fCwYevwYZNJxp/+dL3b4Y2ivb2djz766I7DVn19PadOneo9jomJwd7efkjrwPnz5zl16lRvxMbG8tRTT3Hq1CmMRiMvvvgiDg4OXLhwgZaWFrMb4b9BZti6h/RTG2TcCq4GftG6NXz9+Pwfg6nbha2BcDVCYNFbnjZuzFge/dUj/PMfz/PUX/7Ec3//G3bLbfF0XYur4wqk0YFIRQHESUJIUoSjCHVFIfQnyt+N6AB3VJFBxEX6IvRxQBsTRKzQC500mDCvtTgseY8gt1WEeazBx2Ex4gBnPNcsRB4TSHioJyq1lJr6CjZv3cS+D3axdUc7dY1l1NUV0dFRx7ZtzdTUFFBfk0vnxkr27mph1/YNbG2roaY0m6b6MjbUV9BSX0xDRS7VeakohP5IAt1YNe9d3nr5eRa+P51Fs2fxxr/+wT//72nefvVlgkL9yC/IQBcvYf3aRfi6rSfI2xVhoDfhAV6IggJQxYhRxYjxd3fF292BGVNfI8jPlaK8VDbUlRLo64I+XoZUFICH42pUihjCQgNRxslQqWPRxCuRyqLJz8tBLouhoryIrCwDMpmIuDgJlZWFVFUV0VBTy75dnShjAtDIg9lYX0aKTk5EqBfP/PV3/O63jzF6lCVWlhYm6OoDNz2AY21t/aOAdSPY6jHEGGiAcSO3wh+L65scDw4Ef3jWsf2aI18PNf3/1q83qbj5a4OFm8HD2I//P731PQb3fGbdHXV1dQ0JtlpaWjh58uSQgWXr1q189NFHw4KtoWbWhgNbFy5coKSkhAMHDgzahl2huNwNSEYETxoRvGtEYGPstVifcL+RnJzLpKVdZuwEoyljZdENY9aYHATLTf+2GGGktvYSpaXd2aHdfYBjczeETesuSxxNLzQUFJzl229NIHPkyFF+8QuTxfnu3beXVbrd+PDDD+ns7Lzha2fPnuXkyZMcOHCAjo4OqqqqqK6uprOz80ft5iMiuvd+Xe3z3nea3mtZ2QF279497Od+6KFrWFgYiYm5yKef/vjYgc2F71TU1dXx+eef9x5HRUX9ZM2M+5YRgqnP1uTJkxkzZgyPPfaYuc/Wv0Fm2LqHZIatm8OWpcUIRlpZYzN2HJMmTOT3j/+G/3vmL/zhyd8xb+4sVBIhKxfORB7pR4ivPQnRwUT7OOG3dhE+dgtxtV9CqK8TiuggAjzsWbt8JqF+DoQHrCfMfx2+rquIDvUgMtgNT8dlBAc4EhXhhVYtIjtDTaw0ivKyQrZt7WTb1k6OH/uQ/Xs2095WRUNdIXt2tdHeVsWGhmI2ddSybVszra1VtLfX0tRUzobGfBqqcihOS6AuP4s8jYRA5xV4Oy3Fae181tmtQCaOJE4ZS1RUFAVFuWgT1Li4OeLp7UaUKBJ/by/W2a2gKCud8AAvAjydmT9zKqsWz2P5ogVEhgXj7rQOx7Wr8fBwQyqVEBjoT0qKAX28DFVsJKIwX0J8nQn0ciLVoMPFeR3ZOenk5GZQWJRLdk46xUUFZKSnUldbQUKCEr0+joQEJcXF2aSkaGmqb2D39o1oYkOIDHGhKjeFeGk40eHeSKMDefCBifz84fuxHCHAZuy4G2aTbgVbPSA1duzYXpfBm8HWjZwKfyzzZYYtM2z9p2iosNXa2sqJEyeGDEvbtm3j8OHDQ54/nMzaqVOnaG5uHtTY8+fPc/LkSfbt29drw15cXIJU+jHvzfoO20WXqKy8dMO55851MXv2VRNUWRkZMdGIxdPXEFgYefb5a7S0XKK+/hJnzvwwJzHxMoIRRgSeIDiFad/VfSB4GQSjjSgUl+nq6uLixS6mvncV6/uNCHwwjR/XXW74NgjCQPC0CdDa2y/w9ddf94JLVtbnCATw0kuDtzf/d8DWjeDr9OnTHDp0iM2bN9/Ubv6jj75j7AQjI2yNCHaBoB6s/2jkpTeusGvXrmHB1tmz57Bb2w2yT4DVQ0bGTTLS0HBzs4y2tjaOHDlyx2GrpqaG06dP9x4LhULc3Nzu9pJi1hBlhq17SGbYujls9bgOTpowkfvv+xm///1j/OEPv2HKlJeZMWMKUUEehPs6EubrgDLaBz/7BXjZzWP9kvdxWj4fT+eVhAW4ECPyIzrcG2GQE7IoH8RCD9TyYBTiEKSiAORRQRjipWiUkSRoJCRoJCRqpZSWFVBUlEVFaQ6NtUUUZyfSUlvAxsZCGirTKcjSUFueztb2Sja1ltFUm8vmtnJaGwpoqs2lviKNokwNkmB3ls58i3nT32DdigWsXjKbFUvex8vVEUd7O5yd1hMREUGiQYentxuiqHCixBEkauNRSsXIRaEEezgRHuBFsI8bCrEQqSgEVZycsNBAMtKTqaosJSM1kZzMFDo3NhERFohaEUWSLpaQAHeEge4oxGGkp+hxc3UkQa+hqbmektICsnPSaW1poryshKYNtWRlGQgM9CQzM4mysjwqKwupraxix5YWctPjkAg9MMSGk6ISkaYTY9BG8eADE3nwgUk8cP99jBk1uhuIfgCuwcLW2LFjsbGxYfz4idjYTOi2dR93S2v3HijrCTNsmWHrP1VDha3hNiXevn07H3744ZDnDyez9vnnn9PU1HTD177//ns+++wz9uzZ02vy0NzczO7du9m06QQdHed5Y8oxRowyMmKuEcsZRiwsjQQEXqGrq4sTJ7pYa3+V+x/p7mtlAwJ7I4IF3ZksIaZywpFG/ufJa7zwwjX+/uI1liy7yubNl/jHK9dMBhL0ydrIQTDKiJdX/0zguXNdSCRXeOaFa1iMMSL4BQiWDTDh+D8jy1de7gdbM2aYnPwSEi78/wq2bhQ3s5tPTz/M7/7XlDG0GGFk2szLHD16jp07d7Jnz54h36+09DwWlkYETd2/w8tgscTIrx+/dtO9a62trXzyySd3HLaqq6v54osveo+Dg4Px9va+i6uJWcORGbbuIZlh6+awZTN2HCOtrPnZpPv42aT7eOmlv/PUU0/wwgtPExcnIcLHmagAF4LdV+Ky+n3cVs9i/fIZrLR9Fy+3NcTGhKBWRBAR6klEqCcx0T6EBK4nIswVSZQ3MnEwaoWIlEQFaYY4kjVSFFHB5KVqKcpMpLahlJrafEoKE6mrTKMyP5mSbA01JUm01mXS2VJKdWkqFUUGGqqy6KzPpCJHSW5SJBqxB/4OC3FeMQtPx2W4Oa1AGa/AxXU9otAgQn298XBYjsuaZUSGBREnjyEmKoI4eQxVZcWEBwcQFR5IoNd6li94l38+/TjTJ7+Ch+MaDPEKEuKkbGisJT3NQFpqElmZqaTEyxD6u5FtUOOxbgX6eBlpBjX+3k4oxCEEeTuTEK8kVi4hQa8hNS0JXYKaje3NbN7UQdOGBkqK8yguziY3N5WEBCVtbfUUFGSwub2D+uoi4hWhJGujSFUISVdHIQvzIDsllnenv4WFQMCvfvkLxo+z6ZOBMgHXYGFr3LhxjB8/nokT72P8+Ilm2DLDllkDNFTYGm5T4h07dnDo0KEhzx9OZq0vbJ07d45jx46xc+dONmzYQHl5Oa2trezdu5cTJ07w/fffc+KEybq9d6+UAAQb+0BNLoywNHLoUBd/eOqayeLdERNc9TVxyOg+NwIEs40I/DE1EX4QrF4xYmlt5Jf/7xqCqO7xV0GQ0J2hGmXE1/fwTftsrXO8YsqIVQ/YwxUNT/71Wi9sHTt2jpEjjdjYmPZv/buB4NChQ8OCrYHR126+oaGR1NQ6Kiraeu3mt2/fPizYsrO7hNXbA2C3255+27YbZ7daWlruCmxVVVXx5Zdf9h77+/sTEBBwl1YSs4YrM2zdQ7olbI2y6B/DhK2fuqnx7cDXLUFrwJe5cePGYWFhwf33388vfvELJr8zlZdffQlffxdixP7EBKzHy34+Dounsfi9l1k0ewreziuIjfJHEu6Fh8tqfDzsUStEREf4ERXqTZi/K5EhXmQlq8kwKElPUpCepECvjkYm8iVVL6e2qpCmpmoaygsoL86gobGYmvo8WhpyaW3MpX1DPuUFOiqL1WQlhpOnF5Ik9SLSewmOi95h4Vv/YtXMd1iy6D3CwnyoqCxky/YOgjzciJdKcFtrh04uJdjbw9T3SqskLdOARBxBeooeUZA/od6eLJ07gwXvvc2caW+yePZ0HJfOxd9xFesWz8bbfhniYF8SFRI0kggiA7yQRQaiU0YRGx1Mml5BfJyYrDQdKYlxiCJCCQ0JIDsrDY1aQXNzMyq1HG2CnPSMZGqqy0lPM5CeZiAnO52y0kIUsTG0tjRSUpxPQ3MThUW5JOlkKKJ8iRX54eu6hDC/lRjUIlydlnLfhDGMHjmGX/7yl4webfqSPnbs2F7gsra27lcu2DdMpYM9oDWRSZMmMXHiRGxsbLr3aI0aMPd62OrJhPWUHfY1x+gLfjdqojzwb/dWTY1/DKaGAkA/HrcCu9uFsx+fP9jnMevuaKiwNdymxDt37uTgwYNDnt/W1sbx48dve96ZM2fYt28flZWVNDQ0UFFRQXt7OwcOHODUqVM3/F28+c5Vk8X65u7yvN8PAJprIBhnxMrK1BdL8AUIgkDwrwHjurr3YYX3OXcOBL8EgRQEq43c/4jRBGvnQLAIBBNAsN6IwMGI5bhrLF529Sbvq4ux9xlNz9fnnpZzjLwz40ovbEmlFxEI4L33TtwRIOgxDvl3Xb/Hbn7nzp00NzdTWlpKdXU1O3bs4MiRI3z99de3db316y9h/dIA2Npjgq09e268v62lpYWjR4/ecdiqrKzkq6++6j328vIiNDRi1/H+AAAgAElEQVT0biwjZv0EMsPWPSQzbN0ctiwsLHj00Ud5+OGHefLJJ3H19kYqiyLYaw0eK6bhs8oW5yWzcXNYjJf3GiKC3YkK8yI80JUYkR9ySQipSUqUsnDEIn8SNWKKchKpLc8mVS8nXhGBWOhDnDQUTayQsgIDeVkJ1NYWk5ObSlGhnuYNpWza1MzWLe20dDbS2lbJ5rZCOurSKNSGowp2wGn+66yf+yorF01jydypRAR4oowWkpefycaWGpqq89DLg4n0cCFZJSMk0INQoS+xcilZmekoFHIaG+vRxITj47SaKS/+DddVi1i/chFvvfw87015BTf7FXiuXcGKOTNwXbUE5xWLCPF0RhoWgDjYF4UoBKUklES1hES1hIrCdFINUlINUqIiPFAqpKji5JQU55OeZqCkpIS8/EwSDXFkZKZQVlqIXCamtKSAvNxMyssKKSnOIy01kbraCuobqklP16NTi5GE+xDu64yz3RzUUj8koZ5o1UL+94nHGDdmLPfffx82Njb9skNWVlbY2Nj0QsvAPVo9sGUqIRzPhAkTGD9+PGPHjh0UbI0bNx4bmwl9gGtsP+Ayw5YZtv5TNFTYGm5T4l27dvHBBx8MC7ZuVcZ4Ixv2qqoqWltbe0uwbmV7/8knpp5Lgo7uL96ZIJhI/+a/JzFllR7vzkLRnZF6EJOzYM+4uu6s2OEBELYaBHNB0GJ6/dePG7H6Wbfr4NY+4zaaXt+588Z7xFSqyyZLdBGmMrj1RkZYGqmru0hDwxm8vLr4xS+uIRCAXr/jPwK2Bsa2bdvYunUre/bs6bWbb2hoYOvWrRw+fLhfJujG4PQ9FhZGBPHdZZgnweo1I3/9+82dCZubmzl27Ngdh62Kigq++eab3mM3NzdEItHdWUjMGrbMsHUPyQxbN4et0aNH89BDD/HII4/w7LPPst7JHg9XB4I8HFi/aAZLZ79LoIcjUREBKFXRxEQFo5AKyUrTkaSLJTtdiyFBTnqyirKidErz9WSnKlDJglDLg1HJwlDJwsgwKMlOVZORFkd5RRbZecnUt1SzaVs9+w5sYt++Lezd1cmWTbXUVqSgkXgS4DSbdQumYr/gHXwdFxPgsoyYqADyshIoyjNQkJNIYYae0uwkUlRRZCXEEOHlzIr5M5CJg9FqxGQk66guysXDfjWLZ0xj9tuvs3Lh+9gtnYev53pkEUGsWTKPIE8nXNcuJ8jThRULZhPm60FUsB+RAV5E+HkQE+qPIU6KRh6BThlFolpCRJAHdVV5pCTGIpcEI42JQi4TU1KcT7IhgbS0NMorisjMTqSgMIfsrDQMSTpqqstJSdZTVVVAfX0pOp2cxsZylHIRhXmpaJTRiEWBSEL8CHBfhSzCA891yykr0TN96suMHmXJqNEjeOCBBxgzZkzv52hjY8O4ceP6leiNHj26F7JuFH2B6VawZWMzgfHjJ/aWHvadP7Ck0QxbZti6lzVU2BpuU+Ldu3dz4MCBIc+/0Z6xwdiwX7x4kS+++ILGxsZBQmG3WcKxbuA5D4JHQPCOEcH2bgh73ojgT5jMLEZjsm0/C4KfYzKraAFBKQh+AwJLI4KcPgBlBMEzmAwulHDfw0a++KKLOXOuMuKxARkWYOSvjCQkXL4JXHahVF7mF782gdoTf7lGUdFlPLxMe5usnzUi+K0JDIODD/xHwtb27dvZt29f73GP3fy+ffvYuHEjFRUVt7Sbl0ovYj3aiOUYkx3/b/9w9UddG5uamvj000/vOGyVl5fz7bff9h47OTkhFovv4mpi1nBkhq17SGbYujlsWVlZ8cgjjzBq1CgmT57MeoclrFg6H2m0iEStDqU6hgR9HKmGeFPz3kwDJYVZpCVrqSzLpzDXQFFeMtXlOWSkqEnUiJBGeqOSBaGSBREV5kWiRkxBVgIFWQlUVmWRnaunobWKg0f388GRA2zf3cbG9krqajPRi50IWD+LAJf5xEs9KMpOJiNVS1llHpn5yeSkxCEOd0erCEYl9ScvPop0dRTxsghyUnUk66TESUIIcFtLXpIKpxVzWfruG6yfM511s6ayetFiAny8UavjMKQnI/T3YOXC95FFBCEK9EIU5I9GJkEY4Et5fg4hns6I/D1Ri4UkKiSk6RVEh/lQkKknRScn3aAlJz2JjU21JBsSyM3JoKqylJLifCoqKmhuqaegKJ2s7DRystPJSDeVE0pjomhurqCwMJWSkgxKSjII83dFo4ykvCQbkSgIaVgAvs4rWb1oOg7L5hEe6oCz4zJ+dp8NI0dZcN999/WW7/3sZz/jwQcf7FdK2ANhPYYYfQFrYFaq796pm8HW+PETmTBhUh9jjXHXAZcZtsyw9Z+gS5cuDQm2htuUeM+ePezfv3/I89vb2zl27Biff/45H3zwwXU27B9//PENbdi7urr48ssvaWhoGNR9zp/v4uHHjAhc+zQcrjDtoerdv/VkN4xdAcHfuqFKAQInEIztHjOij6X7xO6eWxtAMN9oGhMGgjEwd66pTLCs7JIpS3W6D2wdN/XLqqm5cWZr4HN3dXWxdWs3LFb2gTshjLa5ysmT/34gOHjwIJs3b75jALJt2zb2799/09cHazd/9KipuXFd3a17jW3YsIHPPvvsjsNWWVkZZ86c6T12cHBALpff3QXFrCHLDFv3kG7Z1Hh0/7ilYYaVdb+4dZPjH49bAdRPCVs9PZl6Mh/W1tY8/PDD3HffffzrX//Cx9eV4BAf0jMS0eoUBIf40dxST0trA+UVRdSUF1OQnU5Rbia5GSnkpujJTFSTmaQkI1FOcW4SKlkYkaGe5KRpKM1NJCdNRYpBTlFxMomGODZtbWX/h3vZtncbzU2FlBUnkpooQhzhTHZOAlnZOgoKk5HKQkhKUFBZmkVzTSFttYUUZcdTV55OQ3kG6QkSFBGexEX6opdFUJAcjyI6CHmYLx4rbZn96j9YMmsydotm4e6wnCBvZ+SyGKTKGFJStIR4OuO5cg5x4V5E+rkSLw1Hp5BRnp9DRqKORJUCaUQYGYk6spMTSdVpUMrFFOZlkpmWRFa6gfSEODL0KnKStahlIgzxcrKS48lJ1VGYbyAjTUN5cRZxsijiYiVkpiTQXFvMjo568lKVqBUi0tIScLKzJcjVHtc1S5CE+ZKgkeDjZU90sCceK21xXWVLVJgbwT52/P7XD2Iz6T7Gjx/PpEmTmDRpUm9Gq+/neyPQ6ikX7GvS0NNDa2DJ4UBDjJ6sVk/037817jrYuhVQDIStnn5vgwei24GtnxLMbv0stw9XNw6z7o6GClvDbUq8d+9e9u3bd1tz+tqwV1ZWUlZWRmNjIzt27ODo0aOcPXt2UNe5Hdjas+cST/7pmsnU4g+mjNaIUUamTL3Cxx938bcXrmHh0CcD9S0IXuzOcI3uBjILI3966hqdnZd47rmTpnPW3RA2ofvnGCMCSyNjxhjZsuUS58938fgfr2H9NyOCMhCUgMWfjfzx6Ws3Ncm4UYSHX2HUUwMyZBfBwtpIUdH5/zrYuhF8ff755ze1mz9x4sQtGy03NjZy/PjxOw5bJSUl/Z7Nzs4OlUp1V9cTs4YuM2zdQzLD1g9hZWXV61pnbW3NxIkTGTVqFI8++ihvvvkmIaG+VFUXU1tXRl5+OiUlWchkQnJzkyksTKepvozy4izysw1kpMSTk6onNUGJQhJMnDSYNIOS3EwdFSUZFOUZSNSI0aqiSE1TkZGlZccHe+jc1k5bSwW1Vdmk6ET4+61FpYmmuaOOrKxEMjP1hIR4kZmpp7GulCA/Z+LlQrSyMOIlnkR7ryRg6Qyi1swn2m0VgasX4Lt8Ht5L5rFu3rv4LF/AvFeex3H2dJyXzMXTbilCL3ci/HyIiYmhqDiP9BQ9fu6OCL0cydTGEh8TRaZeh14rp6Qwg7LiLHIyE6muyKe6Ip/kxDgSdbFUlubQ0lhBfJyYsCBP4mNDCPBcjVYRijYmiAjfdUQHOiPyW49G7EeQ2wr8XVeTqIqmpCiVsqI0knXRxEZ7I4/wpygvlaQkNWuWzsJlpS3u9ssI9nIkSSdjrd0CdPIIlr/3Fr7rVyIO8ybC35k3/vkMo8eO6QXmkSNHYmlpeVPY6oGs60sGf+ifNXaszXVZr4Gw1bNfq2+YYcsMW/+JGipsbdu2bVhNifft28fevXt/dExfG/aWlhbKy8tpampi9+7dNDc3D/n+X331FfX19bcc9803XTz0KyOWU4wIckFgCxYPGHn4l9/zzTfn6OrqIjPzMhZWRgSq7uxWhimbZWFhaj68adMlPv/8h2uWlZUx5a0rCKYaTZkwIwi+A8EWejNljz1m5Phx036xGe9fZYSVEcEIGG1zhWPHbu+9ymSXGfmY0WTiQXd8bgLAurr/PNjaunUrBw4Mr0TyZnbze/bs4dNPP+2XTTp37hwNDQ2cOHFnDEd64uzZs5SUlPQ7t3z5crRa7d1eUswaosywdQ/JDFv9Ycva2rq3/GzMmDFMmDCBX/3qV8ybNw+ZPJJ161cRI41Aq1OQn5tETVUe+blJFBemkpOhIz1ZRZJORrI+loxkHXlZSZQUpFBfk0t2TgKZWVq0Ogma+Gj0Wjl6vYLyyjxa2+uoqSumdWMtWk00cbGhJKcoaW6tpGVjPSnpCRQXZxMXJ6G6upjc3FRUiijKitIpyNCRqZcT7baMRa/+lZWv/w33Ga/iNPt1nGZPYdXbL2H7ynMsef155r36N3xWz8N9+fusXPAeokAfgr090GviSIyLoSY7hQ2FmVTmJrFz+waqqnNpaq0mPUtPY0U+uzc10VpbQm5KPMVZSRRlJlJflktDeR5auYiUeBkRAe4kKKKQifzRxkYQI/TFx2kVS+dMRejnQrivMzpJEIGuq9HFRRIU4IJOIyVRKyXIx4Eg7zWmfWA6NQaDiugwF2a+8S9c7BbjuX4laoUIcZQ/CbEils2YgrfDcmJC/fFau5S5015j0sTr92YNhK2+gHUjK/gfIGt8936s8djY2PQpC7zeIKNvmGHLDFv/qRoqbA23T9b+/fvZs2dPv3Pnzt3ahr1n7HAMOr7++mvq6upuOS4l5TJWk4ymfVp0x1ETqDQ2ft99rS5sbIw/ZKosTT89PK7c8JplZWUsWXoFyxkDsk07TPOmT7/a3XD4Gt991wOdXTz1lKkccPv2W5cQ9o1jx7oYOaa7DPKMqRTRcpqRnz928ZblcT9FfPDBB2zZsuWOwtYHH3zwk16zr918Y2Njb++1Hrv5+vp6Tp48eUdh68yZM5SWlvY7t2jRIpKSku7qemLW0GWGrXtIZtjqX0Y4btw4HnroIX7961/zwAMP8Je//IXJkycjFouRxAgRRgSSlZ1MaloCNRU5ZKVpyMnQolGKiI0JQauKIs2gpKosi8qyfEoKMyjISyJBG40wwhtNfDQVldlkZmkpLc1ly9Y2UjP0NLTW0FiZRqzYj7yCVOqaaiirr6J+QzVFRWkU5ydTXlZIRXkR5WWFVFYU8+EHO0hPVtFWX8KaxTNZ8cYLrJ32Cn7L3sdlwVRcbSfjPP8tVkx9kbXvvcGama+jFnqwcu6b2C+ZhiQqmASdCq1ORW5+DrpIf/wWzUTmuhLPlTNQ+TmSHxdJujSMipR4MuIkJMUIUQsDSJaJKDZoCHayI8hxNXFhfgj9XJBH+JOukyMO8SLQwxmDOhaNNIrEeAWhAV7ESiJwXW+Ht+MqxOH+xEgjUOqU6NRK0pJ0rF4yH7kokNiIUAJ9PImLi0Yh9mat7fvYznwLu8WzUcVGoJCHkZEQy4K3XsFn3Qo819ixZu4Mpr/yHL/4+f29YNR3f9RA2OqJnkxX3+gPWhOZMGFCP9ga2EfLDFtm2Ppv0VBha7h9sg4cOMD27ds5cuRId8+kwdmw98RwDDoGC1uRkVcY/dcBUHQNLG2ukZFxnq6uLkJDr/TvvyWAJ564xpkzN75mWVkZJSUXTdmqyu7M1hkQvAGWY4zk5Fzm6adNjoEODj8Am4/PGQQCCAq6McT9WBQXX+S+h671Pt+vf3+ZtLStdwQK7jRsbdmy5SeHrYHR126+qamJkpIS6uvrh2w3P5T49ttvKSsr63duwYIFpKWl3eUVxayhygxb95BuBVvXwZe1Vb+4lWHGOGvrfjFc2PoxoBoubFlaWjJ27Fisra2xtLTEcswY/vDnPxEaHkK8No5kvZwkvSkbVV1TRlyMkIwkNUpJOFJREGKhF2KhF2EBTkgivAkLdkEmCSAlSUZpUTLVlbnU1RVRWJxGaWU2WfkZVFQXkZ+fTEaqErlChEYrpaIqn8rqAurqy2lqriG/IIPkFC0bWqqoqCykoaGCyopiduxqJz9TR6jzSkLtFxOybiGey2bgs3IWLrbvYD9zCqtnTibIaTl6aQg+qxbgbzeH9HgJyQYdWdlp5GWnUJ6bTKS/IyG2byNcOh3R8hko1i8kznsFCs9lqH1XoQtcS/jyOYSvnIvadx3JEV5I1i0hdPVCQtctQysKINTbEUVkIOk6OZJQb0qzDZTmZWBIiCc7Q0+0KJhoUSgycSSK2BgyM1LQJ2jIykwlI1lPklaJo/0yIsO9SU6IR6+JRR8vQRMXgljowcLZk3Fas5hALxciQvzwcbVn1aKZuNktxGnVQlbPf4ulM9/g5ef/yiOPPMJDDz1ET6+tG5UR9o2BJhg3cyfsyZL1QtOAeT/YyPeHrzFjxg1ocNzf8GIgkNzKIGP4QPTvhK3+casmxbf7PD3zzLo7Gips3W6frIE27D17rjo7Ozl48OCgbNj7xnAMOr755htqa2tvOa65+RICC6Mp60R3FIKFpZGDB89x8mQXEycar4Ot5uabZ5/Ky8v57rvvcfMwQdqoR02udzb3/XCdxYuvcv/9pmOt1uQ82NR0CoEAnn762m2/3/Pnz3Pq1NfU1HxPS8v3HDnyCa2trf+RsLV582YOHjx4x+537tw5amtrOXTo0JDt5ocKfBUVFf3OzZ49m6ysrLu7oJg1ZJlh6x6SGbb6zB81qnd/z8iRI7EaO5qFS23JL8qmuCQHVawQrUZMUlIchUU5pBnUhAZ6IIkMQiEVEh3hizDEgzh5OEF+TgT4rCcsyI0ooQ+Bvo74ua3G392OWGkQ+bkJpBgUaDXRKOUhBPqtQ6mOobgsl47Nzew/uJON7Y0kp2hp3FBFe8cGNrQ1sm17J1s6m9m3vZ2YgPU4zJuM68J3CFo5C+d5U/Fe+j7utjOIdF6Jj90i1EI/5EEerJ79DprocHyd7cjPSKQgN42kJAXRga74LHqPiOXvE7bobSKWTkNuP5fole8Ru2YOstXvE7tmDkr7eWg87YhZv5g8eRBha+chcVpGqJ0tIeuXo40MRBbqg+sqWyL9XIkTBZKpVyIT+pOgEJOsl5Osj0UWHU5ifBwJ8Uq06lhKCnNI1KnQa5SUF+UgCjP9DqvLCkhNUhEW5IYmTkh6koI1y+cwf+YUwgPcCPB2xWGlLQaNhDW2M3BebcuqeVNYPOM13nn9nzz44IPY2Nj0loX2bWw8GNj6wQhjbL+9WgMh60bAZYK1/rDVk+H6AbjMsGWGrXtTly9fHhJs3apP1q1s2Hfv3s2OHTuGBEtdXcMz6Pj222+pqakZBCB2MXveVSzHGREsNSKYDSOsjcxfcJgzZ87g4XF9VsvR8cczT+Xl5b3lkPv3dxEff5mCgsucO9dFbu5lJkwwQZaNjennyJFGmpsvcfz4cR577DwCAXz44e3DVk9T43PnzvHJJ3cWtrZuvTNZtLsJW59//nnv8VDs5m83vv76ayorK/udmzFjBvn5+Xd7STFriDLD1j0kM2z1t363tLTs3bv1z9f+iYevG9V1pRhS1BTmJlGQZyA3N5nsnDTi4qJJT9ehVkuQSsOJi4tGJAogOjoYmUyIRhlNnFxERKgPgb4uKMRhJGrlJOpiSU5Wo1FFIhT6EBLmjSE9kY6tG9m8o5Ntu7fQvqWNLVvb2L1nCzt2drJ9Rwe7d29mS2s1acpwHOe9jcPMF1n97ku4L56Bk+10XJfPJth5BVE+64gJcEYU4E6gy1qCHO2QBniSmxBHTnICyqgg5GFurJk9Gbe5bxE4900CZvyLqKVTUdrPIWblDKKWTkW+aibSFTOIWf4ukmXTCVv+LvE+q9D426EOsEPuvhpduBcZqkj00jAivZyQBXqiFgaQFCOkMj+N1LgodNEB5KdrkIT7EBsZREq8kvjYKHRKMcJAT/SqGCSiMJITVGSkxJOVpkEVG4FOLSZK6ItMHIxOGUOYvzvLFr5LdLgn0qgwDPFy1NIw5k19GceVC1g5dzK2019h5juv8fDDDzN69OjeBsXjxo3rzUoNBrYGvt6vBPAG0Xd/2I1gq39J4TgzbJlh657VUGFrYJ+sCxcu3JYN+6FDh4YFW1u3bh2yQcZgYcsEKl0YDJf5+a9MJhVi8WWqqqo5ePAsY8b0z2qNGWPk669//Hp9YetGsW/fJf7852v9rvvznxvZuvUktrafIhCAVHp7pYR3E7YOHDhwR2Fr06ZNHDp06I7CVk1NDadPn77p64O1m7+de3711VdUVVX1Ozdt2jSKi4vv9pJi1hBlhq17SGbY6p/ZsrIy/Xz88cdZtmYZOkM8yWnxpGXEo5SFIYsJITZWhFoTS0qKhsjIQGJjRSiVUUilEaSlJZCQoCQ5OZ6sVD3lRTlkperJzTCQlJiAWh1HokFPWU0FRaU55BRmUdFUT3V7O7sP7mbf4X10bO+gc0cnHZ1NnDh5hPKKArbv6CBFI8Zz1Wzc572Gz5yXcXj3FfxXz2f17HdQRgSQniQnKT4aXVwEBq2YnNR4cpM1JMsiiQ30Ruhmx9olc1g64xWEDjOROSwheOFbiBZPQbjwVSJs30SyfCohc19B57wA6ap3iVk5nehl7yBaPAW580JCV0xH5rEYdeBqxC7LydeKSVNFoojwJVcbS36CknhREJmqGBJiIwlyWk6S2J+8VCXScG88HJbh7+JAqJ8Lq5fMRiEOoTjHgCImiuqyAoryUvHzciAsyI04eTgxUYH4eKxDI5OQk6onxM8JhcSf8CAflJJwlsydisOSWaxfMZ9V86awcNrLvDvlZR577LFe2Bo1ahQ2Nja9+7MGA1s3g6lbwVbPNW4EW32BywxbZti6VzUc2Nq6dSv79u2jra2N8vLy27Jh//DDD9m+ffuQYWs4bohnzpyhurr6tuY4OJiyWPn5l6mpqWHFiq7rslqD6X9VUVHBd99996Njvvmmi0WLrva79lNPXSIk5AACATz55DVaWi4N2gLeDFv/3qiuruaLL74Y9Pifwm7+iy++oLq6ut+5KVOmUFFRcbeXFLOGKDNs3UO6ZVPjWxhi3BK2RvaP2zXQuJ0vdT3W7b0W7rcw0+hrWmBtbc0oSwEjR41h3MRJvPnmi0RFhqHTKVDKwgjwskMpDiZBFYUuPopYRSiFRbm0bWyivKKYhsYasrLTyM5JJy8/i7z8LIqKs8nITCK/IAN9oorMlAQyMhJJSU8gLcfAjp2b2XtgJ4eOfMDHxz/ikyOHOHRwL1u2NVHfVMqGmjwaKjNJVoXh6TCXNe+/xerpr+Iydwp27/wLh3dfx3v5bPwcbPF3Xoo81IOYIFdC3e3wtl+E9/K5+KyYh/viWTjNn46r7bt4LphK+IqZhC2eSvSSqUiWTUe8dBpRi98hetGbRC96E9nyd1CufpfopW8TtfRtFOtmE7VqGjq/tcT5rEHuuZbECG/0Ad4ky4TkJMaSp5WhDvVBHxlEmUGNxNuJpMgAglfZ4rdqAXGSIFztlyAXBVOYkUxUsA8u9ivJSNajUcrJL8giJUVLnFxEWIALEUEexET4E+i1Hj93e1J0CuJihOhVpgxXmL874nB/5s98m5iIQNYsns3S997GdtqbLJk3nUkTJjJ+nE0vrAx0J7y+0fCYfnE9jA18vb9BxmD2cNnYTGDsWJublBEO+HseeL1uc4yRVta3NIa51+L6RsiDgzOz7o6uXLkyKNgaaMNeWlpKdXU1u3fv5tNPP70lQAyMw4cPs23btmHB1uHDh4c09+zZs7cNW0KhCbYUissYDC1YWfXPas2bd3VQ1xkMbHV1mUoY1erLjBzZfZ8RJhdEgbWx1/Xwsd8a2bFjMA2Oz/PVV1/dNdjatm3bHQOfzs5OPvzwwzsKW1VVVcPel3W7dvOnT5+mpqam37nXX3+d2trau72kmDVEmWHrHtJ/M2z1fJHt/VI80pJRo8fyyGO/xs5uCSmpCkJC3YmO8CM9UYVWHEhUgAt+Lna4rVvOipVL0CfGk1+QTWvbBjo6W6mqLqOoOI+i4jzq6sspLcujbWMD1TUlFBVlUVCYSU1tKe2bmmjpbGfj5jY2tlfTWJNJRWkaxQV6inPU5KZLkXivx/79ySx7+wUc33+N1VNfYuVbz2H/zvN4zn0N/2XzCLZfgt/aRfg5LCZo/Qr87Zfitmwu6xbMwHnZVDyXTMNv4VT85r6F75yXCZz9EsGzXiRy/hsIF0wmctHbRC1+h6jF7yBfPYOYFdNMkLXkLaSr3iPOcT6StbNICrQjzmMFUrflJIV7oQ5yIUkSSEKkL0rv9Wh8nCjSSkiK9MN/9XzKk2IJWzGHSIdFRPvYIYvwoiLPgF4RiZ/LGpxXLMB+6VyiwwLwcnUkRiIiKz2RmIhAFs1+m/WrbQnydiTM3xVft7WIgr2RRQYT6ueGVhGNVBSEPCqEYB8XpKIgls6ZxrpFc1gy4y1mTX2VieMn9AJKD2z1QNDAfVg3hqmBZYRjfzTMsGWGrf8W3Qy2zp37cRv2vXv3Xmfdfjvx0UcfsXXr1iHPH471/NmzZ6mqqrqtOQbDZQQC8PK6wquvnrwuq/XFF4O7zmBhqyc6Oi5x331GBDYg2NDtXtgJgp+DxRNGHv2t8YYZrp7Pb8eOHdTX11NaWsqGDRvYuXNnLzDfCRDZv3//fwVsffXVVz/pNY/1bpUAACAASURBVG9lN3/ixAlqa2v7zXnppZdobGy820uKWUOUGbbuIf03w1aPWULPl+OJ40YzavRY/vb8C4SG+hIc7I6vryOpSUp0cZHIwl1xs5+P67qlBPm6o1LHolLHYkhOIF4bR2lZIZVVpVRVl9HS2khTcw3btrdTV19O56Zmtu7uZPuuTjZvaWXb5lZam6rIzUxAHu1LdJgzMRHuxMsDEPuuxmHOKyx67VnmvPBH5j33JFP/9AgL//kHVr3xFGve+AvuM57DZebLBC6ZRuCSafgveoeARTMIWfY+YSvmELZiDs4znsd1+nN4vP13PN96Fr9pzxA44zmC3v0HkfNeJ2TOa0QsnIJ46TQky6YjWjYd8f/H3pmHU5n+f9zMVHbt+75rEVFCQoTsO9lFhVQiWmihtCgt015TTTPTMk3NTJYk7Sjtq/YSRVok7WZwXr8/jBNaHS2/vp33dX2u6TzPcz/PObju67zmc9/v9zAbYkbYMd/Xnrk+tkQNtWTlhGHMGzWEOf5OzA30YGGoH6tnhLI6ehILgkewJHQkswM8WRc1gRn+biSuWcj6WZP4cYwrS8a6E7s8kjlTAlizKILIUH8CPBzwd7VmhLM1Q50smTYxmFmRU4iaMgEPB0sczAbi7WrD1AmjmTUtlMiwsYSHjCJ0zAiWL5zNvKjJ/LJ6McsXzmZJTBTBAT7YGOswbaw/vkNsGDfKmyaNGleCrYr5aXJycpUcBsuWDb4btqrmaolhSwxb36qKi4t5/vw5hYWF1bJhv3jxImfPnhUZlm7cuMGxY8dEHl8T6/knT56wY8eOao3ZuvWf//ZPlSIhUbmrtW3bvx98n3JTg+o8u7NSKRLTqGxBvxAk2pZ1u/bt+0fYeTxz5gz79u0T/v7K9wTdv3+frKwszpw5w+7du9m+fTsHDhwQdiardk6+Vtg6fPgw165d+6ywtWPHjo8OW1Wrqt18XFwccXFxQrv5vLw8tLS0SElJ+aLziViiSwxbX5G+Zdiqer1Ure+QkZXHxsGRWbOmMmZ0AEuXLODXdYsJCXQldJwLo0c6MXVqMDNnRbBk6UKWLf+RHxfPZ9XqZWzYuJ49e5PYmRTPnr1J7D+QRHzCNg4c3MXf23/nr8StJB9I5M8/N7Lpl59YMz+M5fMmsXh+GEuXRPLTjzOJHDeC4WY6eOr3wVFXGUftHliotMG+b3sc+rbDW0eRkYY9CLXow3jLvoRZazDRrA+TzPsSNKg3wYaqhBj3IcS4D2EGykwyVGHiYFXCzfoy1bIf4eYaTLbUIcxKl2n2A4lw0CfCQb/s3y7GzPKyINrHmmgfa+b7DWHlhBHMHGFPTKA780a5MD94KKumBbMychxRo935MdCHyGGOrJsfTkywD1sWRjB37FBign34c/5E/ogMZLKjATHTxpC09Semh/gyKcCLkGFOuFsNwt/NjiC/ocybEYGztRl2g/XxdjDHwXIQE8aOYHzgcMJDRhI00hu/oc6MGu7OouhIlsREETUllDXL5jM5dDQjvZwIGe7BGM8hhIeMpFWLlshISQshpRy2ZGRkhAHFYtj6/1Fi2Pq69O+//7J7924SExOrZcN+6dIlzpw5IzIsZWZmcvToUZHHV9d6viaw9fff/1JHRoCEJEh8BxIDQEK37N+16wiq9WxRYKudogCJmCqwtfa/7lZtAfPmnRV2Hi9cuPAaHL9pz9bBgwe5efMmp06dEnZOyjuXOTk5NXbL+1KwdejQIa5fv/5ZYSshIeGzZGtVrJycHHbt2iW0m+/cuTNNmzbFzs6OLVu2UFBQ8GUnFrGqLTFsfUV6X4hxTQ0yXquPDFvVDi5+B3zJSUnTqHELxoWMJ2pKKGFhwaz7aTFL5kcSM308UVETiYoKY87s6SxdUgZaS5ctYuWqpfy0ZgUrVi7hl1/X8tuGn4lP+Juf1yxhwy8r+WPzOrZsWsuva2JYt3IOP84LZ870YBZFT2Le9HHMmhhAyDAnfG0McB2kjvvAvjhp9sJZtxcWqq2x69MWa5XmuPZrj5dWZ3x1uhOgp0SwYS+CBikRNEiJsQY9K/13nJEyE03VXqsw876EW6gz2bIfE8w1CbPSZqqdHhEO+kS6mDBrqBVzfO1ZFORO9EhH5o/1YMkEf36KDGHN9FAWhvqxaLw/MwM8iB7lxtzR7qwIG8maaYEsn+TP6imjWRsxlnWRQWyMGM3iYHeWTfJh6/KZrJ8/lYixPoT6uuE3xIRRblY4megR4u/DpjWLCfL1YISrA1aD9BnuZscId3tmhAXh7+VEgI8X08NDGT3Cg8jwQGZOHc+KRXOYNnEs40YNI2JSIB5OFgx1sWbwwH4odmyLVK3vkJKsLczXKjOukEVOTu6NocOvBQ9XcResCEvvg63yLlrF55WPf1POVlWgqGqQ8XFh630ByNU1zKgaWly5PhWkifVlVFxcTEFBQbUyroqKirh8+TKnT58WGZZu3rzJkSNHagRb77Kef1c9ffqUhISED7o2P78I2boCJHzL3AgltlQAnr/hu+8EXLz4aWEreFwxtdoLkMj777kPQaIXSKiBjEIJ16/f4fnz528d/yEGGeXL1k6cOCHcM5SWlsaFCxe4c+eOyPCVkZHByZMn/6dhKz4+noKCgs/6zNzcXPbu3St8nZ+fj4qKCoGBgVhZWXHo0KEvPLOIVV2JYesrkhi2Kv4fdinatGnDyhVLGDPSk/VrfmTtqgXMmBzMgjmTiYgIYcGCKNb/vJpNG38RdrNWrlrKL7+u5ffNv7Ll999IS93H7uQdbN28jlXLYli8YCYzpo1nvJ87Y7wcsDPUwt6oPyZ6vbE10sDZRBsbXTXM1RVx0lNliLYKbjpqOGgoYqXSCmfNTtj3bomHVieG9u+Cn24PxhioEKjfg7EGPRlnpEyIsQpjDXoKX483UWX84N6Vqhy2plhpMNVak6l2ekyx1WWKrS6TbXSI9DAl2t+e6NFOxAS7Mn+kI3P9HVkc6sPy8JEsGTeMZaEjiPZ3YaqHFcsn+LA63JclIV4sCfFiUaAbS8d5sTzUmxXjfVg8ZgibZ4xmy6yxzBzjxmRfR6aN9mTzirn42Zvh62xJwFAngoe7McLNljlTQ3GxMsFCXw8PB3OGWBkRFR5MgLcz/kM9GDdqBGHjAvD3cWLV4rnEzJxC9PQwFs6JIDxkJDameoz190S7bw/MjPRRkJFEVkYKCQmJjw5bVTthYtgSw9a3og81yKhaNbVuz8rKIj09XeTx78v5elc9e/aM+Pj4D7p269Z/+UFGgMSask6ShKACbAlAso2AZcuqt4zwfU6NRUVlOWX37t3j0qVLJCWl075rId/VESChChJSAr6TFfB9LQGbNr3/2aK4Eebn53Pt2jWOHTtGcnIyO3bs4PDhw1y6dIm7d+9+MHx9bthKS0vjxo0bnxV84uLiePTo0Wd95u3bt9m3b1+lY0pKSpw5c0akeaCoqIhhw4bRrl075OTkUFRU5Oeffxaef/z4MU5OTsjJydGsWTNiYmI+yvwj1iuJYesrkhi2XtUPUrJYWZoyO2I8Xh62/LF+KQtmhfPj/OksXzKXyMhQ1q1bys/rVrFs6SL+/GsLP6//iTnRUSxZWpaftWxxNGMCvAmfGIiJniaD+vdhsK4GBlpqaCt1QUdZEW2lLphp98XGQB1rPTVM+vXAVL0Hrob9cDPsh616d5w0e2Gn1gk71ba49O2Ah0ZHvHUUCTBUYayxGoGDejNmYHfGGvQk2LAXIcYqwhpvospEsz5MMFGtVBNN1Qi3UGeajRaRdtpEOOgz3anMKGOmizExPlbMG27NLB8LZg63JMbPmtnDrJniZsI0L0uiPM2Z7W3FooAhrJkwjAUBTsweZs08P3uWj/NkWeAQVoe4s3aCF+smDiVuQQh/RQfyo68VM0cNYe64oUz1H8LKmeMZbWNJgIcjwYFe/LZsDtZG2kwLHYWNkR5mejp4Olpga6JHWJAfI9ztCRnlzzB3J6ZOCGTqxFFETApi7oxwfl65iMiwYELHDCM4YChh4/yxNRtIp7Ytkar1HXVq//BJOluvAYUYtsSw9Y1IVNiqqXV7dnZ2jWCras7Xp4KtP//8lx+kBUhsBQlpkCisAFtPoZacgM2bPxy2EhMT3whbFUOgDx8+zI4dO9izZw+nTp0iOzubGzeymTnzAsOHF2NnV8KMGcUfHG78JthKTU2t1pf7+/fvVwqo3rlzp9Bm/V22598CbMXGxn6yPW9vq1u3brF///5Kx7p160ZGRoZI88CzZ8+YMmUK169fRyAQkJ6eTr169YSGGx4eHlhaWvL48WPOnTtH48aNiYuL+3gTkVhi2PqaJIatVyVVryGLF85hwlgvfH1dWTFvCvMiQ1mxZA5z5kSwePEsliyJZtXKJaxcsYR5MbOZPGUic6Kj+GnNCqJnhmFhooOZsTZREaGY6mpioa+NgYYq6j06o9atHRq9OmM8oA92JnqY9e+FoVpXDJQ74W6szTBLPZz0VHHQVMJzoDpO6l3x6K+Iq3pHRg5SJtCsLwGGKowepMJYQ1UmmKoxwVRNuGcrzEKdiWZ9hK+n2WhVqqnWmkTaaTPTSY85LgZEe5gx282EmS7GRDkbMc/VmBh3E+b7WLBslCNrJrizKtSTVZOGMcvXjmgfc2Z5lVnBrwhyYclYF1aEeLBmkg+LA51ZO86FXyZ48NskL36b5MUvU3z4KciZ9cGuJK2dw3h3E9bNDsV9cD9GmlvibmfK9Bnj0FXtgKO5Pub6mtgaD8Ta0ACbwboYDehDgLcz3s7WTAgcxVh/n7LlnSF+RE0JZV7UZJbOn8mKRXOImjIOZ9vBjPRxRlmxDR1aN6dVs8Z8JyGBjIyMGLbEsCXWR5KosHX9+vUaWbffunWLQ4cOiTz+3LlzXLhwQaSxz58/Jy4u7oOuLSgoQr6BAAl/ARKtQcISJC6DxFX43kZAoxYCCgs//NnlsPXy5UsePnzItWvXOHLkCImJiSQnJ3PixAlu3rz5GpDl5uaSkpIi8uetKWxVrPKcqEuXLgnBcNeuXRw7doxr165VMovIyMjg1KlTnw1CUlNTyczM/Oyw9bH2uH1oZWdnc+DAgUrHOnXqxJUrVz7a3GBjY0NkZCTPnz+nTp06nD17VnguLCwMa2vrj/YsscSw9VWpuqHG1TXIqApX1YUtmVp1KlVNwKvq9eVOhLVq1UJaWppW7doyO2oKAd7O/Lx6KfNnT2BhdDirVswjOnoa61b/yKplMcyeEcbkiYFMDApghK8nK1YuInSUL+bGAzEz0sPTxR5LEwP0NHtjrKeBgXYfdPopo6+pipWRLgM1eqPTtxd66koYa/XGcZAGboM0cB6gilN/ZTwN++AyUAlv7W74G6jgb6DCaOM+BJv0I8RMkwmW2kyy1mGqjQ7THfSJchpElNMgZjgaEGk/8FXZaTPDQYeZTnrMGjKQOS76RLsaEO1qwFy3Qcx1M2SOiwGznfWZ7azPHHdTYoZassDHmgU+1qwKsGPJcAtW+Nvwo48ZK8c4sHqsE6vHOrFyjAM/jXFi48ShbJrkze/hw9g8ZRhbI/3YMm0Ev08dzuZQN36fOJR1YV6smD6aBeO8WRbqR4C9Pv6u1kQE+zLGwwYj9W6McLbDUKsPxjr9MDPWYYjVYNzszAnwdsXebBAxMyYzcqgLo4e5M3ncKKaGBTEnKpx5s6fy80+LmTsjHB83e/yGOqPdV4m6CjI0bFDvP0CRfg225OXrIisrj7S0LDIylc0yKuZwvbKIl62yfPDtAcdVgavsPnKVjDXe9LdYGbakq1RV2PqUQcQf997vCzF+f8jxm68X68tIVNiqqZvg7du3awRb58+fJyMjQ6SxL168IDY2thqA9A9y9QRlywmlXjkRdlEq5fjx9+dcldejR49ISEggPT2dpKQkkpKSOHbsGDdu3ODRo0fvHJubm8vBgwf/X8DWm+Drzp07XLx4kUOHDpGQkMDu3bs5ceIE6enpnzXUODU1lZs3b3625z1+/Jjt27d/dtjKysp6zb6/Xbt2ZGZmfpR54eXLl7Rs2ZJt27Zx6tQpfvjhB0pLS4Xn//jjDzp16vRRniVWmcSw9RXpW4YtSUlJ5OXlqVu3Lo0bN0ZVvS/z5kQSOMKdLRvWETMrjPWrFvLH5nUsXDibvbu2MzEkgPHB/owd5YO//1AmThxLcKAfI33ccbA2pb+6CgY6GvRXV0G/vxqaqt3p26sLA7VUGdS/DwZaagzW1cBogDpmumo4GGpgN0AFO82e2Gv0ZKhhP3wHq+M1UIkA/V4Em/RlvIUmk+10iXI2YrrTIKY7DSqzbHc3ZcFQSxb5WLPIx5oFQy2Z627KXHdT5ntZMM/diAVeJiweZsHSEVYsHWHJ4mHmLBxqwgKvwSzwMqkEXDHuJizwNBPWEh9zlg6zYJW/LatH2rFmjCOrR9nzc5AzGyd48nv4MOJmjiF+ViA75gSROGssp/5ax4ObV3jx6CH3My+TtmkF2+YG82t0KH8tmMTCUY5Ejx7C7JARBHnaYdinO7YD+2GkqYaWcje01XpiajQAM/3+2JsNwsvJGkcLI6LCQ3CxMcXXw4nAEZ5MnhjIgrmRRM+czJqVC1k4JwJfryEEDHNDo3c3GtSXR0FeFmlJqQ+CrYp28BWrprD1CroqgJaktBi2xLD11aqkpEQk2Kqpm2BOTg6pqak1gq3z589/FtgqKiri4cMiNm/+l19//Zfly49y5MhDXr5895jHjx9z8+ZNTpw4QXJyMomJicTFxXHx4kUePnxYLVOSO3fu/L+FrTcBSG5uLhkZGSQnJxMbG8vevXs5deoUN2/e/KRmEikpKZ8dtmJjYz8raL3td9iyZUtu3bpV4zlBIBDg6uqKnp4epaWlpKSkULdu3UrXJCcn07Rp0xo/S6xXEsPWV6RvGba+++47FBQUaNq0Ka1bt8bYzJSoyDCC/b3YsmEd0dMnsnn9SlYtX8if237npxULmD41lCULZxEy1hcvHxcWzIvCxcYcU0NdtPv1ZrDBAGzMjTA3HoixngbmhgOwNNZFp58y6kpd6K3YngF9lOiv2gNd5Q7o9WrH4N4dcddTwXWgCgHWA/Az7M0oo95MMFVjqo0WM4cMZJGPOYuHWTDfczALvc1IXDmHnMsZPMm/T+7VC+xZt5g9Py8m9+qFsmNXLrBn3QLWjnXm5yAX1ge7sjbQidWj7FnuZ83SEZYs8jZjnrsRs4YMJMpRl2hnfea7G7HQczCLvExY6G7EiuGWrPazYf0YJ34OHML6sc78PnEof0/zI25mIOcSNlBw6zovHhdQ9OwJgtJSBP/93yxBaSmlpSXcvnyG1L9+Iy/zEo/z73L7agYbFs/BUbc3phq9cDEbhIG6Cn26dUSte0dMjQYwWFcDm8EDcbQwwsfFDldbM5wsjfFwsCTY35tZ0ycxb/ZUIqeEsHTRbBZFRxIyejiu9uZoqfWgebNGyEhLIiMlzQ/f1fkg2JKXl0deXh4FBYVK9vBl3anqw1Y5FJQ9+xVovWlpnRi2xLD1tUhU2Kqpm2Bubm6NYCsjI0Nk2Hr58iXbt28X+dl79+7l/v37rx1/+vSpMAh6z549QlOJy5cv8+DBA16+fMnOnTspLCys9jO/JtiqWOfOnePkyZPcvn1bGKYcHx8vDFjOysr6qOYSBw8eJCsr67NBT2Fh4ReBrczMTNLS0ioda9q0KXl5eTWaDwQCAb6+vvTp04fCwkIAYWdLIBAIr9u6dau4s/WRJYatr0jfMmyV78+RkpKiSZMmaOvpMn3aRKLCg1m1dAHR08P4c9N6IqZMZPvffzLa34tp4cH4+rjg7eHA2Imjcba3ZIByTwYbDMBYXxujgf0ZbDCAgdrquDtaMlBLFbWendBU7U5vxfb069UVvX4qqHRtR/8erdDu1gJbjW54G6rhb6dDqIshAYYqhNv0Z7qjLtsXz+D25XM8fXif3CvnSVoZzZUjBygtKRG26EtLSxEIShEIBELQKf0PdO5nXuZe5mWeFTzg3o1LpG1cxoYJnvwa4savIe78NNqRZb7WLBluyVJvE5Z6m7Bk6GB+9DTiR3djfvK14SdfG34b68LB9Yu4e/0izwsekH/zCvnZ1yvDVYWJtaLK31fV9/vy+XPOnzrO3Iip9OveCaUOrdBQVsTMWAcz/f7o9VPB0cIIV1szTPQ00ddUxVinH2N9vYiKmED4hDFMGDeSH+dHMX/WVKZNHMtwD0dUurWnXduWQtj6TqLWB8NW3bp1qVevHnXr1kVeXr7GsFW+J6siaIlhSwxbX7NEha2augnWZFlcUVERFy5c4Ny5cyKP3759e7Xt7str37593L9/XxgkfPbsWfbt20d8fDxpaWlcunSJe/fuvfH+3yJsnT59utKxR48ekZ2dzZkzZ9i/fz/x8fHCgOXbt2/XyGzic8PWo0ePiIuL++ywdePGDQ4dOlTpWMOGDcnPzxd5LhAIBPj7+9O7d+9KOV3le7bOnTsnPBYeHi7es/WRJYatr0jVha1qG2RUE65ev/7dsFUTQwxZSSmkJcv257Tr1BFnDxeiIieyaE44s6ZPYOXKBWzatIali2azesk8lsREMWq4O17ONozwdGKYuxPqyt0w1tPC1swQa5OBuDlY4Gpvjom+FpqqPVFX7oZazy6o9eyCco8OqPXshLpSF1Q7t0WnZzv6K7XDVk8Vf4uBhDgZE2o/kFAzVWY6a3MhbfdrUFVaUvJWqHmTBAIBAkGVTtPZY8RNDyR2+hi2TvZj0wQfNoQO5ZcAO9b5WbNmhCVrRljyS4ANvwTYsCHQgcxjB8ueXaFr9aHv413XlZaWUlJczPZtW+mt2JFB/dXp27Mr7vYWmBtoo6uujL3ZIHTUlOiv0h1DrT74ujkyNXQU/l5OjB89jJmTxzFulDcRkwLxcbNFT1OZRg0aVvobqVOnDK7LAobLgKt8j5asrKwQsspBq7y7Vb6UsGrIcdWqaKZR0Wjjw4N6KwPO67AljWRtKerUkqT2Dx8TrD4Eft4HX+8zyKh6vnpw9bbxYn0ZiQpbt27d4vDhwyLDTl5eXo1g6+LFi5w9e/azwtbz58/Jzc0lMTGxUhBwRkbGa0HCb6ukpKT37s/6X4etqlVQUPDRApYPHDhAdnb2Z4OegoIC4uPjPztsXbt2jcOHD1c6pqCgIOxGiaKRI0fSq1evNwKbu7s7VlZWPHnyhPPnz9O0aVOxG+FHlhi2viJ9y7AlU0eSegplHYyhw4fh5DaEmdMnMXd6KGHjA1i9ehGLF89h6+Z1xMycQnCAD24OFjhaGWNvYYhazy6Y6GvjbGuO1WB93BwssDTWRb+/GroaKuhqqNK/Ty/6KHWlZ+e2KPfogEbvbih1ao1al3Zod+uAnmpXXEw0mepjy1RnI8Zb9yfSQZu/F02jtKTkjb+z6sDWm1RaWsLZ7evZFR1M/IxR/DXVl22Th/N78BA2Bznxe/AQtoxzZtt4N7aNd+PIhsWUlr75vXwsFRcXMyFoDD06tMZYRxOt3t1xMDfE3EAbDWVFNHsp0l+lO/1VuuNpb8nEwBH4eToSFuTHzMnjCBntw5Txo/BytsLSeABNGzcR/p6/l/iukmFFOXCV78eSk5OrNmy9qZMlhi0xbH0LEhW2ampwkZeXx/79+0Uef+nSJc6cOSPy+NjY2Pd+7hcvXpCXl8eFCxdISUkRdmB27tzJ1atX3xkkLIatD4etqlWTgOXPDVsPHz4kISHhs8PW1atXSU9Pr3RMRkaG58+fizQPZGVlISEhgaSkZKV9zr6+vkBZzpajoyNycnI0bdpUnLP1CSSGra9I3zJsSdeuw3cSEvTs2ZPmrVvh7u3BvDnTmD0tmMAAL9avX87y5TFsWL+CCWP98Ha1w9nWFHdHS2xM9bE1M8RziC3WJgY4WA7GwdIIU4P+mBsOwMJIB6vB+hjraTFAXQVN1Z706t4eLbUeKHdpi5ZSV3R7dMegb09CfOzYumoemedPUHAvl6wLp8nPzRZ2kT62BKWlFGRdZV/MOJJmjSY+0o/YaSPYHu7G32GubA93I26KB7HhQ9ke5sX9Gxc/2XspV2lpKUfTD2Oso4muem8G9e+DtlpPjHX60adHJwao9qRPt44M0lTD3sQAT0cLfD0cGD96GJPG+hIy2ocJY0fg7z0EewsDVFV607hhI+op1EVWWuatUCQjI1Np+eCHwtZrwCCGLTFsfSMSFbZqanBx7969GsHW5cuXOX36tMjj4+LiXvvcFYOEy1319u3bx5kzZ7h9+zbPnj2jqKiI/fv3c/fuXZGem5SUREFBQbXH1aQT+CVh6+zZs5w5c6ZG96gYsLxr1653Bizv37+fW7dufTboyc/PZ8eOHZ8dtsozzyoeq127Nv/888+XnlLEElFi2PqK9KlhS7Z27Ur1Pth6/frKsPVeh8FqgJi0tDTff/890tLSyMnJYWptyYwZ4cyaFsrCmJksWzyfebMiiAwLZlyAF2NHeuDjZssQGxMcLc1wsbPAw8kGJ2tTnG3NcbY1x3OILa72llgaD0RLVYXe3bqi3LUzPTt1QE25F32Ue6Kq2AUdNSWMtFUJdLfi7KH9lLy2B6tm3av36dnD+8RN9mbHtOHsmTWKpOl+xIYPFQLW9jAv4icNJXHyMJ4XPKjRsz70s+Tm3KZ3l3ZYGgxArXtnurVrSdc2zcv+26oJaood0FLuhoW+NpaD+uPlaMEob2fc7UyZMNaP0EAfvN2sGebmgpaGJnVq1aZOrdrU+v6HN+yJkkRaUgpZaRnkZGRRUFCoZIzxyoWwHJykK1X1Yau69eqZZfu9Ku8Bqy6gvAt2XgfBd9f7crned//3wd3734MYtr6kRIWtmuQ+lcPWvn37vihsPXv2jPz8fK5cuUJ6evprQcJPnjx549iawNauXbtEhq0DBw58k7BVtd4VsLxnzx5u3779WWErMTHxs8PW5cuX7PIn9AAAIABJREFUOXr0qPD148ePkZCQ+OTfNcT6dBLD1lekbxm2JCUl+f777/nuu++oX78+9i5DCA4eydrlMYQGB7B6xWJmRYYzbeJY/Ic64mI/GL+hTgzUUsXHdQg+bo44WZvi7miNt6sDXs52eA6xxdHKBCNdTXTU+6DaXREVxS6odldEs09vVBQ7o6HUjYF9euIwSIufYmZQ8pblgm9TzZcRlnL3ynm2jHMmNnwoO6YN5+9JnsRN9ubvSZ5sDXUtW0YY4sq2EFceXK9eZ6v8/VVnj1lpSQlHD6eh11cZ3T69UOrUlk4tm9CpZRO6tG5Gp+YNUe7Uhn49u6DXV5mB/XoxWKcvbrYm+DhbMz7Ql6AAT5ztjNFQ6YWGej86tGtPi2bNhXu2qnZTpOqUGWjIycgKnQjLHQgrglZZJ+s9nSkxbIlh6xuRqLBVk2VtRUVFPHjwgL1794o8/sqVK5w6dapaY16+fElBQQHXrl0jNjaWxMREdu3axYkTJ8jMzHwtSPhtdeDAAfLy8r5a2MrMzPyqYatiVQ1Yjo2NZefOnW8MWP4U9eDBgy8CW5cuXaqUX/bo0SN++OGHLz2diFUDiWHrK9K3DFtlLnFSKCgooKSkhHJfNSIjJxE2zh8PV3tioqOYFRlOxKQgPJ3McXUwwd7CgKEutoz09sTFzgIna1OsBuvjZG3KCE9nHK1MMDfUZfDA/mipqghBS71XTzSVlejbvQu6qt3R6N4e677duXzmZKXgv4p6q7vff85+lTph/3XDPqQ7VlpSwq7ls/httB1/T/Jke5gXf05wZ9t4N7aGuvJHiAt/hLjwyxg7fhvrQMr6Be/cP1bxmSUlJTx99JCC+3ncvnyO5DXzuZy+r5LRx5tUXFzMxLGj0O7dgy4tG9O1TXPaN2sohK0uLRuj1KEV6j06o96jM5rKXTDsr4qzlRG+7vaEjQtgtK8rrg4mNJCRomH9BjSoVx85Gdk3drbq1KqNZO06wu5WxVytisBUDk21a1cuMWyJYetbVWlpqUiwVZMv/+WwtWfPHpHHX716lZMnT773usLCQm7cuMHx48dJSkoSfhGPjY3lwYMHIj1bDFsfXmfOnPmksFW19uzZw7Vr17hw4QJpaWmVApZv3LjBw4cPP+rz7t+/z86dOz87bF28eJETJ05Ueh+SkpJfejoRqwYSw9ZXpG8Ztsq/ICsoKNCqVStadWiHr68nQSO9cHGyZtrkCcyePpmx/kMZ7m6Ls50x5ob9cbU3x9bUGEcrE4bYmOHmYMUwdyeG2JhhYaSHib42A9RV6NWlEz07dUC1u2JZh6tzW9S7tUelQ3O0e7THU6s3BffenXFRFWZKS0o4n5rM1kURZJ4/zcO8XK6cPs6ayPGsjRzPldPHeXAnhyunj3P97Mk3uhleSE1mqY8pvwTYsGWcM3+EuPD3JE8hcP0R4sKWcc6s9rMg2kmbKDsNTu6OpaSkuMK9SigpKebqmRNcPXOCh3fvcP38KX5fFMV0D3OiPC340deGJSOsWBlgx66Vc8i5fJ5/X76o5JBY/p4e3L/Hndwc0tNS8PVyo2UDeZoqSNOqoQJtGteja6smdG7RCJXObVHp3JbeXdugr6GMia46w11tCRk9nNBAHwbpqNJITgZpSSmk6kgKu1dvg63y85WXDEpWAq06depQq1blEsOWGLa+VYkKW3fv3q3Rnqv8/Hx2794t8vhr165x4sSJ144/efKErKwsTp48SXJyMjt27ODIkSNcvXq1UpBwQkICT58+FenZBw8e5M6dOyKNTU5O5uHDh98UbJ09e/azQcjevXvJyckRvn78+DE5OTmcP39eaHLyMQOW7927R1JS0meHrYyMDE6ePCl8nZubi5yc3JeeTsSqgcSw9RXpS8OW3A+V630GGdUxxKj9Q513VvkX8vp169GhXXsUu3Rl+DAvJoWOwt3JjClhoUSEh+LuaMkwNxtM9LVwsDTC1swAWzMD7EwNcLY2wd3eAnd7CwZp9cZERwMt5R4otm5J984d6NS2Feq9e9GrWxf6KXamU/Om9GzbFN3uTRk5SJnMC6ff3tkqLeVhTha3Lp6h8F4emedP8Ef0BKKHDGCyqTKTjNQIHaRGkL4qo3SUGa6tyLD+XRmq0QkfrS54anZhadgYLp08yoM7t7l6+hibo8OIsO/PHLeBrB3tyKYQV7aGupIYMYzE2aPZPsWb7RNc+NnHmGXuRkwc1IsAbUW8+3Vi8YSxZBxL517OLS6fPM6+vzaRmXGaR/fvknP1AmePpnH3djbPnzzmXs4tDsX/ztJwb1YG2rFqrBsrA13ZMNmPY3//yv2sqzx9eJ/njwsoKSkRLqUsKSmhuLiYLZs20rSuPM3qKdCyYX3aNW1Ah+aNaN+sIV1aN0OrRxe0lbthN1gfT0crQgOHEhroQ+sWDZGVkUJOTg5JSUlq1SpbQlj1C345iElLSpXB1n9V/jfxPgAoh546dV5ZyldcglieqVW7tuR/cPbuZYivAUmVPWJV7/d+4Hk7IFUXrqoPWx8GS6+WdL4P1t78sxLry0hU2KrpnquHDx+SnJws8vjr169z/Phxnj59yq1bt4RBwgkJCa8FCb9pfLmpgRi2/rdga8+ePeTm5r71fGFhIbdu3eLs2bMcOHCA+Ph49u/fz5kzZ8jOzq52wPLdu3fZtWvXZ4et8+fPc+rUKeHr7Oxs6tev/6WnE7FqIDFsfUX6lmGrTq3aSEtKle3ZkZWjQb36qPZWwtXJEiuTAQT4+TAheBRezjb4uFozaEBfnG1NMdHXwtbMANOBWoxwd8TT0QoTPU0GaigTFDCCw6mp3M7OJv3wIcaM9EO9dy+6dmiLYoumdGzWhJ5tmzK4d1umDjEg4aeYty7RKy0pYfuiCKbbajPDTpcpVv0YZ6JGgKEq62aFc+1sWUfpytmT/BIzg9XTJ3Lp1DEe3Mnhwol0fpwYgJt6R9z7dcJTswvDNToToNONYCMlpjv2Z4WvNX9M9CQxYgSp84PYHT2W+IjhbJ/kykpPfWZaahKs2x1/7TKA+3FiABdPHOHBnRweP3xQaSljWbdKIFy6KBCUZXoVPX/K00f55F6/yJ7flrE5cjSx88azfXYQR/5Y+dbPXlxczFA3F5rWladVowa0aVyvEmz17dKevoodMNPTwtXWjOBRXvgNdaJV80Zlxhh16ggBSErqTQ56r0wyyoGrHLQ+pNtSu3ZtateuLYSt8uwuMWyJYet/XaWlpTx//rzamVM1XQZYUFDArl27qj2uPEg4LS2NHTt2EB8fT2pqKhcvXuTevXsfDI41ga2UlBRyc3NFhq38/HyRYEvUTuK3Blt37tz54OsfPXpEVlYWp0+fFgZTHzx4kHPnzn1QwHJeXh7JycmfHbaqWurfuHGDxo0bf+npRKwaSAxbX5G+ZdiSqiMpdKyTkZJGQU6etm1a4OxgjoVxf3yHeTJujB+eQ6xxdzDF3HAA5oYDsDTWxdnWFH8vZ1xsTDHR06RPj078uW0LxcXFr3Vptv/1J62bNaZbu5a0bdqI7i0b4WGgyuJRTqyb5E3W2SOUlr4KDC5fWnfuYBIRtv2ZajWACJuBTLDUItxxEBePH6p0ffl+rdf3TxWTuuMv3NQ74tq3Ax59O+LRtz2+OopMcdBmzSgHkucEcnTJJM6vjeT82pkcXjSenVHDWeypx+TBavhpdsZTvRMpCX9SUlwszNuqbqBx6X+ByjfPHWN7zARi54WQn3XlrcYbJSUlpBw4QGN5WVo0qEerhgq0b9aQDs0b0allE5TaNKevYgesBukwxGowQSO9CBo5jK4dO9CoQWMaNGiAvLz8q0ysqkvXKiwjLAcuIWj9B2vvXtr2avlguZtlRYMNMWyJYet/VeWdrerCVk2XAT569IikpKT3XvfixQvu3LnD+fPnOXjwoPDL8OHDh0lNTRWpK1dUVERiYuIHG2J8TNjavXu3SLBVk2WbXxK2Tp8+zblz5z4bhOzevbtasFW1CgoKyMzM5OTJk+zZs0cI8xkZGeTm5r6W8XXnzh1279792WGrqvHIlStXaNGixZeeTsSqgcSw9RXpW4at2j/Uok6t2sJ9O7LSMrRu1QxrcwNszHQZO9qPsQHDcbU3x2tIWWCxsZ4GzrameDnblC0d7N8Hla7t8PN2p7i4+I0/4+LiYvyG+9ChdVOaN6qHVo9OhLmYsW6iDxun+RE3J4gjW1dzL/MKTx/e5/bl8/y1IIKp9tpMsRtAhKMh2xZGkXU5g5fPnlTLjVBQWkrhw3wyjh9mYWgAQ3q3w029PWNN1VjpZ0Pa4klc3xRDwbEkXt67zb9PH/E49zp7180hWLcXzj1aEh04jJK3fLbqqrS0hOOJm0hcHMaLxw/feW3WzZs0lJUuA676ckLY6tiiMcrtWqLauS1melo4W5sQ6OeF1xAHenXvQasWbalfv74Qtt60x6kcsisuKax4/P0w9Cqzq7yDVtE6XgxbYtj6X5WosFXTZYCFhYXs3LnzjXB19+5dLly4QGpqqnCZ17lz58jJyREGCWdmZnL06FGRn79z504KCwtFGpuamkpOTo4Ytv6fwlZeXt5Hu9/Dhw+FS1aTk5NJSEjg0KFDXLx4kby8PHJzc9mzZ89nh62qHcOMjAzatGnzpacTsWogMWx9RXovYNWpXak+NWy9zyDjXSYY1TXIKIet8i/cdaWladWkCYMNdLEyHURwgA+TQ0cz3MORgGFumBr0x2yQNg6WRvi42WOio0Wvzu1o1bQRqSkpb7VwLykp4fChNJo0rkeLxnVx0O/DogAbtkeM4q9pASTMDSF2TjAbJ/uxJsiD+R7mTLXQZopVP6Z5WHE6bX+ZhXqFJXsfqledpRJKiovZ9/c2LBVb4q3bg1WBzqStCuN59sX/umOvOmWlJSWkxP6BSccmnE1Pe+tyv+pKUFrKg5xM0n6eTuGdm+/ubB08QAN5GRoqyNK0gRytGtctW0bYrDGKbZuh0rUdOn174eNix5TJE3Cwt6Z1qxa0bd2GevXqoaCggLS0NLVr137vF/r352i9Dj7lUCQtLYu8fF3q1q2PvHxdZGTkXjO0EMUEoiLQvX6/6gHRp4Sn6oCeaPd7M3SJ9WUkKmyJugywvB4/fkxiYiIvX77k/v37lYKE9+7dy+nTp7l169ZbTSxu3rzJkSNHxLAlhq1KlZyc/FFhq2o9ePCAq1evcvToUZKSkkhISCAhIYHLly+/FrD8OX+up0+fpmPHjl96OhGrBhLD1lckMWxVhq0WjRoxQKMPNuZGeA6xJnTMCAKGueFiZyaELUcrY4a62GKopU63di1p2qAu2VlZ7/w5Z2dn0ap5Izq1boqPtT5rQ92InzGaxDlBxEcHET8vmC0Ro1gb7EmMuxnTbfSY4jSI3xfN/GigA1BSXMykEV6Y9e7AAj87ruze9HbgKS5msp83ebezP9rzAYqeFXJq81yu7t8mXJZYVcXFxXi5uwphq0l92Uqw1atzG7q1a45ePxVcbExxdXFAuVd36tdToK68QgXL9tr88MMPHx22yoFLSkoGGRk5MWyJYeubkaiw9aHLAKvWy5cvyc/P5+LFi8TGxrJjxw52797NqVOnyMrK4smTD9tHlZWVRXp6+lvPr179L206C/juewHde5fy99//VjqflJTEo0ePRIKXtLQ0bt++LdLYPXv2iGQ5/7XC1qlTpz4rbO3atYu7d+9+tufduHGDpKQk0tPTSUxMrBSwfP/+/U/6c83IyBC+PnHiBF27dv3S04lYNZAYtr4iiWHrFWzJS0rSrEEDunduj6ONGeaGAxjp44rfUGccrYyxMdXHQLsPFkY6DHWxRUu5B+2aNqChgiypKQff2dk6lJZK++ZN6NmxDaHuNvwePozEWYEkzQ1m+6zR7FwYysG1s/ltih+rA92Y52HGj6PduX35/Dvzqaqr0pISjqamoKvUltnDbHickynsaL3p2uNpKZw4/HE7WwW3r5P2Uzgnfokk/9qZSp260v/2uW3euIGGCrJC2GpcT4aWjRTo0LwRXZs3QalTaxTbNsNogDpOlsYodu1A/XpyNGnc8I1W7x8btsrs2Mu6WmLYEsPWtyRRYettywDfVAUFBVy/fp2jR4+yc+dOdu3axdGjR4mLixO5u5Sdnf1W2Fqz5l++ryVAYhpIJINEgIDvfxCwe/c/wmtEzbsSw1b1oeD8+fP/s7B1+/Zt9u3bx5Mnrwcs79ixg+TkZI4fP87169c/asDyiRMnuHDhgvB1eno6PXr0+NLTiVg1kBi2viKJYesVbClISdG8YUPqyUpirK+NrZkBPm72WBjp4GBphLnhAHT6KWNuOAAXOzOUOrShZQN5GirI4unm9s49W6P8RtC1dUvUFTszw8+dP6f5sXPOKPYuGkfKqnCSl4RwcN0cUn+OZuv0MSTND2PTJG+e5N/76L/znOwsjNQ6MMvfiZePC955be6tLKaN+nh7tgSlJdw/lsjVP2O4um0eFzZEUXD7OgD//vsvJ44cYYSnBw3kZYTVUEGWRnWladFQng7NG6HYoild2zSlt2J79PqpYG6gTft2LWnUsC6NGzUQdrakpKSEgPIpYEtKSgZpaVlkZeXFsCWGrW9GAoFAJNh68uQJiYmJbwWxzMxMjh8/zq5du9i5cydHjx7l+vXrQsB59uwZ8fHxIsFDOWwdPnz4jec6di9FIqzsy0t5/eAkYLBFyUeBrUOHDnHr1q3PClv37t0Tw9YHVFJSEvfu3ftsz7t16xb79+9/47nHjx9z586dTxKwfPz4cS5evCh8nZKSgoqKyheeTcSqicSw9RWpugYZVeGqalWFpeqGGr9eHw5b1TXMeN0KXBZ5WQUka9dBRbkHrq52+Pq6M3CAKo7WgzA31EW7rzIm+tp4ONmgotiFJgpyNK0rTwMZKTZv3FgJuEpLSykuLmbb1i0otm+JYptWaPTowIyRjiTMGkVS9GiSokezf1EIx9dEcHJ9NGkrIji7YT5/RY7k0I+TuHvl/FuX2omi0tISzh07ird2f34KcuXRrWtv72yVlpJx/DD2vduQlridkgoBydV1IxSUliIoLSHv4knSlk0mbdkk0ldO5ujqqTzKuQHA0UMHUWnTiqYK0shL1aaerNQr2JKXpE3T+nRo2ZjObZrRq1NLDLX7oqGmTKd2rZGTkUVWWkZo4f5+2KlelYNP1So3yHgfbFWt9wNH5Syw10OSqwco7wYq0QOS3wxnH2ZwIYatr1OiwtbTp0/ZsWOHELzKg4R3797Njh07SE9P5+rVq+Tn57/x3s+fPycuLk5k2Lp16xaHDh164zlJGQEScZVhS2IBtOokEF4jat7Vx4Ct+/fviwRbouaaFRYWVgrw/ZywdfLkyUrL3f7XYCs7O5sDBw580LWFhYXvDFiuTsbXsWPHuHTpkvD1vn376Nu37xeeTcSqicSw9RVJDFsVSwapOmXhtm1aN8fWxpzhw92xtTTERF8DCyM9nKxNMdbTwkhXk+4d2tFYXpZm9RSoLy1JfVlZRnh7C3+2mTdu4O3tRftWzejWoRVKHdqh3aszM/wc2DFrFMnzAtm3cBy7Y8ayPXI464Nd2DTRi+3TR7J9+kiW+wxmU2TwR+sqQdk+rEVh44hwtmXbND8uJqx/656t0pIS1kSNx1u3J6MN+vLrrKncOHeap4UF1YKtkqLnFOXncvfITi79voArfywiZ8cqchNXk3dkByX//gNA/oN7hPiNoEV9OerKSL4GW62b1KN9i0Z0adsctW7tGNBHCe1+arRu3qQSaIlhSwxbYn06iQJbT58+5ebNm8TGxrJ3716hQ9vly5e5f//+B93rxYsXxMbGigxb5VlbbzrXt38pEh6CV6BVChKaIPE96OiUEhv7L8nJohlVFBUVcfjwYZFha+/evZ8ctl68eEFeXh7nz58XBvfu3r2b+Ph4UlJSOHr0KPv37/8sZg6fG7Z27tz5SfdKVa2srCwOHjwo0tj3BSy/K+Pr6NGjXL58Wfg6OTkZTU3NLz2diFUDiWHrK5IYtl6VrLQCP3xXCwU5eVq2aIJ6XzXsbC1xtrdkgHovjPW08Bxii9kgHTRVe9KjY/tKsFVXWpq60tI8efIEgGXLltKwQT3at2pGz85tUevciYEqikR6W5Mw3Z890WNIWRjCiVVTObtuBrnxK7n552Iubojm0JKJ/D3Jk43B7lw/efi1HC5Rcq5KSoo5lBxPtL8jG6aMInleEGkLg3hy80JZd6v8ngIBgtJS8i6eZHmQC6ONVfHXUSLcXJuZjkbMcTHl6pFUSqt0uiqGGpeWliIoLSU/6xrHtizn/M+zuf33Cp7s20Thng3kJaziWfYlYUZY+Zji4mK2bdlMo7py1JeTpr6cNI3qytGkrjStm9SjQ8vGdO/YGo1enemt2J6B2ho0b9ygUl7Wp4Ct8mWJ5SWGLTFsfav6ENh6/vw5OTk5nD17lv379wu/tMfGxnL37l2Rsq5evnzJ9u3bRYatnJwcUlNT33ju11//QeJ7ARLGAiRmQ20tAXVkBbRrV4qEBEhIQPv2T1i+/AlPn4oGW9nZ2f+vYKugoICrV6+Snp5OQkIC+/bt4+zZs+Tm5vLkSZmFeX5+Pjdu3CAlJYW4uDgSExM5cuSIsAP5vwBbiYmJPHjw4KuArapVnYDlchOOip9bR0fnS08nYtVAYtj6iiSGrcqdLRkpWZo0akzTJg1o37YdBvp62JgPZqBWH8wG6WCsp4WD5WC0+yrTV6kHzeop0ERBjgYyUkLYunb1KgDbtm2lfj0FOrRuTq+u7dHo0gV9ZUXCXUyImzyMPbNGsW/OGA7OC+LQwlAu/DqTjF+iOLggiP0xgaTFBHFs9Swu/b6U24fjeP7gNkVPCynMu0XBndv/Lc17O+yUlpbypCCfgrt3uHH2JL8vmMHPEQHs/Wk6iTHjSF86gSNLQrjyxyKeXDmBoHy5okBA8bNCbh3czokNc/lrZiDz3EyZZq5JlI0Oc50GMc/ZiL2rY8jOOM2ju7lkZ5zieloSL+/nUPLiKS8f5PLi8hEepf7B3T2/UZC0nvzEddyL/4m82FUUntj91o5acXExPl5l+7bKYatlIwXaNW9I5zbNUFbsgKpiW8wNtOnVrTNStb4T/g7L4eRjw5a0tHSlEsOWGLa+Vb0JtsqDhDMyMioFCZ8/f547d+7w4sWLGnemioqK2L59e7WXL5ZXbm7uG2Hr5csiDAzKoEqxZyk9+pTi5V1CRsY/vHhRxNat/6Kh8Qq6WrUSMG9eMfn5H/7s9PR0srKyRHrf+/bt4969ezWGradPn5Kdnc3JkyeF++KOHTtGZmbma2HNb9uzVW7mUG65v2fPHqEr5Lu6KmLYelU3b94kJSXlk9y7asByQkKCMGA5JSWlEmzFxsair6//pacTsWogMWx9RaopbFXXEONTwtb7QOz1PVqS1KlVW3hOWloaGRkZYUhth07tUVVVwcRoIBaD9bEzN8JAWx0jXU30NNXQ01SjY6smNJSVpr5UGWjVk5Hh8qVLALx8+ZLUlBRG+Q6nV+d2qHdrj55yV0IcDNg63oldM0ezPzqItJggji8cx+nVYZxcOZF7CUt5lLyaBwnLuPl7NBfWTePIj8GkrwnjzMYZHFg2jl0LRnM5eRNPcjP558kjCrOucT0lkdsXTlN4/y551y9xevta/ozw47dQD5aNsOXPOaGc3LyY0xvnk7YigqPLpnF02TQub1hA0Z3MSt0ywX/drcc3LnBl43yOr5jGCj9LZtn3Z8VQE7aGurN1sh9/TQvgtxAv1ge5s8LfmYWeZiz1GszG0fZsH2dPfJg7x5aGcWXFFG5vmkvR/l95euAXigvuvHWvWElJCWkpKUKQbVZPQQhbPTu3RaVbR9RUlXAeYkejhgrUriUhBB9paWmhMUbFeh123r1MsOLx8vtWrIrnpaWlkZeXp27dusjLyyMjI/OGUOPqL1us9FxJKWHw8psAqDqmF++/tnqw9SZzj5pU1ee/DdbE+jISCAQ8e/aMvLw8Ll68WClI+OzZs+Tk5PDs2bM3QE3NOlNFRUXExsaK1BUrh62UlJTXjq9Y8S8SEtC9eymPH799/MKFxzE2LhJCV/36AiZOLObWrf+fsHX37l2Sk5PJyMgQLjlLS0vj8uXLPHjw4L2dyfcZZBQWFnL79m3OnDkj7KqkpKSQkZHBnTt3RF5yWNU171PXjh07PlmX7k31Ofe/5efnCwOW4+PjiY+P59ChQxw6dIhFixZhZGT0pacTsWogMWx9RfqWYUuydh3q1KotdCQsh63ybkWrNi3R0tKgT++eDDYYgNkgHQZq9cFIVxNDHQ10+vWmd/dOtGxYn3qSUtSXlWXzxo2VrNpL/rMyj/trG2pd2jCgZyd8TbVYN9qKv8N92Ds7kCOLQrmwagrXNswk96+F3Pl7Ebe2xnBj02wu/zKdG5tmk7f9R04vDCFpojsnYoLYNcmD1R76RJn1YqpxN6KsVFg83Ja/I0ZxeHkER5ZFsGPKMLaGePLbWFfiZwSS/ssCLv21mivblnFh8yJO/zST4ysiubV/+1u7TILSUvKPJXP990WkLQvn59H2LHQeyFx7bRY6D2SZpzE/DbdgwxhHNgY5s2WcM1vGOrBtnCM7pvlydEUE+Xs28fLArzzds47cLfO5t20RpS+evPPv8lZ2Fq0bN6Rlw/q0aFCP5g3kUFbsQO/unVBX7oamRh/0dPujIC+NjHRtMWyJYUuszySBQMCVK1fYs2fPe4OE3wRLonamioqKiIuL4/nz5yKNvXPnDgcPHqx07MaNIhQUBHz/vYC0tH/eOb58Od/p0//g4VFC7doCJCRASkrA8OElXLjw9rFHjhz5LLBVcWlgfHw8cXFxwqWB1fm5ieJG+PDhQ65fv86xY8dISkoSecnh/zps3bhxg7S0tM/2vPIqB+2rV6+ybNkymjRpgrS0NC4uLmxBQApuAAAgAElEQVTevPlLTytiiSAxbH1F+pZhq7yrVadW7bIvsv99cZaSkkJWVpamzZugoaGO3gANtPoqo6uhip6mGoMG9MNEXxuN3j3QVO1JlzataCgjy1B393fav08Y44eOUmdc9NRYMMycrRM82R8dRPrCEM4tD+Py2mlk/jaTS2umcuPXKB4mruCflN94lLSKA9EjydwaQ27cEn4PdWTHdB9iZ05k/8po9q+bT/rvy9m7chZ/Tw9k4xhn1nmb8utQM9b6WLEhyI3DK2ZwfP1CLv2xgitbl3L2l3mcWh3F8RWRPL2T/dYuk6C0lOd3b3Fl43zOb5jLvphxrB9py0yrfkRXqFnmfVjhqsvaYcb85G3MTz6D2ffjVLJifyZ/7xbyEpZxN34p+duXkv3LLJ7n3Xx7mHJJCWkHD9KmSSM6t25J59Yt6dahFWo9u9C/Ty/6KHWlbZtWNG/WhLoKcsjJSn9y2KpaYtgSw9a3KoFAwPPnz0WCpri4OJE7U0VFRcTHx7+xa/YhlZeXx4EDB4SvX74swsSkBAkJGDeuuNrQc+NGEUFBxcjLl0HX998LsLMr4dCh16HtyJEj3Lx586PDVsWlgcnJyZWWBubk5IjsRlhT6/fy/KiLFy8KLcz37t3L6dOn32vk8LlhKyEhoUaW6tWt69evc+jQoc8OW6mpqWRmZgpfb9iwAUNDQ9auXcuiRYu+9LQilggSw9ZXpG8ZtipmbUlLSgm/NNerV48mTZrQqUtHVFR6oa+rRe+eXejVtT39VLqj0bsHeppqaKkpoanakz49u9OxRUtSD7472Ph4ehoDenbCrK8i01yM2RjkzN7ZgRyYM5qj84O4uGoy55dP4sb6GWRvmE3m5jlkbZlL/o7lFO5azeWfp3NwTgCnl08iIdyD/fOD2THdlz9CXNgc6Mi60RYsdB7AbDM1pur1INJQiZgh+iQtGM/ZP5dx8feVZGxcwqXNP3Lu57mcWzeHk6tm8M+TR+/8G/nnySMu/jqXM7/M5sjyKeyZNYY/J3gy31Gf8EEqhBkoEz5IhYjBSsx11OHXYDf2LggjL2kD95N+4V78Kh5uX0r2xmiurJ/B1d9mkrP791d7xKqouLgYPx9vWjSoR5smjVDq3JE+Sl3R7quMunI32jVvSP269ZCsXYe68grISst8cth613kxbIlh61vTy5cvRYKtmsBSUVERCQkJH9xFq1pVQ37XrStbPtilSymPHokOPXfvFhEVVUyzZgLhEkNd3VLi4//h/v0iRviVICVfQm0pATYOJVy/Xr33vX//fu7evUtRUdneuLt37762NPDSpUuvLQ28f/8+e/fu/SKwVbXKXfQqLjlMTU3lwv+xd9ZRVaXtGz40HFq6uzsEEVDsBBHERkUpEREVE8UOzDHG7tZxHDFQETtBRUywRrG7fjOjo8D1+4OBT1QQQfHjm3Ov9Szch7P3PiLrXfvyud/7uXSJBw8elLIcfjwPqjpgqzjivjrq2rVrHD9+vNph6/Dhw9y8ebPkePny5YSEhHyzNeHdu3f07t0bFRUVatWqxaBBgyoc5CVS5SSCrRqkbw1bX4KlT6v8IcffNiCjdEmKSyArLYO4QAwFoTza2tqoqalhbm6Oi4sLnh7u1HZ3xb95Y+q42GFjoYuDjTHuTnY42Vrh6eqEh4sjnq5OuDrYcuf27XJ/1vdu5+FhYUhjRxMGBtZleXx7to2OYP+k3pycGsfRaX24sHg4VxYlcmVRItcWJHJ9aRKvUufxcvd8Xqav44+Dm8hdM4NVcR1Z0Nabqc1cmRXgy4zWPoyv70Sijy193I3o52vJhO5BnF49i9zNc8jdOJ0r62dwZe1MLi6ZSta8SZxaMpoLKybw+u7v5doI/3x0hxu/zObKL3M4tTCJ9AlRHJkaw/5pA9k5LoYtI3qxeXgYaZP7kzkniZxlU7i5dhY3Vk4gZ/EoLi9KInfxRC4tGMfZ2SPJnD6UrHkjeHolu9RiXPCP5XLzpvUYaqliY6qPuYEWVsa6ONhbUcfTDVUVJRTlFT7bbfoYhL4Gtj6uz12//M7WpwEZxeEYUlJSZQJDcX34vrIi5ssLyPgy8FQMxD4frvF1VVXYqii8ifTjVFnYqgosvX37lp07d/L69etKnfvo0SP27dvPs2dv+f33t6iqFiImVsiBA+XbBz8HPZ+rly/fMm/eOyws/hOmIa9aiIRJIYKVINgMUp6FGJoXlrs37OPat28f586d48SJE+zcubPk+O7du+VaA781bH1L69vHlsPiIdbXrl3j5MmT1Qpb27dvr1bYKrZ5VjdsHTp0iFu3bpUcL168mE6dOn2zNSEpKYnatWvz6NEj8vLysLS0ZPbs2d/s+iJ9KhFs1SD9m2FLQky8JCRDRUkZAwMDbGxs8Pb2xsvLC1MTI/xbt6RZw3q0aOiDnZU+9tZGuDrYYG9ljp2lGc521thZmuFoY8npzAwKyulsZR4/irOJLj7WBkQ3d2NBTBC/jOjJrjERHBgXxYkZ8Zyc2Z/jE2M4MakPGZNjyZmfyN31U3j460yep/zMH7sW89eepfxf6iKyV45jQ2I3pvdqycgQH0Y182BCSAOWxndh14yhXN25ilvbl3Fh8XjOz03kwtJx5KxM5sqqGeQsn0H2ykn8vnkO9w5vK/N/oAoLC3l4PJW72xZyZf0MzswfSfqEKA5M7M2hSf05NnUQJ6YP4cT0IWT8NIiM6QM5PrkfR8f34dCoCA6PjuTEhD4cSR7I0SkJHJs6iOPTBpM5ewjH5wzj7R9Fe7f++vMPMo4eIi68J8Y6qhhp18JUTwMTXXXsLYyo6+WOkaEuCvJyKAjlvztslTVXq+zOlgi2RLD171FlYasqsPT27VtSU1M/Sc6raC1a9BJNgzcIBCCtUNSFio39sn2wuA4ePMiDBw+++L6//nrLpk3vcHD4B7oufDAo+SVIKhayevW7Ms//448/yMvLIysri7S0NFJSUjh69OhnUwPLq/9m2PqwPrYcpqSksGvXrgpZDr8VbH3NcOCq1pUrV34IbB08eJC8vLyS4/nz59OtW7dvtibo6+uTkpJScrxo0SKcnZ2/2fVF+lQi2KpB+jfD1ofXkJGSRigUoqOjg7KyMlZWVjg62OHj7UVwQEv8vNxwsjPGzsoQVwcbrM2MsTQxxNbCFEMdTYz1tBkQ26fcPVsJfSJwNNHB09yAbvVcmBnhz9oh3UkZGUFqUgT7J8RwODmO4xP7sm9kOOlJEWQkx3NiUhxnpidweVYC1+YN4+rPQ7m9dDQ3lo7n/qbZPPh1Ib+vnc21LQu5vm0JebtXcSdtDTe2zCV7wSiOjo3h8PBwjkyI5dz8UZxfMp6Mn0eRs/4nHqet5mX2oXJh6/6xHVzfOIMrKyZw5ufhHJgUR9rY3hz+p85MTyB3wShOzxrI6ZkDOD21HxmTYzk+oR+HRsewf2QUe8bEkD6+L4enDOT4jCGcmjOU4z8nltxn+byp2OsqYa6pVgJbhlqq2JoZ4OVqj5GhDqoqCsgLZUui0EWwJYItkX6MKgtbVYGlt2/fsmvXLl6+fPnV5+3Y8Tdi4oUIhoHgJAimg0CqkGnTyoaeysJWcW3a9A5xYSGCwg9gC5CpXci4cf+BvDdv3pRYA4tj848cOVJiDTxw4MBX3bemwdbHlZmZyZkzZypkOfwWtW3btmqHrZMnT1Y7bB04cIA7d+6UHM+ZM4devXp9k/Xg+fPnCAQCbt26VfJaZmYmUlJSIivhd5QItmqQ/s2wVdzVKkkklJFBTU0NbW1tzM3NadK4IU0aN6RjcBsa+3ri4WpVYiO0MjXCRF8HE30dDHU00dWohZmeDlt/3cz79+8/SSTcsmkDdiYaWBtp4mSsR1t3e8Z2asSSfh35ZVhPUhJ7sWdUFGmjozk+oR/7R0aRlhTJtoRQtsV3Zs+gHqQNCWXngI6kD+tO5qS+ZE8bRM7Po7i5bBr31v3M09RFPNu1mCfbF3Bt9WRyZg3h8Iie/BYbxIrQRqzq0ZRf+rZj56gI0qf05+bmhbw4uJn3L5+UC1t/PbpDxpwhHBjVi4PjYzgwKZ70CfEcGBfFoQm9OTo5luNT4ji/ZCyXl03gyvJJXFs+iQuLx3N2/mgyZydybNYwjs0axok5iZycO4LTc4dz4/COkvv8fi2X/hGhmGuqYaJb1NWyMNSmtqM1LrbmqCgLkZOVRF4oWxRo8p1hq6Ilgi0RbP0bVVnYqiwsFdfu3bt58eLFV5/XuEU+4qGFpaBHMBYMLQorfI1Dhw5x//79Cr//ypW3iIkVItjzwT1vgECikC1b/o9r166VsgZmZ2d/1hr4tZBXXE+ePKmxsJWTk1Ny/KHlcNeuXaUsh98iRTAlJeW7d88+rNzcXDIyMqodtvbt28fdu3dLjmfMmEFUVNQ3WQ9u376NQCDgxYv/7P++evUqAoGAN2/efJN7iPSpRLBVg/TjYat8+Pr4+xWJc69sycsJUVJQRFdbB11tHdQ11ahd240G9bxo3siXhr6euNhb4uZojaONGSZ6euhramKorY2xri7m+rpYGuoT1bMHGSeOlwDMwf3pmOtpYq6php2+Fs5GWjR0tiQh2I/5fUNYM6ATm4eFsz0xnNQRkaQn9Wb/yN7sHt6LrQO6sDmuA6sjAlgVEcj63u3YOaA7x8f24+KcUdxcNoW8FdN4tnkBTzf/xMMN07i1YjwX5w7lxMie7B7QkU2RbZgb5ENyKw+mdfHnzLIZnFs8joebZ/MybQWFb/8s93fk/Z+veZiylKQGTswJ8WPfyJ7sG9GDAyOjODGhL5nJfcme2Z/sOUO4MG84OYuSuLJkNNeWJZO7IpmclUVfLyweT/aCMZz8aTiPL58utU+soKCA9+/f89svGzDTUcHeUA9HMyN83ByxtTBBQUHhk8j1j0MxSsNWVUMbKnZ+MWwpKCihpKSCgoIScnLyFYCtT2HwQ9gqHmYslJVDKCv3CWx9Cjgfh158TcjF18HTt4atyl5PpB+nt2/fVipVsLKwVFx79uzh+fPnX32euUNBUTeLD2obSMtVHLYOHz7MvXv3vuq+kb3zkVQoRNCvEEEiCGoVIpCCzp2vkpmZyY0bN74In1WBrfT09BoPWx/Wx5bD7du3Vzjl8L8FtnJycsjMzKx22EpPT+fevXslx8nJycTGxn6T9aC4s5WXl1fy2qlTp0Sdre8sEWzVIIlg6z8lKy2DvJwQ9VpqaKipY2xqhIODHQ3r16V5I18a1/fC3ckGN0drHKxNMdXXx0hHBxM9PQy1tTHS0sBYWxM9NVWMtDQ4sG8vUPRgcicvjxNHDhMf2RMnQ03q2ZsS6+/FzKgAFkW3YU1CN7aPjCA1KYq0kdGkjYgidWgYO4f0YFtCKJtiQ9jSvys7h/Tk8KhYsqcN48q8cdxaOoVbS6fwYM0s7q9N5uaysVycM4TjE3qzb1BXfokOYHGnBkxs4kSEnRbnl8/g6Z51PEhZyINfZvFs5xLeP39UdvR7YSHvnt3n/9LWc2F5MoN9LElu5sL67i3YEBnIzoFdOJDUk5OTenNm+gCyfxrExbnDuDwvkatLJ3NleTJXVk7h2uppXFo6kewFY7i6Y225SYR9I3viZKqLt7MtdRztMdLVQl5e/pNgChFsiWBLpB+jysJWWlpapWDpw/OfPXv21eeF9cpH0qMQwbt/QKsQxDsUUtev4LvAVrE18MKFSwwenIu101Ms7F/RufMzFBWL9nKNHFmx/WJf21Gr6bCVkZFRJmx9XF+TclhWbd269ZtbE8ury5cvc+rUqWqHrb1793L//v2S44kTJ9K/f/9vtibo6+uzbdu2kuPFixeL9mx9Z4lgqwZJBFv/KTkZWRSE8igrKqGqrIKBkT56ejrU9/GkWUMfGtf3oo6bA26O1jjZmmOip4eBlhZ6GhpoqqhgpKWBgYYaBhpqmOnpcOZUZqmfdcmA480bqWttSHhzN6ZGtmZORCuWD+jCtqRIUkdHs2dUb9JGRrN3ZCR7R0aSOjSM7YO6cWBsX04kJ3B22jBy547h+s/juLlgItd/HseNeeO5MmcYl2YO4vTEWA4O78FvsUEs7dKIyc3cGFLHkgmB9XixZyXPdy/jzq9zuLd5Fk9SFvLq1P6y0wgLC/n76X0ebFnEo10rGNHIicHu5iQ3rs2Kbs35tU8wqYM6cXBUGMfHx5A5OY4zU/tzdvpALv08gksLR3F56VhyVyRzbuFYzvycxMu86+XO2Dp57Aju1vo08nLG0dwUJVlhCWx8bLUTwZYItkSqflUWtvbu3cvTp08rDVuVPT8n5y0qGgWI2xUgGAbi3oVIyxVy8GDFkgjfvn3LkSNHuHv3bpnff/HiRUma3s6dO0lPTyc7O5s7d+6QmZnJtWvX/rnO3ygpFVYYuP6NsJWbm1upc4sthxkZGZ9YDsuapVXdsHXp0iVOnz5d7bCVlpbGgwcPSo7HjBnDoEGDvtmaMHLkSDw9PXn8+DG3b9/G2tpalEb4nSWCrRokEWyVLnk5YQl0aWproKmpjpeHC3VrO9HAxwMvd0dqO9vi5miNlYkJehoaaCgro6aoiIGGGlrKiuioKhPVswf55YRlDOsbSef6tkyJbM2cqNYsiu/I2sFd2TS0O9tGhLNjRARpIyLYOzKSfaOiOT65PyenDubsrBFkTx/OhZkjuDQtkcvTi76eTx7KmQmxZIyJ5uDQ7mzvE8SKbs2Z3roOg70siXEyIG1qIrnLx5K3bjLXN07j97VTuLNxFrfXzubNw7tl79sqKODuvq3c3ziXkzNHEOliQoKfK7PaeLE8tAkbo1uzrX8w6YNDOTCsB0dGhnNsVFEK4amp8Zz5KYHTc0dy8qdhHJ8xhDcvnpX7O3n3zi0a17GmqY8rtsZGyIkX2QelpKREsCWCLRFs/ReosrCVnp7OkydPKg1bVTn/woUXuLk9RiANLm4FnD1bcdAqhq07d+6UHP/xxx/cvn2brKws9u7dS2pqKhkZGZ+1Bp4+fboEtr4WuA4dOvTV9sV/K2x9WK9eveLBgwdcunSJI0eOfNZy+OrVK7Zu3Vqt0HPx4kXOnDlT7bC1Z88eHj58WHI8YsQIhg8f/s3WhHfv3hEdHY2ysjKqqqokJCSILITfWSLYqkH6ElwpS0mWqq8favy1sFV+IEZ5VdH0wbJKVlqmVAll5UoshWYmpvh518bL3RFXBytcHaxwtDTHXF8XbRUl1OTl0FRRQUUopJaCAocPHixzwHFBfj6njh8lpJ4z48P8+TnKnwUxQSzv24418R3ZOjSMHcPDSR0aRnpSFEcmxHEieQBZ04dw/qfhnJ86hKwJAzg1Pp5T4+PJGBvHidGxHBwexp7BXdkSG8Sybo2Y2dqbYT629HYxJdLVnAMTB5A+Iozj4+M4PGEgp+cmcm5hEucWjeDPB7fKDcnIf/c3z25cJmvzInp7m9Hby4Khvg5MDfBhXkgjVoX5szEigN9i27IroQN7h3UibXh39if14tCYSI5OjudIcn+OTB3As1tXyumkFXA+6xhdW7rTsI49zvY2KMrJIiatgIS0IjKSisgIhEhJCZAVSiGQlUIgr4i8tARyUuIoyhUN/5WQkEJSUhopKRmkpD4Nzfg0MOMLg36/kEYoLy+PgoICQqGwFBgVA9eX4OdLsPWlocZfrvLA69v+h8XX1qfwVf7nK/43EunHqbKwtW/fPh4/flxp2KrK+S9evCA+/gICAYweXfHI9w9hKzc3l0uXLpVKDbx8+TKPHz8uNzDkzJkzXL169aPrVQy4KrNX7FvD1o0bN2ocbH1cL1++JC8vj7Nnz7Jv376Sf7+tW7fy8OHDautuXbx4kaysrGqHrd27d/Po0aOS46FDh5KUlPSjlxKRqiARbNUgiWCr7BLKyqGkoIicjCxKCopYmuhhY26Ig7UpTrbmOFtbYmVkgJ6aKuoKRZClLCeHspwct27eLPfnfu92Hm3r2jO2eysWxASyJK49y2KDWRXXns0JoWwd3IOdw8JIS4rk4PhYjk6O59ikeI5P6MeRUTEcGBrOvmFFlT60F2mDw9jRvwObYwJZ0aMJM4M8GOXnRP86VvSwN6RPXXuWxoSQOm0keedO8/LhA57dzePVw7v89eIp+e/fffF3paCggIL8fC4dTaevrw29XUwZ6uvA6EbOTG5ZmwXt/VjapRGrw5qxPrIlW+KC2T6wI7uHhrJ7RDhpo6PZOy6GrM2Lyh2ivHhGDB2butKkngf1mwaga+mOrKIKErLyiIlLIy4mjayEEFkxWVRkFFCTVUBCWhmBmBBxKSVk5dWRlRUiIyOHlJQMkpKf7ySJYEsEWyJVTpWFrf379/Po0aNKw1ZVzn/58iX9+hXB1pgxFYOtFy9ecP36dU6ePElKSgq7d+/m7Nmz3Llzp9yBwh9XVlbWJ7D1MXAlJX3+M/3bYOvkyZNcuXLlu9/n2bNnXL16la1bt7Jr1y52795NZmYm169fL9Ny+C3qwoULPwS2du3axZMnT0qOExISGD9+/I9eSkSqgkSwVYMkgq0PHuI+iIEviYP/53VZaRlU5GXR01TD2sy4aKixmQkWBnro1lKhllC2BLQUpKU5dOBA2Z2tgnyyTh6lna8TE3u1YWGftizsE8yy2GBWxLZjQ3wnfunfhd8GhbJ9WBh7RkWRPjaGfWN6s29UNPtGRJI+PJzUhG7sHBhKSr9ObIltz9pe/izu3Jjpbb0Y1cSBAXVsiXA2JdLDmindg8g5fpD8/PcU/BNOUVhYWNLN+vDPX1JBQT5rJw4n3M2c3u7mDKhrw/AGjoxp7Epyay/mdKjPwtAmLA1rwZroQDbFtefX/p3YNrQH2xN7smNMFC/uXP/kmvnv33Pq2HYigwxo6mFF/Xo+1GneEa82UXiHDqZu10G4hcRh3Toco/qt0XDxRdnSETF1XeSFKshKy6MgLYuihDgSElKIi0siISH1WRugCLZEsCVS5VVZ2Dpw4AAPHz6sNGxV5fxXr14RF1cEWx/Oufqwiq2BZ8+e/cQaePjwYW7fvl2pe2dlZXHlypUyYKp84KosbD19+lQEW1+oFy9esG3bts9aDvfv3092dja3b9/+pmmF58+f5+zZs9UOWzt37iwVlR8fH09ycvKPXkpEqoJEsFWDJIKtss+XFJdASkISOZmiQboK0tKoKSpiqK2NmYEBlob6mOnpYKChhqZSUVerloICCtLSdO3YscwBx/n575k0OJZgH0cm9mrD4r7BLIptx4q4EFbFtWd9v45s7NeJDfEd2JzQhZRhRZCyfVgY2wZ3I2VgV7YP6Mqv/TqyISaYFT1bsahrE2a39WVyy9okNXYkwceCCGdTerlZMDywIfvXLCmBrKqqsKCAe1cu0q+BO6EORvR0MiTG05z+XvYMqe9IUjM3xrbyYHqwL/O6NmVpL3/WRAeyeUBnNg3szMl1c3n7fy+LrlVYyJv/e8W5U0cZENmDgCbWtG/uQB0nW9zcvWjgH0qjwF44NY/EqWUUbkFx+HQbhk9EIo1jJ9A4PpmG8VNoGJmEfeswVGy9ESjooqCghIyMXImVUARbItgS6dupsrB16NChSsWYF1dlY9Dfvn3L69eviY0tgq3x44ug5s2bNzx69KiUNfDw4cOftQYeP36cvLy8bw5bXwKuLwVzlAdbe/fuFcFWBWDr49c/thzu2LGDo0ePcvny5SpbDs+dO0d2dna1w9aOHTtKdez69OnD9OnTf/RSIlIVJIKtGqSqwtbH9SNh61s/9MlLKiArUWRFk5ITIlRSRk6ogLamDlq1NNHSVMfOyhIrI32MtWqhXasW6kpKqAiFqAiFrF27jvfv35eyzOXn53M8fRfd67oQ4mHOpJ6BLIztwLoBnVkX3571/Tuwtl8Iq/sGsy6+HRsHdmLjgFDWx3dlU3xH1vcNYXXvtqyIDGBVZACLerRkVsfGTAioy3j/Ogxr6kKfujb0cjenu4spcX7OzAgL4PHvZe+T+lAV7W79+ewJY0Pq0cnBlBBHIzq56RPhbkmsty396tvR19eKES3dmBxUl3ndmrC4dyBLerfl98yDFOTnl+qoFeTns3fHBhp4mGNuoo+bsxUOdo5oaxlgaOqAh19r6gX1wdS1BboWnuiauGDu3ghL79a4B0ZTv2cS/gMX0GbIYoLHrMZ/7Crqx89CzbMtAtlayEiLoyAtjZSYOEpCeaQlZRBIC5CUl0QgJkBGWr4CD/ifD8coDumQl1dEXl4RWVlhGYEa5Q8h/hi2igH/PyVEVlquEpBVVOUFUnzps30tnH0tPH3t9UQBGT9ef//9d6Vgq7Jdmg9hrTLJfMWw1adPEWwNHvy0VGpgsTXwjz/+KPP8EydOcOvWrUrd++zZs+Tm5n7hZ/Mf4Bo16j/A9W+DrRMnTlQbbD1//pzt27d/8X1Pnz7l2rVrJSmHVbEcZmdnc+7cuWqHre3bt/P8+fOS46ioKFFaYA2XCLZqkESwVc5DnZQEsjJSCKWlkJOQQEFaGnkpKVQU5FFUEKKuromBnj72lpbYmhqhq66OpooKtRQUUBEKkZGWJLJ7V/KuXy35ef/1559cPX+W2SMG0aGOJePDAljcvwtrBnQqga118e1ZE9eOtf2CWd03mNWxHVjTtxNrYkNY2TuIpREBLO7VmnldmzIjpAET23gzvIkbA+rZEFPXsgS0erpbMLy1DwtjO/Hni6ff7HemsKCAp7euMT8mmN71HAm2N8DfSp1ujqb0cjcn0tOCSE8zBjZyYGQLN6aG+DK9S0N2z5tIQRnWyvz890ybOJb+8YNwcXbExckVfT0T9I3t0DCyw8a1Ea3aRWDr2RwNc0+ktayQ0bZGzdydWma10XDyw6pRR+p2HULIsMVEz9lH35/3EDlpHbXbRCOvZYZASgk5oRJCKXGkxARIi4shJyNESvJzEPN1sCUUKiAUKiArK/xsJ00EWyLY+l9SZWGrsuBQFVj7448/uGifPpkAACAASURBVHPnDmfOnCEyMhuBAPr2zeP69etfHChcnbD19u1bDh36FLj+jbB19erVaoOtHTt2fNU5VbUcnj17lvPnz1c7bG3bto0XL16UHPfq1Yv58+f/6KVEpCpIBFs1SCLYKvuhTkJagLSMeNHDtKw8cjJCFOWL7GlCeUUMDCywsrTHQM8YPS1t9DU10dPQQLtWLTSUldHX08HaUIPULetLdYwKCgrIz3/PwdTfGNGlOYv6d2HFPx2t9f07fABcQSyLDmBJRCBLI4OY38ufn8NaMad7C2aFNmNqUD3GtvJkeDMP+vu5EOdrT1Qda8LczAl1MaePryOTO7dkSb+uPLyRW6HOVkVUUFBAxuYVrBjYjaRgP3p629LeyZggSz1CbPTp6mJMT09zYn3tGNjIgfFB3kzt5MfdnHNlfoaCggKuXLnK9JmL6dSpC9qaOuhoG+Lo6ouNW30MjOwwsnDDtV4A9t6BONZtibqxM7V0rVDWMEFV3xhtC0e0bXyxrd+V2l1GEzBoGTHzjhA1/wQxs7bSIGwoAhkNBBLSKAtVkJNRQEpSDnFxySrDlpyc/D+R73KfDeQQwZYItv6XVFnYOnr0aKn49O8Ba8XWwMuXL3P48OESa+DFixeJijqPQACTJ399GuHJkye5efNmpT53dnY2OTk5FXrvx8D1ceS8CLa+XT179uyrYevj+lrLYVZWFhcuXKh22EpJSSkFgt26dWPx4sU/eikRqQoSwVYNkgi2yn6oU5CXQ1ooj5iSOpLaJiiY2aDvUBsDMyfcXOrj4OSNhYULtVR1UFPRopaCAhrKymipqqKhrIyKojp9I8PJzy9779bSKSOY1acdi/u1K4GtjQM7sWFAR9bEBbEiJpBFvQL4uVtLZnRpzvTOzZjasQlTOjRmXOs6DG3kQn8/F/p4OxBe24JQJ2M6OZnQycWCgU08mNUrmFWDenJ8w6Iq79kqLCyksKCA+7nn2PFTIlvGxDErKoA+TVzp6GxNRwdzgqz1CbEzoLOzMeEelsTVt2NMW2/mhDXn9ZOH5V7/xYsXjJ40k7FjR2NsaIKGui7a+lY4eDaifvNOGJi7o6Ruir6xPRY2tTGy9MCzYTvcG3VEVcMERTUTFLSt0bTyxMA7GMfAPviGT6D71K10mrOX6CWH6Lswlfphw1E1t0UgKYOMgjKS4lLfBLaKLYQi2BLB1v+6Kgtbx44dq3TIRHmw9vLly5LUwJ07d7J3795PrIF//vknkZFFsDVlytfDVkZGBr///vt3h61i4FJULAKu8PBb/yrYOn78eLXC1s6dO7/pNb9kOczKyuLixYvVClrF88Q+BL/OnTuzYsWKH72UiFQFiWCrBumLsCUtVqq+PiDj4yHFVRt6/DUPafIyRV8FAknEpRQQyAkRky7ag6UgLYuMtCTi4uIIxCQQl5ZDViBAQiBAIKGIuJYtQp9Q7DoOo1XcNAJ7T6Jj2ADc6rbGs64/vt6B6Onoo6Ojh6JSLeSV1BAKFZCXV0RRURkFBSV01LQ4fPAgBWV2c/K5mJXJpOhg5scEszqhM6sTOrMxIYSNCSGsi2/P6r7BLI5oxdxujZkY5MOMzo1JDqnPhLbeDG3iSpyvPX28HYisY0eoqyldXUwIdTUloq4tQwIbMK9PF35J6sOuyYO4c+E0BQX5JZ/n4zTCslT8vr/f/MXp1E3sXTSJQyums2fmMNYO7srEjn5E+jnQva417ZwMCLTToaWFGhGe1vSua8n4IG8Whjfh0fWL5Xa27ty5y5z5Cxg/OZnaHnUwNTDHSMcKA2MnHFv1xbdDHAbO9dG28MDExA51bXNsXBtRt1lnPJp1QVrTEqG2GYrahhhYNsHCPRg3/zh8uo0hYOBSOo7dRNyy48SsOE7v1eewbR2FQEwKoZwMYgJZJCWVEBcXIvdZACkftj4eOvylAI4vwVbxNT+s8oYaVzRU4nPwVBbMVLy+boB0RWHqS+eL9ONUWdiqSsjEh7BWbA08e/Ys6enp7Ny5k5MnT3L9+nVevHjx2XP/+usvwsOLYGvq1OqFrXPnznH58uWvOudD4Bo0qOJ2x/8F2Lp27Vq13Ovp06ffHLY+hpyPLYepqakcOnTom6ccllcvX74kJSWl1Gvt27dnzZo1P3opEakKEsFWDdL/MmxJiksVpQlKSSIlEKAsJ4e0uBjiYgKECnJISUkhJaeAmLw6WlbuWLftR4PYaXQYv5a2o1bTZeQKwsetoF3fcTQIDsOlQSDNQyJo33MAteu1wdrOGS1tA5SU1ZGWUUBGRg45OXnk5RWLwEtO6Yvzth7cvcOo8DbMjg5iRf8OrBzQkfUDgtkwsB3r+3dgdd9gFoW3ZE5oIyYF+zK5XT3G+Hsyorkrg5q40MfHlsg6NoS6mNPV1ZTOzsb08LAkrrE7E7q0YvWgCHZMGMi+6cPYM2MEWSlreHzrGv/37Alv/vzji5HvpaLhCwp4fj+P5/fy+Ov1S57dvsHx9fOYFd6ahABvwus70MndlLb2urQwr0UPVzNifW2Y3N6XTYPac3rj3DK7awUFBew7eJDlq9ewYMlSWrULxsjYAh09KzSN7bH27Uz/iQtp3jGC+s070bh1J7waBqNl6U3LboPpO+pnuvUbRy1TFyRVdVHQtUDXzhsjr0AsGvfCPjAB77CJBI5YSfTCQ4z85SyJv5yjScwkxISqKMvJISMmgaykFDJSwgoBhAi2RLD1b9W7d+8qBVuV3ff05s0bHj9+zN69e0sG0h4+fJhLly7x6NGjcgcKfw62pk37etjKzMzkxo0b1QZbxcAlFL6v1CDmZ8+ekZaWJoKtcurJkyekpqZWy72Koefo0aMcOnSI9PT0TyyH3+u+n0tdbNu2LRs3bvzRS4lIVZAItmqQ/pdhqzi+XSgthZKcNEoKyggkpBHIyCM0MMOxdThtE36i/ajltBm1lkYDfqJN4gI6j1xI95HzCeieiF+bSPxad6ZhqyBahfahXWQCE+avJSxhLP4hPdA2skFKVhlZOUWkpGRKgEtWVoiUtJDDhw+XOW8rPz+fzBPHiO/UgmlhASyPb8+K/h3YMLAdGxNCSpIJl0b5Mz+sGTO7NGFikA+JzVxI8LOlj481EXUs6OFhSQdnEzq6GNPZzZRwX3sGtvZmYsfmLI3ryqbh4WwfE8P2iQPZPnEgqcmDOblpaZlhFVB2p6tUN+yfIccXj6TRr4UH0Y1cCK1jSbCjPs3NVOnuakTf+lbMj2hJ6piepI7pxf0LJ0pdu7CggIKCAq7/fouVazaycs1GVqzeQGhUJIZmVqhrm2Hn2YiEETNxrtsYpzr1ca/bFKc6LWjZIRqvVmF4BfTGs1UkXq160bJLX+T1bFE2MUPH3g1dlwboe/hjXL8LzsH98Ow+lhaDlhA9fRN91pxj1J4HBPebgEBaDglxASqy0oiLyYhgSwRbIpWjysJWRkZGhfc9FVsDMzIySE1NZe/evezZs4dz586VmxpYHrD17FkEWzNmvPvq80+dOsX169crBS/nz5/n0qVLlTp34cJzKCgUfDVwiWDrvw+2Xr9+zalTp7h8+TKvXxd11q5evcrJkydJTU1l9+7dnDp1ihs3bnzTwcqfS1309/dny5YtP3opEakKEsFWDdL/MmzJiQlQEMojkFJEXMUAgaY5TgE9CJuwmLDk1fQYvZC2/SbRvNdQokbPJXzYFGau2k6z4N40D4ikcWA3OoYNIDR8MGHRwwnoEI27XyAN2vZgxIwlxCVNp2lQN8xtnBAXk0ZGRg5ZWSFCoQJycvKIyckT3SeuTNh6//49sdGRhAX4Ma5zUxbGBLI4Nog1/QJZ1z+I9f07/LN3qx3Le7dhWUw7pnVsyMgWbgxqYEe0tyVhHmZ0cDailaUm7ZwMCK1jSYSfI3EtPJnQviGzwlqxPLY9J9fM5cnNq/z54hlPbl7j9eMHFBZ+m8CMwsJC3r97x93frzEnsR8hzoY0N1Mlqq4FQ1o4sah3C7YmdmXToPakjunFqwd5AOS/f8eT2zfY/ttvbPp1B+s3pbBu41ZWr/uVoSNGYmhghr6uFRZ2Xri6+mBkbIGBiTk29rVp0CQQn4aBeDVuT7MOcQRETCBm1BI6x46nbc8EzGs3Q9XUHRUzV7QdfdCt3RyLRl1wDh6IX9QMWiWuJHbRfgasOMrE1Os0jR2FQFEdOSlJpCXlRLAlgi2RylFlYSszM7NMK96ff/75RWvgyZMnK50I+PbtW8LCiqLfZ86sObB17NgxfvvtYYmlsKLAVRnYevPmDU+ePOHixYscO3aMy5cv8+jRo2qFrWPHjnH9+vVqudfjx4/ZtWtXtcJWZmYmOTk5n7z+6tUr7t+/z8WLF0uCXQ4cOMC5c+e4c+dOlSyHnwsCadGiBdu2bfvRS4lIVZAItmqQvgRbSjJipavaYesL50spICMmhZK0BNLS0oiLi6OsIo+0jBgCTS1kzBzx6TGc6Nlp9J+dQs/kTQQMmkf90CF0jx1JWNwobD2b49+5Dx3CB9Erfgzd+owgdtgUhibNo22HvkTEJtGybRh27o2wcPTFzr0RHvUD8GkYSEC7HtSp2xRtbVOkpeSREJellqoWAoEU0kqq1Pb1Y9/+g7x/n19q71ZhYSEpKduwsrKiVUNv4js0YmZEG36OCGBZX3+WDGjNmv7t2Ti4C2sHdGB5bFtW9A1iXs+WjA2ow5BGjkT72tLVzYQAK01amKsT4mxIV08LwnxsWTA6gfu/3+Dd328pKCiaa/W5vVrfUsX3OJSymdbGavTxtWBcuzosiGrBun5tWRMXyOn1c3j/91sA3v7xmrNpv5KYOIxfd6SxefseVqz/lWVrf2Hw4CQ0NAzQ0zNDT88MAwMLdHVNMTe3x87ODVv32vh4NSagdU/cWvdk6pKtjJixhuCoUQRGjyV+8gqGz96EpK4L0nrO6Lq3wqJRdxxDBlM/dg4th6+iw6TfiJp/gGEbzzEy9SJtosagIKuFQEIcSYE4chIyyErIICcj/CwMycnJlUDQx0OMJSWlS9WXAOXj6394Dzm5bzHUuPL1ZfipWoDGl2Hs84EdIv04vX//vlKw9SGwFFsDL1++XLKf5dChQ+VaA6uyb6oIti4iEMCsWV8PW6dPn+batWuVuu+FCxeqBFu3b9/m4MH/7OEaM+bLwFVR2Prjjz/Iy8vj9OnT7Nq1i7S0NM6cOcOlS5dKAkd27drFnj17uHXr1nffZ1SdsPXo0aNqh62MjAxyc3O/+L4XL15w69YtsrKySiyHx44dIycnh0ePHn3VPT+3N61x48bs2rXrRy8lIlVBItiqQarpsCUtJoO0uASykmIoKskhkJBGXN0Yt4Awuo76mdFr9jNkxX6CR6+kfp/Z1I2cTsiwxYQOnEJw936EhPUnsGssXaKGENp7GB3DEwgJ609o72F0j0ikQ7f+dOzeDzs3P4ysPTGx9cLGtQE2rg2wsPPC1NodJxdfXF19kJIUIi9UQVJCDkWFWsiraeLXvBXtO3VjZNIYLly8xIuXL0t+9gsXLqRu3bq0alyPqKAGjAttzvTuzVkc05ol8f6s6d+e9QmdWDugAyv6BrE6PpiFka0YH1iXxGauJDRzJaKuFSF2erQ0Uy/pbB1J/Y2CgoLvAlQVUX5+PlP69mRAY3smhdRlQURz1sQFcv3kvk8HGhcUcPHSJVZv2srm7XvYlLKLlRu2MHhwErq6pqioaKOpaYi2tjG6uqZYWDhgb++OpaMLDnYe+Pi2pUmHPoyduYL6rbvTolM8P61Ko9+4xUSPmEvYoOmYebZB06kJ5g274hIyCN/eM2iVuJoOk34jfG46A1ZlMm7rVWalX8fcLwBlFXXkZIQIZeWREJNEVlpOBFsi2BLpA1UWtjIyMjh16lQpa2BWVlZJ6MWXzi+vM1aR6tHjEgIBzJ5dOdi6evVqpWHr4sWLlTr3w1CRD4GrjlcByhqFCJUK6dgln1u3KgZbb9684enTp+Tk5JR0UI4cOUJubi7Pnj3j7dvSNsJXr15x4cIF0tLS2L9/f8lDf25uLk+ePKnxsLV79+5qha2TJ09Wamjzx5bDPXv2lFgOPxxW/Ln6nF3Sz8+P9PT0H72UiFQFiWCrBqmmw5aUQICcjCziElIIJGWwqd+auFm/ErvkKA3jfsYnchq+kRMJHj6fiJk76TUjhbbx0/BoGkLdxoHUbxFC/RYh1Gvejtbte+LbLBjfZsH4NA2iqX93fBu3KwItK1dMbL0wtPLAzN4bK+f6WNrXRUPPCgcnbxwd6+Dq4omYQBoZaQWUldTRMTGnXdfudOnWi2bN/WnXoSvRfeJ59PgxAA8fPqBbt260bt6ELq3qMaRjI8Z3acaiaH+W9WvLqn7tWDugA2v6t2dVv3Ysj/VncXQrfgptyIzODRkdWJf4Bg6EuhrRylSFYEd9fhoaW6ZtsbpUWFjIxYyjJLWuzbRO9VgU3pyjy6eWuUesoKCAtANHWLpmE8vXbWb+sjUkJIzAxsYFOTlVNDQMUFXVQU/PDEtLR+zs3LC0ccbOrjYNGgXROLAHTVt0xrtBW0ZPXkzPvmNo07UfvQYk0ythBgMnr0bXuQnqjk2wC4jFL3oq/iPX0nnKNiLn7af/ygwSlmaQsPUiUw5fwcihLgJpaSRk/nm4F5cWwZYItkT6QO/fv+fPP//8IigUWwOzs7NJT09n27Zt7N+/n2vXrpWZGlheVcXKVwRblxEIYM6cr4etM2fOVBq2Ll68yIULF6oMW2/fvuXAgb+RkC1EoAOCxSBYB1KuhZhaF/L69X/Oe/78eQls/fnnn9y+fZusrCz27NnD7t27OXPmTJmQW96ereKH/hMnTrBz507S09M5e/bsN0vXO3r0KDdu3KgW8Hn48CF79uypEbD1YX2t5fDx48efQKWPjw8HDx780UuJSFWQCLZqkGo6bMlKCJCVkUJGWRWnrgNJXH+QnskbaBw9jU6TNtAjeSNhY1cT0HsSPm0jsW7QAS37+hjZuGFi446Niw/Wzt44ejTA1tUXK6e6WDnVxcjKFUOL2hhZuWNs7YahlTOGVh4YWXti5VwfW7eGmNl4omNkh7GpIyYmdtR2r4uFuS0S4rIoyKtiautA96gYQntE0L5DV7p060Vi0jh27fnP/ya9ev2a3NxcZkwaQ1zHBozo1IR54a1YGBPAyrhgVvVrx+r4EFbHh7AirhVL+7RkfngzFka2YnqXhoz09yC2vi3tbDQJctDj4qkTP6yj9aGe3LvNhLbezOnSkOWRrXh47UI5EfgF3L3/gMWrNrBs7S9Mm7OQ6Oh43N19kJJSRE1ND2VlLYyMrLC0dMTS0hEbK1csbVxp1aYz7nUaU9ulPo0atKF1QChePm0I7NCbkB4J9Bu9iLkbTxI1bDpGdQIwbdANp/ZDaDJoKe0nbiFq/gEGrj7FsM0ZjNxxjWFbcknceAQ1IwMEUpLIyAqRlZARwZYItkT6QGXBVrE1MCcn5xNr4MOHDzlz5gxXrlypNCydPn26SrDVqVNOpfdsZWVlVfqzVwW2Pk5wzMr6G4EABNlFD1sCQPAcJOQLWbfuP3+ve/fusXPnTo4ePVqS3piTk8PTp0+/mN5Y0YCMV69elcB08UDf48ePc+XKFZ4+fSqCrc/U9xja/CXL4ef+np6enhw7duxHLyUiVUEi2KpBquoQ46+Hra8dbPwFWJOWQigQ4tqlH1NXHqfXpPX49Z9Jj6m/EBA5Gpdm3THxaIWhc2O0zZ2pZWiLoo4FSrqWGFi4omfmjK6pE3pmzp+UtrED2sYO6Jg4omPiiJ65GxaOvti4NsDYpg5mps7Y2nuhb2yPjok91k4NmJA8GTFxAfomFvg2bknswGFE9xtEnwFDad8tjKQJk7l85WopICooKCA/P5+j6XsY2jWQad2bszC6JUtiglkZF8zqvm1Z1cef5X2CWRQZwMIIf1b2DWF+eDOS23uT1NKdcGc9gm30eHTvznf/nfkSzBUWFnI16yRTQ7yZE9qIFTGBvH76qNxz/u+PP5k2ZzE/L1nDT/OX06FDGK5unsjJC1FQrIWmpiEGBhaYm9tjbm6PhakD9ra1aenfHlNLJxzdG+LTMAAHZy8cHGrj4dEQ/6BIJs3fypzNBxk8bi5ercKwaRqOW6ckPHpNo/WwVfScs5eB67MY8ssFEn/LYcTWXMbsvEHfn9YhqaSFtECAQPLTwIqPQUtGpihUQ0pK5hPQKoKt8gMypCSkkZaUQUZKtmh48cewJVf0WjHMVQWYvgQ/VQ2w+N4lgq0frw9thC9fvuTGjRtkZmaSmppKWlpamdbAs2fPkpubWyXYqkx36a+/3jJ4yHvEpYtS/WQUCr96sHFVYOvSpUvfDLZ++eUdEgqFCAo/gC1ApnYhQ4e+5OzZs6SlpZGamsr27du5devWV6c3VjaN8MmTJ+Tm5nLs2DF27NjBvn37yM7O5s6dO6UG6v63wNaDBw9IS0urVtiqjrTFJ0+elLIc7tq1ix07dpSyHLq5uZGRkfGDVxKRqiIRbNUg1XTYUpWTQaCiw4QtWfScuYUWQ+cSOfsX6vVIxNytKWpmbqgaOKCqZ4WilglCdUNkVPWQUzOglq4V6vo2aBraoa5vg5qedanSNLRDy8i+BLgMrTzQMHTAzN6bqPhReNRphoqaKdqG9ng1akP8kEnYOroU7R2TlKVtx27EDxnJgGGjSEgcQ/eoGDZs2Vpmhyc/P58l0yYytmsTpndvwpxe/iyKbsOS3gEsiWzJkuhA5vVsyZzuzVgY4c+8Xk2Z0cWPKe39SPCzI8RW97+is5Wfn8+acQnM6tKAReEtWRETyL3cC+UONH705BlrN+9g0cqNDB+TTFBQVxwcXUvBlr6+Oaamtpia2mJuYo+BniWWNq5MnbkAIwsX6jVpg5auCUbGFhiZ2lHHN5BhE5Yy75f9dOmTiEPDDjgF9MGj21i8o2fRZMBigsb9QuSiQyRsyCbxtxyStl1l/O5bTNt9A4t6QSgqqSArI/XZdMAPEwJFsCWCrX+T3r17V2IN3LlzJydOnODatWs8f/683If4c+fOkZOTU2nYysrKqhRsJSe/R1KxEMFqEOSBYC6ISxWyZk3FO1xVAcVLly5x/vz5bwJbublvERMrRLDvA9i6BWJShSQnn+PSpUs8fvyYZ8+esWfPnkrd81tEv798+ZK8vDyysrLYu3dvye/J1atXy401r27Y2rt3b7XCVnXuSXv9uqj7eP36dVJTU0ssh/7+/ri4uLBy5cofvu1ApMpLBFs1SDUNtj6+vqSMAkHj5tJt6g5aT1hN9Pzt+HUbjJFrI9T1bVDRNEVVwxDlWjpIK2uXlKyqLvJqxqhoW6Cub0MtXStUdSxLlZqedQmMaRs7YGBZG00jR0xsvTCx9cK1dlOcajfBxrUBXaIGEdQ5CidXbwwNTLF1cqNTj0j6Jgyn/9AkwqLjiB+ayLUbv5drp8u5cI7Ers0Z260p03u0Yk5EAAsi/VkQ0ZJFkQH8HNaCn7o2Zm6P5qVga1ADezo76PLT0JgftngWB14c276ZpGau/NTZjyWRrVkU3pLd8yaWCYEFBQXsO3yC9VtSWbhiAwOGjaF58yDMLWwQKsgjr6CKuro+urqmGBlZYWhoiaWZI1YWzhia2NK1R288fJugbWSBsZk1+gYm6BpZYOdSn+bBvWnWvjehcUnYNuqAY2AsdSMm03zQMvyHr6bt2E30mLuXQRvPMWJrLqO2X2Ns6u9MTn/KjL1XkdS1QFry87D1oXVQBFsi2Po36f3791y9epWHDx9WaKBwcVUlAr0YtioDPPpmhQgmle4EifUppE69ggpfIzs7u9KgePnyZc6dO1dl2Prrr7+4d+8eQSFPkVAsQDAYBGNAoAEKtT7ds/UjYevjKraXFtsaDxw4wPnz57l3716prteRI0f4/fffqwVE7t+/X+2wVZ0wWVz37t0jPT2d16+LLIdr167F0tISS0tLVFVVOXXq1A9eUUSqjESwVYNU02BLQVq6VPn0iGNcygXCZm8nZv5+fDuPwKZ2K9QMLBGqGyOsZYSssg7ySlrIKWoi/OerrIIGcqqGyKsZo6xljpqeNbV0rUqVirYFtXSt0DCwRcvIHmllQ6yc62Nk7YmRtSdahs64+fhj7uyHe4O2uHk3xcTMmaaN21K/cXM6do+gd/xgho6aQOLYySTPmsuz58/L/fd49vQJ/Tu3ZHCHhkzo3IzpPVoxu2dr5oQVdbRmd2vKjM4NmRXahNndGzK1oy/JIfUZ1MCebk56dKltyKl9Oyj8KI3we3e7CgsLefngNitGJxDrZcmopq5MauvJ7K4N+amzH5smDPjksxT8M9D45q27LF2zmdkLVzJ55nzih4zCz68l+gYmyCsqIJRXQU1ND21tYwwMLNDTM8NQzxJDfSvUtYzR1regQ7dwGrdug6qGNoZGJpha2WLr7IOrV2usnRtR178r1o3aU69XEn5xP9FmxFq6Jm8jbHYaPefto8/yEwz55QKjtl9j3K6bTNr5gBHbcum3YDMa+pblgpYItkSw9W9TZdMIq5LK9/Zt5btLQuVCBJtKw5ZgBpjY/vfD1rFjxzh9+jQnTpxgx44d/wQhXCQ5+TUudQqwcSlAV7fIHjl8+H+skf9tsPVhvXz5klu3bnHmzJkSy2NGRgbXr1/n0KFD1QpbxRBSXVWdMFlcd+/eZd++faVes7S0JCcnh/v37/PmzZsqrQcrVqygdu3aKCkpoa2tTXh4OC8/SF4GmDdvHnp6esjLy9OmTRuePn1apXuKJIKtGqWPhxZXFbaqDlflw5ZATICWrBjKSgoomtsyZO1xYhYdZvDCQ/jHTMa+Xjv0TBxQUTdCTkUXORVdZJV1kFHSRkZJE2lFDaQU1JFSUEdGSRM5FW3ka+mipGFQqqtVS9cKFR1rVHVtqKVni5q+HZpGzmibuKJt4oqhVR2MrHzQM62NX5OO2Nh7Y2DmsDU0wwAAIABJREFUgqm1O5YOnnTqEU1kXH8GjRxN/NBEps2dT9KYidzKu11mZ6uwsJC8vDzaNqpDRFAjhgQ2YHynpkzs6EdyZz+mdGnAlC4NSO5cdDy5vS/j2tZhlL87gxvb0dVVl+51jRkZ6MWOWeN4di+P9+/+/v6gVVDA05u5/JbYi8RmTgxr4sCI5s5MDPblt+mjuXnhLO///huA9+/ecef3Gzx7/pyHj5+QdugwaUePs2j1JqbPW8rYqbPpGhFL42YBaGtqoaGqgryCCoqq6mjrGaNrYIm2riU6elboGdigb2iLjp4VlrY22LnUx9zCiEBfDzw8vfDwqoejaz20jVxwrtcK20ad8Og8Ar/oqbQZ9wtdZu6i1/wDxCw7Tsyy48StymT4lsuM2XmDn/bfZvzeuyTvvU6bmEEoysigKCOPUFYeaVmpD/ZqfZs9W5+GQEgjKy2DrLQMcjKylQjIKD+k4utgqnqHFle0RPpxqixsVSUooirA0yIgH4kmhQje/wNaf4GUUyFR0fkVvsa5c+e4fPlypT53Tk5OhWHrr7/+4sGDB5w/f559+/aRkpLCwYMHuXHjBq9evfrsOZcuvUVRsRAxsUJ27/77u8DWsWPHvhsMPHz4sGTeWkpKCnv37uXChQvcv3+/wnu9KlMfdnyqE7Zu3rxZrfe8c+cO+/fvL/WaiYkJ169f/ybrwbx58zhw4ABv3rzh2bNntGjRgtDQ0JLv79u3j1q1anHmzBlev35NSEgIQUFB3+Te/2aJYKsGqabBloaCIgpiAgRCeQYtXc+QtccZsOokXRJX4to6Ci3ruqhomSBU1fsItLSRVtQogS1JeTWkFTWQVdZCqKqDoro+ihqmKGmalVgIP4YtNX0HdM3c0TZxRd3AEYHQkOAucbRpH42JVW08fVuhZWCDs2cD2odGEJswhAHDR9Izpi/T5s5n+k8/8+tv28jP/zxsAZw+fZr6rjb07tSavv71SGjjy5gODZjY0Y9JnRowoUN9xrbzYUywN0kBngxv6cagJo709bWkh4chveqZkxjgyYzOTVgQ3ZbVA0N5eD2nTMD7FiooyOf0pgWsH9iFsQEeTAr2Zmhje84dSKUg/6NhzgUFZJ3OJGniVBasXMfiNRvZkJLKwlUbmTDjZ4aPm0Krdl1o0rwNOlraqKsoI6+ggpq2PmrahqhpmWJg4oCdU12c3etjbe+JubUbjo4euLk2pE0Lb2JC/LC2c8bFwwcXz0bU0rOnXutOWNRrh3O7wTToPY1Wo9bTafpOwhccpO/KDAasyyJhQzbDt1xm3K6bzNx7i0np9xm/9y4jNhxBXEYRVYVaCKVlEJeUEMGWCLb+1crPz68UbFVl71JVgCc7+2+U1AqRtChA0APEtAvRMSrk998rfo2qWCBzcnLIzs4u8/vFQFM8RHj//v2cP3+eBw8ecOLEiQrNFlu16h0CAejoFHL79ltevHjB7t27awRsfViHDh3i3LlznDp1it27d7Nr1y4yMzMrNE/qa+tzHZ/q+PtVN2zl5eVx8ODBUq8ZGBiQl5f3XdaHlJQUTExMSo67du1K//79S46vXr2KhIQEz549+y73/7dIBFs1SDUNtpQlpFBWVsSqSRsSNh1m0LoTDFp9goahiVh5tUHVwA4VdQNklT4GLa2SjpakvBoSwlolwFXc3RLWMkJB3QRlLfPPdrY0TF3RtqiNvo0X1rWb4N0yFLs6LXDwaIalozcunk2o7d0MSwdPukfG0W/IcIaMGktUv/9n7zyjqrq2NkyUIr0pIk1AkF4UUECU3kGUKmABpFgQAbEC0uy9azR2Y++AgILYu2IF7CD2qNHERO4X4Pl+cOXGaCyQ6PWGd4w5YO2z917sc85Yw8e55jsTmTRrLgsWf8fEKTO5dKWUmt9ByO8bENfU1LD820WcPnmcxw/vU37hHGumjSeldw9S/bqT3Lsbo727MsqrC2PcLUhy7kSCgzGDrTsy0EqDQY56pPhYMqevKwsivVkVH8LhtYv+tMdVY9TQlLi2ltraGu5ePMmutEi2jevH4khXJvpasHHSCGprfnvn9TU1NWzPyWfOt6tYtWlnQ6RPnUPsyBQcvfywc/RAuZ0SbWRlkJKWR1pBDVUtYww798Darie2zn44ewbjFxyDrbMf1na9sOvek2ERPVmYNQxDUxuMze3QMramU3dPPPpE0dE2ABO/kTgMmYlbyjqCpmcT9e1B4tedYeSmC4zddoUxWy8zfvc1pu6pYPr+H0gvuM/MI09RsXRBUEgM0ZYtEWkl1gxbzbD1j1ZjYetTMjx/NfDcvl1N377XadGyDlHROu7f/3xz/xG2Xr16xaNHj7h8+TLFxcXk5ORw/Phxbty4wfPnz9+49uTJkx/dyDk8vAYBAXBxqeXp068Ttg4dOtQAIy9evODBgwdcvnyZgwcPvtVKoKlZry8FWxUVFZ91zoqKCg4ePPjGMUVFRe7du/e3rA+JiYl4eXk1jI2NjVm1atUb54iJiXHkyJG/Zf5/ipph6yvS1wZbUq1a8Y2kJKlrchm15RKp20sIm7EDS+9BKOlYIiajgoS0IoISbf8AWgpvgFYLUdkG4GrYTiivjkRrjYYM1x9hS7q9MW20zVE1ssGouxcGNj3RMneitbopGgZd0TW2Qc+kG1oGFgyOH0PC2BRGJI8nNmk0Y9KzmDxtNstXfc+8hUtZvnINpWXlPH36lJu3blNUfIDffquHk9dGE/AfW/hThXmM9LJkhEcXEt0tSHAzJ8HFjDhHU4baGRFpVQ9bw9yMSfPtxqIIb+aGe7A4pjcrhody4/SRN7JMTdlaWFdXx68/PefRrauc2ryUXekx7EyNYHdaGCuGejG9jxWVl8+81wjk3oPHrN2yh9Wbcli1MZt123JInTSTgP5RePqHYt61BypKyqgotkVWTgFlLSP0OtlgbuOOpa1PQ1jYeGHezZPOzv74+IZjb2WIt5Mt2oY9CBwQj4W9D85+YZg7+KBh3QsDnwRsIie/BVujNl8kI/cmKTvLGbe9lAn5D5mcd49pe+8wc/99ktYUICQhh7SoKGLiks2w1Qxb/2g1FrbKy8vfm+H5UDS15mvv3r2YmPyGgABUVn6+ucvLyzlz5gy3b99usMgvLCzkwoUL3Lt3773v5afA1rNn1ejr19dvZWb++tXD1h/j2bNnDW0G8vLyKCgoaHhff/zxx0+e613b6/7uOHDgAJWVlZ91ztu3b3Po0KE3jrVu3ZrHjx//5WvDnj17kJKS4uLFiw3HNDU12bFjxxvnKSkpkZeX95fP/09SM2x9RWqqQcbnsHp/fW8JYWFEWrZAw8WH+NXFTNhxjVHrz9B38maM7QKRaauBuJwKwpJt36jRer11UFhU5o0QlJBGQFgCIYnW9ZDWWgOJ1hpIKXRAuq0WUkr6SCsbIKtqhHx7E6TbmyCn2Zm2Ol1RNuiGXlcnOvfwoF/0cDx9Q/APi2VU+jS0jMyJiU1keOJoksdnMTYlg4SksYwck0rGhKlMnTGX0ePS6Nk7kAERMYQNHETs8CTOnCn5UwiqqalhReZo4tzMGOpqQoyzPkPtTBhqZ8Kg7oZEWukSbqnJCFdjpgR2Z3awLd9GebMw3J1vo7xZNSyAAytmcP/aZV788JCXPz57A75q/2Co8Xu9YWhRU8P1U4fZPH4om9Nj2JYWw6axEeybmkjO+Gg2xXqzdEB3Xvzw4L3fu+cvfmLVpp1szt7Lmi27mfPtCkamTMIvKAI7J1e0zbpgpCaKlpocreXbodBeF00Dc4y7OGLezRMP/zC8A6MIiRlNv9g0HD3DCB0YT2cre4w796CjWTesXXsh396ITjY9MezWE0OHYHQ8BtE1aioeY9fSd3ougxYfZOS6c4zZUkra7ptMyLtDRs5t0nJukZlXyaR995hceJ/U7SVYDBiGgJgUCi1FERISQUhI5D9w9Iemxp8KV+8CmjeaG/+FsPV3wU8zbP1z1FjYunr1KufOnWs0LDW15mvv3r0EBFQjIEBDbdPfNffrBs9XrlyhoKCAXbt2cfToUa5du8aPP/740ff5FNiqrq5veiwqWoegYB1z5hz/6mDrYzM/L1684P79+1y6dIkDBw6QnZ3N4cOHKS0t5dGjR/+1sFVcXMydO3c+65y3bt3i8OHDbxyTkZHh2QcMuwBsbW0REBD40/i9XtdmFRYWvnHc2NiY1atXv3FMXFy8ObPVRDXD1lekrw22pGXkGLN8B7MOVDI15xbDVx7FP20NHS17ItWmPWKyyh8NW0KSMghLyiMk0ZpWUkoNmS0phQ7IKGr/KWwpdOyCkr41hlbutNM2Q8vYEoserqjqWRAROwotoy7Exo8lfsQYRoxKZsSoZEaOSWVg9FBGj0tjybJVzJq7iElTZ9HLrw/BfcOJjInldkXle+3Ry8+dYrBTJwY7mxDtoM8QW2OG2BozqLshUdZ6hFtqMsbLjIUDPVgc7srKoX4sH9ybZTE+LI3uyZIoDxZFejMrzJ3JoS5snJbC9fOn+eH+XcrOnqT83Glqan57A8Bqa2t48eQHnj64x+1LJeR9O4PlCf3ZnDqEzekxbB0fTe7EOA7MGk3x1ESOrZjK/fLz/Pav6vc8Sx2Pnzxjc/Ze1m7NZuGK70mZMJmwyOH07NUXewcnDEyMse4oia66PO3aaTTAlqG5PaZdXbFx8cXBMwT7nv1x9I3Cu08cfcLj8fTvh66xDZ16uKLfxQE9C0e6OPji2WcwKp1c0HKJoFO/dNxGryZ0Wk4DbI3dWkba7ptk7akkI+c2Wfl3yMyrJCv/DlOKHjD/yI/M2ncRwbaqiAkKIiIi2pDNaoatZtj6p6mxsHXt2jXOnj3baFhqas3Xvn37SEl5iYAAzJnz8T22Pha2Xr58SUVFBWfOnCEvL4+9e/dSUlLC2bNnG/3cr+uVPuWaRYvq67fatv2Fhw//N2Hrj/H06VNu3LjR0Mh37969nD17loqKCp4/f/7Oa+7cuUNxcfFnBZ/9+/dTVVX1Wed8l5ukuLg4P//881+2JhQVFSErK0t+fv5br/Xt25fExP84El+/fr25ZusvUDNsfUX62mCrlXw7ZuRfIjX7Klk7LjNq/RlCJ21C1cQZcTkVRGWUGrYOfkxm6zVsCUsoIibXHnF59QaTjD/ClqxGJ+Q7mKHQsQvt9KyQ1zLHZ0Ac0xatI3ZUJmr61gxOzEBeuSP2zr0YNDSeYfEjSUgay5BhiQyMHkr8iDGMz5jE3AXfMnXGXFLSJmDn6EZv/2CePn3//zI9fnCPKCczlmYkUV5ykif371J+9iTfpiTUA5dNR1J6deW7Ib1ZE+vLhhGhbEzqy5q4wHroGuTNwoFezInwZHKIM8k9rYh37kxkd0PCrPQJtzZg/tjhlJ45weN7VZSeOcmSlETiHTozxtOSCUFOLIjxZ9WIMDYmD2Lj+Ch2ZQ3l2KI0zizN4kn5ubcMMd6l2tpaTp2/zKbdBazYsJ30qXOIHzmGgD4D8Pbyx97WDgsjdXqbyaKvJoWishaKGvpo6Juh39kW826e9OwTiaV9L1z8BuIVGodXSBKDR03Gt+8g+kWOwtGnH1bOfmiZ9sDczgt333DadLTGwCMa4+BkXEauJGRqNjGLDjBy3TmSt19tgK2sPZVM3HuXzLxKMvMq640y8h8w48A9oqd+h4CkHGJiEoiKitOqldi/wasZtpph65+jxsLW9evXOXPmTKNhqSkW6tXV1RQWFrJmzQsEBCAm5uOdCP8M9F69esWTJ08oKytraBh75MgRrl69ytOnTxvOa0pGrzGw9epVNb6+/0JAAHx9a3j16n8ftn4fL1684O7du1y4cIH9+/eTk5PDkSNHKCsr4/Hjxw3nvcs44u+OoqIi7t69+1nnvHHjxlufn4iICNXV1X/JelBcXIyMjAw5OTnvfL2oqAh5eXnOnTvHzz//TFBQULMb4V+gZtj6ivS1wZZWFzsm511nwr67TNh9idEbzhI1JxtVE2daSbdriI+BLVHZ1rQUk0GqjSoScmq0klFt6Lslp6TzFmzJaXZugC1FXUvkO3ZFvZM9+tbudHHqjb6FK7qdHDDv5omVjScDImKIiBpC7PAkhgxLbIgxyemkZ01h9rzFzF3wLRFRQ/Dy8efChUvvBZX/+79/cbPs8lvmGjU1v3E8bxdxziYk+3RhXpgrm0YEs21sONvHRbB9XATbxoazNj6AJdE+zIv0ZmIfR1J7dSPR1ZxoW2MG2hgR2f0/P6N6mBBja0ackzmj3a3I8LdnZpg3i4cEsTopnLWjBrJ7ynAOzBvHiSUZXCvYTF3tu004GrYh1tVRW1tH5f0H7Cw40JDVGjl+IsH9+uLp1Rv7Hs5YWXTGs2t74tzb00lTmrbKHVHtaEJ73U4YmNnh6BGCb99B2Ln3wS8sHo/gWGJTFuEXMRJbz2BsnIIYNGIi81Zsx9rFl25uvdExsUFJz4b23QMwCkzCacRy+kze1QBbqTuvk7b7Jpm5FUzIu0NW/h0mFFQxoaCKiXvvkp5/k8ziJyw8/ABlax8kJKQQF5dEVFS8GbaaYesfp8bC1o0bNzh9+nSjYelDrn4fiqKiIk6ceIqAAPT4hIbGr2HrwoULvHz5kjt37nD27Fny8/PJz8/n3Llz3Llzh19++eWd1zYlo3fq1Clu3LjxydfdufOcdu1+QUAA5s//tCzeH2HrXf9Y/7viwIEDf7mBxJMnT7h27RrHjx8nNzeXwsJCSkpKuHLlymfPbBUVFXHv3r3POuf169c5duzYG8datGhBzV9knGVnZ0eLFi0QFxd/I36vRYsWoaSkhJiYWHOfrb9IzbD1FUm6VYs34oNwJdzyzfhE2PpQsf67YOs1cEmKiGDq6c+EgkomZl8hq+AmozZfIHblOaxcI5BS1ERASB4xeU2ExRQa3Adfh7CoDCJisrQSl0NUQp5vhEURkWqNvHJHOna2Q1RCGek2HRCRVkFOTR85NWPk25vUZ7VUjZBRN0FOsxNttM1pq9MFhY5d6GDmiJK+Nd08Q+nuEIiBqSM9/SPo6R+Gl18wMcMTCY+KJmFEIpGDBhMRHUP0kKGMTk5h6oy5jE3JYHjiaAZGD2XU6HGNXvxqan7ju/REknt2ZWqoI0sG+7BrbAS7UqPYNj6SnRMGs31cBJtG9mNVrD9Lo3syu783E/0dSfG0ZqxbV9J62zO+lx1pve3J9HdiSpAL00PcmdnXkyUxgaxMCGHD2Ah2Zg4ld3I8++eN5dTSLE4vzuBF1S3q3tM/rKamlvuPHnPq/GW25BSwOaeIhSu+Z9LM+cTExuPj7YuDiw+29na4W3YkykmZlN4qmOvKId9OGyV1Q3RNu2Nq44GL30CGj52IX9+huPpH4ho4mJChk/EZMIbe/Yahqm2KhY0XDu7BePiH4dy7H1Jy8si210XF0htT/zgchi8iZPJOBi4oYsT6C6Tsukp67k0m7r1TH/lVb8TUontMLbrHxIJKMnJvIiDZFhkRAQQFBBAQbfeWQcbHwNQHoeU9sPU24HwItj6lCfLfDUvvfy/e15C5Gbb+O9RY2HptbtBYWCovL6ekpKTR1+/fv5979x4hIlKHgkLdR1/39OlTjh49SkFBAdnZ2Rw6dIiysjKePHnCq1evPnj9l4Ct58+fM3fuUYSE6hARqeP06Y+vUfvSsPV3Gki8ePGCqqoqzp8/31BLd+zYMa5evcoPP/zwtz9fYWEh9+/f/6ywdfXqVU6cONEwfv78Od98882XXkaa1UQ1w9ZXpK8NtkLGTSZ111Wm511jQmEl6TnXSfz+In6DJtNSqDXybTRpISyNqMzbsCUiJtsAW63E5WglKYOIVGvaqOpi7eKPuJQqkvL11u8SiloNGa3W6qbIqRkjoWKApKohshqmtNE2R1HXkrY6XdHs7IC+tQe6Jg6o61jROzgabSNLDDpbE9A3gsHD4omOGUz0kKFEDR5CYEgoA2MGMTxxNOMzJjFxykzSMifj69eH3D1578hc1XD+/AV+efnyTz/H2toays+eYIS7GRODbFkQ5cmmEaHsSo1ie1p95KQPYmdKJJtH9ef7hGCWDwtmcYwfc8O9mdXfg5n9ezI3wpd5A/2YN9CP+RG9WRjpx5KYQFYN78/mlCh2ZcVSMD2JotljOLo4jRNLMji+cDyvXrx/C+TLX35h2bpNLFu3iTVbdvLd+h1Mm7+UseMzCQjui6e7Fw7OHnS36YqPtSrxvdozyrM1BmritFHWQUXTGAMzO2zcAvEPTyB2VCae/gOxcQ/GIziW6KRZBESNJ3BQOmZu/dAydcHMzo8OpnZ4hw6ilYQ0wtKKKHVyxMhnCF0jp+OfsZnIhfsZs6WU8dnXycy7zYSCSjLzbr8FW5P23mHyvvqfEwsqCRo9AwlJaRRkJRETl2mGrWbY+keptra2UbB169YtTp482WhYaqrBRnFxMY8ePcLIqN6x7+7dP4eNqqoqSkpK2Lt3L3l5eRQXF3P06FFevnz5yfM2Zfvk6dOnGw1beXl5TJtW776oo1PL06fNsPX7qKiooLi4mKtXr3Ls2DFycnIoKiri/PnzVFVV/S0Nlfft2/fZYau8vJyTJ082jJ88edK8hv4PqBm2viJ9bbCVsWEvyTtKWXjgDpMOPiIt+zrjd5QTNy8HDR1bBAQkkZKU4xtxybdg6zVkNUCXpAwtxWSQUeyAU6/+GBh3R1BM8d9OhB0bYKuNRidaq5sirWyAZDs9pJT0aa1uinwHM9poW6Ckb00HM0fUDbqTMmUJtp5B2HoFYGxhi7FFdwZGDyM6JpaYobEMih2Gf59g+oaFEzs8iYwJU5k8bTbpWVMYPSaV4JABJCaO4sqVUh4/fkxpaSlz5swjNLQfDx683+Hv8b0qhtgbMaanJdP6ubB8qC/bUwayKzWKnSmR7EqNqoevcRFsHRPGppFhbBjRn7XDQ1gVG8TSKD+WDwpk5ZA+rBzShxWDg1k5JIT1CeFsHhnFltRosifGUThrDKV5G3lWeZ1fnz/lx7u3+e1ff773u66ujoePn7Bpdx5bcgpYunYjc5esIGPSNGKGxuHs4oaLkzOOzk7Y2+gR6a7CuL5qjPKSwURTjraqemjomKHXqQfewTG4B0Zj6x6ApX0vbNyD8R84ioiEKSRkLOW73adYkX+JhKxl+IQlEZ86E0sHL1qJStGiZSvaaZuh7xZJp/4T6T1+AxHzCxm16TJpOTcaYCtjz623YCsr7zYT8iuYtPcOUwrvMnHvNURVdRETa4W4cItm2GqGrX+UGgtbFRUVnDhxotGw1FSDjeLiYh4+fEhAQH0/qsLC/2R7nj17xrVr1zh69Cg5OTkcPHiQ0tJSfvjhB169etWkLYxfErZevarGw6P+efv3/7g6tS8JW8XFxZ8Ntv5oif78+XPu3LlDSUkJhYWF5Obmcvz4ca5du8bTp0//kjn37t3LgwcPPitslZWVcerUqYbxgwcPEBMT+9LLSLOaqGbY+or0tcHWtPzzTN1XwcL9t0jee48J+RVM2HOdEd+fIixjDZIqJkhIyvGNaOu3YEtUQr4BtoRFZRAWl0JQXBbJNupYu/hj2c2Ddu2NEJFWQVpZpwG2FDQ710d7U2SVDJBqq4ucsiFSasYNNVyqRt3RMXfGyNoDcwdvengF0N3Rh/YdTXF26010dBz9wiPoHzEQv6A+9A4IxMc3iPDIwYwYlUxcwihSx2eRkTkZK2tbLLp0w9PTG3//QIYMiWXQoCFcunzlT2u66urqePbDI+K8bIhz7sTGGalUlpbw85NHPLp+hZPrFrA9uR68do+PZvf4aPIzYslLH8ru5Gi2j45gW2IYG2JD2BTXl22JYayL7ceG4WFkJ8eSmxrH7gnDyJkUz91Lp6mtrWnYNvihnl21tbUcOHaSrbl7Wb15B/OWrWL+ku9ITsskNDSUHt274WRnj6NDdzzstcgK1yIrRpXhLq3QU5ZCQVUHJXVDzG3cce49gB6eoVg69KS7SwAOPgMIih7L8PSlZM7bwppdR5i/aicuvoOYNHsVI0an06ZNW4SEJBESEES2tSpqVoEYBqfTM3kdEfMLGbnxEqm7r5Gx5xYTCirrt6n+AbYm5Fe8AVyTD92ld+JEBEQlERIRboatZtj6R6mxsFVZWcnx442zI28qtFRXV3PgwAEePHjA+PH12Z4pU37k/Pnz7Nu3jz179nDq1Clu377Nzz///Na1TdnC2JRatTNnznD9+vVGw1Z1dTV371ajrFyHgACsXPnh+q0vDVufyxr99u3bb1mi/z4eP35MWVkZR44cITs7m/3793PhwgXu3r3b6KxXQUEBDx8+/KywVVpayunTpxvGVVVVSEtLf+llpFlNVDNsfUX6ZEOMP8DW393EuKVACyRkxRAVEEBSVoasnWeZsPsSMwrvMOfgY6bkVzAh5wZpO8pI+O4YvRMXIiCqiqx8e4RFRBESk0JMTpUWUmqIiEshKimDkJgULUSlEWoliYCgGHLtNDCysEPX3AETS1ck26gjKauCpII2sqpGiCsbIKlmioJmZ2RVjZBsp4dkOz3aaHRCRsUQWVUjVPWs0DZ1QNvUAYMubuh0dsLWoy/axrbodepBL/8wBkQMJrjvQPz7hBIWGUVgUDC+fgHEDU8gJTWNVWs3MnHKTKIGDaOrtS32Dq54evUmPCKGgZGDmTdvwQdrun75+Sduv8NEo7amhlunD7J1dD+yUweSnzmIXeOi2BAfyuYR/clOiWHriAFsSezP9pHhfB/bh+/jgtmSNICdYyPZnRxNQcYQTqxfTO17jDBex+txbV0dd+4+YO323Xy/PZv5S1YwZ/5SpmRNI3Jgf3r7OWPTvSuOdu442ZgwuLc2S2INmBvWmj49xFFTkaadsg5KuhZYOfthauWGaVdX9Ds7Y+0QgJ1XBKFDMhiavpA5y7czef5alAxsGZk5j8SUKRiYWCIqJt3QF0uwlSxt9bvGZsLVAAAgAElEQVSh7zUIt6Rv6TunmJFbrpKWfZ3MPbfq4f3fQPX7eF2rlZV3m8n7qph/+hmZe67T1tAWBSkJpMREaNFCACERYURFxD4Ctj7NIKNVq//Yy78LWN4GlPe//inxob/106//AGQ2w9Z/vWpra/nll18+ql7p93Hnzh2OHj3aaFhqqsFGcXEx58+fZ/Lk8n879VVx+fJlHj169MFnacoWxi8NW9XV1ezb9y9atKhDQqKOy5ffX7/1T4Gtd/Wf+rN4/vw5FRUVnD17lr1797Jnzx5OnDjBjRs3PinrlZ+f/9F9wP6quHLlCmfOnGkY3759G3l5+S+9jDSriWqGra9I/+2wJSYkiqDwN0gLCdNKrjWTcy4wc98N5h58wPTCe8wsusfUgkoyd18jY9dtUtafI3TMIgQkOyAgKoeYvBKiEvJIiMsiLi6PoKAEoq1kEBGW4htBUYTFZZFqo4qWYVc6dffEwNyRdhqGiEsrIaXQAXkVA6RVDJH4N1TJqhohrWyAeFsdJNvp0VrdFEUtc+TUjBGU1kDP3IXO3X3oYu+HjWswXe16Y27jTmBINCH9IgkKCScguC99+vbDu2cvvLx98PULICExiXGpmWRNms74jEmMHpdG9x6OWFr1wNnFE59eAQwZEktx8YE/gFQNNTU1/PDg/gc/69qaGg6tmMX3w4PYmBjCmqGBLI/uzeohAWxK7Ef2uGi2JPZnc0L973npQ9mbFcfu5Gg2JfZjfWI/nt659d7mxz8+f8GjH37gl19/5cGjxxw6dorl6zazYtM2Vm3azpyFy5g6Yz4jRyTh7+eDq4sD9jYOuDpa09OuA5MGGbJsuBazB6rgYiJEu3ayKLfXR1mvC/5hcVj08EZD1xKTrh6Y2/jg4jsIv4ixzFmzB7+weDp382BoyizUjbqjoG6IpKwSUtKtERYSQ6ilMC2EJJBSM0bPLRK7obMImb2PUVvK3oKtrLzbb8SE/IoG2JpYUMm43WVMLLjFhFV7EBSXR1RUFAEBAcTExGjRokUzbDXD1v+0Xme2PhW2qqqqOHLkSKNh6VMNNn799VcePHjAxYsXKSoqYteuXRw6dIh9+6oQEAB7+493JGwKbDXFGKSxsPXixYs3YKu6uprU1PqMnqlpLS9eNMPWrVu33uo/9bHx6NEjSktLOXz4MNnZ2Rw4cIBLly5x//7992a98vLy3rCf/xxx+fJlzp492zC+du0aioqKX3oZaVYT1QxbX5H+22FLUlwCYaGWiLYQpbWhKVNyLzJz3w0WHv2BOQcfM7PoHlPyK0jfWU7S5nLSs2+RtOooicv2YewdgWRHa1pKq9JKvHW9AYa0CkItpRBpIco3gqJIt1ZCQl6ZdhqGdOruiZpOFxTVDWit2AExWWUk26gjr2KAfHsTpJT0kVExREbFEAlFXcQU6uu6lHW6omncA3WD7mga2WJk6YGumTOdu/tg1MUVdV0L9IysCI8cSr+wGKIGxxLSfwB+/oH4+gXg6ORCeEQkgcH9GT0ujTHJ6aSkTSBm0DAsrXpgbmGNT68Ahg9PIC4unnnzFnD58mXu3bvLiaNHSB8xDL9unZiSOIjqX3/908+6traWO6XnmRfmzsKBXqwc5MeKGF9WDwlgfXwoR1fO49H1Ul4+fcyTW+UcWz2fNbFBbB43iLO7NvDswd0Pfp9+fvmS+ctWsGTVWhYtX8vydZv5bu0mpi1axIxFi8mcPI0xKWmE9g3C1cUJLxc3/Ny88HLQITZAg3WppqxO6kBaaHtM27dEoZ0ayu110TTtjn9YHA6eIWjqWdHJyguL7r3wDxtFQGQyfWLG4RUQSd/I4ehauGDlEoi8qh5tlbWQkVVAWEQcwRZCtGwhgpB0O9p3D8I2air9Z+czevMVUnddJT3nBpl7bpG559ZbsJWVd/uN16YUPSBzz03mFF6lnY0vAkJiSIrLINiiJQItBZphqxm2/qfVWNi6e/cuhw8fbjRsfYzBxosXL7h58yYnTpwgNzeX/fv3c+nSJR48eMChQ4e4d+8eP/9cjZBQHe3afbwjYVPqxZoKW9euXftLYOuXX6qxta03Bxk69Lf/Stj6nE1/39XstzHx448/cvv2bc6cOUN+fj55eXkN/dGePXv2xrl79uz5LK6Hv49Lly5RUlLSMC4tLUVVVfVLLyPNaqKaYesr0n87bEmIiSMmLEJLAVHCs2aQtfMsi47cY8W5l8w+8IgZhXeZnHeb8dtLydh9jYQ1p8jMvk7sisOkbL9E/IpD9J+4HjP/EUirmyIgroiAiCyiYtK0EpdBXlENWUV15JS00TV3oKNJD5Q0jVBur498W3XE5VSQUdSmjZrRfyzg/53lEm2jjYh8ByQUdVHq2AUNwx6YWHuhb+GKY88wbFyD0evsiK2rP0pq+jg4ezEsfjQR0YPpFx5Bn+BQ/PwDcXRywdnFjT6hYYRHDmZMcjppmZOJTxjFuOR0unS1QVfPGH//QCIjo+nfP4zQ0H4E9gmiu6UFhu3bYa2jjo+lLj88uPfez7uuro5710s5X5hD0fI5bEodxqIIb8oO73ujIXFtbS21tbW8/PHtDu/vy2xVVt1l9aatzFy4hEXL1/LtqvUsWr6WKQvmMXnuHMalpxM9ZChu7k64ODji6+ZCT3tT3K3aMi/ejM2jtVgzQpuBbvJ0VBKjXXsj2qhooqLfFRu3QMxsPNHUs0K/szM9XIIZOHwi077diWefwSiqG9DNwQuPwEgsHHxRUDdESU0HGVkFBEUkEGwhhLCgEC1EJBHX7oFd5AT6zshhxJozjN12hZSd5YzffY3xu6+RkXvzrXgNWxm5N8nMq2La/ntM2HuL+I2nEZBth7SoPIIC3yAg0gxbzbD1v63Gwta9e/c4dOhQo2Hr9u3bbxlsvHr1iocPH3Lp0qWGBrbHjx/nxo0bPH/+/I1zDx8+zN27d6murkZfvx46Hjz4uLmbUi9269atRsPW2bNnGw1be/bsecffUk2bNvX1W1u2vLt+658CW3/Hc7148YKHDx9y5coVDh48SHZ2NgcPHuTy5cs8ePCA3Nxcnjx58llh68KFC5w/f/6NsYaGxpdeRprVRDXD1lekT4UtSaGWb8TfDVutBIWQFBRAREKaSat3EzdvM1O3n2D+/ltk5ZYzM/86U3bdZuKe26TtKGP89lLGbrrAiLWnSVx/lhEbzpG45hSx3x5iwMJ9uMbPopWyIYJCYkgotEVeTQtZZR2U1PTRNLHD3DkANePuKKgYoqjVGRmljojKKdNaUYM2yga0U++MYgcL5Np3RqadLpIK2kgqaCOnrI9aRytUtS0xNHelm2MgTh596Gbvg5a+JXom3TEy6YFP7/6EDRxCUGhfwsIHEhkVQ3BIX5ycXXF0csHN3ZOExCQSEpMYkTSWEUljmThpOiGhYWhoauHdsxd29o4kJCYRGOhP/5BgrMzM6KiqRg9tdS6dPfXexsjvUm1NzQdNLgBulZeyP3/Pn96/traWnTn5TJu7mDWbdjB78VIWLl/Fgu9WMm3xSlLHZzIyKR73Xm7Y2QfgaW9Bnx4mOJnIkOChx9pUc/ZM786KeG2cLZRRVZChfQdj2qhooqxpjpNXEAbm3dAxscG4qxs2rsH0Dk9gQGIW9h7BmFi6MighnQ6G3dDt5ICKVidU1PWQlGmDqLAkoq1kaPGNKGItxRBS6IjD4GkETitg6LLDjN14keTNlxm/rYy07eUk7yglZWcZqbvKSd1VTnrOdTJyb5CRe4O07GsNtVuT91UxsaASLec+CLVshfA3QggIin8yXAkKCiIkJNQAWaIird6It2HrQ4DyPjj6owFG08Cw6fd7v4HGn8FXs76cGgtbDx484ODBg42GrYqKCo4fP85PP/3UADCvm9ReuHCB+/fvv9e448iRI1RVVVFdXY2fX71DX3Hxx/WfaipsNdby/q+Grerqanbt+j8EBEBWto5z56o5fPhfVFQ0w9bfEc+ePWvIbObl5bFz505OnjzJrVu3+PHHHz/Lc54/f54LFy40jM+ePYu2tvaXXkaa1UQ1w9ZXpK8BtiSEBBBoKUj8hNlETFiOZ+JsoufnkLHjAll7KpmY/4CJuddJ31lO6rYrjNl4npHf14NW0sYSRn5/loQVx4lavJfh3xUxbPZmDJ1DUe9gSOu2arRRUkdcTpF22hZ0dQ2km2cIHY1sUTe0QUXbHMk26kjJqSKjoEVrZQMUNDvTRtOMNmpGyLTTRaKNFhJttGitaoyiRmdUO3ZFXsUIxQ4W2LgG4+obiYZhDzS0LDDu3IOImGEMGZ5Iv/5hhIT2wz8gCC9vH9zcPXF0cmFgZDRR0YNISc1k4qTpLFr8HfPmL8E/IAh1jQ64uLrjHxCEt09P+oaE4u3ugYudA8YdVElPjKWm5rd3fta1tTVcPH6Ia+fP8OvLnz/q+1FXV8fDe1UEuzkQNWAAa1atpbLqbkPmq/6+9b9fvFLGjPnfsn5bdn2d1vpNLF65hnlLlzNpzlwyMicREhCKvb0jrg62+Ll2wtFQBXt9cZbFG7IpuSM5k0xZMdKCju1aoammjI6xJe3UdWnf0ZIuPdxR7WiEhl4XTKy9sO85ADNHP9yCB2PRwxtrR186mvRAXsUAbWNblDuYoqSmg4R0a4SFJBESlEBEWAphYSmkdLrjOHQWwTPqYStx9WlGrjvH2I0XGbfpEuO2X2kArpSdZYzffZX0nOukZV9j/O6rb2w7zMi9ScqmYwhKKSErKYW4pEQzbDXD1v+0GgtbDx8+pLi4+JPB4dWrVzx+/JiTJ0+Sm5tLTk4Ox44d4/r16/z4448ffZ+jR49y584dqqurSU6ur19atOjD7nzV1U0zuXhXRu5j49y5c1y9evUvha3q6mri4+uf/xuh+ixXi5Z1hA6o4aef6ps4X7t2rSED8zlhq6ioiLt3736Wua5fv86xY8c+y1w//VSf9crOzub8+fMcOHCA7OxsDh8+TGlp6d9qmlFSUsLFixcbxidPnkRfX/9LLyPNaqKaYesr0n87bLUUEEBU8BuERITRNjLBM3IMhr3j8Bv3LTFT1xG9uJiU7BtMyiknc/c10naUkbzlEmM3XSBx/VkSvj9D4ppTJK48weiNJ4mcl0PU/DzCZ+bg7D8UOcWOKCm3R7JtO+SVO6LX1Qm73uFYOgbRsZMjmgY2KLY3QUpWHcnWaki31URW1QCFDma00+xEGzUjpBV1EG/dASFpZZS0TFHUNCYofBgb9pwkdEgqGXPWYtitJ569BqKlb42zVyBJKWkMjY2jb78BBAT2wT8giIDAPjg5u+IfEERgUDApqZnMnDWfmbPms3jJciZOmkJo3/5od9TFu2cvegf0of+Agfj7BuHr7YezszPGHdpTsHM7NTW//aEx8m8czdvNACtDBlgZMrC7KSMDPViYmsQvP//03u/Iw4cPyZowhUnzl5F34Cir128mP38fN27d5tmPz7ldWcmefUXMXLCUb1etZ8eeQrbszmfe0uUs+G4lC75bSWpmCgPCInGxd8O1Wzd62+pgbyqHjkwLBnq2Z/s0c7almJI7WY+58d1QU5BH38CIDoYWqGuZot/JEUNzW9R0jDHr5oZ9rxhGZC5m+bYiwuKSGZSQTnBEAuKtO6Chb0V7XSuUNE1QUOqAmKQcQhIKtBQURVBIDAExRXQ8h+KauJDQGbmEz9nL8BUnGLHmDGM2XGDcpkuM2XqJsdsuN0BX8o5SUneVk7Kz7N8QVt6w3XBCfgWZBRVY9RmGgIAQrQQ+fRthM2w1w9bXpLq6ukbB1qNHj9i/f/9Hnfvzzz9TUVHB6dOnycvLY9++fRw7dozi4uJG2c5XV1dz7NgxKisrqa6uZt26+uxOXNyf1y79EbYauxXwS8DWTz/99F7YWr36/xAQrENgJQj8BAL7QLBtLcEhFeTm5lJcXNxg/HDixIk3+lE1w1bjIzs7u6GO69mzZ9y4cYOTJ0+yZ88e9u7dy9mzZ6moqOD58+d/2Zznzp3j0qVLDeMjR45gbGz8pZeRZjVRzbD1Fem/HbYEBQQQFmqJlKQoIsLfYOfuS2D8ZAalL0Hbwgnn8NEMWpZP8pYSMndfY2LuTSbk3CB12xVGb7lI0sYSEtecImHFcfrN3k3UwgKGLCkkYlY24bOzsegZibi0InLtOiDfVp32hhZ0deuDk98QbFxDMTBzwdDMGbk2HZFX0kSqrTribTsgo2aAooYpbdVNaKNmhJyyPq3VdBGWUUJWWZvWarpo6lmhZ2pH1x49sbT1wT8kHjNrLzoYdCE0ciijx4wjYmAUoX37ExgUTL/+Ybi6eeDh6Y2Lqzv9B0QyNDaBpJHjSE7JYMLEyaSkpjEwMpqultb0cHQlpF8E/QdEMqB/JAH+IfTy8MK4gyopibFcOHWMR/equHLuFIsyxxJhZ06IpSHBXQ3w66RNL1NtvE20OH/q2J/audfW1lJ17z4j0zJYvmE9i1asYkxKGlmTppMwNoWMqTNY8N1KJs6cw6oN21i/LZvNu/JYuX4rc5YsY8aCxUyZM5+kEXE4ODhhb2OFe1cNPA2l6aLWAkdDJRamWLN+STB758eyZ7oJEY6t0dbUw9jMCi2jLujod8PM2gsdE2s0DTrT3dkXB79hOAfE0idqJDrm3fHwi0BD3wrdTnYYWjih1MEcRXUj5Nuq00pchlZt1GglKkmLliJIalpg0jcLh+GL6DdtFwPmFDDsu2MkrDrF6PXnGbvxIqO31Mdr6HoNXuO2X2HM1ksk7ygjZWc5Gbk3mbT3DtOKHzB+81GkNYyQEpFqhq1m2PqfVmNh6/HjxxQVFb3ztVevXvHDDz9QWlraUOty5MgRrl69yrNnz6iubrqb4fHjx6moqPgPbH0Dcop1ZGX9xqNH77+2KSYXTWnm/HfBVg+nGr6JqUMA/hPfglTrWl6+fMnTp0959uwZt27d4uDBg+zevZt9+/ZRUlJCVVVVo/tM/TfB1rVr1xq2pX6u2L179zu3D7548YJ79+5x8eLFBtA9cuQIZWVlTXYvPHv2LJcvX24YHzhwADMzsy+8ijSrqWqGra9IH4KtP8KVpKDQG/F3NTH+Y0NjcSEhJISFEWghgIZhZxydXJiROZbTp4uRN7bCPnE+McsPMuvIQ6YUVJKVfZ2M/NuMz75O4trTDFl6iOErjzNk6SEiFxQSPreAvjNyCB2/AkPbXiioaiOtoI5su47ombtg4xaGR3Aczv4xmDv5096kB/Kqesip6CKrrINYa3Wk2nakjZoRCu2NUdQwRUXXEmWdrijrdEVVz4r2Bt1Q0bXEzqsvfQeNwd4thN59htDDOYjOVp6MGTeZ0ePSSBozmoSRYxgaG0ef4FC8vH1wdHLB1dML796++AYGMXxEEpMmzyBrwlQGDY5jwsRpDIiIwbKbHR7evvTsHUhgUDDBIX0JDArGytoGTaW2GKkrYmugjqd5R3zN9fHtYkBPM118uhrgYWmIlaEWEzLG/2n/rtraWtZ+v5GYIcMZl5xGUGh/4kaMYvLsucxbtorZS5YzY+FStubuJbfwEJNmzmfF91tYvGIdM+csZsLEqQwdOowedrZ0szTDx84If+s2+BtJ4NJJgfQx4axePILp02eyakkCS0fp42TWjk6mhljbu2No5Y5Zd3dMu7igrtMVbePuKOtY0MkpgImL1qNt4YRDr37omdqhrtMVVS1zlDU7o6ZpjIKSNuIyCkjKKaCo2gFBUWnElPQw6BmLRVgmzgkL6Dl+Hf1m7WHI0kMMW36UEWtPM3pDCWO3XWbM1kuM3nKRUZsvNMSYrf/eYvjv7Gnqtiv1GdXscjLzbhM9cTUCLSSQkpBGRKgVQi2FERBogbCIKCKtJBAWEuMbgbeBQlBQGCEhkXq4EBFtMMV4HR9qavxh04n3NSluKkx96H6fBoZvm2y8++9v1pdTY2Hrhx9+oLCwsGH88uVL7ty5w9mzZ8nPz6egoIBz585RVVXFL7/88tb1TXUzfA1b27b9Hy0E6xCwr0NgOAir1qGlX/te4GpK3dXrWrPGwlZ5eXmjYCs3N/etYzdv3uT48eNo6L1AIJ03YWs3tBSqe2fN1pEjR7h79y4lJSUNTaBPnjzJzZs3/9Lao88JW1evXuXEiROfFbZ27dr1UVmr11s5jx8/Tm5uLvv27ePcuXNUVlZ+ctbrzJkzXLlypWG8b98+unbt+oVXkWY1Vc2w9RXpa4MtKVlhBAQlMHfyx8UrhKGxIUxJi6Ob31B6p69g2MoDpOwsZ8r+J2TuucWUwrtk5lYwZmMpcSuOEb1oP2Fz8hk4fx8Rs/cQNn07btHpGFi6Id1GA+m2WihqmWPavSf2vaIIjBqDZ+hQurgEIK+qh7yqHu31LJBS1EJUTgNpRR1aqxrWQ5dmZ9obdKODiS3KOl2RVTVCUcucdtoWaHeyp1fwEHoFDyFs8DgMzJ0ZGJVIStoE0rIySUnPYtz4NPqGhePd2xfv3r7YOTnj6OqGj58/4VHRDIsfSdSgYaSkTSBr0nTSMicTlzAK714BDIsfyZixyYwdl8LYcSmMS05lWFw8fUNCcXeyx7arOQ6mhnQ31qOHmRGO1mZER4UzZ95cNmzdwY2Kyvraq38bZbyuw7p0uZSEpLFExsQyODaBPv3CiRoWT/q0Gcxespwd+UVszd3LnuIjbNyRy/bcfaxcv5WsaXOYPms+scOG4+7ujr1VF3rbGdLfvh0DuonT31qMmEAbUlLGs2jRGubMWUJGWiJjBnTBwlAbfTNLAgYMonMPD2yc/bHo7oa6niXmdoEMTJiFU0AUkUlZBEeNoFdINGodzWjb3hAFNQPaqOoj264jwlLtEJVrh6SCMgrqhgi27oCeYwiGveLpEp6FS+JCfNK+p//sPAYtOcDQZYeJX3WCpHVnGLnpPCM3nW+ArNe/j912uX4r4b9ha+ymCyRvuUTqjsuM3VXKxPwrmIQMRVjZEAFBGVqKiCEhJk6rFsK0EhRCULAFrcREmmGrGba+ajUFtgoKCigvL2/oT3T48GHKy8t58uTJB+/XVDfDEydOcPPmbVQ71CEw4neQ8RyElOuYNOnPtxQ2BbYqKysbDVslJSVNgq0nT55QVlbGwYMHG5wab968yejR1Qir1yHw5N/vwb9AwA7aqdXx7NmHDTIePXr0huPe4cOHKSsra7KteWFhIffu3fufhq1PzQq+ePGCqqoqzp8/T1FRETk5ORw9epTy8vKPer9Pnz5NWVlZwzgvLw8bG5svvIo0q6lqhq2vSF8bbLUSEMHUK5JBK/KJ37wfv5gpuPYKYs6CLHoE9EPXyZfeSXNIWnWUSXllzCyuqLfoLqgibUcZSevOELO4mPC5BUTNzaf/7Hy8x67APiSetqoGSLTWQEqpI+rGVpg79sEvYiRBMaNx8h9IByMrZJQ6omVsjUrHzg21WlJtOyKvYoCcmjHy7U1Q0OyMiq4lHUxsUdG1pIuDL/5h8fSJTKKrox/d3YPx6jMIN48glq1Yy9SZM5g5dwETZs5gUEI8PYMCcfD0wM3LG2d3Dzx6+hAU2peQiCj6Rw9mTHoWsxcvZcXq9axcs4FNW3exeOlKZs2eS0bmBIbHJzJ4SCyJo0YzOjmFwcPiCAoNwdXVHUcnF0YmJ/P9li0cL7nA7r2FbMnOZcqceezcncv9Bw/55ZdfuXyllIWLlxLQpx/Obt5ERA3BN3AAMXGjmLNsNdv2HiDvwFFOXSonp+gQ2/MKKTx8kqWrN5A6YRpJyRmER0Xj07sXtrbd6W5hRkAPNeJcpRjto8JALyMShoSRPHE2c5dsZt78xYxOySTAzZZOnbtg6xtOzMh0VLRM6OLgi6mNGwpanehs70+vsNFEDE9DVa8r9p4BGFr0QFnLCDllLaQVNZBqq46onAaSbTsgr6qDlKIG4irGaNsHo+M5DP1eSXQJz8I5YUEDbMUsLmbwtwcZtvxoPXBtLGHkpvMNmaykjSUNhiujNl9gzMbzjN5Q0hBjNpcwae9tRm09T8ruUkatPYL/mHnoOgYiIKeOgIA4wqJStGghiJhoM2w1w9bXrU+BrV9++YWqqirOnTtHfn4+u3bt4syZM1RWVvLy5ctPAoj79+83yc3w5MmTnDpVgYAACFz4Q1ZnKLh51/zptU2pu6qsrOTYsWOfBbZ+/fVX7t+/z7lz59i5cyf5+fkN2cLf17o9elSNvmktgtJ1CPasQ0i5jm9E6s0yunatoazs2Ue7ET59+pTr169z/PhxcnJy2L9/PxcvXvxgg98vDVvl5eWcPHnys4HW8+cvyMg4SkJCNRMnvuL69Z8bdZ8nT55w9epVjh07Rk5ODkVFRZw/f/5Pt3eePHmS8vLyhnF2djb29vZfeBVpVlPVDFtfkb422LIaOJwR3x8jZdMlxiw5yKAV+QyYuR0nK1tsbczI3VdAj179UbH2pVP4SAKnrGTs9rNMKKxk2t47TMi5wegNJQxbfpTIOblELTtJn+l78E+cgY5RN6TbaiGp1AGZ9h3RMnPD2T+G/nHjCYhKwjtoIPKqeihrd0Lf3A5FDVPE5DURk9dEXsWgoQeXjIohrdVNkW9vgqGlGx07O9DNNYhOPXri6h+Jg88A+g0Zh6OzL+NSM1ny3TLmL17KzEULmTR7FlkzppOUmkLkoMEEhoTi5uWNf59gEselsmHHbrbl5vPt6nUsXLKcFavXs3DJcr5buY4FCxczfcYsxo5LIWbQEBJHxJE0agSDh8XSLzyMrBlzyT1whM0FhWzdt5+cokLW79jOyu/XMmPuTKbNnEda5mTCIwczLH4kHt6+OLt5490rgFFjxzN51hJyio6xo/AI+cfPsT2vkIOnStiSU8DarbuYPGsBM+Z/S1JyBgOHxOPs7oabhyvuHs70dPdmsK8pU8LVSQ/RIzo0mJlzFpM+exFpUyaycOki+g9NQkmhLUZdupE0ew3uQZFo6pmhZ+GMrrkDSroWaFYehD8AACAASURBVFrYYBcQwsxlG/HtPwRTKwc66Hemrboe0ooaiLdWRVROGTV9a9QNrWmtboiUshY63X3p4BKJgkMMnYJTMB+QgePweXilrKHvzFyiF+1vyG7FrTjG8LWnSPj+TANwjd12uSHDNXLTeZLWnWHU+nOM3lDCqPXnSM+5yqj1Z5iUW0nK1puMzb5O8o5SsnKuMHLNYUxdA/hGsh1CQpKItRRrhq1m2Pqq9SHYevbsGVevXuXo0aMNfYZKS0upqqoiPz+/0bD04MEDDhw40OjrT506RWnpLUTE6xBY/yZsCdnWER3z57DVlK2Ad+7caRJslZWVvfecly9fUlFR0WCFv3//fk6fvsiwYRfo5VdDZFQNR4++bXH//Hk1y5b9H0OG/Mb06b9x4UI1lpb1/ceUlWs4fPjnj4KtN4HiOZWVlQ1bQ/Pz8zlz5sxHmz78r8LW8+c/4eP3f3zTsg5huzqENesQEa8jL++XJt73OXfu3KGkpITCwkJyc3M5fvz4G26SJ06c4OrVqw3XbN++HWdn5y+8ijSrqWqGra9ITW9i/GZ8CK4+BFuvwep1iAoIIS0kiKCcMq7xkxi5+gjJG04xas1Rhi/bT8z8PQxflEtg0gw627uhoaONo1MP5i9exLDkCRj08MLAYwDeo+Yx/PvjTNl/h8yCO2Tm3yduySnC5u+n/4J84pbtxTUildbqhrRRUEZWVY82GkbodnHEJyyefvEZBEWloW/tjqhCezQNbDAwd0RRwxTx1h3qrd9V9JBX1kVOSaf+p5o+ilqmqOia08GkG50deuPWJ4bA6JEkT1+Kq68/4yZMYsrMOQxLSGRESjKLVq5g5qKFrN26hVUbtzBt3kK+W7eBHXl7WbN5G+u27mDz7lx25u9j2dr1rFi/iSWr1rL8+41MmTOfOUuWMWXOfMakZzF89DhmLFjMohWr2ZqTx6atu8jJK2Tjlp0sXb6GydNnMHv+AmbNm8+UGTMZGB5JYGAf+vTth7uPDwOHDiMqPomh4zJYtjWHfadKOFV2k2MXyjhw8jz7Dp0gv/goS1Z+z+qN25m//DtSMjMZn5ZBaGg/vLx98OodgKNHL3r79yM12oVJUSYkRPcicmQK81ZvZPWWXJKzZjFp6izs7BzooGuMR784Rk6ch2UPD5RU9NAxscbW3RPNzg7Y9Ixm4sJ1WLv4Y+sWhKmlI9r/z955RkV1dm14RJHee+9FRRQbiCCioggIKggq3QoovYqCgj32hhUUO3Z6UwQVKzbsJcbEGKOx9yTK9f1AJmqMSdSYN+tjr7UXnnGe8wxz9KxzrXvve7fogIq2KRISCsjIayCtZYmpnSeaxm3RNGiFgmkXdDr3x6CbH8bOIbTyTKDTsFn0iFrGgAmbGDJtJ4Fzixm+aBejV+wjctVBItYcJmrdUWI3Hn8NWacYu+0sSVvPELfppFDpapjllrjxBMmba0ndfo4JO84zIf8SEwsuM6n4KpNLvmFC7hlC52yiRTd3BM2kEBGVRFlGmSYCEZqIiSEqKoqEhNTrXi9JxMXfzQ8bZPwdoPnzocF/19Di82bjUOP//XgXtp49e8aNGzc4efKksJ/n6NGjXLt2jcePH7/xcP/gk2DrY63jG/Lo0aNcuXKF8MhfEVWpQ7AWBDUgCAMR0Tpqav545tanwlZ1dfVHrT158uR7Yev+/ftcunSJ/fv3C80ULl26xP3793n8+AWdu/5KU/lXCILrEO1VRxOROlav/nOb+4cPX+DrW28LLylZx7p1zz7a+v3hw4f88MMP1NbWCgdOHzhwgEuXLnH37t33rikvL+eHH374IgB0/vx5jhw58kX2Wr/+GU3F6xCcfA34r6DJsDp0TV7x8OHn2+enn37iwoULVFdXC1XG8vJyTp06JVS9cnJycHFx+bdvI43xidEIW/+h+F+HLWVJCZrLKuAeMYn49YdJXHuA2FV7SVhTTcTy3UQsKydkfi7Bk1czcs4mbIdEotO+G+2796G7ox2WrVtw/OQxhgQEYj0wkKC0ecSuzGPO7otkVF9nWuklotfXMDrrKF5pm9C0GYCclhkyytrIaRihYtCaDo79GRKWzIi4Gbj5jUFeuyXKOhaYtXXArK0DyjoWiMnrIaWkj4yKYb06pmKItIouCppGqOiaoWvWFuve3ti5+eIzKgFbl8H09x1Bl56u+A8dSVzSWCLj40mfPp34ceOYvXAhazZvY+W6jeSV7aakch/55RVsKyyhpHIfRRVVrN2ynZzcAuHrG3fksSx7Has3bSEjK5vVm7ZQceAwZXurycktIK+wjK07Cli/aRsZy7KYu3ARY6KiCYuIJCImFv+AoXj6DGFwQDCBo0IJi0tl9pJsyg+epvrU1xw6d5GDtec49/V1tuwsYvaCDDZu3UnO9jwSxk0gKiGBEaNH4+HpRfdevXF286Cv1xACQyIZOjqGuJiRxEUHkTh1NjMyVrF6cz6rNu1g6uyFDBkcgLa2MWZt7OgXHIvv6GRsnXzQMmiDVSdb7Ho7YOs6EN8xUxkQnMTQiPH08ghAWdsMWUUdmokroKppgopeK3QsHNC17IqGURuUdSzQ7eCKtk0/IWxZeCXScehMesdl0jd5LUOm7cRvVgHDFpYzesU+orMPE72+huj1NcLSwcQtp4WwlbC5Vghb0etriFx7RKh0JW+uJWVbvV18at5FJhVfZUrpNaYXf8vU/CtMzbtI+LJKWrj4I5DWQKy5NIoSkog1k6JZU3EETZvRVEKiEbYaYet/Ourq6oQP+w2lTJWVlZw9e5Zbt279oeL18OFDiouLPxqW/o51/PuypqaGK1eu8PjxC6JifkVCpr5sTtAcunX7Y1XrxYtPKwW8fv36J8PW8+fPuXXrFqdPn6aiooLCwkKOHDnCtWvXfleOuXr1LzSTrkPw3Rvq3SRQUKvj0aM/3/PJk6ekpT2lSZP67yc6+g7793/6nK0GEGgAxDf/zfxbsHX06NEvsldAwM80GfCO++NlEAjgxImPKyf8s2xQGcvKyiguLqawsJDNmzcTFRVF3759/9V7SGN8ejTC1n8o/tdhSyAQwcLZk5isUsZtOEnc6n0krTtI3Op9jFlaTvjSMkIXFREwbSOjM0roFbOY3hGzcQpOxMjKFpO2nTAwMaWbvQ2tzHRJiB1DYnIsEfER5B2pYe+5b1hbVsP0TVWMmL0Tj4ivkNRqhYauMUqaxihrm6Fl1p4ufbwJjExlRNw0rLt7I6VigKZRO4wsuqBnbo28hjlSSvpIKekjrVxvtCGpboKEmjGiSvpIqBkjrd2K1vZuGFh1IzAyFUcXX3p7+GFt1x3fwAB8/QLwGTSEOXPnM2fufGbMX0Tm+k0U7q4kO2crObkFbM4rpHjPXkoq97G7+hC5pbvYc/AI+2tOUFRRxd4jx9hfc4LSqv2U7ztAUUUV67buICMrm8zV68lYlsWsuYsYlzqJqV/NJGRMOCFjwvEPHsog36EMDhiOxyB/EtOnsnxTLvtPXeTAiXMcOXWePUdqqDpcw7a8ItZt3ErGkmWkpE4kLj6RCRPTGTEyhN6ubtj3cqLPgP74Dw/Db8QYhoUnEDQ6koS0aUSOn8Li9QXsKK0mc8MO5mQsY8mKlbRtaYmKhjFt7fvR1y8a/zETcPdLoHWn3owfl0g/Xx/8w5Nx80/Etk8Aw6NS0TO3RkHDGJHmCmhrG6OqZ4m8QUfMO7uib9wGZe0WqJp1RqdjXzQ7uaPv4IuxcwitBybRPmgGvWJXMmDCJgZP3cGIxbsJWVrJmJX7icg6QNS6o0LYqi8lPPNWJmw+ReKWWmI3Hq8vOcw+THT2YRI2HGfclvo+r5TcC0wsuEx60ddMK7nO9PIfSS+6wcSC60wuukzUymKs3AIRSGoiEJFFQlYZkaZiSEo2KluNsPW/HXV1dVy7do3Dhw9z9epVHj169JfA4dGj3zvk/Z38kHX8X4Wty5cvv/F5XnDlygsUFeto1qyOS5f+eO2nqFMfa1n/9OlTDhw4QGVlpXDW2KlTp7h58+YH++WGDXuJyLsP9jfrH+w/pN69ue/du3fJyXmKzGsg7dnzNrdufT4QuH//PlevXuXIkSMUFRUJbeVLSkq+WBnhuXPnvghs1dY+plWrlwg6v3NNDtVfk0uX/hnYasjq6mquXLnCrVu3yMnJoX379oiKimJvb8/y5cv/zVtJY3xCNMLWfyj+12FLTsOQQZMWkrC+ivglu4lauYe41fuIWL6bhDXVhGcUMWpBAcGzdxIwcSVeE9finroOG7/xeCRl0HbAaFQtbDFs3R5pRV2U1PTRMTDEyFgPe9sW+Hv2ITJkKKV7d3Pk+1ekZGzF1Lo3yhp6SCtp1ZsuaBih27IT9u6DCI6aQmDYRDSNLZFTN0NNvw0mlvZom3RAVtUIKaV6+3h9844YWrtg3NkNMzsP2jv7YuXYj8RpGcSkz6eL6xBGx36FS/9hGJlbYtqyBU69nHF1c2fEyBAGeA5k3KSpLFm1hqwNOUKVa3NeIUUVVVQcOEz1sZNUHzvJkdqzHDp5mtKq/Rw8UUtp1X52Vx9i/badbM4rJCMrmzkZy1i5ah1pk2cQOHQUqWlTSRqfgn/wUHx8/eg/0JtB/sNInTKTWYuXs61kF1Wnz7O/9jSHa09x+MQxDpw8RfaGHHZX7Wdi2hQmpk0iNi6BmNh4ho8YhZNTb5zd+uLo0gevoABGRSUyIjKJsMSJpEz/irHTFrBo9U7Wr9/GrEXZzM1YzdbcArr3dERdThE1zRZYOQ7CP3QC4WPn4z0iHTefUAYO6EMH+564DgknKn05IWMnYWnrjJp+GyQVdTA0tUJVTRsVw3YY2/bHzMYFbS0DpJT0MWjfB52OHmh2ckev6xBM+oRi6T0W+7CFOIxZjPu4dfjNyKs3TFm8m7Dlexmzcj/h2YfqFatNJ0jcUitUtZK2niF5+znh3K34nJNErj1SX3qYdYC4dTUkb659Pfj4PKl5F0nNu8jEgitMLLjMtNKrTC26wsw990kquszk3ZcJWVyAjpUdAgl5pJpLoyIh1QhbjbD1Px/Pnz//226Ejx8/pqCg4KNh6V3r+L+bx44d49KlS797fdy4+rK58PA/diP8UrD16NFv9uwFBQUUFxezf/9+7ty585fW37//AgeHVwhM6xDUvfFgXwlNmtRx7dpfg7wGN8LDh5+go1M/ANrK6iUXLnx+MHj48KHQVj43N5eCgoJ/xFb+fbBVU1Pzj53/+PHH+Pr+QtOmrxXUJnUIZoHgGQjOgWiHOhycfv3HYW///v18/fXXwuPMzEwGDhxISUkJOTk5n+2eEBAQgEAg4PTp02+9npqaioqKCrKysgQHB/P8+fPPtuf/52iErf9QfDps/V1DjLdTXKTZOymCtKQUTcWaI62ijFPsJGKzKojNqiI6s4yYrCqiMyuJzqxk9JIyQheXMGxuHkOm5jB4YjZe41biGrOQHmEzsQ1Ox8Z3LNaeo7HoPhi9Ng6ombRDWdcMOQ0tpORVkVNSRVlVibZWrQgY6sr5S6dISpmEnKouyqomSMpqomFggYKWMZp67bB2HsSQ6DR6+0Qgp6CPorop6oaWaJq2Q1W3FbKqRkgrG6Cq2wrNFna0tvPAsd8wrHsNRsvMmvYOHljauuA+JAzLDi7Ydx+IVceu6BsbYWBoTLv2HXF06UO/wYOYNHOOELayNuSwYXsu24tK2XPwCHsOHmH3wcOcuvw1p7/+hvLqgxw8WkNx+S7WbNjI9rx8Fi1eQkxsPJOnTCN1Qhpp6ZMZEx5JUPAwvH0GExYRyZCAYIaOCCNkdAwxE6azYlMuu4+c5vC5bzh56QpbCovJLd/NvOUrWbtlO5lr1jNz9ixGjBpObFwCI0aG4DXQB1c3d/r0daffwEEEhYwmKDSC+JSvmDBzCTOWrGHR+m1sLNrNtpIK1m3LI2PdeuYtX4GPrx/6unpIScmgqmdOhx7eeI9IZtKCjYybvoJBw+Jxcg/EwNKBMUnT6ejgit/wSPSN22Bs3h5pRX30TTth1qE3um174R4YjbicGhKKWqiYd0bDuj9att7o2g/GoEcgLdzG0NYnifb+0+gVvYL+aTn0T9+M36wChi/aReiyKqJWHyJmzRFi1x4lfv2x13O3zjJux3nG7ThP8vZzwp/14HWWqHVHCVm5j/DsQ8RsOEbKtrNM2HGe9LxLTMq/zIT8y6QVfs2k4m+YXHKNScXfvJVTttfQxsUfKWUNmjUVICEuj5i4DOISUkhKiApBS1RUtH74cbN38k+B6a/+3cfAz6fC2J8ZcjTC1v9ifAxsPXnyhPz8/I+GpTt37lBeXv7R6/9oQPD3379AQqIOKak6fvjh04Hp9+f/8HywP7Jnf/ToEadOneLcuXN/usfz5/WDmnV1Xz/YN61DMLwOwWkQFIGocR0eXh8ulXwfbD169IgjR65iZfUAgQDU1V+xZ8+TfwwMysrK+Oabb/4RW/l38+zZs/8IbB0+/AQvr18QEam/FgoKdYwf/4KvvnqCmHQ92AsE0MH2JVeu/LOq1qNHj9i3bx/ffPON8Hjp0qX4+fl91vtBeXk5Dg4Ov4OtrKwsDAwM+Prrr7lz5w5dunQhJibms+79/zUaYes/FP82bEk0FX0rlcUlkW0iQEzTgF5jF5GwppywjHwil+8iasVuIpbvJnzZLiKW7yZ0cQkjFxQSPHsnQ6bmMGjCajyTVwhhy3HEFDr7JdNpYDTtPUbRqncghnae6HTohapFZ9SN26KgZYyMmgYyqiq0MrXAo183YuICiRgTiXkLS9S1DBEIJJBXM0BOxQg1g9ZYdXVnyKgkrKydEJXRREmrftCxun5rVHRa1pcQKuohpW6OmnEHtFt0RsvchhYdndC3sMOmpxcOrr64DAzFtocXba0dUVLXRlNLD1U1LVp3tGZEeCRzMpYJe6825xWyfttONu3Mp2xvNduLSinYtYc9B4+wtaC4HoSy15CZvYZ5ixazZMVKomPiSJ2Qhn9AEP4BQYwYGcJA70EMGuxLv/6e9PcejNdgf4aFRDB5+nxK9x5m/7EzVB05xd6jtVQdrqFwdyUFu/awdPVaps6Zz4Yt24mMjmJU6EgCg4bi0W8A3Rx70Kt3Hzy8fPAdNpLRCcmkzpzPkuwtrNlaxPq8cjYV7iZz03ayN+8gv7yCybPmEps0jtaWbZGRkkZSUhoVXTM69vRhcEgKgWMm4B4Qj8eIFPziFzI6aQZO/YPp4tSfFlZ2GJvZIi5nSDtHL1o5eqNp2RtX3xhk1Y3R1jFAUs0M3Q6uaHb2RruzD0bdAzDuNZRW7hFYDRqL3ch5OEUtp2/KenxnFQh7tkKWVgoVqvj1x4SOg0lbzzBux3nG77zAuB3nScm9+FYmbD5F1LqjhGVVE7PhGGNzTjF+6xkm7DhPWu5FUvMuMbHgCulFV4XA9WaO33mexRVX6DE0AYGiPpLiEshKiiEuJoqohPRbylYjbDXC1v9CfAxsPXv2jLy8vI+Gpbt371JWVvbR6z9kox4a+hKBACZMeL+69SkDld9d22DPfvLkScrKyv7Qnv3FixecOnWKs2fPfvD8Bw78jK3tK+FDfP/+L8nMfIaG3hMEAhBpVofPkJf89NNf+7zvG2pcVXWQoKCfEQhAXLyOrKxn/xhs3bx5U3j8OW3l380zZ85w7Nixzwg1T/Dw+EV4HVRUXjFp0nN++KH+7+/cucO2bSWUlDzl6NF/DljfzaqqKq5duyY8XrRoEcHBwZ/tXvDs2TNatGjB2bNnfwdbdnZ2zJ8/X3hcVlaGoqIida9nejbGx0cjbP2H4t+GrXdTICKOmrkNofO2EbHuCLFZlYxauJOR83MJWVBC6OL6HL2kjFELixg2N4/AmdsZPGUTPqmrhLDlNGY23YalYeM7lg4+8bT1jKaV22hMegZh4uiDob07JjZ90G/viJZFB1RNWqKsaohApAk2tq0JCwsic+VSxMXFkVVUQVZRCzFZVRSV9ZFX1MPSthd9BgYjp2GCtLIB8kqGKGiYoqzdQghcMqomyKqZoqLbGk2jdqgbd6B15z6Yd+iJg6svfYeMpqNjf9rb90Hb0BJpaWUkJRVp1c6G9BlzmbtkOfOXrSRz/Sa2FhSTkZXNwhVZFOzaw9ot21m9Poc1G7eQsWIVq9ZtYsKkyUTFxZOSls7MufOIT0giMGgo3j6D8fULoI+LGx79BjDE1x9fvwCcPPozPDyGRZkbqDp8hgPHTlNcsZ89B2o4cOw0+SW72FlYyvJVa5k8YzaTZ81lbGoa4ZERDBriQ4+evehk3RnH7j3pP8CLgJGhRCanMmneUpZt3EluxX42F5aTV76XtdsL2JRbxIq160mfOo3UlEk4dO2BiooakpKSyMrKI6Oqh3WvwXgExDJgeDK9B0cTEDOTSUvzCRg9njZdXEmZthCjVp1Q0rSgZTsnPIfGY27bjx4DRqFr0hFVTSNEpBRRNu+Gnq0PGra+6NkNwah7ACa9h2HZP5qOfilYB8+kV/QK+qasx2PiJvxnFzJsYTkjMyoYs3K/UN1qULYSt5wmefs5xu+8wPidF0jNu8T4nRcYu+0siVtOM37neRI2n2LM6oOEZVUTt66GpE0nhcCVmndJqG41ANebOa3iJmO3nGTurq8ZkLoCaV1zmoqKICkhhoS0gtACvgG4JMTE38pG2GqMLx0fA1vPnz8nNzf3o2Hp3r17lJaW/iOwdeHCC5o2rUNFpY779z8vbN24cUP4wPumPfuZM2e4ffv2B7/HD8HW1asv8Pd/KTSyaNPmFaWl9T1Z9SpiAVevvuD27b/3ed8HWwcOHODhw0d89dVzoWITH/+CBw/+Wdh6Mz/VVv5TYevGjUfk5DwlP/8p9+799npFxROcnX9TrDQ0XjF9+nN+/PHt9T/99BNFRUVfDLIasrKykm+//VZ4PG/ePEaOHPnZ7gWJiYmMHTsW4HewJSsrS2VlpfD49u3bCAQCvv/++8+2///XaISt/1D827AlJSr2VnZw8yZ0zTHCs08xOXsfsZnVRK0sJuCrjYQuLGfkgkJGLSwiLKOUEfMLGDonl4CvtjFo8ka8U7IYMHa5ELZ6DJ9El4DxdBqSTMv+MbRxH42ZUyAmjt4Y2buja90X4y590bLqiq6VDVotWqKq0xolNUPMW6sxfPgQslYtQ0xcEkkZZSQUlJGVUUFZQRtpVX20W3ZEt2UnmktrIq9oUA9d6iYoaJgiq2qErLoxonJaKOm0QEWvFfoWdhi0tsfCxpl2Xd1x8AjAqqs7nbr3w7KjE6qquqiq6uI/PIz5S7PIyMpm/rKVZGRlk52zlQXLM5mTsYzsnK1sLShmyfJVzF+0jBEh4UxIn8YAbx8Chw1nkJ8/voFBjAmPxK2vB94+gxngORCnXs449XLGxbUvAYHBxE+cTE5BGcfOf0v1icvs2X+IfYdq2Lwjn+Wr1rIwYwUbcrYzfeY8lixfRUxyCiHhUQwdPoyu3ezp1btPvb17Xw9GjAwhLiWduSvXsHxTLgvXbWf77kp2lFWwcXsBmRu2sGTVGrI3bmTsuGQG9PVCS0MXOTkFpKSkkJNToLmcOt08htIvMA634PF4hUwkbtJS0udk0ctzOCkzltHOzhlFTRPEVQ0wa++IkYU9Ldv0wLyVLRrq+sjIqyGp1Qo9a0+0bIagaRuEoUMgLfuMoKVbCG0GxNB+yDjsRs7DcUwGvRKy8J624y3YGr1in3DeVuzaoyRtOknC5lqSt58TKlkN0PWmshWfc5LELbVErHnbLCNl21lSci8yIf8yEwuukFb49eserjey6AqTiq8yteQy6XnnGDhhMXIaWkg2b4q4hAwSEhJC2BITE0NKQvKtbIStxvjS0aDQ/F3Y2rlz59+GtIa8f//+J1nH/5GNekP6+NSrWwsW/N4i/caNG+zdu/dvf95Lly5RUVHBzp0737Jn/6vnqKk5TXr6DXwGvWT0mF+pqfmZ+/dfkJb2K1JS9dCjqlrHkiW/8PTpb+uePHny0f1xfwRbDQ/rO3Y8RU6ufm9391+4efPzgUFpaSk//vjjn77vY2zl383Tp09z/Pjxv/Te1aufISFTh4h4HU2a1aGm84rFi5/RvftvkKWr+4q5c5/z00/vP8ft27cpLi7+4rC1Z88evvvuO+HxzJkzCQsL+yz3gVOnTmFqasqzZ8+A38OWiIgIJ06cEB7/8ssvCAQCzp8//1n2//8cjbD1H4ovbZAh3qwpEuLyNGsqjlhzEaTFxRAXaYaYpgFOURMZs7yChHWHiF97kNjsauJWVhK9bDch8woYNHEdg6ZswP+rLQTO2kbgrG0EzNyK/1dbGDRlA/0mZOI+bjkusfWw5Rg2HdvgVGz8k2jnHUErt9GYu4zEpIc/hl29MejaDz1bVwxsnNFu1w0Ni3aom1kgr6GLpo4hJi2VWbt6Cd5ePghEpZCSVauf4ySnjriUMnKq+qhomyKvZoCkghZNJRWRVdFBQl4deTU9ZFUNkFbWQ1pZDzk1Q1RM26JsbIWycXta2fYlKGoCXsNjse3lTe9+wbS1tseyoz2RCanMWpjJtLkLyMjKZsmqNWSu38SmLTvZuqOARUtWsn7TNqZMnU54RBRx8YkMGuyLz6Ah9OvvKYQrVzd3evXug5NTb/r0ccXTaxADhwQQmTSBhZkbqDh6isPnrlBQdZDt5VVUHzrG9twilq3MZvO2POYvzmDi5CmkT51GWEQkfv6B9HXvR+/evRk4cCC+fkGMDI8lKmUKSzbtZH1+BYX7asirOkTpoWPk7a6ifP9hthWUkZ29lhkzZhIeHkmvXs6YmLdGS0MTeVkFxGRV0TJuhYyaPm27utK++0Ccg5IIm7CI2InzsXZwo11XN7z9wmhjZY+YvBqSijooaZmiYWCBpmFrFPVbo6RmhLisJnKtOqPcaQAaXXzQ7eaHfvcAjHqPoqV7FJbeY+kUPBnbkFl0j1qES9JKqzzc3gAAIABJREFUvNI34D+7kOGLdjFqyR7CM6uJyDpQP9x41UFi1rxplHHmtfnFBSF0NfRypeReZOy2s8RtOknMhuPEbjxB7MYTxGw4zrgd50jJvSA0zGhQut4ErrTCr4XK15TCi3glLUBCVRclWXGkJetNM6QlZZCXlkFBWgJFGUkUpCWQlxKv7+sSbU7zZmI0bybxHgD6fDD0+df/3fPXv68x/t34GNh68eIFubm5H7XuxYv6OV2fYh3/Z/1Phw/Xl8kZGNTx5MnvYauqquqD5/8je/YzZ8581DDmhw9fYNnhCc3k6xAE1CFqX0eTpnUoK9eDTvPmdcTF/fpe5epT+uOePHnCnTt3hGrRu7D16NEjjh17jLFxfeli69YvOXv28/Qe/VXYejf/yFb+Q+eqra3lxIkTf3rus2cfI9KsDsEkELwAwV0QeNUhEK2HLEPDV2RkPOPu3Q+f59atW5SUlHxx2KqoqOD69evC46lTpxIZGfmn/8cberD+KF+9ekWnTp0oKioSrnmfslVVVSU8/umnnxqVrc8UjbD1H4ovDVuioqI0FwiQaSqCtFgTBE2bo2jjiN/MHFLXnCFuzQFiVu8nacMRolftIzqzkvBluwhZVIzPpA30icvAfewKhkzZyJApG/GdugnfqZsYNGk9HqkrcRu7lD4xC+gVPofuo2fQZegEOgeMpb1PJK3dw2npFvJa3RqMkYMX+l3cMbJ1Q79jL3Tb2aNl0QntFlYo6Rpj0MoIjwGulJeX0sHOAXVtM2QUtGkmrkRzSRWaickiJauCnKIGMvJqNJdRQVyu/qeYrCrS0srIyqoiL6+OoqImzZX1UDFqS6cenvTyHEkX1yF4DY/Fw3c0vfsF072PJ/0HDWVYWBTJadNImTKdmQszWLRyFYszV7Miay3TZ85jQvo0UtOmEhQ8jIHeg/Aa6EMfFzf6uLjRvYcTPZ16vwYtV/r07YeLxwB6OLviPXIkiVNnsK6ohL1nznHk9AXK9h1iW1E524t3sXVHARMnTWfewqUkjZtI2pSpRMcnEBYRiafPINz69cetvxeunt4EhYwmIj6F5Wu3snT9NkoOHqdoXw05RRWszy9iQ0EhWZs2s62whG15RcydO5+oqBgcHXugr2+Ipo4hSgqKyErLIauig665FfYunti5+WLrGkhg1GSGxUyho2N/DFpZMzwkGiUlHVSV9ZBR1kTTsA1aRm2FpZvSmkaIymkgq2uJSnsPVG28hLBl0COwfpixR7QQtuzC5tA9ahG945fhmbaeIV/VOxKOzKggPLOa8MxqIlcdJDr7MDFrjhC17igxG44J1as3SwoberlSci8ybsd5YWlhwuZa4nNOvVbF6mdvJW8/y9htZ4Sw9a7alZp3qb5EMfciUwovMjBxHgIFXWQlxVCSEkdWUgIpaVmU5aRRkZdBRV4GJVmpRthqjC8eHwtbeXl5PH369KMg4FPndNXW1v5p/5OTUz1ArF37trr1ww8/vBe2nj59yvXr1zl27Ngf2rP/0do/y+XLf6GpXB2C62+4CibVzwXr1+8l5859GJj+Dmw9e/aMx48f8/DhQ+7fv8/du3e5c+cOd+7c4eLFi+8davztt49wdPxV2J9UXv7pfUgfC1tv5h/Zyl+/fv2tPq+/CltTpjynufE77o63690FExNfvFVS+KH88ccfKS0t/eKwtXv3br7//nvh8aRJk4iLi/vke8D9+/dp0qQJampqwhQIBCgpKZGRkQHU92wtWLBAuKa8vLyxZ+szRSNs/Yfi34At+eZiNBURQyClREevkURkVxC9vobktSeIza5mXM4xolftI2HdIcJX7CZiZQUjFhYyfEEB7gnLcAydRf+xK3FPWMaA5Ey8xq/Cc1wWbuOW4Zq0RAhbPcZ8hd2wiXQOGEuHQVG07R9Fa4/RtHQeilkPX0y7D8GgywCMbT0wse2LsbUz+u27o9/BAdWW7VE3bYOKrhbDRvqTmJKCtYMLnR3d6GDXG7M2tmgYtkJGVQ9RWTWaSCohIqGAQFQGUWllRCQUEJVQRFRCEUlZNZTVDdAxa4+mUTsMWnbBsKUDll37Yt3bm76DQ/EfmYh9D0/cvYIYHZtAXMp4ktOnMG3uAuYtXUHq1BlMnzmPOfMzSE2byoiQcPoP8KKbYw9cXPtiZ++AfdduOPVypotdV7o59sDVZQBu/X3wGTqS0MRkFm7YzJbde6g+fYb9tbUU79nLxh15rFi7gbVbtrNu41ZCx0QzKiySiOgEYhISGR4SioenF/0HeuM52IegsDFEpExm3trNrNtZwbbSavafukhuxQGKKw9TcbCGjNVr2LAzl6S0icxZsJDFGUsJChqKra0dWlo6qKlpoKqhi6y0DJLiUsiq6GDWsSuG7RywsPdgROJs+g4ehWmbrrTr4oJz/yAMzNuhrmlGEzEVNFp0wty2H2adPVAy6YJhBxfUjK2R0bVEvV0PNDt7o27rjUYXH3QcfDFyCsakTyit+8fS3jcV+5CZdItYgHPCctzHr8Z78iYGTd9JwJwiIXA19G3Frj1KzJojRKw5TNS6o8K5Ww2wlZp3SQhZb2by9nMkbK4lYXPt64HI9YpYA3Cl5L6tbjVAVkNZ4qTiqyTnXmBa8WV8J69BRtccseYiyEk2Q1q2HrJUFWRRVagHr0bYaowvHR8LW/n5+b8bwvtX89GjT5vTdfr0ac6cOfPB9xQX//za5vwVz5//9vrNmzeF6tSjR2/bs1dVVXH+/Pk/tGd/c+3fST+/lwgGvzOb6Zt6NeXMmQ/Py/oz2Hr27BlPnz59C7AePHjAgwcPePy4XqX67rvvhP1RR44c4c6dO9y7d++t/qh79x4REvKzUGkbPfoF7WxeIqNch03XXyksfPq3wKCkpOSTYevNfNNWvry8nMLCQqGt/IkTJzh58uQH4OgRq1Y9w8TkJQKzd67DY2jStI78/L/++928eZOysrIvDlu7du16a1B0amoqSUlJn3wPqKur4+bNm2+lQCCgsrKSp0+fApCZmYmRkRFXr17l7t272NvbN7oRfqZohK3/UHxp2BIRNEFGTAKBhBouY6YQtb6a8dnHSF5TTfjqfGJW7yduzQEiM6uIWb2f8Kw9hCwrI3R5OUNmbiVo6mYcR83EymccPcPm4BK1CLeYDPrGLsE1eSkuiRk4R88Xwpb98DRsA5PpMCgKqwHRWPYbg4XLcFo4+WPeIwBDu4GYdBmAmV1/zDr3xcimD7ode6Bj0wN9qx7IaWhiaKLJrAUL0DZth7ymKUo6LbDo1B3r3t506OlJ5z6D6OjkRYcuPVDVMUFeTQ8ZZW2hMYaOaUc0DK1Q0mmBgmYLFDRboWHQCW2LLlj39mZoRCoDfMcwdFQy1vau+AQGEzU2gZjkFJImTmLmwgzGT57G9JnzSJk4hbDwGAYO8qdDR2v6uLhh28Werg6OdOhojX3XbrS1ak8Xu64EBY5ifNo0Zi5byaayXew7c5mSfQcp31dNQVkZBaW72LBlO1NnzmH67HlExiQKlbPImESi4uIZHhLKsFEhhIwJJyohjikLF7Fg/VZyD5+m8uQ1Sg+eYdfhU5y48h2llYfIyS2oN8GY+RUBw4cTGRVD374e2NjYoqGhhaqqOpqa2sgpqiHeXAwJMUkUNQwws+mOeksbug0YiX/0DHyDwzG17IxBK2ssbZ2RUTVBXq0F6iY2dOgbjEf4DFxDp9DadRTdApJxcAnDyNoDNZs+aNp7otHFB027Qeg4+GLcayjmbmOwHBCH1eDx2Aybiv3oubiOzWTAxHV4pW/AZ9oO/F67EgbOLRb2bkWuOlg/6HjN4beGHCdsrn3LDn5C/uXflQY22MKP33mBpK31JhopuRdIyb1A0tYzjN12Vmgf36CONUDXlLzTpBVdJSXvEtOKL+MeOwc5NQ3kpZsiJy+Fspw0qgqyqMjLNMJWY/wr8bGwVVhYyOPHjz8Klh4/fvxJsHXmzBlOnz79wfc8f/6C9u1fvTaA+JUtW37hwYMXXL16lZKSkvfas//Zvh8DW7dvv6BTp1cI2r7zkF8OIk3ruHHjw+vfB1sNgPXoUb3ZRANgPXz4UAhd3333HTU1NW+pdDdu3Hiv4nX37l3hOebPf22c0QQEo+oQ5ECTwDpEmtVRWvrXgaSkpIRbt279Y+Bx69Ytoa18bm4upaWlb9nK37//iLy8p/j6/iIc6CzMnNfX4CUIYuuQVa7j9u2/vvfNmzcpLy//4rBVXl7+lulIcnIyKSkp/8h94Y/mbCkrKyMjI0NQUFDjnK3PFI2w9R+Kd+FKRrTpW/lnsPVXhxc3WFRLSUkhoaCLd/x8wtdWE7/2IHFrDhCbXS3MmNX7iV61j6isvYSv2EPY0l2MXFTC8AVFDJm5Bfdxy7EdmYbloGhs/RJxHDkJp6gFOEfPpVfkbHqGz6Rn+Ey6j5iEw9CJ9SYZgxNpPzCK1h5htHQbhUnvoRj39MfIcTCGXb0wsOuPcWd3jDu7Y2jtjF7HHqi2sMWktQ0qKmrMnD+NKctXIRDXpqmULBbt7dE2bIuheScMzDqiZ9IeS+tuqOqZo21iiYSiFqraLVHWNEde1RgZJQPkVLWRV9NDScMEdV0L1IzaYNy2Kz08AvEKjKW3hx82XV3o7epOQGAwickTiEscz7jUScyYNZ/09MmMGhWKl5c3ffq44mDfjc429lh16IJVJzs6d3bEsacrHt5++A4NYc6SleTkFXPw5FkOnjxLUeVejp2/SOWRGsr2H+DQydPMmL+IsWmTmTRzDrPmLSR96gwiYuKJikskNC6BhLRJTJw5m68WLyFzexGbS6o4eOZrDpy8RNnBY+Tt3kfhrv2UVRxkw7Z81m/bydylS4hITCAoaCjOzi60aWOFrq4+mpraaGhooaysipS4HCIiIohLy6CsboC6liFaZta4BMYREDsdz4AYXL1DSEhfgFl7B5Q1W6Kk2RJ9C1usHNzo4x1Kr4EhdHQejJFNH0xt+qHTuT9qdj5oOwRi0M0fg27+GHUPxNRpKGbukbTxScZ66BTsQubinLAcj5Rs+k9Yi1f6BgbP2IbPtC34z85l6IIi/GcXClWu0GVVjFlZSUTWXqJW7yc6u5rYtUcZm3OKiTsvMPk1XKUXXSW96Kqw92pC/mVhX1dK3iWSd5wnecd5xr12MWyArQbQejMbnAsbygvTCk4xMHk2UsoaaCmIIy8tgaKCHCoKsqjISCIhWW//LioqhuifwtbfzT+Do7+7/u/C2fuzMf7d+FjYanBj+xhY+tQ5XX8Ftl68eMGwYb8iEIEmcnU0laxDVuln5s2rpqio6L327H+WP/74I3v27PmLv+MLFi78BVXV1w/6InUIIuoQXARBCTQ3qsPT58/nZTV8V38FsK5evcqhQ4coKChgz549nD17ltu3b/P06dPfZYPq9eDBg7fA686dOxi3fFkPWvwGh0196ujh/NcH9/7TsPVmHjt2jOrqag4cOMiCBVV4e3+Lqupv1u2SknV4e//Ctm1PSUl9gUAAYuZ1NNeuo7lEHVu2/D3V7ocffmDXrl1fHLbeLc2Mj48nPT39X76DNManRiNs/Yfin4atBshqOBaIimMdGkfMpv2Myz5EwrpDQtiKWb2fqKy9RGXtJTKzioiVlULYGrW4lJGLSvCZnoNX2hrckhbTMSCZNgMisPKKwi44FYdRaXQLSad72GS6h02m27A0ugZPwNZ/HNZDkujoE0Ob/mOwcA/F1HkYJk4BmPTwxbibN0ZdPTHp0g9Dm77oW/fGyNYZM1tnTDs5oW7QEuPW5kxctJihCXMRiMogEDRDWdMUTX0L1HVboqJlhoKmEco6pihpmyCvYYiUgg6S8tpIyGkhIaeFtJIG0kpayCrro6BmgpJeK9SMrDCxcqSPVwg9PALp7jaI1h1sce7bj5DRUcQnpZCYPIGJk6YTFDQULy9vXF370qePK7Zd7LGxc6BDZwfa23bD3cePoVGxJEyZzqINmyipOsCu6iMcOnWOo2cuUnPmPNXHTnKk9izZOVtZsmoNC5ZnsjhzNdPnLWTilBkkpaSRkj6VWfMXM2nOIuatyCYrZwcl+w5TfeYiB05f5Px3P3Lk9CUO1p7jcO15inftZXnmOtZu2s74tCmEx8YyNCSELl3sMTQ0RkdHDx0dPaGyJS0ti0RzGZo1a4a4tAxyStrIqerTyqYP/jHT6NZ/GJ0cB+IVGI2maSdad3bCskNP1PXaYNTGHr3WtrS1c8O8oxOmNr3QtXJA1bwb6h3c0Ormi65jMEa9hmPUazjGvUdg5hKChWcclt5j6TJyBt0jFtM9ahGuYzPpl7qGgZM24jNtCwFz8hjy1fbXwFVG8PxShi0sJ3RZFSMzyghdtpvwzCoiV+0jPLMeuJI315K6/RypeZd+Z+neAF/pRVdJL/6GtKKrpL3+c0ruRRK3nCZxy+m3BiQ3ZEruxbd6uZJzLzCl6DyeMVMRSCmjqSSFhrwYqkqySEg1wlZjfPn4WNgqLi7m4cOHHwVLT58+/STYOnv2LLW1tR8ElN27v0fQpA5BxmsF4zGI+NWhofeS8vKKj9r3r8DW8+cv2L79F8zN61W1Jk3qCAh4ydSp11HX/Vk4L2vg4JfcufPh/Z49e8bDhw/Jzc3l22+/5d69e9y/f18IWA0uifv376egoIB9+/Zx8eJF7t27917A+lA+fvyYBw8ecO/ePaQV6hBs5m0lbilIKtWxadPTv+RaWFxc/Flh69Spx0RE/oyL+y+kpr7gm2/eBLuzREb+QMuWL4WAJSJSR/v2PxEff4q9e4+/ZSt/7Nhjpk59zpw5z/n6679vCHLjxo1/BbbeBdjo6GimTZv2L99BGuNToxG2/kPxT8OWaNNmNG8m+rpkTBwLFy9Cs8uIXH+YhKy9JK4/LDTFiMraS/SqfUSsrCRs6S5CMsoIX7GH0ct2E7qknJCMMvxn5+I1cS19k5bTY8ws7ALH0dojjI6eo+k4OJYugWPpNjyVbsNT6Ro8AbvAFDr7JWM9JAnrwXFYeUZg2W805i4jMOsdhJmTP6bdB2HSbSAGdh7o2fZFp3NvdDo7YdGtD5pWjrS0d0fTxIxBAf1ImLUOHXs31PQMEZdTQ05VF1kVHWSUtYWQJaOqh4quGZIKGkgqaCAhr46EvDricvUGGlIKOsipGCGvbY6WWUcsbJxx9hyFg5s/vT2H0aJdZ7p0dyYsPIbg4aHEJozDvb837u79GDDAix49nOjcuQstLdvQ3qYLfb19CYlN5KuFS1m+aQvZO/PJrz4oVLSqjpyg8vBxdlVVU1qxl9yiMop3VTJ3yXK2F5Uyfd5CZsxfxJQ5i5mzJIuZi1awcWcxuw6c4MDJixyqvczxC99y4utrnLh0lZrTF9l36Dj55RUUlO5me24Rs+csZMKEaYweE80Az4F0dXBEXV0TbW1dDA2N0dc3RF1dE0VFZSQlpRFrJoWoqChiUtJIyKgir2FOx16DcPWPxbKLK4OHJzFkRCJ6rbrQoqMj7WycUdZqRYuOPdC16Ixxazu0zDqiZtIOZWMrNC16otrOBTU7H/R7DMPUJQwz19G08ojEamA8bX2SsA5Mx3bEdHpEZuCcsJz+E9YycNJGhkzfiu/MHQTOzSdwbj5B8woImldC4NxiguaVMGxhOcMXlTBicSmjlpQTsnQXYcv3Ep5ZTdTqQ0RnH349a+uCEJDeHF48pfRbppZfZ0rZd0zb9T3Td99gWvn115bxtcRtOilUuhqyoTSxQd2aVnaDpG3nmVlyEbeo6chpaKGiII6SvATSioqNsNUYXzw+FrZKSkp48ODBR0HLs2fPPmlO17lz5zh16tRbr70JHvn5+Qwffo3mrV+9DQy36x/EFy2q+ah9b926RUVFPagdOPAzfdxfoqJTh03XV+Tm/sKhQz/TrdtvQ4m7d3/FkSP1PVlnzpzh1KnTXLz4gh9//PB382b/1b1796itraW8vJyioiIOHTrE0aNH2bNnj7AM8sqVKzx48OBvA9YfZSe7lzQJekPZqgOBax2CZvW/l5hYHU5OvzJ79nPOnHk/rBQXF3P79u3PAhmVlU8Ql66jebs6BKHQ3KDesn3q1OfY2/8qnE9W36P3kmnTnnP58uPPYiv/vvz+++/ZvXv3F4etd7/T8PBwZs2a9a/ePxrj06MRtv5D8U/DVjORpm/BVt+kNFLWHiF65UGi1u8ncf1h4tceFJYNjl62+61sgK2wpbsIXVJO8PxifKdtxSV+KT1Gz6FzwDjaDgjHorcfLd1GYOU5hs6+cdj6xWMflEqXgPFC2LIZEk87r0ja9B9DC9eRmDsHY94rALMegzF19MbQoT9G3QZg0NUNbVsndNt1pkVPH1r38kOnZVvGx/gQMSmD5LWlKBlb0ERcFgl5VaQU1ZFW0kBKWQcd0zZIq+giraKLlKI6kgpqiMup0FxGCVFpRcRkVZFS0EFBzQS9VtboW9SrNN1cA/EaloCH3xjadO5Od9d+ePn44T04gAEDh+AfNAI3N3fs7LrStm07bG3taNupE15+AaROm8WSNRvI3rCV0soD7Dtey+Hzlzh65iJ7j54kr7ySvPJKcgtKKS7bw4qstWSvy2HF2g1sLShm0cpVzJi/iJK9R1mVk8fugyfZXLCbQ7VXOHr2G05/fZPaKz9Q+/U37Dl8lJ2FpZRX7COvuIyyiiomTJxMyKgxBASMZIDnINq0bYeungFGRiYYGBihr2+Irq4+CgpKSEjUW5g3bypZPzNKShpRCUVUDNvh4htJd68Q2jv0xXdkMhbWfdA2t0HFoDWq2hao6Vqi16ozuhad0Ta2Qtu0HUp6rVA3tULJxB7Vdi5oO/ph3HsULfpFC9PCM452g5PpFjITm2FT6R6xGNexmXimrWfQ1M34fbWdwLn5+M/OZWRGGSMWl+I/u5CgeSUEzy8lcG4xwxeVMGxhMUMXFDF0QRHDFpYTsrSSiKwDRGcfJmpdDQmba4UlgQ1lhVNKv2Xqa8iaWn6d6btv8NWem8yuusX0Xd8Le7uStp55K5Nfq2VC2Cq4SnrhNdJyzzJ55zHsBocioyiLsrI0MkoKjbDVGF88fv7554+CrdLSUu7du/dR0PKpQ5HPnz/PiRMn3mvPfu3aNZ48eUJKyq+ItXunT+pu/QO5r+9VHj36eNg6evRnmkvU0dS9DkEWNBleV6+iCeof+lu0qIevN405/kiNe5/BxZvq1aNH9e53tbW1lJWVkZ+fT2FhIfn5+Rw6dIhvvvmGR48efTbQevr0KYWFzxFpWofI4DoEy6CpRx3NxOpITn6Kl9cL5OVfvdUD1arVS2JjX1Be/oT79z8/bNl2+xURzzoEr15fx6cgMP0NsDQ0fmbEiFscPfphF8WPsZV/X16/fp2KioovDltFRUXCnrRHjx4RGhrKvHnz/t0bSGN8cjTC1n8o/hS2REXfyr871FggaIaylCwCgSiW3VwIzyggcmU5sdn7iM6uFs7TisraK1S0GsDqzQxbuosRC4sZNj8f/5nb6D8hG+eEpXQdMZl2PnG09gjDuLsf5r2CaOseQkfPcDoNisV6cBw2Q+KxHhxHR58o2nmFY9kvlFZ9R9LGZQQtegZi3iMAU0c/jO37Y2TXDwNbd/Rs3NDp7IR5dw8suvfDoF132lq1YMPOXAKmrccvaR4CETHklDURaa6AorI+kkqaGLfuhJZRW5rL6CAqo4mYnDZNpdRpLquFoqYZKjotUddvjYaBJUp6bdA07YSmaSfaO3jgHzqW3v0C6dilN6YtO9Krlzsurv0YNNgXVzd3ejq5YNO5K+07dKZjpy44uXsyadZ8NuwoICevmM25xew5UMOeAzVUHTpO9bGT7CwpZ1n2OnYUl7Ekax3pM+Yyf2kWczNWMn/5Kpat2cim3CIyN2yhfP9hjp65yPlrN6g6coLj569w6tI3nLjwNYdrz3O09gKrNmwle9N2FixbxfwFi4iLT2R8ygT6D/Cis60dlm2s0NUzwMy8Ja1atcbCwhJDQ2OUlFSQlJRGUlIaCQkpJCSkkJKWR0JWGUUNAww7OBMYlY6jeyAevqPp2cMVbSs3Bg9PwLCVHQoapqjotETLqG09aBm3QVbLAlVzO+R1LJFv4YBKG2d07AbXOw96J9DKK452vuPoFDiBDkFTsBk+A4fR8+gRuYi+yWvpn7qRQVO24zcjj8EztjFsYTG+M3fgN2snA6dsw3dmPv6zCwmcWw9ZQfMKhArXiMW7GbVkD6HLqghbvpcxqw8Svb6GhM2nSNp6WlgGOLnkGlPLvhOqWu9C1/TdN5hS9h3jdpwjbtMJoTV8Qy9Xg5X8m+YbaYVfM2n7cSy7uqOupoSygghSUlKIiYnVj1b4KCD6J2HsU2GtEbb+F+NjYausrIy7d+9+NGx9zFDkBnv2yspK8vPz32vP3pDHj9eX7AmyXyszL0Aw9LeZShoadaSn/8oPP/z1/W/fvk1FRQXeg1/SzOkdC/FIaCpZx6JFv/xutte7sPVm/1UDXL0LWN9//z3Hjx+ntLSU0tJSTpw4wffff8+TJ0+Ew4ovXLjA3r17hYrN51S4Skuf0733SzQMXuHc91f27n0u/Gw//XSfwsKHREQ8w9z817fAS1HxFYMG/UJi4nEuX/4NDI4ff4zHgF9QUH+FaeuXLFjwnIcP3w8Vt28/Yt++Jyxd+oyIiJ9p0rQOQeE7ZY1TQV7jFaWlT6mpOc7p06f/Frj8VVv59+V3333Hnj17vjhsFRYWcufOHeHx8OHDWbx48b96/2iMT49G2PoPxT8PWyJIS8ohkFEnav4a4jLLCV9eSvzaaqKzq4lbc0BYOvhuyeCoxaWEZJQRklEmhK0RCwsJnpuLz5SN9EtdTZ+4DDoGpNJ6QCSWbiNp7TqCls5DMe0ZQIs+Q2njEUIHr3A6eIXTziscK88xWPYLxcJ9FFZuo2jVK5hWvYJp0TMQk64D3gIuXZvemDjPgFm8AAAgAElEQVS406aXN+YOHrRqY0mP7vZ4RU1hzOJCrBzdEYhIoaGui0AghpiCJk1l1JDXMEdaxRQ1PQv0zDpg2NL6rZ/q+q1R0DBFUddSmC079aJTD2/SZ68iYEQ85pZ22Ns70cfFAxfXvvTo2YuuDj2x7dINaxt7ejv3ZXh4DJNmzScnr5gtBaXkl1VSdeg4BeVVFO7ay9aCYtZv28mKtRvI2pDD8uyNpE2fQ0bmWmbMy2Bp9gaWrF5P/q4q9tWc4uzV65RUHWDPoWOcvHiVoj37ySuvpKTqAAW797K/5gQ7S8rJyS0gITWNceNTGT0mgoHegzAzb4mBoTEdO9nQvkMnrNp1wMLCEn19Q+TlFRETk0BcXBIpKZl66JKSR0ZeDVkVHZR1TNG06IZPSDIDAqPwGRaLoakVfUelMzRyIrqm7ZFRMURJyxxNwzZoGrZBWbsFMrptMbD2QMnMASljW1TaOGPQzR9TlzCs/CfSLiCNTkOnYDN8GnYhs+kaNpfuEQvpHbuUPgmr8Bi/Hu9JWxk8dQcBc/IInl/IiMWlBM2rdyQMnl9K0LwSRmZUMDKjjFFLyhm2sJjQZbsJWVopBK3RK/YxcnmVELhiNx4naeuZt0oBJ5d++1sJ4a7v+WrPzXqFa+//sXeeUVEd2gImNnovUqU3KRZARDqC0qVLUwFBwQII2EBAUBCwK/beFSz0JmA3Klhjb9EUk1ijMbm5Sa7f+0GYiIk3iSV5eY+91l7AmTkzw+A6az733t++z6Jjjyhq/lwAWlNL2ypkL1e42lXx7bCVvu8K2ev3o2FkjpyCKGJiYoiIiCAsLEyXLl06Yasz3nu8KWzt37//tYr0P5Ll5eV/CLaePfu1nv3YsWOcOnXqd88tKvqRD7q0iRC6ybxAQvYFhYXPsLP7StB6Jib2goSEn7h0qe2cCxf+zdj4n7B3/Q8pqT9y8+bLla37rFhxCnn1FwjNfeXDfy106/Hita/l4sWLAj35bwkunj17xp07dwQf/puamrhw4QJffvmlALBel0+ePOHGjRvvZHbrz8x4tUPL2bNfU1DwHBeXf9Ojxy8Vp65dX2Bv/yNTp/4LSbkXdHN6gdBGEJoBXUVfkJX9PefPf8OOHd8xY8b3BAT8gIHBT3Tt+oo9sAcILej4fncZ9Yuw4/Tp01y8ePGNIea/aeWfPHnyq/vfvXuXgwcP/uWwVVVVxePHjwU/R0VFsWrVqr/z8tEZ7yA6YesfFO8btqSkpBASEsbCN5qJGxqYsKySSeubSNt8lMT1h0nZeJSkdYcEoDV+VRPxyxsE9sHRi6uJXVLD2GX1P39fRcyiCiKLdhMyezvDMtYzNKWY/mHTMBoSRW/3GMy9x9DHZyyGg8MwdovA3DOK/r6x9PEfRx//cZj7JWDul0B/n/gOsGXoFISBY6AAuHQG+qA9yBfToeGYuIejZe1BbuZUXAPDGTl3J3m7T2Ng64uQkChaOn3o7+DJkIAofMPH4egZiamlMz01TVHV6YN0Tz2ke+q1QZaqIXKqhogo6CGv2YdevQdhOtCd3ja++IRPJHZiFuZWblhZ2WM90L5tZ5a3L336WtHfYiD9LQYSFBzOrHmL2bqngu37qqhsPERN0xHKapvYWlrO+m2l1DQfYu3WHazevI0NO0rYtHMvKzdso3DRcnZX1rNueyk7y2uo2H+Q2oPHqD/8IUdaz3P26i0Ot5yjrL6ZPTX7WbZ+CzvKqtmyu5S8BfNJn5VLWuYMYkbH4eDojImpOTaD7Bhka4/LYDccHJ2xsByAhoYmUlIySEhIISYm0SbGaK9qySghrdQLOTU9ZNUMcQoYw0CPCGzdw3APikXH3A6fCQXY+0SiYdBHAFs9NU2RVzNCQkkHOb1B6DqPQNMuHDFdG+TNhqDlGImR9wTMIrIZEFuAzdi52Ca0gZbDuIW4Ji/De9o6ArJ3Epq3l4iCcsLy9zF8TimR88oYu2I/41Y3E7OkgdjiRkErYXtFq72NMGHVoY657igTN50gacspkracYvKu80zbfVGgc5/5M3Dl7/+0Q2Vr3qGvmH/4PgsOf8XcA/eYUnL+52zfz/XL/Fa7Xj6z/Bozq2+RW3GdtOJSuqtqIiYmRrdu3TphqzP+snhT2GpsbOTBgwdvDFsVFRWvfd6HDx9y5cqV1+rZr127xpkzZ/7Q81y//j3FxT+wceMPPHjQ9tj79+/n0qXvSUj4CTGxFwKRhaPjT/QQfUH3QS8QmgI9TF8go/iCdev+TXz8T6ip/Sxg6ApCLnSsbKW8wND8Px2e+7vvvuP58+c8ffqUK1euUF1dTUtLC3fv3hVA182bNzuA5OXLl3n48OEbQ9CrVsKDBw++9WP+GcHGzZtfsmjRHdzc7qCk9IuwQkgbhH7sKNwQ6v4KVP2cGhr/YejQH0lJ+Z61a79j3Lh/003qBUIbQOhqW1Xrgy4v2LPn23cCW6/my1r5yspKjhw50kErf+fOHQ4dOvSXw1ZlZWUH+IuIiGD9+vV/6/WjM94+OmHrHxTvG7a6dv0ASQV1RuevJXJFLZNW15GyoZnEtc2k/jyrlbj2oGAuqx222loGqxk1v5zohZXELqkhakEF0QvLiV5Yzoi5ewjN30lgzja8p63BLi4Ph8gpmHnFoeUQioHrSPr7xmIytE2AYewWgZHnaIy9YjH2iqW3dxx9vcbQ2y1K0Epo5ByMoVOQoMJl7BiEnr0/fbxHYj4sCmWn0Vj0MeXC5Us4JuQQs/okOVsOoK5vSQ9ZXcSU9ZHT7ENva3ecfKKwcfZFTE4TeTUjxOW1kFTUEQCXjLI+YkoGSKn2RlG7H1qmdli5RTJiQg6OnpG4+Y7CwsIWM3MLBljbYGfviIWlDXb2Ltg7DCZhXBIZswvZUVbNtr2VlDccoKbpCJt27mXN5p3ML15NTuE8Vm7cQtGSZcxftpL5xaspXrOJPVUNzJ67mPnL17B6y0627qlgX10T+4+epPHYKeoOHedI63kOt5xjzdZdbN1Twez5S1iyZjUz8mYzJTuL2IkTsB44CEsra5ycB+Ps4spg1yEEBQ9nqLsnRsYmSEvLIiYmIahmSUhIISIihrS0LD17GaCmZ4aGYT8UtfswLHoymn1dsHDyx9jKDV0LF8IyVtDH0RdVbWOklHRRUDdGqZcJUkq6iMpromjsjJZzFCa+iYjrDULWxBUNuzBMhiXRZ1QedhOW4DxpBW6T1+CbvgHvaevwmb6ewOyt+GZsJWTWbkYUVRJZWCGobLW3CkYvru8AUxPWHhTo3+OW1TNx3TEmrjvGhLVHmbD2KElbTpG8tYWkLW0LkF+FrcyK6+TU3GZW3R1m199ldv1dig58QWHzPfIaPiG/4S65NbeYvuciSVtOkbL9DFNLP2La7ouC5cjt1bIZZVeZsfsc6WW3mVV9lci8FSgrK9OjR49O2OqMvyzeFLaam5u5f//+G8NWZWUl3377rQBK7t27x7lz52hoaKCuro4zZ868Vs9+/fp1Tp8+/UbP+/DhQxoaGgQ/37v3Pbm5P6Ki8nOL4bCXIOoHEOr/886pnw135uaPSUr6kW7CL+gS8AKhLfBB/As+6PKCHTt++JXg4uUK1hdffMHZs2epra2lvLyc8vJympubuXbtGk+ePHkvAHTnzh1aWlqorq6mqamJjz76iK+++up3q2V/Jh8+fMjly5c5cOAA1dXVnDhxgtu3b/Pw4WOamr7GwPhHhMa+Ugm82S60+JHRo//NggX/or7+Wz755NeQ8fXXz5g85XtEpdrgTF7lPyxf/p3g9tbWVi5duvReAOfRo0fcuHFDAMTNzc2cOHGCpqam3203fNdZXl7eYRF1aGgoW7Zs+XsvIJ3x1tEJW/+geFtBxu/BVg8RYXoPiSBlTT0pa2qZuLyGpDXNbTu01h0RfGAdt/owCasOMXZZvQC0ohdWMmr+PkGOnLeXqAVlRC0oI7JoN6H5Oxk2cyP+WRtwT16K09h8rCOnY+gRi6ZjKNq2nhi7BmPuE42ZTywGTsPRtQ9C2zYAPYdgjN0iBGnkGo7R4FAMnEPQcwxCzzEILVtfDF2CMfeIxMpvNCYeQWgZWBI1KhyfqCRGLqpmdvkFJhSsQ0ReBZmemigo6yKvZkR0Wi4eYQnYe4QhKq1BTyU9xOXUkVLURFyuTXUurayNrKouihq9UdXuh7KeJTZuwYSPmYKbfzRW1kMwMjbDxMQEa6tBDLC2w87RFVfvYUyaPoN120spr2umrHo/JXuq2LizlGXrNrJy4xb21tRTuLiY3KL5LFu3kdWbt7FoxTp2V9ZT03SEXWU1bNy1l7L6Zs5f/5jyhgPsq21g+fpNbCndS0lFNas2bWXJ6nUsWL6KzLwCxo2fyISJSYwYGYWpWR+cnAcz1N2TkOFh+PkH4u8fiL29I716aSEjI4eEhJQgpUWkkRKXo7uINNJK6miZ2GPtEoRhf1dk1c0Z7DWSfoO8sHTwxNLBHVXLYWQUrUNFwwhZBQ1klXWQU9FFVlkHCXkNeijpI29kj67LSMyCp2Hok4Kk0WD0HIIxDEjDMroI+3FL8Zy6Ed+MrfhmbcYncxO+WZsJ+HmJcVhhOWGF5YxaWEtYYTnhRRU/yzAaBf8mE9cfJ3njCRLWHWPizyKM5K2tJG4+Jfg+eWsrk7adJnlrK6k7zgoqUjN+3qeVWX6NnJeysP4ueTW3mVN3R6CIzyo7z9TNh5mwcj/xqw6TurmVKdvOMm3HedJ3ffSrfHkh8vQ9l3CKm0o3MTEkRIQR6irxF8PW28GZcHeRDtkJW/+MeFPYOnDgAF999dVbwdatW7c4deoU1dXVNDc3c/HiRe7fv/+77YU3btygtfXNjIKPHj3qAFvt+fTp93QXfYHQ3legYGGb8nzVqh+4evURjY2NfP/99xw58m9cPX5CTuUFFoN+Yteu734luHj27BnffPMN9+/f59KlSwKD4IkTJ7hy5YrAkvey3OObb755L5Wn58+fC+bA6urqaGho4Ny5c9y7d++NwOv+/ftcvHiRpqamDhW7V1//N998Q3r6v+ih/wKhf7/0vhaDhOwLHjz447Bx//4zrl79hsePOx5/n7DVEfq+5u7duxw9epSKigrq6upobW3toJV/n1lWVtYB8AIDA9mxY8ffev3ojLePTtj6B8X7hi0pNV3i520lYVkFycvKGF9cxfgVbUr3CWvb9Nnj1xwhYdUh4lceFFS12kCrnMii3UQUlhJZtJsRc/cQUVjKyHl7CZuzi8CcLfhkrcc3Yy0ek4pxn7QYp7H5WIWmoTckGg0bX1QHeKNp64+x+wgsQsZh5heLoedI9N0j0XUMRtcxGB2HIHQcgjBwDkHfKRh9p2AMXYajY+8ngC3rgDjU7IZhZh/CsCA/fIOCsA6dyph55Uxe1cRA3zjE5XshJdcLOWUDLJy96anfn5SseVjaeiEhp4WItApismqIyaohKqOKpJImUj21kFM1RFmzD1qmdvSz92HclHz8IicwyMkPTT0jjIzN6N/PGkurQbi4eRIyMppZcxewavMO9tU0Ut98lJr6g6zfvotte8rYuLOURSvXsGT1OhauWM2u8ipKKqrZsH03dQeOsbd6P+u2llBz4Ci7qxsoq2+mpLKO/UeOs6e6jt1VtSxZvY6lK9cyu3A+45PTSEhMIWZ0HB6e3tg7OBE3Jp6o6NH4BwQxPDQcV7ehDBgwkJ49VQSzWZKS0oKUlZBBXEwGEQlF1PX60N9+GJ7BYzG19mCQ23DMrNwx7j8Y0wEuKGoaI6ltw+ikTLr2kEZWsRcKavrIKusIYFVC1RAFw4HoOIVjHjyFQdEF6AyORb6/L70DJ2EdOx/XSavxy9xOyKzdDJ9TSnDeLoJm7yRo9k6Gz9lHeFEF4UUVRC+uZ9zqw23//n6exWrbrdXMxHXHSNnc1hbYXmmaWvoRaTvPCX6etvtihwXFmeXXBAuNp++5xJSSC6SXXCB73xVyyq+RW3Gd7H2XyCw9S+auVjK2nyB5QxPDpi3HO309WZW3SNnUQtqW00zZdpap28/9KtN2nhNUujL2XWFm+XnMhoYg1E0YKdG/WpDRCVv/H+OHH354I9g6ePAgX3zxxZ8652U9e1lZGUeOHOH69es8efLkTz3OzZs33xi2Hj9+TH19/W/epmX4AqGcV2aDol7g6PYfQVVs//79v7lguL2C1T7LdO/ePc6fP8/+/fupra2ltbWVTz755Ddhqr0ydPDgQQGMvQ/L4Mvg9cUXX3R4fadPn+bTTz99Lew9f/6cr776igsXLtDY2PiHzmnP27e/RV75Bd1s2uyGQikv6CL8gtzc5zx8+FCwP+xNgaWlpYXLly//ZRWm27dvc/jw4feilX9dPn36lLKysg7HfH192b179998BemMt41O2PoHxfuGLYfQBJJW1pC8Zj8pxXtIWFLB2KU1bYbB1QcFFYT4lQcZu+IA8csbBC2DI+buI7JoN2FzdhFeUCKArfCCEkJmbycodyvDZm7EJ30NQxIXMzhxEfZj8rEbnYtF6GRMvcai4xSOipUPqpZeqNv6oe8ahrlPDGbe0W1zXF7RmAwdgeHgMHTsA9C280fL1g9tO3907P3QdwrEZEgYA/xj0bfzRssiECPrQWzdsRETmyE4jc4hvKiCJTWXMezrSHcRFZRVDZHqqYWpjQt6fe2YnrcULVM7pJW0EJVRRUxWDXE5dcTk1RFX0EC6px6K6qYYWgxGy9QO68GBjEnJxSdoDH2tHdEzNsOwtwUWljYM8fAlKn48RUuWUVpVT3ldMzt2V7Bo6Wpyi+ZTuLiYaTNnMWfhEpav38TSNetZtWkrO/ZVsGrjdvYfPsGeqgaq9h9qMxhW1lFaVc/u6gYBlI0aO45pM2eRkjqNrOzZjBufTFj4KNyGuOPqNpSIyJHExo0lZnQckSNGMcwvAOPepsjKygvaBSUkpJCSkhGkmJgEPYQlkJDrhV4fZ+zdw/EJHYe5jRcBI5LoY+3JQOcA1PT7oWHYDyVdSwbYuSMsLI2MgibyqnpIKWoiJquGpEIvJHvqIq3VF/UBwzDxTcRyZAGDxy2ml9sY9DzGMDBuAZ5TNxKUU0JkYQWR88oYMb+cyHllhBftJaywnIi5lYQXVQgkGGNXHGDc6sMkbfiQydtOk7j+OEkbPiR1SwupO852sALOKLvaYQ9W+26t3Jrb5FTfEsDWjLKrTC39iPSSC0zfdZ70kgtM3XGWjF2nmbr5KNPWNTBhwS78Js1G0yGQyJz1JK09QsqmFlI3t5K25TRpW04zeeuZDpmy/QxTSi4I9nLNKLvC5M1HkNXrj6TE3w1TnbD1/yHeFLYOHTrEvXv3/ut9/vWvf71Wz15VVcWzZ8/eCJhu3rxJS0vLO4etpUt/oKvIC4QWglArCGW1zQaVl7e9R/fv3xcozV8VXHzzzTd8+umnnD59mtra2jeuHD1+/PhXlsFbt27x9OnT9wJe3377LV999VWHKlX736i99fHV9s7PP//8T1fDLl36jrDIH+mp+R/Mrf7DmjVtNsInT57w6NEjHj58KMg/C14tLS1cuXLlL4OtW7ducfTo0Q7H3pVW/nX59ddfU15e3uGYl5cX5eXlf/clpDPeMjph6x8U7xu2JszbwpjiapJWN5C0cDvxi8uJW1zF2GX1jFt9kPFrjvwmbLVVtfYSmr+ToNythMzeTnhBCaH5O/HP3oRf1kYCc7bgNWMtnlNX4pW6nKGpy7GPL8IpoRDbmBz6B6Zg5p2AvlMEvQb4otLPA3VLb3QGBWDsHEZf7xj6eEVj7hmFqftITIdGYuwaJqhwadsNQ8feD6PBIVgOi8HBPQAz+5FoDnCgr3UfyqursAxKIGhuBek7TzI6cSbKaqaICCsiKqmEbC8DeuqZYTXYj6jkmWgb9Udaqa3CJSqjiqicGmLy6kgp6SKv2hv9fs7I9TLHxHooGXNWEJ0wg4HO7mjq9aa32QAG2jjg5RvImMRJzCtewfodu1m5YRsLi1czIzufzLwCNuwoYdm6jSxcsZrCxcUsXrWWxavWkjd/ERu27yZv3hK2lpazc181ZfXNHDp1lrnFq1izdRcLV6xmfOoUpmTlEDwiiuiYsQSHRBAUHI6PbyD+AUFERY8mPSOTsPBI/AOCsLSyRk/fEFU1DSQkpBAXlxTMar0MW6LiYvQQlUJB3Rgzm2EM8R+NtqkDPXUsGTVuBh7+sbj7x6BhaIGe+UBUdPqha9gXSSl5xKVVkVXWQVxOHVEZVWR6aiOjrIu0pjkqFp6Y+E6gX2Q+npM3YB8/l17OI7COnY/XtE0E55Yyal41o5fWCoyCscV1xBY3EresiejFbRr39qrWy8uKE1YdYuK6Y0zedlrQFphVcV1gBWzXus/Z/ymzaj8mv+ETZtfd6QBf+Q2fMLPqJtn7rpC2tZXULS0kbfiQ8SsaiJtXSkRGMS4j0wgcm8yH178kd30V0zY0M2njKVI2tQig61e546xAojGl5ALTdraSWXWL6NmrERJ+13u2OmGrM34dbwpbhw8f5vPPP//V8W+//bYDdLxOz15bW8vTp0/fCJja2w/f5NwnT55QV1f3GjhsMxjK9mybDVLV+g/r1v2Lp0+f8vXXX/Po0SOOHz9OVVUVhw8f5sqVK1y/fp2TJ0/+qhXyXUDQy5XAqqoqjh49yo0bN97pAuNX88GDB4K/XVlZGZWVlRw7dqyDdv59ZLtg4/Hjxx3g64+A16lTp/5S2Lp58ybHjh177e1vo5X/b49ZWVnZ4diQIUOorq7+uy8hnfGW0Qlb/6B4W0HGq3DVXagHcmLCCHXrRm8nL+KL95G8tpZxy8tJWFbG6CVlxCyqIHZJDWOWNjBm+StZXMeY4jqiF1YSWbSXyIJSwvN3MXzWdoJzthIyqy0Dsjfim7EWn6z1+KSvwT15KYMTF+E0fj6O4+YxcHQelhHp9AtJxdhrDFpOYWjbBqHa3xMNC3d0B3qh4xyM0dAITL1G0dtjBKZDIzEZEoGxaxhGg0MxdAlG18EfPccATIeGY+kzGn3bAHqZOWHYfwDR0WEMix5PQMYqpm47yYzNx1Hv44SYuDRi0vJIKGgir2GMir4VLsOi8AqZgHE/V5TUTRGXVEdYShlRGVUk5DWQ6amNnLIeSr1MMLQYjLPvKPwiUwiLTkTXwAQ19V4MsnViiIcviVOmU7RkGctXbWTp8nVk5RSQOXMOU9OzKZi7iOkzcogfn0zRkmXkL1jMqk1bWbVpq2CWa9m6jVy4foszl6+Rv2Ax84pXkFs0nzkFRRQUziU+YTwTE5MJCAzF3mEwAYGhpKZNZ/r0WSQmpTE6dgyD7Gyxd3ZF39gUKxs7TPr0R05OAUlJaaSlZQXZbiMUFpZGVFIJNf1+mNp4Yu0Tg2dkCn3shqFn6oiq4UCsnP3RMLRARdsUdV0TpJV6ISGvhrRSL8QUlJCQVkahpwGSmmZIqxkjoWGGgrkbOq5RWITn4ThxMV4z1mI/Jh+TkGm4Ji8lJH83oxbVkbDqEOPXHBHA/dgVBwTVrIRVh0jd0kLyxhOCNsKkn6tZk7adJnXHWQFo5VTfagOr/Z9T0PQFeQ2fUdD0BQVNXzCn8R75+z9vy8ZPmFV3h8yqG8yovMms6qtM2nyE+OJaYuaXEZ61HO/xM5EzccRpeALf/wj89CPfAakrS0hcf7xDTlx3jKQNH5K88QSTNp0UzIi1v74pu88wfedliiou0T9sHCKSMoj2kES0mxgiPf63w9ebZWf8vfHjjz++EWwdOXKEzz77jO+//209+5UrV/6rGr62tpavv/76jYDp9u3bnDx58o3O/frrr6mtrX3t7d999x1ff/0Nn3zylCdPfq1of/LkCdeuXaO5uVkguWhoaOCjjz56r6r1dnPhsWPHOujd34VY4/nz5x0AubGxkQsXLvDZZ59x7do1QbXm6NGjgrbP9/V7/jfwevz48W+C18mTJ7l69epfClvHjx//Q/f9s1r51+Xjx48F1eD2dHZ2pqGh4e++hHTGW0YnbP2D4l3DVlehLkhJivKBnArx8zeQuLqWccsrmbCymrjFezvAVtySekYvre2QY5fVM3ZZPTGLqhgxdx/h+bsInb2D4JytBM3cgn/WBvwy2wDLa9oqPDPavronL8Vl4kKcxs/Hafx8bGLzGRidw4ARM+gXlExv77EYuI6k16AANAZ4o2HhjqqVJ5qDhmHgHEJvt3BMhkTQ2y1cAFtGg0MwcA7C0CUY06HhGA4JRd95OBbeUZi7eTFq1HA8/AMxdgkhvriWlHUHCE7KR1RWHWl5dYTFlZBW1EZMQQtVA0uc3CNw9RmJubU7sspGiMqoCqpcUoqaKKi2aeEVtPqi29eZ8enzSZg8C6eh/sgradDfYiDuXn5MzpxJwaKlzJ6zgJzZc8nOLSSvYCGZM/PImV1Idu4cklKmUrBoqUCQUbRkGSUV1VQ1HmDVpq1s3b2P/LkLWVi8kpl5hSRPnk5s3FgSkyYRHBKKu4cXQ919cBnszshRsczOK2LytEzixyczxNOHgJAwYsaOZ1hQKH7BYXj7B6Ou3gs5OQWkpGSQkZFDWloWSUlpxMQk6N5dEkUVHdT0+2Fg4YrTiCRS5m7Ad3QaIWOmMGJcBs4+I1A36I+ihhEKarpIKqgjqaCOTE9NekgrIaGkhZxmH2T0ByCj1RdJrX7Im7mi7RhB38AMnCYsxCd7IxEFu9pgO2oWEXPLCZ9b2aFiNWnTSQHAtEPM2BUHBLdP23lOUDlqF1xkV94gt+a2oJpV0PQFhc1fCiCrfWFx+9LiWQ2fklNzm9yaW+RUXmVaSQtJK6vwSsjBdUQqRi4R6Nn4EpOSw7UvntF6+BDwlIjUTEbPa/h5t9cv+XLVLXH9cSZuOsnETSdJ2tLCpG2nmbzrDJl7rzB9RwvTtjej1NuKDz4QpesH3RAV+98uzOiErX9ivClsHTp0iJaWltfq2X8v6+rq/jeQtjcAACAASURBVPSsVnt+/PHHnDhx4p3A1nffffdag+CzZ22Ci1dV9C8vEH727Jng9bwMmu8TvNr17q/C7aNHj/4U0Ny9e5eWlhbBXq//VpX7LU39n33ONwWv9r/L68Drr4at69ev8+GHH77Rub+nlX9dPnr0iOrq6g7HHBwcaG5u/rsvIZ3xltEJW/+geNewJSUhidAHQlj4jSRuTS2Jq/YzdkkVCcU1xC4sJ2bxPmIWVTB6cfVvwlbczxm1oIKIwj2Ezt5BSO42ArM3E5C1Cb/MNiGGT/oafDPW4j59FR5TVjA0aQmuSYtxmbiwbXYrvgjrmNlYR83EInw6fYIm0cd3HIZuo9B1HI6m9TBU+ruj0t8djQHe6NkH/gxYv6ShS7Age7uFYjJkOJa+cZgOjUTX3pO+Ds4MDwshfmIy9hGp+OduZvyiUnr1dUVcUhVpORXEpZWRUdJBTt0IdYP+mA1ww2ZICIYDPJBT0UVSoReiMqqIy6kjr6KPjLI+8pp96KlnhXvEBEaOzyA4cgJyygYY9+6Du5cf8cmpzJg9h6npOWTOnMOM7HySU9NJmzqD1CkZLF+1nklp08mYlU9O4Tw2l+xh6+59rN68jcLFxazduoPJmTOZnVfEkqUrKSxaSFT0GELDIvAd5o+dvSNBwcMJj4hidGwCEyamkD0zD9/hIQwd5s+YianMnruYwiWrKFi8krHJUwmIiMHOzkFQ3ZKXV0RaWhZxcUlERMQQEZFBUUUHZR1zdPs60897FJPmrMU/Jg1n31E4eEWiqN0PHdOBKGoYCapaUooaSCqoIyrbCxmdvsiZ2qNo4oKCsR0yBrYomruiYxeMZfA07OOLGDJtFf45O0hZd4CBsXMYnLqKuOXNjF9zhKQNH5Ky+RRpW1uZvO00qVtamLTpZJsAY9tppu44S9rWVtK2tgpmodoha2bVTWbVfkxe/V3m7P+U2fWfMqfxHnMP3m+DrubPKDzQVtHKrbvNrMorZO9uIW1NHaNmrcN9Qi59h42ml5Ub5o7DiEqeyZHTl8lfOI+79z7m3z98i2f0WHJ2HSFj5wVGL93fIdtbHSesPdpW7dp8iqQtLaRsP8PkXedJ2nKC9L2XmLzrDFN3ncF/8lx6SCrSrUtXPhAV/9vBqBO2/u/Fjz/+yLfffvu7kPKqnr2iooKjR4++Vs/+e1lfX8/jx4/fCJju3LnDhx9++EbnPn36lJqamg4VlHa4ellw0T5r9vIc0+9JK549a9vBdPLkScGOq/cNJO2w197KeODAAS5duvSbe7V+675vsoOr/ff8LZPk+wav9pa6l8Hr+PHjXL169S8xAr4tbL0KUK9q5c+fP8+9e/d+1W744MEDampqOhyzsbHhyJEjf/clpDPeMjph6x8U7xq2hHt0Q0JRgbiitYSvamD88jrGLqkiblEFsQvLGTGvhMii3YycV0bU/Kqf52d+ydGLqxm9uJqR88oIm1MqaB8MyNqEf+ZGvKevxmPKCjymrMBr2iqGTF2B++TlDElcjPOEBTiNn4/zhAXYjS1kYOwcQYXLMiIdy5AUzH0SMB4ajb5jKFoDfFDr545q36FoDfDB0GU4hi7DBbBl4BwkSEOXYPq6hGDuGIaR3XCMnQJQtnRBv7cB+dlT8QiLxz5pEWOXlhE1bREyctpISioip9gLcWlVxOV7IaGgibKOOZp9HDFzDERNxxQ5Fd22+S0ZVXpIKKPUywRZDTOcfUdh7uyHz4iJDPWLxsDEAQNDU9y9/AiLjiUlPZPESdPIyikgbWoWfoHhTMuYSXbuHMZNTCE9M5c1W7aTN38Rs+ctZF7xCo6fOc/U7FzSZmSTlV9IbNw4srJnEx4RRWjYSBwcnenTtz8jR0UzbvxEZucVMTExlajoMdg7DMYz0I8JaVPIyC1gzoKVLFm7jdTMfPIWriRmwmRCQ8PR1NRGSUlZUNkSF5dEWFgUWVkVFJS1UdXri5HVEALjM5m1tIQh/nGMnTATbXNH+tp5I69hjLaxJVKKGgLYEpNVQUrREMXetihauqNk7o5KH1cUejuj3G8oenZBWAakYReXh3fWJobN3EncogombzqKQ2IxkfOrBRWslM2nSNl8iqk7zgqAK3VLSxtg7TrPtJ3nmL7rPJnl10jfe1kwezWz6ia5NbfJq79LfsMn5DV8JmghzKm5Q97+j5lZc53UXadJ2HCEwBkrcR2TzcDAMegO8kSlnz3eMcnMXlXCppqTpGXP4uyl88BT0qaMJHlWJknLmxi/9kPCizYSW9zYIV+FrQkbTzDx53bCtJ3nmLbrPJnll5my+wIpOy8yo/QYFnaDERMRRUhE7G8Ho07Y+r8X/w22nj9//toP1cePH+fOnTtvBDzff/89DQ0NPHr06I3OvXv37p+GrXaD4KNHj6ioqODSpUvcv39f0B74/PlzPv/8c86ePUt9fX2HXV9vomNv33HV/t61g837BK/fqlZduHCBy5cvv7eK1KtikJdn9N7njNeDBw8EUo+qqio+/vhjHj58yKNHj97KbPhH8tq1a5w4ceKdPma7Vv706dPU1dX9SivfLmd5+RwrKytOnDjxd19COuMtoxO2/kHx52Hr10KMHt26071rN7p16Uq3Ht0xGhrJuJUNJKyoZ2xxNWOWVhG7uILRi8qJmrePyIJSIgtKGTV3L9ELK4lbWkvskhqiF1YSs6jqJRPhXsLydgoqW/6ZG/FNX4f3tDV4TF6Je9oKfKevwSNtOe6py3BLXoLLxIW4TFyIQ8Jc7GPzsBs9G5uoHCwjZjAgbDr9AiZh7jMOA9eRaDsOR9PWH40BnqhbuKExwJte1j7o2Ppj6BSCoVMQBo6BGDgGou8QgKFTEL0HD8fYJQQ9e3/0rb1Q7W1N34G2nGg5isOIFPzTV5K+qRlrz1AkFVQRllFBUlELMSkVpOR6IdtTn569+qJr7oShlQvymmbIqBghpaiPpKIOUkq6qGibo2VkhX4fWwZ7j8AnOB7zAV7oG1pg6+hC2IgoRkSNJS5+IqlTMkhKmcqIqDjGp04hccp0svILyZ5TxPjUKazbtpPFq9Yya+4CsooKWLhqJfGJiUTFxjF+XDKhwyMJ8PPHydEeiwG2BIeOIGd2IdMyZhIxKgbPYYGMS00nq2Ax6bPnM2/5BoqK11G4dC2L12xl695aNpVWsXJzKWkZOfS1skFBsScSEhKIioojLCZNVxEppBQ1UNAwQFm7L+Y2PgwOHo+FayhafZ3wH5lIbHIWA539UNYyQVFFD3FpVaRlFJGRVkRCrhcyBrYo9XFDw9oXNethKPX3RMXKBzXrYeg5hWIWlIrVyCzckpcQmL2ZUQsrSdl8nPiVjQxOXcGY5c1M2nSStK2tZO65xNTSC0wtvUDK9tOk7TzLlJLzTNv9ETPKrpBZfpWMfZeZWXWDzPKrZFVcI2vfFbL2XRHMbM3df5eiupuk72wlq+QsU7YcJjRzBcMmZNHfOww731CGj5nI1Nx8itdvZMX6FeQX5rKkuJCTJ5vgp6ds3rUCj5GjmDBnM6MXVxKzqIJR8/cRvbCcqAVlbcu8F9cxtriJ2OJGxixvZsLaoyRvPCGYKXt52XH63ssCFX3q9vPELytBWEUDMaEPBIDSvbvwW0NOl67dERYRQ0iobXmyUFdhunUXo6ekIqoKSvQQEaZHN2G6dRGme7f3B3qd8ffGq22EL0sZXp3TeRle2vXkbwpb+/fv/68zXb8HW8ePH/9DgPX8+XPBh9n2FsGXW/Campo4ePAg1dXVglmldw0K7RD0Mni9rvr0LvLrr7/mxo0bHDx4UDBXVltby9mzZ/nyyy/fGwQ9f/5cUP18GVjflVzj0aNHXLlyRbA8+dSpU4LdXm8j2PizefXqVU6ePPneYO7p06e/0sofOXKE6urqDlr5vn370tra+ndfQjrjLaMTtv5B8a5gqz27yigzbsFOYpdUEb+0UgBaMQvLiF6wj5FFe4iYU0LEnBJGFLZVuNohK3phJdELKxk5r4zIor2EF+wWyDECsjbhN2MDvunr8Jq6Gve0FQxNXY5r0mJck9qqWu1fnScswD6+CLvRswWwZRWZiUX4dPqFpNI/KBlz37EYDo1C1zkMLVs/NAZ4otxvKCr93VG38kJ7kF8H0NKz98fAMRAj52AMnYLQs/fHdMhwjGw90O8/kP4DB/LZjQvEz1rO6JUHSVi0h/4WQ1GQ00JGRhVRWXXEpVWRlNdESkkXBS1zjK1d0TSxQV7dBJmehsgo6yOlpIuMsj4K6sbomA6kl+FA/MMmMNgrCl39fpj1s8TbL5DQiBiCQ0cwesx4YuLGETFyNIlTppOSnklWfiHTc2aTnpvHopVr2kArv5CUjHRGxcWxqHgZY+PHERE+isGuQxhoZ4+bhydx8RMJi4xm+ar1TMuYiZ3TYEbHTyAlI5cNuyrYV3+Y3TUH2Ft3iFVbdlNa3Uz9kVb2HztDWcMRNpWUM9jTDzVNHWRk5REVFaebsAQ9xGVR7GWIQi8jVAwG0NcxCP+YNCxdgwiKSsbKwQdlvf4Y9nVEQ78v4tKqiIgrIC2jiLCYLBLKRiiYDUbV0gst2xA07cPQtB+OjlM4us4RGA+NxtgviQGjshkyaSkhuduIWlTFmOUNpJecIXJeGf45u0hcf5wp288wY/dFppZeIH3vJabvuUjGvssdvs8sv8rMqhtkVVxjRtkVsiquMbP6Y3Jr75JdeYPssqvk7LlA0so6vBKLcB2TjY1nOPOXryEzO42F86ZzoWU/Ny4c4tq5A7QeLOPh3RZOn6hm05blBIT64hEUSnTGRobPqcUtr2133Mh5ewUrDsILSohaUEHMwhqiF9QSs6SBuGVNgkXL7S2E7bDVvuC4fe/WlJILTC85gUN4PB90l6JHDxGEhUXp1u0d7OAS6oZYd1GEhUXboKtbV7oKdcFMSR07TT269/gAoe4f0KWHMN27dla2/q/GDz/8wJdffvmbevbnz5+/FmROnjzJ7du33xi2GhsbefDgwRud+8knn3Ds2LHXAlb7nM/LLYLtFaynT58KZB6VlZU0NDTQ2NgomJ+5fv36e7X9ffPNN3zyySe0tLQIqoWXLl3iwYMHb/W4r5oLjx07JjAXvly1q6uro76+/q0WGv9R8Grfy9XU1ERNTc1rFx//EcBqB+KXAeu/vcd/RrDxZ/PKlSucOnXqvcHWq/ngwQMuXLhARUWFQCu/dOlSLC0tOX/+/N99CemMt4xO2PoHxdvCVo9u3RHu3gORHsKI9BDG0ncUSasbGL24kviFuwWgFTV/L6Pm7SGyoJSwvJ2E5e1sg67CPYyYu4+oBRWCRcYj5u4jvGA3ofltUNYOW77p6/CZvhbPKasYmrqcISnL8Jy8Ap9pqxmcuEhgI2xvI7SNmYVtzCxsonIYMCILyxEZ9AudjEVoKn0DxtPb+xfg0nEIQmOAN2qWnqhZeqIxwBsd22Ho2vmh7xDQAbzaU8lqKKZDgunv6odBXxuMdVS5cP0WE+asJn3LIQb5JqCgZkJPpV50l1RGQrZnW3ucgiZSqgbIa5tjaOGMur4lMj0NkVUxEMCWvJoRcupGGPRxQt/MieGj0uhtOhBNXQMsB9ri5RuMX2AoYZHRhEVGEzFyNPHJqUzJymH2vIVMzc4lt2g+mXkF5BTOY3LmTGLi40lMScXPLwAfL1883T3oZzUA28FujJs8lezcOcycVcCqtZsw7WOJSZ/+TE7PYnNpBau27Kbx+FlqD52i6cNz1B46xb76wzR9eI6mD89x4OQFmk+cZ+OuMswsByGrpIqIiBgfdBNFVEoBRR0TFHT6oNXHBSu3SNwCRmPjFoytayCahv3RNrPF1MoVWRU9ZBQ0ERaTRVJKHhFpFaS1rVDu74W6dQCaDuFouYxE03kE+kNHY+gRh6nvOPoOn4JdXB7OExbgNXU1IfklxC2rJ2nDETJKzxKQW8KI+dVM23mOGbsvklVxjZzqm2Tsu8y03R8Jvk4pOc/0PRfJrrwuqHJN33OR9NKPyCw9y8xdJxm/aA8OEdOxD4xnYlY+tYePcunKSaZOH88QTzssrI1x9/bB3sUNW1cP3P1D8Bs7FZvgcfhPXohtTDb2UzbhmrqDCcsbicpfQ8js7YTM3k7AzM0Ez9pGaP5ORszdR/SCamIW1hG1qI7RS/f/0kq4+dTPYozzv+jff4auGWVtr3ny7o+YueMo4tp9EBYWpWvX7u8EckRExOgi1BXx7qIIC3XFWUWPwuAYZgxyJ9fWAwslVSS6fICIpCjduryb5+yErf998eOPP3L06NHf1LP/tzx16hS3bt16Y9hqamri/v37b3Tup59+ytGjR38TsH5LcPH48WOBVa9doX7t2rUOEotnz9qW1bar3f9K8Gptbe0gqfij4PUmO7leXmj88u6s9612f/Dgwa8WN9++fZtnz349A/cyYFVVVf0hwPo98Ppvgo0/m5cvX6alpeUvg61nz57xxRdfsH//fkFlNjQ0FHFxcfT09Jg+fTr37t37uy8lnfGG0Qlb/6B4V7AlKiyCqLAIIzKLiV1SRcyiCiYs3s3oReVEL9jHqHl7GDl3NxFzSgidvYPQ2TsIz99F2JxSwgt+qXC1V7XC5pQyPG8XkQVtc1svtxC2w5bbpGKGphTjPGEBHmnLBbDlNH4+dmMLGRSdi23MLAZF52I9MhuLUTPoFz6FfmGpmAeMw9g7HkOPWPTdRqI/OAI9+0C0B/kJoEtjgCdaNj7oOwRg7BIiqHC1V7mUbTzRtPPGzGkYVoP9UO49ABM9da6fP0Hi/M3kV7SgZGqDnJIKotIaiEkrIiGvhriCBuLK2shqmqKo3Qft3jYoqpsir2aEdE89xOW1kFDQRlpFn55a/bB3C8XVOxoHJ29UNLSwsB5Efys7hnj44h8URkjYSKJjE0iYlMbkzJlMzc5l0co1FCxayqTpM4idkMTo8Ynk5OUTFDycsLAIhrq507ePGXZOzkyakUXW/EXkFcwnLn4igSERzFtYzCAHZ+LGJbJ49SZqD52iqvlDGo6e5uiZK1z/7BGHWi7SevljDp76iNbLH1N79DSVTcdZvHoTkgptsCXURRgxaUV69R6AmtFA9Ad4Yu4UitkgT0ys3bB29MbAzBozm6FoGQ9EUlELYXElxMXlEROXQUZZFzkDB3oNCmirZrlGoe8+Bm2XaIw9EzAflohFUCpWkRm4jJ+La9JifNPX4TdzK1GLqoheXE3ShiPMa/yMwFmlxC1rIqP0I7IrrzO77mNya24xs+oGM6tudACvlO2nmVJyXnB8xo6TTFpeic/4WVj5xRGWMJOsOYs4eGg/udnJWA+wZJCTH/pWw+ntmIiZbxK2o2ZhGZHLgOi5OMQWYhM1B5cJxXimrWf4zI24pc7FJnEBAfnV+GVtxC9rI97paxmWuYGg3K0Ez9pBRME+ohfUMmphW3Vr7IoDjF9zhImbTpK8tZW0neeYUnJBIMqYvucSGfuutIFj2W1yyy4QnFaAomLPdwY5Qt260E1EFIkPhLFQNyBxoBspls6kDxhMhLoeGc4+aHcTQUS0G126de2Erf+j8aY2wpaWFm7evPnGsNXc3MxXX331xpWtI0eOdACslwUX33zzDQ8ePODSpUuCD+zttsQ/shy4vfrVDl5/xX6rdv16O3g1Njby0Ucf/Uo68SqItLdz/ha0/JHnbK8+NTY2UlNTQ2trK5988skbgc0fzXb4PXLkiKAKd+XKlQ5/r5MnT3Lnzp13+jpeJ9j4s+B16dIlWltb/1LYunfvHo2NjR2O6ejoUFpaSkZGxjuBrbt37+Lv74+kpCQyMjIMHz68w+3Lly9HTU0NcXFxhg0bxsOHD9/6OTujE7b+UfG2ggwREREkugsh9IEQ5i4eRM/by5jFlcQuLCduUQVxSyqJWVjWBloFuwjL30Fo3nZC87YTPmcnw/N2MDxvB2FzdhFRWEpQ7nbCC3YTMnsnEYV7BIIM/8yN+Exfi/fU1XikrWBoyjKGTCrGLbnNQjg4cRFuE+bjNLYAl4QiHOLycYiZjV1ULg4xs7EZkY115HQsw6bQLySVvsEpmPklY+ozgd4eYzAaEoX+4Ah0HYPRsvFBy9qDXtY+9LL2QXuQH/oOQejZB6LvEIS+QxAGjsEYOYVi5DwcfUc/tG09MRzkjJy2AfomxpTtKyFt6Q6mrdyBuG4fxOV7ISqpjISMGt3EFZFS1ERcTgdZVWMUtfsgr22OrKousqq6SCppIq6ggZSaLvJaRmibD8BskAs2boFoaumhb2CEvrkFg+xd8PD2JyA4nMCQCBInTSEjaxbpmbnMnFVA5qxZJE2eTOjIkfiFhBA6Ipohnj7Y2NhgoK/LgIGuTJ6WzfrN20hMSSUkKAyPwGCWbNhGWcMRitdvxC80gjHjk1ixegPHT57jw9YLHDhxmtYrN/jwwlWOnLnIhxeuUnfkJLWHT7C7tomqA8eImZiKtLQ0XbsII69mhGpva6yHhOERmsSknEV4B8fi4hWOcX9nlLX7MmBwIAZ97ZCQVka4hzjC4lL0kFZGVssCJRN3VGwC0B48En33WAy9EzDxTaRvUBoWkelYjJqBU2w+ruPn4Za8CJ/0VQTO2kFscR1jV+xn3OpmsvddIWvvZYJm72b8miNkV15nVu1tcqpvklN9kzk1d8gouUjWniuk7/qIyTtambbzHCmbTzFj1wWGJOdjFZCMmeNwUrPns2VHCZvWr2BMXBT6JsZoWrqhOdAbbcfh6LiOwtQ7jr6BSViETsZ6ZCa2Ywqwjy8S/MfA0NTVeE1dj9fU9fimbxL8Z4LP9LX4TF+L1/R1+GdvIWxOKSPm7hPAVtyyprb9YGsOM3HTCVK2nyZ1xxmStrSQvLWVybvOM233RbL2XmZm2VXBMmUDF1+EhYUREvrzlabuPdpaEHt80L2tUtWtOyJdxXDpPZBkWzcyHL1wVNNErWtXbKQUaQ4eQ6KVHXIiovToLk43oS6IdhOhe9ce76y61glbf3/89NNPbwRbra2t3Lhx441h68CBA3z55Zd/+P7tgotnz57x6aefUllZKWhLe/bsmaBi8zI4vEnb2m+B18v7rf4q8Prss88E0omGhgYOHz4s2NPU3ub5roGoXTrxajvp+wKvx48fc+nSJRoaGgSzZY2NjX+ZUv63wOuPCDYuXbrE6dOn/1LY+uyzz2hqaupwrFevXnz88cfv5Drwww8/oK+vT15eHt988w0//PBDh3mwpqYm5OTkBL93cHAwAQEB7+S5/79HJ2z9g+JtYat7ty6Ii3RFSEyGyIz5jF1SxegFZQL7YHtla0RRKZGFJYTmbSdk1laCc7cQnLuFwJy2DJm9ndD8nQTP2sHwvF0Mz9tFaH7Jr2DLZ9oaAWwNTVnWAbac4wtxji/EJaEIp7EFOMfNwT56FvbRsxg0ciYDR6RjFT71F9gKSsU8MBmzYeMx9Y7D2CMGA9dI9ByD0LEdhuZAXwFwadkME8CWoVMIRs7DBbBl4OSPrr03iiY2aPSxQUXPCD0jQ+qrNpGxdAX+k+djZjMMVV1TuoopoKCsi7C4EhLSvZCQ00JaRR+5Xr1R0DBAWlkbMXl1xBU0kFDshVRPLRQ0DFDTM8PCzgt9Y0uk5XqioWOAWV8rBtm74DTYneDQEcSOncCEpDRSJqczNT2b0WPjmTR5ClMzZhCXMA4PHz9cBrvR28QMewcn8ovmMi5xIokpk3DzcEdbxwCPoBCyChdS2XCU6gOHcPbwJmB4BPmFC1izfhtLVqxj/9GTnLx4lXM37nL106+4+ulXnLn2MScvXufImYs0nThDw7EWpGUUkJXriYKGKYbWrvR1DMDRNw5n/ygGOvvh7h9FT622yp6F4zB6avWhq6giXbpL0VVcCREFHZRMnFCx8EXTORK9oaMx8IrHLCiV/iHTsIyYgXVMLrbxc3CdsIihKcvwnLIK/+xN+OdsY8T8cmKL60hY1TbrlLnnEvk1t4ktbiSz/Cp59XfIb7jLrNrbFNTdIaf8GjPLrpJecoHEDaeYuuM041dU4DOlCOPB4QwNTyAjv4gbn9ygID+d8MgIDPo7IKc3CLW+zqhbeaBpH4z24JGYesdh7j+RvsEpWEVmMChuDvbxRdjHF7W1vCYtYWjqcoamLsdzyqoO0hf3tBV4TluLX9ZmQvNL2pZ7z6ti5IIaohbVEb24nlFLG4hbdZCEdUcZv+E449YfZ/yGD0ne2krqjrNklH5E5p5L5FZcJ6/6FkmrG+iirIuytMyfhhqx7qJ06dqdLiIidBMTo6uwDP1ldch2CWKkWT+clLXQkZBCTUaKXt1FCJNVZ4HncKIHOKGvro1UdzHEurU9Vpceby/o6ISt/x3xprB15swZrl+//sawdfDgQb744ovfBazfElw8ffpUoGavr6+nsrKSyspKamtrOXPmDJ9//vl7aYl7FbyOHTvGzZs3/1C17M9m++/X2NhIVVUVjY2NVFdXs3//fi5cuMBXX331Xtv+Hj58+Ku2vzetoL2cT5484erVq4KdZS8/7rNnv6jpq6qqBCKRt51n+6Pw9fXXX3cAr9cJNi5evPiXw9ann35Kc3Nzh2Oqqqp8+umn7+Q6sGbNGgYOHPja2yMjI5k0aZLg5+vXr9O1a1cePXr0Tp7//3N0wtY/KN5a/d5VCGHh7mjbuBG/rIKY+ftIKK5h7JIqYhf+0kL4MmwFztwkWE7sn72JYZkbGJa5Ab+sjYTmlxAyeyfhBbsZnrdLsNQ4aOaWNkHG9LV4Tl6Je+py3FOXd4Atp7EFDB43F6exBTjE5eMypgDbUTltoBWZhVX4VCxCJ9MnaFIbZIWkYRY0CbOAiZgNi8fYa4xghkvXMRgdW3+0bIa1LUEe4I32ID907QIEwGXoOBwj5+EYOgeg7+iLvlMwav1dkdM1Q05NByNNJUrK9lK4cSd5a8pYsmEHJlYOdOkhi6SkCmISyohKKiMm9+lizgAAIABJREFUq4ZkTy1kVHSQ6qklAC1RGVUk5DWQ6amNgpo+2kaDMLF0Q1ZZBwUFJTR1DDExt8BigC3ew4KIiRtH5KhYokbHMyN7NklJk0hMTMbX148hQ9yxt7dH38AIa1sH0qZnEpcQT3LaZEz7WJIyOZ2gsEhy5i2g5eINauqO0nD0ODHjJmJs3p8xCYlk5xayYWsJ+QuL2VPXyMGW85y9fofWK7c4c+1jLn78OZfu3ONgy3kOnDrHiJgxCAmJ0sfWC1M7Dwa4hTIkeAIGA9wY6jcKeXUT9M3t0TEZhHZvG5S1+yKjYoS0ij7S6n2Q0bJGub8XKv/D3nlHVXVgbf9G6VV677333nvvXRBUEFCxgCgWimLvvffeGyhiB1QQC/ZuEpPJJJM2mSSTvN/MfJnf98f1ngGTzMREk8n3utfai9zLujkXuZx1fufZ+3l8MzGPGoJd8kgcMqtxK6jHd/AMfItnETxiIVHjVhI5egVpddvImr6btOm7yJ61j8JFTQxfe5bKrZeE/KzGpsfUH7pPxZYu6o4+ZPbp95l16j1mtTxmVstjph65S83uq0zaepEhs7YTV16HtlMAuw6dZPPOrbz73n0qhg8mOSkBYwdPNK39MXWPRd8lVIAt88giHBJKcEqtwDljLO55E/EeMp2A0jkEls0V7xWOXkxU1XKiqpYTO34VcePXEF21kqjKFURXrSSuZj0pdVvJmbmX/LkHyZ/fTMGCYwxaeJzCRS0Urz7HsLVtlK5rZ9jaNkrWtDFsbTsjngceV+8QK3NT9t+hsekxDUeekDp5GSKR1MvD1lsySMnJI5KWRkEkjbWSDqNDEyh28MRNTRtbVS1sdA2QE4nQkVNEVak/RvJyRBhbMyExl4KoFMwG6CIj6vdK3BDfwNZ/R/1c2Lpx4wYPHz782bDV3t7Ohx9++KOA9WMGF1991Tfj6ezZs1y/fp1r165x6tQpwfzhdbruffPNvxz/ehtS/BLw+utf/8qf/vQnbt26xenTp39wl0pidNHT00Nra6tgs/66f9YXd8NeZiRTAliPHj0SXv9TwO3FfTaJU+Tr/ll7g9ePORveuXOHnp6eXxW23n//fc6fP9/nOW1tbf70pz+9kvPA0KFDyc/PJykpCXV1dby9vWlvbxe+7+zszJYtW/q8RkFBgYsXL76S4/9vrjew9TuqXwpbCtL9kJKRJnZYDQMXH6Vk8VHKlx+ncO5+ypYdE4wxJLCVM2Mn6Q1bhGDihEnrhT2VtIatZM/YQ/rUHeTO2kfGtJ1CqLHEICNl8kYSJqwlrno1cdWr+8BW+PB5RI9aREjpbAKLZxA2bLZ4fDC/Dq+8KYKy5Z5TjVv2OOyzx+GQORaHjFE4ppbjnDYKh6RybGIGYx1ZgPVz4DL2ScLQK0FQuCwC07EOyRJgyzY8A+vQFGyiijD0ScTAMRBdc0d0Tb1wtrPm7u1LTNu4l4jMfEbUNODiEYy6iiEKCtooKOmiqCq2iJdXN0BZ2+RfwDXAoE9bOwQTGFuInUsQWgM00dQxxNTCFgdnDwKCI0hJz6FwSCmV1ZMYO24iWRnZ5OcVEB+bQGR4FD7entjaOTC0bCQlIytJTs8iMiaZA4dOs2vPCapr62lpv8DZi9d4/9nnNJ05x6Zde/EPicDB2YPykVWsWr+VnYeaefiHjzh2/hKXbt7n4o173Hr6Pu3XbvPwDx/z+I+f0nH9Dheu3MTRIwBLt3CCkgbi4J+EW2gObmGpOHlHoWnkiJaxE37haeiYOWHpFIixvT/aFh5oWwajbh2CgXcaJuGFmEUX45BeiWt+HR5FjYSOWELYqGXEjF9Lcv020ut3kjNjP7lzDpG3sInBS44xdFkLw9eeZdTGdsrXtAkZWtObn5Azv4nR27qZeuwJ00+8Q93BWwJojdrYTsLIRuwiBuIalsX42sWsXbeSM6f2k58Vg5+rAxbWXsjoOqJm6YGJoycGrmEYecdjFpKDZfQQ7OOLcUwZiWPaaFxzJuA+qAH/YbN7wdZCoqqWElW1lNjxK/rAVlTlCgG2JDceJKAl6Zz5TRQsOcHgFacZvOI0+YtPMGjpSYasPMuwte2UrT4v5Ik1HH5Aw6HHNLbeRVnb5KWhRvYtaWQUFJHqJ42HhinV3hHkO7ngoKqElaoBVgO0UBaJ0FFURknUDytFFRSk30JdRw01WRkiTZ2ZMmg4SYGRqMq8uoDlN/Xb1s+FrZs3b/LgwYOfDVsdHR388Y9/FADr3xlc/OUvf+Hp06fCDpUkK+pF63QJsNy8eVOAkdu3b7/2sN0XweunGFVI3u+HH34oZHu9jEtg79e2trZy6tSpXyXf6t+5Hv47wOrq6vpFu2W9M9BOnjzJjRs3XpuC+UPgJRk3/PTTT7ly5QrXr1//1UKUv/rqK9577z3a2tr6PKeurv7KlKWoqCj69+9PU1MTf//739m2bRsqKioCzJmbm3P48OE+r9HX1+fEiROv5Pj/m+sNbP2O6j/ClkzffhG2lBWkkdEzpWzBLkqWtlK6/Jiwp1W04CBF8w9ROO8gg+YeoGDOfrIat5NSu5GEiWtJmLhWCChOnLSOlNqNpDVsJWv6TmGXK2v6brJn7CGzcRfpU3f0sX+Pn7C2T75WWMUiQkYsILBsLoFlc/ErmYFnUQO+RVPxya/DM28CnnkT8Mgdj0fueNwyx+KaMQaX9NE4p43COXUkTikjsEsoxSpmKDZhBViF5GIelI6JfxJGvuI28U/BIjgD27Ac7MJzsQvPxSY0G7uQTGwC07D1TcHEOQoNI2tcPDxxcXXgYs91Smvnoefgh3tAPLb2fmjpWCCnoI20rAbyijooKKijqKKFrLIeCupGyKkboKhljLapHca2bli7ReAWmoWxjS9mFi4oq2igq2eMkbEFXt4BRMclk5U7iGHloygaWkZaWgbx8YkEBgbj7OyKja098QlJDBlSTG7uQALiEmk63ca5S1fZtH0vWQVD2bDvIJv2HqS75y5dPXc53XGZMRNq0TQww9TMmuEVldTNnEPz6XPsP3aSw61naT7Tzo2Hb3P33T9y990/cuedD7j+8B2efvQpOw+34hEUQ2LBeJIHVeESEEdIXAaGFh4YmLtjbOWFlWMgZp5RWLkFYWLrhq61B6oWAWg7R2Pon41lVKkALZ5F0/AvnUvs+E0kTd5OYt1O0mYeIG/hMfIXtzBoaSsFS04wYl0HI9df6BVk3EnVtk7G7+xm8r4e5p98zJDFR6ne2cm47V2UrD3NkMVHqFh8kKCcKvScxbt6o6bO4p/8ndYTO4mIDsLW3RNlfXN0rd3QtvVGx94PHccgDNwjMfZLxiwoA+vIAuxjS3BKLMc5vQKvgdV450/Ef8hU4bMZVrGI6MrlRFcuF+8bjl1G1NhlhFUsImL0EuInrCW1djOptZvJn72PwgVHGDT/MPlzDzJwzgGGLjnG0CXHBPfOQfMPkzd7P/lzD1K44AjFS05SsbaDqs2XmbLnFg377jL58BPSx81CTkMHUX8p+r0lQkb6+zlY0oqK9JeSQaqfNHIy8si8JcsAWSX8jG0Y7hFBqJEl7hp6OGjpYqSswgAZWZT7S6HcXwo1WTnUZWTQkJVFR1YOfVl5TJTksB6gTk5QNJVZJThrWzBARoV+/WWRlpJ/A1u/0/q5sHXr1i3u37//s0Dr22+/paOjg2fPnv2owcXnn3/eR02RXNR/8cUXP/kC/cMPP6Snp4cTJ05w5syZl3L6+6XgJTF/6Ozs7OO6J9nHepXq1Iv5VhJoe93g9UMQ3N3dLYwIdnV1/ajj4M9tCVD/mqYeL36WTp8+LYQov0pL+X/Xz549o729vc9zysrKfPnll//xbzwkJASRSPSjDZCSkkJgYGCf1zk6OrJ3715ArGxt3bq1z/cVFRXfKFuvoN7A1u+ofilsycjKE5RXxuAFeyldeuwHYUti954zfRfpDVtIqd1IfM0aosetIKpqOTHVK0mYuJbkKRtIrd9CZuMOwQo7Z+Ze8WhYw3aSa7cIeVtJkzaI87ZeCDMOGbFA2I0JLJuNz9BG/AZPw7egHu/8icIooXtO9Y/ClkOS2KXQIboYu8girJ5bw5sFpmHin4KRbxLGfslYBmWIjTLCnitcYVnYBKVjF5yBtW8ylv4xSGvq4R/mT3x8MB9983+ITs1D09AOORVjBmgZoKKhh7K6LrJK6kgradNfXgttc1f8o7Pxi8zGPSgFA2tfDG38MLEPxDkonbD4fHT0rFBUEtuja2rpY2PrREBwBAnJGeTmDxZgKywsAm9vX2xt7XFydqdgcDGJaZmkZeexr/U0py9203L2AqfbOknPK+LQmfPce/YBbZeucuZCN63nL7Fj/1Hc/UJQ19DF2c2bCfXTqJ81l33NrZztvMrZzqtcu/eYzlsPuHjjHm1Xb9Fx/Q6Xbt7neFsnYydPxyc6j7DkIkJic3D1jUDX1Ak9M2eMrNwxsHDF1isKS2dfNAysUTN3R9M+HAOvZExDCrCNH4VzTo3YZGL4AqKr15Bat4usxv1kzjxI3sJj5C08RtHyU5RvuMDobd2MXH+Bqm1XGLf9KmO3XGb8zm5qdl+lZvdVKrdeonLrJYavO03Bc8U1b8oKYsrqsY8uwMQ/hZTCSmrnLuZv//gLleU5ONvaY2nngo6tO7rOgejZuKNt642ugz+6TsEYekRh4p+CeXAmNlGDsIspxjlpOK6Zo/EdVINn3gR8i+oJKJ1D8PD5hIxY0AeyJApt6MiFhI9aTMSYZSROXE9a3ZbvuXYWLz1O0cKjffLoJH8n2TP2kDtrH4PmNVO85CSly88wat0FKndeY+zeu0w7eJuw/BGIlLWRVVShv9T3IeYtUT/kFZSQkZVHStQfE+kB5Nn7U+ERSbCBOXYDNLHX1MFQXhFNGRlUpWVQkZJGRUoaNVk5BkhJoSYtja6cPIbyiugrymCoIIdefxl8jKypLSijICoJeVF/5OXfwNbvtX4ubN2+fZt79+69FGB98803wv6VZDzs6tWrfPDBB3z11Vd88sknfQwauru7X8mekARwJMc8d+4c9+/ff+0mDH/5y194/PgxHR0dNDc3c/LkSWH/6s6dO3z88cevBQx6W7tLVKDXlanV+2dsamrixIkTQhbUr2F08cknn3Dv3j0h6PhVfWa++Ua8N3fr1i0BYG/duiX8zn6JwcbP6XfffZcLFy70eU5OTo5vv/32lZwH6urqCAoK6vOco6Mje/bsAcQ7W1VVVcL3njx58mZn6xXVG9j6HdUvhi1VTXLqVjBo/gHKFh2mZGkTxUuOCqOD+bP3CaCVNW2HMEIYN2E1MdUriR2/itjxq4ivWSNWt+o2kzFtO1nTdz7v3WQ27hJgK3PqdtLqtpAyZRNJkzb0gS2J9Xvw8PkED59PUPkcfIuf52wNrMWnYJIAW27Z474HWw5J5TgklYvzt+JKcIgtxy66BKuIQZiH5mIZ8i/gMvZLxsQ3WRgptA3LwTYqB6vQDOxCMrENSsfYLRyH4CREimokJcaQlp5Iz+1bWLv4IqthgZ65A/oWjsio6qKoaYSBpQfO/vF4ReYQnlFG8bjp2PjEYOAQgKalJ/ZeMbiFZjF0ZC229t6oa+giJ68iKFx2jm6ER8WTmz+YgqIS0tMz8fLywdnZFWNjU3x9QohJTCcoNpG5q9dx4NRZdh0+xupNO5gxdzFZBUNZu3sfu5taON3WyemOyxw/00HzqTbGTZ6Kjq4RmjqGhMUlUj52HNMXLOVw61luPnqHR+9/xL1nH9J1+yGXbt7n7OUeLly/T/u129x++13Ckwfi5BOBR0As+qbOaJvYomFohaaRNSo6puhZOGFi7YqagRWqlj7ouMVjGpCLVXQZjukTcMieiG/JbEJGLSVu8jZyZhwkf85R8hccY/CK05SsOU/5hgtUbOli9LZuKrd2M2X/HSbtvcXkfbep3nGZmt1XmbDrCmM2X2DMulNM2nKW0KFTiCyeKFYwfZOwC4hh8YYdbNmxk3/87XMyUwIZXzUcE2tn1A2tUTVxRt3KG31bD3TsfNBzDEDPOQQjz2hMA1KxCMnCNroQx/hSXJJH4Jo5Gu/88XjnT8R7UC2+xTMJLJtL8PD5QhB3dOVyYsetJHLMUkH5Chm5iJhxq0iZsonMqdvFJhnPIxEkTp35cw8KO45JUzb36cxp+xg4+4gAXeVrOxiz/SpTDtxlztHr2EflIuqvgIys0vcgRklGrHZJifrhqm5MoXsYxV7heCppYq2uhpmGBjry8ujIy6MhKyuAlqq0DANkZFGTlkZdRgYdWTkM5BQwVFHESEURE2VFzBSVMZJSYHxOEUXRiaiKfr41/Jv6bevnwtadO3e4e/fuSwHWi/tXn3zyiRDue/ToUZqbm+nq6uIPf/jDa1MpJLtAkp2vtrY2Hj582Cdz61Ud58Xdss7Ozj5W9K8KCv4deEn2wHpnav3S8TsJYP2YeieBg+7ubo4fPy4YXbw49vmq+0U1tLOzk6dPn76Uc+Rnn33G3bt3OXPmjGC48p9A9cfA68cMNn5Ov/POO1y8eLHPc1JSUvzjH/94JeeBJ0+eIC8vT0tLC9999x27du1CVVWVjz76CBC7EWpoaNDT08PXX39NTk7OGzfCV1RvYOt3VL8UttSMrSldcYjydWcpnbePIYsOM3jhIQbN2y+2dp++i5zpu8hu3El2406yGreTOGkdcRNWkzBxLTHVK4mqWk5k5TKiqpaTUreZ9KnbnucM7SR96g4ypom/ptZvEwPbc3UrefLG78GWZJQwePh8wkctJLBMvL/lN6gB30GT8c6fiEfueFyzqn5Q2eqtbtnFlmETXYxlRBGmoXlYhWZhEZyBWWAa5kHpgmmGBLbsonOxChUHH1sHpuETnomBQzh2/omI+svj7WFJ0eCBHGg+SfHYaSRllzGwuBob1zDUDRwxtPPHwiMCfcdw7EMyGVw5BVO3APziM9Gz90TXwgtjp3DcAxLx9Y/GwNAMWTllFJXUGKCmjZ6hGZ4+gSSmZBIWGUdCQhLOzq64uXlgbW1LcFAU8SlZ5JYO58rTdzhyrp29TSfYsvsgNbWNDCkfzfq9B5i2YAlHjp/m7MUrNJ9qY9vew+w62Ix/QCga2gZYOrqQXTiE6rpGlq3fws5DzWw/cJRbT9+n++5jYYfr+oP3ePTBn7j33nucu3wL94BIgiNTMTB2Qt3AEhUdU9QNLNEwtEJZ2wQtQ0uUtE3RdY5A3ysV85BB2MRV4Jw9mcDy+QSNXEz0hA3E1+8ib9ZhCucfY9CiFoauOsuITZcYtfUylTuvMW53jzhL67nt+fid15my/wYT91yjalsnFRvaKJ23jehhk/FNKULB0BaL0ELCc0fx6bf/l40bVvPVn98nLy2Q0uJU5DS0ULexR8PSESM7H8zsAzCw80TX3hc9xwD0XUIx8ozGLDBNgC3X5BG4pozEOb0Cj9wq8b5gwRS8BjfiVzKLoPJ5hIxYQOSYpcRUrRD2DiWqV/CIhUSOXU7SpA2kTNlESt1WIQA8b/Z+oSUjtklTNpNcu4Xk2i0kTdlM4qRtpNXvJmPqXvJmHaZk8RnGrDtL1fZ2xu28zPSd5zB38UX6B3ao5KXk6NdPChcDS0a4RlNg44OVqjpG+hpYaKqiraKEtooSA2SkUenXD+X+UgJoDZCRRUNWVhgj1JORQ0tBDiNVJczUlTFTUcBAWRlPPWMqk7PI8Q95A1u/0/q5sHXv3j3u3LnzkwwuJA6CkhFBifGBZCTr5s2bPH36VNg/On36NHfu3HntI38SIJK433V0dPDo0aOfPKr4Yksg4/Llyxw7duxH1Z2fYxjxKsBLkql1+vTpl3Zu/Ll7aV9//TXvvfceV69e7RPc/Lr36L744gvh/TY3N3PhwoXvBVlL+s9//jMPHjwQ1LFr1679opDn/2Sw8XNgS+KCKXn85ZdfIhKJ+Oc///nKzgXNzc1YW1ujqKiIh4dHH4MMEOds6evro6Cg8CZn6xXWG9j6HdWLsPUiXL3YavIyyPYXoSQvhbJCfwKzhzF08S7KljVRsfCI4D5YMHefOFerl6qVOXU7afWbSandSOKkdcTXrCF23Erhzn7ChDXiUcK6TWRM3UrmtG3C61NrN5PRsI30+q2CDXz8BPHOV3zNGsJGLyZyzFIBtkJGLCBixHxCSmcTMFSsbvkOmoxH7ng88ybgnlONe1YlbpljcUkfjVNqhdgCPnkEDknDsU8sxzZ+GNaxxVhEDcYsohCL4DzMg7MxDUzDJDBZ2OEyDUjFMiSzz0ihdUgW9qE52AalYuUThZa1M3rG5vj4e1A0LJ/Fm3aycPN+BlU04BuRh7tfHHo2nmiYOWNg542pcwAh8YVYOIcTEl+IW2AqCloOmDmG4h2WQfXUJbj7RiKtMAB5BSWkZWXQ0jbA0ckd/4BQAoPC8fcPxM3NA3NzS2xs7HDx9Cclu4BTl7o5dqGTvUdaONd9lYvXr1FX10DNjHn0PHiHU+3dXL/1mPOXr9N18x6HW8+ydd9hxowdj46uEeYWtkRGxTO8sprZi5exefc+dhw4zMkLF7l67wHX7j3lztM/cunmfVovdNNx/Q5X7r7DqJrpOHhGYesagZ1bMBYO3mgYWmFg6YCKlhHqhtaoW3ih5x6LYfBALKJLsE8ei0deHX5l8wkfu4LoietJnr6T7HlNFC47RfHq85RvuMjIzV1U77lJzf47TDn8gNp915h66Cb1h24zaX8PlRs7qD98k9yZ2xg0bT1B2RWY+CbjmVxERNEozt14j567d1kwu5qL544wdEgKvn5uGJjbom3mgbatd5/WtQtC1z4YfZdwDD2iMPSJxTQwDavIPGxji3BIGYZLxkg8sqvwzqvBp6AGv8IpBA6eKo4jKJ8njL5Kgrgl469B5fOIGLuYmHGriBu/jrQ68Q2H3oAlgazMxl1kTd9N4uRNxE5YR3T1GmLGryV+4gaSpmwmfeoOsRI25yhDFp2gYm0HlZvbqDnQw4hVR9G0cUJJSYm3+skgK6OC1FtyyPWXJ9DYnlLvSJItHLHV1MBKQw0TNRV0VOTRVpVHR04aPRk5lKWkUZHqj6q0FKrSUgyQkUZdtj/qsv3RkJNCU14aXUVp9BVlMFaSw0xFARNFZczllSmLTaYudzAT8gpx0TVGXVYZeTllRG+J6CfVH1lZWaT6/bjy9aZ+2/q5sHX//n1u3br1kwwuJHfmX1Q6fuiCW2KGcP36dVpaWjh//jwPHjx45crTj4FSV1cXx44d48KFCz8pT+vFAOSOjo6XUspetEJ/HWG+P9S9w4xPnDjB9evXvwcYPxewfqwlwc2S/DCJgcnrdhj88ssveeedd/pA8J07d7hz544AvN3d3b84k+1lwOtl97yePHlCZ2en8Pjzzz9HSkrqtz59vKlXUG9g63dULwtbKjJSyIlEyMlLIa+qSm7NfEYsP0zZsiaGLzjAkEWH+wYYP3cTzJy6nYyGbaTVbyZ5ygYxaI1fJQ54rVpBXPUqEmvEe1tp9ZvJatxOzoydgiqWOXW70BkN2/61t/XcaCN8zBIixywVLl5DRiwgfPg8Abb8hzTiX1QrHud6rm79J9iySyjFJq4Ey+ghmEcWYRU6CMuQgc+BKx0T/xShzYPShR0um9BsbEKzxf8dlI5NYBIm7qFoGLuiY2hOTFwkQ0YWM3PFesZPX8KwsTNILRiBjoUbWmYuqBrYoWvpjltQElZuYehYeBCRUoRrQAq6Fl4Uj6kjt2QsfiFJGJnZIyunhJS0rDBOaGPrhJu7Dy4ubjg6OmNmZoG1tS3RSRnMWbqKi9dv03S2nXVbd7Nu524279lNXFwCi9ZvZcfBYzSf6qD5RBsXr9/mzKUrtF+5QfOZdhYvW41vQCiWNo4EhUZRPHI04+umMmfJcjbv3sfBE620dlzkbOd12q+Id7ZOdFzmTNd1Tl/q4dKNR8SmF+LsE42RlTtaRrYoaRmjaWSJopYJKsZOaNgFY+CXgXlUMXZJo3DOnoTP0JkEDF9I/MQNpM/YTda8AxQtP03Z+guM2NTJmO1Xqdl/h0kH71Gz/w4NzU+Y1vIOtU0PmXL4LpMP3KJ6TSsRI2YTP3Y2NuE5GHqnEZA6jCGjJvG372DDmsWsWt5Ifd1I4hIjsLT1wMjCBWNbTwztfdCxE7euvS+69r4YOIZi4BSGoVskxl4xGPvFYxGSiU10PvbxQ3BMLcU1swKv3Gp88yfhXzSZwCH1hBRPJ2zYbGGMUGLsEjpy4XNTl1n4lcwicPgcwkcvJbZ6Len1O4Wwb8l+lmS0Nq1hu6D6JtduIXHyJhImbSS5dotYCZ6+WzxqOP2AWOFaeorKDV1UbL7C5EN3GDRvM7KKOvRTV0ck2x8DGVXSbd3Jc/YlxsQWOy1tLDU1MVZRQUtWBm05WXRlpNBXlENeJEJJRqYPaKnJyvQBLS0FGfSUZDBQksVYSQ5TZXn0VZUx01BHX04OUwUlEu1cqB9UQo5fBLYqeihKyyLTrz/S0tJIy79Rtv5b67vvvntp2Pr222+5d+8ePT09fQCrt3r1omvdhQsXXnpcr/fIX2/l6XUGCvcGqN55Wm+//bagPL0IIRcvXuTx48c/WxGTtMRi/dcGr08++UTI9GppaaGjo4Nz587R3Nz82rLEejsMtra2vpQT4y/5vT5+/Jhz584JIcqtra3CLtav4Wwo+Xt5WfB6/PgxXV1dwuOPP/4YObk358//H+oNbP2O6mVha4CCAsr9REjJSKNj58GwRTsYvqyJEcubGbnssBBgnDdrtwBLWdN2CKpUxtStJE/ZQOz4VURWLiOmagVRY8VfEyasIWHiWlJqN5I5bRvZ08Wvy2jY1ge4esNWb2UrauwyYW8rdORCIkcuIKx8LiGlswkeNougoeJRQp+CSWJ16z/Aln1iGbbxw7CKGYpF1GBswoZiHVYkAJd5UDqmAamY+KdgGpCKeUDYAZhCAAAgAElEQVQalkEZ/4KtiCysQjNwCMvGJjAFj6g8rJyD0NE2IG9gOpNnzWJi4wLW7GzBIyKdYRW1yKoYo2PsjL6ZG2ZOAdh5RaBl5oKmqTOOPnEMGTWFsKQ88ssrGTN+JmZWbujqmqKgqIqC4gBUB2hhZGyBnb0Ltrb22Nk5YGpqjqWlNQFxiXRcvcnlG/c4cPQErecvsXbHLpasXUNMTBzbj7TQcr6T0x1XaGo5T9PpNppOt9Hz4CknO7o4eLyVsROnYOnoQlhcIrmDixlRNZ66mXNYsGI10+Yv4EznZbpuPuD0xet0XL/Due4bnO68xtX7j+m++5jGBaswtHZHy8geDQNrNAytUNU1QU7XBjULH7Tc4jAILsAyoQKHjAm4FTQQWL6Q4IolpNRtJW/+IQqXH6dw2SnKN1xkzParTNh3m0kH7zHl8AMmH7rP9BPvMq3lHWa0PGHG0dsMX3aEnMoFuCUVo+MeQUxOGbuOnadu1kK++7//h8G5CUyfNIq0tBi0jA1w8Q1Bx9ILHUtPdK09xCOc9r7oOfhh4BSAoXMgxi4RGLtGYuIZg5lvPGaBSViH52AfV4hTUgnO6eW4Z4/GZ+AE/AomEzB4CkFDGwgtmUF46RzBdTBq7DKiK5cLylZA6RwCSucQUjGf8NFLiapcReLEzcKeVsG8Q0IsQm/YSqnb2mfkNmOaGNByZ+0Tjx/Oa6ZgbhOly88wbEUb5Ws7GL2tm3F7rlA0dSlvKajhomdArkcA6Q7OeGlpY6uuiaW2NjqKyuirDEBHVgETpQGEWlgR4eaCtEiEmrJ4nFAALTnZPqClpSCDvrIshspyGCvJYaIkh46CFIaq8phpqqCnJIORnCyG/WWIcXSjOruQwohEHLSNkBO9hbS09BvY+i+tnwpbvfevvvjiC9555x3BgU4yeicJwu3tRveyOzM/1hLlSaIgXbx4sQ8Ava6WgJXEAKKlpYWmpiYBQl4X+ElG29ra2jh+/DhXrlx5LcqLBEIkY2rNzc1Cztev4fT3zTffN/X4oYyxXwI4vRXLixcv8uTJE7788svvOUOeOnXqtQNf7/f1MgYbjx494vLly8LjDz74AGVl5d/69PGmXkG9ga3fUb0sbCnLyqImJUJaXgG3hIFUrGuibOFRyhYdpmzpPgG2cmfuIqtxu3hPqxdsJU5aR+KkdYIiJQGkqLHLiB0nNsxImrye9IYtYpv4KZtIrd0sZG1J/j8pUzaROHE9iZPWkTR5PZGVywQb7bCKReJ+DlpBJTMJKplJSMk0/Itq8R00+SfDll1CqTBKaBtejE34YKxCB2ERnCfsb0nULTP/1D7qll10NrYR2ThG5eMQlouxXyTG9r64u/nh6erEsvVrKB5dzbzVu6lfsonoxAJyC0ejrGGBjpEThraemDn5YeLgwwBDW7TN3VE1sMHBNwwLV188fBPw8o1hwAB9NLX0UVHVRElZHXUNXXT1jLGwsMLKygZ9fUOMjExYs3sfZ7qusvtAE7v2HmHF+q0cOX2W8fV1REZGc+Dkedqv3GLXweO0nrnE5j0H6bh6k+Yz7Zy5dIW9R4+xceceHD19iElJJyO/kIFDh1Fd28DUOfOZOm8+m/bs40RbF0dOdnDxxj3BBr777kM6bz2g8+Yj3AOj0TV1QknTBEVNIxQ1DVA190DHKRwDvyxMIopxSBuP+8B6fIrnEDZ6pRi0Zu9n0OImBq88QfmGi4zdcY2qXT2M33uLuqOPaGh+Qu2Rh9QdfcSMYw+p3trB0NnbCB1cg7lHEo7hOYxpXMqFa0/YvWcb77xzm8yUQCaOzcPGyhpTO2fkDewwtvZD3doJXUcP9B290bPzRtfeF31HfwydAzFyCcLENRITtyjMvOOw8E/EIjgFm4hcHBMG45w8DJeM4XjkjME3v4aAwlr8iyYTNLRBULYkNwTCR4lvEvQ2dgkZsaCPspVWt4O0hu3kzNwrqFpZ03d/D6wkz6XWbxNGDfNm76dg3iGGLDpB4fxjlK04y7C1bYzb3sXodeep2XGdcUfbiA5NpsozhCRTGyy1FbHQVsFSWwMTJRU0FZXQVlBCT14JP0s7Qo3MUBaJUJCXRkok6gNa6nKyaMpLC7ClrSiLgYqcAFvGirKYqchhpCSNmboiOgr90Bwgi46KPCaqqlgoD6DEK4r6gaVkBEehKv/juVxv6retfwdb/8ng4ssvv+TevXucOnWKI0eOcPToUdrb21+53fcPwUFve/XLly+/FgXo888/58GDBwI8Xrp0iatXr/7qypPkfbxK8OoNWL0hpDc8fvrpp9y7d09wh7x69eqvAl69Rxx/DvC9aILS+4bAvzuuBPgkO23Xr19/rWYtvd+vBLz+/Oc//6DBxsOHD+nu7u5jBa+urv5bnz7e1CuoN7D1O6qX3tlSVERJJEJWXZfsukWMXHaU8qVHGTRXbEs9cPYecmbsJHv6DnJmiA0xMqZuJa1+M6l1m4SMrfiaNURVLSdi9CKixi4hunIpMVVi4IqrXkXChDVk1G8RAEvSvc0xkidvJHHieuLGryG2erV4lLByGcEjFxBQLs4y8iuZRfDw+QSUzsF7aB1eQ2rxeq5s+eZPwi2zCteMyudfx+CYMhL7pOHYJw3HLqEMm7hhWMUUYxE1BOvIwVhFFGERNgizkHzMg3LFe1xBuZgGZGMakCo2SQjOwCo0C5vwHGwjcrGPGohdZB7ukQNxDM5Ex9ILG2tHnO3NaOu+SP7Y8aza20rtsi1UzViGjIoBCir6qBvYo2vmipm9H3rmbgzQs0XL2Ak9czfcA+JJLRiBV1A86noWaOpaoKKsgYqyBgNUtVBX08HIwBh9PWPUtfRx8fRnb9MJLly7xY2Hb9Pz4Cn7m1rZsvsgU2cvxD8shp1Np5k2bymt5y+x73Azx85eZG/TSQ63nufKncecunCFtVt2kZiWRXJ6Fml5BYyeMImqyXXUz5rLniPNNJ06y4FjJ9jf3ML+Yye5+egdbj1+lws9d2m7eotz3TeYvmgFhqaOqKrroaSmwwAzB9Ss/dBxjcbQPxPr2BIcMibgWdRIyMhlJE7aRuacIxQsaaVkTRujt12hcsctxu8Rjw7WHnlAzYG7zGv7kHG7rzF6ywUGzt5E6qTFmIdlY+yTwOgZa9nV2snC1Ws4eaqJ5kPr2bxxCVo66uiZWaBl7oC2hSO6Vs7oWbugZeOGtq07uvae6Dl4YeAYiKFTEMYuIZi4hmLkHoOJVzymAcmYBadiE56DY2whLknDcE0djnP6CDyyq/ArmEzQ4Kn4DZ5GwNDpBA+bRUjpbAG0JGOEwcPnElg2m4DSWXgNnioO5R6+kKjKVcSO30Dm1O3/MpmZtoPMqTvJaNhBev12cTfsIWf2YXLmN5E97yiZc46QM7+ZgYtaGLT0JOVr2yle2szwlR3UbLlG6ZbLVO3uZuKs7eRHJ5HlFkCkiQ32urr4W9tiqaGElpwILXlllN6SRVNKmmgna7y15QmzN2eAtDz9+ykgLS3Cw8GWsrIkNm+exJFDeWzfbsf+A/bs2GXCqlX67NijxfrNSiREi9BVEWE0QISekrgtdWQxU1fFWFUJQyUlTFRVsVbVwV/fiplDRjEiJRdtZXX69ZdGSkGBfv2kkJKSQlpa+rc+df6vr++++45vvvmG//mf//lJBhcSNUASMCtRIZ49e8ajR49ob28XLsz/8Ic/vHaFQLLzJAGRX3rczz777HtW4s+ePfsePL6oPP0aIPLNN2Lwun//vvD+Xua4L+6X/RBg/dR/l9eptPXuTz/9tE8cwJUrV34QcF/c9ful9v4ff/zxDx73dSup33zzw3tet27doru7W1C8nj59ira29m99+nhTr6DewNbvqF4WtqREIhRlpdB39qF85T5GrWimbMkRCueJw1ZzZ+4ie/oOAbZeBK3Uuk3E16whpnoloaMWET5qIeGjFhJWsYCwigVEVy4nrnoV8eNXkzJZ7MSWVie2fM+aJg41lti+J9SsI2nSBpInbyRu/Bria8RjiBFjlxI6apHg7iYxzfAprsdrSC3egybjNbAGn4ETccusElqicDkkj8A+aTjWsSV92uY5cFmGF2IeWoBFcB6WIQOxCM7DLDBHgC3zoPQ+wGUXmYddZB6u4dm4RA3E3CsafQtH7O1tiU1OJDI9g3HTl7Fg40GqZywnPDEXBXUjAa50TF0wsPRA28QZHVMXNI0cMXfwx9YzHAePULQMrTEyc2SAqhbKSupCq6lro6aph46hOUvXbGHP0RZ2HzlO4/wlbNt/hLau66zZvJNxk6cSnZTBnuPnuNRzj6aT59mx9yC7DrfQ8+Adjp5q5/zlG7RfuUXzqTZGj6shLimV9IGDmFA/jZqGRiZNm8H2/YcYUTWenvuPuPnwCc8+/jNnO6/SffsB1x++Q/O5i1zoucvpzmu4+0Wga2SBnKoOGpae6DpHYeSTjGlIPrYJI3HNryOgbB4x1evJmL6fvIXHKV59nhGbOqna1cPkgw+pb3rMtOOPmdbykAm7rjH7+AOqN54la/JqgguqMfRKYFT9IiY2LuKf/IPsnDQO7NvEjk2LiIuLQVpeAXM7N3RM7NG2dEHHyhU9G3fB1r2PmuUahrFbOKYekZh5RmHqFY+5bxIWwWlYhmVgHzUQl4QhuKeW45FRgXv2aLxyq/EfNIXAogb8Bk8jsHiGGLTK5vwgbPkWT8d7yDTcCmrxH9JISNl8IseuJKZ6PUmTNpBau5m0ui2k1m4mceJGEmo2CJ05bR95c48ycNFx8he3kLfwOAVLWilefZ7hGy9RuuoMFduvUL7xBmPXdzJ5bxfF1TPItPclziOEYHNnXDQNcDU1w0RJBV05edSkZdFV1sBbVwUfA1U8dOQJMFPHyliXypEZtJ9u4MKpfB5fyefiOW/On/Zgx2YRG1eI2LBIjdkTFFg0VYb6CSK2rbUkwlMZQ1ltDFVln7sT6mCmZoyVuhK2mhrYauhjqWKArZ4hNuo6eGoZUZWcS+3AEfhZuKCurIGsmjqysrJvYOu/oL777jvByOJFg4veO1jPnj0THOXOnDnzb40NPv/8c+7du8eZM2dobW3l5s2b/OlPf3rtF6mS4549e5aWlpafZNv9zTffCPleZ8+e/VngJAGgc+fOCUrMqxiB+08tGdv8d+D11Vdf9QGsn2r88TLH/TEAel0/r8Q+//Lly8Lu4Ot0sfzss8/6KJxdXV2/yCjkp7ZE0Tp//jzHjh3j4cOHguJ1584d9PX1f+vTx5t6BfUGtn5H9bKwJdtPhIySHH45Qylb1cTwJYcpXnCAwnkHyZm5l/w5e8W7VlO3kt6wRQCt5CkbSJq8XgCt2PGrxFA0cj6hI+cLsBU1dhlx1asEd8LEiesF++vU2s3CBWfy5I3ET1grHiWcuJ7YanFuV9yE1USMXUr4mCXCWKFkH8a3pAHvoXV4P7eA986rwT1rHB7Z1bhmVOKUWoFz2igcU0Zil1iOTdwwoW3jS7GNHopN1BBB3bIMGYhVaL54hysoF9OAVAG4JNBlFZqFbUSuGLaisnGJLcAuPBsDB3+UNfWpGDuGcTUTCIvPY/SUBew+dpG1O49i7OCJtIoRipoWqBvYo23ijJq+HdomzmgZO2Fg6YGjbzRWTv6Y23mgpWeJ2gBtVFU0UVHWQFVFEyVVTdS0DQmLz6Dj2n3ar9xg9ZadtJy/yJK1mzjQfJLNuw5QPmY8McmZnOq6yZ6jrdx+9C7HTp6ltf0ybd03Odx6nttP3qf9yi0uXLnJ8jUbSMvKpaRiDBOnTqd2xmzGTaln9uJlzFmynOraBiZNm0HzmXZa2zs50XaJlvYurj14m60Hmui6/ZC5K9YheksWXXNHBlj5o+MWi7FfJuYRQ7FLrcSloI6IyuWkTd9D9ryjDFl5lootlxm3+wYTD9xlyuH7NDQ/ZFrLQ+qabjO76R65tRtIGjkTC79UwlIKWL11H/MWzId//h+KCjLIyEjAzc0FNXVN1AzNUTOwxMDKBT0LFzStPdGy8RJnZzn4oe8QgIFjIEbOwZi4hmLsESsGLJ9ELHyTsPRLxjowDZvwLGyjcnCOK8QjZRjemRX45IzFe2AVvvk1+A+aQkBhPf5DGgkqmUlo2RzCyuf+IGz5DG3Ee8g0PArrxSpY6TxCK5YSNnolsdWrSZy4XlB0U6ZsIbV2K6m1W0mr20bmtH3kzD7MwEXHKVx2kiErz1K2/gLlGy4ybG07Y7d1UbLlErV7rjNh5wmKUoZTYB5AolcQofY+2GmZ4mnhgJGaBqpvvYXRAD005bTxd/XDTkmGgnAPBkZb0XNuIZ0XB9HdFsTNdkPuXFDh2RVpbl4S0XVSl11L+7Fvs4ida0TsWCli52oRh7aJOH5Qir1bLTlyOICDe4NYvdyW+klaDC0QEemlgJuZCPMBIuy1VXExMMJaQws7LR3cNfRYNLCMraMmE29iR5CpFQoKCsjKyv7Wp87/9fXZZ5+ho6NDSUkJp06dEgDriy++4O233xZ2Xdra2rh///5LZyVJgmFbW1s5c+YMd+/efe15S998Iwao27dvC8G+vQNpJflTL7rxvQolTqLEvExO06sCgt4jfx0dHbS3twu2548fP34t+2W9Rxx/rdHKTz75hJ6eHo4fP05TUxNNTU10dHT8KgDU2/ilubn5lZmjSFqyYyaB487OTt59913hpsdnn33Gnj17iI6ORlpa+pVav7+p36bewNbvqF7e+l0WqQFKZE+eRfnak5TM30fRnD0MmntAvCcyfQdZjdvF+1rTdwiKVtLk9cKuliRbK3TUIkJGzCOsYgERoxcROUZs3x5XvUqwg5coWZKWqFyptZtJqFlH4sT1xIxbRWz1arHhRvVKIbMrZMSCPlbwviUN+BTX41M4RRxwnDuhD2w5pozEOW0UTqkV2CWWY5dQhm186b+AqxdsWYYXCrBlFZr/XN1KE4BLAl2WIZl9YMshOg+nuEIsfOPQt3TGyMSYw0f2kzdkNP7hWVTVL2Lxxj3UL16Nia0PcmqmKGtboW5gj4ahAzqmLoLCZeYUgLN3BC7eoZhauqCupoPaAG3U1XTQUNdFTlkDUxsXVmzYzfnue+w+cpw1W3excNV6rt59xOpNO1i9aQd5g0tJzMij5cI1TnZ0c7T1HNdu3ePq3SccOdnG5VsPOXb2Il03H9B98z479h4kJ7+QUeMnMnLcBMbXTWXYqLECZBWPHM3Rk2fYuGs/ZzuvcuTkOW49fZ+r959y5d4TTl68ws23/0BwTDIq+tboOESi55WEWUgeNvHluOZOwb98LtE1a8iYfYCilWLnwXG7bzD50P3n+1liVav26C3G7rxI/rSdOCZV4B5bxPiZKznTfomaSRPYsWkJA5O90dbRQ1ZJHSNrHzTM/dC0tkfL0gENU1v0bVzRsvVB284XHXs/9BwDMHQKwcg5FBPXcEzdIjD1TsDMJxELv2Qs/VOwDkjFNjgDu8gc7GPycE0YjFdaGb7Zo/HLq8K3oBq/gokCbAUMnS7AVvjwed+DraDyOfgMbcSvZIZY4RpUT2DJHMJGLSOqai0x41b1UXKTJ28WgCutbhvpDXvImnmQvIXHKFx2kpI1bYKqNXrbFcbtvUHZ9i7GzN3CEPsYEh0DiPQJxdcuGGs1U/ztvdBV0UZPRR1tBQVMNEzIjC3g7rUHeNkrcfncfI4fyqarI5Fb3ab0nBZx/6SIOydEXNgsT8f+/uxZJcXccSLqhr3F8gYpVjSKmFUpommLiMNbRWxbZc+ubSGsmGnKmMEiygeKaKiUoSBHROUIEZPGaDMsTw1nFQ2c9PSx0dPFSUePQdYOVDp4MdHWi6WxGSgpKb2Brf+SevLkCdOmTcPc3BwNDQ0cHR0JDg5+pReSkjGva9eu9QkTflUXqf/uuB999BE3btygpaWF48ePc/z4cVpaWrhx48YvDvj9d90710ritve6bM4l9vpdXV00NzcLRhOS3KhfY6TzxR23V5kfJoHJH1ItX3S+vHTp0i9W735KS8YyJTck2tvbfzBX7ad8Rj/44AMh4Lu9vb0PHP/1r3+lvb2d8vJytLS0CAgIYMWKFbz77ru/9anjTb2CegNbv6N6Ebb+E3wpy/XDyMuHsSsOUD63iaL5h8ifvY+Bs/aSOXU7OY07yZq6nfS6LaRO2dQHthImriVhwhrBgTByzFKiRy0iYsR8wofPI3z4PCJHLiB61CLixi4loWo5iTVrSZq4jqSJ60ietP75Xf1Nwr5W/IS1wkWoxE4+qmo54WOW9LHWDh4+XzDL8B/SiN/gaYIroWtWFU7pY3DNGINTagUu6aPFo4TPDTJs4kqwji3GPrYEu5jiXsBVgGV4ARZh+ZiHDsQ8OLNPWwRnYBGcgWVIJjbhYvXDITof96Sh2EbkYuIWhb2rK4GB7qzdsQ8r/yRCM0pYv/8Umw6cZGDJaFR1zFFSN0ZF3Rh1fRu0jR3QMLBF29gBQytPLBwD8ApOws49DHVtMzTUtBmgooGmpiFGpna4h0Rx9NxFNu85zM5DzbScv8i+5lamL1jKis3bmbtoBclZ+WQMKWHnoWYOtpzmzKUrHDvbwdptuzl/+Tq7Dh+jrbuHc13XuPHwbTqu3mRc7TRKKsZQUjGGKdNnUVFdQ+WkWlZv3sbClWtYuVEcdnyyo4sTbZfovHGfC9fu0H37Eecv3+BEVxeNi9dg7h6HumsshoFZWEQPxT5jHN5DZxIybj0JDbspXHaKEZs6mbTjFuP33mLCoTs0Nj9h9ulnVG2/SPGCfcSPnoW6UziZI2rYtHc/7330NoMy4shLT8TGyhZVdQM0dMzFu21G1miZ2KJl5oS2uTO6lq7oW7sLboOGzoEYuwZj6BaJkXuU2G3QOw4r/ySsA5KxDUrFLjhNrFiG5+ESNxSnmKG4ppTglVWBb0E1voPEipZ/US3+Q+oJKJlKwNDpBBbPILRsjvjz3itjK6h8HqHDGgXjFo/c8fgWNuI/dCbBIxcQPnYpMdUriR63QlCFo6tWEjthHcn1O0iZuoeM6fvJnXOEwUtaGbTwOMVrzzN46UnGbLrM+B09VOzoomFVK4nWXsQ6BZMekICjoR2B7kF42bui0U8OY2UN9NU0ifVMIjN9BFfv/4mPPvmarisbaT8WxtWOCHrOu9J5VETn4bdo3yvi9A4RzRtFHN3Qn6V1IqYMEzG1QkTjaBErp0uzapaI/WtE7FqnycbVdqxbbkfdWBFVpSJKBoooyhKRHCKiNL8fg1LfoiBZFiddDRy0NXDT08NDzxBXLWPSdG2odQ1ihLMrSjJyyEvL/Nanzjf1vA4cOICamhoxMTGkpaVhYGCAl5cXCxYs4NmzZ6/0Ql0ylijJPXpdzoISwJOMmZ08eZLLly/T2dkp5H39GhleEiXt5s2bnDx5klOnTnH79m1Bafu53RuwfiyUWaK0SSDlh/K0XkdLbOwlOVZdXV0vbZzyc/bx/vKXv/D06dM+Y5O/JKj6ZX4Xz549E0w5zp079x/Dm19Ufe/du9cH1O7evUttbS2WlpZYW1vT2NjI22+//VufKt7UK643sPU7qpeFLWlZKQJzSxi7ponSOQfJn72P3Bm7yZm+i/T6rWRN3U5mwzbSajf/IGzFj18tXGhGVy4nqmKh+E7/8/GqsPK5RIyYT/SoRcSOWULsuJXEj18tHimsWfs90JKMESbUiEOS4yasJnrciufmG0sEd8KQEf+ygQ8snkFg8QyxujWwBvecalyzxAYZEmXLIXkEDkn/sn+3iSsRYMs2eujz3a2+sGURktW3n8OWRXAG1mHZOETn4xhTgFviEBxjCvCILsXY1p2g8ECGjR5OetlkrP3iGTt1MVsPn2HNjiMEx2aiY+KIrLIBihqmqOlZo2loh5aReLTQ2MYbG9cQzOz90DSyxsTYAk0NXVQ09NA2smLR+q2c6brOvUfvs2XvIY6cPEfzmXbmLV/DwjUbmNwwk4T0XEqrazhw/BSt7Z2cv3ydc13X6HnwlF2Hj/HwvQ/pefCUE22XOHD8FAeOn2Ljrv0Ulg5n1qKlLF27gQUrVrNw5Roa5y1k2twF4p63mNb2Th48+yNdNx9woq2LSz33ONnRzekrNzh6rhOX0FSsIwsxjSjCLvn5rtbIpSQ07CZ3wTFK13Uwdsc1Ju5/TNX++1QduE31rqvMbn1E4sSVmIXl4pVSyNDSMlpajrF5w0pM9VSxsLFFRUMHFR1T8Z6bvjWahjZom9qjY+mErpUXetbeGNj6Ymjnh75TIAbOQRi7hWLmGYGpV6zYadA3ASv/JGyDxSHVDmG5OEUMxC5qIA4xg3BJKMY1oRTP9BH45VXhXzgR/6LJBA9pILh4KkEl0wgqbRQcMSWwFTlmaZ8R18Ah9XgNrMEte5y4c6bgXTiNwOHzCB29mLDRiwXYih63guiqlcTVrCd24ibSGveR3riPzBkHGLTwOEOXnWLwyvMM29zFsA2XGLmpm6KR00h29mOgeyKpgbHYapsT5hmMmY4phkpKaIlkcTd1xckigMJhDTz++J/8FXjw+F2+/dtX3L2Qx51Lblw4psGVFhHHNmiytEaew6tkOLCmP9sXy7GsTo5Fk1RoHC1iZpWI+ZNFLKoTsX6eiI3LdVm7zIYVc42Y3yDLvHoVJlcqUT1ShYrBCgwfJM+wPGkS/GSx1tPAwVAPOy0d3LSN8FMxYaRnDI2xOZSFRr2Brf+y+vbbb/nb3/4mPP773//O8ePHyc3NZcCAAcTFxbFly5ZXvg8jccWTOAv+0nDZr7/+uk9wrmS/7MUcpa+//pr33nuP7u5uAVRe16hd7/7rX//Khx9+SE9Pj/D+7t69+5P/XSUW+BJQ/SHA+rH+rcDriy++4NGjRz8JvCRW+6/CafJFGP25ytMv/QyePn2aW7du8dFHHwn7fWfPnuXEiRPcuHGjzz7j+++/z5IlS/D19UVbW5tRo0Zx5cqVNwjQGmYAACAASURBVOOC/x/XG9j6HdVLK1u6+gyZsY7hy5oobNxG3sw95EzfRe6M3WLHwPqtpNdtIa12sxi4XoCt2HErhRDXiNFLiBgxn9CyOYSUzhbMAySwFTN6sWCYkTBhDUkT1wlgJdnl6u1IGFO9UrgYjapa/r3craiKhYSVzyWw+P+xd99RUV5rG8ZJ7KIC0rsKSBGkC1KkCCIKVrBTxIKioqKiYsGOIoq9996lo1RBRBFsYC9JNEZjjUbNl8r1/THOBEhPJCY5+7fWu87JOUYEhrXm9tn7fubRPnQ2jm/vbkmnCZa9ImVTrTbdIjDvNpI2/pLlxiZdhtHGdxhmnYfKjhP+VtgydJNMt1q59sLQLQAj90BMvfrT1jdY8nQMlexuMjYmfMwoIueuQc3UCQNbT4ZGxbJk8yFmxG+gtaU7ylrmNG6uj7xyC1R0TNFoISnO0DdxwNTGA/sO/rSx74CCshrNmquipKGHvXsnskrOc7ywhEOHMsjILyLr5Bl2HExiyZqNbNp7kFnzF+Pk4cPMhET2JUt+TW5xKWm5hSRn5ZOWW8ixgmLOXLpK2ZWbXLr5MWm5hWw/cJSIqElMmTWXaXMXMHfxUuYlJJK4dgPDI8cze1ECW/cdZtv+I5y7eovyW/coLC2n6NxlSeA6XU5yXhGRs+Jp4TqQNj3GYDNwGk4jEvCO3kKvBUcIW5MnK8SYeugGMUlXmZ58kbHrUwiITsTGP5TgMRNZtDiexXEz6d3DF3s7G+TkPqRuUxXkVfVorKJHA0V91PUkRy/VjWxQN7ZDw7Q9mmZOsntZOtae6Np0pIV9J1o5dP7JJMvEsz+mHQfQxnsQ5p2CMPMNwrxrKOZdwrDqNoL2fcfjOmgKrqEzcR08G/chs3EbOpsOw+bgOnxOtde358h4OkYuw3NMIh1GLsZpWBxOIdMl6wj6TsSm70Rs+8+g/eB5uEYspsPoJZIymbHL6DhuOR3HLadT1Gp8Jq2n85Qt+M/cQ58FR+i/KJlBCWmErchi+Op8IjdmEbVgK927DiXIphN9zB2xsLDHWKcV7dvaodJIATV5JbSaqtDZ0RvFujrMnrOFO0/hFXDvyWu+q4TjJyq4frIfJZlNOZPRhKTV9Rk/UA5XMzkOrdRh5/IPWBn7IQuiPmR+9AfMHdOQuAl1mDdOjvED5Uic3YBVi3RZtdiQ5fOaMzWiDqOD5ejnJ0dPbzkCu8jR3V2OsL5yeNs0xkBVBaPmKtir6xNg5cIYb3/Gevnjb2JJbydXEbb+RV6+fMnWrVvp2LEjioqKBAUFkZ6e/s4nUV988QXXrl0jPz9fFgZ+z30naXCSHsP6PVOFn3tTLp2G1FxiXFuP9PhY1Qa9K1eu/ORO218JWL/0VF1kLL1bVptHKqt+j2/cuCELU8XFxdy6dYubN2/KauiLi4vf+foA6eSppKRENtX8ua91bXyP7927R1FRESkpKSQlJZGdnc3Vq1dln9+zZ8/YtWsXfn5+KCgo0K9fP9LT0/n222/f94++8DcQYetf5I+GLVNnNyZvyGBQ3AGC5myVLRmW3qPqNWPbr4atqruw3CIS8BwZL1s63GHYAlljm+fIeNlxK6+xy2WV8L6T1uE7aR3+UzfRc8Y22b6tzhPXyiZbvtFr6TxpDT5Rq2Rhy2P0UtkxQumRLumCY2ngsuwViVXvsZj6jaBNtwgsuksCl3S6Zd5lOG18h8mOEtYMW4bufao/bgG0cu0lq4Nv6dITY8++tOk0EIvOQVj6DsCqcy+UWxnTpq0tB/LLCR4/h1Y2Hrh27cfImHhmLdtG0IgYWrf1QEXHlIaKuiioG6KsbYKipgm6re3RM26Hma0nLSzsUdPSpYmiMmr6hiRu2kFq4Wkyck+Rk3WKVZt3sHLTdrbuO8z6HXtZu2MPcQkrcPfxZ86ylRSWXuR44Wk27T7A+Wu32XEwiTOXrrLzUDJHMnPIP3OO0xevcKLkPDsPJTNj/kKGjh7LxOmxLF65hgVLlxOXuIKVG7dwJOM4Ow8ls2HnPvanZFJ+6x4l5TfILirlbMVNTl++z4U7n3Aw7xQOAVFY95uM05C5eI5bhd+sffRfkk7ElmIid5xl0v5LTN9/kUl7ihm28gBOA0ejb9+RecvXM3XKRGyNNDA1bUmTZk1R1TFErqEGyjoG1GmijHxzLdS0jNBoaYW6gbUkaJm1Q9PcFS2LDuhYuqNn7YmuXSf07CULig2c/GQhq417b8w9AjDvHIqF72DJJMtvKJY9hmDdczhtuw3DLmAMLgOicQuehlvYHDqEzZOFLZchs3AeOkv2FwrSsCU9Qug8fCEOYfNoN3AKVoFRtO09DsuA8bKw5RS+kPbhC/Ecu4wOoxJwG71EErrGrqBz9AYC5x8kcMERBsSnELrsGIMS0ghJzGTY8mOETluGj5UTUx3d6ermgaG+LS5GbTDSN0Chvjxq8kq01m6JtZkTKvItOHywgMffwJdfw9OX/8f/fQMFpz7h/nMoPOLKlbwm5O6RY8eCD4ibVo/F8xTZsUyOTQlyLJkmx8Lo+iTM/oDY0XLMmyjH8tlyLJpUj1ULNFkZb8TS+S1YPL0B8TPrMiNKjsmR9QgPliO4txwBHRUIDpDDrqUcZmrqWKpo0rONIxM8Awn2cMVRU422zRXo1r6dCFv/QpWVlXz66afEx8djaWmJtrY248ePp6Sk5J2/SX/y5AkVFRWygovy8vJq4UkaQKq+ef4zBR41n3c5Wfmjb8o//fRTWWDMz8+ntLRUFgALCgq4fv16rRx5fB/B69WrV9y+fZu8vDySk5NJTk4mNzeXGzdu1HrJhXQPl7RdMzc39w+F89/7MaoelZUG+AcPHlBRUUFaWhpqamrY2NjQpEkTPDw82L59O19++eX7/jEX/mYibP2L/Fa4UmxYj0Z16iBfrx5qTZvhPz6WEYv3E7rgAP1n7yJg9g5Zvbu02l36n/4xG2UNhF2nrJfcNRm/HM8xS3AftRi3iHg8w+dJJgBDZkn+c/AMnINjcB8SS6eR8/EYnYBP1Aq6Rq95+6yT3N16+0iXI0uLN6Rhq9OEVfhOlAQur7HL8RyTiOuIhbiEx9F+6DwcwubgGCKpgbfpH41lnwnY9ptEmx5jaNNjDOY9IyUlGX4jMOkajnGX4bIJV+vOQzDykUy3jKvs32rlPqDa09Ktf7WnVYcADNwCMfEagIVvCHZdQrDsPAg9KxdaGhvh160j4Ut2oaCihXF7f5y69Cd0XCxhUbPp2DsMI2s3FDWMaKKsi4KyHqp6xmgbWtDC1AZTG2daW7iiqmuGqp4xzl7+pJ4o5khmDofTj3E0LZO8U6WkZRewYfteDiRnkpqbz+w58+gROJD4VdvYsHMfuw6nsOdoGrnFpZw6X8GB1GPkFpdSdK6cwtJyVm3exYmSi+w8lMr8hBXMilvCyg3bmBu/jI079zAvIZGZCxYRM2c+e44kk7h2A7sPJ5FdVML5a7cpvXyDsis3OXnlU85dvsnJsgqCpizBachcXMesxGfaTvrGHSY4MZPIraeZtLuUqXtLGbU+m5ErknAPmYhjlz7s2rmPgUH9sLI1Q07uQxQUtGmmqEMTZV3kVXRppqmPopYByrqSBkctQyu0WtuhaeoomWZZuaFr5Ya+jQcG7bwxatcZI0dfjFz8MHLrJptCmnkPkATjrqFY+Q3G2j8Ma/8wScV7z5E49onEuf94HAZNxjl0hmxpscuQebgOnS/bq1X1LxG8RiXQcZRk6bbnsLm4BE3Hts9ELHuNw7LXOGz7TKTdAEn9u9Ow+TgNm4/z8IWyvzTwHrcC38nr8J+2lV6x+wiYfZCguKP0iUth2OpsIpYn4eMXSrCjN36mVnR26YRFC2PsjNui1aw5CnUb0vTDxhhrmuBg5Iy6fEvOnLnHjU+/5/OX8OLr7/j06RsyCy9zuvw5BeUvOFu0jd3L5Vg/R46545SI7F+fscFyLIyWY8l0OWZGyjFhmByjB8sxbVQjxg/+gJiRHzBnohwr41VZOleLRTO0GTtEjnGhDRnkJ8fIfvUJ7yfH6KEKhPaWY3CPhpiqy+OsaUygmTMzegbjZ2pFB3M9rHXrMsLPjh5mxjSo15AG9cRS43+ryspKLl26xKRJk9DV1cXCwoL58+dz8+bNd/omXVpwcf78eTIyMjh+/Dg5OTmkpqbKAkhtHQt71zu8/sgb9JSUFDIyMkhJSSE/P/9vuXf05k31Uo9jx45x4cKFd9amWDNQVi1JkYbcqiUXt2/f/luOddY88vdraw1+6/d68OAB586d+8USmLKyMiZOnIiuri7t2rWje/fu2Nvbo6ysLILW/ygRtv5FfitsNW/cEPn6H1K3XgOM2toyavkugubtZMCc3fSasbnaDq1u0zb9bNiShiHvqJV4jU3EY3TCj5Xvw+fiNnQ2rmGxuIbF4jAgGocB0biETMNj6Cw8IuLpNDYR36gVdB6/HJ+oVdUCV9WwVW2qNXE1nSesrha2PEYn4BYRj0t4nOQNbFgs7UNnYD9oKjZvj3C17T0O856RWPQa++Ny47eBq2phhpFPmOw4oTRwGXgMrPbUDF8GboEYuvfBuGN/2vgE0dYnCMsuIRi5+GHm6ExooAfB0xbhFDAKHf3WaJnYY+7kg7NvHzr49ceivQ+6RjY01zSgiaI2ipqtUNM3QdvQAkOLdphYuqFjaI2SlgFzFq/i0PF8ko7nsftwEhevXGf7viPsO5rOkfRs1m/bw4pNW1iydBkdO3dj2YY9rNm6i9ScAg6lZ3H14/scSs/i1PkKis6Vs+doGknHT1B6+RbHCs6Qc6qMnJMljBg7iaWrNzI/YQUzFyxi0fJVxMyZz+xFCazcuIWZCxaxaddeTpScJ7e4lLzTZZytuM62I8cpOHuJlOxC9hw/Q/eopfhN2UjveYcYlJDC8C0nidp3ljFb8hi3OQv38HnotPNhyKhINm5YQ7/e3dHRVqdRMyWU9Ixp1lyXpip6NFXTp5lGSxR0DFHSM0alRVs0DO3QMrFHy6w9Ohau6Fp5oG/njb6dNy3b+WDk1BUzF8kkq7V7T1p79MLUewAWvsGYS4NW96FY9xiGTc/h2PQcjm3v0dgHSpoHXYOicRk8XfIXBkPm4j50gSxkVX1k97VGJeA8ZAHtQ2fjFDQNu0BJ0DLzH4VFj0js+k7Cps8UbAdMwy4kFvvQWTgNi8N1RDwdRr697zV+NV2nbiZg9j76LzhMQGwKIzZkM3xKAt423vRt44Svgz3mBoaY6LTGWEcLdXl5VBo2QbOeElZ6bbExcMTdpit3HsK1u9/y2VN4+QqufvSS1Oxyzl1+QdG5pxSUPWXbxiEc267LviU2eNs1YtTAOmxepMbWJQpsWizHpng5ti/7kD3r5di3uiE7ExuyaVFD1syrS+I8beJnahA7QYFRIXKE9m2If0c5enaqS2DXOnTvKMeY/nIE2MvhpdWaeP9B9LH1pa2eKU4tmzKsewuiB9thpi2HSoMPRNj6D/n+++/Jzc1l8ODBKCkp4eHhwbp163j48OFffjMsLTw4deoUqamp5OXlyfYOFRYWcuvWrVqfhLx582Mb3ruudJcGLOndsRMnTlQr7ZBO8KT3jt7Fnqzf+0iDl7TZ8M8Er6olJdIpUs0iiF/7nv/R5ct/5ZH+WS9cuCArVLl48eJvfs5PnjyhvLxcVn5Sc9fX7du3iYuLw8rKCh0dHaKjoykvL6/2M/Ts2bP39NMrvG8ibP2L/FbYUpZvRNP6csg1aUKnoWMZs/oo/WbtlEy05vxYgCF9aoatqscIvaNWVptquY9ajPuwObgPm4NrWCzOoTNo138S7fpPwnHgZJyDY3AbMp+O4YvoGL4Ij2FxeI9bISvN6DJJcnSw6tN50hpZkYC08VB2ZPHtx3YdsRDn4QtwHTob57BYHEOmYzdwCtZvp1uWAeOx6DVWdndLGriqFma07jxEVpYhDVzSY4VVjxdWfYw8+mLo3gcjj76YeA3AsnMw1t3DMfLqh46NKzYOVqzasIZeUzfQQNkABU0jtI2saWXuiKmtG0bWbrQwsUddz4QmitrIq+iiqNkKVT1j9IytMLftiJWjN1btPck8UcLx4jLOXLpKUdkF9h9J5uMHT8k7VUr88rVk5J5k0559zJg5i159g0hYs4P1O/ZyJDOH7KISkrPyOZKZw4mS86RknyAtt5Cic5fJO32e/DMX2H0knWP5p4iaGsu6rbvZsH0vsXHxsr1bG3bsZurseazYsJm1W3eweNV6jh7L5VhBMYczssksOsexwlLOX79L4YXrjF+yk94x6wlakkrYymwitpxk3PZCxm1IxX3IVPQcfZkdn8iKpfPp4uNJ06byqGm2QF5Jl3oKmjRV0aOZegsUNFvRTNcQhRZmKLVsi6qRHRomjuiYO6Nj4YqelRd6dr7otuuCbrsutGjvj4FLD9p49MOso2SSZdZpIOZdQ7DqPgTLbmFYdR+CdUAENoGjsO0z+u0ThX0/Sb27S8g03IbG4j5sDp7DF0heq2/LXtzDF1Y7Qij93z1GJkjuDg6KwbrX+Ld73iKx6BGJZa9x2PefhkNwLM7DF+A+ajHOwxfiEr6IDiMX4xO1ii6Tt9Fjxi76zNvDgIX7Gb7qCF16DqGnuSsjLNzwdnCgpYYmji1NaVtPFc2mTVFp0IwWzfXpaO6Ok6kL9laduHTlOeX3v+b+C3j+Eq7eeklq3k3OXv6CvFMfc6r0U06XlrEkzp+1cwIpzMwnJ30nK+Kbsnd1PVbO/5AtS1qyY4UBe1Zqc2BdM/aulGP3yg9Yu+hDEuc3IS5Gj/lT1YkZW5+JI+oSNVKO0WF1GNrvQwb2kCOka33CvBQZ7tqGcZ0C8NDSx0FbAzcrbUYNbI+Nhjxmak1pa2jEB3KNRNj6j3rz5g179+6V3T8JCAjg8OHDf+iNsrTKW3qU7+eqvKX3rKRvyE+fPi3bR/R3hJBLly5Vaxb8I0fQpHfMpM110oD1WxO6mguKpdOf2g6b0jbFS5cuyY51Xrx4kYcPH/5iCKnaviidFv2ZY3rSApWq7YJ/V5HJw4cPZZ/zsWPHOH/+vKxQpOb9wprh+9GjR2zcuBEvLy+UlJQYPHgweXl5/PDDD+/7R1T4hxFh61/kt48R1qdZAznktbWJXLePoUsO0m/uHkmImrmBHjMkgavnzK3VplxVJ1vSo4QekT9Ol6Rhy23obFnYah88DceBk2XTrXb9J9E+KBbP4QvxGbWEzm+PUPlErcInapWkPOPtNMs3eu2PRxXfhi3pr5HeEZN+bNcRC3EaNh+34XNxHTqb9qGSRcdWgVHYD5gsuztj3n3UL4YtY19JM2HVwPVbYau1Zz9Z4Grt2U9yRM1/KMY+wRi4+aNq1Z6powfSe9oWHPtG07C5DgqaBihoGqBl2Bat1na0NG2HfmsrVDUNaaCoSVM1fZprG6JtaEEr0/bYu3ZhWORkCs5WkF54huILl9l58Ai7Dxxm1cbtLF6xjvScQhavWMe6HbuYGjOdTl17sm7HEbbtP0LZlZus2bqLjPwiUrJPkJFfxN6kdE6dr2Db/iROlFykpPyGpOyi9BITp81mSux8lq/bwtzFS5m5YBFxiStYsnodCavWsnjlGqbOnkd2UQn7UzJZu203haUX2X4gmdyzFZy/dZ/S8uusOlzAwJkbGLoqi6Grc4naWsygeXtxC45Bz86XyOnzWRA3B38vZ5Q1tKmnqIJ881Y0aKKPqlb1iZZCC2OUWrZFxdAWdWMHtEwlJRh61p7o2XZGz8GfVs7daeXcHUPXnph4BGLq0R8zr4GYdw7Gwm8wlj2GYNN7OFY9h2Ldaxi2gZHY9RmLfd9x2Pcdh22/SdgPmIxTyHRcw2JxGxqLZ/g8vEcuolNEgmydgTRwSe8gSidbjqGSXVr2/aKx7DEW8+5jsA6IwrbPRKwDorAKiKZtYDSWA2KwDZ6J64h4SUX8qCWSwpgpOwiYvY+QJUcYtioFD1tPgozt6dbGGlMbayzUDTFspk1LDV3kPpCj2QcN0ZTXoKtzIF7W3vh06M1nj6Hso6+48vAlL76B8isPSMq9Q1H5M44VfUTJpfsczz9Hyt4LrI+fz6dXHnAk/zRPHn7F6kRVti1qxOZFrVmxuAXrl7dm3WINNiQ0YkNcA9bFN2DBTDnmzGzOrPF6zByvxNihcowZLMfYUDnGDKrLkB51COv+IWE+dRnibM0Qx9446epjbKjPYH8zZg+xRKepHJY6epjrtkC5mTx168mJsPUfV1lZyePHj1mxYgWOjo6oqqoyYsQITpw48bOB6Oeqwn/vktoXL15w48YNCgoK/pbjflXfkFdtFpRObX7u3ljNgCWtnf+zRyBfvnxZ7djdn6lW/6vB6/jx49X2h0nvfkmPIL7rvWLSvVZ/d63769evq9W0S++YFRYWVrvP9/LlS44ePSpr8PTz82P//v189dVX7/vHUfgHE2HrX+S3CjKafCCHfMMPsAwYxIiEIwxauJPA2VvoNWMrfpPX4zd1gyxc9Zixhd4zt9Fz+ha6Td0o24/lP2UDnSespmPkMjqNiZeFHLfhc3EfNocOQ2bhHDqD9sHTaB80GYeBk3AYOAnHQdF0CIrBLWyWZLo1UtIo6BOZiO+45XQZL5lydZu6UTbt6jxhNZ3Gr5TUyr+dbEmb36ruNXId8WMxh3PYXNqHzsYmeCptB0yS3OEKGI9lwHjZsUKz7qMx7Roue8z8Rsj2bxn5hGHkE4Zhp8EYdhqMgXcorbxCMPAIqvYYug2o9ph2HICFTzA2fkMw9uhHU/02ODo50CU0ksD4FFRb2dNYUYfmavqo6prQXNMAVZ3WaOib0lzTgIZN1Gkgr4aqpiGGJrY4uHbF1NKZ/SnHOZh2nEOpx0k5nk/imk0cTssiq+A0+5My2Hc0nU079zNz7iLGjp2MlYMrmw8d5donn7HrcApb9h7iYNpxDqZls+NgCqcvXqPg7CXOXb3DiZKLlF25TXZRKQUXylm7bTcz5y9m+ZpN7Dp0lMS1G1i8cg1TZs3lQEo6iWs3sGXPflZv2sGB5EzOXLhCUmYuablF5J+5QEZ+MTmnysgsLmH00v2ELMsmdOlR+kWvwD10MvVaWjJ78SomjBqJi2N75JspU7epGg0UVWmopIG8sh5NVVuhpG6AkqYhyrrGKLcwRdWgLerGdqibOqDd1hVdGx/07HzRd/SjhXM3Wrn2wtizL8aefTHzHoBVpyCsfEOw8Q/DtvtQbHuOwq7XaOx7j8G+9xic+0/Cuf8kXAZE4zpwMh2CJ+M2eAauYbG4hy/APXweHiPm0zEiDq9RC/EalSBbaSA9RugxYhHeo5fQMWIxTmHTcRgQjV2fKKy6j6ZNN8lj3n0MbXuOxSZwAg4Dp9E+ZC7tB8/DLTwe57DFuI1ahm/MOrxi1hAWtwNfrwGEOXSmh7kjnsZWWOoZYqCuTUtVTZTqf4hKw4aoNmyORjNNBnTuh4u1B6OjE/nkCVz55DWfPoeHz+HYiSsUnn9A1tn7VNx6zrFTV8kquExpwU0Ob0vh07tfUHb5LrknLnD30VekHt/MseRpzJ2kwuKpTZk+So6E2KZMGy9HfFQzIoLk6OXTADMNOXycG+Dv3oiB/k0YPqAZgwc0IiK4MYN9GxHe0ZQpPSLwNtbHSdsCP4dWDO9mgoe5AjatlLE1aY2Vng4GqirI16tH3bp1qV+/IfXri7D1v6CyspIbN24wc+ZMDAwMMDIyYvr06WRkZDBr1izZscCSkpK/vAT32bNnsuW3tfGG/9fekNe8j3Tt2jXu3LlTLWBdvXr1nd8xk4ZNaVAtKSn520o97t69S0FBAcnJySQlJZGXl8etW7dq/WP/nh1j7+pzvHfvnuyY58mTJ7ly5Qrl5eXk5eUxc+ZMOnXqRI8ePVBXV8fBwYGVK1fy5MmT9/1jJ/xLiLD1L/JbYUuhQV0aNG1K7xmLCFuwj4BZG+kxfT09pm2WBKm3RwWlT7epG+kes4ke0zbLfo3f5PX4RK2SVL6Hz6PDsDl0GDYHt+Fz8QyfJwtcrmGxOAVPwbbveGz7jsdh4CTa95uIU9BUXMNi6TBsnmwyIK2Gl066ukavo2v0OnwnrpGFrZqhq2bYkr4RllbBtwubgW1IDO3eLpe1CoyqFrjMu0Vg3i2CNv4jMfMbgUmXYbIpV+vOQ2TBSxq2DD2Dqz1G7gOrPcYe/TDzGohVl8GYdwrCoVswLU3N6do/jH7T19A1bA5y8pqoaevTqLkSTVX0aKykjaJ6S1R1WiOvoom8iiaNmqvTRFWLpppGDBo+jiOZeRScvcDlW3fZn5RB8rE8duw/ys4DSWQVnGbvkTQS12xi7aYdDB8eib2LJ+v3HWTP0TRSsk9wIPUYh9KzyDp5lu0Hktm2P4mM/GLyz1yg6NxlMvKLyTxxmpJrkinYtDkLWbNxOylZuazfvoups+cxa+Fi5sQvIXHtBrbvP0T88rWs3LCNA8mSoo6sk2c5ffEaJ0oucrKsguOnz7JkTxZD4vbSfVIC7oOiaKBrwujoSfj5euLq6oaGpi4NmyrToJkGjZqrI6+iTTO1lihqGKGsbYKyrinKLc1RMbJErbUtmm3ao2nujI61Jy3bdaWlgx+tnLtj8HYpsZn3AFkBhrXvYKy7hmHbfRi2vcKx7z2GdgGROPYZR/u+43EZOBnXQVPoEDRV8oROxX1ILC5DZuE+Mg6PEfPxHLkAr1EL8R4t2RUn3SFXtRzDe/QS3MMX0n7wNNr1n4Rt4Hja+kf8JGzZ9pmITZ9oHIJm4zI0DrcRC/GcuB736HV4TV9LcGQcPlaOhNi6E2jqhb1ZWyxaGmGqpY+xhi7KDeuj1rgZGo01cWrjToBrT1zM3IlfuI3rd6Hiztd89gJuPXxDck45xZcecvzUHYrLH5N/+iapx8oozLvCzpVHKPz4Ifc+/4qi3HN8/PQ1uScvcOvWQ/7v32xhEwAAIABJREFU6ZfMmmrL+EGNCPKTY2xoHUYO/JCw7nUIHVAXUyM5VBspo1CvKSqNmqLeqCE6jepg2fxDPFopMtzLiWGu3pioNcHFoB3dXJsTNdgUY01FrA11aNNKG12N5rTW0UahfgMa1KlL/boNRNj6H/X69WsiIiJQU1Ojfv362NjYsGLFCj755JN3/oa86jQiOzuby5cv13rVt/QO1smTJ2UBJCsriytXrvwtd8ukE0JpqcfZs2e5d+/eOw0/0vp26STx7Nmz3L17l88++4yLFy9y7NgxsrKyuHTp0k/2m9Vm8Kpajf9XmhtrlrLk5eX9ZPn11atXmTVrFtbW1tjb26Onp4eCggLz5s173z9iwr+MCFv/Ir8Vtpo1qo+6UVtCl+9g8Py99JyxDv+pa+ges0myZHh6jZKMqRvxm7we34lr6DxhNf5TNtA1eh3e41bgFpGA69s6bJchs3B+W4rhMngmzqEzcAqZjsPASdj0GYdNn3HY95+AY7+xtA+ajGvYDFyHzpYdyfIalSCZEkQuw2vscrpMWis7NugTJWkilLYRSuvfa4Yt6REv16HzcRo8B/vB07EJnor9oKnY9puETd+JWPeZIAtclj3H0LbH6CqB68fSjKrBy7DTYFp5hWDUsfrT2mNQtcfEsz8mnv1p2zmEtp1D0HfugaGtE1mFRbj496XfjA000DJFrm5jGjdtToNmGjRW0paEDUUtGqvoUreZOvKqehhYtKNd516knCghJbuQvUfS2Lb3MDknS9i0cz+rNm4nu/AMS1dvZNnazSSu2UTC8rVERcXg0tGXbUdT2JuUzo6DSRSdK+fU+QoOpedwvLCEXYfTOJyRy5lL1zlbcZNVm3dRduU2WWdKyTxxiknT57B5xz42797HwdQMlq3bSPyK1cTGxbNy4xamzp5H1NRYVm7YxtY9hziSns2uw2nEr9xAdlEpmSdOk118hvTii4yZsxojt26omrQjInoiba0MsLO3pHEzdeo0bk6dxs2Rb64lCZdquihqGKCsbYJKCytUWlqjamSHmkk7NNu0R8eyA1rWHdFt1wXD9t0wcu5Ba7feGHtW33dm7TcYG79h2HYPx7Z3BLZ9Rv8YsgZMpMOgaFxCY3AdPI0OYdPpEDYdt2HTcQufjcuw2XSIiMNz5AI6RsThPXoRncbEy/5SwGPEItkyY+lrtsOwBTiETMWu7wSse4/FvOuIn51sWQdOot2gWTgPWUCH8Dj8J65kQOQievQcTv+2ngywdMTdzBw9vRa0btEKPVUNVBo1RaFOA5TqymOsaUZvr750de2Goao5np4DKLnwklsPvuXT53Dt3tek5V/hzNWXpJ+8w9krT8jIqyAr5xJpKWc4erCQW3e+5OOnP3A07TTPv6zk6v2HPHz6gDdffc2jz17z4stSEiY0YeVMeeZGyZEwTZnZ4+UYHd6EpvJyqKmoUr9uA5QayqNStwF6DeXppG/NGN9A+jq5YautjamaDtMmtcHJ8kMstVtj09oEU119TPR0sTY2QlVJkbof1qF+3QY0qCsvwtb/qO+//57x48eTk5PDmzdvSEpKIjAwEAUFBfz8/Ni1a9c7n/xIiw/Kysp+sSXurwYsaZW4dM+X9Dih9J5Vbe6Q+qVHukA3Pz+f9PR0ysrK/vTxSumxRek9ul+7Iyc9XiktmpDe2Xr06FGtf841d5JJFxn/nuD19OlTLl++THZ2NsePH+fSpUvV7pndv3+fVatW4ezsjIqKCiNHjuT06dOyhcMPHjzg4sWL7/knTPi3EWHrX+S3wlbTRg1x8B/A4HWHCJ6zi14z19MtZi3dYzbRNXodPWZsoVfsNln1u9/k9fhNXo//lA2yo4Rdo9fhNXY5HUYulgWt9qEzcAieJtt1Jd13JZ1q2fWLwq5fFPaBEbQbEIVTyFScwqZXXwxbZQ+XT9QqWciTTrM6Ri6rdoSwZtiSHvOS7t5qP2wW7cJmSP5sVQKXdMJl3XssVr0iseg+ijb+koXH0ntcpl1/rIaXhq3WXqHVnxphq423JHCZdwqibecQ7AMjMG7fEUtrKzZu347PpAQGTZjNhw1VaNxIXRay5JvroKZrjKNXAK6+/TG198bA0o3A0RNJO3WOo8fyOXX2ItmFZ9h9KIVTZeVs23uYhYmrSTmez6qN29m0cz8r1m4mLi4RJw8f9h/LZveRVPYcTaP4wmUOph1nw84D5Jwqo+L2p6RkF3Lh+sccSM3icEYuOafKyCu7QOaJU0TPmMuSFeuIX7GanQePsHz9JnYfTiIzv5CZCxaxcNlK5iesIH75WnJOlrBt72F2HEwhOauAwxm5FJ27TP7ZMs5W3GTGotUYt+/I9EWJmFubYdPOhEYqanzYRA25Rs2Rq98MVc1WNFPXQUFDn+ZaRqjomKLW0hY1AzvUjB1QN2uPloULOtaeaNn6oNe+G62de2Ds2ktyP8tLsuvMqmsoVl1Dse02BNtuI7HtOQqbgDHY9ZMELef+E+gwKBqPkKm4DJ6Ga9h0OgyZgdvQmbiNmInbyDk4h8/B9W3Y8hq1kE5j4vGJ/DFoSQsy3MMX4j1acgzWZcg82gVPwbZPFFa9ImnTJfwnYcs6IArbvpNpN2gW7QfPo2P4YtwCxtPVrjPDTR3xsDDHqpUtpsr6uLfUQbdJc0nIqt8YTUVl3Kw96eU5CDsjRwzUdImZlsilu19z7ircfPgF1z59yZFjlyi78hWpRZ9QeuM16Seukl98g60bUygtvsPx7ItcfPiGo2uPc/3Wcy49esYnj5/y/NkPXLx4nR++hRu3HrNsqReDQuozc74J2/eGsHZeXbq5yaEmr0Ojeh/SrJECzRso0LKxCr1s3Ijs0ofu1u0x12xOZw8jRoXIY6lujLFma4xbN8RCXwdTbS2sW7bEVE2D+g0bUK9eAxrUa0yjOk1F2BKq+eKLL9i0aRPu7u4oKSkRGhrKsWPH3nkoqbn/qKio6E8tMJYeGywrK/vVhcRVnxcvXnDz5s1qx/3u3r37t5R6SINEbm7u796l9S6WPde81/Z3B6+fa3qsGualRzClk8CysrJqX5fnz5+zb98+unfvjoKCAoGBgaSkpPDNN9+87x8Z4T9ChK1/kZ+Eq4b1ZOUYTRvWo2FzJXrMXELInB10n7JKVuUu3Z3VK3Ybfeftps/cXfSetR3/mI34Rq+l27RNkmKMSavpPGGlrO6944j5OIfOwDEoBqeQ6TgOmIRD/4k49J+I44BJ2PefgFVAJJa9x2AdOBa7PuNxHDCJ9gOjcRs8HY9hM/AYPpsOw+bgHZkgK9roNH65rPK904RVeEdJJlzSI4ReY5fjPW4FnmMScYtIwC0igQ4jF0umbSPicRoWJ1uq3D50tqS8YNAMbAdMw6rvFCwCfmwptAwYj3nPSCx7RdK25xjMu4+S1MT7jcDMbwSmXcMx6TJcdo/LwDsUA+/Qn+zlau0VTGuvYIy9QzDrHEa7HiNp7d4X3dZt6NXTj6EzF+MemYi+qQ11lFvRwsQWJ68eWDp3pYmmGQZmThhauGBg6UorK1cSN+8h9UQx2/YfoeTSZc5eusaU2Pkczcjh4rU7xC5cwrGCYlZv2cm67XuYk7CUKTFTsXdyZeuBJM5WXCfpeB65xaVvSyyOknniFEcyc8g7XUZ2UQn7kjPYeShZtofrUHoWUdNmsXXfYXYdOkrSsWyyTxazde8BDqZmsHXvASZMm8mqTVvZfTiJDTt2s2HHbuJXruNA6jGOHsslOSuflBMFHCss5XBGPpNnzMDO3goTM1MaNWtOXXlVGipp0ai5Nk1U9VDQaElzDUNJ0NIzQaWlGcqGdqi2boemWQd0zDuibeWBnq0XrRw609rZDxP3fhh79KO19wBMfYNp02UQFn6hWPcYhl2vCGwCJK81+75ROPSfiOugqZL7gsHTcA+ZLltP0GHILNzfHoHtMGwO7uHz8By5QBakfCIT8YlMrFaQ4TFikawcw3v0Esnrq99ErHuPxSZgHBbdR8nuAbbxH4l177G0CYjCatBsOoTOxSdkGt19QvCzdqKHrSMOBpZYaLXAWE2HVspqqDVugmK9RqjJK2PewpweXr1wt/HAXKs16s1acvhIGeevfsfFG19z/wsovfCUnIKPOHX+CSdKH5JdcIvcMx+RW3iVIzuO8cmNr8k/c4Oy249ISirj4p1nXProPs/e/B9fPH/NzXMfcffBN5y99YwnL+G7b75ldtxczlwpZdrsSfj7alL3AzkMW1lQ7wPJvTFHPVPCO/Qg3MMPx1ZGWOko0cvTFB8HPcxb6lZ7LHW1aauvg5meHvqqarJwVfMRhKoqKyv55JNPWLBgAebm5ujp6TFx4kTKysre+XE0adOddFrzW+GnZsD6tUKM33qeP38ua7OTvsmXNt3Vdgh5/PhxtV1aVZsFpUUe0oBSWFj4ztr/qtbAZ2ZmkpOTQ0VFxTtdJvxLjzRknz17lrS0NLKysmT72k6fPl3tjtvr16/JyclhyJAhKCsr4+7uzubNm3nx4sX7/vEQ/oNE2PoX+UkhRgNJI2GTBpIjhAb27QlJ2E7/mM30mL62WtDyj9lI9+mb6RW7jV6x2+gxYwt+UzfQZfI6/KZukIUt34mrZGHLZfBMXAbPlAStoBhsA8dhEzBW9mbXJmAMlj0jsOolmTJY947ENnCc7E2wU3A0rmEzcBs+l46jJc2CbhHxeI1NpNOEVbKg9XNhSzrZkoYtt4gE2T/XLMxwGjwHx5BZtAuaiU3/GCz7TJZNuWz6TsQyYDxWvcdi2SsSix6jJc2F/iNl97kkgWtYtRKNmnu5jDoGYeg5CKOOQRh7h2DtF04bnxD0rZzw7NyZ7j398Jm4Er/IRTRQ0kZJ0xAnrx7ErdyJsZ03ShomqOm3Rd3AGkvXLiTlnWbb4VR2H0ml+Pwldh5IYtfBZIrPVbBj/1G2HzjK3qR0FiSuYsPOfcQtX8nQ4cOwtHNg4cr1JGflczgjm6yTZ0jPO8mB1GPknzlHbnEp567eIj3vJCnZJziSmUNGfhFF58o5UXKeuGWrmb90JZt27WXdtp3sPZrC3qMpLF65hrjEFcSvWM2qTVvZn5zGsnUbmTJrLpt2H+BIZg6H0rNIyy1kza7dpOWdpvTyHXz8/VFT16SpkgqK6rrUa6ZOo+aSqvtm6i1Q1GwlOTqoZ4ZKKwtUjCxRNZFMtLQtPNCz6oSuXSdaOPhi6OyPiVtPzDwlhSSmnYNo0zUUq+5DsOk5HPveY3AIlISsdv0m/Bjsw2biFjaTDoNn0GHwDDzD51V7PEbE4R6+AM+RC+kYsYhOY5bK7hH6RCZKFhe/DVyyRcZvjxbaD5qBbeB42bFUi+6jMPMbgXm3CCy6j8I2cDzWAROxGTiWrj2G0Me+C/0tXelqYo5VCwM0NPUw1dBDX1GdZh80plkdeQzUjHGz8aJf1yDcbDqhXl8NCyMXyq9/zYkLX3Hh+jfc/BQKSu+TW/QJJRefcvr852QX3yY1+yLnC+6wedFurl57yuoD2bz8GpKST3Lz8TdcvP2YB8/e8PyL19y//4JHd7/m7EeQfecbnr/6P258/ITSS3coOHWRH76Db15/h5OjNy30jTmZlU4fY2fGePahj50nZurKdLNXJ8i3LRYtFDDSU/tJ2DLX08ailR6tdbRp3qixCFvCH1ZZWcn58+cZP348WlpaWFtbExcXx507d955KKlZ5X3u3DkePHjAq1evZEtvpQHr8uXL1fYo/dVHOnXKycmR7bP6tVr1d/VImwUvXrxIZmYmaWlppKSkkJOT87uP3v3V4CX9uubk5HD58uVaC15VC0zS0tLIycmRTbNyc3OJiYkhOTmZyZMn06JFC9q0aUNcXBz37t173z8Gwn+cCFv/Ir9U/d60YT0UGjegQ/+hDJq/naCYHfSIlUytukxeJyvG6DZtU7U2wq5TJA2FvtFr8Zu6Ab/Ja/GJWoFLeBzth87DKWS6LGjZD5iMbeA4LHuOxqJ7BBbdIzDrEoLJ2zfEbbsNoW2PUVj1GkO7fhMkk4f+43EKiaHDsDm4DJuLS3gcbhHxeIxOwGv8CrzGr/jFsOUxeqnsOKF095akEl7y36vuROowbAEOwbE4BMf+OOXqN0m2i8u6zwRsAsdjHTDuxwnXzxRoVA1bNfdyGXtXn2619hiEZbcILDv1QbmlGRMnjaVbSDjOYbPRaOOCio4xGq3a0qlXGCGjZ2DYxplm6q1ppmXCyMnzyDpziUPH88kuKuFgaobkqOD6rRzNyGHL7oPsTUonJfsEKdkn2HM0jcWr1zIwaBBGZhZMj1vC2m27Sc7K51B6FkeP5ZJ0PI/TF6+QeeIUl25+zNmK6yRn5ZN3uoyyKzdJyy3kUHoWG3ftZ8rsBUTPnE1KVi6Z+YXsOHCY1Zu3sXTNeuYlJJJ8PIcZ8xdSfvMOS9esl5VwbD9wlG37j1BUXkFO8QXScotZtWEDui3NaKSoQUMlDZpq6CGvoktTNX0UNVvRXNsQZX1LlFtYoWJoi5pJO9QtnNG0dEXH2osW9l3Qa9+Nli6SIgxTr/5YeAdh3imINl1CaNttCLY9R8qClmPgjyHLOWgKLsFT6TBkpuxxGxpLxxHz8Rq5AK+RC/AMn0fHkUvwHJEgacgclUjnscvoPHYZPpGJdBqzFO/RS6oFLq9RCbKGQqu+U7DrE4VlzzEY+w7DpMtw2VTLvFsENgHjcPUbgo9Hd/xtXejV1hFLI0PMVLVo20wTeyV91BvKo/ChPJoKWpi1sqabe1+6duiBvUl7jLVN6ds7gtMXXnHuY6j4DG7cg3NXX5F/5jPJNOvUJ2QVXiPn5BXOFVxjQ8JublQ8I+fMR9x7BvuSTvH4JZRevc2Vj5/w6OGXfHL9My5fe8zFzyC3/CHPvoO8wlIuXbnM48dP+fzRMx68+BK+h7ycXB7fu0J3RzMGWXvSxcweG10NfBz06OVhgG2r5rRtoUublq1+ErbM9LVp00oXPTUVGtT5UIQt4S/57rvvyMrKIigoCEVFRby8vNi4cWOtHEd7/PixbAKSlJQk26P0LgPWLz1/dYfXHwkfNY/3lZWVUVpayrFjx/7WqdPr16+5f/9+rQTaR48eyUo7cnJyfrJQ+aOPPiIhIQFra2vq16+Puro6Y8eOFXXtwt9GhC1BEARBEP5RXr16xa5du+jcuTOKior069ePpKSkv9T2V/UNv/SIW3l5OR999JGslS43N5erV6/W6sTn58JQ1SOLf7U85OfCXM3AWnPq9FeOS/6Zz7vmUc0/Gryq1v9nZmbK6v+l//+TJ0/YunWr7PUTFBREVlYWX3/9NTk5OUycOFEsHxb+NiJsCYIgCILwj1RZWcnDhw9ZunQpdnZ2aGhoMHr0aIqKin5X6cQfuUMk3bcknXgVFhZy69atd3KX6fcGkKo7vP5Im2LVY4qZmZl/6JhizY8tXcb8dwVOafCq2fJY89dK2xILCwt/drH1l19+SWpqKoMGDUJRUZHOnTuze/duXr9+/b5fxsL/OBG2BEEQBEH4x6usrOTq1avExMTQsmVLTExMmDVrFlevXq0WKn4uYP3RdryaLX3FxcW/WIP+rp9Xr17x8ccfy5b5njx5klu3bv1kqlcbBRzS8gxp4CwoKHinFfq/9bFr1utfvnyZmzdvyr4Wp06dqlar//r1a06fPs24cePQ0tLCzs6OxMREPv/88/f9chUEGRG2BEEQBEH4V/nhhx8oKChg+PDhKCsr4+zsTHR0NP3792fjxo3vtH5cWh0uXfBbc6JSm8+XX37J7du3KSoqkoWN0tJSCgoKar1aXhr6pBX6J0+efGethb/2SI97FhUVkZycTHJyMsePH6eiooI7d+7w5s0bbt68yZw5c2jTpg36+vrExMRw7dq19/2yFISfJcKWIAiCIAj/WjNmzEBVVRUFBQUsLS0JDAxk7969tXIMruZdoQsXLvD555/XavCS1tcXFhaSkpJCeno6qampnDlzhnv37v0t07aak76ioiJu3779l+7Q1XykdfXHjx8nOzuby5cv8/TpU9nEq6CggObNm6OtrU3jxo0ZMGAAJ0+eFHevhH88EbYEQRAEQfjXOnToEBUVFVRWVvLs2TPWrVuHi4sLysrKDBkyhOzs7FoJJNIiimPHjlULB+/i9655lLBmuHn27BlXr14lLy9PVmP/WwuM33X4k07biouLqx3t+yOP9Cik9PM4f/58tbtmX3zxBQcPHqR3794oKCjQs2dPpk+fTnBwMCoqKjx+/Ph9v/wE4TeJsCUIgiAIwn9KZWUld+7cYc6cORgbG9OiRQsmT57M+fPn33kgkd4Rk5Y8/NFyi6oBS1rQkZ6eTkFBATdu3PjN3+fJkydUVFRUW2Bc29M26fPixQtu3rxJYWEhaWlpnDlzptry4J97pEcjqy6avnfvnuzP+/r1a/Lz8wkPD0dVVRUXFxfWr1/Ps2fPqn2Pv/vuu/f06hKEP0aELUEQBEEQ/rN++OEHzp49y5gxY1BXV8fW1pbFixfz8ccfv/NA8urVKz755BPZPaeioiLu3Lnzi1OfmhXs+fn5XL169U/Vv1ddYCydtlVUVPwtu8PevJFMoa5fvy6723b27FnZfTJp8UZJSUm1SV3Vr0t5eTkxMTG0atUKY2Nj5s6dy0cfffS+Xz6C8JeJsCUIgiAIwv+Eb7/9loyMDPr374+CggI+Pj5s2bKlVhb7So/bVZ3g3L17ly+//JKHDx9y4cIF2SLed7Xg95dCXF5e3p8OcX/mkR5zzM7OJiUlhZSUFLKzs7l69Wq1Sd3du3dZunQp7dq1Q11dncjISEpLS6msrHzfLxVBeGdE2BIEQRAE4X/Oy5cv2bZtG15eXigqKjJw4EBSU1PfaelD1anPpUuXyMzMJCkpidTUVEpKSqot4q2tp+rxRGmd+40bN2qtVfDp06dUVFSQlZXF8ePHOXfuHBcuXCA3N5e9e/fSp08fYmNj6dKlCwoKCvTv35/MzExxLFD4zxJhSxAEQRCE/1mVlZXcv3+fxYsXY21tjZaWFpGRkZw+ffovHzN8+vRptfbC8+fP89FHH1FeXi4LI5cuXaqVydovBa9fK974K2Hy+vXrnDhxgvT09J8Udrx69YqMjAzCwsKwsrJCQUEBZWVloqKixBRL+M8TYUsQBEEQBAFJ8CovLyc6OhpdXV3Mzc2ZO3cu169f/93B6/nz59WCxy/t5Xr9+jUPHz6ULV/Ozc39W4/61WwVPH369B9a3Cytgz916pTs369ZjnH27FmioqLQ1tbGysqKhIQEPvvsMwAqKirYuHHje/6OC0LtE2FLEARBEAShhu+//568vDzCwsJQUlLCzc2NtWvX8uDBg58Ej5qtfCUlJb/ZylczeFU96ldYWPi3LBCuOpmqurj57Nmz1RoCq/45P/3002p/zlu3blWbjN2+fZsFCxbQtm1bdHV1mTx5MhUVFe/72ykI740IW4IgCIIgCL/izZs37Nu3D39/fxQUFOjVqxc7d+4kMTGRTZs2/eV9Uz83MZIuEC4uLv5DE6e/+lRd3Czd4XXr1q1fncB9/vnnbNiwAU9PT5SUlAgLCyM/P18sHBYERNgSBEEQBEH43Y4ePYqtrS116tTB0NCQsLAw8vLyaiUMvXjxotrE6ZeOJNZW6Lpw4QIZGRkkJyeTlpZGaWkpH3/8MW/eSI4hHjlyhD59+qCgoIC/vz8HDhzgq6++et/fIkH4RxFhSxAEQRAE4XfavHkza9as4dGjR9y8eZPY2FgMDQ0xMDAgJiaG8vLyWglDVSdOmZmZXLhw4Z0vL5Yeh6wa7u7fv8+rV6/4/PPPuXDhAh07dkRHRwd5eXmsrKxYtWoVT548ed/fFkH4xxJhSxAEQRAE4S/44YcfKC4uJiIiAlVVVRwcHFi6dCl3796tlanTo0ePuHTpkmx58eXLl3n69Omf+r2kDYW/dmzxypUrzJw5k9atW2NoaMjw4cMZOHAgqqqqbNu27X1/+QXhH02ELUEQBEEQhHfkm2++ITk5WXa8rmvXruzYseNPh6Ffe6TLi8vKykhPT+fEiRNcv3692uLg3/Pv/dzurU8//ZQVK1bg5OSEqqoqo0aN4syZM9Wq2r/99lvevHnzHr/agvDPJ8KWIAiCIAhCLfjiiy/YtGkTHh4eKCkpERISQmZm5l8u0filCdUnn3zCmTNnqu3QqvqxHj9+/KsTsefPn7Nnzx66deuGgoICffr0ITU1lW+//fZ9fykF4V9LhC1BEARBEIRaVFlZyd27d4mLi8PCwgJdXV0mTJhAaWlprdzvku7QOnnyJGlpaeTm5nL8+HEyMjJ+ctfr1atXZGVlMXjwYJo3b46HhwdbtmzhxYsX7/vLJgj/CSJsCYIgCIIg/E0qKyu5cOECUVFRaGlpYWlpyYIFC7h9+/Y7C14vX77k1q1bnDx5ktTUVPLz88nOziYjI4OjR4+SkpJCWVkZkyZNQk9PD3NzcxYuXMi9e/fe95dHEP5zRNgSBEEQBEF4D7777juysrIIDg5GUVERT09P1q9fz+eff/6njhHevXu32jHCO3fuVDtGeO3aNcaOHYuGhgb16tXD0dGRpKSkavewBEF4t0TYEgRBEARBeM9ev37Nrl278PX1ld2XOnLkSLXSip8runjw4AHnzp0jIyOD/Pz8nxRkPH78mM2bN9OpUycUFRUJDg4mKyuLs2fPEhUVRWxs7Pv+1AXhP02ELUEQBEEQhH+IyspKPv/8c5YtW4a9vT1qampERERQWFgoq2N/+PAh5eXlZGVlkZWVRXl5OU+ePJEFrC+//JLk5GQGDBiAoqIivr6+7NmzRzQHCsJ7IMKWIAiCIAjCP1BlZSXXrl1j2rRp6Ovro66ujqGhIV26dOHcuXM8ePBAds/r9evXnDp1isjISDQ1NbGzs2PZsmU8evTofX8agvA/TYQtQRAEQRCEf7BNmzahoKCAl5ekYjskAAAC50lEQVQXAQEBqKqq4uTkxIoVKzhz5gyzZ8/G1NSUFi1aMG3aNK5fv/6+/8iCILwlwpYgCIIgCMI/2JMnT3j16pXsn7/++msOHz5Mly5dqFOnDuHh4RQVFYmiC0H4BxJhSxAEQRAE4V/qq6++et9/BEEQfoUIW4IgCIIgCIIgCLVAhC1BEARBEARBEIRaIMKWIAiCIAiCIAhCLRBhSxAEQRAEQRAEoRaIsCUIgiAIgiAIglALRNgSBEEQBEEQBEGoBSJsCYIgCIIgCIIg1AIRtgRBEARBEARBEGqBCFuCIAiCIAiCIAi1QIQtQRAEQRAEQRCEWiDCliAIgiAIgiAIQi0QYUsQBEEQBEEQBKEWiLAlCIIgCIIgCIJQC0TYEgRBEARBEARBqAUibAmCIAiCIAiCINQCEbYEQRAEQRAEQRBqgQhbgiAIgiAIgiAItUCELUEQBEEQBEEQhFogwpYgCIIgCIIgCEItEGFLEARBEARBEAShFoiwJQiCIAiCIAiCUAtE2BKE/2+/jgUAAAAABvlbj2JfWQQAAAPZAgAAGMgWAADAQLYAAAAGsgUAADCQLQAAgIFsAQAADGQLAABgIFsAAAAD2QIAABjIFgAAwEC2AAAABrIFAAAwkC0AAICBbAEAAAxkCwAAYCBbAAAAA9kCAAAYyBYAAMBAtgAAAAayBQAAMJAtAACAgWwBAAAMZAsAAGAgWwAAAAPZAgAAGMgWAADAQLYAAAAGsgUAADCQLQAAgIFsAQAADGQLAABgIFsAAAAD2QIAABjIFgAAwEC2AAAABrIFAAAwkC0AAICBbAEAAAxkCwAAYCBbAAAAA9kCAAAYyBYAAMBAtgAAAAayBQAAMJAtAACAgWwBAAAMZAsAAGAgWwAAAAPZAgAAGMgWAADAQLYAAAAGsgUAADCQLQAAgIFsAQAADGQLAABgIFsAAAAD2QIAABjIFgAAwEC2AAAABrIFAAAwkC0AAICBbAEAAAwClLCciNUau0UAAAAASUVORK5CYII=\" width=\"959.2166666666666\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(172.0, 328.0) (129.0, 267.0) (-63.546772, 46.46999)\n" + ] + } + ], + "source": [ + "lm = fa.get_landmarks(im_rgb)[-1]\n", + "generate_3d_face_plain(im_rgb, lm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"959.2166666666666\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(172.0, 328.0) (129.0, 267.0) (-63.546772, 46.46999)\n" + ] + } + ], + "source": [ + "im = cv.imread(fp_im)\n", + "im_rgb = cv.cvtColor(im, cv.COLOR_BGR2RGB)\n", + "lm = fa.get_landmarks(im_rgb)[-1]\n", + "generate_3d_face_plain(im_rgb, lm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "\"RGB:0/51/153 (hexadecimal: 003399)\" for \"PANTONE REFLEX BLUE\" and \"RGB:255/204/0 (hexadecimal: FFCC00)\" for \"PANTONE YELLOW\" for the web palette (the limited 12\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + " # line weight\n", + "def generate_3d_face_anim(lm, fp_out, num_frames=30, dpi=72, stroke_weight=0, size=(480,480),\n", + " mark_size=2, mark_type='*', mark_clr=(0,255,0), fps=10, transparent=False):\n", + " '''Generates 3D plot of face landmarks\n", + " '''\n", + " # convert opencv BGR numpy image to RGB\n", + " bg_color = '#%02x%02x%02x' % (0,51,153)\n", + " mark_clr = '#%02x%02x%02x' % (255,204,0)\n", + " \n", + " # scale to make larger\n", + " #lm = np.array([1.2*x,y,z] for x,y,z in list(lm))\n", + " \n", + " # center x,y,z\n", + " xmm = (np.min(lm[:,0]),np.max(lm[:,0]))\n", + " ymm = (np.min(lm[:,1]),np.max(lm[:,1]))\n", + " zmm = (np.min(lm[:,2]),np.max(lm[:,2]))\n", + " \n", + " # make copy of landmarks\n", + " lm_orig = lm.copy()\n", + " xmm = (np.min(lm_orig[:,0]),np.max(lm_orig[:,0]))\n", + " ymm = (np.min(lm_orig[:,1]),np.max(lm_orig[:,1]))\n", + " zmm = (np.min(lm_orig[:,2]),np.max(lm_orig[:,2]))\n", + " \n", + " # swap the y and z components to improve 3d rotation angles for matplotlib\n", + " lm = np.zeros_like(lm_orig).astype(np.uint8)\n", + " for i,p in enumerate(lm_orig):\n", + " x,y,z = p\n", + " lm[i] = np.array([x - xmm[0], z - zmm[0], y - ymm[0]])\n", + " \n", + " # Create plot\n", + " figsize = (size[0]/dpi, size[1]/dpi )\n", + " fig = plt.figure(figsize=figsize, dpi=dpi) # frameon=False\n", + " #fig.set_size_inches(100/100, 1, forward=False)\n", + " fig.tight_layout()\n", + " fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None)\n", + " ax = fig.add_subplot(111, projection='3d')\n", + " ax.set_facecolor(bg_color) # background color\n", + " \n", + " xscale, yscale, zscale = (1.2, 1.0, 1.0)\n", + " \n", + " # scatter plot the dots\n", + " # jaw line\n", + " #mark_clr = '#%02x%02x%02x' % (0,255,0) # green\n", + " ax.plot3D(lm[:17,0]*1.2,lm[:17,1], lm[:17,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-right eyebrow\n", + " #mark_clr = '#%02x%02x%02x' % (255,0,0) # green\n", + " ax.plot3D(lm[17:22,0]*1.2,lm[17:22,1],lm[17:22,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-left eyebrow\n", + " #mark_clr = '#%02x%02x%02x' % (255,255,0) # yellow\n", + " ax.plot3D(lm[22:27,0]*1.2,lm[22:27,1],lm[22:27,2], \n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # nose ridge\n", + " #mark_clr = '#%02x%02x%02x' % (0,0,255) # blue\n", + " ax.plot3D(lm[27:31,0]*1.2,lm[27:31,1],lm[27:31,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # nose-bottom\n", + " #mark_clr = '#%02x%02x%02x' % (255,0,255) # magenta\n", + " ax.plot3D(lm[31:36,0]*1.2,lm[31:36,1],lm[31:36,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-left eye\n", + " #mark_clr = '#%02x%02x%02x' % (0,255,255) # cyan\n", + " px, py, pz = lm[36:42,0]*1.2,lm[36:42,1],lm[36:42,2]\n", + " px = np.append(px, lm[36,0]*1.2)\n", + " py = np.append(py, lm[36,1])\n", + " pz = np.append(pz, lm[36,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " \n", + " # stage-right eye\n", + " #mark_clr = '#%02x%02x%02x' % (255,255,255) # white\n", + " px, py, pz = lm[42:48,0]*1.2,lm[42:48,1],lm[42:48,2]\n", + " px = np.append(px, lm[42,0]*1.2)\n", + " py = np.append(py, lm[42,1])\n", + " pz = np.append(pz, lm[42,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " \n", + " # mouth\n", + " #mark_clr = '#%02x%02x%02x' % (255,125,0) # orange?\n", + " px, py, pz = lm[48:,0]*1.2,lm[48:,1],lm[48:,2]\n", + " px = np.append(px, lm[48,0]*1.2)\n", + " py = np.append(py, lm[48,1])\n", + " pz = np.append(pz, lm[48,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr, linewidth=stroke_weight)\n", + " \n", + " rh = '#00ff00' # edge color\n", + " #ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=35, edgecolor=rh)\n", + " #ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=1)\n", + " \n", + " # center center x,y,z points\n", + " cx = ((xmm[0] - xmm[1]) // 2) + xmm[1]\n", + " cy = ((ymm[1] - ymm[0]) // 2) + ymm[0]\n", + " cz = ((zmm[1] - zmm[0]) // 2) + zmm[0]\n", + " \n", + " # set initial plot view\n", + " ax.view_init(elev=120., azim=70.)\n", + " \n", + " # remove ticks\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_zticks([])\n", + " \n", + " # remove axis\n", + " ax.set_frame_on(False)\n", + " ax.set_axis_off()\n", + "\n", + " # rotation increments: from 0 to 360 in num_frames\n", + " phi = np.linspace(np.pi/2, 2*np.pi, num_frames)\n", + "\n", + " def update(phi):\n", + " ax.view_init(180,phi*180./np.pi)\n", + " \n", + " ani = matplotlib.animation.FuncAnimation(fig, update, frames=phi)\n", + " savefig_kwargs = {'pad_inches': 0, 'transparent': transparent}\n", + " ani.save(fp_out, writer='imagemagick', fps=fps, savefig_kwargs=savefig_kwargs)\n", + " clear_output()" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + " # line weight\n", + "def generate_3d_face(lm, fp_out, num_frames=30, dpi=72, stroke_weight=0, size=(480,480),\n", + " mark_size=2, mark_type='*', mark_clr=(0,255,0), fps=10, transparent=False):\n", + " '''Generates 3D plot of face landmarks\n", + " '''\n", + " # convert opencv BGR numpy image to RGB\n", + " bg_color = '#%02x%02x%02x' % (0,51,153)\n", + " mark_clr = '#%02x%02x%02x' % (255,204,0)\n", + " \n", + " # scale to make larger\n", + " #lm = np.array([1.2*x,y,z] for x,y,z in list(lm))\n", + " \n", + " # center x,y,z\n", + " xmm = (np.min(lm[:,0]),np.max(lm[:,0]))\n", + " ymm = (np.min(lm[:,1]),np.max(lm[:,1]))\n", + " zmm = (np.min(lm[:,2]),np.max(lm[:,2]))\n", + " \n", + " # make copy of landmarks\n", + " lm_orig = lm.copy()\n", + " xmm = (np.min(lm_orig[:,0]),np.max(lm_orig[:,0]))\n", + " ymm = (np.min(lm_orig[:,1]),np.max(lm_orig[:,1]))\n", + " zmm = (np.min(lm_orig[:,2]),np.max(lm_orig[:,2]))\n", + " \n", + " # swap the y and z components to improve 3d rotation angles for matplotlib\n", + " lm = np.zeros_like(lm_orig).astype(np.uint8)\n", + " for i,p in enumerate(lm_orig):\n", + " x,y,z = p\n", + " lm[i] = np.array([x - xmm[0], z - zmm[0], y - ymm[0]])\n", + " \n", + " # Create plot\n", + " \n", + " figsize = (size[0]/dpi, size[1]/dpi )\n", + " fig = plt.figure(figsize=figsize, dpi=dpi) # frameon=False\n", + " #fig.set_size_inches(100/100, 1, forward=False)\n", + " fig.tight_layout()\n", + " fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None)\n", + " ax = fig.add_subplot(111, projection='3d')\n", + " ax.set_facecolor(bg_color) # background color\n", + " \n", + " xscale, yscale, zscale = (1.2, 1.0, 1.0)\n", + " \n", + " # scatter plot the dots\n", + " # jaw line\n", + " #mark_clr = '#%02x%02x%02x' % (0,255,0) # green\n", + " ax.plot3D(lm[:17,0]*1.2,lm[:17,1], lm[:17,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-right eyebrow\n", + " #mark_clr = '#%02x%02x%02x' % (255,0,0) # green\n", + " ax.plot3D(lm[17:22,0]*1.2,lm[17:22,1],lm[17:22,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-left eyebrow\n", + " #mark_clr = '#%02x%02x%02x' % (255,255,0) # yellow\n", + " ax.plot3D(lm[22:27,0]*1.2,lm[22:27,1],lm[22:27,2], \n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # nose ridge\n", + " #mark_clr = '#%02x%02x%02x' % (0,0,255) # blue\n", + " ax.plot3D(lm[27:31,0]*1.2,lm[27:31,1],lm[27:31,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # nose-bottom\n", + " #mark_clr = '#%02x%02x%02x' % (255,0,255) # magenta\n", + " ax.plot3D(lm[31:36,0]*1.2,lm[31:36,1],lm[31:36,2],\n", + " marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " # stage-left eye\n", + " #mark_clr = '#%02x%02x%02x' % (0,255,255) # cyan\n", + " px, py, pz = lm[36:42,0]*1.2,lm[36:42,1],lm[36:42,2]\n", + " px = np.append(px, lm[36,0]*1.2)\n", + " py = np.append(py, lm[36,1])\n", + " pz = np.append(pz, lm[36,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " \n", + " # stage-right eye\n", + " #mark_clr = '#%02x%02x%02x' % (255,255,255) # white\n", + " px, py, pz = lm[42:48,0]*1.2,lm[42:48,1],lm[42:48,2]\n", + " px = np.append(px, lm[42,0]*1.2)\n", + " py = np.append(py, lm[42,1])\n", + " pz = np.append(pz, lm[42,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight)\n", + " \n", + " # mouth\n", + " #mark_clr = '#%02x%02x%02x' % (255,125,0) # orange?\n", + " px, py, pz = lm[48:,0]*1.2,lm[48:,1],lm[48:,2]\n", + " px = np.append(px, lm[48,0]*1.2)\n", + " py = np.append(py, lm[48,1])\n", + " pz = np.append(pz, lm[48,2])\n", + " ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr, linewidth=stroke_weight)\n", + " \n", + " rh = '#%02x%02x%02x' % (255,224,10) # edge color\n", + " ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=35, edgecolor=rh)\n", + " ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=1)\n", + " \n", + " # center center x,y,z points\n", + " cx = ((xmm[0] - xmm[1]) // 2) + xmm[1]\n", + " cy = ((ymm[1] - ymm[0]) // 2) + ymm[0]\n", + " cz = ((zmm[1] - zmm[0]) // 2) + zmm[0]\n", + " \n", + " # set initial plot view\n", + " ax.view_init(elev=180., azim=90.)\n", + " \n", + " # remove ticks\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_zticks([])\n", + " \n", + " # remove axis\n", + " ax.set_frame_on(False)\n", + " ax.set_axis_off()\n", + "\n", + " # rotation increments: from 0 to 360 in num_frames\n", + " phi = np.linspace(np.pi/2, 2*np.pi, num_frames)\n", + "\n", + " plt.savefig(fp_out)\n", + " fig.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"1999.9499999999998\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# filepaths\n", + "dir_out = '/home/adam/Downloads/'\n", + "fp_out = join(dir_out, f'{Path(fp_im).stem}.svg')\n", + "# generate 3D face\n", + "generate_3d_face(lm,fp_out, size=(2000,2000), stroke_weight=2, mark_size=34,\n", + " mark_type='*')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:megapixels]", + "language": "python", + "name": "conda-env-megapixels-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |