diff options
Diffstat (limited to 'fw')
| -rw-r--r-- | fw/Scope.ipynb | 872 | ||||
| -rw-r--r-- | fw/adc.c | 118 | ||||
| -rw-r--r-- | fw/adc.h | 1 | ||||
| -rw-r--r-- | fw/main.c | 4 |
4 files changed, 970 insertions, 25 deletions
diff --git a/fw/Scope.ipynb b/fw/Scope.ipynb new file mode 100644 index 0000000..966c83c --- /dev/null +++ b/fw/Scope.ipynb @@ -0,0 +1,872 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "%matplotlib notebook\n", + "import struct" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(offx=0, end=-1, signed=False, channels=1):\n", + " with open('/tmp/scope_dump.bin', 'rb') as f:\n", + " raw_data = f.read()\n", + " data = struct.unpack(f'<{len(raw_data)//2}{\"h\" if signed else \"H\"}', raw_data)\n", + " \n", + " print(''.join(str(x) for x in data[offx:][:100]))\n", + " fig, axs = plt.subplots(channels, 1, figsize=(10, 5))\n", + " for i, ax in enumerate(axs):\n", + " ax.plot(data[offx:][:end][i::channels])\n", + " ax.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "61515991715159978151599491515997101515997111515991121515994131515997141515991050-5345150-5361250-5358350-5351450-5348550-53616150-53547150-53488150-53549150-5361051599115159912515991351598845159915515988\n" + ] + }, + { + "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,iVBORw0KGgoAAAANSUhEUgAAA+gAAAH0CAYAAACuKActAAAgAElEQVR4nOydeXhU5dn/c7W19mp/rX/09Wp9e70d6lYXqq1ara2KuFsVrdattVLrUmtdW9tBFiMiCCqoIAIiLogKIqI4JECAECDshCXsO4QAgQBJ2BKSnPv3xzn3mWeenOU5c56TzGS+n+s619s3DnkmM3POnPu5v/f3m0cAAAAAAAAAAABoc/La+gkAAAAAAAAAAAAABToAAAAAAAAAAJARoEAHAAAAAAAAAAAyABToAAAAAAAAAABABoACHQAAAAAAAAAAyABQoAMAAAAAAAAAABkACnQAAAAAAAAAACADQIEOAAAAAAAAAABkACjQAQAAAAAAAACADAAFOgAAAAAAAAAAkAGgQAcAAAAAAAAAADIAFOgAAAAAAAAAAEAGgAIdAAAAAAAAAADIAFCgAwAAAAAAAAAAGQAKdAAAAAAAAAAAIANAgQ4AAAAAAAAAAGQAKNABAAAAAAAAAIAMAAU6AAAAAAAAAACQAaBABwAAAAAAAAAAMgAU6AAAAAAAAAAAQAaAAh0AAAAAAAAAAMgAUKADAAAAAAAAAAAZAAp0AAAAAAAAAAAgA0CBDgAAAAAAAAAAZAAo0AEAAAAAAAAAgAwABToAAAAAAAAAAJABoEAHAAAAAAAAAAAyABToAAAAAAAAAABABoACHQAAAAAAAAAAyABQoAMAAAAAAAAAABkACnQAAAAAAAAAACADQIEOAAAAAAAAAABkACjQAQAAAAAAAACADAAFOgAAAAAAAAAAkAGgQAcAAAAAAAAAADIAFOgAAAAAAAAAAEAGgAIdAAAAAAAAAADIAFCgAwAAAAAAAAAAGQAKdAAAAAAAAAAAIANAgQ4AAAAAAAAAAGQAKNABAAAAAAAAAIAMAAU6AAAAAAAAAACQAaBABwAAAAAAAAAAMgAU6AAAAAAAAAAAQAaAAh0AAAAAAAAAAMgAUKADAAAAAAAAAAAZAAp0AAAAAAAAAAAgA0CBDgAAAAAAAAAAZAAo0AEAAAAAAAAAgAwABToAAAAAAAAAAJABoEAHAAAAAAAAAAAyABToAAAAAAAAAABABoACHQAAAAAAAAAAyABQoAMAAAAAAAAAABkACnQAAAAAAAAAACADQIEOAAAAAAAAAABkACjQAQAAAAAAAACADAAFOgAAAAAAAAAAkAGgQM8xmpubqaKigmpqaqi2thYHDhw4cODAgQMHDhw5etTU1FBFRQU1Nze3dZkCLFCg5xgVFRWUl5eHAwcOHDhw4MCBAwcOHJSXl0cVFRVtXaYACxToOUZNTY19Erb1jh0OHDhw4MCBAwcOHDja7uDmXU1NTVuXKcACBXqOUVtbS3l5eVRbW9vWTyUyDMOgHfuPkGEYbf1UAAAAAAAAyFhyoTbINlCg5xi5cBL2nrSaYvEETV21u62fCgAAAAAAABlLLtQG2QYK9ByjvZ+E26uP0GnPTaZYPEGDp29o66cDAAAAAABAxtLea4NsBAV6jtHeT8J/f7acYvEExeIJemXK2rZ+OgAAAAAAAGQs7b02yEZQoOcY7fkk3Lz3EP2sW8Iu0F/8enVbPyUAAAAAAAAylvZcG2QrKNBzjPZ8Ej71aZldnMfiCXrui5Vt/ZQAAAAAAADIWNpzbZCtoEDPMdrrSbhhTx11sLrnT3xiFurPjFvW1k8LAAAAAACAjKW91gbZDAr0HKO9noSPjVlKsXiCHhm9mD6ct5Vi8QQ9NmZpWz8tAAAAAAAAMpb2WhtkMyjQc4z2eBKu2VVry9rX7q6lcYt2UCyeoAfeX9TWTw0AAAAAAICMpT3WBtkOCvQcoz2ehA9/uNjsmH9sdsy/XLaTYvEE3fvO/DZ+ZgAAAAAAAGQu7bE2yHZQoOcY7e0kXFlRQ7F4gn7WLUEbq+qIiGjqqt0UiyfoD0PntvGzAwAAAAAAIHNpb7VBewAFeo7R3k7CB95fRLF4gp4emzSEK1m/l2LxBN3wxuw2fGYAAAAAAABkNu2tNmgPoEDPMdrTSbh0+wGKxRN06nOTacu+w/bPF27ZT7F4gjq/Wtx2Tw4AAAAAAIAMpz3VBu0FFOg5Rns6Ce97dwHF4gl69rPlKT9n2ful/aa30TMDAAAAAAAg82lPtUF7AQV6jtFeTkLukp/23GTasf9Iyn/bsKeOYvEE/bL31DZ6dgAAAAAAAGQ+7aU2aE+gQM8x2stJePeIeRSLJ6jbhJUt/tuO/UcoFk/QWT0L2+CZAQAAAAAAkB20l9qgPYECPcdoDydh6cZ9FIsn6IzuBVR58GiL/763rp5i8QR16JYgwzDa4BkCAAAAAACQ+bSH2qC9gQI9x8j2k9AwDLrj7VKKxRP0/Jfljo+pO3acYvEExeIJOna8qZWfIQAAAAAAANlBttcG7REU6DlGtp+Es6wItTN7FNCe2mOOjzne1GwX6DVHjrfyMwQAAAAAACA7yPbaoD2CAj2DKCkpoZtvvplOOeUUysvLo4kTJ6b8d8MwKD8/n0455RT6zne+Q506daJVq1YFWiObT0LDMKjLkDkUiyfoxa9Xez72tOcmUyyecC3iAQAAAAAAyHWyuTZor6BAzyAKCgqoR48eNGHCBMcCvX///vT973+fJkyYQOXl5XT33XfTKaecQnV1dcprZPNJOH3NHtv8bW9dvedjz31+CsXiCdoq5KMDAAAAAAAAkmRzbdBeQYGeocgFumEY9OMf/5j69+9v/6y+vp5OOukkGj58uPLvzdaT0DAM+v2bsykWT1C/gjW+j7+wzzSKxRO0dnd2/Z0AAAAAAAC0FtlaG7RnUKBnKHKBvnnzZsrLy6OysrKUx3Xp0oXuv/9+5d+brSdhYfkuisUTdE6vQtp/uMH38b/rP4Ni8QQt23GwFZ4dAAAAAAAA2Ue21gbtGRToGYpcoJeWllJeXh5VVlamPO7hhx+m6667zvX31NfXU21trX1UVFRk3UnY3GzQdYNKKBZP0GtT1yn9m6sHzqJYPEHzNlVH/OwAAAAAAADITlCgZx4o0DMUtwJ9165dKY976KGH6Prrr3f9Pfn5+ZSXl9fiyKaTcNLySorFE9Qxf4qyK/tNg005/Mx1VRE/OwAAAAAAALITFOiZBwr0DEWXxD3bO+hNzQZd9VoxxeIJeqNog/K/++MwMyu9sHyX/4MBAAAAAADIQVCgZx4o0DMUN5O4AQMG2D9raGho9yZxX5RVUCyeoPNemEp1x9Qzze97dwHF4gn6oqwiwmcHAAAAAABA9pJttUEugAI9gzh06BAtW7aMli1bRnl5eTRo0CBatmwZbd++nYjMmLWTTjqJvvjiCyovL6d77723XcesNTY1U6dXZlIsnqC3Zm4M9G8f/GAxxeIJ+mTh9oieXRLDMMgwjMjXEddrTdrzenjvsne99vy3tfZ6OA+ydz28d9m7Ht677F2vtd+7qMmm2iBXQIGeQRQXFzvOi3ft2pWIzAtCfn4+/fjHP6YTTzyRrrjiCiovLw+0RjadhOMW7aBYPEEXvDiNDtc3Bvq3j39SRrF4gt6buyWiZ2diGAb9ffQS+u3LMwJ1+NOl+lA9XflqMf1jzJLI1yIimr+5mn6RP4U+KN3aKuu9XbyJzulVSOU7ayJfq7nZoL+MWkidXy2mY8ebIl9vV81R+u3LM+jfny2PfC0iouJ1VdTx+Sk0bvGOVllv4NR11PH5KbSx6lDkazU2NdOdw+fR9a+X0PGm5sjX21Z9mC7pO52e/zLY9TZdCst30Tm9CunrFZX+D9bAi1+vpvNemEoVB45Evtax403UZcgcum3oXGpujv4Gd/2eOrqwTxG9XLA28rWITNXX2b0KacbaPa2yXvzzFXRhn2m0t64+8rUO1TfS9a+X0L3vzG+V4mRlRQ39svdUenO6+nhbGMYs2EZn9yqk0k37Il/LMAx6/JMy+k2/6creOmE4eKSBOr9WTA9+sDjytYiIFm/dT+e9MJVGzt7cKuuNnL2ZzulV2CrJPYZh0IMfLKIrXplJRxqC3ZtmKtlUG+QKKNBzjGw5CRsam+2otHdKgl/gn/1sOcXiCRpaHKzzHpSZ66ooFk9QLJ6gJdv2R7oWEdFLidUUiyfozB4Fka8lZs8/8P6iyNfbXXOMzuhRQLF4olW+1BMrdtnv3Zpd0Z8Pz32xkmLxBP3qxWmRr9XY1EydLe+Gf368NPL1tlUfplOfm9xqqpVxi3fY79326uiLyqc+NTf8LhswI/K16hub6Lcvm9e++OcrIl9v3e466tDNfC2/Wh79hsD7c7fY7131oeiLSlZTXf96SeRrHWlopAv7TKNYPEG9J62OfL2l2w/Yr+X0NdFvCLw1c6O9Xmtsat77znyKxRP0h6FzI1+r5shx6pg/JVBaTBjmbtxnv5atkTYzoHAtxeIJ+lm3ROSbK4ZhUJe35lIsnqD73l0Q6VpERHvr6umsnoUUiyfo7eJNka83ddVu+71bWRF9M6E1yJbaIJdAgZ5jZMtJOGbBNorFE3TRS0V0tCH4jUDPieUUiydo4LT1ETw7E8Mw6JYhc+wLddSO8VW1x+hMq4CNxRPU0Bht55Cz52PxBP1xWGmkaxEl37NYPEGDInzfiEzzQY7ii8UTtHBLtJsrO/YfodOsAvb07pMjv0H6fEmF/bfdP2phpGsRET0zbpm93oiSaG+QxM27WDwRudpiw55kAXt+76mRrkVENHreVvtve2xM9Jsrfx+9xF5vzIJtka51tKGJLnqpyF5v677Dka63fMdBe63fvhz95srbxZvs9Z5tBaUMe63E4gmaWLYz0rVqjx2n816Yaq9XVXcs0vXmbaq217pm4KxI1yIiem3qOnu9/K9WRbqWYRj0h6Fz7fWmrtod6XrVh+rp7F6F9npBFYlBmb5mj71Wl7ei31zpPWm1vd6AwmiVMs3NBl3/eom9XunG6NUWrUG21Aa5BAr0HCMbTsL6xib6Tb/poSTqfSevoVg8Qf0mr9H87JJMW538EorFEzQp4u5T/lerUtbbf7ghsrXE7PnW6D7tPHiUTu8+2V7vxa+j7T59uWxnymsZtRz1P+OXp6wXZffpeFMzXWF5N8TiCbr97Wg3VzbtPUQ/65b82wZG3H36eMH2lNdy/uZou0+PfbzUXuu056LdXDl2vIku7pssYP8S8eZK+c6alNdy+KxoN1dGzt6csl7Umytd31tor/WL/CmRrlV37Did3ztZwD76UbRjSAu37E95LUfPj3Zz5fWi9Snrbd4b3SiLYRh057B59lq/6Tc9srWIiA4cbqBzhAL2X+Oi3VwpFpR3sXiCJiyN1syW74f42FMb3eaKqLyLxRN01WvFka1FRLSnNqm8i8UT1CviMaTJK3elvJZTIt5caS2yoTbINVCg5xjZcBJ+UGp2kC7pOz3tQmagtRse1cW6udmgG96YnXKh/nhBdNLeXTVH6YzuBSnrbauOrvvE2fOt1X3qNmFFynr/GR/dDVJjUzNd+WpxynpfLouu+7R1X1L+zUeU86JjF6UWsNcOirb79ITl99Aa3af6xia61Nq842Pa6ug2V9bsqk1ZKxZPpKXoUWXUnC0pa90WsbT3wQ8Wpaz36pToNlcO1zfSBS9OS1kvylnfJdsOpKwVtbR38PQNKev9eWS00t67R8xLWS/Kca6DRxqo4/NTUtZbHuGs7+wNe1PWOvf5aDdXXi5Ym7Lewx9GN6ctK+9i8USkHi9Vdcfo5z1T7x02VqkbCwelsHx3ylq/fqkosrWIiHp9WZ6y3tNjl0W2VlOzQdcIyrtYPEHjl7SPpKBsqA1yDRToOUamn4THjjfRry0JZJiOAM/KRVXo8S7quc9Pob9aXZoopb3drfnlO4fPs1+fqLpPYvY8F1/nvRCdtHd7dVL+zeZ+UZrgfWbNL/+y91T680hTIvpRhN2np8ea8u+/vreQzrVucrdEJO1taGy255f5vbs0wu6TOL/8T6vTHKUJnrh598dhpRSLRxul+PCH5vzyY2OW2iqBqKS9Rxua6MI+RSnvXZTS3mWW/Ptn3cy/L+rNlaHF5jX5ildm2gVKlNLeP42cn/JaxuLRSXtrjh6nX1jzy7xelNLeUmt++YzuBfTIaPMzGqW095UpZgF7/esl9mjQ3IikvYZh0K3W/LL43kVlKCjOL/N6974zP5K1iJLKu7N7FdobZEFTaoLAyrvbhs61vxvKth+IZC1Recev5dm9CiNZi8hU3nHjgteL0gSPlXe/yJ9Cfxll3ve9H7ERcWuR6bVBLoICPcfI9JOQJZC/fXlGqBlr7kQ98UmZxmdnIu6iDpy23t7BjcpYZsf+I7b8e8Hmart4jspYhrPnz+89lTZWHaJYPEGnRijt/bdl6PeXUQtpwlJz7aiMZY43NdNlA8yblOGzNtG/xplrR2Uss7Gqzi7sVlbU2KMbKyqi6T59NH+b3bVYXWl2fztG2H36xxhzfvnRj5bQaGvtR0ZHc4Mkb949+pG59ofztkay3sqKGruA3VhVZxdgmyKS9o4oMeeXLxswg8os869L+ka3uXK/dYP5r3HLafgsc+1nxkXTfRLl3xOWVtg3t59H1H2av9mcXz69++QU/4fdNdFsrgycZsq/rx00i0o3mcVz54ikvYZh0B1vm5tTz39ZbqvFek6MRi22/3CDPb88ZdVuut1au7B8VyTrzVxryr9/3rOAduw/YhfotRGlpPT5erW9ocKz0zcPnhPJWqLyrn/hWnrRWrtfQTSjeLtqjtry7zkb9tmz0yXr90ay3tcrTOVdx/wptGXfYfu9a4woaaPbBLNxcc+I+bbq767h8yJZq7GpmTpbyrshMzbYqr/BrZQwEDWZXhvkIijQc4xMPglFB9yxi8LJxXlO9aEIpGriLmrN0eO2O2pU3af/jje/CFgyye6oUUh7xez5ocUb6XB9o/0lG0WcyGZhfnnZjoO2O+qtEXWfPllofi4u7GOaD3J34ZUp0XSfuKvMkkne2InCWObY8Sa6pK+5AfBB6VaqqjtGsXiCOnSLpvu0qrLG/v3rdtfRxDLzvPjTyGi6T/LmHSc1RNV9euB9s7vFkknuPkUh7T1U30i/suTfny3eQVutm9uopL1Ltu23N962Vx+xTTmjkva+acm/O79WTE3Nht2xj0LaaxgG3TnclH93/2IlEZG9ORCFtPfA4QZbGVOwcpc91x+VtHfWelP+fWaPAtpTe8ze2IlK2tvPml++afBsMgzD3tj5LIL4RsMw6ObBprqi3+Q1ZBiGvTldefCo9vX2CMars9bvtef6r3y1WPtaREQFgvLuwOEGGmRt7PDnVDc9JiaVd4Zh2KqjySv1b66IxqtvFG2ghsZm+94hihg5UXm3aOt+O1Hn92/O1r4WEdF4y3j1l72n0qH6RjtRJ0qfo9Ykk2uDXAUFeo6RySchO+BePmBm6GzjqDqx4i4q75zy847CWEacX16yzZSlsXNvFMYycva8YRh2AR2FscyTVnzV36wYN3bujcJYRpxffneOKUt7LUKvgrW7k/PLHOPGzr2F5fqlve9Z8VW/6Wd6Nxw73mSvXxdB94njqx63VCrcfbpliP7uk7h596kV48bOvVHkW3N81anPTbbHEbj7NGeD/s0VHsm58tViamxqpupD9fZ71xTB5grHV3GM21dW9+meEfo3V8T4Ko5xi3++wu5E6WauIP/moo5VM0sjkPb2tzZob3hjNjU3G7S92uz6ntVTv7TXMAzqYo0HsJEmbzo++IH+KExxfpmNNHnTcdQc/dLeKdYG7dm9Cu0IPt64Wrdb/+bK85b67fa3S8kwDNtz4sI++qMwm5oNunaQpbyz1Ha86RiF0q/iQFJ5x0aavOkYtgHiBCvvznthqq124M2PHfv1R2Gy8o7v8XjT8fIBM7WvdbypmS4fYDYuhllGmrzp2G1CNJsrrU0m1wa5Cgr0HCNTT0JRAqlD9sg71XcO0yt3+lzaRSWiSKW9HF/V9b2km3NU0l637HmW9m6s0ivtFeOreJ6eu08X99XffeL4qov7Ftnmg7a0N4LuE8dXiVFZLO3VbSwjxldxVJZhGHaHYVeN3u7Tiork/DJLvhdYsuLOEXSfhs1quXnHsuIeE/XfIPEmmBiVdUdE0l4xvoqjsuobk5sruqW9vAl2evfJVHHAvHFmWXEU0l6WYF83qMRWcvSJSNorxleJiiaWFeuW9u4T4qtY0bT/cIP93umW9vIm2Fk9C2mfVcBGKe3lTbBb35prjzixtPdNzdJeMb5KVDRxYbRkm94ozEphfpkVTSypP7NHgda1iJKbYKy8I0oaej7wvv7NFd4EExVNPKc9cvZmj38ZHFF5JyqaeFOVN6h1sWXf4RTlHZHphxKLJ+hXL+rfXPnUVt5Ns5WEPEb5eASbK21BptYGuQwK9BwjU0/CwYIEUsdNTRQ3nE67qERJybtuY5mNVUn5tzizzJFduqW9btnzURnLsMz176OThnDbqg/bHRSdiPFVo4WNDR6F0G0swxsNHbolaMOeZOeHI7vSjQ90450SsxPzu/6p3g2/tDa91u/R233i+CpxZpln3i/so3dz5VB9o/13iJt33H168lO9N0iLtpqdmNOem5zS+WEzyHGapb0cX3X1wFkp3XKeHd2pUdorxleJM8uLrb+50yt6u0+i/Fvc2HijyLzeP6dZ2ssy1zN7FFCVoPhhyXtihd7NFZa53jJkjl3AitLeg0f0RWGK8VWiaoQju258Q6+0d3dNMr5q9obkxgZHdr2U0BuFmVhhbqp3fH5KyuvGf/PMdVVa13vOMl69e0RyY6PmyHH7vQvjgSPT2NRMnV9LVd4RJc1m/zhMbxTmtmpReZfc2GCz2UHT1mtdb5xlvPorS3nHcFrKwi16N1eekpR3ROaGC2886vTLqW9ssu+B3hVUI2w2KzZPsplMrQ1yGRToOUYmnoSiA66uuCs26tHpgsy73eIuKlF00t7HXVxJo5D2Hjvunj3PXQ3xJi0sXMx16JagtbuTn8WopL3vWrvdl/abTvWNyc0H7mqIN2k6+JslJZSLR+5q6DSWOSzML49blFo8srSXxyN0wPFVpz43mbYKbvTcffp5T73dJ3vz7tXUzTvuavxNc/eJ46tk6SKfj+9qlPaK8VVfr6hM+W8cSSaeH2Hh+KozehSkGKbxOMYFmrtPHF91oyX/Zt6NoPskxlf1+Tq1ePxbBNLeKmF+WS4eo5D2Fpabxdw5vQpp/+FkARuVtLfnxHK7eBQLnqS0d4W2tcT5Zbl4vMvaXJm0vNLlXwdHNA4Ui8fGpuTmivgah4WVd+f3npoyblRi+Qlc/3qJtrWIksq7+0elFo/9CszNlRe/1re5Iirv5CQb9hPg8QgdOCnviEwlEr936cbzOuGkvCNKno+3v613c6WtyMTaINdBgZ5jZOJJKDrg6jKzYhfkywboye8W46tkeVgUxjJifNXqytT3KgpjGY6v4vllkSiMZTi+6p8fL035eRTGMuL88icLU2/QozCWEeOrNkuO39xx66vRWIbjqzq9MrOF+uRGS9pbrLH7xNF0/x2feoN+8EhS2hvWQ4Lx2rzjjpvOMRbe2BPnlxnuuL1RpG9z5dUp6+wbdPnax5LRxVv1dJ8Mw6DbLPn3C5NSDS13Wt2nMzRKe/cdSsZXFUmGltxx+6vG7pMYX8Xyb4Y7bjqlvWww+Yehc1t07DguT752p4sYXyWnhazfY0p7f9lbXxTmzoNH7fllOS2EvS4ek67dYWAVmji/zLDXxccL9G2usArNyaOGRxa2VeuJwjze1ExXWOeynBbC9ym/fVnPfQoR0SbBeFU2tIwifpZVaLLyjijpdaGr8UKUVKHJI4XNzYb9/bO3rt7lXwdDVN7JI4XsdXHdIL2bK21FJtYGuQ4K9Bwj005C2QFXF0mzFz1y29FCfJVcwOpeiyg5Z+6UB65b2ivGVznlgbOxjNydTZfU+KqWc+3cfeL52LDwnPllA2a0KBxZ2nuFRmkvz5k75YGztFeXsYzo3eCUB87SXrk7my4LpPgqkeNC9+mApu6TuHknKyrYzfoGTdJeOb5Kht2s5e5suuw/3EDnCPFVMjcNtqS9a/VsrojxVXKWe83RZPdJVJiEwY6vEuTfDHuE3KGp+yTHV8mwm7Uuae+umuT8spNpYGfN0l6eM++YP6XFxuWuGv3SXp4zdxrbYjdruTubLo1NzbYU2mls65mxyxy7s+kiGq86mQbyd6HYnQ0DK+8ueHFaiySUjVV19saELrzywHkj3um+Ih1E41WnsS3eiHe6r0gHvteKxZ2VRXwvuWWfns2VUS7KOyKi5dZG/KX9oovCbE0yrTYAKNBzjkw7CWUHXF1wBqeODGg5vkpGt7GMGF/lNDus21jGL3tet7EMz/K6xQLpNJYR55edYoF0G8ssFuaXt1e33GDgL3xZOZAuXPBfZcVXyTz4wSJH5UA6OMVXyXDH1OlvD4q4eeek3mCn9d/119N9kuOrZIbMMF9rdj4PixxfJXPPCLP79JUGaa8YX+Wk3mgSuk/Vh8J3n8T4Kif1xpwN+2zlgA7k+CoZ/p7pPUnP5grP8nJ8lQxL7aevCS/tbWo26CprftlJvVGnWdorxlc5qTcKy3fbygEd8CyvaLwq0styWpeVA+nytFXwu6k3+LWWlQPp4KW8IzLPk1jcHBfSsbkiKu9WVbbcYNCdbsMF/yV9WyrviIj+NW65o3IgXbjgd1Nv8Jie6NmTLkcbmmwljJN6Y/PeQ/amWXsg02oDgAI958ikk9DJAVcXu2uO2V2FsIjxVU7dJd3GMizpc4temazRof5IQ6M96+o2n8k3o68Xhe8+ifFVW112ubmbskiDtJclffL8MmNLe7vr2VxhSZ/bfOY4jcYyYnyV23wmS3tFV/50seOrehS4usKzk7zTzWFQBvhs3m2wpL3na5D2GoZBXd4y5d9u85nvs7R3TPjNlb119S3iq2Qesm5G2ZU/DFMd4qtkuJvvdl4GgeXfHF8lw2MgOqS9ThDwtcAAACAASURBVPFVMjqlvTv2t4yvkvnTSH3SXo6vkueXmeZmwy7KdEh7Ob7qLy4d8lLrOnDtoPD+Lsebmm2fjOGznIu4V6aY1wHRlT9dNlbV2fLvlRXO1yi+Dui4J/nIQ3lHZPqH8L2D3F1Ph3+MMZV3j37k3CHn68Ctb4XfXBGVd6NdOuR8HRBd+dMlVXnnbHp6jeVjwK78YRhR4q68IzIjCLmRorO51FZkUm0ATFCg5xiZdBLyPK6TBDIs4jxsGFd4cRfV7UZZp7HM8h0t46tkdBrLcIb7Fa+4Z8/rNJbh+CqvG2VdxjJifJXbjbJOYxkxvsrNeVunscxrDvFVMmz05Fa4qOIWXyXDTsVuhYsq1Qqbd7wJp6P7JMZXuRU5bPTkVrgEwSm+SoaNntwKF1Xc4qtkWCUUVtrrFF8ls8nqPv1CQ/eJ55c7CvFVMmz05Fa4BOG/41vGV8k8MnqxZ+GiihhfNbTYPbWDjQZlz4ugbBbml5ftcO5CcsTibzRIez+x46tazi8z/B31r3HhN1c4w/3hD91TO/g7asLScFGYfso7IvO6yq+3k2onCKLyzi0znr+jrnqtONRaRP7KO6Lkd1Qvh5GhoPConZvyjojs76jC8pYjQ0E4JBivOinviMz3l+8dnJQf2UYm1QbABAV6jpEpJ+HRhibb/EmngRWj6+LpFl8lw8VEWGnv/aNaxlfJlGmS9qpmz3P3STYFCwqb6cnxVTK6jGXYTO+agS3nlxlR2isbSwXBMAzbTE+Mr5JhaW9YYxlxftkrl5ulvbIpWFDc4qtkuljSXtkULChO8VUyh4Tuk9vNvQpifJVXLvcUq/t0W0hprxhf5ZXL/bwl7X11SrjNFbf4Khl20S7dFK77xGZ6d7nIv4lMB3TeiAyzudLY1GzPe3vlcnMXOqy0V5xf9kpG4C50WGnvuEWm4uYCKb5K5lJN0t4nHeKrZHSNj4nzy17JCNyFlk3BgsJJBbG49/gU+7/IpmBBEZV3Xpu/fB/k5McSBFbeeSUjcPznxX3D+eWIxqufeoxPsf/LMx5FtQqi8s5rvpz9X8Z73M+owPc8V7oo74jM7w0eBXFTlGUTmVIbgCQo0HOMTDoJKw8epbeLN2nvnhOZF8+whVdKfJVP9rEOYxmOyzn1ucmeDrK6jGXE7HmvSDNdxjIcX+WXfazDWEaMr/LLPtZhLOMWXyWjy1iG46t+/6bz/DLDDu9OhnWqiPFVftnH7PDuZFinild8lfy8WNrrtWngB8/UyvFVMrqiG3mmVo6vkmGH9zDS3qZmw5Z9+hmkscP7VAfDOlXc4qtkjjYkN1C9Ck8/3OKrZIosh/cuIaW9rGrwG1Fhae8AB8M6VcT4Kr8RFZb4zw0h7XWLr5LZW1dvd2rDSHvd4qtkWCHhZFgXhL+PNgtvvxEVdnh3MqxT5WhDkz3u4zeiwjPqZQ6GdaqwqsFLeUdk5qPH4uaoSxiGWYX35QPclXdESYd3J8O6ILCq4Vmf7zF2eHcyrFNFVN5NLPNuErC/zQYHr6BsI5NqA2CCAj3HyKWTkGc8082i5V1Up/gqmas0SHt5btHPhEqHsYwYX+VnQqXDWIbnFp3iq2TYWGZYCGkvzy06xVfJsAzRbSbRD8Mw6FZrbtHPhGqTBmOZvXXJ+Co/Eyq+Cf776PQ3V8T4Kj8DMb4JHh2i++QVXyXDM/heN6VeeMVXyfAM5CV9099c2SnIv/1MqPgm2EtN4wcXN7/In9IivkqGb4K91DR+eMVXiRiGYXeivTa0vPCKr5KZvzm8tHdjlXt8lcxADdLeMQvMzrFTfJXM7Vb6QBhp72NjlipdK0R1mtemiN/v4Pgqv2vFjLV7bDVNunDnuEM3/2KKx09eLkh/c0VVeUdE9vjJ7A3uaho/ur7nr7wjMkeH+L3z2pT3QjRe9btWfGWlD9w9In2/nEVb1ZR3RETxz83xk8Eeaho/Xi8ylXdXeyjvGPZP8FLTZAu5VBtkCyjQc4xcOglZvu1mKOJFnbCLqtINDGssM1+Ir/KLF9NhLMM3kCrZ82GNZQzDsG8gneKrZMIay4jzy07xVTJhjWX4BtIpvkpGh7HMixxf5TG/zEwsMws0r3lZL/ziq2Se/Sxc98kvvkqGu09u87J+eMVXyWy1pL3nhpD2cnzVPSP83w8u0LzmZb0Q46uGzPC/YeUCzW1e1g+/+CqZMNdnotT4Kr8uPM/n/vql9KW9j3vEV8mwwZTXvKwXx4432Y7UKt1AHo1ym5f1Y3VlrX1dcoqvEjEMwzbJ89tsdeNdj/gqGR6NuvLV4rTWIiL6mzW/rBJNyqNRbkkVfqQo7xSiSXk0yimpQoUl2/yNV5n6xuTmit/1zg1beech/2Z4NOr3b6YfhcnKO5VoUh6NckqqUEFU3qlEk95ofTfO8hhVyhZyqTbIFlCg5xi5dBLyDU46nVG/+CoZ7j6lI+0V46t6TPT/EhKNZdKR9gbNnmdjmavTlPaK8VUqz5eNZVSKeSc4vurmwWrmgyztVSnmZQzDsPOq+yncFIjS3nS8EcT4KpWbAlvam2b3yS++SuaFSauUi3knOK/aLb5KhrvfKsW8jF98lcy+kN0nv/gqGe5+qxTzTnBetVt8lQybn6kU80484xNfJcPybZViXsYvvkpme/URWwWSDn7xVTJsfpautJfHivzml5l/hpT28liRavwjF6BOMaB+iPPLKvGPnH19YZ/0NleWCcarKiZ6bH6mUsw7wWNFKso7omTsqEox7wSPFal6xLD/hV8jwAlReafiEcOxo1e8MjPwWkTJsSIV5R1R8r5NpZh3gseKVJR3RGTft6kU8zKGYdDQ4o1pb3LpJpdqg2wBBXqOkUsnYbpxXSrxVTJhjGXYOMwrvkomjLEMG4fdqJg9H8ZYxjAM2zisj6ILfBhjmaq6Y/Zow8y1auaDYYxl2DjMb36ZCWssw8Zhd7jEV8kssJQZndPoPqXEV/nMLzMDre6TykaTTMUB//gqmTssZYbKRpMMG4ed94L3/DIjdp/85OJO+MVXycxcW2VvNAXleFMzXT7AlH+rusD3sZQZXkZ5bojyb9UNUVZmeBnlucHGYRe5xFfJHDgcLtWDr++qLvCszLhreHBprxhfperDwcoML6M8N1Ljq9S+T/iztWRb8ChMvr67xVfJ7Nh/xN7gTQe+vqv6cLAy4wEPozw3RONV1c36JyxlhspGk8wCQXmnOsrHmyNeRnlu8PX92kH+8m8ic2MrFk/Qr16cFngtwzDs67vqZv0oS5mhutEkIhqvqm7WP/iBqczwMspzg6/vv8ifEsrkVBe5VBtkCyjQc4xcOgnTne1Sia+SSddYxjAMu4MbxAwqXWnvvkPJ+WVVOT4by5yTRveJO7hn9SxUNutjY5mH0pD2cgfXK75KhqW97wfsPqnGV8mcn6axzE6F+CoZlvZelIa0V5xfdouvkuHZy6fS6D6pxFfJ8Oyln4mjjBhfFeSc5dffLUbPDZX4KhmeveyURvcpGV81TXkMhmcv/UwcneAObpBz9s5hZvfJz8RRRoyvUj1njwtRmEGlvSrxVTLFIaS9KvFVMn0t1VA60l7u4AaR43PqQdAEFnF+WVWOX3MkGYWp+nowi4X5ZdWEFU49uHNY8M2VoMo7omTqwetFapugjKi8CyLH5+te0MaFqLxTlePvPHjU7oAHRVTeqUbQjVtsph74mTg6wcq7mwZ7G6+KPGWlHviZOMoYhmHHyaYrx9dNLtUG2QIK9Bwjl07CdFyJVeOrZNI1luEZLZX5ZZF0Nx/SyZ5P11jGMAx7RivI65KusYwYXxXkdUnXWEY1vkomXWMZvpEL8rpw9+nnPYPdIInxVUFel0+twtArpsmJbdVq8VUyPBfsFdPkBN/Iqcwvi1xgSXtVCzXmKYX4KhmOhbqwT7DuU31jk72BF+R14bngJzximtyeJ8u/g3TleC547KJg3SfV+CqZdE1DVeKrZDiR4/IBwTZXjjQ02p+xIK/Lm9NZ2hssClOMr/KbXxa5yyoMVRVmDBuvqswvM43C5oqKSkmEIzuDvC4lVmF4/evBojDTUd4REfUrMAvDFxUVZszcjcGVd0RkF4Yz1gbzyxlgKe9uUFTeEZmO6PzeBTlXDcOwfX2CvC6F5eZ38u1vlyr/GyLTeJWvD0Fel54TTUWbqsKMYV8fFePV1iKXaoNsAQV6jpFLJ+E9I8wvZz+XchHV+CqZQWlIe8X4qqC7qGwsE0TaK8ZXBel8pBjLKHZSiZJfluf0KlSaX2Z40+KmwcG6T/xleecwtfllxpb2BngPmpoNOzc6aOfjhjSMZVTjq2REaa+KnJQR46uCzMp/vcLcXLkzoLRXNb5KptsEc9NCZYacCRJfJcOu4Soz5IxqfJVMxYEj9g14EFTjq2Q4c1t1hpxRja+S4cztINLeIPFVMhf2KQq8ibB8h1p8lcz6PelJe98uNuXfV7ziHV8lw5sWQaW97J3yn/HBYhh500JlhpwR46tU5pdF2PRTtQtOlPROOb375ECKF960+F3/GYGeYzrKOyKiITPMzRXVGXIi897hD2ko74iS90VB3gPReDWIEW5Tc3pxt9PXJJV3e+vU/x2PC143KNjmCjdYgijviJLjgi9MUn8PROVdmBhG3eRSbZAtoEDPMXLpJPxrQPlrkPgqmXSMZYLEV8mkYywTJL5KJqixTJD4Kpl0jGV2Hjxqzy/7xVfJpGMsw/Lv816YGngeOR1jGdX4KhlR2qu6SRIkvkqGZYk3vKG+ubJpr3p8lQzLElX9DYiSIxQq8VUybAio6m9AlMzmfWR0sJGNmqPJ7pOf0zUjxlcF9cNgQ8A7AnSfxPiqoIZhbAgYpPsUJL5KhhUhQTa4VOOrZCotae/p3dWjMMX55aBRd59ZipD7Ff0NiJLu6CrxVTJPW4aAI0rUrw88QnGNQnyVDM/kq25wGYZhj1D0nBjMbHRjVZ19bVflQJrKO6KkIeA/xqhHYfIIharxqggbAqr6GxAlRyhuCaC8Y1gWv0VRoWEYhj1CEdQPgzfULu2nHoW5pzapvAvqh8GGgKr+BkREk1emp7yLmlyqDbIFFOg5Ri6dhP8YE8y4LUh8lQwby6hKWMX4qnR2UZ8IKO0V46vmphEnxsYyfhE8TJD4Khk2lrkgQPeJTZLufSe44zVLe1UlrGJ8VTpxYiztVTWWEeOrytJwvA4q7eXPcpD5ZYYjfy4boN59eiJAfJUMR/7EP1frPtU3NtGlAeKrZDjyR1WVww7UKvFVMmL3SXUDb1SA+CqZ2RuCS3vZJCkdx2tWK/WepLa5EjS+SobVSqoS1iDxVTJ1aUh77fiqAPPLTGG5KZkNIu3lz3I6ngO9LLPKgYqbr2J8VVDPASKy0xZUzSP5s3xGjwLaXROsgN1dc8x+31XvA9JV3hEl1Uqqm6+i8u6lRDBZPFFSrTRM0TwyxXg1oOcAEdl+EarmkfxZVjVeFdm095B936EKf5b/OEzNeFWE1Up/H622udLUbNixroMCyuKjJpdqg2wBBXqOkUsn4TMBdvmDxlfJ8K6oqrHMZCG+Kp1d1O4BjWX48XcpxlfJBHHEF+Or0nEVrgxoLBM0vkomqLEMd6t+9eK0tKLSghrLcLcqHVdhIrIlwSrxUEHjq2Q2WNLe83urdZ+CxlfJvG9Je1Xl1dytuqRvsPll5iGr+6Qqrw4aXyXDXTmVAvFoQ5Mt4w4iPWY4juq3L6ttrgSNr5LheeRnFbtP3K26QjG+SuZPI4NJe/nxQaTHTHOzYX+uVSS6YnxVkJEsptSaR752kFoUJj9eNb5K5pUpZkGqKq/mx6vGV8ncas0jq8irDcOwH6+6+SNyuL7R3lxR2aAMo7wjSs4j3/rWXKXHh1HeESWVdKrGpmGUd0RkF6QqxqZhlHdE5mYCb4iqfM5E49WgyjsioollppJO1dg0HePV1iKXaoNsAQV6jpFLJyHPp6oUiUHjq2RKAkh7xV3UoOYiDBvLqEh7d+xPxlctUOxAyLCxjIq0l+Orzu+tFl8lIxrLqHQBg8ZXyfCsvIq093hTs23yphpfJRPEWGZjVV3g+CqZztZmicp7z/FVv1aMr5Lh7tNpit0nVrmoxlfJcPdJ5b0X46tGB5B3inD3SeW9T42vCp4XTZTsPqlIe0eUBIuvkuHu0y8Uu0/3W/FV/xoXbH6Z4e6Tynsvyr8nLA0eh0iUnJVXkfbOTyO+SqZjAGmvGF+VTgG7okJd2ptOfJUMz8qrSHv3H26w55dV46tkeFZeJbqM46uCGq8yhmHY11wV+XifEMo7ouSs/NUD/TdXROVd/zTnl3lWXuW931Vz1JZ/z9kQXHlHRPasvMp7zx4m6SjviMxrPN87qGye8z3iPSOCK++IkrPyXYb4R2GKxqtDZgRvXERNLtUG2QIK9Bwjl05CNv7w+yJLJ75KpiyAsYyOXVTuPql0dzi+6s8jg80vi7Abrl/3SYyvGlocXP5NZN6E8Jesn7FMOvFVMkGMZZLxVcHnl5kgxjIcX/VwGpFzDOfQF/l0n8T4qg9Kt6a11iGh++T3+qQTXyXDOfS3DfXvPqUTXyXDG3mvTvHv7jxgjTIEia+SYSPC0k3e16VDgvxbNb5Kpqr2mL2h4FdosEv5qQHiq2R4I0/luvRmCPk3wxt5fr4K6cZXyfAoxYoK7+uSGF8VxPRTZMs+Mwqz4/P+myvpxFfJ8Eaeiq9COvFVMqrjamJ8VRDTTxlWM/jlwodV3hElfRwu7usfhVkgKO+CGK+KcA79MwrXJfaJuDNN5R1RMod+vI+vgmi8GsT0U8QwDFtN5+dsLyrvgkbOMZxD3/nVYt/Hjrc2k38Z0Hi1tcil2iBbQIGeY+TSSThAsRBKJ75KRtVYJt34KhlVYxlxfjlorJeIqrEMO0EHja+SUTWWeTKN+CoZVWMZcX45aKyXiKqxDMdsxeLBnKdl/jxSrfuUbnyViGEkpb1+3ad04qtkSjftU+o+HWlotH0UVGf/nXh1itl98pP2ivFVquZITqhGRfKG3ZUB4qtkjjYku09+5y5v2KnO/jtRZEl1u/hIe8X4qnTk38wLk0yprp/nB2/YBY2vkrl2kFls+Hl+9E8jvkpmb129vdnl9TsMw7A37ILGeonwJrOf54c4vxw01kuETTL9PD+maIqv4jEfP88P3rC7PU3lHZEZMcnP2YumZsP+TKnO/jvBJpl+nh8VB5LKO9XZfyfYJNPP84M37NIxXhX5paW08TOt5A27oMarIqsrze/oi17y3lw53tRMlw8wGxeqs/+tTS7VBtkCCvQcI5dOwmQ2rHsXJN34Kpk9tWrGMp9r2kWdsFTNWCbd+CqZf41b7vvlEia+SuY3/fyNZdKNr5JRNZZJN77K7ff4GcukG1/l9ntGe3SfwsRXyXAx5RVLxZLcoPFVMiwjv6Sv9+bKMKtrdPmAYPFVbr/Hz9WbJbmq89V+v8fL1VuMr5pYFiy+SsQwDHszz8tYS4yvUk11cIJl5J1fK/Z8XLrxVTIDrd/Ty0PaGya+SuZ2S0ZeWO6+ubIvzfgqGVHa6zVWJMZXBYm9kpmx1vw9t/hIe9ONr5JhA9eXC9w3V8T4KtX5ajf498ze4N4Vr9SgvCMyI8z4vfNSh3xlGa+GnV/m3+PXkIh/birvVOer/X6PV0NCVN6lY7wqwiNoXg2JLfsOh1beEZn3j7G4OU7hxacL0zdebS1yqTbIFlCg5xi5dBJyJI+XxPRZDbuoRGrGMjp3UVWMZTZWJeXffjJLP1SMZcYs2GbvJqcr/2ZUjGUeG7NUqdD1Q8VYRoyv8ip0VVAxlhHjqzYEjK+S4c+4141PmPgqGe4+ed34pBtfJbPVkvae49F9OlTfaHdVgsZXyfBn3GvkYNHW9OOrZPgz7jVywPFVV6cRXyXDc95uM/Nh4qtkeMTh1x7dpzDxVTIq3wczQ8RXyfCMvtfIwUuJ1XahG6aANQzD7na6mb6J8VVeha4KHNF2pYe0d3dNMr7Kq9BVYZA1o+81cpBYoS++6o/DzM2VyR4jBzqUd0SmMovvHdzmrhubmm0vkTDKO6LkZ/z3b7r75WyrFpV36TcuiJKf8b4eIwfjBOPVMMo7IqIbrRn9Yg/H+ac0KO+IzHQCfu/cNn7rG5vs78QwyruoyaXaIFtAgZ5j5NJJ6GdCtEWQfy9NI75KRMVYRucuqoqxzOMh4qtk/Ixljh1vsrve6cRXyfgZy7C0LJ34KhlR2uumang3RHyVjC3t9eg+cRRbOvFVMiztdfNiCBtfJcMuvG6mQmHiq2T2KXSf7PiqEPJvhqW9XqZCHF/lpdxRhf0j3EyFxPiqr1ekL/9mWAHjdj0ME18ls736iN3NdYPjq24MIf9m2D/C7XoYNr5K5p8+0t4qYX45nfgqGT6H3aS9bIaZTnyVDMcHXtjHfXOFzTDTia+SYf8It+uhOL+sI77qr9YGotv1UJfyjuGNDDdFCivv0jVeFVlsbSBe8cpM18ew8u7+NI1XRd4o8lYyiso7lcQdP9g/wu16qEt5R2Q2Xfj7x80TQJfyLmpyqTbIFlCg5xi5dBLyruxfXeTdHF/l9t+D4mUsEza+SsbPWEaMr1pdGf699jOW4Zn4MPPLIn7GMmHjq0T8jGXE+eV04qtk/IxlwsZXybBDdI+JzjdIPBPfKc34Khl2iHYzvOKZ+HTiq2RSuk8Osk8xvko1XssLdoi+ebDz5grPxKcbXyXDDtH9Cpy7TzwTn258lQw7RJc4GF4ZhmHPxKsYHPpx4HCy++T0uRPjq/wMDlVgh+i7hjt3PMX4qjDyb6bbBHNzxS1FJGx8lQyrs5w6nmHjq2RY2ntmD2dp786DR+2OfjrxVTJjF5mbK25Rk7xxFnZ+mXnC2tx2+67mmfiwyjuGv1+cvEaONzXTFZb828/gUIV1u+vsbrUTmwTj1eUh5N/MKGtz2+27mmfidSjviIge/GCR53c1z8SrGByqwNcoJ7WUqLzzMzhsa3KpNsgWUKDnGLl0Ek7ymLXaWJUsYNONr5LxkvaODhlfJcPGMm7S3kc/MueO/UzkVOEv0YccpL1ifJVKhJEK/CX6vkP3KTW+KnwBS5SU9jrJyXlzIt34KhmW9roZy/DmhEqEkQos7X3KofskxlepRBipwPL1cQ7S3gUa4qtkeA50p0NBLMZXhZV/EyXl650cuk864qtkWL7+nIO0d78g/043vkqG5euJFS03V8LGV8mI3ScnSbIdXxVS/s0Ue0h7dcRXyfS13MudpL27apLzy34mcqqwfN1J2svfhenGV8nUHElGYTqNxPDmhJ+JnCqTLffyO4e1/C5vbGqmKy3j1bDzywzL118vatmN36pRecfw/LWTmzhvTlzwop755Z0Hj9qbiE48oVF5R5RslDj54IjGqzqUd0RJ+bqTDw4rP2Lx8Mo7hr1bVlW2vI8cpVF5FzW5VBtkCyjQc4xcOgm5I+I0p60jvkrGzVhGR3yVjJexjBhf5edkqoqXsYyO+CoZL2MZlh+Gia+ScTOWEeeX042vkvEyllkszC+nG18lw6MVTvN2LD+8KkR8lQyPVsjzdrriq2QusKS98g2XGF/lNUsaBHbWv7BPy+6TjvgqGR6teMLB6V5HfJUMj1aMXZTafRLjq7xmSYPCDt/yZo0YX+U1SxoEHq24fEDLzZXJGuKrZJImpS2VIt2/CB9fJXOXdW5Nkpzum5oNusqaX043vkqmUdhckeXyYnzV4jTjq2RKrHPr+tdbRmF+ZhWAOuOr+hWY55aT071u5R0R2eeW7HSvW3lHZJpK8nsnNwtE5Z1TwZkOPFpx+9ulLf4bK+8u6atHeUeUHK1wcrpn5d1jGpR3DHsDLJCc7o82NNGFfczi/eMF4ZV3UZNLtUG2gAI9x8ilk5DnJeUvdV3xVTJsLCNLezm+Sucuqpe0l+OrnG7q04WNZW4anNp9OtLQaBdI8k19GNhYRs6yFeOrws4vi3D3TM6y5fgqHfPLjCjtlTvyHF/ldFOfLiztvVOS9orxVfJNfRi6TVjpWAzM3agnvkqG5Z9yMTBAQ3yVTMWBI/bfIGIYBnV5a67rTX26cGyhXAzsravXEl8lw7GFcjEwVVN8lQzfwMpjODriq2TW73GW9jY1G7YpZZj4Khm+7svS3h37k/FV8k19GPi6L0t7Ob5Kx/yyCLvPyxuJHF/1Fw3zy0yZdd3/Xf8ZKT8/3tRsb64O1xhfNWSGubkij+FsrKqz5d+6lHdERPeMMK/78hjOR5qVd0Tm552/f+RRDs6bd/PtSQeOLbxuUOp9mKi8G61JeUeUjC2Ux3BSlXd6GhdEZMcWymM4I0r0Ku+iJpdqg2wBBXqOkUsn4WIXOeojo61d1JDxVTJOxjJR7qI6Gcss36EnvkrGzVjm7eJN9s91fgm5Gctw7NR/xuuRfzNOxjJifJWO+WXGzVhGjK9ykmunC3d2b3gjdXNFV3yVDHd2+wiFqs74KpmbBpubKzPXJjut1Zriq2Rqjia7T+JmmxhftbdOXwFbYHV2/zgstfukK75KpsdEc3NFNNrSGV8l09mSJotGW7riq2R21Ry1zy/xNeP55bDxVTLc2ZWNttj4788j9cwvM9zZFY22xPiqocV65N8MF1ei0dZmYX45THyVzMYqc3PlvBempvz8E9t4Vc/8MsOdXXlELArlHVGysyuOiEWhvGNYWbRF2OQWlXfrdusrYPme5NJ+qVGYUSjviJKeKvKI2AOWOkin8o4o6akiRlweEoxXdSnvoiaXaoNsAQV6jpFLJyEbqYkZyTrjq2SecJD28i6qjvgqGTaWEaW9HO0TNr5Kho1lLhC6T+L8ctj4Khme3XpcUAFwtI+O+CoZlvZ+KnSfONrnGg3xVTKytNcwDFuBETa+SoalvZcNSHaf9muMr5Jh1/T458nuk874Khl2Tf9KUAHoiq+SEbtP3EkW46vczNzSxUkFJMZXkXFMYwAAIABJREFUOZm5hYFd03tPSm6u6IyvkmHX9OlrkpsoPP97l0b5N5F5veL3jruRjU3N9iZB2PgqmcLy3bYKgBHnl71ymtOh15ctpb2swLhAQ3yVDMvm5wsqgCc1xVfJ7Kk1ozBPfS65uSLOL+uOr2LXdNEELirlHVHSNV2MX2UFhi7jVREu/EUVACswHteovCMyTedicdP/gBGNVz/VYLwqwq7pYvyqqLzbolF5R0T099Gm6kCMX2Xl3ZUalXdRk0u1QbaAAj3HyKWTkHfdz++d3HXXGV8lIxvLpMRXRbCLKhvLLNm23/4S2lat90vIyVjGjq/SOL/MOBnLcCHmZJgVFtlYRoyvcjLMCotsLKMzvkpmw56W5wEXYr9/U9/8MvO+dWPJChXd8VUyD1ndpzELzO6T7vgqGd7Y4BELLsR0xFfJsKP/b19Obq5wIaYjvkqGbyyftbpPovxbR3yVzJ9Gzk/pPumOrxJpbjbs+VpWOeiMr5LhkY5rByWjMLkQczLMCguPdLBCRYyvcjLMCguPdLBCRWd8lczh+ka7OGajtCjjq3ikQ/Sv4UJMt/KOKOnozwqVow1N9ncEX9d0wuc0K1RWVESjvCMiqqo7ZjdFWKk1zDJevXyAXuUdEdHEMlMR86eRSYNCVt49q8l4VeRZa6SDDQpF5Z3YVc90cqk2yBZQoOcYuXQS8rwoR8Hojq+SYWMZlvbyza6u+CoZNpZhaS/f7IqdS12IxjL1jU0p8VVfaZxfZthY5g6r+1S6UW98lQxLewdaRcgrU9banUud8m+Gu3YLNleTYRh0q3WzK3YudcHS3tOs7pMYXyV2LnUx3ip6eAZVjK/SOb/MPGNJe3kGVXd8lQzH5pTvrNEeXyWzscrsPv3C6j7tFOTfOuKrZD60ih6eQRXl3zriq2R43IhnUHXHV8l0FKS9x5ua7WgyHfFVMlz0sLR3Y1VS/r2iQp/8m+FxI5b2jllgzi/riq+S4aKH0x8eG7O0RedSF4Zh2MqDqtpjKfFVoyOIr+K4xKsHmpsrUSrviJJxiZz+wMkbUSjviMiOS+T0B07e0K28IzI3G/je4VB9Y4rxqm7lHRFRkfV902WIGYW5aGt0yjsiohcmmd83nP7AyRtXR6C8i5Jcqg2yBRToOUYunYT7BKdzwzC0x1fJcEH+3/ErUnZRdcVXybCh2JfLdtJ8Ib5KnEnXRbNkLDPQml++dtCsSApY7j5dN6iEDMOg2zXHV8mIxjLi/LKu+CoZ0VhmxlrzhkJXfJXMIaH7dLShiV7k+CrN88vMFKv7dNvQuZHEV8mwodirU9alxFfN2aBvflnkau4+bdqnPb5KpsqS9v6sm3kN4/iqe0boia+SYUOxP49ckBJfNWSGXvk3w4ZiQ4s3RhJfJcOS6BUVB+10A13xVTJb9plRmB2fNzdXHtccXyXDhmKPjF5Mx4430W80x1fJsKHYh/O20urKWruA1RVfJcPfpxurDtnpBlHFV3FBfnFfMwozSuUdUTLK85mxy1KVd4uimV/me6HxSyrsESjdxquMYRi2KmZXzdGk8i4i+TdHeXZ+tZiIkso72c9GFxzl2WPiyhTlnehnkw3kUm2QLaBAzzFy6SQUCxN2EtUZXyXDxjKPjVlqm5xFuYsqGsuwyVmPidF8CREljWXKth+w/7fsWK+L5YK0V4yv0j2/zIjSXjY5u3mw3vllEVY7fFFWYZucyY71uhClveU7a2z5t+xYrwtWO1wzcJZtcqYzvkqG1Q75X62ylRA646tkWO1QWL5Le3yVzJGG5DVsza5a7fFVMqx26PLWXFsJoTO+SobVDgMK19pKCJ3xVTLXDjI3V4rXVWmPr5LZW1efUrTyOSg71uuC1Q5/Gjnf/i6KYn6ZYbXDWzM32t9FsmO9Tvj9Kt20z55flh3rdbHV2lw5p1dh5Mo7oqTa4aEPF9smZ1Ep74iSaof3526xTc5kx3qdsFfNkm37beWdTuNVETa7u+ilIlsJEZXyjiipdnjq0zJbCRGV8i5Kcqk2yBZQoGchQ4cOpQ4dOtCJJ55IF1xwAc2ePdv/H1nk0kkoZrWyiZPO+CqZCUsrbGkVx1dFuYv6r3FJOWgsrj++SoY7MrzejRrjq2Q2s7HM81PsWcc+GuOrZHie8Y63S20DN9EVXDc8z8ivZRTzyyL8eeT17tAYXyXDcTa/fqnILogGRjC/zPA8413D59nxVfM1xlfJ8GvI//e8F/TPLzOitJfX0xlfJcNKnMsHzLTl3zrjq2RYiXPvO/Mjia+SYSUOv5YXaYyvkjl2PCnt5fVkV3CdsBLn2kGzbIf1jzTGV8mwEof/NjO+KpoClojsJAFeL8r4qmpBfccFbFTKOyKirywlzk2DZ9vFbFTKOyKi+OcrUl7L07tHI/9mOAqP17t2UHSNix37zdHGn/csoDsiVt4Rka3EuW3oXNufJCrlXZTkUm2QLaBAzzLGjh1LJ5xwAo0cOZLWrFlDTz31FH3ve9+j7dvVdpJz7STkG3b+EopC/s2wsQwfUe+icveJD93xVTJsLMOHzvgqGTaW4eOsnoUtMlt1wtJePnTHV8mwtJcP3fFVMizt5UNnfJUMS3v50B1fJcPSXj5Ec6AoYGkvH2wOFBUs7eVDZ3yVDEt7+biwTzTyb4ZTLvh4SHN8lQynXPDxfkTybyJzc0X8/unQLUHrI5hfZjjlgg/d8VUynHLBh+74KhlOueAjyviq+samlLWiVN4REc1cW5Wy3lURGK+K9LE2V/joHoHxqgiPOfExOSLlHRHRgcMNKWud2aOA9kSkvCMi+npFZcp6Nw3Wb7zaGuRabZANoEDPMi6++GJ69NFHU3521llnUbdu3ZT+fa6dhDwPFIvrj6+S4RxrPgrLo91F5Rxr3i2OYn5ZhHOsY3FTJRDll5DYfYrFE/RyQbQFLBvL8DF7QzTyb4aNZWLxaOKrZNjILBZP0N0j5kW6luj9EIvrj6+SYWkvH7rjq2Q4xzoWjya+SoaduGNx/fFVMturj6S8lrrjq2Q4x5oP3fFVMpxjHYtHK/9meJY4Fk/QE5rjq2TW7KpNeS3HLopG/s1wjnUsHt38sgjnWMfi0c0vi3CUYSwerfKOiGjx1tTNlUkRGK+K8AheLB698o6I7BG8WDxBN0SovCMiOi4oJ2PxBL0YofKOiOwRPD5mrI2ucREluVYbZAMo0LOIhoYG+uY3v0lffPFFys+ffPJJuuKKK5R+R66dhBxVEkV8lYzYfYoivkqGjWVi8QT1jWh+WeQvQvepOIL4KhHRWOacXoWRzS8zLO2NxRN057Do5peZgcLmCsfyRQlLe2Nx/fFVMuLmyvkRzi8zLO2NxaOJr5J5Ueg+RRFfJcPS3lhcf3yVzH6h+xRFfJUMm+zF4tHEV8mwyV4sHk18lQyPCUQRXyXD0t5YPEFXvKI/vkpm7KLk5sp/xkcn/2aesEz2YvHo5pdFLrA2V07vPpl2RjS/zIgZ69cNin5+mU32YvHolXdESZO9WDxa5R3DY2pn9Sy0IxWjgk32YvHolXdRkmu1QTaAAj2LqKyspLy8PCotLU35ed++fenMM890/Df19fVUW1trHxUVFTl1EvIN0guTov8S2ladlPZGEV8l8/EC8wYpqvgqmces7lNU8VUyHMUSRXyVDBvLxOLRxFfJsLHMeS9MjSS+SoZjdKKKr5JhJ/Uo4qtkFgndp+URyr8ZjtGJKr5K5s5hZvfpkdHRyr+JUrtPH0YQXyVTvM6U9kYt/2b6WgaQUcVXybD3SRTxVTI1R5JRmFHEV8lMtgwgo4qvkun+hWkAeU0rxVd1esW8d4haeUdkxicmlXfRyb+ZcYt3UCwerfGqyFOfmpsrt0SsvGO4MdOvIPrGxYY9dfZ7VxKR8WprgAI980CBnkVwgT5vXqpE9aWXXqKf//znjv8mPz+f8vLyWhy5chK+NXMj3TlsXqTzy0xzs0EPfrCYnv1seat8CVUePErXv15Cn0bkZCszddVuuuGN2ZGaOIm8OmUd3TNifqTzy8zxpma6790F1CtCMxmRzXsP0XWDSlqlE0RkmhD9/s3ZtG539EUQEVHvSavpL6MWRjq/zBw73kR3Dp8XmQu+zOrKWrpuUEnkIyzMuEU76JYhc2hLxBJiptuElfS39xdFEl8lc6i+kW4bOrdVVCREREu3H6DrBpVErgBiPijdSre+NTfyDiyRqTp6euwy+seYJZHLv4nMWd+bB89pFRUJkZlNfv3rJZEaQIoMm7WJ7ni7NPLRMSLz3uHvo5fQ02OXtcq9w57aY3TDG7NpdIQmgiIz11bR9a+XUFlE8Ykyg6atp7uGz4tceUdkmhF3fW8hdZuwMmu750Qo0DMRFOhZRDoS91zvoAMAAAAAAACcQYGeeaBAzzIuvvhi+sc//pHys7PPPhsmcQAAAAAAAIBAoDbIPFCgZxkcszZq1Chas2YNPf300/S9732Ptm1TkyrV1NRQXl4eVVRUpHTWceDAgQMHDhw4cODAkVsHq2tralpnhBH4gwI9Cxk6dCjFYjH69re/TRdccAGVlJQo/1s+CXHgwIEDBw4cOHDgwIEjL89s3oHMAAV6jtHc3EwVFRVUU1OTMTt26Obj8DvwWcGheuCzgkPlwOcEh+qBzwoO1SNbPys1NTVUUVFBzc3RG0wCNVCggzajthYzL0ANfFaAKvisABXwOQGq4LMCVMFnBegCBTpoM3AhA6rgswJUwWcFqIDPCVAFnxWgCj4rQBco0EGbgQsZUAWfFaAKPitABXxOgCr4rABV8FkBukCBDtqM+vp6ys/Pp/r6+rZ+KiDDwWcFqILPClABnxOgCj4rQBV8VoAuUKADAAAAAAAAAAAZAAp0AAAAAAAAAAAgA0CBDgAAAAAAAAAAZAAo0AEAAAAAAAAAgAwABTpoM4YOHUodOnSgE088kS644AKaPXt2Wz8l0Ibk5+dTXl5eyvGjH/3I/u+GYVB+fj6dcsop9J3vfIc6depEq1atasNnDFqLkpISuvnmm+mUU06hvLw8mjhxYsp/V/lsHDhwgO677z76wQ9+QD/4wQ/ovvvuo4MHD7bmnwFaAb/PSteuXVtcZy655JKUx9TX19Pjjz9OP/zhD+m73/0u3XLLLVRRUdGafwaImH79+tFFF11E/+///T86+eST6dZbb6V169alPEblc7B9+3a6+eab6bvf/S798Ic/pCeeeIIaGhpa808BEaLyOenUqVOLa8rdd9+d8hh8/4CgoEAHbcLYsWPphBNOoJEjR9KaNWvoqaeeou9973u0ffv2tn5qoI3Iz8+nc889l3bv3m0fe/futf97//796fvf/z5NmDCBysvL6e6776ZTTjmF6urq2vBZg9agoKCAevToQRMmTHAsulQ+GzfccAN17NiR5s2bR/PmzaOOHTvSzTff3Np/CogYv89K165d6YYbbki5zuzfvz/lMY8++ij95Cc/oaKiIiorK6POnTvT+eefT01NTa35p4AIuf766+n999+nVatW0fLly+mmm26in/70p3T48GH7MX6fg6amJurYsSN17tyZysrKqKioiP73f/+XHn/88bb6s4BmVD4nnTp1oocffjjlmlJTU5Pye/D9A4KCAh20CRdffDE9+uijKT8766yzqFu3bm30jEBbk5+fT+eff77jfzMMg3784x9T//797Z/V19fTSSedRMOHD2+tpwgyALnoUvlsrFmzhvLy8mjBggX2Y+bPn095eXktuiGg/eBWoN96662u/6ampoZOOOEEGjt2rP2zyspK+sY3vkFTpkyJ7LmCtmXv3r2Ul5dHJSUlRKT2OSgoKKBvfOMbVFlZaT/m008/pRNPPBE52O0U+XNCZBboTz31lOu/wfcPSAcU6KDVaWhooG9+85v0xRdfpPz8ySefpCuuuKKNnhVoa/Lz8+m73/0unXLKKdShQwe6++67afPmzUREtHnzZsrLy6OysrKUf9OlSxe6//772+LpgjZCLrpUPhujRo2ik046qcXvOumkk+i9996L9gmDNsOtQD/ppJPo5JNPpjPOOIMeeughqqqqsv/7jBkzKC8vjw4cOJDy78477zx6/vnnW+V5g9Zn48aNlJeXR+Xl5USk9jno1asXnXfeeSn//cCBA5SXl0czZ85snScOWhX5c0JkFuj/8z//Qz/84Q/pnHPOoX//+98p6i18/4B0QIEOWp3KykrKy8uj0tLSlJ/37duXzjzzzDZ6VqCtKSgooM8//5xWrlxJRUVF1KlTJ/rRj35E1dXVVFpaSnl5eSmdCiKihx9+mK677ro2esagLZCLLpXPRt++femMM85o8bvOOOMM6tevX7RPGLQZTgX62LFjKZFIUHl5OU2aNInOP/98Ovfcc6m+vp6IiD7++GP69re/3eJ3XXvttfTII4+0yvMGrYthGHTLLbfQZZddZv9M5XPw8MMP07XXXtviMd/+9rfpk08+ie4JgzbB6XNCRPTOO+9QUVERlZeX06effkodOnSga665xv7v+P4B6YACPcdobm6miooKqqmpodra2jY51q1bR3l5eVRUVJTy8549e9Lpp5/eZs8LR2Ydu3btopNPPpn69u1L06ZNo7y8PFq/fn3KY+6//366+uqr2/y54mi9Iy8vjz7++GP7/1f5bPTq1YtOO+20Fr/r1FNPpfz8/Db/m3C0zmfF6Vi/fj1961vfoo8++ohqa2tp5MiRdMIJJ7R43JVXXkkPPPBAm/9NOPQfDz30EP3f//0frVmzxv6Zyuega9eudNVVV7V4zLe+9S0aNWpUm/9dOKL/nDgds2bNsmXwtbXZ8f1TU1NDFRUV1Nzc3NZlCrBAgZ5B6HCf9aOioqLF78CBAwcOHDhw4MCBA0fuHkiryBxQoGcQOtxn/aipqbFPwrbescOBAwcOHDhw4MCBA0fbHdy8k93nQduBAj1DcSvQvdxnVaitNWV/tbVwGAUAAAAAACCXQW2QeaBAz1DcCnQv91kn6uvrHXfJMuEkfPyTMrpp8OxIjj+NnE/bqg/7PwkfGpualZ7nE5+UUWNT+NmdLfsO073vzPddb0TJptBrERFNW72Hurw113Ot24bOpTkb9mlZb9C09b5/233vLqBdNUdDr3XseBP9ffQS3/We/Ww5GYYRer11u+voruHzPNe6efAc+nDe1tBrERFNWl5JXYbM8Vzv9rdLadHWYCobN/oVrPF9Lbu+t5CqD9WHXutQfSM9+MEi3/V6TizX8t6trKihO4d5v3e3DJlD4xbvCL0WEdH4JRV0i89798dhpbR8x0Et6z3/Zbnva/ngB4uo9tjx0GvtP9xAf31voe96fSev0fCXES3Ztp/ueLvUc60uQ+bQl8t2alnvo/nb6ObB3u/dXcPn0drd4b9jDcOg/45f4ftaPjJ6MR07Hj6jfU/tMbrv3QW+6w2cqicaau7GffSHod7fP13emktTVu3Wst7I2Zt9/7Z7RsynzXsPhV6rqdmgpz71v3d47OOldFzDvcOO/UfoTyP97x2GFm8MvRYR0cy1VXSrwr1D8Trve1RVhszY4Pu3/XnkAqo4cCT0Wg2NzfTYmKW+6z0zbhk1N4f//skEUKBnHijQMxSnAt3PfdaJ/Px8xzmTTDgJb3hjNsXiiciOYbPCF7HLdhxUXm9lRXhp0FszNyqt1TFfTx7vn0bOV1rv76OXhF6rudmgDt3UXsvRGorY0o37lN+7TRpuyF6ZslZprUv6Tg+9FhHRrW/NVVrvmXHLQq91uL5R+bX8fEn4GbZpq/cor7e75ljo9fK/WqW0VufXikOvRUR0zcBZSuv1nFju/8t8qKo7pvxaFpbvCr3exLKdyuvp2BB49rPlSmvdMmRO6LWIiH778gyl9V4uWBt6ra37Diu/lrM37A293pgF25TW6tAtoWVD+rExS5XWu3vEvNBrERGd33uq0nqDp28Ivdaqyhrl927JtgP+v9CHd0o2K631854FodciIur63kKl9f72/iIt653RvUBpvXfnbAm91sIt+5XfOx0bcZkACvTMAwV6huJUoMvs2rWLTjjhBJowYYLrYzK5g754634qXlel/Xjwg0UUiydo4LT1oZ8jF3m/fXmG63qX9ptOsXiCFmyuDr0eF3kPfbjYca0vl5k3v6c9Nzn0WkTJIm/QtPWO6/WdvIZi8QT9ZdTC0GsdaUgWeVNX7XZc788jF1AsnqDhGjZXuMi76rVi1/ful9YNW/nO8JsrXOQ9/kmZ41qfLtxOsXiCfqFpc+XaQWaR93bxJsf1en1ZTrF4gh79KPzmyt66evu9m+nyWt7xdinF4gkaPX9b6PX4c37jG7Nd37uzexVSLJ7Q0u3iIu/Zz5Y7rvVB6VaKxRP0m356Nle4yHtv7hbH9f4z3nw+/xq3PPRaXOT9vGeB62t502Bzs3TC0vCbK1zk/cHqnjkdP7M26vbUht9c4SKvx8SVjmsNn7WJYvEEXT1wVui1iJJF3scLtjuu9+SnZRSLJ+j5L8NvrnCRd37vqa6vJW/26Ogyc5F37zvzHdcSN84O1TeGXo+LvD5fr3Zc742iDRSLJ6iLps0VLvK+KKtwXO/hDxdTLJ6g/oXhN1cWbTWLvEv6Tnd9737X37wOzNGgUHu9aD3F4gl64P1FjmtNWl5pv3c6ur53DptHsXiCXp2yznG9/oXmvcw9I+aHXut4U7P93Cev3OW43v2jzM/SkBnhN1dmrquiWDxBnV6Z6freXfRSEcXiCVq6PfzmSiaAAj3zQIGeoagU6EREp59+OvXv31/59+bCSchFZT8NEsoZa80bEq/uy+/fNG9uZ60P38F48evVFIu7d19qjhy3v6h0yOKuf72EYnH37svklbsoFk/QncPDdzD2H27wvUHo/sVKisUT9EZR+C9ZviHxukHo9MpMisUTtFiDDLzbhBWeNwg7Dx6lWDxBZ/TQ08G4fMBMzxuEcYt3UCyeoL++F35zZcf+IxSLJ+isnoWuj3nKKkxGzt4cer2xi8zNjAc/cO++8A3S6srw17LHPzGf+yiX7suGPXUUiyfol72nhl6LiOiCF6dRLJ6gdbvrHP/7+3O3UCyeoMc+Xhp6rbW7aykWT9CFfaa5PuYhqzD5eMH20Ou9O8d87k98Uub6mHOszRUdY0h/e9/ckB27yPm5swrqd/1nhF6LiOjnPc0ib8d+Zyktq6D+O35F6LWWbDtAsXiCLh8w0/UxrILSIeEfPN0siLtNcH7uhmHY1/B9GkZZ7h5hFnmTllc6/nfeIL9uUEnotZqak8/9wOEGx8cMsIrKFyatCr3e7A17KRZP0A1vzHZ9TBdrg7xo9Z7Q671csNbe7HBCVEEdbQg/DnHLkDnmhu1aZwn71FW7KRZP0G1D54Zeq+5Y8r6nvtH5ufMG+atTwo9fFJab9z13vF3q+hjeGCvdpGf8r63Jhdog20CBnqGoFOjV1dV04okn0ocffqj8e3PhJBw4dR3F4gnqpaGDkVhhFajD3AvU263OYWF5+A7Gc1aB+nqRc/f/2PEm+4uqToM8lAtUtzlllQ0KVVQKVL8NiiCoFKh+GxRB8CtQqw8lu9BNGjoYfgXqV9YGhQ55qEqBGv/c3KDQIQ9VKVAvG2B2n3TIQx/8wLtA5Q0KXfLQs30KVFZb6JCHlm03i7zfvuxeoPIGhQ55KBeo/xnv3v3nDQod8tB73/EuUFU2KFQRC9S9dc4FqsoGhSpzrQL12kHu3X+/DYogcIGa/5V7geq3QREELlCnuRSoKhsUqqgUqG/6bFAEQaVAvWu49wZFEPwKVHGDYr/LBkUQ/ArUkvXmBsX1r4ffXOExnQ7dEq6eI/0KzMbMiy4bFEH4oqyCYvEE/XnkAtfH3DzY3KCYsTb85komkAu1QbaBAj2DOHToEC1btoyWLVtGeXl5NGjQIFq2bBlt376dDh06RP/+979p3rx5tHXrViouLqZLL72UfvKTn1BdnXMXxolcOAlVbhBV+XyJeaG+7133C7XODsYz45ZRLO4+P28YyTlutxvEIFzS15Tnu83PlyrcIKqyae8hisW9Jd4s8fe6QVRl9DxTluwl8fa7QQzC30cvoVjcXeIt3iAeaQgvD+2YP4VicXeJN98g3vpW+A7GygpTausl8eYbxFemhN9cGWbJkr0k3vYN4sbwHYz73jVHK9wk3uIcd1hTOsMwfCXePMf9p5Hh5aHzNlVTLG6OerjBEv+3ZoY3kHpNYYOUJf7LNJjg/WHoXM8NUpb4n/t8+NESlQ1Slvg//OHi0OtNX+O/QcoS/w9Kt4Zer/ck/w1SlvhvrFK/73DDb4OUJf6/fqko9FriBqmbgmtEiXndeXpseN+OrxQUXCzL/kyD+SRvkHpJvE/vPpli8QRVHgxvwsobpG4KLp7jvvLV4tBrqSi4Bk0zJf7dv1gZer1PFvoruP44zGzMTF4Z3rcjE8iF2iDbQIGeQRQXFzsaunXt2pWOHj1K1113HZ188sl0wgkn0E9/+lPq2rUr7dgR7MKeCyfhKI0dDJWbLZ0dDJWbLZ0dDL+bLZ0dDJWbLT+JZRB4ntLrZstPYhkEnqd0u9nS3cHgeUq3my2WWOroYPA8ZWePmy2WWOroYPA8ZY+J7jdbLLHU0cHgm60Cl5stUWIZ1i27oTE5T1lz1LnIKyw3N1du95BYqsLzlDcNdpfasl+BDnfulxJmkec1YnTVa8UUiydovgbfjhvf8B4x2lNrbq7o8O04eCQ5puM2YsSbujp8O2wFl8eIEW/q6vDteE5hxIg3dXX4dviNGKls6qqiouBS2dRVRUXB5bepGwSVESO/Td0g+Cm4VDZ1VWEF169edFfBqGzqqvKepeD6p4eCy29TN9vIhdog20CBnmPkwkn48QJz9/MhDR2MkbM3+xb7j31sFtXvzw0vD31AodhnY7MNe8J3MM7s4V3sr6405aEXaehgLNlmFnlXvOJe7PPr/dSn4TdXknKToF11AAAgAElEQVRF9yKPi2od8VksV/x6hXuxz0X1zpAdDJV5Si6qO3m83qqwXNFrnpKL6uc0dDBYrug2T0mUNClKrAjfwWCTNLd5StGk6OCRcJsrNUf95ymLraL6Ro/XW5WClf7zlOzb8VIi/OZKj4lmkedl0sm+HTPXhY9g6vyqWey7mXTq9O3YVXPUt9i3fTs8xqJUGa9Q7Hf3GYsKwjNj/Yv9K63XW0d848V9izyL/UouqruHHy3ZWGUW++e94D6mw0V1Vw2+HR9axf4/xrgX+1xUv1MS3rfjkdHmmM5HHsU+F9WrKsNvrnR83iz2t+xzHtPhovp8Db4dKypMH4lLPYp9eyxqTHjfjqHFpgrz35+5F/vs2zFmQfjNlUwgF2qDbAMFeo6RCyfhhKX+snRVVOTy/xpnykN1xLr5zVMSEf2mn7csXRWVecrNVgdDR6zbXAXDn9HzTcWCjlg3FcMfu4OhIdZNxfCHOxhhY91U5im5g6Ej1k1lnpI7GDpi3VQMf7iDoSPW7WoFw59TnzPloWFj3apq/ecp5282Zek6Yt1U5inZt0NHrNu/Lbm8V95y0rcj/OYKp2i4Zcbr9O3YoiCX1+nb8dF8fwWXTt+Of4wxr4deCi6dvh3nveCt4BKNRcP6dpTvNK+HF/d132zW6dvBcvlnPBRcOn07WC4/3uN6qNO3g+Xyu2qcN5t1+nawXN5LwaXTt2PgNH8Fl07fjkwgF2qDbAMFeo6RCydhgcYOBs9TekXm6Oxg8DylV2SOrg6GeOPqFpmjs4PB85RekTmfaexg8DylV2TO01bHSEcHg29cvSJzfq2pg6EyT7mxSl8Hg29c733HfZ6So8h0dDD4xtVrJvphjR0Mjjsq84jMOdfqGG116Ripsr3avHE9u5f7POVyy3ncy9hNleQ8pXuRxx2jZz06Rqr801IUveehKOI4xYll4X07fmUZzq13URTp9O1Ys4sN59yLPJ2+HawoetJDUaTTt4MVXOMWuSuKbtXo28EKrooDzgouMZozrG+HioKLY+R0+HaoKLh0+naoKLg4mjOsb0ejoChyU3CJ0ZxhfTtYweWlKOJoTh2+Hf0UFEUchanDtyMTyIXaINtAgZ5j5MJJOHOtKQ+9eXD4Dkafr/3nKe3HFISPdbvBZ55SfExJyFi3A0J3otFF+nlAYwfj6xVmkXeXxzylymNU6TbB3Dh506M7wdFoXo9R5QprnnLJNveNE45G83qMChUHzCLvTI95Su5geD1GlXGLzI2TBzy6ExyN5vUYVZ5UmKd84hN9sW4X9jGLvDW73K+LKo9RYd1u/3lKlceowp4cXvOUKo9R5cEPzCLvk4XuYzoqj1HlrJ6mI/72andPDn5MWN+OpZYjvldkGz/msgHhN1eGzDCLPK/INn5M/PPwvh33jPBXcPFjvgrp29Hc7B/ZJj6mOmSs25wN5saJlyeHTt8OzgHvPcm9yGPfDq/HqNLF8uSYvsZ94+QWhceocEhQcLl5cuj07ZhiKbj+4KHgYt8Or8eowp4cr3l4cqg8JpvIhdog20CBnmPkwklYusn8Ir5mYPgOhso85atT1mnrYPjNUxIR3WZ12ad6dNlVUJmnPNqQ7LIfdumyq8LzlPd7zFMWWR2MLho6GDxPOaLEffSAOxgDPLrsqvjNUxIlOxhzQ3YwVOYpdXYwVOYpuYPh1WVXRWWeUmcH41yfeUqipPO4V5ddBe6Oe81Tbqs+7NtlV0VlnpJ9O7y67Kpwd/yLMnep7WMKXXYVxO54lYsjPpE+3w7+brna47tFp28Hf7d4Kbh0+nbcpqDg+qsm3w7xu8VNwUVEdEYPPb4dKt8tOn07Xpjk/92i07fjukElvt8tunw79h3y/27R6duh8t2i07dD5btFp29HJpALtUG2gQI9x8iFk7BMYweD5ynfLnYv8nR2MHieckWFe/yQrg4Gz1N29Jin1NnB4HnKR0a7FwEqXQ5VeJ7yQ4/5cpUuhyrJeUr3+XKVLocKKvOUKl0OVex5So/5cpUuhyo8T+k1X/68xg7GaQrz5TynPm9TOOfxBQrz5Tyn/jOPOXVVeJ7Sa76c59R1+HbcoTBfrnJdVaG+MVnk1XrMl1+qybdDRZ2l07dDRZ2l07dDRZ316Ed6fDtUFFxERL/Q5Nuhos7i66oO3w4VBddwjb4dKgquvyhcV1VQUXARqV1XVWAFl9d8ucp1VZUnFObLVa6r2UQu1AbZBgr0HCMXTkKVOUFVVDo9KnOCqnCnx22ekkhtTlAF7vT4vU5+c4KqqHR6VOYEVVHp9LxR5D8nqIpKp+dOhTlBFRYrdHpU5gRV4dfJq9MzS8HpXRV+nbw6PTwn6OX0roJqp8d2eg/pPD5LYZ5SdHpvaAznPK4yT8m+HX8cFj7WTeV1YmXSIA9lkgqiQ7vX68TKpIVbwo2WTFZ4nViZdHr3/8/emYZHUWbtP9eMy7zOf8YP83o5zFzvBBccFUYU93dUxBUVcRcdR9BRHMQFHZdmDwhBEEFBkU0EWQRkE2xCMEAIEghbICxh3wwhBBCSsCUEcv4fnjrdlba765yn6nm6+63nvq76IBKqG6q665xz37/jfq0b8k3i/T1RnElU3Un4e6I4kyhCvonT3xPFmUQRhW+C3I54ziSqKHwT5HbEcyZRReGbILcjnjOJIirfhOJMoojCN6E4k6ii8E285HYkg/xQG6SaTIHuM/nhJqRMhqmiZCUpk2GqKHlKymSYIkqeEoA2GaaI4jSgTIapojgNQhOMOKRdiqhOg+cJpF2KqE4DnGDEIu1SRXEahCYYcUi7VFGcBhTSLkXUrCROhmPtSqeKkpW0T4Zj7UqnipKVxMlwvF3pVOGO83hOAwrbg6IDRKeBV9wOyoYQL7kduCEkntPAS27HLQQHF2UyTFHIaeDwPU2ZDFNEcRp4ye2gOA285HZQnAZecTuoTgOvuB0Up4GX3A7KhhAvuR3JID/UBqkmU6D7TH64CcsqTnk2waDQhr2aYNTLU1bFtoR5NcGgZvW9mmBQsvqUbDVVlKw+JVtNETWrT8lWU0TN6jvtqqUK85TxaMOUXbVUYZ4yHm34i1zx0BYvW00RNauPD23xstUUUWjDdXV1cAkhW00RJU+5bIdorsTLVlOFWf21MdaeAdC2Y1CEWf2rHbL6j3nE7cCs/stx1p55ye1AB9fYOA4uL7kdlKw+JVtNETWrT8lWU0RxcB0ibMegiuLg8pLbQXFwvT/NeTsGRRQHFwBtOwZF6ODqGsfBRdmOQRVm9efGacZStmOkkvxQG6SaTIHuM/nhJjx6gpZto4iyrzdYZK11cznBsK89i5en7GLZHj/NcTfBwH29TrT75tYEY5XLtW6Ufb37cK2bBxMMyr5ezLa94HKtG3VfL4VOTtEc4r7e6/uI5sqmUnf3O9Lu4+3r3XpATDCu9WCtW5h2H/vB7qulYoLR0eUEg7qv96VxqxzdNBTh1MxpX+9VPZzdNBRR8pSFRDcNRTg121wW+5r7fJGwh8ajk1O0uUwUec0cpmbPjnKmk1P0pTU1e/2b2EUehU5O1b+sONPkONfcUmut232D3XM7/tpdFHnxaPcDLDdNrznuoKir99BYMa2ttW45Lte6DQ2tPYt9zdm5HSdr3HE72owURd6cOA4u5HY86pLbccZ2zf0cJ86E3I6B2e64HVTaPXI78ne4a64g7f6DOHEm5HY09IDbgbT7hZtjX3NecjuSQX6oDVJNpkD3mfxwE1L2e1P14BDnPCVlvzdF1DwlZb83RZQ8JQBtvzdFlH3xlP3eVFH2xeME45mR7iYY1H3xOMH4bKG75gp1XzxOMNa4nGBQ8pQ4wbiyu/sJBiVPGZ5guLOHbjtAy1Pifu8xcQpdisZiY8FhXzzu995S5o48/jIhTxnmdri3h15tNRbi7YvHaeYbcQpditYS98V7xe3AxoJT7tQrbsc/RovGQjwHl1fcjrq6cJEXz8FF2e9NEe6Ld3JwUfZ7U0TZF+8lt4OyL94rbgd1X7xX3A7qvvgQj2KzO24HZV+8ndtRXeuuuXLPIOd98cjteOIL99yOZJAfaoNUkynQfSY/3IT2Bw23EwzMUy6Ps/bMqwkG5ikv7TI3bgfYqwkGJU8J4N0EA/OUwxfHtuYf93CCcQuB3DzfowkGldyMDxpuJxhUcvM9Hk0wQnnKONb88irvJhiYp9wZJ085q1A0V54b7W6Csb5E5ClvcbDmv2uRx4flurOHDrfylP+ZGr/IQ6v4ujhWcYrQmj9jTWxr/m6L29HYA27HpRb34EAca/7EAnH9to9jFadoucU9uMuB3NxxomiuuOV2DLKs+T0crPlecTvCDq7Y1nyvuB32xnZVHAdXaKODS24HOrgedmhst/WI20FxcAEAXN7VG24HxcG1YpdorrjldtgdXPEa24M94nZQHVxPDveG24EOrniN7ZracHPFLbfjtgHOje1FW7zjdiSD/FAbpJpMge4z+eUmpFj1KKLkKdGqd/sAdxMMfEh2ylNSrHoU4UNyvDwlAM2qRxE+JI/L3x3z91CtehQ17Y0PybEnkHlbaVY9J20sFQ/JNzrkKftlFTta9SgalScmkG85PCS3Gups1aOonZWn/DZOnrKSCFujqFFXcf+WxslTztsgJhiPu5xg4O7jOx0ekrvPEvbQQS7J47j7OF6eEgCghdUcLIjTHKSIkqdEbsdlXdxxO+xE/IoTsR+Sp1vcjuddcjvwIfnBIfEfkt+eKhwgI+I0BynqGxRFXqYD3O7mTNEcdMvteMCC2+XGcXDtsJqDf3O51s0eDTsdJxo23uJ2dJjgjtsRioYNj1/k/Xu8c3OQImo0DLkd8ZqDFFGiYcjtcGoOOokaDUNuh1Nz0ElTV9GiYZTmIEWdCNEwO7cjXnOQohv6OkfDvOR2JIP8UhukkkyB7jP55SakFGcUNfvAOU9JLc6cRM1TUoszJ1HylAC04owizFNOWRk/w0spziiiNGlwguFUnDmJ2qTBCYZTceYkapMGJxjxijOKKE2aehOMOMWZk6hNGmpx5iRqk4ZanDmJ2qShFGcUUZo01OLMSdQmDbU4cxK1SeMVtyPUpIlDxAfwjtvRguDg8orbgU2aSx2aNNTizEnYpHFycFGKM4qoTRqvuB2UJo1X3A5qk8Yrbge1SYPcjkkF7rgd1CYNcjv2HHYHRaU0aZDb4RSvSRX5pTZIJZkC3Wfyy02I9ma3E4yrCR/4Xk0wqHlKryYYmKd8b1r8brpXEwzMUzqBmpoQ7M1OssccDlbFjjlQ7c1OwjzlvYPjd9Op9mYnUfKUAN5NMB4hxBzq6upI9mYn2fOU8WIOVHuzk6gxB6q92UnUmAPF3kwRJeZAtTc7iRpzoNqbnUSNOaC92S23gxpz8IrbQYk5eMXtoMYcZlv2ZrfcDmrMITDdG24HxcEFQLM3U0QZEiCg0i23gzokmOwRt4M6JHjdAlS65XbgkMAp5tDMI24HJeaAAxUvuB3JIL/UBqkkU6D7TH65CSmAMCdRLVNUQJiT0DLlVHBQAWFO+phYcFAAYRThqqNsh1VHFECYk6igQCogzElUUCAVEOYkKiiQAgijiFpwUABhTqIWHNSGlpOoBQe1oeUkasFBbWg5iVJw2Fc8xmtoOYlacFAbWk6iggKpDS0nUUGBFEAYRRRQIBUQ5iQqKJAKCHMSFRRIAYRRRAUFUgBhFFFAgdjQSg+443ZQQYHY0Iq34pEiKigQG1pu17pRQYGUSKKTqKBAL7kdySC/1AapJFOg+0x+uQkpgBYnUS271BVbTqJadqmAFidRLbuUFVsUoWV38db4/yaUFVtOoq7ao67YchJ11R5OMJxWbDmJatl9nbBiiyKqZZcSCXES1bJLjYQ4ibpqjxoJcRJ11R5lxRZFVMuuF9wOqmWXumLLSVTLrlfcDqpl1ytuB8Wye9YjbgfVsktdseUkasOLsmKLIuqqPS+4HVRQrVfcDiqo1ituBxVUS42EOIkKqqVEQpxEXbVHjYSkivxSG6SSTIHuM/nlJnx0mPsJhv3LM97aDq8mGPjl6bS2w6sJBhV65dUEgwq9unew+wkGFXp1sCo8rXUzwaBCr3Ctm9sJBjVP+d40byYYVOiVFxMMjIxc0yt+kbfnMA2q6KSvrcjIqxPjR0YmFYjmihNU0UmvjBdF3gSHyEhHa1o7dqm75grmKXc5uBqutSy52w7I20MRenWrQ2RkU6lortzgktuB0Kt3HNae4bTWLbcDIyMzC+Nbbb3gdtgdXOUOkREvuB1U6BUVqugkdHD1dHBwUaGKTqI6uChQRSdRHVxUqKKTqA6uXI+4HVQHV6a11s0ttwMHLksdnglwLa4bbschooPLvhbXDbcjWeSX2iCVZAp0n8kvN+EzI0W3fLaLCUZ5JS1PaZ9gHHax1m1moSjynPKUP2475MkE4x1inrK/1S3vPcfdBONWiwtQVBK/eGv9mZhgLCiWb67ssuxnTRzsZ1UeTTAmWGvPXhkfv3ibt0HknR9zudbt1YmCC+C0NqrHd6IJ87HLCQZ1bRSuJVy2Q36CQV0bhWsJL3G51o26Noq6ltBJ1LVRlLWEFFHXRlHWEjqJujaKupbQSYOIa6Ooawmd9MQXtLVRobWELta6VdeGizyntVG4lnCHC27Hos20tVF4f96c6Y7b0cfiAvRzKN5GWNyOt6e6a660tBxceQ4OLmzCTHex1u3IcZqDCyC8lrCsQp7b8X2RcNU97eDgQm5HC5fcjs4zhINriIOrDrkd3We543bc8RG66uI7uMLcDvnmSskR4aq7wsHB5RW3I1nkl9oglWQKdJ/JLzfhC9YEY6qLCcbew3SASyMrb7bPxQSDmqdcZU0wmjvkzZxEzVN+miPsoV1cTjAwT7nVYUL3lJU3CxbJf8mG85Txizz7BOPoCXl7KE7o3pwc3/6ME4wHPnU3waDmKXGC0TforrlCyVMChCcYi1xMMKh5SvsEo6ZWfoKB17dTnnLueuFweXK4O3voU8Q8ZVcrxjDYxVo3ap4SIMztWLFLntux2CLit3S4vpHbcXlXd/bQftb13cfB/uwVt+Ohodb1vTn+9e0Ft6PiJM3BBeANtyNrPc3Btb3cG25Ht1ni+nZycI3LFw4Xt9yOFsTr2wtux/4K+vXtBbdjmuXgauvg4PKK2/G2dX2PzIvfPMQYw7sODhcn3ZQprm8nBxdyO2YVynM78Pp2cnDZuR3lVe7WuiWD/FIbpJJMge4z+eUmxAmjmwkG5imvI2RcvZhgYJ7yNYc8pVcTDMxTfuOQcfVqgoF5yr2H4xd5z1sTRjcTDMxT/r2/84PIZR5MMPBB5P1p8TOuBR5NMKh5SpwwuplgcBwiT3gwwcA8pZNDxD5hrHQxwaA6RHDC2GqoO/I41SESmjBmydtD7XlKJ4cIdcIYT9kbaQ6RIx5xO3oSHSI4YXTL7bjbAog5OUS84HaUMxwiXnA70MHl5BDxituBDq4vcuMXeVNWesPtoDq43vCA20F1cAEAXN/HPbeD6uDaUiaeadxyO6gOrjEecTvQweX0fPXSOPfcDs7z1ZXdxTONG25HssgvtUEqyRToPpNfbkJqhzee1v1Ey1MC0Du88TQsVxR5TnnK7eW0jK6TnhtNy1NSM7rxxOk2UzO68ZS/QxR59zjkKQEAGhMzuvE0MFtY+Zwo0ZxrKp6QsTDfIU9Jvabi6WRNuBA+HidPCUC/puIpx2IstHZgLNS7plysdes1RzAWBjjkKTnXVDzdN5iWp6ReU/Fkz1M6FXnUayqekLHw7Kj4jAXONRVPVMYC9ZpyEjIWCh1WcFGvqXhCxsJVBMYC9ZqKJ2QsvDQufpHHuabiCRkLXzkwFqjXlJOojAUvuB0cxgL1moondHB1cnBwca6peKI6FKnXlJOoDkXqNRVPHIeiF9yOZJFfaoNUkinQfSa/3ITUjFQ8haadBBgONSMVT9Q8JTUj5SRqnhIp1y+6mGBwpp1UynU8caadOMEo3i9/T1CnnTjBoLgy4ok67cQJhpMrI544006cYDi5MuKJmqcECE8wnFwZ8YTTTqfPijUMV0Y8haed8T8rPlu4jeTKiCecdlI+K5Db4WatG047nT4r7K6MeJRrJ+G00+mzwituB/WzwgtuB+ezwgtuB/WzguPKiCfqZwXVleEk6rTTC24HflZQthR4we3Az4rA9PifFV5xO6iMHy+4HRwHF3I7nFwZ8cTZUnAL0ZWRCvJLbZBKMgW6z+SXmxApo24mGJinpOSFvZhg9CPmhamUUSeF8pQOeWEvJhj2PKVTXvj9aUWuJxhZjLzw3/u7n2BgntIpL4xcA7cTDGqeMsw1kJ9gYJ6yUVfnIu81DyYYmKek5IWpXIN4ouaFqVwDJ1HzwlSuQTxx8sJUrkE8cfLCVK5BPLUn5oWRa+CW24FuG6e8sBfcjnWMvLAX3A502zjlhWs94nag28YpL8z5Ho4ljoOL+j0cTxy3DfV7OJ6obhvO93A8Ud02nO/hWLK7bZy25FC/h+OJsyWH+j2cCvJLbZBKMgW6z+SXm5C6pzOeOMRt6p7OeKJ27o8T93Q6idq5n29NMB51McHAzv2lXeY6du5xrdvAbPkJBqdzj7nS/B3yzRUqcZu6GcBJVOI2dTNAPHGI29TNAPHEIW5jrnSdi7VuVOI2J1caT1ReBTVXGk+cPCU1VxpPHF4FdTNAPFGJ29TNAE6iErepmwHiiUPcpm4GiCcOcZu6GSCeqMRt6maAeOIQt6lOtnhauFkUeQ87rD0DoDvZ4ukDy8H1YVb8gQRnM0A84dqzJdviO7iomwHi6Webg8tpIEHdDBBPc9bReRVecDuSRX6pDVJJpkD3mfxyEw5ZQCMzxxNncvw0kcwcT9Ts2xmb5cuJzBxP1OxbHpHMHE+cndX9smhk5nji7KymkpnjibqzmkNmjidq9o1KZo4nTp6SSmaOJ2qeEiA8wSjYKW8PbUfMU6KT4LIu7sjjuLPaKU+JToLnHcjM8bSSkadEbscIF2vdcGc1ZXLsBbcDd1Y7TY694HZwNj54we3gbHzwgtvB2fjQxANuB3XjQ1GJe24HZ2e1F9wO3Pjw1HDnIs8LbgdufPgkJ/7nrlfcDtz4sHJ3/MkxOgnudsHtwI0PFAcXOgl6ficPRZ3K2PiAToJsF9yOZJFfaoNUkinQfSa/3ISj8na6nmBw6LFeTDA49FgvJhhUeqwXEwwOPXawBxMMDj32yeHuJxhUemxNbfgh380Eg5qnXLTF/QQD85S3D3Au8voG3U8wME/ZeYZz9voBa4Kx2MUEo81IUeTNcchTHj1B320cS/bm2s8OzbVgkfWQT8jixxInT9nFesj/NEee2/FhlnAufUBorjW3uB2rHB7y4+lhK3u9cHN859I+6yHfDbej6lS4yHPKXnvB7UAH1+OE5poX3A50cA0iZK+v7yOaK264HejgWu7QXONsU4klu4PLSdRtKvHEcXBRt6nEE9XBBUDfphJPVAcXZ5tKLKGD628EBxd1m0o8jbeaax0mODfXqNtUUkF+qQ1SSaZA95n8chNyPmRjaaz1RU3JU/57vGWTdTHB4OxfbWLZZHe6WOtG3b+6vkTYQ29xMcHg7F8dbtlk/zNVfoKBX9TvTXP+M9AmO2ONfHMF9686fVHX1dXBJdYE44DkBKOuLlzkHayKD81ZtkPYZO9ysdYt31p7du9g5ynIx5ZNtoeLCcZH2aLIo9DLH7MmGPM2yE8wHrHiKT84xFPsNtljkuTxEzXheIpTnnJBsUUeJ9hkY4mTp0RuR38X3A6Mp3yU7fxnoE32x23y0ZJ7MJ7iwP447AG3o7yKHk+Zbdlknxkpz+2YVSgcXP8Y7fxnBKYLbsdnC+WbK+9+S6eX3zZAuK/WuOB2oINrrUM8BUGHV3aX53bstuIpjQnxlDC3Q765MrFAxFPaExxcyO0Y42KtW8eJ4s8Yl7/b8fcit2NLmTy3o2lvjKfE/zPC3A755srGUvH8cSPBwYXuqzdcrHXD4c5bhOGOF9yOZJFfaoNUkinQk0h5eXnQqlUraNCgAaSlpcGsWbPq/f+6ujrIyMiABg0awG9+8xto3rw5bNzIy1j75SZEm9ILBJtSLA1n5Ck7eTDBoOYpAQBusEBTm0rl/x2pecpt1gTjWgJoKpYwT0kpFEONERcTjEGMQhEnGJMK5CcY4Tylc6GIE4w9h+XsoZw8JU4wKI2RWOLkKTmNkVii5ikBvJlgUPOUnMZILHEKxaWMxkgszWbkKZHb4WatGxaKlP3frYmNkXjCQtFp/7cX3A7O/m8vuB2TV9AdXF5wO15nOLju8YDb0ewDmoOL0xiJpc1l9ELRC27Hl5aDi1IoesHt+JdVKE5Z6fwd5gW346/dRUzHycG1i9EYiaXVe+gOLuR2UBojsRSORzpP4ZHbQWmMJLv8UhukkkyBnkTKysqCbt26wYwZM6IW6P3794ff/e53MGPGDNiwYQO0adMGGjRoAFVV9E6oX27COR5MMDBP2ZWQp/RigoF5yrkEq7XbCYY9T1lxIn6R58UEA/OUDw5xtlpP9mCCgXnKTILVGh9M3UwwME+ZSyDxNnM5weDkKTkPprEUylMSrNacB9NY6sqwWnMeTGOJY7WmPpjGElqtGxGs1pwH01jiNCqHMh5MY4nTqKRGC+KJ2qj0gtvBaVR6we3gNCq94Hagg4vSqGw1VEQL3HA7riY2KitPued2cBxc8za453ZwGpXdZ1nRAhfcDqqDCwCgxcfuuB2cRmVZhWiuuOF2oIPrvsHOMZ3pHnA7OIDht6e653Yki/xSG6SSTIGepIos0Ovq6uCPf/wj9O/fP/Rr1dXVcOGFF8KIESPIf65fbkKOtTOW8KGHkqfkWDtjCR96nPKUAAD3DqZZO2OpkpGnPFgVnvrJTjA4Dz0I56NYO2OJ89DDsXbGEuehh2rtjCXOQw9aOylwvljiPPSgtdZOAkQAACAASURBVJMC54slzkMPWjud4HzxdHOmmChRYGVUa2cs7WDkKTnWzljiRH041s5Y4kR9EM73rQOcL54QVkaJ+iCcr9QBzhdLCCujRH0QznenC27HF7n0qA+nmRxLnKgPp5kcTZyoD6eZHEsY9aHAyhYxmsmxhFEfCqwMuR2UZnIsPcaAlSG3g9JMjiZO1MfO7XBqJscSJ+oT4nYQ4HyxxIn6eMHtSBb5pTZIJZkCPUkVWaDv3LkT0tLSoLCw/mSqdevW0LZt25h/TnV1NVRWVoaOkpISX9yEHDhSLHGKbg4cKZaoeUoAOhwplji2QQ4cKZYwT0mxDXLgSLH0LsM2GCrmCXCkWMKim2IbbEGEI8USJ0+JxTwFjhRLnDwlFvMUOFIscfKUWMxT4EixFF735Vx0YzHvBEeKJVz3RSm6dzDW28USrvuiFN1YzFPW28USwjIpRXeomHex1g1hmZSi2y23A2GZlKLbC24HwjIpRbcX3A6EZVKKbrfcjnqwTELRjXEsWW4HB5bpBbeDA8v0gtvBgWW65XZwYJmcOFYscWCZWMxT4lix1HkGvejGYp4Sx0p2mQI9+WQK9CRVZIGen58PaWlpUFpa3w7Yvn17uO+++2L+ORkZGZCWlvaL4//6TbjKgwkGx7buxQSDY1t3O8Hg2Na9mGBwbOscO3wscWzrHDt8LHFs6xw7fDRxbOscO3wsoW39TcLaM856oVj6FwO8Q10vFE9XdBOT1ZIjzrZ16nqhWFq9R3wu3UFYe8ZZLxRLnHWT3zLWC8USZ93kW9Zat1F5ctyOWtvnEsW2fqNLbgfHtu4Ft4NjW/eC28GxrXPs8NHEta1T7fCxxHFwcezwscRxcHnB7eA4uDh2+GjiOLi84HZg07ctwcHFAZrGEq6bHJnn3PTlAE2TXaZATz6ZAj1JFatA37+/fkH28ssvw/333x/zz/HrBB0nVTdnyk8wOKtrOEC5WMLVNZQHSA5QLpq2Mh8gqUC5WPqK8QCJQLkWLiYYHPAbAuW6z5KfYHDAb2GgnFxzhQN+s08wKiUnGJzVNQiUazVUfoLBAb8hUK5fllxz5awtm3zomPMDJBUoF0tLGXnKn4+HJ1VnJMnjnDzlHAZQLpYQ/JZDAL91nkEHykXTMSb47fYBgjXgBJSLpWwG+I0DlIulntbaMwr4jQOUi6W7GeA3DlAumsoreeA3KlAuljjgN2yAUlaCxhIH/PYlYyVoLHHAb9gAdVoJGktc8JtbbgeC314Z7+zgQm7HbQPkmysIfvua4OzxgtuRLDIFevLJFOhJKq8s7pHyy024vVwUoE1dTDBeGS+KPEqecly+sIdSVrLFEidP2Z6xki2aOHlKAIDG1mtzWskWS5infOdb5ynBOg8mGNjAmFno3MDAAvRdwmuLJnuespxgwcQJxqxCuQkGJ09ZV1cHDfG1Vck1Vzh5Spxg3EN4bbHEyVO6nWCcrOGtTsOVbPMJry2acjbR85T2lWzHJde69ZojYjqUPCVyO1q74HbcN5i+Og0jRAMk17odYq5Oc8vtQDYGBTzqBbfj/Wl0B5cX3I6/96c7uN6b5o7bsfcwDzzqltsRXp3mXOR5we3A1WlfEdgYXnA7cHXa1gPODi633I7w6jQaGwO5HdsIry2acHUaxcGF3I4bXHA7XrDYGBQHF3I7OhFeW7LLL7VBKskU6EmqWJC4AQMGhH6tpqbGQOJiqOSI+wkG5imnEabUU1a6n2BgnnJ/hXOe8g2XEwzMU7YgRgCu7+NugoF5ym6znK22W8qqXE8wME+ZRYgAjHE5waiXpzzpPKV+aZy7CQYnTwkAcGX3ea4mGKE8JWFKvWav+wkG5inzCHnKzxaKCUZgutwE48hxep4SAOCZkaK5MluSPP59kZhSP03IU9qn+4cJ0/1owjzlEMKU+sdtornihttxx0c4pXaOAPS3pvu958hxO/Az/goCER8AoLVLbsfUlSIC8CLhM94LbgfHweUFtwMdXMX7nT/je3znjtuBDq7riJ/xd7nkdqCD6zWCg+tAZZjbIdtcQQfXN4TP+Blr3HM70MG197DzZ/x/pormiiy3Ax1cf+9P+4y/pZ87bgc20Cmf8Ts94HZwPuPHW9N9N9yOZJFfaoNUkinQk0jHjh2DtWvXwtq1ayEtLQ0GDx4Ma9euhb17xYd8//794cILL4SZM2fChg0b4NlnnzVr1mLIPl2R/ZJ9ipGnxAnGs6PkJhjcPKXbCcZi5hognGAUSq516zeXnqfcc1hMMK5yMcF4aKgo8ih5ykkF9OlKNFWc5OUpOzKmK9GUtZ63Buhaa4JBma5EU7dZosgbTMhTbirlTVeiqYWV816xy7nI40xXoml/hch5X96VBtELTVckyePTGHlKAIBGVj5+nyR5nJOnRG5Hc0I+PpZuyhRFHoWI/2mOaK50keR2oEvqml40lxR+ngeL5KIl6JJ6daLzw7id23H0hNxaN3RJTSA4uJDb8YCLtW7oktpFcEkht6NvUK65gi6pW4kOLuR2LJLkdgzLFUUexcFl53bU1MpxO54bTXdwIbfjyeFyzZV6LimCgwu5HZTP82jK3yEaeRQHF0CY20H5PI+mgdnCwUVxSSG3g/p5Hk2PDqO7pLzgdiSL/FIbpJJMgZ5Eys3NjQp0a9euHQCID+KMjAz44x//COeffz7ccccdsGEDLzfrl5vQnk+UnWDgxIWSp8R84mOEfGI0cfOUmE/8WHKCwclTAoTzict2yE0wOK8X84mXEPOJ0cR5vW4nGNzXixOML3LlJhiYp6S+XpxgFJXI2UMxT0l5vaEJBjGfGE23Ml7veEY+MZq4r7fDBHo+MZq4r/dvFnl8e7kceZzzepHbcVOmfHOF83pHILdDcq0b9/U+bzmiZLkd3Nd7mUtux/MMB1eBB9wOfL0UB9cgyxEly+0IvV6ig+sJl9wOzuv1gtvBeb1uuR3VtbzX65bbsWhzOev1IreD4oiKpj6M1+sFt4PzepHbQXFEJbv8UhukkkyB7jP55Sas9WCCgXnKpYTMIk6kZScY3DxlP5cTDO7EPzSRlpxgYJ6SMvG3T6RlJxiYp6RM/LNcTjAwT0md+HMm0tHEyVMC8CbS0YR5SkpmkTuRjibMU1Iyi9yJdKRw4k/NLHIm0tGEE39qZpEzkY4mzsR/e/kx1kQ6mjgT/6+X0SfS0cSd+CNTRJbbwZ34u+V2cCb+brkd3Ik/TqRluR3c70ucSMtyOzjfl15wOzjflziRluV2cL8vORPpaOJ+X3Im0tGE35eUTR12pogst4OzqSPHA25HssgvtUEqyRToPpOfbkJOpjuawtRf5w9q7kQgUkj9peYpBzEy3dGEmXlKnhIgPBGgZLqjCTPzlDylfSJAyXRHE2bmKXlKnAhQM92Rwsw8NU8ZmghIrnXDzDwlTwkA0JKxIzeaOJl5bqY7mjiZecx0U3bkRhM3M8/JdEcTNzPPyXRHEydPyc10R4qbmedkuqNpyTZR5FEz85xMdzR9mMXLzHM+g6LpYcvBtaDY2cHF/QyKFDczz/0MihRm5qmOM/wMomS6o6kH03GGn0GUTHc0YWae4uBaw8x0R+oA08GFn0GUrRzRxHWc4WeQ7Fo3Tmaeu5UjmjiZeS+4HckiP9UGqSJToPtMfroJmzAyddGEe3Mp0yukolMzdZHi5ik5VPRo4uQpAXhU9GjiUOe5VPRo4kyvuJm6SHGnVzjBoFDRo4k7vXqUQUWPJs70iktFjxR3esWhokcTd3qFVHRZ8jh3esVx8UQTZ3rFdfFEiju9csvt4FLnOS6eaOJS5zkunmhC6jzl357r4okUlzrPdfFEivtvz6GiRxOX2eKW28GhzrvldiCzhUqdd8vtQGYLlTrPoaJHU0eGgwsg7OIpOSLXXLmWQZ33gtuRLPJTbZAqMgW6z+Snm/CGvnQqbTRhnnIHYe0Zl0obKe7edg6VNppGMPe2c6i00cTNf3KotNHEyX9yqbSR4uY/OXvFo4mb/+TsFY+mcJ7SuchzO8GwuyeqCHlKzl7xaML858PEAp+zVzyaMP/5YRatyOPsFY8mzt7240wORqS4+c/5TA5GpLh727HAluV2cPe2u+V2cPa2u+V2cPe2czkYkeJuPeFwMKKJu/WEw8GIJs7WE9wrLsvt4G494ewVjybu1hPOXvFoQvfElJW0Z49reokCW5bbwdnb7gW3I1nkp9ogVWQKdJ/JTzfhbQPoe12jqVFXep6Su9c1UiuZndjwBEPOHvpJjijyqHlKnGCMkVzr9tRwHkEZc8hbyvgTDG6eMrzXVa65wiUo4wTjDcm1blyC8otjeQ84kUKCci6RP3BFN/oDTqTsBOXTBIv86j3ivrl9gNwEAwnKTw2nFXlDFgh7aOcZctESJChT8pQAAE8zNklEEydPecbWXKFskogUEpQbdaUVeXnMTRKRmsokKPfLom+SiKZOlkV+VB7NIs/ZJBFN2GDeWOrs4OJukojUNqvB3LQ3zcHF3SQRqbFWg7njRFqDGXPIgyS5HS8zHFwAYW5HgeRat6utBjPFwYXcjsu6yHE71jIdXMjteF6S24ENZqqDC7kdIyTXuv1jNK/B7IbbUVcX/gw8WOXcYPaC25Es8lNtkCoyBbrP5Keb8B5rgpG/g28PPcPMU5ZXiQlGQ8kJBjdPOatQWASfGy03weDmKd+1JhjDcuXsoQ8zdxCjRXAdwSIYKW6eEicYjSUnGNwdxDjBaE+0CEaKu4MYJxjj8ndLnY+7gzg8weA3V+w7iCnCCcaNRMhbpLh5ypF57sjj3B3EbRkk72ji7iB2w+3g7iBesUs0V2S5HeMtyBx1B/Fgl9yOf48X99F44iTwyeHuuB1NGA6umtpwU1KG27G+hOfgWrTFHbdjONPB1TfojtuBEa0Za2j3kVtux6WWg+sAIaLlltux3HJw3UV0cLnldgyaL2I6PYgRLeR2fJojx+14nOHgAghzO1YRmpKRshP8KQ4ut9yOZJKfaoNUkSnQfSY/3YRYFMpMME7UhO2eJ2qc85SVp9xNMDBP+QgxTzlvg7sJBto9P8qmWW27z9rgaoKBecp8Ypa2xcfyEwzMU1KbJWUVp1xNMDBP+Y/RtDzldJcTDG6e8u2p7iYY3GbJzZkLpCcYmKekNkt2WEXh34hFYaQmFvCaJVgUdpggRx7vOHENq1kSKgoJu7CjqWlvXrMEi8KdhKIwUhtLec0SLApvkeR2jMoTTpS3iM0SLApluR3trCzttwQiPoB7bgc6uEoJDi633A50cN1JbJYs2yGKQlluBzq4uhIdXB/Pd8ftQAfXXGKz5DEX3A67g6vihHORZy8KZbgd6OB6cAitWbKg2B23Ax1cmcRmSe85ornSX5LbgQ4uarMEYz0/buMPZo6eCDdLKA6uwy65HckkP9UGqSJToPtMfroJuV/KdnE/eOtNMAhfypGazcxTLmJ+KUcqMJ2Xp8QJBvVLOVIYN6DkKQEAHviUZ6u2i5un5H4pR2ryCl6eMljEs1VH6nVmnrIL01YdqWbMuEFza4JBsVVHanMZL26wj2mrjtSXVp6SGjdAW/ULRFt1pP7FjBt0ckke5+QpAcK26k2l/O+H1XsEy4EaN0Bb9bVEW3WkwnEDGsshZKuW5HZg3GAOgYgPEOZ2TCrgR0vsDq6fiXED5HbsOcyHomLcgOrgQm6H7Fo3jBt8QIwboK36vWlyzZVWQ3kOLjfcjkqmg4trq44UNuupDi7kdtw7WK65EmrWEx1cyO2QXevGbdYjt+MHCW4Ht1nvltuRTPJTbZAqMgW6z+Snm5Bra7OL++BfV1fHsrVFipun5NraIsXNU3JtbZHiPvhzbW12cR/8uba2SHEf/HGCQQWTRQrzlNQHf5xgUMFkkbqa+eDPAZNFipuntDfSKGCySHEf/LGR9sxIOfI4N0+JjbTPFvLtoTIP/m64HfnMB39spMlyO7gP/pNdcju4D/7YSJPhdtgf/CkOLgB+I80uBPZRHVzcRlqkuA4ubiMtUty4mxtuh0zczQ23gxt3c8vt4MbduI20SHEdXNxGml27mXE3t9yOZJKfaoNUkSnQfSY/3YTtmYWMXTLWWW4hYxfXOsstZCLFtc66nWBwrbPcQsYurnXW7QQDrbP/mUr7u+EWMpHiNp4+ypafYNgbT1Tr7CMuJhjYeKJaZ7lRlEhxrbPcKEqkuNZZbiFjl4x1lhtFsYtrneWu9ooU1zqLURRZbgfXOuuG2yFjnXXD7eA2nriFTKS4jSduFCVS3MYTN4pil0zjiRtFsYvbeOJGUSLFbTxxoyiRwsYTdeUdN4piVxgYS/+74URRkll+qg1SRaZA95n8dBNyV6vYJQOfwi8SymqVSCF8ivolhhMM6mqVSCF8ivol9iVztUqkED5F/RJDK/BkibVuCJ+i5ikB+FZguxA+Rc1TohX4tgFyzRWET1GjG0OtCUZgOn+CIQOfajNSTDBmS0wwuPCps0yYY6S48CkuzDFSDzDhUwhzpFqB7bJHN6jwKS7M0a5QdIMIn+LCHCPFhU9xYY6R4sKnuFZguxA+1YgBn2rBhDnaNXUlL7qBVmAqzDFSbzKjG8jtkF3rdn0fnoMLuR1UmKNdWyWiG8jtoMIc7fqK6eDawYQ5Roob3eDCHCPFXbnKhTnaJbNy1Q23I5nkp9ogVWQKdJ/JTzchF6Zll4wNDCcYayUmGFwbGMK0ru4hZw/l2sAmFYgu/csSEwwZG1hHa63b2KX85orM+iacYGwjdunt4q5vwgnGDZITDMxTUuGHOMHoNJnfXJGBH+IEY6rEBEMGfshZhxgpLvyQC9OKFDdPyYVp2SUDP3TD7eDCD7kwrUhx1zdxYVqR4q5v4sK07ML1TRwHF3cdol1fMx1c3HWIkXplvCjyqA4u7jrESDXpKYqoXYS1ZwDuuB1FJcLddisDfuiG2/FFLg9+6JbbwYUfcuN7dsnAD7nxPbtk4IduuB3JJD/VBqkiU6D7TH66CXsy11HZhSCV+wbTJ2XcdVR2YZ6y1xyaDdm+jkrGHop5yhyiDZm7jsouGZAKdx2VXZinfHQY3YbMXUdlF9qQB2bTrjPuOqpIcfOU4621bjITDMxTXsLIU3aYID/BwDwl5zr7G2MdVaTesWzIX+TSrjN01lDXUUXqVus6KyqhNfFGMNdR2YXrA5swbMjPW86a6RJr3XB94Cvj6U28y6z4RFkFn9uB6wO/Jl5nBS65HeH1gbTrzA23A6+zmzLpTTw33A7u+kC33A7u+sCFm91xO7jrAz/4Xp7bIbM+0A23g7s+8GfbWjcZbgd3feAcJgDXLruDq5J4nXWewQPg2rVos2jitRpKv85uHyCaK1QAbrLKT7VBqsgU6D6Tn27CftYEo2+Qbw/N2cRfRYITjEUSE4xec0SRR81T2icYNbX8CcZ9g3l5SpxgPDmcbw89JJGn7GpNMAZLrHXDrCkH5HXnQNFcWbGLP8F4fxovT1lqTTAu7ypnD/17f16e8ltrgtFWYq3b3sPCansVw6nxljXZHJnHb658E8pT0ou8G/vyJpt2vWY5Nb4iOjW2lwv7alNJ8vh1zDzluHwx2ew4kU8el8lTIrdjYgF/rdvoJcKp8SbDqdHYmmzuJk427XoBnRoraU6NdS65HY0skFfJEZrVFrkd70qsdVtlOTXu+Iju4EJux6xCPrfj0xx0cNGKvLq6OmiIk80qfnPlKcvB9X0RzcGF3I57JNa61dqcGlQHlxtux2IJBxdyO+ZLrHXD5xyqg8vO7TgusdbtoaHWcw7RwYXcjtYS3I6Kk/znHGyYD5BY65Yl8ZzjhtuRTPJTbZAqMgW6z+Snm3CQ1VnuPos/wfi+SHR9qXlKAIAnQhMMvj2Um6esrg1PMKidZbu4eUqZzjIK85RXMPKUfawJRr8svj0U85QvEteeAYQnGHnEbLBd3Dyl2wkG5imL99PuYZxgPM24llGYp7yOwTrACcYQiQkG5ilfY6zCCk8w+M0VzFN+Q2QdcFf4RYqbp5yykrfCzy6ZPKUbbgcWpO9Po7MOru8jz+14ZiQPJLmlTFzLMtwOO+vgEJF1MMYFt+PHbXwH10vj5Lkd/ZkOLgCAK7uLa1mG29HaYh1QHVxr9spzO47ZHFxU1oEbbke25eB6jOHgcsPtQKfgx0SnoFtux92Wg2vZDppT0A23o7yS7+BCbkfvOfzBzMxCvlPQDbcjmeSn2iBVZAp0n8lPNyFms2QmGNOsPCVn6vjc6ALpCcbbzKmj2wkGN0+Zv0N+goF5ymt60aeOA7O3SE8wME/56kS6pfvRYfITDMxTTiDmKU/WhJsrMhMMbp4yx8UEA/OUnKkjukFkJhgy9yy6QZZKTDC496zdDcKNlsjcs+gGeXYUf62bzD2LbhAZbofMPYtukEKJtW7cexbdIDLcDpl71g23Q+aedcPtkLlnr3XB7eDes5tKhRtEhtshc8+iG0SG2yFzz77ggtshc8+iG0SG28G9Z9EN0pzhBkHJ3LPoBukiwe2QuWfRDRIs4g9mkkl+qg1SRaZA95n8dBPKTONQ4yXylDjBoE7j7MLcLjVPCRCeYFCncXZhbpeap1wjMY1DyeQpP1u4jT2NQ4Vyu4y1LtxpnF3PM/OUMtM4uzC3S81TykzjUJjbbcHI7cpM41AyrhfuNM4urutFZhqHknG9yEzjUDKuF+40zi4Z1wt3GmcX1/UiM41Dybhe3HA7ZFwvyO2g8hTsknG93MLkKdjFdb2EuB0Sa93Q9cJxcMl8/6PQ9cJxcMl8/6PQ9UJ1cAHwv//tQtcL1cEl8/2PknG9yHz/o2RcL264HckkP9UGqSJToPtMfroJZfKsKJk8JTfPahc3TwnAz7Paxc1TyuRZUTIddJm/f5RMB13m7x8l00Hn/v2j7HnKoydoeUqZPCsK85QPMPKU3DyrXTLcCG6e1a5QnpLIjZD5+0fJ5Cll/v5RMnlKN9yObrP43Aju379dXG6EzN8/SoYbIfP3j5LhRsj8/aNkuBEtXHA7uNyI/RXy3A4ZboQbbocMN8INt0OGG+GG28HlRuDfP8dBh5LhRuDfP8dBhxqWy+dGuOF2JJP8VBukikyB7jP56SaUIUKjcILLyaBxidB24QSXk0HjEqFRMhk0GSI0Cie4nAyaDBEahRNcTgaNS4S2Cye4C4rpE1wuERolM8F1M8HACS5ndzSXCG2XzOYFLhHaLpnNC1wiNEpm84IMERolM8HlEqHtktm8wCVC28XdvCBDhEbJbF5ww+2Q2bzghtshs3mh5adLWA4Gu7ibF47YHAy1zLVuMpsXkEEjw+2Q2byADBoZbofMBBcZNDLcDu7mBRkGDUpm84IMgwYls3mBy6BJVvmpNkgVmQLdZ/LTTSizUxklQ3HFCQZ1p7JdMhRXnGBQdyqjZCiuOMHg7FRGyVBcpzF3KtslQ3Hl7lS2CymunAw0lwGAOljFz1PK7FRGYZ7yH6PpeUruTmW73psmijxOnpK7U9mu//1Q5CnX/kRvcnEZAKg9h0WTi5OnlNmpjJLJU3J3Ktslk4Hm7lS2qykzAy2zUxm1sVQUeZwMNDIAODuVUaPy+BloZAD0lFjr1k4iA40MgGwJbkejrrwMtJ0BcIzJ7Vgp4eCS2eKC+iRHNLk4Di7uFhe7nhrOd3Bxt7igTks4iGS2uKByt4gm14ND6A4imS0uqEzLQZQ5l97kcsPtSCb5qTZIFZkC3Wfy0024yPpwf2go3x76gcQ0om/Q+hnGhztKhiL+gDXBWMycYMjkKY+ekJ9gyOxBDRaJ5gqHoo+S2YPKpejbJbMHlUvRR8lQxHGC0UhigiFDEccJxgtf8ZsrMhRxNxMMGYo4l6KPkslTylD0UTJ5SjfcDhmKOJeib9dfu4sij0MR51L0Uav38CniMhR9lAxFXIaij5KhiD87So7bcUbCweWG2yFDEXfD7UCK+AfEtWcA7rgdMhRxWW5H1alwTITq4LK7vk7W8Lgd8zbwHVzo+npUgtvRQ8LB5YbbkUzyU22QKjIFus/kp5twuWWPkplg4B7uT3Lo0/CP58tPMDBPuZJRsD0mOcHAPGWjrvSC7dRp+QkG5vnaMQq2BcXyEwzM843Koxdsvedskp5gYJ5vYyl9Go4NGe4EQyZPedjFBCOUp2QUbLOthozMBAPzfJMK6AVbYDpvD71dV1sF257D9Gn4bQN4e+hRayXylNiQubI7nzyOBdt70+jT8MkhbgffHop7uDkF2+tWQ2YMc61bXV24YDtYRS/YmklyO3AP972D6d8lbrgdMg4uN9wOdHD9wCjYXhwrGjJcbofdwXWihv5dcoUktwMdXI8wHFyr98hzO9DB9VE2/btkyAJ5bofMHu6nJbkd6OBqyAAtyuyhR+E0/LnR9JhOnsQeetS7VkxxWC59Gt4vi7eHPlnlp9ogVWQKdJ/JTzehzAMx6u2posjj5CllHohRN2fy8pQA8hOMHRJ5StkHYgCA8ZblmZOnXCrxQIz693h+nnLAPP4DMaoJM08JANBa4oEYAGB9CT9Pebxa7oEYAGC4laf8z1T6NT3fmmBwHohRaHmesYZueZZ5IEZdauUpDzAsz/dY5PH8HbzmynKJPGV51Sn2AzFKJk+J3A7OAzHq8RARn94wlHkgBqjfMKxi5Mkx0rCOEWkACDcMH2Y0DJHb0ViC24ENww+z6Nc0cjvaS6x1w4bhkm10NxZyO8bl72adS7ZhGOZ28JorsyUcXJhbv1FirRs2DDkOLuR2vCXB7cCGIcfBhdyOb5lr3WQcXABhbkcpc62bTMMQuR13SnA7ZBqGbrgdySQ/1QapIlOg+0x+ugk3l+EEg28P7TiRn6f80rKUvsGwlKK4eUoAgH9ZE4wpK3n2UJk8JYCcpRQgnKfkPHygpfT2AfwJBuYpOQ8f4QkG3x6KeUrOwwdOMOYwLKUA4Twl5+HDbin9mTnBwDxlV0aeEicYHEsp2v6qJAAAIABJREFUCvOUcxnQMJxgcCylAPXzlBUn6EVeq6HCHrpoM488LpOnrLRZSqtrefZQmTylG27Hg0NE5CaXQWTvPsuylDK5HfbIzWlG5KbFx3LcjlDkZji9yCurEM0VGW5HFwkH13QX3I7mVuSG4+DCJjaX27FPwsEFEG5ic7kdU1fxIzduuB2dJCI3brgdN1gOrk2l9Gc6WW7HNitycy3DwQUQ5nbsZDSxAQDGWpEbjoMLuR23SHA7XpZwcLnhdiST/FQbpIpMge4z+ekmRCiTzARDpvidWCA/wZApfrGJwJ1gyBa/2ETgTjCGShS/2ESQmWBgnpJT/Mo0EQDki1+ZJgKAXJ4SQK6JABDOU3LsezJNBBTmKTnFr0wTAUC++JVpIgDIFb+yTQQAueJXpomAkil+ZZoIAPLFLzYRuNwOmeJXtokAIFf8uuF2yBS/2ETgcjvQwcUtfptLcjvGSxS/oSaCBLcj5OBiFL8yTQQUOrg4xa9MEwEg7ODiFr8yTQSAsIOLU/zKNhEA5KCVMk2EZJSfaoNUkSnQfSY/3YT2tUZcydjH8SGOu9ZN1j4uY8MHkLePy9jwAeTs4zI2fJSMfVzGhg8gbx+XseEDyNvHZWz4AGH7+MBsOgBHxoaPkrGPD5dYawQgbx+XseEDyNvHZWz4AHL2cRkbPkrGPi5jwweQt4/L2PAB5OzjsjZ8ADn7uIwNHyVjH5ex4QPI28dlbPgAcvZxuw2fClJFydjHZWz4KBn7uIwNH0DePi5jwweQs4/L2vAB5NY+uuF2JJP8VBukikyB7jP56SasOBGekHEnGAhg4zzIydggAeQf5GRskADyD3IyNkgAuQc5WRskgNyD3FQJkB2AfJ4SJxgckB2A/IPcDRIgOwA5ABtOMDggO5QMgC00wZjIm2DIAthkbJAA8g9yMiA7ALk8pRtuBwLYtpTRizxZbkcYwMaLL8mA7ADCADZOfMkNt+NFCQeXG24HAtg4Di5ZbgcC2LgOLlluh0x8yQ23Qya+JNt4lXVwyXI7ZONLocYrA2QHIAdgw8ZreoDP7ZCJL7nhdiST/FQbpIpMge4z+ekmrK6Vn2DIrDBbuFmu8JW1QuIqOO4EQ9YKKTvBkLFCyqyCQ8lYIWVWwQHIWyFlVsEByFshZVbBAchZId1MMLCRwFlhJrMKDkB+hZnMKjgA+RVmMqvgAORWmMmsgkPJrDCTWQUHIL/CDFfBcbkdsivMZLkdMg4u2eiS7AozmegSQLiRwF1hJhNdAgg3EjgrzNxwO7CRwFlhJhtdOi65wkxmFRxAuJHAXWEmswoOINxI4Kwwk1kFh7rbaiQs20GP6cisgktG+ak2SBWZAj2FlJGRAWlpafWOiy++mPVn+OkmrKurg4adxQd1eRXPHtpiID9Piat47mGuddtfIYo8bp5SZhUPAMA0SZgQruKZz1zr9vYUfp7SvornOHOt202Zosjj5ClxFU9r5gRDFiaEDx4DmGvdZGFCuIpnKXOCgTChCYw8Ja7ikZlgIExo1yH6tBhX8Tw7irfWDWFCtzLzlO9NE9bxzxfxyOOyMCG0jq9lksdl8pTI7bi6B89VUFdXB5fgZy3Dij+pQDRXXmZyO/J3iM9a7grNjpP48E8AgIHZcis0ZeCfAACPSqzQlIV/nqyRW6GJ3I5OzLVuOZvkVmgit2Mqk9vRa474rOWu0ERuxz4mt+O+wfwVmsjtaM5c63ZI0sGF3I4uTG4HftZyV2gityNYxON2vD+tiP1Za+d2HD3Ba678vb/4rC1kOLjccDuSSX6qDVJFpkBPIWVkZEDjxo2hrKwsdBw8yJtm+u0mvLL7PKkJxq39RN6ak6fECcZtA3hTHdk8JU4wAtN5EwzZdTw4wZjNnGDI5CntU53DjKkOgFyeUnaCIZunxAlG7zm8CYbsOh6cYCwo5k0wME85bTW9yHMzwcA85f4K+kMxTjAeY051ME/Zgpmn7PGdBV9jTHUA5Nfx3GXB15YzyeMyeUo7t4PTXKmptcHsTtLdSjPWyHE7Fm0WD8UPDeU9FP9nqmiucLkdfSy3Uj8mzE6W29FSwsEly+04YnMr1TIcXLLcju+LhFuJ6+CS5XZ0niEHs5Pldtwh4eCS5XaUHBFuJa6DS5bbMXWlnIMLm4XTGd8jAABvSsLskNtRVsEbzFzfh+/gcsPtSCb5rTZIBZkCPYWUkZEBTZs2dfVn+O0mvM7KRW5lTjCutSYfnJ/bVIq5SF6xJvtzmIt8kznBkP25F3CCsZI3wZD9uUZWLrLkCK+5IvNzq6wJxh3MCYbsz32ag/ZQXrEm+3NPWbnI74t4zRX8Oc7kwz7BOMKwh9ZKTj4WW7nIlp/yijX8uQeYP9fPIo/3DfKaK7I/99BQUawtYqwvk/25ipPh5kpNLb1Yk/25rPUibvPkcJ49dK7kz3WbJYq1wcy1bl1nyv3cnZYTa8UuHrdD5udKrbjN5V15TizZn/vWitu0ZTqxZH/uLcuJNTKP11yR/bkb+/KdWLI/t71cREuu6cXjdsj+3Lh80Vx5dSKvuSL7c+2/5jux7D83sYD3c40lnFj2n9vN+Ll1LrgdySS/1QapIFOgp5AyMjLgggsugAYNGkDDhg2hTZs2sHNn/M5idXU1VFZWho6SkhJf3YQ4CX/8i3xoO2YF+cAOLCdPudOaYFzWZS7rXAik4+Ypx1uT8Ov75LDOh/Z9bp6ywwQxwbhn0GLW+dDmyQUz/c2aYDw1fBnrfFgocPKUOAlv1C2Lda7W1mSam6ccYU0wbsrk/dthlpyTpwQAeN76e7n/kzzW+XCKxJ28X2bdP8+MXE4+F05ZuJP3AmuCcVWPeaz3hgUsd/I+yJqE/++HC1nnQ6s6J08JAPCERR5/cMgS1vkQLsfJU9q5Hc+NLiCfCzPTlzCJ+DgJb9Izm/XekIfBnbzjJPy2Abx/O5yEf5HLK/Lwdbb+7EfW+RDaVlRCd3DZuR3PM86FTbgmTAcXcjua9p7Pem8Yt3llPM/BhdyOOwfmss6HXIuvmZN3/Kx9dNhS1vnws297OX3yjtyOSzoHWefCrQQ3ZfKa+8jtaPbBD6zz4SrFt5kOLuR23PUx798OByzcyTtyO55gPvdhJJIzeUduR6OuvGcHPLrP4sVmVMkU6MknU6CnkLKysmD69Omwfv16yMnJgebNm8PFF18Mhw/HfgCLllv3002INk+Z44puWaxMXuWp06HprczBtfzhw63sMYQJKMOHW9lj9R7eFAltnjJHk57ZrN3WB6uqQ00ZmeNFJqAMbZ6yB9fyhzZP2YNj+QMI2zxljmYf/MAq8vDhVvbgQtvQ5il7cKBtAGGbp+zBob/X1dWFbJ4yB7fJiA+3sge3yYigPtmD22REKJ3McUlnXp6/pvZsqKEmc3DjPWssUJ/swY33fLZwm6vzcZuMz4xcLn2uRl2zoOIEPepxvLo2BBSUObhNxh+3HXL1d8ltMva3QH2yB6fJCAChxrnMcVWPeSzg3pHjNaFolszBdX6pkinQk0+mQE9hHT9+HC6++GIYNGhQzN/j9wn6gcpTMGNNCUxfzT82lfL/jjaWVkida2ZhCethDEDktBdvPSh1vqz1+9n54OPVtfB9UanU+ZZuP8QGhpUePSn9b8eNNAAIq5rMuWYV7mPn5M+crYNFm8ulzjdvQxmr+QAgmkez18n923GzzwCiaJY51/TVJbCTmfkEEPwHmXN9t3YfGyR0+sxZyNl0QOp8P2w6wF75WHHiNHy3dp/U+Tg5WNSuQ8el/+04jiNUwc7DUueava4UKpnbOaprz0D2xjKp8y3cfICV0QYQU+1ZhXL/dlwoIIBYcSj7b8eFodXV1UH+9kNS5/q+qJTV/AYQ60iz1u+XOl/ulnIWRA1ArOuaWSj3d8m1xQOI1YEy55qxpgQOSDw75Ek+O8xdv59VwAII6GuwSO7fbsm2g+xnh7IK+ec+7rYMAMEQkL3vOLR/lTIFevLJFOgprnvuuQc6dOhA/v3mJjQyMjIyMjIyMjIyAjC1QTLKFOgprOrqavjzn/8MvXv3Jv9MRUUFpKWlQUlJSb3JujnMYQ5zmMMc5jCHOcxhDn8d6K6tqOC7P4zUyBToKaR33nkHFi9eDLt27YKCggJo1aoV/O53v4M9e+iES7wJzWEOc5jDHOYwhznMYQ5zmCMtTQzvjJJDpkBPIbVp0wYaNGgA5557LvzpT3+Cxx9/HDZt4oFWzp49CyUlJVBRUZE0HTszzTeH02GuFXNQD3OtmINymOvEHNTDXCvmoB6peq1UVFRASUkJnD3L42wYqZMp0I0SpspKk3kxoslcK0ZUmWvFiCJznRhRZa4VI6rMtWLklUyBbpQwmQ8yI6rMtWJElblWjCgy14kRVeZaMaLKXCtGXskU6EYJk/kgM6LKXCtGVJlrxYgic50YUWWuFSOqzLVi5JVMgW6UMFVXV0NGRgZUV/N2SBv5T+ZaMaLKXCtGFJnrxIgqc60YUWWuFSOvZAp0IyMjIyMjIyMjIyMjI6MkkCnQjYyMjIyMjIyMjIyMjIySQKZANzIyMjIyMjIyMjIyMjJKApkC3cjIyMjIyMjIyMjIyMgoCWQKdCMjIyMjIyMjIyMjIyOjJJAp0I0SpmHDhkHDhg3h/PPPh2bNmsGSJUsS/ZKMEqiMjAxIS0urd1x88cWh/19XVwcZGRnQoEED+M1vfgPNmzeHjRs3JvAVG+lSXl4etGrVCho0aABpaWkwa9asev+fcm0cOXIE/vnPf8Lvf/97+P3vfw///Oc/4ejRozrfhpEGOV0r7dq1+8XnzM0331zv91RXV8Prr78Of/jDH+CCCy6Ahx9+GEpKSnS+DSPF6tevH9xwww3w//7f/4OLLroIHnnkEdiyZUu930O5Dvbu3QutWrWCCy64AP7whz/AG2+8ATU1NTrfipFCUa6T5s2b/+IzpU2bNvV+j/n+MeLKFOhGCdGUKVPg3HPPhdGjR0NxcTF06tQJfvvb38LevXsT/dKMEqSMjAxo3LgxlJWVhY6DBw+G/n///v3hd7/7HcyYMQM2bNgAbdq0gQYNGkBVVVUCX7WRDmVlZUG3bt1gxowZUYsuyrXRsmVLaNKkCSxbtgyWLVsGTZo0gVatWul+K0aK5XSttGvXDlq2bFnvc+bnn3+u93s6dOgAf/7znyEnJwcKCwuhRYsW0LRpUzhz5ozOt2KkUPfffz+MHTsWNm7cCOvWrYOHHnoI/vKXv8Dx48dDv8fpOjhz5gw0adIEWrRoAYWFhZCTkwN/+tOf4PXXX0/U2zLyWJTrpHnz5tC+fft6nykVFRX1/hzz/WPElSnQjRKim266CTp06FDv16688kro3Llzgl6RUaKVkZEBTZs2jfr/6urq4I9//CP0798/9GvV1dVw4YUXwogRI3S9RKMkUGTRRbk2iouLIS0tDQoKCkK/Z/ny5ZCWlvaLaYjR/x3FKtAfeeSRmD9TUVEB5557LkyZMiX0a6WlpfCrX/0KsrOzlb1Wo8Tq4MGDkJaWBnl5eQBAuw6ysrLgV7/6FZSWloZ+z+TJk+H888+HyspKvW/ASIsirxMAUaB36tQp5s+Y7x8jGZkC3Ui7ampq4Ne//jXMnDmz3q+/+eabcMcddyToVRklWhkZGXDBBRdAgwYNoGHDhtCmTRvYuXMnAADs3LkT0tLSoLCwsN7PtG7dGtq2bZuIl2uUIEUWXZRrY8yYMXDhhRf+4s+68MIL4auvvlL7go0SplgF+oUXXggXXXQRNGrUCF5++WUoLy8P/f+FCxdCWloaHDlypN7PXXPNNdCzZ08tr9tIv7Zv3w5paWmwYcMGAKBdBz169IBrrrmm3v8/cuQIpKWlwaJFi/S8cCOtirxOAESB/t///d/whz/8Aa6++mp455136rm3zPePkYxMgW6kXaWlpZCWlgb5+fn1fj0zMxOuuOKKBL0qo0QrKysLpk+fDuvXr4ecnBxo3rw5XHzxxXD48GHIz8+HtLS0epMKAID27dvDfffdl6BXbJQIRRZdlGsjMzMTGjVq9Is/q1GjRtCvXz+1L9goYYpWoE+ZMgWCwSBs2LAB5syZA02bNoXGjRtDdXU1AABMmjQJzjvvvF/8Wffeey+88sorWl63kV7V1dXBww8/DLfddlvo1yjXQfv27eHee+/9xe8577zz4JtvvlH3go0SomjXCQDAqFGjICcnBzZs2ACTJ0+Ghg0bwj333BP6/+b7x0hGpkBPoJxgNtG0ePFiaNasGZx//vlwySWXwPDhw1nnPHv2LJSUlEBFRQVUVlYm5NiyZQukpaVBTk5OvV/v3r07XH755Ql7XeZIrmP//v1w0UUXQWZmJvzwww+QlpYGW7durfd72rZtC3fffXfCX6s59B1paWkwadKk0H9Tro0ePXrAZZdd9os/69JLL4WMjIyEvydz6LlWoh1bt26Fc845ByZMmACVlZUwevRoOPfcc3/x++6880548cUXE/6ezOH98fLLL8P//M//QHFxcejXKNdBu3bt4K677vrF7znnnHNgzJgxCX9f5lB/nUQ7Fi9eHLLBV1amxvdPRUUFlJSUwNmzZ2VLGiOPZQr0BMoJZhOpXbt2wQUXXACdOnWC4uLi0BfI9OnTyecsKSn5BW3SHOYwhznMYQ5zmMMc5jCHfw+zrSJ5ZAr0JFFamnOB/v7778OVV15Z79f+/e9/wy233EI+T0VFRegmTHTHzhzmMIc5zGEOc5jDHOYwR+IOHN5F0ueNEidToCeJKAX67bffDm+++Wa9X5s5cyacc845cPr0adJ5KiuF7a+yMvGE0ZxNB2D66hIlR86mA3D6jH6rzsbSCmXvyX789PMJ7e/teHUtfF9Uqvy9LdpcDmfO1ml/f+t+Oqr8vc1YUwKlR09qf2+Vp07D7HXq/+0Wbz0IZxPwb7d6zxHl721mYQmUV57S/t6OnqiB79buU/7+lm4/BHV1+v/tCnYeVv7eZhXug0PHqrW/t8PHqmFWofp/u+U7D2t/b3V1dZC//ZDy9/bd2n1w9IT+veLlVadgZqHa9zZ9dQms2v2z84vxWGfP1kHe1oPK39vsdaVQeYr2bOql9lechBlr1P/brf3p/84e82SqDYyETIGeJKIU6I0aNYLMzMx6v4aApP3790f9merq6qhdsmS4CVt+ugTSA0Flx7TVeq06ladOQ6NuWUrfEx4tBuZqfW8AAH2+36TlvaUHgpC1Pvr1rEoHq6rh0i5ztby3h4Yu0freAAA6z1iv7d8ub+tB5xfkoX76+YS29/b0iGVa3xsAwJuTC7W9v9V79BYLW8qqtL23F8eu1PreAABeGrdS2/sr3q/3O33N3iPa3ttrk9ZofW8AAM+MXK7t/e05fNz5BXmoH7cd0vbeAtOLtL43AIDWn/2o5b1d0jmYkKatCpkCPflkCvQkEbVAjyQ+Ll26FNLS0qCsrCzqz2RkZETNmSTDTdh91gZoO2aF58et/RZAeiAIQxZs0/p+dh48BumBIFzWZa6S99V2zApoM3IZpAeCcEW3LK3vDQCgw4TVkB4Iwj2DFit7fzdl5kB6IAijl+zU+t427KuA9EAQGnXLUvbenhyeD+mBIFz3wQ9a3xsAwPNjVkB6IAj3f5Kn7P1d3+cHSA8E4ZsVe7W+t4KdhyE9EISresxT9t4eG7YU0gNB+Hv/hVrfGwDAE1+I6+bBIUuUvb+mvedDeiAI363dp/W9LdpcDumBIDTpma3sveHD+v2f5Dm/II91/yd5kB4IQuvPflT2/ppkZEN6IAgLig9ofW9z1pVCeiAITXvPV/beHhoqmviPDVuq9b0BANw+YBGkB4Lw6LClyt7fVT3mQXogCMt26HVATFm5F9IDQWj2wQ/K3hte+//8ssD5BXks/C564ot8Ze/vCmsYU1Tyf2OKbgr05JMp0JNEqizuyTxBV6VeczZCeiAIA+Zt1nreTaWVkB4IwvV9cpSd49Cx6lD3VreV+IWvRJE3deVPys7x/rQiSA8E4fNF25WdI5pW7f4Z0gNBuOMjdbtr9xw+HiokdeupEaKx831RqfNvllTHSWsgPRCEr5buUnaOaFq89SCkB4LQ8lN1zgQd93YsYZGyaEu582+WlI57O5qy1u+H9EAQnhye7/ybJYX3dnOF93Ys3TkwF9IDQVixS50zAe/tYJFe19G3q36C9EAQ2o5ZoewceG8/oPDejqUb+4pm8YZ96jK5Dw5Rf29H07j83ZAeCMKrE1crO8dcDfd2LDXuKZpWuw6pcybouLd1yhToySdToCeJqJC4q666qt6vdejQgQWJ88NNOGDeZkgPBKHXnI1az7t6j7D83TZA3ZTteHVtqEA/WXNG2XmiCaf3s9epK/IyZovmysDsLcrOEU1Lth1UPmUrrzwF6YEgNOwc1J71fdiaIqqcsr3z7TpIDwRhWK7e5sq8DWXKp2y7DonmSuOe2crOEUt3fSweBFXmjF+dKNwx4/J3KztHNM1YU6J8yobumJsy9TdXbs4Ubq71JeqKvLZjRHNFd6Rr/DJR5P17vLoib8Uu0VxJRKQLnQk7Dh5Tdg50x+iOdA1fvAPSA0F4e+paZedAd0wiIl0YVyurUGc/x4jmYs2RLlXyQ22QajIFegJ17NgxWLt2LaxduxbS0tJg8ODBsHbtWti7V1hEO3fuDM8//3zo9+OatbfffhuKi4thzJgx7DVrfrgJhyzYBumBIHSesV7refO3HwpZwFXpzNm6UIF+5LhecM4jnwub7/yN0eMUXqhfVjGkB4LQ5/tNys4RTT9sOiCsqJ+rK/IqTp4O/dtV1+ptrtw7eDGkB4KwdPshZefoNkvk3Af9sFXZOaLpu7X7ID0QhGdHLVd2jv0VJ0PxFd363w8XQnogqBRI9PaUtZAeCMKIxTuUnSOaJhUIq+3LX69Sdo7t5SJ6dE2v+crOEUsYHdh2oErZOV4ZvwrSA0GYsHyPsnNE06i8nZAeCEKnyYXKzlFUchTSA0G4td8CZeeIpUZdhYV5n0Ko53OjCyA9EISZhXqbK5/kbIX0QBC6zFT3jJS/QzwP3a3weSiaTp85G/qeVQkXfNSKPWUrfB7SKT/UBqkmU6AnULm5uVHz4e3atQMAgHbt2kHz5s3r/czixYvhuuuug/POOw8aNmwIw4cPZ53TDzchPji8PUVddziaFm4WRd7Dn/2o9DyXdxXd4f0VemngmClbsk1dx3jwD+LBodssvc0VzFO2GakOAlZTG35wqDipl2yLecrVe44oO0ffoIAI9ptbrOwc0YR5yn8phIAdPVET+rfTvR0C85Sby9R9ZneZKZorn+bo5XaM+XEXpAeC8Po36oq8fUdPJozb8dfuoshTuXUDIYK6uR1DQ41wdRCwrQeqEsLtsDfCf1bYCH9p3KqEcDs+zBIuww8UNsILLYigbm5H1alwI/zUaXWN8GdHLU8It0OV/FAbpJpMge4z+eEmROtdhwnqrHfRFCwSmaunhqslPaP1bqdC6100Nf9IFHkrFa6FQevdf6auU3aOaJpq5SnbfaUuT1lXVweXdBYPDgc0k19vsPKUG0vVWW0/nr8F0gNB6PHdBmXniKaxS0WR13GiOtLzqdNnQg99VZrXBl1tgaRUkp57zxHNlQ+z9HI7Pl+0HdIDQXhvmrr7/XCCuB11deEi72CVuhVvgemC2/HZQr3NFYySZcxWFyXDDQ1XdtfL7bBHyU7U1Co7z2sWt2PMj3q5HRgl+yhb3f1evB+5HXqbK+VVeqJkL44VGxqmrNTbXFElP9QGqSZToPtMfrgJsdh6QWGxFU3TV6vPUwKEi61NpXr/DXXkKUPFlua1OjrylAAQovbqXqujI0+po9iKJh15Sl3FVjRhnlJlU0dHsRVNgzQ0dRLF7dDV1EkUt0NHU0dXsRUpXU2dRHE7sKkzVOGmm0RxO7Cp89fuah0zieJ2qJIfaoNUkynQfSY/3IRoV35mpLpMajRNLNgD6YEgtFeYpwQAuG2AyKSu2avOrhxNmKfcXq4uTzl5hbArvzRO785ijEW8pTgW0ewDYVfeUqbu7zCaME9ZqjBP+aVlV35DoV05mjBP2VVhnhJAj105UvY8ZcUJdUWeDrtyNGXOFcyJTIWxiERxO3TFIhLF7dARi6g8lRhuB8YiGimORXSftQHSA/q5HZ00xCLKKkRzRTe3Y5sVi7i2t1rmxNtTE8PtUCU/1AapJlOg+0x+uAkR+PWIQuBXNOkqUBD4la8Q+BVNOgoUBH79Y7Te5soQTQWKDuBXpHTlKbFBpRL4FU1YoKjMUwLoaVBFSleBoqtBFSldBYqOBlWkdBUouhpUkdJRoOhqUEUKwYJ/y1A7/UVuh8oGVTQhWHC8QrBgorgdCBa8RTFYMFHcDlXyQ22QajIFus/kh5tQx8qsaNJl8cWVWQs3q1uZFSldFl9cmfX4F3p3p+qy+LbQsDIrUrrylLoiHpHSkacE0BPxiJQui6+uiEek3tVk8U0Et0OXxTdR3A5dFl8dEY9I4Wq+G/uqXc2XKG4Hrub7dtVPys6RKG4Hrua7U/FqvkRxO1TJD7VBqskU6D6TH27CVbv1fEBHCr9seyr+sn1quNhHPlfj7lT7l+2xanVFXu4WsTv1wSF6d6fil23/eWq/bB8cInan5m4pV3oeu3TlKeeu1wNJjJQuSNadA0VzRSUkMVK6IFnfaoAkRtPr3wirrWpI1o0J4HaEIVlqi7xEcTsQkjV1pboiD0APJDFSq/eIZ4g7Plqk9DyJ4nY8PUI8Q3xfVKrsHIniduRtFQOalp+qfYb4KDsx3A5V8kNtkGoyBbrP5IebELvfN2fq3Z2qa83U81b3e/pqfbtT7Xa1WoV2tYKdhyE9EIQWH+cqO0c0dZ6hx672+Bf5kB4IwrwN+porJUdOaMlT4prBVkPVrhmMlK41UzrWDEZK15opHWsGo0nXmikdawYjpWvNlI41g9Gka82UjjXZbStfAAAgAElEQVSDkfpxm9jhfd9gtS68LzWsGYym1pYLL2eTWhdeIrgd2RuFC+/RYWojjonidqiSH2qDVJMp0H0mP9yE28vFQ21TxZCQSHWbtV5LnrL91+KhdmKBuvxYpPZXnNSSp1z3k8iP/e+Henenvj1FD/DlH6PFQ+2sQn27U3XlKfO3i4faewYtVnqeSOnIUwIAPPL5UkgPBGH+xjKl57EL85S3Ks5TIrejtWZuxz+/LID0QBBmFqptNiaC25G/Q9wPdyu+HxLF7Xh0mLgfshXfD4ngduTg/fCZ2mZjorgd9w0WzcYft6m9H5Dbse2APm4H3g+qIcHI7eg0WW9zRZX8UBukmkyB7jP54SbEiaHqNRuRwpUpX+SqLfLesGyhX2rcnYp5yiaK85RbykRzpZniiWGkME/59bLdSs/z0jhhC52seGJoFzpKbspUa7VdY00Mbxugt7mCecppih0lz4wUzZXZ69TZQiOFecoWiuM6ODHUze14crhwlGQpjuu0TgC3Y9Hmci2OkkRxO1p+KuI6eVvVOkruSgC34/si4Sh5eoRaR8mMNYnhdtzxETpK1MZ1bumnn9sxdaWI67yo2FEyfvmehHA7VMkPtUGqyRToPpMfbsJDtsytzt2pr01aA+mBIHy1VG3h/P40kbn9fJG+3am68pR7D4vmylU91GZuI/XCVyu05Ck7arpG7EImg+o85aZSPddIpJ7SkKcEsF0jCsFKkVps5SkfUJynxGukueJrJFIPDRVF3iLFTAa8RoJF+qIlWRaT4cnhagtnXddIpFpYTIYVu9QWebquEbuQydB2jFomw1xN10ikkMmwYZ/awvlOTdeIXePyBfDy1YlqC+dEcTtUyQ+1QarJFOg+kx9uwmM2avWp0/p2p+J0VHWesud3YjXRx/O3KD2PXWs05SnLKwW1+hLF1OpI4XRUdZ7yP1P1uCzs0pWn3HnwmBaXRaR05Sk7TNDjsrAL85SPKc5T6nJZROruQcJ6vmyH2uloIrgduqajieJ24HS0qESt9fyJBHA7cDr6yni11vNEcTv+Zm012F6udqsBcjtUuyzsGmFtNXhb8cpI5Haodlnokh9qg1STKdB9Jj/chLW23alHT6jb+xyp50YXaMkX95sr9j73Dard+2wX5ilV54srTob3PtfU6tudinlK1fli5BQMVswpsCtHU74YOQWXd1XLKYgU5imXKs4XI6dgZJ6+5grmKZ8dpTZPiZyCa3rp5Xb8vb/IFxfuVQtvQ06BTm7HpIK9WvLFieJ2XKspX6zre9Wu0Uv05It1fa9GqlE3AW/bd/Sk0vPo+l6169McAW/rMnO90vPo+l7VJT/UBqkmU6D7TH65CS/vKnan7q9Q+wVkl65O/+AftkJ6IAjdZqn9ArJLV56ypjbcXKk4qW93qq5Of5/v9ZD+7dLV6T9yXA/pP1JhQrdaGyWS/ocsUEv6t0sXoRu5HVcoJv1HShehWxfp364xmgjdukj/kbqyu1h/pprQrYv0bxcSugPT1RK6dTnT7DpzNrz+7PAxtevPdDnT7PowS6w/6z1H7QAjUdwOVfJLbZBKMgW6z+SXm7BJT2Hh2nVI3+5U3HGtOiv3Ra6wcL3zrb7dqbqycnV1dXBJZ/HwUF55Sum57NKVlRuYvQXSA0Ho+d0GpeexS1ee8mTNmdCD37HqWqXnsktXnrLXnI2QHghC/3mblZ7HLsxTdpyodse1ndtx9qy+aElj63N6t+LP6URwO3DH9buKP6cTwe2w77gur1L7Oa2L7WKXrh3XieB2nKgJRwCPK/6c1sV2sStjtvicHqD4c1oX20WX/FIbpJJMge4z+eUmvMF6aC/er+996qLNfrVUTGZem6T2od0unbTZq3qIyczew/p2p+qizeJD+/vT9O1O1UWbPWubzBxSPJmxC/OUOw6qzVMOmCce2nvNUfvQblcoTzlVbZ7yuI3bcbJGH7fjsi7C6VRWobbIw4d2ndyOQfNFM66H4mZcIrgdp06Hm3FVp9Q6nXRtR7HrA8vp9GGW2iJP13YUu362OZ3OKG7G6dqOYlfnGaIZN1Sx0ylR3A5V8kttkEoyBbrP5Jeb8LYBItu4RnG20S5d+1onrxC215fGqbW92qUrTwkA0OwDYXvdUqZvd6qufa2YbXxDse3VLp37Wq+wso2qba92NeqqJ085xLK9dp6hL1rySY6Is3RVnKe0216PHNfD7ThtY4VUnFBb5PXLEtyOPt/r43ZkWqyQTMVxlspTYW5Hda2e5krFifA5TyuOs3SfJaCogzRyO7rMFHGWT3LUnhO5HZd10cft2HdUnLNRV/VxFuR2jFisr7nSyYqzjMpTG2dJFLdDlfxSG6SSTIHuM/nlJrzHogPn71ALjrILC0vVecpZhQIc9dxofbtTv9SUpwQINzrWKW502PXX7noKywnWNLu9hkYHSleeEgDgml6i0bG9XE9zRWeecmSemGa/pZgObBfmKT/QUFgit6NUcaMDVWUrLFVv20gEtyNUWCqe2ieC21FWIab2l2ooLPsG9XM73p4qCsvhigvLRHA7duC2jQz1U3vkdnyao4/b8e/xYmo/XvHUHrkdjTRzO1TJL7VBKskU6D6TX27Ch63VS4s269uderVlzd5zWG2ect4GkQd/4gt9u1PRmv3eNPW59xZWVKBAcVQAZc9THqxSW+RNXy2iAs8rzoPbpStPCQBwc+YCLXlwlD1PeaJGbZ5y/DKRB+8wQW1UwC60Zn+UrT733sSKCuxUHBVAHawSufeGGqzZwxfr53a8a1mzh+Wqzb0ngtux27JmN9Zgzf54vn5uR8eJIvc+Ln+30vPYowK6uB0bS4U1+8a+6q3ZveeI5opObkc7K/f+7Sq1uffDCeJ2qJJfaoNUkinQfSa/3IRPDV8G6YEgzF2vZ3dqXV0dXGrlKQ8ofkjK3SKI6g8OWaL0PHbpylMChGF7uYpheyidecpgkWiuPDVc3+5UfEhSnacEAGj+kSCqr9ytFraH0vmQNNWC7b3wlb7mSmC6yFN+tlD9BAq5HZtK9Xw3/PSzmEBd2V093Gysxe3oqJHb8fo3wmo75kf1cDNdzWHU5jKEm6knx+tsDqNeHLsS0gNBmLJSLTleZ3MYtXqPgJvdPkA93Ay5HTqaw6inR4hnvznrSpWeJ1HcDlXyS22QSjIFus/kl5vwn1+K3akz1pRoOV89m6HiPOXynYchPRCEuz7OVXoeu9BmqDpPCQDweGhdnZ7dqUdPhG2GqvOUC4rF7tSHP1O7rs4uXXlKgPC6uiXb1K6rQ+nMU8621tW1GamvudJJ43ow5Has3qOH27HNWg92bW/1Gc5EcDtwPdikAvXrwXRzOwqt9WA6dq9jvEont+PZUfrWg+nmdizdLtaD3TtY/e71MLdDHxS19edi9/oPmw4oPY89XvWzJm6HSvmlNkglmQLdZ/LLTdj+a30PRwB6QT1rfzqq7eEIpRPU84/RenenYp5SB6gnX+PDEQrzlDpAPY9oejhCYZ7ybxrylD9sEs2VRz5fqvxcqFCecvke5ee6d7DF7diuh9uxvkRYbW/pt0D5ub5bq5/bgU3imYXqm8S6uR3Ldogm8d2D1H+OTSzQz+14bJj4HMveqL5JjIBSXdwObBK31tAkRkCpTm4HNol/3Kb+cwwBpbq4HSrll9oglWQKdJ/JLzfhG5a98EsN9kIAgPKqU9rylFvKxOSp2Qfq7YUoXXlKAICXxgl74eQVeporuzTmKVfvEZOn2wboa67gqhvVeUoAgDYjhb1wtmJ7IQpX3ejIUy7ZdhDSA0G4/5M85edCtR0j8pTTVqsv8pDbsXCznubKil3CattiYK7yc83bUAbpgSA8rpHb8eRw4QTK0hCz0rXiE7XIilk9NFR9zErnik9Uy09FzGrxVvVOIOR2qF7xifq+SDiBnhqh3gmE3A7VKz7tusOKWa3SELPSze1QKb/UBqkkU6D7TH65Cd+bJgrKzxepLygBAPYe1pen3HNYFJRX91B/LtRrk9Zoy1N2tM41dqme5krxfn15SgT03KChoETpylMChAE9UxUDelA685Qrd4tzNf9I/blQmKf8vkh9wwO5HcEiPdyOvK2i4dHyU/VFXiK4HQ8NFUWeDlCpbm5H1np9oNK56/VzO1oM1Acq1c3tmKYRVIrcjnYauR03ZQqWhg5QKXI7Npbqaa6olF9qg1SSKdB9Jr/chD2/07PiBrXVylNep2GqfaAyvOJG9bQehXnKbzRMtf8zVTRXVK+4QWGe8u/91U+1d2pccYPSmafsMEHPihsU5invG6x+qo3T+psz1VuyUZinzNEQGXjemtZP1zCtBwCYv1FMtR8dpj4yUJAAbsfd1qrPZTvUF3m6uR0zC/VNtRdu1s/tuLWfmGoXlaiPDOjmduCqz1fGq48MzEkAtyO86lP9VPv2AYu0cjtUyi+1QSrJFOg+k19uwn5ziyE9EIS+QfX7gwEAikpELvxWDXnKipPhvHtNrZ7dqTrzlN1mCajZYA15dwCA/B2HtOUpSy2o2eVd1efdUY9qzFO+NUXk3Ufm6Wmu5GzSl6fcXi6acE01QM1Q9w0WD+9LNeTCkdsxsUB93h0gnAt/dtRy5edalwBux9/7i1x44V71D+/PjRafz7MK9XA7vglB99QXefj5fI+Gz2fUtVYufOsB9blw5HbM1/D5DAAweonIhb85WT10D7kdrTVyOxpZ0L2SI+qhe7q5HSrll9oglWQKdJ/JLzfhoB+2QnogCN1n6dmdihMaHXnK6trwWrBKxWvBUE98oS9P2ed7QYzvl6WeGA8AsGizvjzlz8fDxPgzmnan6sxTdp4h1oINWaB+LRiA3jwlrgW7opt6YjwK85Sr96i3vyK3QwcxHgBg6kphf31xrHqyeiK4Hdf3EWT14v3qv2t1czvGWGT11zSsrVuzVz+348ruYm3d3sPqizzd3I7PFgqy+vvT1JPVdXM7ztrI6oeOqV9bh9yOBcV6uB0q5ZfaIJVkCnSfyS834Re5OyA9EIR3v9WzO3Wxlad8QEOesq6uDhp2Fl9C5VVqd66jQnlKDRnHgdli57qu3amYp3xyuPo85cmacHPleHWt8vMBhPOUK3apL/J6zdkI6YEgDJinfuc6QDhP2VZDnvKQbee6rmiJzjzl+9OKtHI7vrYAUq9OVA+QQkaITm5H454CILX7kPrd5Lq5HcNyt2v7ft1UWqmV26H7+/UFzdwOnd+vqzRzO3R/vz41Qi+3Q6X8UhukkkyB7jP55Sb8aqm+Dj8AQLaVp3xMQ54SQG+HH0BvnlJnhx9ALyVYd4cfAOAWjXnK/vM2Q3ogCL3m6GmujNeYpzxWXRv6tzt1Wu0qRdTfLEqwjjwlcjs+1sTtGLFYNFHf1rCCqdzidlyiYcsG6rIucyE9EISyCvVFHnI7vsjVEy3R6VALcTs0bNkAADh1Wq9DDbkdX2vidnyg0aGG3I6bMvU0V3Q71HRzO1TKL7VBKskU6AnWsGHDoGHDhnD++edDs2bNYMmS2BPYsWPHQlpa2i+OU6foDwB+uQl1ZuQA9OYpAQCu++AHbRk5gPCeXR15Sp0ZOQCASQV6rxWdGTkAvXnKT3NEc6XzjPXKzwWg91qpPXM29PB35HiN8vMBhK+VfRr27CK3o8/3ergdeK10man+WtHN7Thtu1aOnlB/rejmdmRqZLzsr9DL7ag4ofda0c3t6DpT37WC3I5reunhduhmvCC3Y8JyPdwOlfJLbZBKMgV6AjVlyhQ499xzYfTo0VBcXAydOnWC3/72t7B3b/Qc2dixY+H3v/89lJWV1Ts48stNOKtwn7apKADAlJWiyPuXhjwlgF7KLEA4T7m5TP11o5MyCxDOU77+jZ6GgE7KLEDYbfHTz+obAiPz9E1FAcJui8B0PW6Ly7uKqej+CvUFs91tcViD22KwNRXtNktPcwXdFr3nqC/yamrDBbOOqWjVqXCRp8NtoZvb0UPjlpQjtqlo7Rn1BbPuLSmdZ6zXyu3QuSWl5IhebofuLSlvTtbL7VApv9QGqSRToCdQN910E3To0KHer1155ZXQuXPnqL9/7NixcOGFF7o6p19uwnkb9O1pBQAYly/ylB0n6rHU69zTCqA3T6lzTysAwOeL9OUpAfTmiuvqwkWejjwl5oo7TFCfKwYA+Ch7s1ZeQRPrPtil4T44URO21OvIUyK34x1N90HGbH28grq6OrgEc8WV6u+Dg1WCV9BQk6Uec8U9v9MDRX1v2jptvAJ7rviYhvtg96HjWnkFyO3or4nb0XGiPl6BndtxVoPlfGNphVZegW5uh0r5pTZIJZkCPUGqqamBX//61zBz5sx6v/7mm2/CHXfcEfVnxo4dC7/+9a/hL3/5C/z5z3+Ghx56CAoLeVM/v9yEi7boI3MDAAzHPOVUPZPDBzSSuQEALtWYpwwWieaKDjI3AMCg+Vu05SkBwmTuVbvVQ9t05ymRzP3CV3qaKzrzlAAA1/cRzZVNpeo/P3XnKZHb0VETtwOJ/0M1TQ6v6qGP24HE/7921zM5xCajLm7H6xbx/8sf1Rd5urkdm8sElE4X8V83t+NfY/UR/+3cjpM16p0kq/foJf4jt2Ngth5uh0r5pTZIJZkCPUEqLS2FtLQ0yM+vP+HNzMyEK664IurPLF++HCZMmADr1q2DJUuWwBNPPAH/9V//Bdu2xX7Aqa6uhsrKytBRUlLii5twubX2TMduawCAT3KEPbSrhjwlAMBjGndb2/OUFSfUF3kLivXttgYI5ykz5+op8u7/ROy2/nGb+t2p9jzlaQ320NnrxNqzZ0bqYTFgnvKTHD3Z29sGCBbDGg0sBsxTNuqqp8ibHOJ26InpYPZ2VJ4ee2gzjdyObQdE9vba3nqyt7q5HS9b2dtJBXrWul2hkdux9qejkB4Iwv9+qKfIG7JAL7fjH6OXQ3ogCN+t3af8XLq5HfnbD0F6IAj3Dtbz3NcvSy+3Q6VMgZ58MgV6goQF+rJl9aeEffv2hb/+9a+kP+Ps2bPQtGlTeOONN2L+noyMjKhguf/rN6HuL9kPs0QX/ANNH9TPjtL3Jas7T7lU85ds91n68pQAAK0/F82VHzap351aVhHOU+rQfGubwSOf69lm8PbUtdrylAAA91jbDPJ3qG+u7NCcp0Rux3Oj9XA7/j1e0KvHa6JXI+hy3U/quR3rS4TV9pZ+C5SfCyDM7Wj/tR5uxz+/LID0QBBmrNFDrw5zO9Q3V5btEM39uz7OVX4ugDC34y1N3A5s7s/boL65DxDmdpRqAF1ic/9hTc193dwOlTIFevLJFOgJkozFPZpefvllaNmyZcz/79cJOtrUru+jx6aGecqPsvXkyNCmNmWl+gmG7jwl2tRuH6Bnd+q73+rLUwIAPG3tTp2zrlT5uXTnKfO2HoT0QBDu/yRPy/l05ikBAFoN/RHSA0FYtLlc+bkwT3mjpjylbm5HO2v/87ea9j+3+Fgft2Oltf/5zoG5ys8FADBdM7fjqeHiM2zuej37n2/OXKCN24HxuAeH6InH6eZ2YDwud4v6zzCAMLdj50H1UNRQPG64nnicbm6HSpkCPflkCvQE6qabboJXX3213q9dddVVMSFxkaqrq4MbbrgBXnzxRfI5/XIT7jksCpPGmnanBqaLPOVnC/XkKbEwGZe/W/m5ME95ZXc9RZ7uwgTzlGM05CkB9BYmuhtVugsTnY0qAL2Fie5GVa7mwqTNSH2NKgCAB4fo43Zgo6rlp3r+LnVzO3Q2qgAAmmvkduhuVE1dpZfbobNRBQBwQ1993A7djaqxmrkdKuWX2iCVZAr0BArXrI0ZMwaKi4vhrbfegt/+9rewZ4/Yqfj888/XK9Z79eoF2dnZsHPnTli7di28+OKLcM4558CKFfQPI7/chPZVKTrUSfO6DZ3WXt15St3W3pfG6c1T6rT2Fu49ojXqgdbemzP1WHt1Rj0A9Fp7dUc9kNuhy9qrM+oBAPD4F/narL0Y9Xh0mJ6oh25rr86oB0CY27Fkm/rmyszCEq1RD+R2tBmpp7mCK1p1RD0AwtyO1XvUczt0Rz10cztUyi+1QSrJFOgJ1rBhwyA9PR3OO+88aNasGeTlha2hzZs3h3bt2oX++6233oK//OUvcN5558FFF10E99133y8y7E7yy02oG44VKrqW71F+LgC9cCzdeUrdcCzdeUps5uiAY+nOU2Izp6mmZo7uPKVOOJZuWKJubodOWCKAXjiWbliibjiWTlgiAMAjGps532guunRzO66zYIlbytTn+QFszZzt6u9zhCW+8Y0eWKJubodK+aU2SCWZAt1n8stNWF0bXi9VpWG9VNsxwrY8bbWeIg/XS32YpT7zvmKXsC230GRb1r1e6snhYrKWpSlPqXO9lO51g7rXS+leN/iGxvVSum3LW8pEc0XXeimdtmUAgJfG6YtD4LrBF8fqKfJ0xyFw3WDxfj3PETrjELhu8DVNtuUl2/RyO3SuGwQAePgzEYdYuFl9c0X3usF5G0Rz5XFNcQiV8kttkEoyBbrP5JebsK6uDhp2FkVeeZX63d0I/vq+SE+e8qNsQY3PmK1+d6ruPOWJmvDu1OPVtcrP99DQJVrzlAgUHDBPfXMla73ePCUCBdMDeoCCLQbqzVO+N00fUHCa5jwlcjt0AQVvyszRBv4CAOg4SR9QEMFfr07UA/5CbscNmrgdCP7adei4lvMht2OqBm7HsNztWsFfyO1o/pH65kq956JK9c9FAGFuR7BIfQN8YPYWSA8Eoed3G5SfC0A/t0Ol/FIbpJJMge4z+ekmvLK76BT/9LP6TjHmKXM05Sk/Wyh2pwamq+8U685Tnj1bFyryDh+rVn6+uzXnKXElX+856lfy6c5T6l7JpztP2eM7fSv5ME/5yng9eUo7t0NHcyW8Oks93RkA4D9T12njduDqrLc1rc7aqZnbgauz9leoX50FANBhgj5uxyDNq7N0cjvszsKKk+qdhQDhCNl0De7CPpazsN/cYuXnAtDP7VApP9UGqSJToPtMfroJMWu17YD6rNV9g0WecqmGnBVAOGvVabL6rNV3a0XO6tn/z96ZR0dVZW2/Vivgq6/yrrZ7OfTXXTgwyaSoYDuAOEG3iLbdirQI2oqijaCtbSEEwpQQkEGROcxDSGQKUIQhTAESwhQggYQpkFCEkBCSSiCQBMjz/XHuqbp1c6uJJnvfStf5rXWWy6TIqVu177l337P388zk6acEgMaD42B3OHGWwTv1mQjRT5nC1E/5fbx4uPLtCvobQG8/JU+SV3H9hucGsKi0nHw+eY4fYzjHASB8bTrsDidGOekfrshzvD/DOQ4A7ivehyvl1+h1O5po57irkKfUdvBKPt0OznMc4NXtuMZ8jgPAF9EH2HQ7OM9xADiRx6fbwX2OA0AfTbdjUTK9Po88xydspD/HAeAgs24HJcGUG9QVVIIeZATTSSh31w656HfXOmj9lPuyePopFzDurnH3UwJAq9D1bLtrj4/cyNpPOX0b3+7a7B28/ZQA8NC3fLtrskqGq59S7q6FrKQvoZRVMlz9lPrdtWJi3Q59lcwFhioZQLe7Fke/uxaxjq9KBuDV7bhU5m1B4qiSAby6HT8w6HbIKplxDFUygFe3o8lg+ocrskrmgYE8LUiAV7eDw+FGVslM3UpfJQPw63ZQEky5QV1BJehBRjCdhLI/dfcp+qSZu59S9qf2YuhP5e6nBHg/zxbM/ZTzEvk+T+5+SoDv87Sin1J+nl8zfJ6yn5JDZwLg1e24Uu59GMChMwHwfp7DVvPpTAC8n+eFS7w6EwDv58mpMwHw6nZInYnmTDoTAO/nKXUm5jDoTAD8uh2UBFNuUFdQCXqQEUwnoVR4TmBQeJY7vifzefop1xwSNj5vMyg8e3Z8Y3j6KQHeigS545vr5knyOCsSOHd8JVwKz5w7vhJOhWfOHV8Jl8JzIbNTA+BVeObQ7eB0agB4dTu4nRoA3ooETqcGgLciwYod36GMFQnSqWHJbnqnBgDIs6AigYpgyg3qCipBDzKC6SSUHsnrD9N7JHP2TANA/BE+j2TufkrA29NP7ZHM3TMNeHv6OTySw5j7KQFvTz+1R7K7lL+fkrOnf9AK3n5KgK+nX/ZMPzxoLek8ejh7+jl7piWNmXr6OXumJfIaNHA5/TXoI8aeacC3p7/wMu016IAFPdOyp3/kGvpr0N8jd8HucGJlylnyuQBrevqpCKbcoK6gEvQgI5hOwh4zxWIde4B2seZWHQeAnScuwO5w4pUJ9N6p3P2UAJ8qPrfqOACsZ1TF5+6nBPhU8a3op5Sq+D1n0avic6qOS7h0O7hVxwFeVXxO1XEJlyp+2lk+1XEJpyo+p+q4hEu3Q6qOd2JUHedUxX9zaiLsDifWpdFbugHWVHFREUy5QV1BJehBRjCdhP+YK8qdYvbQeqfqfbtLy3n6KfdlCe/UDgzeqdK3e+x6nn5KgM9Xntu3G+D1lefupwSArpN2wO6g95W3ov9vXRqfrzynb7ek0zgeX/kjOcWwO/h8uwFgGaNuh/Tt/onBt1vCpdshfbuf/24r6Tx6OHVQpG/32lSeJA/g85W3wrd76lbxcIVDB+XPP4i2xq1Haa89ksrKSjzArINCRTDlBnUFlaAHGcF0En62SNzgzks8TTqPXkH3BlM/pdzFeJLhBpe7nxIAes3mucG1op9y9ym+G9x+zP2UAPC3aYksN7gZucXs/ZRbtBvcVyfR3+DKB4xc/ZSAV7djG7Fux76sQtgdTjw7hq/U1nlIPFx5i0G3o/sMkeStPkj7gFGP1O3Ye5pWt2P7cfGAsfNE+uotidTteH8O/cMV+YBxcwZt9ZYeqdtxJIf2vkw+YHyT4QGjROp2fMag2yEfMO4ifsCoh0u3g5pgyg3qCipBDzKC6ST8Mkb0AU4nLhHl9KCVnNRKRFsxlIha0U/5yQKtRHQXbdEujxoAACAASURBVB/g8fP8/ZSHXKIP8Klw+hJR7n5KwFsiunw/bYmoFf2USSdFieiL47eRzyX7KalbdPRw6XYkai06L0+g/xwlm9L5dDte11p0NhK36OjpPJFHt2Ojpn/y+mT6Fh3JqoM5bLodL8kWnRO0n6MeLt2OlSlC/+TvkfSfo8Sr20Evivr0aPE5HjhDb60r4dLtoCaYcoO6gkrQg4xgOgmlyNL38bQ7v5zJsuSsfCjA4J3KlSzrGbCExzs11eVmS5Yl8qHAowwPBbiSZT3yocDiZNqdX9lP+QJjPyXnQwFvPyW9yKWE66HA5gyR5L3GkCxLEhl1O7iSZT1cuh2cybJkA6Nux7NjeJJlPS8x6XYsYUyWJfKhwLuR9LodbbVk+WguX7IsHwocZHwoQEEw5QZ1BZWgBxnBdBKO0GyKRsfR9k4fzuErN5cU6LxoqW2KrOindCzjKavnLDeXcJbVc5Wb6+Eqq99iQT+lLKt/fCR9Wb0sN+fqpwS8ZfXRe2gfrnjKzafRl5tLZFn9c2PodTs6MpWb65G6HdRl9TF7+crNJVK3g6OsnqvcXA9XWT1nubmEs6xelptnFdD28uvh0u2gJphyg7qCStCDjGA6CceuF+rjoasOk87DeeMn4RSms6KfkkuYjvPGT5JXctXz3VEL01nRT/n1TzzCdFb0U56+IITpWgylr5ax4saPS7dDCra9xyDYJuF8kNo+bBOLYJsergepCzTBtr4L6QXbJJzCdFKwLTOfVg1fD9eDVCnY9q8YesE2CdeDVL1g23lGwTYu3Q5qgik3qCuoBD3ICKaT8MfN0jv1EOk8nJZnEr2120Vi71Su0kk9o+PEw5URxN6pnKWTEk5rN67SST3S2m08sbUbZ+mkRFq7PfgtvX+3FaWTXNZui5KF5Vmf+fSWZ5JMxlYkLsszPVytSJyWZxLOVqSHB/FYnunhakWawGh5JuFqRSq/5vWTd1/hszyzohWJgmDKDeoKKkEPMoLpJIzcngm7w4kBS1JI5+EUH9LTeFAc7A4nzhbR3khY0U85MV7cSHy7gvZGIvbAWfZ+yorr3huJolLahytc4kN6wtamw+5wYpST9uEKp/iQxF3qfbhScf0G6VyPWdBPKXU7JsYfI51Hrs2fR9GuzXo4xTybDBZrs6uQT9lZ6nZQi3n+sEk++OZL8rjEPK/p1uZC4gfferjEPMO1tXkk8YNvPVy6He4r3rW57Brtg289Voh5UhBMuUFdQSXoQUYwnYQLdoldmk8W0Jbicdr36GkVKkrxThKX4lnRTzl9m7ZLE0O7S8Np36PnwW/FLk2um7YUz4p+yvEbjsLucCJkZRrpPFb0U16tuO65CSy5SrtLY4V9D5dux+QtJ2B3OPHNUtrqJj16O0xK3Q59ddOFS2Vk8xjhssMcs05UNw1bTds6podLt+NSmbd17Eo5X5LHpdsxVKtu+m49bXWTHi47zDytuqnRQPrWMT1cuh3UBFNuUFdQCXqQEUwn4VKtz7E3cfIl5+nF2E8JAE+OEsnX4RzaPsd2YfHs/ZTzEkWf42eLaJOv+Vo/5aeL+PopAaCF1ud4+gKtmI3spzxFPI+eKVtF8vX1T7R9jrKf8iviefRUVlaikdbnmFdC93BF30+Zx9hP+d36oyy6HeO0hzhDY2kf4ui5Uu59uEKp26Gf53IZrT6IHi7djmGrxTxj1tHOoye/xCuKSpl8XdCJr94gFl/V8++lPLod3yw9xDKPnqwCodvxyJB1pPNkF4iHOM2J5zHy2WKh2zF3J+3DFWqCKTeoK6gEPcgIppNwzSFhB/M28c72Qm2n/uMFfP2UAPDcGLGzvS+Ldmfbin7K6D2ifPmDubTly56desZ+SgB4fKQoX04/R3sePvQtfz/l7B1iZ/ufxDvb4y3opwSAZiFiZ/vMRbqd7bJr3iSPs59S6nY4ltHubI/UdurD16aTzqNHv7NdQLizXci0U29E6nYMX01bvjxwuWiD+IF4p14Pl26H3KlvwmBfqkfqdowj1u34PIrHvlSP1O14gHhn+2iuaIN4jHin3giXbgc1wZQb1BVUgh5kBNNJGH9E6w2fTCsAJvsp+xP3uht5ZYLoDd95grY33Ip+Stkb3mMmbW/49/H8/ZSAVwAshbA33Kp+ysXJsjec9oGVFf2UAPDocPHA6vh5ut5wfT9l+TXaXnc9XLodg1eKJG/CRtpedyONB9Prdpxzi173hwfRCwnqkWsZtW7Hl9EHYHc4MSOBLyHh0u04kSeSvNbDaHvdjXDpdvTRet0XEgsJ6tHrdlCuZQe1Xvc/MggJ6uHS7aAmmHKDuoJK0IOMYDoJpbo6tYUW166TkW4/CgutTel06upcu05G1mvq6n8hVlePWMez62TkRU1dPekknYWWvp+SWi1ez4oU0fLRcxatuvpQpl0nI38MFxZah1x06up5TLtORriqgb7SrPimbuXddZLVQJS6HVItviWDWrweLt2Ovgs1tfik06TzGHmIQbcj7axQi28fxpvkyWogat2O92YLK75l+2jV4vXoq4GKCXU7kjW1+E7EavFGPNVAcXzVQBQEU25QV1AJepARTCfhvizhndphLK0/OVffppG3pgt/8jWH6PzJreqn3Kb5k3f5ntY7VfZtcvZTAsCrk4R36paMPLI5uPo2jcSlCtHEvxL7k3P1bRrp9J3wJ999iq61RPZtcvdTculpyL7NOcx9mxx6GkdyhCjWEwx+63qkbge1nsb7mt96DLHfupEWDHoa0m+9I/E9gxGp20Gtp/HWNHHP4DxE67eux0e3g1BPY6vmt/4n4nsGI1bd/9U2wZQb1BVUgh5kBNNJKJ+GtwujvVGy6gmqfBq+lPBpuFX9lJ6n4d9tJZ1HKh9z9lMCwF8179S4VLobJav6KbdkiBulVyfR3ihZ0U8JAF2+Fw9XEo7lk81hVT8ll27Hh/OE8nHUbl7l4w5j6XU79mcXwu5w4tkxtLZSRrh0O96ZIWylVh2kezBsBodux/bj+SxVd0a4dDteY6i6M0PqdlA6UqxL46m6M2JVBWVtE0y5QV1BJehBRjCdhCe1UkPqfjKrepA+XkDfT8bpHaznkIunn+wLrZ+S2jvYSM9ZybA7nFiRQvdwRfZTUnsHG0k6KR6uvDh+G+k8fZi8g438ZcpO2B1OrD+cSzbHQSbvYCOb0jXdjh93kM7zbqSI/5UpvN7BnSfS63Ykaq1VL0+gjX8jXLodr08W8b/xCG+S90wEvW7HRk235nVi3RojUbt5dDteniBaqxKJdWuMPDZCPFw5RqjbIeP/75G08W/EKg2i2iaYcoO6gkrQg4xgOgnPyuSSeAfRKhXP/kvodxCt6qc8dl4kl48SJ5efLLCmn/LDeSK5XJxMt4OY6rKmnzJF20GkTi7lQw7OfkoA6DFT7CDGHqBLLndZ1E8pdTtemUC7g/imVkGyLo2v1BYAumnJZTxhcrk5QyR5rxE/5DAidTveIN5BlA85th+nqyAxQ+p2JJ6kSy5XHRQVJN1n0FaQGJG6He9G0up2PDtms1ZBQveQwwyp23HwDJ1uxxLtIcc/iCtIjFjl4lPbBFNuUFdQCXqQEUwnYQGTp6lVPpjS0/THzXTl2Vb1U0pP02YhtD24vS3qp/ynFjOzd9DFjFX9lOnnRMw8PpK2PNuKfkoA+GCuKM+O2UMXM1b1U3Lpdvz5B02D4SidBoMZbzPodqzVNBjemsab5HHpdjyvaTDsOU1r72mEQ7cjZu8Z2B1O9J5Dq8FghEu344lRQoPhcA6dBoMZUrcjOZNOFHXuTtEm8Nki2jYBI1y6HdQEU25QV1AJepARTCdhablXxfpKOZ2K9T+0G/boPbz9lFLg7Lv1dCrW+7LEbuhzY3iTvLwSoWLdiFjFuvsMccO+mrmf8mtNxXrKVjqBM6v6KU9fEAJnLYbSVl3IfsrNGbyltp8tEg9X5iWeJptD9lO+SXzDbuRwjqi6eJL4gdwL48QN+y7CG3Yz5AM5St2OZdoN+3vMN+y7T11k0e1oHyZ2QymF9sz42zR63Y4FSUJor+9CWqE9I1uO8uh2tAwVQnuZhC4GZvxJ0+3YRqjbMU1zMfhXDK3QnhHnIe2BHLFuBzXBlBvUFVSCbjFTpkxBo0aN0KBBA7Rt2xbbt//nBXrZsmVo3rw56tevj+bNm2PFihU/a75gOgn1FmEXCX2g/x5JX/JqRnic8E4dQegDbVU/ZfFVr3cqpUVYN4v6KUNWCouw8YQWYRu0klfufspct3i48uC3tD7QL423pp/yyxihWzCdsKVlZYo1/ZRSt6MVcUvL06NFqe0BwpJXMzwtLYS6HYuSRclrn/m8Ja9St+MpYt2ONsOFVd2JPLp+YjNkS8vy/XQPV2YkiCTvi2haqzojUrfjBeKWlocHCau6nKIrpPMYkbod69LodDsmaFZ1g1akks1hBpduBzXBlBvUFVSCbiHR0dGoV68eIiMjkZ6ejgEDBuCOO+5Adrb5TmxSUhJuueUWhIeHIyMjA+Hh4bj11luRnFz9vqVgOwkbD4ojvyB5+ynpLj5mcFyQrOqnLL92w5Ogu0vpvFOt6qcc5RTK/2Fr6ZT/reqnLCr1Kv9XXL9BNo9V/ZTfaqKQ38fTtZZY1U/JpdvRVhONysjlvQ4NYNDtmKUpcn8exSsaxaXb0TREXFPPXKRT5DaDQ7fjh01CkXvgcl5Fbg7djutMGxZmcOh2cGxYmMGl20FNsOUGdQGVoFtIu3bt0LdvX5+fNWvWDAMHDjR9/dtvv40uXbr4/Kxz58545513qj1nsJ2ErRhKumQ/JWX5lhkcJV2efkrm8q3Kyko8+K142n+e0Du1o2a7tJe5n3L8BuGdOiQ2jWwO2U/5PnM/5dWK654bwZKrdA9XZD/lkRzetWyEZqsYsS6DbA5PPyWx7ZKRizpbRUrdjkeGCNulrAI6T2szpK0ipW7H5C3C0/qbpbxJnrRVpNTtqKz0JnkXLpWRzWNGP81WkVK3Y8y6DNgdTgxbzetpnZFLr9txuYyn5c8MjjZAjpY/M2QbILVuBzXBlhvUBVSCbhHl5eW45ZZbqpSo9+/fHx06dDD9N7///e8xYcIEn59NmDABf/jDH6o9b7CdhE9qN/ELkk5j69E8kiEVSikFUMyQN/FvTUsiO7awtemW9FMC3pv4mL1nyI7vUa1ck7ufUt7E95yVTHZsQ2LTLOmnrKysRKOBTs+OCdXxNdfig7ufcux6cRP/0fy9ZMf276UHLemn1Ot2bDicS3Z8D2jxQfnwzQx5E98vKoXs2KS7xlDCh29mSN0Ou0OI71Ecm7QhszucuFR2jfX4pG7H1z8dJPvupHUj5cM3M6RuR9OQOLJjW61VVFE/fDND6nYMXplKdny9Zu8mf/hmhtTtaDN8wy9639ybA/4IttygLqASdIvIycmBzWZDYqKvCFBYWBiaNGli+m/q1auHxYsX+/xs8eLFqF+/vt95ysrKUFxc7BkulyuoTkKpOMsxUl28SZ7cIeUYnyzgTfIA7w4pxzjJnOTJhysc48sY3n5KwPtwhWPkunmTPPlwhWOErORN8m7c8D5c4RjFhBUWZsiHKxxjdBxvkndJt0NKPRoNdOIaYfuKGfLhCseYtIk3ydM/XKEeTUNo21fMkA9XOMYswgoLM+TDlV86qF0XqotK0AMPlaBbhEzQk5J8S4dHjRqFpk2bmv6bevXqISoqyudnixYtQoMGDfzOExoaCpvNVmUEy0kYvScbXSftwKuTtpOO/ktScJ35qXR+SRl6z9lNfmxvTNmJHcd5hbgAYF7iaZbv7uufDpIqxZuRU3QFPWclkx/bm1MT2e2QANF+QX1sr07ajpCVaezf3ekLl9Fj5i7yY3trWhIOuXhF1ABgYvwxlu+OUn/BH8fOl6D7jCTyY3t7ehJ7fz0g+nA5vrvxG4+xH1uqy423ptF/dz1m7mKvygGAobFpLN8dpXOIP/aevoi/Tk0kP7aes5LhKuTVRqisrMQ3Sw/94vfcj1mrwh8qQQ88VIJuEVwl7sG+g65QKBQKhUKhUCjMUQl64KESdAtp164dPv30U5+fNW/e/D+KxP3pT3/y+VmXLl2USJxCoVAoFAqFQqH42ajcIPBQCbqFSJu12bNnIz09HV988QXuuOMOZGUJj9b33nvPJ1lPTEzELbfcgoiICGRkZCAiIuJn26y53W7YbDa4XC6fnXU11FBDDTXUUEMNNdRQI7iGrK51u3m1lBT+UQm6xUyZMgV2ux3169dH27ZtkZDg9VLs2LEjevfu7fP6pUuXomnTpqhXrx6aNWuG5cuX/6z55EmohhpqqKGGGmqooYYaaqhhs4nNO0VgoBL0IOPGjRtwuVxwu90B88RO7earcbOhYkWN6g4VK2pUZ6g4UaO6Q8WKGtUddTVW3G43XC4XbtzgdWdQ+Ecl6ArLKC5WPS+K6qFiRVFdVKwoqoOKE0V1UbGiqC4qVhS1hUrQFZahFjJFdVGxoqguKlYU1UHFiaK6qFhRVBcVK4raQiXoCstQC5miuqhYUVQXFSuK6qDiRFFdVKwoqouKFUVtoRJ0hWWUlZUhNDQUZWVlVr8VRYCjYkVRXVSsKKqDihNFdVGxoqguKlYUtYVK0BUKhUKhUCgUCoVCoQgAVIKuUCgUCoVCoVAoFApFAKASdIVCoVAoFAqFQqFQKAIAlaArFAqFQqFQKBQKhUIRAKgEXWEZU6ZMQaNGjdCgQQO0bdsW27dvt/otKSwkNDQUNpvNZ9xzzz2e31dWViI0NBT33XcfbrvtNnTs2BGHDx+28B0ruEhISEDXrl1x3333wWazYeXKlT6/r05sFBYWomfPnrjrrrtw1113oWfPnigqKuI8DAUDN4uV3r17V1ln2rdv7/OasrIy9OvXD3fffTduv/12vPbaa3C5XJyHoSAmPDwcTzzxBP73f/8Xv/3tb/H666/j6NGjPq+pThxkZ2eja9euuP3223H33Xfj888/R3l5OeehKAipTpx07NixyprSvXt3n9eo64/i56ISdIUlREdHo169eoiMjER6ejoGDBiAO+64A9nZ2Va/NYVFhIaGokWLFsjNzfWM/Px8z+8jIiJw5513Yvny5UhLS0P37t1x3333oaSkxMJ3reAgLi4OgwcPxvLly02TrurERpcuXdCyZUskJSUhKSkJLVu2RNeuXbkPRUHMzWKld+/e6NKli886c/HiRZ/X9O3bF7/73e8QHx+PlJQUdOrUCW3atMH169c5D0VBSOfOnTF37lwcPnwYBw8exKuvvoo//OEPuHz5suc1N4uD69evo2XLlujUqRNSUlIQHx+P+++/H/369bPqsBS1THXipGPHjujTp4/PmuJ2u33+jrr+KH4uKkFXWEK7du3Qt29fn581a9YMAwcOtOgdKawmNDQUbdq0Mf1dZWUl7r33XkRERHh+VlZWhoYNG2L69Olcb1ERABiTrurERnp6Omw2G5KTkz2v2bVrF2w2W5XdEMV/D/4S9Ndff93vv3G73ahXrx6io6M9P8vJycGvfvUrrF+/nuy9KqwlPz8fNpsNCQkJAKoXB3FxcfjVr36FnJwcz2uWLFmCBg0aKB/s/1KMcQKIBH3AgAF+/426/ih+CSpBV7BTXl6OW265BStWrPD5ef/+/dGhQweL3pXCakJDQ3H77bfjvvvuQ6NGjdC9e3dkZmYCADIzM2Gz2ZCSkuLzb7p164ZevXpZ8XYVFmFMuqoTG7Nnz0bDhg2r/K2GDRtizpw5tG9YYRn+EvSGDRvit7/9LRo3boyPPvoIeXl5nt9v3rwZNpsNhYWFPv+udevWGDp0KMv7VvBz4sQJ2Gw2pKWlAaheHAwZMgStW7f2+X1hYSFsNhu2bNnC88YVrBjjBBAJ+m9+8xvcfffdeOSRR/DVV1/5VG+p64/il6ASdAU7OTk5sNlsSExM9Pl5WFgYmjRpYtG7UlhNXFwcli1bhtTUVMTHx6Njx4645557UFBQgMTERNhsNp+dCgDo06cPXnnlFYvescIKjElXdWIjLCwMjRs3rvK3GjdujPDwcNo3rLAMswQ9OjoaTqcTaWlpWL16Ndq0aYMWLVqgrKwMALB48WLUr1+/yt96+eWX8fHHH7O8bwUvlZWVeO211/Dss896fladOOjTpw9efvnlKq+pX78+oqKi6N6wwhLM4gQAZs6cifj4eKSlpWHJkiVo1KgRXnrpJc/v1fVH8UtQCXqQcePGDbhcLrjdbhQXF1syjh49CpvNhvj4eJ+fh4SE4OGHH7bsfakRWOPcuXP47W9/i7CwMGzcuBE2mw3Hjh3zeU2vXr3w4osvWv5e1eAbNpsNixcv9vx/dWJjyJAheOihh6r8rQcffBChoaGWH5MaPLFiNo4dO4Zbb70VCxcuRHFxMSIjI1GvXr0qr3v++efxwQcfWH5MatT++Oijj/D73/8e6enpnp9VJw569+6NF154ocprbr31VsyePdvy41KDPk7MxrZt2zxl8MXFdeP643a74XK5cOPGDavTFIWGStCDDJfLVUVtUg011FBDDTXUUEMNNdQI3qHcKgIHlaAHGW6323MSWv3ErqCgAFFRUSgoKLD8vagR2EPFiho/Z6h4UaO6Q8WKGtUdKlbUqO6oa7EiN++M6vMK61AJepBRXCzK/oqLrVcYraioQGxsLCoqKqx+K4oAR8WK4ueg4kVRXVSsKKqLihVFdalrsRJIuYFCoBL0ICOQTsIeM5PQKmQNnhi5EY+PjMfjIzfisREb8ejwDWgzfANaD9uAVqHr0Sp0PVoPE//fZvgGPKqNx0ZsRNsRG/H4SDni8cQoMTp9txV7T1+8+ZuoZcZvPIZ2YfHk42/TElFafo312K5WXEf3GUksxzc6LsNnbo6LXarLjc4TE/BMxGbS8cK4rdh6NO/mb6iWmZ90Gs+N2UJ+fG9OTUTBpTLWY7txoxIfztvrjaFR8WgdsgbtRsWjfdgmn/FUuO/4o2E8PXrzfxyDVqSyHhsAnLpwGV0n7SD/7p7/bitWHcy5+RuqZZbtc+Hp0ZvJ15XOExNw+sJln7k51pavfjpo+n5qOzY/W7wflZWVZMdhRl7JVbwxZWeVWHp2TNXx3JgtPqPDWN/R0TCe/26rZ7wwbiuW7M5mPTYAiD9yHs+N2eK7rmjfnb/v6j99R/I1T4V7v/d2YfF4cfw2pLr4dy8j1mWQryvPRGxGr9m7UX6Nt7/5Utk1vDk18abnXU3PvWciNmPylhM+c6sEXVFTVIIeZATSSdh5wjbYHU6yMXz1EfZjemzERtJj0o/EkxdYj21fViHbsT0yZJ3P3BwXu4h1GWzH139Jys3fUC3z0nja800/VjMneVkFl9mOze5w4mrFddbji9yeyXZs70Ym3/wN1TLdZySxHd/cnad85qZeWy6VXWONTVdhKclx+GNlylm2Y+vy/XbWYwOAzxbvZzu+cRv4PbGbDI5jO76DZ4pYj2378Xy2Y3tiVLzP3CpBV9QUlaAHGYF0EmbkFGHy4lgcyr6I9HPFOJpbgmPnS3D8fAlO5JXgZP4lZOZfwkltnMi7hBN54vfHz4vXHs0tQUZuMdLPiXEkpxghK9NgdzgxcDn/TlezkHWwO5zYnHEeaWfdJEMmWpszzrMe284TF2B3ONFx7BayY5MX1AcGOn12gjgudqGrDsPucOKrnw7iwJkikiEfAvSZv5fsOPzxTMRm2B1OxOw9Q3Z8b05N9MzBSUZuMewOJ9oM34C0s24cyCrA5MWxOJBVYBpnqS7fcchVVGUcPOM79md7H1AVXi5nPb4fNx+H3eHER/P3kn1307adhN3hxJtTE2/+hmqZbpN3wu5wYvaOU2Rry4fz9sDucGLq1pM+c1OvLfklZZ64qc77/CWxefBMEVoOXQ+7w4kTeSU3f1O1SNTubNgdTrw1PckTSynZhT5jv27sy9KPiz5j72nv2KMbC5JOw+5w4vnvtrIeGwD8Y66Im/Ebj5muK/6+K+P3c0D7r/x9qsv7nf8r5iDsDidGruHdVLhxo9ITmwnH8snWlqdHi2vPrswC1uPbcDgXdocTnScmkJ17cannYHc40XLoep+5VYKuqCkqQa8FQkNDqygh3nPPPZ7fV1ZWIjQ0FPfddx9uu+02dOzYEYcPH/b5G4WFhejZsyfuuusu3HXXXejZsyeKinyfNqampqJDhw647bbbcP/992P48OE/u5wtkE5CqgVsRoK40fwy+kCt/t2bUVlZiUYDxcUur+Qq2Tx/myaSoLWp58jmMGNT+nnYHU50+3EH2Rzu0grPDYO+HI7jYjdw+SHYHU5M2nScbI6l+1ywO5x4b/Zusjn88fjIeNgdTqSfozv3P1mwD3aHEwuSTpPNYcaBM0WwO5x4evRmAHTx8tC3a2F3OHHOfaVW/+7N+G79UdgdToSuOnzzF/9CthzNg93hxJ9/4N+l7DwxAXaHEzuO01UFDVqRCrvDiQkbj/n8nHptOXOxFHaHE01D4kj+vqRdWLznIQAnc3aegt3hxD8X7yebI9Xlht3hRPuwTWRz+OPvkbtgdzgRe+AsWayM33gMdocTg1fybipcKb/uud5eLqNrmfvT99thdzjZW7tWHcyB3eHEOzN2kc2RU3QFdocTDw9a6/NzlaAraopK0GuB0NBQtGjRArm5uZ6Rn5/v+X1ERATuvPNOLF++HGlpaejevTvuu+8+lJR4n3R36dIFLVu2RFJSEpKSktCyZUt07drV8/vi4mLcc889eOedd5CWlobly5fjzjvvxLhx437Wew2kk5BqAZuvPW3vu3Bfrf7dm3G1wnuxK7lKtyj3nJUMu8OJZft47TDWHBIXu7enJ5HNUXbN+xm6r3g/Q46L3RfRB2B3OBG5PZNsDuehc57dJm7kDpuxB7c2kZ/hzAS6z9CMpJMFsDuceHH8NgB08SI/w1OEn6EZI9ccgd3hrKLNUJvsyhSf4QvjtnoXUQAAIABJREFUtpLN4Y8OY7fA7nBiXxadboj8DMPXpvv8nHptOX6+BHaHE48O30Dy9yUdtc+QW3tl6lbxQPzrnw6SzSE/wzbEn6EZf5kiqjvWH84lixX5Gf4rhu4zNKPwcrnnenv9Bp12gaysWpeWSzaHGTF7zsDucOKDuXvI5tB/hteu824q1CaBlBsoBCpBrwVCQ0PRpk0b099VVlbi3nvvRUREhOdnZWVlaNiwIaZPnw4ASE9Ph81mQ3Kyt/dv165dsNlsOHpU9CRNnToVDRs2RFmZV3xp9OjRuP/++3/WLnognYRUC5hclN+fw7tLqd/9rbhOJ4by0fy9sDucWJScRTaHGXL3txfh7q9PFUKxtwqB42Ln2f3dRfe5yiqE1wirEPwhd39z3XTVHbIK4QfCKgQz5O7vq5PE7i9VvMgqhCM5vOun3P2dGH/s5i/+hRirEDjh2P2VVQhDY9N8fk69tsjd36fCaXd/ZRXC9uP5N39xLSJ3f0NWpt38xb8QWYXQZDBtFYIZcvd327F8sliRVQifEVYhmCF3fxsPov1cZRXCypSzpPMYkZs1ny6i26zRVyFc0lUhqARdUVNUgl4LhIaG4vbbb8d9992HRo0aoXv37sjMFDtImZmZsNlsSEnxFYXq1q0bevXqBQCYPXs2GjZsWOXvNmzYEHPmzAEAvPfee+jWrZvP71NSUmCz2XDq1Kkq/9YfgXQSUi1gHGVNZpwvvgq7w4mHvl178xfXgM+jUmB3ODFrR/W/99pg4a4s2B1OfLKAtjKh+RDRx59d4BU74rjY9Z6zG3aHEz8R9k8nan38L0/YRjaHGRXXb3huIopK6fqnZR//mHV0O71mrEsTlQl/myb6p6niRfbx788urNW/ezNkj+q0bSdv/uJfiOzjbztiI9kc/mg9bAPsDidO5l8im2PylhOwO5z4Zukhn59Try17Tl+E3eFEJ+L+adnHv/EIrzZJ+Np02B1OjHLS9U/r+/i5Veo7jdsKu8OJ3acuksXKEq2P/8N5dDu9ZmTmXxL906Hrb/7iGiD7+LlV+D3tjjF07Y76Pv4LOvcSlaAraopK0GuBuLg4LFu2DKmpqYiPj0fHjh1xzz33oKCgAImJibDZbMjJ8VU17tOnD1555RUAQFhYGBo3blzl7zZu3Bjh4eEAgJdffhl9+vTx+X1OTg5sNhuSkvyXy5aVlaG4uNgzXC4XbDYbCgoKUFFRYekoLS1FbGwsSktLa/Xvxh066+mV5jyeE7lip+SRoetI5/kqRpQR/xB/lPX4pm8VQlWfL95POs+jw8XN+mHXRfJY0Y+3tN7+2P1nyObYfVKI4D0TsZn1u7tYcsX7lL/0Ktk84c4j2i5lKuvxLd0jHh79feYu0nh5UbtZTziay3p8fReIqpnZ20+SzXHivFi/mg+hXb/MRmNNSTorv5hsjhnbRIL+z0X7fH5OvbZsThcPjzpPTCD9DN+eLtavFfuyWb+7wStE1czYdelkcxRe8q5fJYTrl9l4KnyTeCh3+gJZrCzdKxL0HjOSWI/tYLZoa3lyVDzpPJ8uFOtXZMIJ1uMbv0GIsjqWHSSdRyrhn8rzrl8c9yy1OQoKClSCHmCoBJ2Ay5cv45577sH48eM9Cfq5c76CXh999BE6d+4MQCToTZo0qfJ3Hn74YYwePRqASNA//vhjn9+fPXsWNpsNu3b53yk2E7Cz2WyIiopCbGzsf+WImLcKdocTfxy+hnXeqYtjYXc40SKEdt6eE1bD7nCiz6TVrMf32WTxub4znnbeNkPWiAcQi3jjpsNIMe+oOavI5pisxUgr4hgxjgU/iXkbOdZg5Uq6efr+KGKkB3GMGMc3M8S8r0bQzvvsCBEjYXPpYsRs/DlCnPOOGXTzzmeKEeNYsTLWk3wtWko3z9fTRYx0JY4R4xg5R8zbcSTtOd9ltIiRgTN5Y/PtcWLef06hm3e5LkYWE8aI2XhksDjnp0XRzTF8toiR50fxXhcmLhSfa9uhtPO+pcVIP8IYMRsf/iDm7fU97TnffJCIkemEMUI9oqKiVIIeYKgEnYiXXnoJffv2tbzEPRh30JNOiH7UDmO2sB7Pnkxtd3T0JtJ5Rq4RZcQjVqexHl/EWrE7OmQl7e5op++E2NHO4+fJY0U/Xpkg7Ou2ZdDtjh47V+QpKeT87k7lifLlZiFxpPNM3SKqLAZE0VZZGMfMBLE7+pm2O0oVL3+dKsqIV6XQVVmYjR6aT/hywt3RguJSTxJ0+UoZ27G5L3t3R92Xr5DNE7NbVFm8G7nL5+fUa8vyfdlayxXt7ujH80UZ8dwddFUWZuOfi4R2x0zi3VGpoZF9oYT1+JqFiN3RzDw3WaxsOiKqLLoQV1kYR8JRYUP28vhtpPN8u1y06IxbT1dlYTaGrBTaHRFrj5DOIzU0DmR576vVDrqipqgEnYCysjL87ne/89ig3XvvvRgzZozn9+Xl5aYicbt3e8W3kpOTq4jE/d///R/Ky739oxEREUokzgSrLFmMStJUWGXJMoJBSRowt2ShihU9HErS/ixZqOFSkrbKQWHKVpGgSyVpqnixykFBryRNhT8HBWou6lSQbxAqSXscFKb5toRRry0cStKA10FhRgKdToEZUrR0cTJtf7EVDgpG61SqWJEOCp2YHRQ4rFMB/w4K1HBYpwJeB4U9OgcFjnuW2iSQcgOFQCXotcBXX32Fbdu24dSpU0hOTkbXrl1x5513IitLqEFHRESgYcOGWLFiBdLS0tCjRw9Tm7XWrVtj165d2LVrF1q1auVjs+Z2u3HPPfegR48eSEtLw4oVK3DXXXcpmzUTTuRZY8liVJKmQlqyfEVoa2OGVJL+Pp72YmdmycJxseNQkr7ox5KFGi4laascFORDqyGaQjdVvFjloKBXkqbCn4MCNR4laWKF7s0Z5g4K1GsLh5I0YJ2DgnxotXw/7UMrKxwU9A+tSq5WkMXKQYscFLhsP/05KFDDZftp5qCgEnRFTVEJei0gfc3r1auH+++/H2+++SaOHPEqmlZWViI0NBT33nsvGjRogA4dOiAtzXehunjxIt59913ceeeduPPOO/Huu++iqKjI5zWpqal47rnn0KBBA9x7770YNmzYz1Y0DaSTkGoBs8qSJS7VV0maCqssWb7UxOmmEypJAzC1ZOG42LUKFTs0lErS/ixZqNl9ikdJ2ioHhTBNSTpM26GhiherHBQ6fedVkqbEzEGBmpOaknQrYiVp6aDwkqHCiXptmb6NXkkaAIattsZB4W+auGZc6rmbv7gGPDuG30HBaJ1KFStHc8WmwmPMDgoc1qmAfwcFajisUwHgdRMHBZWgK2qKStCDjEA6CakWsAuXvJYslCWTRlakiItdz1nJN39xDYiyyJLls0X7YXc4MS/xNOk8ZpYsHBc7qSR9tugK2Rz+LFmoSTgm9BG6fE9b3bHhsOhpfH3yTtJ5jAyJTYPd4cT4DaIliCpe/r1U9FJO3nKiVv/uzfijpiR9yFV08xfXgMdGbITd4cTR3JKbv7iWOJwjqjueHBVPOs++rELYHU48O8Z3l5J6bfk+XugyfLuCtiUpYp1QrB62+jDpPEa6TtoBu8OJLRl5N39xDXhpvNAISTxxgXQePdI69UHNOpUqVrIKLsPuEA4KnEjr1I8X7CWdJ3J7JuwOJz6PSrn5i2sRDutUAOiuaYSsOuh1a1IJuqKmqAQ9yAikk5BqAbtUds2TBF0pv16rf/s/sThZJM4fzae92K1MOauJHdE+CDDygZY4x+yhvdh9tlg8CJi707tLSX2x0yfOBcSJs7RkcRXy7VLKxPmNKbSJ8/bj4kFA54kJpPMY+fonkThP2SoSZ6p4Gao9CBinPQjgQibOx87TJs5Pjxa7lAfP0D4I0LMvS1R3dBi7hXSeIzlCKPEJw4MA6rVFJs4j1tD5hAPAD5vEg4CBy3m1STyJ80naxFk+CNicwefzfvqCSJxbDBXVHVSxkqc9CHhgIK/Pu0yc+y+hTZwXJYsHAX2I742MvD1dJM5rDuXc/MU14H3tQUCM7kGAStAVNUUl6EFGIJ2EVAvYtes3PMlW4eXym/+DWmL2DlF63o/4KfG6NFFK/+ZU2lJ6Iz1mitLz2ANnb/7iGvCvGJFsTd3qLaWnvtiVlnsf6pSW05aetx4mfN5P5PHtUsYeEA91esykLT3fc1okWx2Jky0j/bTS89la6TlVvIRrpfQjiZMtI81CROn5mYu0D3U6aT7vuzILSOfRs1MrPX9lAu1DnUytlL7lUN9Seuq1JXSVKD0fu5629HxGgiil/yKatpTeyDMR4qFOCnHp+VvTRLK1lriUXk9Grnio8/hIUXpOFSvuK95S+rJrfJsKP24WD3Ucy2hLz5ft46kuNNJNKz2PP0L7UKfvQlFKPz/ptOdnKkFX1BSVoAcZgXQSUi5gDw8Slizn3HTlykaMStJUSDG6P/9AW65shENJGvCK0U3YeMzzM+qLHZeSNMAjRmeES0naKgcFo5I0VbxY4aBgVJKmxMxBgRouJelzbnMHBeq1hUtJ2ioHBSneln6O9p7CCgeFAwbxNqpYKb/m3VTgdFCQ4m2hq2jbIvw5KFAjxdt2HKet7jBzUFAJuqKmqAQ9yAikk5ByAZOWLJmEgl9Gxm8QF7shxEql0pLlBWZLli7azXsCoZI0oLNkifNaslBf7DxK0oPohQWlJcve07SCX3rmJYqb988W0QoLWuWgIG/eV6SIm3eqeLHCQeFqha+SNCVmDgrUrDkkhAXfJlaSLvTjoEC9tgxYIqo7IrfTKknH7LXGQaGFdq09TWx/1scCBwWjdSpVrFRWVuIB7SHceUYHBS7rVH8OCtRwWKcCwMDlYlNB76CgEnRFTVEJepARSCch5QL2xCh+SxajkjQVxqf6XHApSZtZslBf7LiUpAFzSxZquJSkrXJQMCpJU8WLFQ4KRiVpSswcFKjhUpL256BAvbZwKUlLB4XuM3h3KR/6VlSr5bppE0vpoED9oEOP0TqVMlakg0JWAZ/Pu6xWmxh/7OYvrgH+HBSo4apWkw4KEToHBZWgK2qKStCDjEA6CSkXMGnJsi+Lz5LFqCRNhbRkactsyfKUpiSd6qK92JlZslBf7LiUpAFzSxZquJSkrXJQeHWSqO7YopVmU8XLEgscFIxK0pR8OK+qgwI1CzQl6U8W0JZm+3NQoF5buJSkNx4Ru5ScDgoVOr2XolJavRcrHBSM1qmUsdLWAgcFqfcyjdg6dX+2uYMCNV69F9pKyjEmDgoqQVfUFJWgBxmBdBJSLmBWWLIYlaSpsMqS5dHh4mJ3nFhJ2syShfpix6UkDZhbslAzOo5HSdoqB4UXtfM96aQQN6OKF+mg8PdIPp93o5I0JWYOCtTI830AsZI04HVQ0IvtUa8tXErSVjgolFz1VndcraA9361wUDBap1LGinRQOMDooMBlnerPQYEaDutUQO+gwLepUNsEUm6gEKgEPcgIpJOQcgF77Ud+SxajkjQV5y2yZOFSkpberHpLFuqLHZeSNODdUYsh3lHTw6UkbZWDglFJmiperHBQMCpJU2LmoEANl5I0ALQZXtVBgXpt4VKStsJBIb9EVMw0YrgWWeGgEOWpmBHXIspYecECB4V/aNap0XtoK2b8OShQwmmdauagoBJ0RU1RCXqQEUgnIeUCJi1ZnIf4LFk+nCdEbKKIy0P1lizl12h7UiWVld6LXX4J7cVOWrK8p+tJpb7YcSlJA15LlgU6SxZqHMuEkvSPm2mVpAFrHBQeHynKQzNyxbpGFS9bLXBQ4NScGLyyqoMCNWPXi+oOaiVpAGgftqlKTyr12vLKBB4l6bSz/A4KUnOiWQh9NdcECxwUjNaplLHy5x9823Q4kJoT1Nap/hwUKOG0Tl1g4qCgEnRFTVEJepARSCch5QL23myxS8lpyWJUkqai7JpX7IjLkoVTSdrMkoX6YselJA2YW7JQw6UkDVjjoGBUkqaKF+mg0InRQcGoJE2Jx0GBWOhSD5eSNOB1UNijc1CgXlu4lKSlg0LrYXwOCsfPizkfZXBtsMJBwWidShkrXgcFvk0FLutUfw4KlHBap0oHhd5z+DYVaptAyg0UApWgBxmBdBJSLmDSkmUhsXKuHqOSNBV6S5Y8JkuWolLvxY5aSdrMkoX6YselJA2YW7JQw6UkDVjjoPCgQUmaKl4OWuCgYFSSpsTMQYGab5mUpAFzBwXqtYVLSdpVyO+gkOoSu/ZPhdPv2lvhoGC0TqWMlXcjxQN+TgeFP2nWqduIrVP9OShQwmmdutrEQUEl6IqaohL0ICOQTkLKBcwKSxajkjQl0pIlu4C2H1yS6xZ97w8xKElLS5aXJ3h3DKkvdlJJ+uMFe2/+4hoiLVnGrKPfMZT00ipKljJUlEgHhf3ZPA4KeiVpd6mID6p4scJBwagkTYmZgwI1X8aIipLpxErSgNdBYYNux5B6bWkVKqo7ThJXlFjhoLD7lOh77/TdVvK5rHBQMFqnUsaKdFCgbpHTw2Wd6s9BgRJO61QzBwWVoCtqikrQg4xAOgkpF7BvloqeW05LFqOSNCWPMVuycCpJ78uqaslCfbHjVJKOMLFkoYZLSRrgd1AwU5KmihcrHBSMStKUmDkoUMOlJA0A78wQPbd6BwXqtYVLSdoKB4WEY0I5vsv39NUdVjgoGK1TKWPln5qDwhxGB4U/ataph1z0yvFmDgqUcFqnmjkoqARdUVNUgh5kBNJJSLmASUuW79bzWbJIm5QUhp1DOddBJkuW9HNSSZr+YmdmyUJ9seNUkvZasvCJHXXTXA2olaQBfgeFvBJR3aFXkqaKlzwLHBSMStKULEqu6qBAzQeaknTMHnpXg/dNHBQo1xZOJWkrHBQ2HM6F3eHEG1PovdfXpYm5OB0UjNaplLHy1U/8DgryQf8xYutUwNxBgRJpnfrcGHpXg70mDgoqQVfUFJWgBxmBdBJSLmDhcfyWLEYlaUo6MVuypGSLXe1nIuh7b80sWagvdpxK0maWLNRIJemdDLva3A4KZkrSVPGid1Aou8azS2lUkqbEzEGBmh4zeZSkAa+DwnydgwLl2sKpJA14HRRyiHfrJbEHxK52j5n0u9pWOCgYrVMpY0U6KIxndFDgsk4FzB0UKOG0TpUOCu3C+DYVaptAyg0UApWgBxmBdBJSLmDSkmXQCr5dSqOSNCXSkmUrkyULp5K0mSUL9cWOU0nazJKFGi4laYDfQcFMSZoqXsqv6frdmRwUjErSlJg5KFDDpSQNAF+aOChQri2cStIAv4NCzB6hXv3BXPq+cCscFKR16uJk0RdOGSujnLwOCpWVlWgkxWZL6MVmzRwUKOG0Tj2RJzYV9A4KKkFX1BSVoAcZgXQSUi5g0pLlXzF8lixSSfo8g7K615KF/qYWALZkiN2LrpPoL3ZmlizUFztOJWlpyfL+HL5dyic1ZfXDOfS7F9JBYVEyj4PCIZdQVv+jTkmaKl6scFCQStIhK+mV1c0cFKjpoilJJxArSQNeB4Xv470OCpRry1lGJWmA30FhXqJ42PjZInpldSscFIzWqZSxMs6gGE+N3jq1mNg6FTB3UKCE0zrVzEFBJeiKmqIS9CAjkE5CygVsLrMli5mSNCV/jxRloVyWLJxK0maWLNQXO04l6VUmlizUcClJA/wOCmZK0pTxIh0UsgroK2WAqkrSlEgHhZcYKmUkXErSADB8tdiljNA5KFDGCqeSNOB1UNiXxeOgMH2beBD+ZQx9u450UHiM0UHBaJ1KGSvSQeHfS3k2Fdyl3nYdautUwNxBgRJO61QzBwWVoCtqikrQg4xAOgkpFzBpyfIPhtI7ACg2UZKmRFqyLGGyZFm+n09J2syShfpix6kkbWbJQg2XkjTA76CwTVOS/pNOSZoyXtoyOygYlaQp2Z9d1UGBmqc0JelUF311xxgTBwXKWOFUkgaAlyfwOih8Hy8EL79laCXLLhC7lJwOCkbrVMpYmaVpTXA5KJzXBC8fZLBOBcwdFChZyGidetnEQUEl6IqaohL0ICOQTkLKBUyK13BZspgpSVPymWbJMpfJkmVxsnjg8RGTurO0ZHEVCvEa6oudVJKO3kP/wMPMkoWS67oHHhcZ1J2lg8I4hoQSANZrStJ/mcLjQcvtoGBUkqbEzEGBmkc1defjDErSXgcFr1sDZaxIJekOY+mVpAF+B4XRceKBxwgGMVYrHBSM1qmUsSIdFLiusZzWqYC5gwIlnNap+musdFBQCbqipqgEPcgIpJOQcgGTlix/YbB/AcyVpCn5VwyvJQunkjQAtB7ma8lCfbHjVJI2s2ShhFtJmttBwUxJmjJeXmB2UDAqSVNi5qBADaeS9MwEcdOud1CgjBVOJWmA30EhdNVh2B1OjF1PL65phYOC0TqVMlY4q9QAICNXWqfytAyYOShQwmmdCgCNB4lNBemgoBJ0RU1RCXqQEUgnIeUCJi1Z9GWvlBwzUZKmRFqyTGCyZOHujzNaslBf7DiVpKUlS/uwTTd/cS1QYNIfR4l0UBi8ksdBIXpP1XYWynjhdlAwKklTYuagQEllpXfnKb+E1iccMHdQoIyV+CN8StIAv4OCY5loZ5m06fjNX1xDrHBQMFqnUsbK2lReBwVpncolumfmoEAJp3UqALQM9XVQUAm6oqaoBD3ICKSTkHIBS2a2ZDFTkqZk5BpeS5bxzAqzRksW6osdp5L0iTzxMEdvyUKJR0l6MI+SNLeDgpmSNGW8eB0UeHYpjUrSlJg5KFCiV5IuYVCS/klzUOitc1CgjBVOJWnA66CwcBePg8KAJXyCkFY4KBitUyljhdMpBeC1TgW8Dgo/MDzMAXitUwGvg4J0SlEJuqKmqAS9DjJlyhQ0atQIDRo0QNu2bbF9e/V3iQPpJKRcwKQlC1fCbKYkTYm0ZBnKlDBze7QaLVmoL3acStJmliyUcCtJczsoTDNRkqaMl3cjRcLM5aBgVJKmRJ8wSwcFSopKvQ8EOJSkV5s4KFDGCqeSNAD0Z0yYAeCTBaJseQHTA4FHmB0UjNaplLGSeJLXQWGLVmX46iSeKkMzBwVKBjFapwLAc2PEpoJ0UFAJuqKmqAS9jhEdHY169eohMjIS6enpGDBgAO644w5kZ1ev/DGQTkLKBUyWnHNZspgpSVMiS86/WcrTXxWyUlOSZiqpl5YsG48IsSPqi51Ukj7kohf+MrNkoUSW1LcL4xH+kg4KH87jcVCYGC9K6gfplKQp44XbQcGjJJ1BX1KvLzmXDgqU5LqF8NdDTErS0kGh22QeQcEFjErSAL+DQi+tpH4pU0k9p4OCmXUqZaxIB4VnInhKzqV16l+n0lunAuYOCpRwWqcCVR0UVIKuqCkqQa9jtGvXDn379vX5WbNmzTBw4MBq/ftAOgkpFzBuSxYzJWlKpEIplyULp5I0AHSfIcSOpCUL9cWOU0nazJKFEm4laW4HBTMlacp4+afmoDCHyUHBqCRNjXRQ4BBt41aS3nFc7FLqHRQoY4VTSRrwOih8t57HQeHt6WKdXnOIxzpLirYdYHBQMLNOpYyV9HNStI3nQeqKFF5ROjMHBUo4rVMBoJvmoLApnWdTobYJpNxAIVAJeh2ivLwct9xyC1asWOHz8/79+6NDhw6m/6asrAzFxcWe4XK5YLPZUFBQgIqKCktHaWkpYmNjUVpaWut/++xFUdbbaKAT5eXl5MeybK/YNXxnRhLLZzc/Udz4fTRvD8t8n2kKrJEJJ1jm6zVblBFHJZ8mj5WKigo0CxFJSWaem/zYrpZ5y3rz3JfJ59uaIR4evTx+G8t35zzo8jys4pgvRBNMjIg74vkZZbx8GS3KiH/cdIzl+J4ZLao79mTms8zXRnNQSD9bSD5X6pmLWlKykeXYdp0QZb0dxmxhiZXvN4pWpH//dIDl+EatEarqw1elscz3mlbdsS71LMt8shVpx7Hz5HPlmNxDUMbK8dwiz8Mqjs9yYZJoRfrH3N0s803bKhL0/lH7Webrrd1DLN51imU+2Yq0KuUMeaxQjIKCApWgBxgqQa9D5OTkwGazITHRtyQpLCwMTZo0Mf03oaGhsNlsVUZUVBRiY2P/a8eSZbGeJGjZCvr5HDNWwe5w4s8Rq1mOb1CkmK9zOM98r0asFiX1M1axzNdtjJjvq+n0861c6Y2VBT/RH1tsbCweHLgGdocTc2Po5xo1R8RKh5FrWI5t9Fwx39PDeeZ7Z7yIlc8m88Tm3yeI+T75kefcaxEiYmXqYvq5YmNj0XqImO/HRfRzfb9QnHuPDeWJlcmLxXytQ3jm+2iSiJX3JvLEyic/ivn+PoFnvqeGiVgZM5/n3HtmhJhv9Fz6+WZHi1hp/C1PrMyLEfM9MJBnvi+miXX6L2N5YuWr6WK+bmN45nspTJwLQ2bxxGbncDHfoEie+Wp7REVFqQQ9wFAJeh1CJuhJSb6KsKNGjULTpk1N/02w7qBfvuLt871QTP8Ec/Z2IVTVd8Fels9uVcoZrX+MZ5eyx0xRyrh0TxbLfAOiRHna1C3HyWPlUulVT6xcLLnCcnzSkuXYuSLyuWL3i1h5a1oiy7HtPC76fDt9t4Vlvn6LRXXH9K3HPT+jjJcRq0UZ8cg1h1mO75GhQhjrRC59dUdFRQU6aGJHSSfyyOfaflTEygvjtrIcW0aO2KVsPcy7S0kZK8NWiVgJc/LEyuTNQo/hi+gUlvmeGyNKzpNP8lR3vKnZYa454CKf64hL9IQ/OnwDS6zku0s916HSq2Xkx/fjJhEr/4rhiZWoZOG20WtWMst8b0wWJedrD/JUd3ykaZPM25lJHisUQ+2gBx4qQa9D/JISdyOB1GdSUUHXo1NZWVlFgZUSMyVpSjZniBvb15j8df/KbC1ltGShjBVuJWnAa8lyJIf+PDSzlqJEOihw+et+vKCqtRRlvHA7KMh1LNfNYy1ldFCghNtaysxBgTJWvmVWkubjHZHOAAAgAElEQVR2UHjSYC1FDaeDgpl1KmWscFsOSuvUkJU865iZgwIl0jp1G4N1KlDVQYEyVigIpNxAIVAJeh2jXbt2+PTTT31+1rx5cyUSZwKnJYuZkjQliSd4LVk8StJH6ZWkAWDYatFLKS1ZKGOFW0kaqGrJQolUkv5kwT7yuQDgaC6vg4KZkjRlvEgHhX8vpfd5N1OSpsbooECJVJL+2zQeJekCEwcFyljhVpKWDgr/mMvjoNBKqwQ6mX+JZT7poBDF4KCQnFmgVQJt9fyMelNBxmZ+Cb2DQtjadFHdwWSdKh0UXp/MI6TLaZ0KeB0UftxMv6lAQSDlBgqBStDrGNJmbfbs2UhPT8cXX3yBO+64A1lZ1fMhDaSTkHoBk5YsGbn0xxoeJy52eiVpSqQly7NjeHYpXxgnLna7MnmUpI2WLJSxwq0kDVS1ZKFkZgKvkjS3g8JbJkrSlPEya4fYpeRwUCgxUZKm5p0Zu4TY0UF6Ze7l+3mVpM0cFChjhVtJmttBofEgIa55tugKy3ycDgpm1qnU9yxNQ/gcFIZoiv/jN/Ao/ps5KFDCaZ0KAKGrxKaCdFBQCbqipqgEvQ4yZcoU2O121K9fH23btkVCQvUXvEA6CakXME5LFrk4j12fQT4XABzJEZYsT4zisWTh/CwBvSWLqEigjBWvvQ3Pji8AvGawZKFkErO9TV7xVU3syInKSnqfd6O9DUAbL4uSRUVCn/n03tZ5JeKzbMT0WQLA+3NERULM3jPkcy1OFju+HzF8lgBw/YZ3l/Li5XIAtLHywVyx4xu9h37HFwDWpQnHhjcZvK3NPktqvtLsPqdupa9IMLNOpb5n4bT7lNapk7fwWKfuPS0cGzoy2X3Kz/IYw2cJeDdpRmqbNCpBV9QUlaAHGYF0ElIvYHLXl8M/2LHMt7yJmsx8YQHTkmnXl7MaAQBmJJzUxI5ETz9lrKRo1QjPRPBUIwDeXV/nIfqe/rHrRTVC6KrD5HMBvv7BZdfod31lNcJOXTUCZbxw7vqeuSiqEZqF8FQjAEBfzVJxftJp8rlkNUI/hmoEidz1zdF2fSljpcdMUY0Qe4C+Zxow3/WlorTcW41QWn6NfD4ACFmp7fpupO/pl9UIPWZ6qxGo71nkrm+qi76nv1+U6JmevYO+GgEA0s66YXc40S6MZ1OhWcg6tmoEoGqbo0rQFTVFJehBRiCdhNQLGGfftFEghJpz7iuwO5x4eBBP3zRnPz8ALEgSiq99F4q+acpYSTwpSu9eZOrnB4D3tL7pZbq+aSqGrz4Cu8OJ0XE81R3l13R901fob07M+vkp42Wt1jf91jR6saNj50U//6PDN5DPJfkyWvRNz0ig36Xk7OeXSAeFTK1vmjJW3tBUx9cfzq31v22Gp2963Fbyucz6+akZ5RRrWThD33T0nqr9/NT3LM9rfdN7TtP3TX84T4hrLk7mqe44kSc2FVoPo1/L9P38eSU84ppSKPhfMWItUwm6oqaoBD3ICKSTkHoB41QeN1OSpqTwsld5/Bqx8ji3Ij4AxGjK4+9ryuOUsSKVpF+dRL/rJOGMF6kk/X08T3VHZWUlHhjoZIsXMyVpyniRDgocyuNmStLUGB0UKJFK0kOYFPGBqvFCGSvcStKcDgpni8RD4sY6RXxqOB0UPIr4i7yK+NT3LDJeEhjipecsoYi/IoX+ITFg7qBABbciPlA1XlSCrqgpKkEPMgLpJKRewKQlC8cFyExJmhL9BehSGW15IfeOKFDVkoUyVriVpAHeigu5I8qlJA3wVly0NFGS5qi44HBQ2H1K9G3qlaSpkRUX0kGBErkjyqUkDVStuKCMFW4laVlxweGgIHdEW4XyiWtyVlwYd0QB+nsWWXGxgaHi4m/TxAZGXCqPdSpnxYW71NtmxWWdaqy4UAm6oqaoBD3ICKSTkHoBkyVcHJYsZkrSlOhLuC5corVk4e4pBqpasvy39BRLpCULh0DPp4v4eoolUrPgaC69QI+xpxigjRdOBwXZU9yFoadYYnRQoISzp1hi1CygjBVuJWlOBwXunmKA10HBzDqV+p6FU7PA0wKYwWOdauagQIW0Tn2Q0TrV6KCgEnRFTVEJepARSCch9QImLVk4RFDMlKSpaTKYx5JFqnJzKklvPy4SE2nJQhkr3ErSQFVLFkqkknTMHnpVbgmX6r8/JWke1X/6xMRMSZoao4MCJVKVe8pWHiVpoOpaTRkrnKrcAO9avS9LVHd0YFLlBnjXajPrVOp7Fs61+sXx4kEVh4gu4LtWFxKr/lthnWpcq1WCrqgpKkEPMgLpJKRewL5mvPkzU5Kmpo1283cij/bmj9vXGqhqyUIZK7MtUJI2WrJQIn2tuZSkAa+Dwq5M2ps/f7sylPFySrv543BQMFOSpmZmQibsDq+DAiWcvtYSo4MCZaxwK0lzVjtJX+tXJvD4WgO81U5mD1Gp71k4q53kQ9SU7MKbv7iWMKt2osAK61Sjg4JK0BU1RSXoQUYgnYTUCxhn+aS3r5Gn1xAA2oeJ8sm0s7SWLJx9jRJZPtk+TIhjUcaK7Gv8+ic+JWmz8kkqOPsaJX/+QZRPbiV2UPDX10gZL5wOCrKv8QOdkjQ1RgcFSjjbkCRGvRCqWLFCSZpTLyRea0PqNpmvuoPTQcHMOpX6nuXLGD69kMdHijak9HN894JGBwUqpHUqh1iixOigoBJ0RU1RCXqQEUgnIfUCxilAZKYkTQ2XJYtUBuZUkjZaslDGihVK0mYCRFR0npgAu4NHGVjC5aAglYGNStKU8VJUyuegMC9RJMt6JWlqftIcFHprDgqUcAp5SowOClSxYoWSNKfjxppDQsjz7en0ybJEOm5wOCiYCXlS37NwOm60GCqS5dMXeKxTAb77pKSTIlnmtE41Om6oBF1RU1SCHmQE0klIvYBxJl5mStLUyMRr+3HaxIvTW1ditGShjBUrlKQ9liyL6ROv55mVpAFv4rUyhbas3p+3LmW8cDooyAc5X8bQl5tLjA4KlHBaYUqMiRdVrOgf5HApSQN8DgryQU6v2fQPciScDgpmVpjU9ywj1ohr0eg4egcF+SAn181T3QFUdVCgwgrrVGOloUrQFTVFJehBRiCdhNQLGGfpMldvlZ7XJ4vS5Y1HaIXpjL1VHFwwlC5TxoqnFWIDvWCbxGjJQolUkk518VV3cJUu+1OSpowXfelyfgmtgwJnK4TE6KBAiUdJmrgVQo+xdJkqVqxQkgb4HBQW7MqC3eHEJwvoWyEksnT5mQj60uX3TKxTqe9Zxq4XDgqhq2gdFCqu61ohSvkSSKnVk0is1WOFdeqZi2JToVmI0OpRCbqipqgEPcgIpJOQegHjEv/ypyRNjRT/WnWQ1tptXZpQJ31zKt/Fzij+RRkrnGKCEqMlCyVtmJWkAT7xLykmaFSSpl5bmobwOCiMjhM37CMYxAQlUvxLOihQIsUEuZSkgariX1SxYoWSNMDnoCDFBAcs4RPX5HRQMIoJAvTryiSPg8Ihkr8vKdGJCV6t4LFOBfjcbqywTs0r8XVQUAm6oqaoBD3ICKSTkHoB47Jk0SeTpeW0Ja963p8jnvDH7KW1ZOFMJiVGSxbKWOG045Nw2mdxJZN6pH3W1K20Ykf+kknqtYXLQUEmk2PX05e8SowOCpRwJZN6jA89qGLFCiVpgM9BgSuZ1MPpoGCWTFKvK5HbeR56GJNJLsweelAg7/0+nMdnnWp0UFAJuqKmqAQ9yAikk5B6AeN6iupPSZqavgt5LFmW7OYrx9bz8CDRI3fOfYU0VqxQkuZqG+Asx9bD5aCw0Y+SNPXawtU2YKYkTY3RQYESWY6dkct3PTK2DVDFCmc5th6utgGucmw9sm3gIYa2ATPrVOp1hattwFiOzYVsG1i2j1YU0grrVGPbgErQFTVFJehBRiCdhNQLGFcfkj8laWq+jBaWLDMSaHcpOQXN9OgtWShjxQolaS7hPSuUpAGv8F44sfCeP0Ez6rWFy0HBTEmaGn/CexRwCZrpMTooUMWKFDTjVJIG+IT3hq/mEzSTcDoomAmaUa8rS/eJTQVqBwUpaPbocPpzXI+Z8B4FVlinAvBxUFAJuqKmqAQ9yAikk5B6AeNS8pQ3tK1CeXsNBy4Xliw/bKLdXeO0BNPzhGbJciSnmDRW5A1tXCqfkrTRkoUKq5SkuRwU/FmCUa8tXb4Xu5TUDgryhnYB8Q2tHqODAhWclmB6jNZ1VLFihZI0wOegwGkJJuF0UHjCxBKMel3hsq6T15+nGK1TAb4HjvL6E7KSzzoV8FrXZRVcVgm6osaoBD3ICKSTkHoB4/LC9KckTY3cwYhYR7uDMWGjKAkdvJJPSRrw3cGgjBUrlKSNlixUnHNfYSsJ1SN3MP69lPahzoKk06YlodRryxtThIPChsO5JH9f0stESZoarpad8mvWKEkbHRSoYsUKJWmAr2VHVnBN30ZbwaWnsrISjQbytOzoK7gk1OtKvJ+Wndpm9ymhM9Hpu62k8xjhatkJW5sOu4PXOhUAHh/pbdlRCbqipqgEPcgIpJOQegHj6gH0pyRNzZh1ogdw2GraHsDwOHGxG8moJA34WrJQxooVStKyB7D5ENoeQE5RJT2ztB7Az4l7AKWS9BfRvj7h1GsLl4OCFFVac4h2Hj1GBwUqjKJKXBhFL6lixQolaYDPQeHTRTwaKEa4RC/NrFOp15WdJ0RbxCsTaB0UpAZKF0brVKCqgwIVVlinAr6ilypBV9QUlaAHGYF0ElIvYFwqupy2RHp+8Kjo0u5sD41NY7moGnlNU9HdnHGeNFbkRTUlu/DmL64luFR0OW2J9HA5KPzgR0maem35YO4e2B1OxOyhdVDgsiXSY3RQoCKv2BolaaODAlWsWKEkDXhtI6kdFLjOASOPMthG+rNOpV5X9mXxPOzndBHRw/Ww3wrrVAB4cfw2z8N+laAraopK0IOMQDoJqRcwLh9af0rS1PjbPaxtvlkqytImb+G92OktWShjRV+WxgXX7uF+i5SkuXYP/VWRUK8tXLuHZkrSHJjtHtY22QU8VSRGjA4KVLFihZI0wOegIKtIYg/Q9rob4XBQ8FdFQr2uHM7haZeTVSQ9ZvJZpwJVHRSosMI6FfBtl1MJuqKmqAQ9yAikk5B6AZOWLA8S999KJWlqYRcjsv+270JaSxYrlKQBX0sWyliRStKnL/ApSRstWaiQStIvMStJy/7bt6bRnhP+dBio15YvY3gcFLw6DLRq8UbM+m9rGy4dBiPG/luqWLFKSZrLQYFLh8FIJwYHhQt+dBio15WT+TyCs1KH4QNm61QuwVmpw7A4mc86FQD+Ns3roKASdEVNUQl6kBFIJyH1AsalYO1PSZoarnn7zOexRjEiFawXJWeRxYpVStIAWObdnCGqO7pO2kE2hxlSwZp6XulkYFSSpl5buBSsnzRRkuaAY96DZ3icDIwYHRSoYoXLycCqeTtPTIDd4UTCMVonAyPSQYFyXn/WqdTrytmiK6bz1jZGJwMuuObtOYvfOtU4r0rQFTVFJehBRiCdhNQLGJcHtD8laWr8eUDXNvqdbE70O/dUsWKVkjTga8lCxVqLlKS5du6lkrRxJ5t6beFyUJA72ScJd7LNMPOArm2SM4XLRqdxW8nmMOO4YeeeKlbkTja3kjSXg8Lz2k727lO81R0cO/fSOrX1MF+fcOp15eJl76bCdUIHBbmT/WUMbXucEaODAhVWWKcCvg4KKkFX1BSVoNcCdrsdNpvNZzgcDp/XZGdno2vXrrj99ttx99134/PPP0d5ua8Az7Zt29C2bVs0aNAADzzwAKZNm1ZlrilTpqBRo0Zo0KAB2rZti+3bf54KZyCdhNQLmN6SJa+EbpdS9oIPWMLbayh7318n7n1/a5q3F5wTfe87Vazoe8GvVvApSQM8ve9WKUlzOSj0XWjeC069toxdz+OgIHvBzxL2gpuhd1CgYuvRPJ9ecC6kg0KzENH7ThUrVilJz2ZyUODoBTejx0z63nd/1qnU60ppubf3vbSczudd9oJ/S9wLbsTooECFpxc8g886FQD6RaV4et9Vgq6oKSpBrwXsdjtGjBiB3Nxcz7h0ybvjcf36dbRs2RKdOnVCSkoK4uPjcf/996Nfv36e15w6dQq33347BgwYgPT0dERGRqJevXpYtmyZ5zXR0dGoV68eIiMjkZ6ejgEDBuCOO+5Adnb1+2wC6STkWMCahYj+YkpLFn9K0tRwqcfr1dQ50VuyUMUKl5q6GXpLFioWJWfB7qBXUzfCpR7//hxR3WFUkqZeWyYxnPP+lKQ54FCPX5dmjZK08ZynihWrlKS5HBTaMKipm8GhHi+tUzsa1NSp15UbTOe8VFMfwWydyqUeb4V1KuB7zqsEXVFTVIJeC9jtdkycONHv7+Pi4vCrX/0KOTleL9slS5agQYMGnpPhm2++QbNmzXz+3SeffIKnnnrK8//t2rVD3759fV7TrFkzDBw4sNrvNZBOQo4FTFqyHCO8iZBK0qGraHfTjPi7iahtOHbTzNBbslDFilSSlrtpnEhLll2ZdDcRXH7kRk4z+a/78yOnXlsit9M7KOiVpCl308zQOyhQwbWbZqTEUDVDFStWKUlzVc1w+ZEb+WzRftOqmdpk+/F804ffHPcsjQfTV83Ih99j19O26BgxOihQYYV1KgAMifU6KKgEXVFTVIJeC9jtdtx777349a9/jTZt2mDUqFE+5etDhgxB69atff5NYWEhbDYbtmwRydVzzz2H/v37+7xmxYoVuPXWW1FRUYHy8nLccsstWLFihc9r+vfvjw4dOlT7vQbSScixgMkyvEMuul1Krn5UI7IMr30YrcjSs2M2k/ejmiHL8AavTCWLFakk/ejwDTd/cS2jt2Shgqsf1Yh0UHiI2EHh9cnm/ajUa8uCXVnkuhMFfpSkOejFoDuxZDdPP6oRo4MCVaxYpSQdx6A7UVnp3enNLykjm8cM6aAwfRudg4I/61SOe5ZWDLoTjmWifezHzbQil0Y8DgrEuhNWWKcCQNjadI/uhErQFTVFJei1wIQJE7Bt2zYcOnQIkZGR+M1vfoMPP/zQ8/s+ffrg5ZdfrvLv6tevj6ioKABA48aNERYW5vP7xMRE2Gw2nDt3Djk5ObDZbEhM9L3ohoWFoUmTJn7fW1lZGYqLiz3D5XLBZrOhoKAAFRUVlo7S0lLExsaitLSUbI7nxwqxo8TjeWRzfLP0oNZrmMH6+WXkFGlCNutJ53lCu9gdyr7IenyTNx/TdilTyGJl3ynRJvBU+CbWY6uoqMBfp4rkcs0BF9kcY7QqhMErDrEeW7671HMDf+VqGdk8nbXqji3puT4/p15bliQLYches5LJju10vmgTaDw4jvW7q6iowEfzRBnxvJ2ZZHPM2i6Eqj5duJf9+B7SHBRcBSVksdJjpqhCWLoni/XYNh4W4qGv/rCdbI6S0qveUuySK6zH51hGf71duV84pLw9PdHn5xz3LO00B4WD2XT3aP0WC+2O6VuPs353+0/zXG+ldeqJXDfr8Y1d573ecsRKbY6CggKVoAcYKkH3Q2hoaBXhN+PYu9e8x2vZsmWeJBgQCforr7xS5XX16tXDkiVLAIgEPTw83Of3O3fuhM1mQ25uridBT0ryVeweNWoUmjZt+rOPIyoqCrGxsf/14+nha2B3ODF63iqyOf723WpRRjyFbg6zMScmFnaHEw8PXEM6T9NB4jOcuYT3u/vXtFWwO5x4Y+xqsjnGLRCf4ZOhtJ+h2XglXMTN4Ei6uHn/ezHHBz/QfYZmY+mKWM8NfPRyunkeDxWxOX4B73cXOkvE5othdJ/rjCXiM2w2iD8239TWtAFT6WKz3xTxGb41jjc2Y2Nj0URb0yIJ17TnR4k5hs3mvS58N198ru2H0cXN4qXe83v5Ct7vrre2pn1IuKYNnCk+wy6j+WPz8aEibiYupJvjtTHiM/x6Om9sTosScfPIYLrYXLkyFg84xGc4L4b3u/untqa9bcGaVtMRFRWlEvQAQyXofrhw4QIyMjL+47h61VwZ/OzZs7DZbEhOFj1gVpa4B/sO+huThdhR05A4tB2xEe3C4tFulBhPjorHEyM34omRG/G4NtqO2IjHRmzAYyM24NHh3tFmmBith61Hq1DveHT4Bk/P2JwdJ1k/v9yiy56bpCe09y7fq3x/bYZ5j+GxERs8r2k9bD1ahq7HI0PXofmQdXhkyDrP8bQdsRFPap9Pm2EbPHNkXyhhPb7Fu0T/dJPBcWg3Kh6tQ9bgiZEbPd9bTb4zeYxSo6DzxAT2+P/H3N2eHdJHhq5Di6Hi/bUett5zDG1HeI9TxuqTo7wx3C5MDP1nIj+HNsO8sfndunTWYysvL/c4KMjj8jfaDBPf3RMjxfn59OhNeHr0JvwxfBPaa+erWXxLmzq7w4mU077rGfXasi5V9E8/+O1aPDp8Ax4fuRHtRsXjqfBNeEZ7//IYntKOo732XRnXn8cNQ37Hj40QsdluVDx7bP77J1FG/MiQdT4xVZ11o31YPJ4ZvQnPjdmMDmO24JmIzfhj+Ca0GxWPx0eK77BV6HpPbA5cdpD9+NqO2Oi5LjQfsg5NBq3BI0PEOdhiqDjGlqHe89FsHX3ceD5q3/FT4eJ7f3iQ2KXfeDiH9dj2ZIo+3wcGOv/jmmhcF6t9nLp186Fv17J/dxFrj3jWTfk+5fnXPiwef9Sdg/o15Ekt/vTrY6tQ33huFhKHJoPjPBUWH8/f4zM3xz3LK1pV0MOD1qLxYPF+mobEoZkWq/K8k9cMY5ze7Dt8clS859yL3n2a9bvLzHP73LPI70Ku548MWYemIXForH0HDwwUYo4PfrvW83nIc/aRoevQUne9lHEgK/7sDicuFPPuXs9MOOH57toM24AWg9d41sV2uth8NkKsjc+P3YIP5+5mP4fMhtpBDzxUgk7AmjVrYLPZPOrqUiTu3Dmv4E50dHQVkbjmzZv7/J2+fftWEYn79NNPfV7TvHlzJRL3H4jQBNw4BqXYlxnXrt9A+7BNLMf23JgtqLh+g/X4pFUXx+jPbJEHAFO2nmA7PkrPYH9IJXDq8ejwDSi+6ruGUK8tZy6Wem5yqcd7s3eTHMN/Yu7OU2yx+dNeOjVuf3w0fy/LsT0w0InsAl4RtcLL5WiulfhSjzeYFfgBYF3aObbYjNye6TM3xz3L4JWpLMfWaCCtNo8ZVyuu47ERG1mO7+nRm0m95M1IzizAAwN/3vvktpn0RyDlBgqBStBrSFJSEiZMmIADBw7g1KlTiImJwf33349u3bp5XiNt1l588UWkpKRg06ZN+H//7/+Z2qx9+eWXSE9Px+zZs/3arM2ePRvp6en44osvcMcddyArK6va7zeQTkKOix0A5JeUIavgMo7mliDtrBtpZ904nCPGkZxipJ8TIyNXjKO5JTh2Xozj2jiRV4ITeZdwIu8STuZfQma++O/x8yVIP1eMHGafYsmlsms4nONG+jnxvsV7Fe/tZL54v8e1YzmaW4KM3GIcP1+Ck/mXcOrCZWQVXEZ2QSmyCi57jicjtxiHc8TndCKvBGculqL8Gm9yLjnnvoK0s24cyCrA5MWxOJR9scp3djS3pMp3Jr4v389C/51l5BYj7awbh1xFOOQqwjXmhw+S88VXkV1QitMXLuPUhctVvjMZk/J4j+QUe2JXxrKMZ/l56D+Dk/mXkFdiXulDTcX1G8jUPnd/QxyvN+ZSXW6kZBfiwBnxveiPTR/fmfmXcPqCiN0r5VX96znWFndpBU7kXcLR3BIcyRHxdPBMEfZnF3qO4aA2DrmKkOqq+p3JWNZ/z/I7lq/jfjAGCBGwk/mXcCTHG1MynozrRqbJOZWSXYi9py9iz+mL2J9diINnxHeZfk7+LfH9WRWbN25U4szFUmQXlOLkeTdmRcfixHm35zw8deGyLj5FjBrXUeP3lOoSx37wTBEOnBGfwTm3NdcFd2nFz14X/R2nWUwezRV/w4rYBIC84quedfJorrgGy/enPwcPnvGed8Y1Un4Oci3JKriMMxdL4SosxdmiK7hwqar4Hce6UllZifPFV5FTdAVni67AVViKMxe9Q553p03j9D9/h/rv0bLYvFLhs6bLdUWu567CUuQUXUGu+yrySrRRfBW5bvGZyM8jq0B/zfReL+VafLmM1/lCcuFSGU7mX0L62UJMi4pF2pmLns/8kEusDfuzC7EvS6yPaWfdlrxPI4GUGygEKkGvIfv370f79u3RsGFD3HbbbWjatClCQ0NRWur71Dw7Oxuvvvoq/ud//ge//vWv0a9fP5SV+V4Atm3bhsceewz169dHo0aNMG3atCrzTZkyBXa7HfXr10fbtm2RkPDzPLAD6STkStAVdR8VK4qfg4oXRXVRsaKoLipWFNWlrsVKIOUGCoFK0IMMt9sNm80Gl8vl05tuxSgoKEBUVBQKCgosfy9qBPZQsaLGzxkqXtSo7lCxokZ1h4oVNao76lqsSH0qtzswdvQVKkEPOuRJqIYaaqihhhpqqKGGGmqoYbOJzTtFYKAS9CDjxo0bcLlccLvdAfPELhB289UI7KFiRY2fM1S8qFHdoWJFjeoOFStqVHfUtVhxu91wuVy4ccMaXQlFVVSCrrCM4mLV86KoHipWFD8HFS+K6qJiRVFdVKwoqouKFUVNUQm6wjLUAqaoLv+/vXsLiSJswDg+FKtl2YIm5oESyk6aUkQRhFJZCW0F3UgUeZNltWXgTRC1BB3sou6CKCq6KA2yIEoCO4OHqNZoS6KDpaFRpHaQWiH2+S7C/b7xkBPhznz2/8HezLw7vAMPMz7u8A5ZwZ8gL7CKrMAqsgKryAr+FgUdtuECBqvICv4EeYFVZAVWkRVYRVbwtyjosE0wGJTP5+vzujmgN7KCP0FeYBVZgVVkBVaRFfwtCjoAAAAAAA5AQQcAAAAAwAEo6AAAAAAAOAAFHQAAAOZuo/EAAAiMSURBVAAAB6CgAwAAAADgABR02ObYsWNKS0tTdHS05syZo3v37tk9JdjM5/PJMAzTJzExMbw/FArJ5/MpKSlJo0aNUm5urp4+fWrjjBEpd+/elcfjUVJSkgzD0OXLl037rWSjo6ND69ev17hx4zRu3DitX79enZ2dkTwNRMBgWSksLOxznZk/f75pTDAYlNfrVXx8vGJiYrRy5Uq9e/cukqeBCDh48KDmzp2rsWPHKiEhQatXr9bz589NY6xkobm5WR6PRzExMYqPj9f27dvV3d0dyVPBELOSldzc3D7XloKCAtMY7kOwgoIOW1RUVMjlcunkyZNqbGxUSUmJxowZo+bmZrunBhv5fD5lZGTo/fv34c/Hjx/D+8vKyhQbG6vKykoFAgEVFBQoKSlJX79+tXHWiISqqirt3r1blZWV/ZYuK9nIz89XZmamamtrVVtbq8zMTHk8nkifCobYYFkpLCxUfn6+6TrT3t5uGlNcXKyUlBRVV1fL7/dr0aJFys7O1s+fPyN5Khhiy5cv15kzZ/T06VM9fvxYK1as0MSJE9XV1RUeM1gWfv78qczMTC1atEh+v1/V1dVKTk6W1+u167QwBKxkJTc3V0VFRaZry+fPn03H4T4EKyjosMW8efNUXFxs2jZ9+nTt2rXLphnBCXw+n7Kzs/vdFwqFNGHCBJWVlYW3BYNBud1uHT9+PFJThAP0Ll1WstHY2CjDMFRfXx8eU1dXJ8Mw+vwKguFjoIK+evXqAb/z+fNnuVwuVVRUhLe1trZqxIgRun79+pDNFfb7+PGjDMPQ3bt3JVnLQlVVlUaMGKHW1tbwmPLyckVHR+vLly+RPQFETO+sSL8KeklJyYDf4T4EqyjoiLju7m6NHDlSly5dMm3fsWOHcnJybJoVnMDn8ykmJkZJSUlKS0tTQUGBXr9+LUl6/fq1DMOQ3+83fWfVqlXasGGDHdOFTXqXLivZOHXqlNxud59jud1unT59emgnDNsMVNDdbrcSEhKUnp6ujRs36sOHD+H9N2/elGEY6ujoMH0vKytLe/fujci8YY+XL1/KMAwFAgFJ1rKwZ88eZWVlmfZ3dHTIMAzdunUrMhNHxPXOivSroI8fP17x8fGaOXOmSktLTU9xcR+CVRR0RFxra6sMw1BNTY1p+4EDBzR16lSbZgUnqKqq0sWLF/XkyRNVV1crNzdXiYmJ+vTpk2pqamQYhulXCkkqKirSsmXLbJox7NC7dFnJxoEDB5Sent7nWOnp6Tp48ODQThi26a+gV1RU6OrVqwoEArpy5Yqys7OVkZGhYDAoSTp37pyioqL6HGvp0qXatGlTROaNyAuFQlq5cqUWLlwY3mYlC0VFRVq6dGmfMVFRUTp//vzQTRi26S8rknTixAlVV1crEAiovLxcaWlpysvLC+/nPgSrKOiIuJ6CXltba9q+f/9+TZs2zaZZwYm6urqUmJioI0eOhEtYW1ubaczGjRu1fPlym2YIOwxU0H+XjYH+AThlyhQdOnRoaCcM2/RX0Htra2uTy+VSZWWlpIFLWV5enjZv3jwk84T9tm7dqkmTJpkWgLOShYH+SexyuVReXj50E4Zt+stKfx4+fCjDMPTo0SNJ3IdgHQUdEccj7vgTeXl5Ki4u5hF3hPGIO6yyUtClX38g96xhwCPu/x6v16vU1FQ1NTWZtvOIO3obKCv9CYVCpjUMuA/BKgo6bDFv3jxt2bLFtG3GjBksEgeTYDColJQU7du3L7wQ2OHDh8P7u7u7WSTuHzTQInG/y0bP4jz3798Pj6mvr2dxnmHOSkH/9OmToqOjdfbsWUn/XRjswoUL4TFtbW0sEjcMhUIhbdu2TcnJyXrx4kWf/Vay0LNI3P8+wVNRUcEiccPMYFnpTyAQMC0kx30IVlHQYYue16ydOnVKjY2N2rlzp8aMGaO3b9/aPTXYqLS0VHfu3FFTU5Pq6+vl8XgUGxsbzkVZWZncbrcuXbqkQCCgtWvX8pq1f8S3b9/U0NCghoYGGYaho0ePqqGhIfxqRivZyM/PV1ZWlurq6lRXV6dZs2bxepth6HdZ+fbtm0pLS1VbW6s3b97o9u3bWrBggVJSUkxZKS4uVmpqqm7cuCG/36/FixfzmrVhaMuWLXK73bpz547p1Vjfv38PjxksCz2vWVuyZIn8fr9u3Lih1NRUXrM2zAyWlVevXmnfvn168OCB3rx5o2vXrmn69OmaPXu26brBfQhWUNBhm2PHjmnSpEmKiorSnDlzTK+qwL+p593VLpdLycnJWrNmjZ49exbeHwqF5PP5NGHCBEVHRysnJ8e0giqGr9u3b8swjD6fwsJCSday0d7ernXr1ik2NlaxsbFat26dOjs7bTgbDKXfZeX79+9atmyZEhIS5HK5NHHiRBUWFqqlpcV0jB8/fsjr9SouLk6jR4+Wx+PpMwb///rLiWEYOnPmTHiMlSw0NzdrxYoVGj16tOLi4uT1esOLDmJ4GCwrLS0tysnJUVxcnKKiojR58mTt2LFD7e3tpuNwH4IVFHQAAAAAAByAgg4AAAAAgANQ0AEAAAAAcAAKOgAAAAAADkBBBwAAAADAASjoAAAAAAA4AAUdAAAAAAAHoKADAAAAAOAAFHQAAAAAAByAgg4AAAAAgANQ0AEAAAAAcAAKOgAAAAAADkBBBwAAAADAASjoAAAAAAA4AAUdAAAAAAAHoKADAAAAAOAAFHQAAAAAAByAgg4AAAAAgANQ0AEAAAAAcAAKOgAAAAAADkBBBwAAAADAASjoAAAAAAA4AAUdAAAAAAAHoKADAAAAAOAAFHQAAAAAAByAgg4AAAAAgANQ0AEAAAAAcAAKOgAAAAAADkBBBwAAAADAASjoAAAAAAA4AAUdAAAAAAAHoKADAAAAAOAAFHQAAAAAAByAgg4AAAAAgAP8B25wYsd/0nz8AAAAAElFTkSuQmCC\" width=\"1000\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_data(offx=4, signed=True, channels=4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} @@ -92,9 +92,13 @@ void adc_configure_monitor_mode(int oversampling, int ivl_us, int mean_aggregate st.mean_aggregator[0] = st.mean_aggregator[1] = st.mean_aggregator[2] = 0; st.mean_aggregate_ctr = 0; + st.detector.hysteresis_mv = 6000; + st.detector.debounce_cycles = 0; + st.detector.base_interval_cycles = 10; + st.detector.symbol = -1; st.detector.bit = 0; - st.detector.base_interval_cycles = st.detector.committed_len_ctr = st.detector.len_ctr = 0; + st.detector.committed_len_ctr = st.detector.len_ctr = 0; st.detector.debounce_ctr = 0; xfr_8b10b_reset((struct state_8b10b_dec *)&st.detector.rx8b10b); @@ -161,35 +165,49 @@ static void adc_timer_init(int psc, int ivl) { TIM1->CR1 |= TIM_CR1_CEN; } +/* FIXME DEBUG */ +static void gdb_dump(void) { +} + void DMA1_Channel1_IRQHandler(void) { + int start = SysTick->VAL; + static int debug_buf_pos = 0; + /* Clear the interrupt flag */ DMA1->IFCR |= DMA_IFCR_CGIF1; if (st.adc_mode == ADC_SCOPE) return; - for (int i=0; i<NCH; i++) - st.adc_aggregate[i] += adc_buf[i]; + //for (int i=0; i<NCH; i++) + // st.adc_aggregate[i] += adc_buf[i]; - if (++st.ovs_count == (1<<st.adc_oversampling)) { + //if (++st.ovs_count == (1<<st.adc_oversampling)) { + /* FIXME DEBUG for (int i=0; i<NCH; i++) st.adc_aggregate[i] >>= st.adc_oversampling; + */ /* This has been copied from the code examples to section 12.9 ADC>"Temperature sensor and internal reference * voltage" in the reference manual with the extension that we actually measure the supply voltage instead of * hardcoding it. This is not strictly necessary since we're running off a bored little LDO but it's free and * the current supply voltage is a nice health value. */ - adc_data.adc_vcc_mv = (3300 * VREFINT_CAL)/(st.adc_aggregate[VREF_CH]); + // FIXME DEBUG adc_data.adc_vcc_mv = (3300 * VREFINT_CAL)/(st.adc_aggregate[VREF_CH]); - int64_t read = st.adc_aggregate[TEMP_CH] * 10 * 10000; + int64_t vcc = 3300; + /* FIXME debug int64_t vcc = adc_data.adc_vcc_mv; + int64_t read = st.adc_aggregate[TEMP_CH] * 10 * 10000; int64_t cal = TS_CAL1 * 10 * 10000; adc_data.adc_temp_celsius_tenths = 300 + ((read/4096 * vcc) - (cal/4096 * 3300))/43000; + */ const long vmeas_r_total = VMEAS_R_HIGH + VMEAS_R_LOW; - int a = adc_data.adc_vmeas_a_mv = (st.adc_aggregate[VMEAS_A]*vmeas_r_total)/4096 * vcc / VMEAS_R_LOW; - int b = adc_data.adc_vmeas_b_mv = (st.adc_aggregate[VMEAS_B]*vmeas_r_total)/4096 * vcc / VMEAS_R_LOW; + //int a = adc_data.adc_vmeas_a_mv = (st.adc_aggregate[VMEAS_A]*(vmeas_r_total * vcc / VMEAS_R_LOW)) >> 12; + int a = adc_data.adc_vmeas_a_mv = (adc_buf[VMEAS_A]*13300) >> 12; + //FIXME debug int b = adc_data.adc_vmeas_b_mv = (st.adc_aggregate[VMEAS_B]*vmeas_r_total)/4096 * vcc / VMEAS_R_LOW; + /* FIXME debug st.mean_aggregator[0] += a; st.mean_aggregator[1] += b; st.mean_aggregator[2] += abs(b-a); @@ -201,35 +219,91 @@ void DMA1_Channel1_IRQHandler(void) { st.mean_aggregate_ctr = 0; st.mean_aggregator[0] = st.mean_aggregator[1] = st.mean_aggregator[2] = 0; } + */ - - st.detector.len_ctr++; - if (st.detector.len_ctr - st.detector.committed_len_ctr > st.detector.base_interval_cycles) { - st.detector.committed_len_ctr = st.detector.len_ctr; - st.detector.symbol = xfr_8b10b_feed_bit((struct state_8b10b_dec *)&st.detector.rx8b10b, st.detector.bit); - //if (st.detector.symbol != -DECODING_IN_PROGRESS) - } - - if (st.detector.debounce_ctr == 0) { + //if (st.detector.debounce_ctr == 0) { int old_bit = st.detector.bit; int new_bit = old_bit; - if (a < st.detector.threshold_mv - st.detector.hysteresis_mv/2) + //FIXME debug int diff = (int)b - (int)a; + int diff = a-5500; + + /* + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); + } + adc_buf[debug_buf_pos++] = diff; + */ + + if (diff < - st.detector.hysteresis_mv/2) new_bit = 0; - else if (a > st.detector.threshold_mv - st.detector.hysteresis_mv/2) + else if (diff > st.detector.hysteresis_mv/2) new_bit = 1; + /* + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); + } + adc_buf[debug_buf_pos++] = new_bit; + */ + if (new_bit != old_bit) { st.detector.bit = new_bit; - st.detector.debounce_ctr = st.detector.debounce_cycles; + //st.detector.debounce_ctr = st.detector.debounce_cycles; st.detector.len_ctr = 0; + st.detector.committed_len_ctr = st.detector.base_interval_cycles>>1; } - } else { - st.detector.debounce_ctr--; + //} else { + // st.detector.debounce_ctr--; + //} + + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); + } + adc_buf[debug_buf_pos++] = st.detector.len_ctr; + adc_buf[debug_buf_pos++] = st.detector.committed_len_ctr; + adc_buf[debug_buf_pos++] = st.detector.bit; + adc_buf[debug_buf_pos++] = diff; + + if (st.detector.len_ctr >= st.detector.committed_len_ctr) { + /* + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); + } + adc_buf[debug_buf_pos++] = st.detector.bit; + */ + + st.detector.committed_len_ctr += st.detector.base_interval_cycles; + st.detector.symbol = xfr_8b10b_feed_bit((struct state_8b10b_dec *)&st.detector.rx8b10b, st.detector.bit); + /* + if (st.detector.symbol != -DECODING_IN_PROGRESS) { + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); + } + adc_buf[debug_buf_pos++] = st.detector.symbol; + } + */ } + st.detector.len_ctr++; st.ovs_count = 0; for (int i=0; i<NCH; i++) st.adc_aggregate[i] = 0; + //} + int end = SysTick->VAL; + /* + if (debug_buf_pos < NCH || debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) { + debug_buf_pos = NCH; + gdb_dump(); } + int tdiff = start - end; + if (tdiff < 0) + tdiff += SysTick->LOAD; + adc_buf[debug_buf_pos++] = tdiff; + */ } @@ -61,7 +61,6 @@ struct adc_state { int adc_oversampling; int mean_aggregate_len; struct { - int threshold_mv; int hysteresis_mv; int debounce_cycles; int symbol; @@ -69,9 +69,9 @@ int main(void) { } set_outputs(0); + adc_configure_monitor_mode(0 /*no oversampling*/, 50 /*us*/, 10000/20 /*mean window size*/); /* FIXME DEBUG */ -// adc_configure_monitor_mode(0 /*no oversampling*/, 20 /*us*/, 10000/20 /*mean window size*/); - adc_configure_scope_mode(MASK_VMEAS_A, 10000); + //adc_configure_scope_mode(MASK_VMEAS_A, 50000); uint8_t out_state = 0x01; #define DEBOUNCE 100 |