diff options
Diffstat (limited to 'python/notebooks/Curve Trades.ipynb')
| -rw-r--r-- | python/notebooks/Curve Trades.ipynb | 6025 |
1 files changed, 31 insertions, 5994 deletions
diff --git a/python/notebooks/Curve Trades.ipynb b/python/notebooks/Curve Trades.ipynb index d4fe6326..20912cb1 100644 --- a/python/notebooks/Curve Trades.ipynb +++ b/python/notebooks/Curve Trades.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -14,19 +14,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e6bbb16c7c584180b9cdf5acb0e58240" - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "w = widgets.Dropdown(\n", " options=['IG', 'EU'],\n", @@ -39,10 +29,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "index = w.value" @@ -50,812 +38,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'] / mpl.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", - " var x1 = msg['x1'] / mpl.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys (original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object')\n", - " obj[key] = original[key]\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * mpl.ratio;\n", - " var y = canvas_pos.y * mpl.ratio;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event)});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value,\n", - " guiEvent: simpleKeys(event)});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " var width = fig.canvas.width/mpl.ratio\n", - " fig.root.unbind('remove')\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", - " fig.close_ws(fig, msg);\n", - "}\n", - "\n", - "mpl.figure.prototype.close_ws = function(fig, msg){\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width/mpl.ratio\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\n", - " });\n", - "}\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\" width=\"900\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "<matplotlib.axes._subplots.AxesSubplot at 0x7f1507d8d9b0>" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#On the run spread differences\n", "spreads_diff = ct.curve_spread_diff(index, 6)\n", @@ -864,882 +49,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'] / mpl.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", - " var x1 = msg['x1'] / mpl.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys (original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object')\n", - " obj[key] = original[key]\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * mpl.ratio;\n", - " var y = canvas_pos.y * mpl.ratio;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event)});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value,\n", - " guiEvent: simpleKeys(event)});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (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,iVBORw0KGgoAAAANSUhEUgAAA4QAAALQCAYAAADIJr5uAAAgAElEQVR4nOzdeXgUVb4+8JqZO787I/ei3Ln3PqMzc3ucUbvFg4KKCigK4o64j4oOOKK4r6PTLIGwyL6vIogUGMCwCukkbEnYQ4Cwhs5GAglkJ5CQkKXTXe/vj0pXaLqTVEIn1R3ez/PUI+muOvXtksPTb+rUOZJEREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREVB9w48aNGzdu3Lhx49YGNyLSAUREREREbYnEQEikm9H9lYiIiIjIryQGQiLdjO6vRERERER+JTEQ0jVmjiRJZyRJuihJUo4kSTMlSfp/Oo81ur8SEREREfmVxEBI15jbJUlqV/vn/5EkKU6SpBCdxxrdX4mIiIiI/EpiIKRr2P9IkhQjSdJSnfvX25EURYHD4UB1dTW3yzaHwwFFUVrxnzQiIiIiagqJgZCuQUMkSSqT1L/85yRJulfncT47UUVFBVJTU2G327n52FJTU1FRUdHK/7QRERERkR4SAyFdw26XJOkbSZL+WM/7o6Qr1mi5kqIoSE1NRU5OjuF34wJ1y8nJQWpqKu8UEhEREQUgiYGQrnGvSJK0Tee+Xh3I4XDAbrejurragO4bHKqrq2G32+FwOIwuhYiIiIiuIDEQ0jWuvyRJWTr39epA7rDDQFg/XiMiIiKiwCUxENI15D8kSfqHJEk3SJL0C0mSOkmSZJckaaHO4706EMNO43iNiIiIiAKXxEBI15B2kiRtlSSpWJKkckmSMiVJmiJJ0nU6j/fqQAw7jeM1IiIiIgpcEgMhkW5eHSiYws7HH3+MP/7xj/jP//xP3HTTTfjss8/qrTsuLg6SJKFdu3ba9tFHHzXrvMF0jYiIiIiuNRIDIZFuXh0omMKO3W5HeXk5AKCwsBCPPPIIxo4d63PfuLg4XH/99X45bzBdIyIiIqJrjcRASKSbVwcK1rBTWFiI3r17Y8CAAT7fZyAkIiIiujZIDIREunl1IF9hp/uEGIjQTS2+dZ8Q0+QOP2HCBPzHf/wHJEnC7373Oxw4cMDnfnFxcfjVr36FG2+8EX/4wx/Qv39/nD17tsnnq+8aEREREVFgkBgIiXTz6kDBFgjd7HY7hg8fjjNnzvh8Py8vD8ePH4fT6UReXh5ef/11dOnSBS6Xq8nnYiAkIiIiClwSAyGRbl4dKJjDzqpVq/Doo49i3Lhx2sQxTz75pM99y8rK8Mtf/hLJyclNPk8wXyMiIiKitk5iICTSzasDBXPYWb58Of7v//5P177l5eUMhERERERtkMRASKSbVwcKlrBTVlaGH374ARcuXICiKDh27Bhuv/12vPvuuz73j42NRWZmJhRFwblz5/D3v/8dnTp1gtPpbPK5g+UaEREREV2LJAZCIt28OlCwhJ3y8nL06dMH//Vf/4V27drh5ptvxldffYVLly753H/atGn44x//iOuuuw6///3v8dprryErK6tZ5w6Wa0RERERtV155HooqiowuIyBJDIREunl1IIadxvEaERERkdGELCBkYXQZAUliICTSzasDMew0jteIiIiIjFTjqmEgbIDEQEikm1cHYthpHK8RERERGamkqoSBsAESAyGRbl4diGGncbxGREREZKTcslwGwgZIDIREunl1IIadxvEaERERkZHSz6czEDZAYiAk0s2rAzHsNI7XiIiIiIx0pPAIA2EDJAZCIt28OhDDTuN4jYiIiMhIe3L2MBA2QGIgJNLNqwMx7DSO14iIiIiMtPX0VgbCBkgMhES6eXUghp3G8RoRERGRkdanr2cgbIDEQEikm1cHYthpHK8RERERGSnMHqYFQkVRjC4n4EgMhES6eXWgYAk7AwcOxK9//Wu0a9dO2/bu3Vvv/uPGjfPY97rrroMkSVi7dm2Tzx0s14iIyGgXKi/gm/hvkFuWa3QpRG3KwqMLtUDodDmNLifgSAyERLp5daBgCTsDBw7EZ5991uzj16xZg+uvvx4VFRVNPjZYrhERkdHejHwTQhb4JOYTo0shalOmH5yuBUKH02F0OQFHYiAk0s2rAwVL2LnaQPjUU0/h/fffb9axwXKNiIiM5v7C+sHWD4wuhahNeXvT21r/qnJWGV1OwJEYCIl08+pAwRJ2Bg4ciA4dOqBDhw7o2LEjpk6dCpfLpevYM2fO4Je//CUOHjzYrHMHyzUiIjKSw+nQvrCOjR9rdDlEbUZZdRk6L+2s9a9LjktGlxRwJAZCIt28OpDPsDP9DmD8n1p+m36H7o6emJiIwsJCOJ1OxMfH409/+hOmT5+u69gxY8agc+fOus91JQZCIqLGZZZkal9Yh+8abnQ5RG3G5UtOCFmgrLrM6JICjsRASKSbVwcKlkB4pXnz5uH+++8HAISFhWmTx3Ts2NFjP0VRcPPNN2POnDnNPhcDIRFR47Znb9e+sH4Z96XR5RC1GSP3jPQIhKXVpUaXFHAkBkIi3bw6ULCGnW+//VYLhA3ZunUrfvOb3+D8+fPNPlewXiMiotYkJ8l8hpDIzxRFQa/wXrhz6Z14fPXjELLAhcoLRpcVcCQGQiLdvDpQsISd8PBwlJaWQlEUHDhwACaTCZMnT270uNdeew39+/e/qnMHyzUiIjLSmL1jtED4VvRbRpdD1CYkFydDyAJ/j/o7Xo14FUIWOFdxzuiyAo7EQEikm1cHCpaw89BDD+H6669Hu3btcNttt2HSpEmNTipTXFyMf//3f0dsbOxVnTtYrhERkZEGbRqkBcJXI141uhyiNuHHEz9CyALzD89Hf1t/CFmgqKLI6LICjsRASKSbVwdi2GkcrxERUeP6rO6jBcJ+6/sZXQ5R0CuqKNL61N6cvXgj8g0IWSC/PN/o0gKOxEBIpJtXB2LYaRyvERFRwypqKiBkoT3j9Njqx4wuiSjozT08VwuE5Y5yDIgaACEL5JblGl1awJEYCIl08+pADDuN4zUiImpY6vlUCFlg8JbBuPfHe/HgygeNLoko6H0W+xmELPDD8R8AAG9FvwUhC5wtO2twZYFHYiAk0s2rAzHsNI7XiIioYe510sbtG4eHVj6Ee368x+iSiILeM+ue8Vh38O1Nb0PIAtml2QZXFngkBkIi3bw6EMNO43iNiIgatujYIghZIMwepg0bdSkNT/xFRN4O5h9E33V9seX0FnSSO6HP6j7ae+9sfgdCFjhVcsq4AgOUxEBIpJtXB2LYaRyvERFRw0bsHgEhC+w6uwvPrX/O464GEelT7azWnhnsGtbVawmX97a8ByELZJRkGFhlYJIYCIl08+pADDuN4zUiImrYwOiBELLA6dLT+HDbhxCywNHCo0aXRRRU1qWt0wKhexu6c6j2/vtb34eQBdLPpxtYZWCSGAiJdPPqQAw7jeM1IiJqmHuYaLWzGvMOz9O+zOaV5xldGlHAcCkufBP/DSYmTERJVYnHe06XE8///DyELPDB1g+0PjQrcZa2z0fbPoKQBVKKU1q79IAnMRAS6ebVgRh2GsdrRERUP6fLibuW3oVe4b0AAHHZcdqXWTlJNrg6osBxquSU1jd6/tQTG09uhKIoUBQF4/aNg5AF3ox8E3nleegkd4KQBcJTwrXjP4n5BEIWSC5ONvBTBCaJgZBIN68OxLDTOF4jIqL65ZXnQcgC/SP7AwAcLoc2Pf6gzYMMro4ocGw+tRlCFui9qrcWDN/e9DZmJs7UQmL2RXUG0Xc3vwshC+zJ2aMd716GIulcklEfIWBJDIREunl1oGAJO+3atfPY/u3f/g2dOnWqd//c3Fw8++yzuPHGGyFJEg4fPuy1z/r163HLLbfgt7/9LXr06IHkZN+/cQuWa0REZITE/EQIWeCr7V9przldTjy08iF0XtaZk8sQ1Zp9aDaELLA6dTUS8xO1IaJCFrjnx3s8nrs9c/EM5CTZY7beL+K+gJAFjhUeM6L8gCYxEBLp5tWBgjXsdOrUCePGjav3/fz8fMybNw8JCQk+A2Fqaiquu+46REREoLKyEiNGjMBtt92Gmpoar7aC9RoREbWGiIwICFlg2sFpHq8P3TkUQhbYcnqLQZURBRZ3oDtcoH4ncbgcWHx8Mfqu64uYrJhGj/9q+1cQssCRwiMtXWrQkRgIiXTz6kDBGHYSEhLwq1/9Cjk5Obr2l3wEwpCQEDzzzDPazw6HAzfccANiY2O9jg/Ga0RE1FoWHl0IIQusTF7p8Xp0ZjSELBCyO8SgyogCy+u21yFkgYJLBc06/usdX0PIAocKDvm5suAnMRAS6ebVgYIx7AwePBh9+/bVvb/kIxD269cPw4cP93ite/fumDlzptfxwXiNiIhay6i9oyBkgR1ndni8Xlpd6jHZDNG17pHwR9B5aWc4Xc5mHT9k5xAIWeBA3gE/Vxb8JAZCIt28OpCvsPPY6sfQbXm3Ft8eW/1Ykzv8pUuX0L59e/z8889N+kfiykDYu3dvTJkyxeO1p59+GmPHjvU6noGQiKh+721VF8tOPZ/q9V7Pn3ri7mV3G1AVUWBxLzr/xJonmt3GsF3DIGSB/Xn7/VhZ2yAxEBLp5tWBgi0QLlmyBL///e89nvULCwvTJpvp2LGjz38kfN0hDAnxHMbUo0cP3iEkImqifuv7QcjC5+QxPX/qiS7LuhhQFVFgyb6YDSELDIga0Ow2QnaHQMgC8bnxfqysbZAYCIl08+pAwRZ2evToAavV2qRjpHqeIbx82KnD4UCHDh0QE+P9UHewXSMiotaiKAq6hnVFtxXdfL7/8E8PMxASATiYfxBCFvh6x9fNbiN0T6i6FMXZPY3vfI2RGAiJdPPqQMEUdlJSUvCLX/wCqanew5J8qaysRGVlJSRJQkJCAiorK+FyubS2rrvuOkRGRqKqqgqhoaG49dZbOcsoEVETnK88DyELvLThJZ/vPxL+CDov69zKVREFnm2nt0HIAhMTJja7jdF7R0PIArvO7vJjZW2DxEBIpJtXBwqmsPP111+jZ8+euveX1H8cPLa4uDjt/XXr1uGWW27Bb37zG3Tv3p3rEBIRNVHSuSQIWeDjmI99vt8rvBc6L2UgJFqduhpCFlhwZEGz2xgbP9bnBE7EQEjUFF4diGGncbxGRES+ue96jN833uf7vcN7466ld7VyVUSBZ9GxRRCyQHhKeLPbGLdvHIQsEJvlvUTWtU5iICTSzasDMew0jteIiMi3pUlLIWQBOUn2+X7vVb1x59I7W7kqosAzef9kCFlg86nNzW5jYsJECFlgW9Y2P1bWNkgMhES6eXUghp3G8RoREfnmHsIWk+U9IRcAPLrqUXSSO7VyVUSBxx9LRkzaPwlCFthyeosfK2sbJAZCIt28OhDDTuN4jYiIfBu0eRCELJBxIcPn+31W94GQRStXRRR43t/6PoQskHY+rdltTD0wFUIWiD4V7cfK2gaJgZBIN68OxLDTOF4jIiLf+qzugzuX3olqp+9/Hx9b/RgDIRGAlze+DCELFFUUNbuN6QenQ8gCUZlRfqysbZAYCIl08+pADDuN4zUiIvJWUVMBIQs8uebJevd5fPXjELKAoiitWBkZoaisCplF5UaXEZDyyvMgZIHHVj92VX1hZuJMCFkgIiPCj9W1DRIDIZFuXh2IYadxvEZERN5SilMgZIH3tr5X7z5PrHkCQhZwKa5WrIyM0GfadpisNhSUVhpdSsCRk2QIWWDawWlX1c7sQ7MhZIENJzf4qbK2Q2IgJNLNqwMx7DSO14iIyNumU5saXWjbHQidLmcrVkatLbv4EkxWG0xWG77flWl0OQHntYjXIGSBE+dOXFU78w7Pg5AF1qev91NlbYfEQEikm1cHYthpHK8REZG3745+ByELrExeWe8+T655EkIWqHHVtGJl1NrC9p3WAuEg+YDR5QSU7NJsCFngmXXPXPXQ6flH5kPIAmvT1vqpurZDYiAk0s2rAzHsNI7XiIjIm3sa/b05e+vd56m1T0HIAg6XoxUro9b21aojWiDsM2270eUElO+PfQ8hC8w+NPuq23L/EmZV6io/VNa2SAyERLp5daBgCTsDBw7Er3/9a7Rr107b9u6t/0tIbm4unn32Wdx4442QJAmHDx/22mf9+vW45ZZb8Nvf/hY9evRAcnKyz7aC5RoREbWm/rb+ELJAblluvfs8vfZpNRA6GQjbMvfzgyarDbcOj4LLxUmE3N7e9DaELJB0Lumq21oeMR5PTL0D4SnhfqisbZEYCIl08+pAwRJ2Bg4ciM8++0z3/vn5+Zg3bx4SEhJ8BsLU1FRcd911iIiIQGVlJUaMGIHbbrsNNTXew5qC5RoREbUWRVHQbUU33PvjvQ1OGPPMumcgZFHvshQU/H4+fBYmqw29p8bh+Xm7YbLacPZChdFlBYQqZxXuXnY3uq/oftXP0bqqqmA3W2A3W7AieYWfKmw7JAZCuob8uyRJiyRJOiVJUpkkSSmSJL3dhOO9OlCwhJ2mBsLLST4CYUhICJ555hntZ4fDgRtuuAGxsbFexwfLNSIiai3nK89DyAIvbnixwf3cgbDKWdVKlVFrOnuhAiJ0E/48xIY9J4vwz9qho1tP5BtdWkDILMmEkAUGbR501W2V792rBcIwe5gfqmtbJAZCuoa0kyRpjCRJf5Uk6ReSJD0gSdIFSZIe13m8VwcKlrAzcOBAdOjQAR06dEDHjh0xdepUuFz6pjGXfATCfv36Yfjw4R6vde/eHTNnzvQ6PliuERG1LYqioKom8GbnVBQFS5OWQsgCX8R90eC+fdf1ZSBso5wuBa9+txcmqw3jIu0AgJUJWTBZbRhf+/O17njRcV39RI/ckaFaIFx2YpkfqmtbJAZCusatk9SQqIdXB/IVdtJ69ULKvV1bfEvr1Ut3R09MTERhYSGcTifi4+Pxpz/9CdOnT9f9j8SVgbB3796YMmWKx2tPP/00xo4dq+saERG1tMmbkiFGbkJxeWD927Px5EYIWUDIArMSZzW4rzsQVtZwbbq2ZldaEUxWG56YsUP7xUVGYRlMVhuem7vb4OoCQ3xuPIQsMGL3iKtqpyotDfaOd2iBUE6S/VRh2yExENI17DeSJJ2VJOllnft7daBgCYRXmjdvHu6//34AQFhYmDbRTMeOHX3+I+HrDmFISIjHaz169OAdQiIKGG8v2Q+T1YbjZ0uMLsXDu5vf1QLhz+k/N7jvs+ufhZAFKmr4TFlbs2zvKZisNsyNTddeUxQF94zdir8OjUR5FZca2XZ6W6NrdTbGkZ+PtAcf0sLgkTssWHx8sR+rbBskBkK6Rv1CkqQwSZLiJEn6ZT37jJLUDqJtVwrWsPPtt99qgbAxUj3PEPbt21f72eFwoEOHDoiJifE6PlivEREFtwGLEwIyEA7eMlgLhIcLvGdwvly/9f0gZIFLjkutVB21lglRyTBZbVh/6KzH6x+GJcJktWFXWpFBlQWO9enrIWSBuYfnNruNk089DbvZgpNPPoVjXe/GsdstWHRskR+rbBskBkK6Bv1CkqQFkiQdkCTp+iYc59WBgiXshIeHo7S0FIqi4MCBAzCZTJg8eXKDx1RWVqKyshKSJCEhIQGVlZXac4cpKSm47rrrEBkZiaqqKoSGhuLWW2/lLKNEFDDeWLQPJqsNR89cMLoUD4+vflwLhKXVpQ3u+9z65xgI26iPVxyCyWpDQmaxx+vyHvXO4bTNKQZVFjjC7GEQsmj2EE/nhQvancGKY8dxtMd9SDJb8N3R7/xcafCTGAjpGvMLSZLmS5J0SJKkDk081qsDBUvYeeihh3D99dejXbt2uO222zBp0qRGJ5WRrrg7KkkS4uLitPfXrVuHW265Bb/5zW/QvXt3rkNIRAHFPWHHkezACYQuxYW7lt6FB5Y/gKKKxu8APf/z8xCyQLmjvBWqo9b04vw9MFltOHPeM+zbc0thstrwtwX1rxV8rVhwZAGELLAmdU2zji/fswd2swVnv/gSAHDkoW6wmy2YnzjPn2W2CRIDIV1j5kmSdFSSpN8141ivDsSw0zheIyIywsvfql+4DwdQICypKtG13ISbOxCWVZe1cGXU2rpPiMGfh9hQ4/T85azLpeCOkZtgCYk2qLLAMe3ANAhZIPpU06+FoijIevdd2M0WnPthCQDgSK8HYTdbMDtB36R61xKJgZCuISZJ/QtfJUlS+WXbAp3He3Ughp3G8RoRkRHci3wnZp03uhTN6dLT6rpqm/Stq/bChhcgZIGL1RdbuDJqbR1HRKNT6Caf7/WYGAOT1QanS2nlqgJHtbNaG1q96+wu3ccpioLy+HiUbIyA3WxB+qN94CxVh2YffbQn7GYLpu2e0FJlBy2JgZBIN68OxLDTOF4jIjLCs3N2wWS14eDpwAmEhwsOQ8gC/9z+T137v7jhRV3PGlJwcThdMFlteGhSrM/3H5u+HSarDWXX8Eyj0aeidU++5Ka4XMifPFl7btButuDckiXa+0cf7wW72YJJ20e3UNXBS2IgJNLNqwMx7DSO14iIjPDUzJ0wWW04cKq48Z1bSVx2HIQsMDbee81WX17a8BKELFBSFVgzpdLVKSqrgslqQ9/Zvu989av9ZUbhxapWrixwbDm9RQuEmSWZuo45t2SJGgRv74jsDz9C9kcfwVlS13eOPdUHdrMF47cN93n83py92Hhyo1/qDzYSAyGRbl4diGGncbxGRGSEJ2bsgMlqw/4ACoRNnUb/5Y0vMxC2QSdrF6B/Y9E+n++7J0TKOnftzi4blRkFIQv0Du+t+5istwfBbrag6LuFPt8/3vcJ2M0WjI7+yuu9KmeVFkALLhU0u+5gJTEQEunm1YEYdhrHa0RERnh0mjrsbl/GOaNL0Sw5vgRCFgizh+na/5WNr0DIAhcqA2diHKpfpcOp/beh5U4Ss87DZLXhw7BEn++/9YO6hmZK3rX77OiGkxsgZIE5h+Y0uq/idKJs506kdLkbyV3uhuJjCSwASHpOXZNwZMSnXu+5A6iQBTad8v1sZ1smMRAS6ebVgRwOB8NOI9yB0OFwGF0KEV1DHpkSB5PVhvgACoQzDs6AkAUiMiJ07e8OhOcrA+c5SPJt9cEzMFlt2GbPx4DFaqDbc1JdWkRRFLyz9AAGyfuhKApiUwpgstowZO0xn225F6c/FEATIrW2NalrIGSBBUcWNLhfVXo60h/toz0zmGMdUu++J17qB7vZguHrP/B6793N72qBcGLCxKuuP9hIDIREunl1IEVRkJqaipycHFRXV3PzseXk5CA1NRWKcu3OlkZEre/BSTEeX8oDwbh94yBkgdgs35OJAIDzYt1dob9F/A1CFiiuDJxhr+TbnaM2w2S1aRPCmKw2fLQ8EVHHcnH8bIn2mvvun8lqw8Ro3+v3fhl+JOD+7ra2lckrIWSBxccXN7hf4bx5sJstyHz5FZRGRkJp4Bf09r+9ALvZgiGr3vF4PacsB53kTlog1DvpU1siMRAS6eazE1VUVCA1NRV2u52bjy01NRUVFRWt/E8bEV3ruo3fpn6pTg+cL9XDdw2HkAX25fp+dsy9kHbRt+pdkVcjXoWQBc5VBM5dTvLt4cmxMFlt+OvQSC3wNbZN3uQ7EIasP67dbbxWLTuxDEIWWHZimfba+fBwpPfqjYIpU1BTWAgAyPnXv2A3W1C2e3ejbSa//grsZgu+WvF3j9fnH5kPIQt8EfcFhCwweMtg/36YICAxEBLpVm9HUhQFDofD8LtxgbY5HA7eGSQiQ3T9ZitMVht2B1Ag/DLuSwhZ4Fih76GCBVOmaEPfXJWVWiAsqgicz0C+9Zu7u8Hwd9+4rdiZVojIY7kYH2VH59Gb650Bd1ykHSarDRFHc1r5UwSOxccXQ8gCK5NXaq+dfuNNrX8kd7oTeaNHI6NvX9jNFlSfOdtom6l/fx12swVfLHsNABC6JxSfx36OJ9Y8ASELJOYnQsgCr9teb7HPFagkBkIi3Yzur0REpNPdY7bAZLVhZ1qh0aVo3t/6PoQskH4+3ef7uaNGaV94HTk5eC3iNQbCIDHwsqGgl29Pz9qJuJQCrxlDG/pl6bQtqTBZbfh2+8mWLjug1LhqELonFLvO7sKCIwsgZIE1qWu091O7dYfdbEH++PFI7nJ3XTgUnaA4nY22n/7W32E3W/DZDy/B6XJqQ0SFLPBG5BvaTKN91/VtyY8ZkCQGQiLdjO6vRESkk/uZrh2pgRMIB0YPhJAFcsp83/nJfv8D7Utupd2O122vMxAGiU9XHtJCYO+pcdqfB/4chzcAACAASURBVC870OS2vt1+Ujs+NuXaWQLhcMFhLaDNTJwJIQtsOLkBAFBTXAy72YKMvs8CAJwXLqBwzlykPtANZz7+WFf7J995G3azBR8v7Ie88jyPQDh051AAQJdlXfDwTw+3yOcLZBIDIZFuRvdXIiLS6Y6Rm2Cy2hAXQF+oG5s1NPOFF7VAWB6/D/1t/SFkgcJLgRNqybePV9QFwm32fO3PozYmNbktec8p7fi/DI0MqLU0W9K+3H1aQHP/3d+yU4azpER7vvbM5583u/3M9wbDbrbgw2+fwv68/R6BcNL+SQCAnj/1xN3L7vbXRwoaEgMhkW5G91ciItLJHBIVcHdY+q7rCyELVDmrvN5TFAWp3XtogbB002b0j+x/zS6UHWwGLzsAk9WG8APZyC6+pAW6xbsym9zW7G1pHsNOxchN+Gl/FubFpWtrHbZFsVmxWkDrtrwbHppzB+xmC9J69ULBtOmwmy0oDtO3hqcvpz/6CHazBe/N6YN1aes8AuGiY4sANNxH2zKJgZBIN6P7KxER6XTLMHW2x5jkwJmpsfeq3rhr6V0+nx8798MSLQzazRacDw/HG5FvQMgC+eWB8xnIN/czhKn5F1FS4dDCXHpB0xeXnxubDpPVhluGRWJ67fOE7u3jFYdaoPrAEJER4RHSXhp7h9Yf0vs8BrvZgqqMjGa3f+azz2A3W/DujEcwef9kj3OtTl0NANfsMG2JgZBIN6P7KxER6XTzkLrhe4Gi2/JueGD5A16vl27aDHvHO5Dc6U7khoTAbrbg3KJFeDPyTQhZIK88z4BqqSleXxgPk9WGU0XlcLkUmEOiYA6JatZM25UOJ8ZGnMDpc+VQFAWvfrdXC4QPjN8GoOFJaYJVeEq4R0gbOLyjxy9JsgYPvqrPffbLf8JutuDtKT20CZvc27bT6nUdvGUwhCyQWdL0O7vBTGIgJNLN6P5KREQ6uFyK9gV664nACISKoqDz0s7oHd7b4/XyhATtC++F1atRsjECdrMFBVOn4u9Rf2cgDBIvzd8Dk9WG3BJ13d3z5dUorXT4pe1NSXkedwnfWXoAfx0aiQVtbBZSOUn2CGmffV4XCNMe6oma4qt7lvLs11/Dbrbg9W/uwl1L7/I4V2J+IgDgq+1fQcgChwsO++MjBQ2JgZBIN6P7KxER6eBwurQvz5uTAiNMVTurIWSBZ9Y94/F64ew5sJstyPnXvwAAZTt3al+C3w9Xh6/lluUaUTI1Qd/Zu2Cy2nCurGWePUvILNZC5+Xb+Eg7ACCjsAzjIu0or6ppkfO3hvmH52sBrcv3d3jcHbx0oOmztV4pZ8hQ2M0WvDqqo0cYFLJARok6FHXcvnEQskBMVsxVny+YSAyERLoZ3V+JiEiHSodT+8K8KUAC4YXKCxCywCsbX/F4PevtQbCbLag4rs5G6cgv0L4Er3+5G8SSO+pdpoICx+PTd8BkteGin+4K+jI24gRMVpt2LvcGQFvqInRD02c1DRRT9k/RAtqnl90dLN2yxS/tu4djvx6qBkL3gvRCFqh2VgMA5h+Z77X+4bVAYiAk0s3o/kpERDqUVdVoX5ajjwfG3bW47DgIWeCjbR9pr7kuXUJy5y5I7nI3FEddkHCWlCCtVy91RsSvO+Js2VkjSqYmeGSKGsiqa1wtdo4z5y9h6uYUFJVVYcORHI9A+Jeh6iRK/ebsarHzt7TRe0ej+7w7MGhIR3z8ZV0gLI/f55f2c0eGwm624M0RaiD8NOZTLRC6uZ9jdM86eq2QGAiJdDO6vxIRkQ4ll+pmeYw6FhiB8O1Nb3sNRSuNioLdbMHZf37ltX/5PvXZwp1dLThz8UxrlkrN0G38Npistlad7OX+cdtw8xD1nN0nxMBkteG+cVtb7fz+Zt1pha2nGgLX9KkbLuq82PSZWn3JGz0GdrMFA4Z3RNewrtozi5cvRL/l9BYIWWBiwkS/nDNYSAyERLoZ3V+JiEiHc2VVWiC0HTU+EKYUp0DIAk+tfQpOV906cjnDh6tD4qI3+TzuwD2dcKSjBdkXs1urVGqmO0dtxq3Do1r1nH2mbYfJakNZVQ1emLfb445hMPok5hOP5wbtZgsyFs/zW/t534yD3WzBP4Z1xFvRb8HhcmDRsUUe63weyDsAIQtYd1r9dt5gIDEQEulmdH8lIiIdCkortS/HEUeNf/4uZHcIhCwQZvdcVDv9scdhN1vqnT1xf9dOONrRguxSBsJANnNrmiFhzB0Cc0sq8Ob3+7QagnVJivc2vuUVCE+vWua39vMnTITdbMGgIR0Rnxvvc5+MCxkQssBDKx/Cu5vfxfh94z1+idNWSQyERLoZ3V+JiEiHnAsV2pfjjUeMD4TuySvKqsu01xx5eeodkL596z1uf9dOOHa7BVmlWa1RJjXTlRO8tJYBixNgstqQmn/RYwbSvJLKVq3DXz6Y96RXIDwbtd5v7edPngy72YLUVT/Uu09FTQUeXPmgxwyku86qz2UezD+IOYfmwOFsuYmDjCIxEBLpZnR/JSIiHbKLL2lfjn8+bPyELPeF3Yduy7t5vFaycSPsZgvyRo+u97iE++5EksWC06WnW7pEugpGBcKPlifCZLXh4OliPD1rp1bDnpNFrVqHP1TWVOIfIcIrEBbs8t/yDwXTpsNutqBkY0SD+5U7ynGq5BRWJK/wGD761NqnIGSBsfFj/VZToJAYCIl0M7q/EhGRDplF5QETCB1Oh/b84OVyQ0bUPj8YXe+xCfffiSQzA2GgMyoQDll7DCarDbEpBehVu+yEyWrDEzN2YOi6Y6h0BM9Qx6TkXV5h0G624PyRg347R8HMmbCbLbiwXt9dR/dSMc+tfw4AtDuGD//0cNAOy62PxEBIpJvR/ZWIiHRILyjTvhyvO2TsDJ2FlwohZIHXba97vH7y8SfU5weL6r+bs++Bu2A3W3Cq5FQLV0lX45ZhkYYEwvGRdpisNmw4koMHamc5dS8/4X49WMR/OkALgZkvvVy35ERGut/OUThnrhoI1+hfY/CR8EfQeWlnlFaXegwjbWvDuCUGQiLdjO6vRESkQ0reRe1L8dpEYwNh6vlUCFng/a3va685CtTF508+/UyDx8Z3UwNhxoWMli6zyXakFuJQ1nmjywgIT8xQF4r/atWRVj3vnBh1MpsJUcm4a/Rm3D4iGiUVDvy0Pwsmqw0frzjUqvVcjR2f9tdCYNH8+dqfHYWFfjtH0bffqncdw8N1H/PO5ncgZIGNJzd6BMLIjEi/1RUIJAZCIt2M7q9ERKRDUk6JFghXHzQ2EO7P2w8hCwzZOUR7rcRmg91sQW5oaIPHxnfvrAbH4rQWrrJpqmtcuHV4FB6aFGt0KQHh0drlHy5V17TqeZPzSnHb8Cjt7/o9Y7cAAMqqamCy2vDw5OD5/7P1s9e0EHjp0CHY71CfJ3RV+m+CnKLvFqqBcMUK3cfMSpwFIQt0XtoZQha498d7IWQBOUn2W12BQGIgJNLN6P5KREQ6HD1zQfuSvOqAsUs2XLnQdVVamvbFtzSy4bsMe3vUBsKiwAqEeSXqsh5/HmJDdY3L6HIM9+AkdVF4p6v1nyuLSynQhon+dWjd36cuY7bg1uFRcBlQU3NsG/i01i9cly4hNyQEWe++69dn9c59vxh2swXFP4Y1vnOtzJJM7a6gdacV69LWQcgCk/dP9ltdgUBiICTSzej+SkREOiRmndcCYbjBgXBV6ioIWWDBkQUAgLwxY7Uvvg09PwgAex/sArvZgvTC5NYoVbfjZ+vuwGadu+SfRhUFcFT4p61Wdu83W3HLMOOGEH4RftjrGca+s3fBZLWh4GJgL0FRc+4cyvfsQdzzPWE3WxC/e3WLnevckiVqIJSbdncvOjMaMVnqbKeJ+YkQssDX279uiRINIzEQEulmdH8lIiId9p8q1r4g/7Tf2MkfFhxZACELhKeozy2l9+qtDos72PjsiXtqA2Favr2ly2ySuJSCuiUO0pu3xEHBxUokXv4M4tZRwLibgFO7/FRlCzuyEshPAgB0Ct0EMXKTYaXMjzvpFQjfW3YQJqvN0Oc8K1NSUHXyZIP7nPnsc9jNFpywqL8kOZqxt8XqKV72I+xmC84trn8dwsZkX8yGkAXeiHwDKcUpqKwJ7MCtl8RASKSb0f2ViIh02HvynPYFeWWCsYFw3L5xELLAtqxtcOTnq5PE9HtO17F7et6tLqSde7yFq2yaNQfP1N2B3d+8O7DvLD2Am4dcdgdr6XNAaHtgwv8Bhal+rLYF5B1Xaw1tDwC4dXiU9vyeEeIzznkFwtEbT8BktSHiaMvPNOq6dAlZg95Byc8/171WVaXdCUep7xocBQVI7dZd2+/Y7S07gVLx8uXqpDULFza7jcqaSo/JZSYkTPBjhcaRGAiJdDO6vxIRkQ670oq0L8jL9xkbCL+M+xJCFjhSeAQXt25VJ5MJGaHr2N21gTAl91gLV9k03+2ouyM1bUvzwtvz83bDZLVpdwld3z1SF7JmCODcScAVoM8npm/TalUUBSarDd0n+G8B9eZYmZCFo2cuaD//GH9a+390+est4WJMjBbqLsbGIjc01GMtQYz/E3CpGABQceQIipf9qPUFu9mCjL7PYuUb3TH5zdtRVNG8O856nP8pXA2E3y64qnYGbxmM7iu6a6Ew+6Kxw9L9QWIgJNLN6P5KREQ6XD6kMWyfsYu6D4gaACELnLl4BoWzZqmzHP6kb9r73Q/fA7vZguQzh1u4yqZxr39nstrwRbhaW8HFyiY9r/b0rJ0wWW3YlJSnHj9eAKHtUbHsb3XBcP2HQPgA4PvHgYIAeo7yZIxWY6XDCZPVhl5T44yuysPlEyuZrDZcrHS02LmKly7zuai8FghD2wNHfoKiKEi9736v9/MnT0bfdX0hZIEqZ1WL1XlhzVrYzRYUzp5z1W0piqIFwvuX3++H6owlMRAS6WZ0fyUiIh222fO1L8LL4o0NhO4vuhU1FcgZMlRdbHvPHl3H7nqkNhBmB1Yg/DL8iHZ9/7ZAfear5+RY3DN2C86XV+tqo0/tUg0/1v7/uTDmz3CM7IA99ixgoqkuFLq3yK9a6uM03WWBsOSSAyarDU/O3Gl0VR6qa1wegfBfq4+22LnyRo/2CHgZzz2PS3HR2s/KyPZA+ABUJCX5DIyVGRl4cOWD6LKsS4vVCAAlGyNgN1tQMHWaX9q7fOhosJMYCIl0M7q/EhGRDpuS8uoC4d5ThtbSbXk37Q5C1qB3YDdbUJWmbxmJXb3uVb80ZzU+AU1rGvhDgnZ9u0+IQUW1U/t5yFp9waPn5FiYrDZMrx1yWjXqf1A88iZsOJID5J8AQq/3DITr3m/Jj9Q0lw0ZLShVl+B4ft5uo6vysmR3JsZEnMA9Y7fCZLUhJjm/Rc5zeuBb6nDRmFic/eprVJ85A2TE4eS9t6jLSITUhufQF9W/zx3v0MJg2fbt2ky8b0S+0SL1uZVu3qzekRw/3i/t/WPTPxgIia5BRvdXIiLSIepYrhZQlhoYCB0uB4Qs8OSaJwEAGc/2g91sgbOkRNfxO3vXBsJTB1qyzCZ7ZrY63NMcEoW/DI1EesFF7Xr/eYi+mS0fGL8NJqsNQ9cdA5wOILQ9To+4BUt2Z6o7XMgCDvwAnN6jhq/wAS38qZogJUoLhNnFl2Cy2vDqdy03O+bV2npCvWP++PQdLdJ+Ws+HYe94B1zVl90d3jMbGff/Vf37PlQN9+ff/L06ZHPOHORPnISMRXPQSe4EIQvcufROJJ1LapH63Mq2b1ef4R01yi/tna88DyELPBL+iF/aM5LEQEikm9H9lYiIdNh4JEcLKFrAMEBJVQmELPDyxpcBAKkPdENypzt1L7a989Gu6pT8mftasswme2D8Ntw8xIbn5qoTw6yunXX0zlGbYbLa8MmKQ422cfeYLTBZbXhn6QF1wpHQ9jg+4k5M25ziuWP+CTV8hb3SQp+mGZLWaYEwLV8NwwMWJxhdVYPuGbsFtw7z/0L1zrJyda3Mxx+vezHnEDD2f5HZ7S/qepv/ugEIbY/i125Ul31Y9B0AYFbirFadrbN8717YzRbkDB3mtzbvX34/uq3o5rf2jCIxEBLpZnR/JSIiHdYfOqsFwh8MDIQ5ZTkQssCAqAFQqqvVL869H9V9/I4+aiBMyohvwSqbRlEU3DpMXWbhkxWHaoeJHoPJasPgZQdgstrw+sLG671j5CaYrGqoRHEmENoee0MewLB1V8yoWvseljzTQp+oGY6s1ALh8bMl2mcPZFe9UL3LBThrvF6uOK4+F5j9Xu2Q3rxj6tIhoe1x+sGbYTdbUD3vBSC0PYpevkmdVGmJOsvnyxtfhpAF3ox8E+WO8uZ+NN0uJSbCbrbg7Jf/9FubPX/qiXt/vNdv7RlFYiAk0s3o/kpERDqsvmydvO93GRcI086nQcgCH277EFUnT8JutuBUf/3PSe147D41EKbpm4SmNbiHSD4xYwcmRSerQxGnbUePIUuwfM1q3GZdh76ztjfazq3DouqWa/j2QSC0PXaHdMMHYVc8L3kxXw1fC3u30CdqhgM/aIFwf0aB7ruiRnKH9cPZzVyCYvXb6mfeMgJw1IXKko0b1efyJk5SX5h7v7rf5hBkvf22+sxsih0oSkPBm+oyKiU/fgsA6LGyB7qGddV9x/xqucPrmY8/8VubfVb3QSe5U6t9hpYiMRAS6WZ0fyUiIh1+2p+lBcJFO1tuoevGHC44DCELfL39axSHhakzHE6brvv47Y/fb2ggLK+qwYqELJRcUpcsiL1sOY/XF8YjbN9p3G5dg+KRN3lMAHMx9PdAyZl621UUBQ9Yl8JkjUDHYRu14xJGdNVmLdVUlqrvzwugYXnx32o1bzuirskYuqFln3+7WqEbkmCy2hB1LLf+nS7mA9m1Q18VBUjfCpQXAVnx3hP8KAqgKHVLqaxaVXfndE5XQFGQ/cGH6iyidjsAIO+tXurkMyvmotpZ7fF8bWuoTE2F3WxB1uDBfmvz6bVPQ8gCDmfLLevRGiQGQiLdjO6vRESkQ9i+ukW5F+4wLhDuPrsbQhYI3ROK7I8+UpeciNc//HP7E2ogPJ7S+ksaKIqCD8MStWtY4/RcxmDUxiTsSivCW0PHakHBOekvdaHhxIZ6264+tRcIbY/okEcxfNhn2jEvDJmOPtOuuLtYO+EMZt7Vwp+4CXbN0Gpeu/MwTFYbZm3TN3Nsq6ipBgpTgYrzQKU6gdHCHRkwWW34bsfJ+o/77hH1c9kj6u4Ihr0CTLV4LwMy4f/gsP4vsh7+M+xmCy598N917238FABw5vPPYTdbUHFYXTYl580+ah/4aQbyyvO04aKtpfr0adjNFpwe+Jbf2nz+5+chZIGy6jK/tWkEiYGQSDej+ysREemwdO8pLbg0+AW4hW0+tRlCFpgSPxEp93ZF8p13wVWlf+HtuCcfgN1swTF7y8wO2ZCVCXV3WadsSvG462qy2hB9PBdVVRVIDr1TCwLK+VOYO+YD9c8JC+ttu3L7DK+AsXDU2zBZbbhn7BbvA0b/FzDlthb8tE0UN1GrW47a5bGeYkBYNbDu2s7qAigKtqcWQlhX4bOVDQxtvTL01bfNuRfOIdd7rCVYY72h7v0s9ZceOdYhagDclwBHfr62b8WqyThedBxCFvg89vPWuSYAHHl56rDt1/v7rc1XI16FkAWKK4v91qYRJAZCIt2M7q9ERKTD4l2ZWnBZsN24QLgubR2ELPDjqhHqULV/vN2k4+OeUgPh0RNxLVNgPdILLsISEu0RAN3bgMUJeHrWTpRX1QDJNiC0PRyhHTBznXpnb/KEEUBoe1RvHu27cUVBxYZ/AqHtcW7kH7Bs+IvIWfkJeoX+BJPVhr8MjfSeCXP8H4Hxf2rhT90EW0O18DN7VZQWkANCfpJ3gKs4j4tHI4DQ9pg3vp4AVlNdt/83NwLRQz1D5WXDZKEo2gQtdrMFyR0tUE7GAes/UIf41sodGaquNbhzJzJf+VvdQvSrxiAuOw5CFhgbP7Z1rguAmuJi2M0WZL74kt/aHBA1AEIWyCvP81ubRpAYCIl0M7q/EhGRDu7hcSarDfPjWjcQKoqCipoKAECYPQxCFtgy6l11uv3vv29SW7FPd4PdbMGRpJiWKNWnkksOdJ8QA5PVhle+3esRBj++cuKUbaPVgLBrhvbSmBmzgND2KF/9AaAosG9ejEVT/oWC1ATA9iUw/Q4tWLw2dBJMVht+PnzWI4CeL6/2PM+UW4HRv2uFT69T9BDtM0xcshomqw0JmQFyh2jVW2ptMd8APzyl/jnvGLCxbmhu+eG1wM5pQEEykLlDnUHUHSRn360NM9UC4IaPgaT1dT+jbjIZu9mCs8/f47OUvHHj1GcGt25Fyt33aPtXL/tQ6xvzj8xvrSujLZGR0bev9pqiKCiYPgPle9VnV2uKi6E4nbrbHLR5EIQscLo0gO4QN4PEQEikm9H9lYiIdJgfd1ILF/Pi0lv0XOcqzmFl8ko4XeqXyOjMaAhZYHv2dnx39DsIWWD/y0+qd0ZOnGhS27HPdIfdbMHhY1tbonSfoo/nwWS1od/c3diZVugRCL2C2tLn1ICQc1h7acSCFUBoexya0AeXds5rcOjhI0MWaRP//HVopHae9IIrnseaWTss9Wom7tgcog6ldLka3E1RFGQUljW8Xl/E59pnGDl3CUxWG04WBsAzZEXpQOj1wOS/Ao6KujpTouuCYmNb5Fd17cWOU4frFqYAaVs8AmHhvHm1dwfNcMaH+SynYOpUdVZRmw2pD3TTAqFj6H/j+XXPQsgChwpab3ZWxeHwWjOx0m6H3WxByr1dURoVBbvZgsK5c3W3+eG2DyFkgbTzAfQMaTNIDIREuhndX4mISIc5MWlauJgb27KB8Km1T0HIAqtSVwGom3Xw8u34PV2QfOddUBoJI1eK7VsbCI/6eK6uhaxNPKM9N3jwdLF2Hb+xXRFmFUVdb27M/3gEteE/bqs3bGwJ6YUD8XHazxbrGpisNoyLtHsEz/2nrrjbNu8B9ZjLhiPWy+kA5L5A7Pi612qq6upY8bp6x2vHZHVTFAySD+DV7/bC5VJgXXMUJqsNaxPrnyUV6z/Q2vt6yjyYrDZcuFRd//6t4dTuuruA2yerr+2cqv687ztgYS91KO/IDsifcJfn/5sZQt3CXgYuXjb00eUCqmqDrrMGWDsYsG8EAOQMGaoOB40Mr7ekwtlz1GUePvscaT0f1gLhrm/+F0IW6B/Zv1WXa1AUBXbL7Uh7+BHttYtxcR7PQro3vb6I+wJCFkgqCuxZZhsjMRAS6WZ0fyUiIh1mbq0LhHNiWu4394qiaKFvzqE5AID3t77vEQYfmH9H7TC1Z5vcfsyzPdRAeHiTv0uv17L409qdVfei6yarDdM2p3jueO6kGiauWB9Q3p2JnSHdtbCRNuL2uvA07J+4b9xWZE/ujsMjOkOEqovTf7g88YoJa654Hqs2zOBifuMfoDC1Lui4w82VyyZctlXkp2vndc+qarLaMCEq2aPZg6eLMXz9MVyqrvG42/bJmMn4q6/nHv2p6qI662fSOvXOn9vZg8Dse4DJt3h+Lvcd26Or1J9H3QCMugHK6P/Gn60b8cK83XXDRZsZyE6/8aY6/PN0/UMli75bWBeybu+o/XnQ/FvUodSbPq8bntpKku/qjNQHukGpqcGlgwdRvHSZVxg8+cwzutuz7rRCyAKJ+YktWHXLkxgIiXQzur8SEZEO0zanaF/sW3I5gNyyXC34TTswDRtPbvQIiNGnorFy7ZjaxbA/bnL7Mf0ehN1swaHEqBao3rcF29XhtvKeU0gvuAiT1YY/WzciYcnXQMxYIGufeufo2GrvIYYASiocMFkjMHLYJ5g87B18NHS4FlSmzZmhtWeyRuCJGTtgstrw/LzdHoFw+b4sz6KWPKO2UZzZ+Ac4tasuGK17D4ibUPdz2CtAxnZ1WGXta5m7Vnmc2z109Z+rjmhNOl2K9v732456hK/3h43Cvd+08JDendPqzrmwt3oX9GKe+ryfr6BbO3wZlSXqmoHT1FCuLH4Ct4+Ixh0jN131nbm0hx+B/faOUKrrvzPqXqPQY3v/LQhZ4KlFZjhD26tBtxWl3Hc/Uu6+B+e+X+xRV/b7HyD5rs6wmy1I7dZdd3sjdo+AkAX25uxtfOcAJjEQEulmdH8lIiIdJkUna1/gZ25tuUC4L3efFgD/teNfHncGa1w1AICSDRtgN1uQP3lyk9uPeU4NhIkHbf4uvV7TtqTCZLVh1YFsZBeV4uUhU/HNsPc9A8e3DwLLX1X/fHi5Vxt70ovqZiUdXrdEw5kjsR7ha+APCTBZbej6zVaP173u6i7/m9pG7tHGP8DxtXV1jv4vdQttrz6HWFag7iM/q+1zdPlwr4lz3LOpuh09c0F7f+KEkR7X4p/DvsYTM1pgWRBFUYdpFtjVUHf59XcPoXVvKdHq3cPZdwPJkb7bK80FHBV4bq4avs+cv9Ts0lxVVbBbbkd6r94N7nf2q689QtepN97A8F3DIWSBlVNvqqv/+8eB8nNAziF1ttMWlPrgg7CLTjj12usetV2MiwMApPd+FHazBa7Lgm7p5s24dPCgz/bGxo+FkAV2nGn9pWH8SWIgJNLN6P5KREQ6jL/smbTpW1L93v6Fygv48cSPHgGw5089PX52K5g2HXazBRdWr27yebY9/xDsZgsO7t/oz/IbNDbiBExWG7YlHEb1oic8g8eaQXWLl7u3gmSvNvJLK7Xrb52ztG7fcydx+ly59t5zc3fj1mFRXktbjN54xfOK695Tj8/08aVbUdTnBU/vUX/et8D7jln0EM8Jac6fUmctDW2P5OlPe5x7y4l8mKw2PD1rp7b75qQ87f1Fw9UgXDb6D0Boe4wZ9gH6L4r3w5W/TGEKMNGkbxKY0PbqZDI6/Wu1+oxkTLKO4bc+OM6exbkfluha4L0qPR3pvXqjxIGbHgAAIABJREFUPD4eFceOw5GTg37r+0HIAiWjr/f8DNOF+t9Nw5pVl17uwHfl5p7w6dSrr2lLxCjV1XDk5Kh3De+73yMkuk3eP1kd/nq69Z7zbQkSAyGRbkb3VyIi0mFMbagxWW2Y5sdAuPPMTkw7OA29wnt5TRxz+fbkmie1Y7IGD1YX4z52vMnn2/ZCT9jNFhxI2OC3z9CglCiUjr0ZaSNuR803f/AxFNGlbpdNqqINT7xMdY1Lu/5Lo3bW7VtxHgDQe2ocTFYb7hi5SVviwr0Goclq81483b3Mw4mfvWvOTvCY/RLbxqh/rh0mifF/0s7roaYKGPcHVI36H5ita/Fl+BFMjE5GjdOFvwyNRNfLhoH+WPtc5WPTt2N3SDcgtD2+Hf4GENoes4YPwCdXLsdxtQ4vr/tM4/8IzL1f/fPyv6mTvCStrxtGG9re87nCRnxfu0Znc5ZjURwOpN53vxai8saN09778cAh9J0Tg3NlVfUe73Q50WVZF/Rc0b3hgPvdw0CRn+7slxUAF7K1H08+9bRWf86QoSiYPgOZL78CV5Vad/748dr7qQ8+6BEaS7dsQWVKChx5dc+4zkqcBSELRGRE+Kdeg0gMhES6Gd1fiYhIh9ANSfVPhnIVeq/qrYW+/rb+2p+7hnXF4C2DkVKcgtOlp1FcWTdLZlrPh2G/vSNclZVNPt+2F2sD4b71fvsM9akqzIAy/o8eX8ydGz/HpGHvAKHtUTP293U7Ox1AlFW9G1ePTrUTxiRlnK1rs/a5tUU7M7Tg129u3fOD3cZvg8lqw5vf7/NsLK522OlB2ftEKVF17ZfmAKv/of45Zqz63/j617lTavf9cPgoOJx1M8DeN24r/jI0Es7aiWKm1w6j/XHvKVwYeROqRv4Og4eGAqHtsXT4Swjd4OcZJvd9V/eZMrb73qcozTMI67Qrrch36L6CoigI35+NRTsztAlzKpOTtUlXSjZGwHVJHXaafTEbQhawzO/b4Ky+Z8vOQsgCb0a+6RlofW3zewCOpvcZL1NuVdurLgcAZL7wYl3Ai/QeXqtUV6MiKQkZzz3vdRcx4/kXYBedPCbT+fbItxCywOrUpo8ACCQSAyGRbkb3VyIi0mH4+mNayJiyyT+B8FzFOY+7gOEp4fg05lPcufROjwB4OVd1tbruWZ/HmnXOrS+pU/Uf2Lvuakr37WI+kLoJiPwKF6d01r6Ib5s2ECHDPkXmwc1QFAW3Wtdj3vA3kbg3pknNf7Q8Ef3m7ILL6fIKLoqiYHtqIcqqajBIPqD9v3JPLnP5cE0AdQFp1wzvEx1YXM8wyjR1ds4GlBz4Sf3M457zeN39nN3ZC+qdtyFr1b9Pew4eUZ87HHEXXhyiTvSyIeQJzPb3xEU7pqifYf/39e/jrAEWPKTerW2CgouVWvj2WlfyMoez656b3JdxDgBwYc1a2M0WFEyZou3ncimIzYrV+sWC7fUHwj05eyBkgWG7hql3mt3/r6aaff8/vGLCoiapLvecXXb120D0UOQOHaIFvJrzPu4c13KWlSH7o498Di+1my04v3IlAGBN6hoIWWDuYf1rFwYiiYGQSDej+ysREekwZO1R7cvs5E3ez7g1h/tL76OrHsXXO75GuaMcDqcDF6vrDx01xcWwmy3IfPGlZp1z68uPwG62YP+eNc0t27eC5LrJVi7bDo64B/eOUodtnipS76jUuzZgU5zeoy6R4IM7bJmsNgxedgB/HqKGFQ/u5RO2jPRuIOYbz8+xoKd611CH3UmZqBr5O1SMvsljMpMvfjoMk9WGXWlFAIBB8n6YrDac3rMGCG2PlcP7ofcQNaRuD3nQe1bUq7VlhPpZjvn/rpOiKLhr9GZtMp9Kh/eQXwCIOJrjNetrztBhHnfWIo7m4PYR0fhX9LK62Xbj6p9cJfpUNIQsMGV/baB0/z+L+ALYHFL386gbgIl/BkKvV38Z0IRnJGs/pDqjrI+QeX7KV01aazD90T4+h4+6J4mKz42HkAWG7hzatBoDjMRASKSb0f2ViIh0+GrVkbpZIaP9EwhnHJzhsQC9HtVZWerkGwMGNuucW19RA2HCbv3n1GX/99Bmd4yfjwGjZuPpIXNgtq7VrlvBRXW4nvvn42dbZr0496ymJqsNn648hC5jtuC24VGeyyKkbVXr3fBJ3WuOCuBkrLrQvPsL/5Rb1WcDdVq4IwNbQx5Wj02vC6Gzt6nrWC7bewoAtOUxyreMB0Lb4+cFI3GPVX3O7/CIzt7rJl6tiM/VmlJbZv3JjiOitWseuiFJGxp7OfezhiarDeMj7XCWlSO5cxck39UZztJSAHV34m+ZEKIFwrfWj673vJEZkRCywIyDtXd6f3wJGPcH4EJtoB73h7rnP2PH1/1/HXdT0z6gfaN3GKydmMi1ZTxyrENQtmu3rqYcBQUo2bgRlampSLn7HqR0vU9dRubTzwDUDZcdEDWgaTUGGImBkEg3o/srERHp4L7D42uB8eZ6K1pdPy31vP5JaipPnFDXOPvwo2adc8vfeqmBcGd4s473yeWsmyn0xAZUOpwwWW3oOTkW/1iyX7tu5VXqshnun9MLyvxXw2XcE7a41/5zTzjjPv//Z+89o5u41vZvfXjXu95PPO2c5zzP//xPlJxzciRg03sJhJYQQgg11AQSQockkIDopvdeTDFlMAZjTDFYuFPd6TZG7r333mRprvfD9ow0SLJHsmSZZH5radmWZvbsmdGM9zX7vq8bAJD93DCwz3lBcwWP9xUO+BMDgeoiq7a9yus1flv/m6ENPxWgreNnxzb7vEG9Vod/rLuHvjuCwV6bA7h0gtvly/inygdw6YT0TR/jWVtmT83h/QPtT4ZjattNeqfuo4mrK4ROvQsuPUPpo8fQKJTIWbmSX4a7zj7et5IXhAPcR1isccjV6Tz64ih9Q9dETXI4djaXojg5kDrBGp9fMeiagNxXwMEuwnWvzzM8VPBZKvYwmaWpqIjO+k+aDADQ6rXofqk7Rl5vuQRHR0cmCUIJCdE4+3qVkJCQkBDBT54vBbMbbaVJ34R+Hv0w4MoA6My4alqiJjqauhmuWWPTdoOmj6SC8PE1m9Y3y6ur/EC5MluDXX504D/tdASySmuh2OgHxUY/3kiEO46ZJbbXrWuJAKOSDlvvvsW0UxGQq9TIKq1FU7PRS31JhmCAr3WhJSPebuqGmB2fIOX4JLDGZSVEMu7oE/RUXRWKB9chKHpxl+8TcQnAP1U+WHQ+FDhKcy333Kb1E+s2/wklm/+K1CI7i2Uu3DHfemdaMWSV1mKb71u8yalA503+UG70R2W98Pj9bHQNfbL3AU4v2EiF0Ck3fpkfmh8gTL2uEuTXvi0xFZgAcCvpFghDcPLVSfMduzpDKNqsFYThxw3Le31HZ5D3fwxkPTWY8DDjxbVlAZZlkThoMDWZ+XoispevwJyTw9GN6cbXHn0fkUmCUEJCNM6+XiUkJCQkRLD0ygt+MLvTDoLwbclbEIZgQeACq9aruv+A2vNv3WbTdoNm0JppUQ+v2rS+CbWlwNmR/KD5W7dw/jhxpRNeZJbxuXOAQRBmlTpGEL7ILOO3ceZxCha5P4dcpcaMM5H4aK0a44+F4osjT/Djui04uP4HxG/rB7h0QtDGEfinyodf91VWuVXbbdLp8fEGP/TYGgg2/BhwbY7BkdKlExasd4FcpcbcddtRvvl/DULjSA9eRJds/ivqNv8JFXXWi9EWOd9c/7HczrmJZuDybS+GpQnen3EmEnKVGp2bw0vPfToVGoUSvpcN+ZlTXOn35+eQ1SAMgeL4NBCGYFnIMtQ3mTqEcgYsp19bcKdtaqRlROppSCpyXxqOe0sF67mHNMY1MityhMto6+n7h7u1ekxaoyYyEgl9+vL5hP5f9AFhCAprC9vctrOQSYJQQkI0zr5eJSQkJCREwIkKuUqNHWrzsxXWcDX+qk1OghV371JXxoOHbNpu0MxmQfjgivUr6/XUXKO+EnhzA3hyENj9AT9grs00hNXKVWrs8jMvnE8/SsESj+cWwwDbSlZpLd8Hn1c5WHcrVtAvc6/vTvhjIRONYyFJONqc77fGO8aqPiYXVkGuUuOb00ZhmSwLhB8DXDqhYfc/0LDlL6a5aJGuOBiYALlKjezNfwdcOoG1YtZYFK7NdfrqrBO5tvAmpwJylRqjDj4Cy7IIfluA1KJqfL/2Ej5afQcud+Lwj9U+eN61B1526YZdNw3lKkYdfETNgAIXgzAEH7m4otu5YSAMwZe3voSmRPid8krwAmEI3GLd3u2GZdxGmxd4HOmhwNb/Ag51Bbb/t8Fh1hw7/hfYIxe/7RaoT0hE+qzZdAZ/UM8WZ0bfB2SSIJT4A7FcJpM9l8lkjTKZzMeG9Z19vUpISEhIiMC4lME237YP0lRPaEhcaE6oVeuVXb0KjUKJ4jNnbdpu4CzqcBgZcln8SiwLBLsA2/5s3sq/+XUjIoE/Rp8ffuywGcDW4HIYufIGu/3iBeIvubAKN19kY9zRJ5Cr1Bi+7wHKaw2zRRklNfjneuqMeiRYfPkH/zc0VHXj7XfCMktS3jlW/wbcmE9/3/7fgE7Lm84kbupM32+ucWc3DnWl7dpbaFqAqwXp8yoHH65VY8+CrdAolFg3eRWepZdixVQVNAolzg+fgllukfx6fXcE4x/r7mGmeiYIQ/Dhhiv4cIMHJt/8HoQhmKmeKdjOFc0VEIbgwpsL4jvnOYsei1wLdRMf7RWer0sTLLe1+wMqCu1IQt9+iOlBQ2UfZ1t2WO3oyCRBKPEHYrJMJpsok8lOyCRBKCEhIfG7Zd6F6BYNM6zl8xufY9ixrkid/z3q4louQt6YnYOCffugq6xE8dmz0CiUKL1iwwwfgMA5Y5oFobv4leJu0YHx1v8EDhFqsOE5i5ZnSH3ED5y5cD+uxpwz6f6LJwYvu4iMkhqBIZBcpeaXiUotwdwL0Wbz9cJTaLH1ge+Wq2imolYL7+fZqG005HhxM5EX3gmVFNTHc+lEzUhYlpa+KKXLnnqUArlKjdebmus3WmlmAwAIPUTLLeiaaBmQY33obFdiAG3zWG/r27SRM4/p/ixrDrWOIr2hUSgR0bM/Sq97Q6NQIqZzV4ybfwwjDzzk1/t4gx96bwvCuJvjQBgC+drbkKvU+P5iNEZdH4Xul7oLyrJcfnsZhCG4FHdJfOfu/kyPx67/S0tRBG2ix4xDvYp+HuNFTXhqWvg+7/+YzibakeSRdBa/+4WuuJl0065ttycySRBK/AHZIpMEoYSEhMTvljnnogS2+m2hrL4MhCG4NYEOklO+GGdxWVav53OLCo8cQeGhw9AolKi4c8embQfO+YwOzAOZlhcsSgRS7tO6dcdpjh1SHphfNjkEuXGh/Gybo0JBxaLNz0d49754o+yCskdPcD++gD93d17nimqDZVkc/2Ietk/6CQDQmJ6OhpJSPE4sQl2jDmRzAOQqNS5HZgAATjxI5rfxMMFM3tftJTRs00Jhe64kQ+SmAfRYl6W33MG6MuClB8AZ39SUGARn8BZqgML9fbgb/ZngL2rf7cGN59mQq9SYcDwU8jW+fG5cRK+B0HQleNO5K6bO3Qe5So2um2kpDG5md8T+hxh8dTD6Xu7LH9OlHi+w9slaEIbgbspdfjtMHAPCEHhoPMR3LjmEPtjY9ifDMTKuz8jNIFqocyngEGmeedWL334rpE6aBI1CiUGuXXEm5ozd2m1vZJIglPgDskUmCUIJCQmJ3y0zz0baTRDGFceBMAQvenejBaoHDARAxV/tixeo9PdH3atXqE9MRPnNW/xgOuWzz5H8GRV0VSHmZ65aI+C7z6FRKBEe2EKIXX0lDYMzntU6/Qmd1bJAYJyFcEknwIlmjUKJnF9/AwCkFdfwLqdi0Obm8m3UNZf6CBs9HnIVNaUxnnE0Fpwtuqe2cPzcI9JpWxuH0eNd0MIstF5vMDvxWQY8Ow+cHGQ4V1v+nZZZMD5/V2dabs8BBL2lx6Tn1kAMX+wmKMCuUSgRsWqD4JhV1WsR3LzO1NNh6MZ0w2jv0SiorOeF5dP8pyAMwUSfifx2zsWeA2EIPOM9re+ksYNo0GbD+3yOYXbrbRzrTZfVmhre2ErG3HnQKJQYfagrdkTusFu77Y1MEoQSf0C2yMQJwi0yeoHwLwkJCdtxj0jH4WDxNdwkJGxl2ukIfvC6ycd20VOrrcX4W+Mx0LWrYICcOf9HpM+ebTJwNveK79UbTcXFrW/MDAFzmwWh/3nLC3H11Vw6AYEbgEjXVt0prz3NhFyldur12JCcDLaxEakTJ/HHKuNb24p7V/r7820kDv+U/701c5o13jFWCU8O7vj5bhxDj3v2M/ML6pqAW4vN53GeGQ7c327+s+Jkm46DrUSnlfLH5Ocpa0y+w7WxsQjRFPC5hteeZmLQrhA6ixubCMIQTL07FXo9i483+KHXtiAAQD+PfvjE8xN+O2djzoIwBNcTr1vfybpyQ33BHf8DXJkORJ0G9v+rdRdSDk5411dYv30LZK/4CRqFEl/v6oqVD1e2vkIHRSYJQok/IFtk0gyhhES7029HMOQqtf0t2iUk3mGyq6GcQltmwbZHbqflJtZ0aVH0JfYfgMwFC5D+zXSkjPsSDWlpKLvmhaxFi1Fx927rG7JAwLyxVBD6nePfY1kWx0KSEPqWhj8iZCsd5EabN665/iwL0WnCwumuD2nO2KWIdJv71hYq/fz4GUGNQomkT4bRWdWxX4hug2VZVAYFIW3KVIvn5V+/3sKHa82LQa9nWTb3/+YLGmLpvXE8PfZpFsxE7q2mnx/sDBztRV8+S4HMKDoDybLUBOVdQdjOxGeXYca3e7Bi6lr+2F0YPhnRg4ej5OJFfrlfr78WHMPlV18ivSIdhCGYHzgfADD2CDX/SSmqxsArAzHoyiB+fdfXriAMsT3XTq8Hbi0Ctr/j/rrnQ3Hrn26e0a2x7QGNOfI20vqMszd3wZx7c+zWbnsjkwShxB+QLTJJEEpItDtcHs+z9NLWF5aQaAPcTIZcpcaG27E2tzPaezQtpD21MzQKJUouXkT1o0fI/uUX5G/dBn2tA5w5I04AN34EWBYB876g4Y9qg9iLy63Ab+t/MxTfPtGf/l4Yb9JUTnmdiTkLAOy6p7EqR8/epE+fIRBu+Tt2IqFvPyT07iO6Dc7BVaNQQqPsjMCRX6HPTx5ICn4CTWcq4Bds9cKR4CR03xLIH4fHiUXwiMqAzoaZQY67r3OpoN4wpeV8vyM9Ws8xLM+khim7/i91F42wULTdgaQdczUR0/9Y7YODQcIZ5Oi0Uow88BATjofi2tNMNDbp8arwFQhD8OujXwEAR4KTeMfXoZ5D0c+jH7/+8ZfHQRgCn2SftnW4qQFIewKEbAPOfQY83C1uvXNjWi5hYQMFe/dBo1Bi4ZouGHtjrN3abW9kkiCU+APx/8hksv9PJpPtkMlkd5t//3+tWN/Z16uExHvNP9ZRa3iPqAxnd0Xid86Xx57wAmDdLdsF4ajro0AudkVYHyXedu4MXYX9Qs0sws16VOYi4Idx0CiUCPU1FPJ+EF+IMxtmCmdIDhGzOW8vjYq+G/Nb80yPcQF6R8PqdGC1WtTFxpqIj+rQMKSM+xIahRK66tZLOLBaLVI+p7Onlf4BYFkWC91pqZGY7HLEr14HjUKJ7etO0eVZFrvuabDi6ku7mOhwJStObWg2NHlzw/yC+/9F3V5bozwLqMxrc79aQl9bixI3N+iqTV1aU2fMFJyPp98uwGafN8gua/2Bx6OsRyAMwfbI7QCAlKJqyFVqjDzwEJ96fYpe7r34ZY++OArCEPim+tpvx6zh4pf0fJWm2q3JkgsXoVEosWNpb/S93NfpJk22IpMEocQfiC2yd3ICZTLZIyvWd/b1KiHx3qLV6fmB6eY25HRJSIiBC1uTq9RYe9N2QTjUcyiGH6X5g0mTJra+gj3gRF5JCgLmU5EUeucU//HzmwcNy3jOomIw4oTZpu7F5vHHwXhGbD7zFHKVGnG57SBwAdS9iUNC/wGI794DiYOHCHMse/aCvqGBN+dInzkL+dt3QFtQwK+vLShE7po1SBw6FJk/zOfbSJs6jV9mlRcVueHJxXhxkg7SvWcvE/RD3ygiz0wEnDHNofXf0/PwwkJZkF1/ozN/HYDctVQkZy0VHhNdVRU0XQw5sm8UnRGTWmChFVN8kn1AGIJjL4/x7/E1Iz1HohvTjX//4PODIAyBX5pf23fIFtwn0fNVlGC3Jutev4ZGoYTP+D4gDEF1o6ngfh+QSYJQQkI0zr5eJSTeWyrrtfzAdPqZCJPPi6oasND9GWKyy53QO4nfG2MOPeK/b6obMTa308+jH2YfGACNQons5Svs2EMLGNfAy30J/x/HQ6NQ4omPURih8cxgsql7Kcuy+OHiU6z0egW3J6n8cSiqauCX4XIsc8vrHL9PAIqOHrOY55e1eAkAoPTKFcSTboIwUgBgGxv52UDjV/LIUdDmGEL/Nvu8gVylRmBcPoIiExGr7IKXvfuj2NUViQMGImXsF9B07oLs5cvRVNq2sPUnSUWQq9TYsb7ZMCbKQrmBbX8C9v2zTduyF6nj6XcpoU9fwfuVQUGC4+o7cLRVed5cKQn3twZRzNVpHHh5JAhDoNPrAAD7nu4DYQgC0wPts1PWcnUGPV95tt8T3oVtakJCr9543a0Lul3sirSKtNZX6oDIJEEoISEaZ1+vEhLvLYXNduRylRq9mx3ojNnUPJj7eL2TnhxL/K4YceChwEnSGk69PoWpd6eiUdeI7pe6Y8X2wdAolMjbssVBvTWirswg9tIew3/BV1QQ3mqeAWysEQjCptQnJk2EaAxlFb6/+JT/fec9DViWBcuyGLCTOkTWa3WO3ycAWUuWQqNQoiYqGtVPQtGYnYOUL2g4bJmnoQQB29SE2hcvoFEokTpxElitFnkbNxnKUqxcibrXr1HqfhmNmUIn1X0B8ZCr1Lj1MhteT7NwffAXpgK0ObcwcehQNKan27w/ESklND91fXPR9NBDpgvpdYa6gh0Arl5efPcegvfzNrsIjtGTadY5vXJhoMb1BjNLaiFXqUHcRoAwBHG5NDR5T/QeEIYgJNO2Mixthqv3aMkV1kbSvvkGGoUSw491xdP8p3Ztu72QSYJQQkI0zr5eJSTeWzJKagTudMXVDYLPV3q9MpvrJCFhC8P2PeC/T79df23VuoQhIAzBs/xnIAyBy/pPoFEoUXTsuIN6a0RpqkHwaXzhv5AKwtCbzdvOjBIIwook4Wx7THY5PrLgqilXqXE0JIkXjF+fCHP8/jSTNGIENMrOAhOenJWrEN+zF7T5+YJlWZZFUnPpCO5n4oCBtEyFzrKAPfmQFpt3j0jHmccp2PzVMipyunRF1cOHqE9IgK6iAjmrV9PSIQsW2Lw/nCBctW4NPRf3zdSfa6imn50YYPN27EnatG94UczBsiySR46CRtmZvoxmZsWyNWIrCEPwONvgtMqyLPruCEbnM3SG8NMDtJj9jsgdIAzBw6yHdtknq7nxIz0n6fb97ueuoaU6Zmzp4rxw2DYikwShhIRonH29Ski8t8TnVwoGpuHJQjOLjbffSIJQwm4M3n2f/z79aqMgfFn4EiOOGHKrSq9csX9HixKA20uoqQgAZD83CL5XV+G3aAKdtbnRnJ+l8RUIwtz4KL6pwqp6fuZvsms4xhx6hBVXXwquu783GzvJVWq4PbGfsUZLsHo9NMrOSBr+qeB9XXUNtLnmXU4L9+/nj3v6jJlozG696PiN59l8mZF9AfEYvtgNMUOGodzbW9ifxkYk9h+AeNKtRYHZEuHJxZCr1Fi8bhM9FwHrTReqLjLUG+wAGNd7TBn7BbJ/+hlFR4/SXMzJU1ATFY3iU6fRVFJiVbsrH64EYQhiioQz8fOZZ+h8egy9nrbeAgBsi9gGwhA8yTad2W4XfJbSc5LywK7NFrtSl9aVP3URhM6+T8gkQSghIRpnX68SEu8txm6HcpUaF8KEeRZc/o8kCCXsASeM5Co1VnnZJggjciOw57vO/CC60j/Avp2sKQF2/pUOUI/1AaryhUXmo07Db8nXVBB6HwEAsK+uCgRh0ptn0OtZlNY08nmBq7xeC5wOE/KrsMj9OZZ6vOCPyYgDD9tUdsEadNU1NAR0/Hjx61RWInv5ChSfOg22qUnUOiXVDfj7unvouyOYv58ExOWbXTZ95iwarnrNS3SfjAlNooJw7rod9Fzc/Zl+cHMhsPcj4MynQOQp+tkF8bUV20q5tzcqfM3fQ5OGfmIxj9PSOq1ur76cv14yK4UhvAcCE9D51FgQhqDvLioIXcJdQBiC8Nxwm7bXZnxX0nOSaN9rmauruX9OZxx8ftCubbcXMkkQSkiIxtnXq4TEe0t4Ch1A9dgaaNb58ZdrhpDR6gZxA0AJCUv02R7Mf59WXnslej2dXscPcIMzgnHxK4MgrHr40H4d1DUBzHihQYzPUiDGy/D3433wWzIRGoUSj71ojlpd2CnBOsdvBmP0QYOBzoQTYRbzAstqGvnlTjxItt++tIK2oIDO9E2f4fBtzXKL5AUvV3PQHLlrVPx5bUi1fqaUmyGctnY/PRc3FwI6LS0x8W6RefdJbd0tUbCNjfw+vUv5rdt8SGhdXBx0VVWoUKtRePAQqsNsC5/Us3p8fuNz/nqpaBA61l6OzEBn13EgDMGQ/bcBABtCN4AwBFF5UeaadDz+a+k5eXvHrs3WazTQKJTwGNcZ60PNzBa/B8gkQSghIRqnXKQRuRE4/+Y8mvTSIFni/YWzaZ/tFgW5So0ZZyIFn8+7EM0PVscfCxVV/0qi45NWkYbiuvardcfRc6uhEPkvVgjCioYKfoB7O/k27g+kA+yEfv2hK2+jAy7LAmFHgafngMCNdGDqOgTIf0N/P6CgRck5IRG4EX5LaZjfo2t01qHQb5dAbPRTXeY7YndGAAAgAElEQVT3s++OYORX1LfYhWtPMzF0731klbbf9dWQkkJz9ub/6PBteURlCCIRnqabdxM1NlIp2LPX6u1odXrMPBsJXz81PRfXZgMlKfT308OEgtBzVlt3SxSNmZn8PumqqgDQ2o/523fwuZTlN2/ZbXs51Tn8tUIYAj2rF3we9LYAStfxIAzByCN0u+uerOPzc51CUHOIb6x368tagb6GzoKHDFRiUdAiu7bdXsgkQSghIRqnXKTf+X0HwhCkV6Q7ZfsSEvZAHZPHOz7KVWp8fvix4PNJJ8MgV6l5M5D2NLyQcAyNukZ+sKjVG2zs90TvwSz1LN6K3hEQlwBeFPzk+VL0epmVmXyfL7+9jKieSsR069L6imLIfSUUCjv/CpRl0M/cRtH3Lk82fH7uM/j9OIoKQs/9tH9eawRtzDsZgPDkYqQWVaPkHaOmjgJXpy37p58dvq3i6gaBqc6bHPN1FhszM3nDGuNahtZQ6e+PhuggwyxgUpBhptf4PN+Y35ZdEk1NeDgvCOsTElF57x5Sv6I5qIkDB6EmKtqu24svjeevlZnqmSafx2ZXQHnyaxCG4IsTNwEAqx+vBmEIXhWKf0hjV+43h/i+sn8+cPzQIXijVGKe7xy7t90eyCRBKCEhGqdcpFwSdkiGk2yaJSTsgHez4cOBwAR8tFaNgbuE32cuxKuqXov+O2m4nzW1sCQ6HiV1JfyAMSjDUGrkq9tfgTAEudXmDUXsQedN/rwoWHFVvCCMLYrl+3zqlStiOyvxvH+P1lcUQ9hRoVAINipjEXbENNTQpRP8pv6DCsIr+wAA6ZcWCz5nGzp+EWxOqOSub59QummnI/hzn1Jk+fiwLIvEgYMQT7pZXbC+PjHREJ7p0gk4/7khZ/DJQeF59Pq2rbskijIvL4NpzLgvBTmCda/sL8Ci86JBGILVj1abzA4C1ORIeWISCEMw/hQVhKserjJrQNNuPN5Hz8mzC3ZvOmU2zUtdcuFru7fdHsgkQSghIRqnXKRXNFdAGIIzMRYK30pIvAe4R9JQLteHKei5NRCKjUJr7t7bgvDxBvreXKPwUX07GV9I2B/jkDJj573PvD9z+CzBxxv8+O/QsisvRK8XlhPG9/lw2F5oFEpEftrPPp3iZv9uLQJCDwNNRiKkIgdw+TejcNENgPsk+E37JxWEHjSsMe3sHKHY0HX8VILKwEAamrlrV7tsb5XXa/7c55bXtbhs5oIFVDDFxra43LsYz8bBpRNwaig9ry6dgAR/4Tm61D4CofDQYYEITB41Grlr1zmsXEpIRggIQ7Aneo/Zz/V6FsrjU0EYgjEnaK3JXx78QusSlsQ5pE+twj14iTpt96azNq6HRqHEml0j7d52eyCTBKGEhGiccpFG5UXRp3CPV9u13SZ9E+b5z4Pra1e7tishYY7Tj1IgV6lxMSwNn+6ns4GJBVV4lVUOnZ7FR2vVGNQ8a7ja2zCgq5EMZt5bksuSeXHlFuvGvz/s2jAQhiAg3c6unUb8w6i8wlIrBKF/uj/f5z33qPFI6Lihbe9QUyOw43+Bnf+Hmo+Y4+KXBhFRQ/Mu/WZQI5CH7ruBpkakHf9aKDbeA8pv3qJ1HI8ea5ftbbkbx5/7spqWZ/6Kjh6zqaRIxV1fXnhljfiQusQe6U7PSW0psO3PhnN0dkRbdkc0Oat+NfRpyVLoKisdur1bSbdAGIKTr05aXGbqrQUgDMHQw/SB0PL7y0EYgoTSBIf2zSLcLG64/b+LxefPQ6NQYucvA+3ednsgkwShhIRonHKRFtcVgzAEU+5MsWu7xvH/EhKO5oeLTyFXqfEosQgTm/MF5So1PlqrRlizY9+E46EAgPRiQxH7jpoXJdE6xuGXJ16d4N8feGWgyayhPWFZVmAsstRDvCD0TfXl+7zDczGdnZs6qu2dyoykA1GPqZaXec7QZbb8B6CnIXh+M7tQQbhnOrD9L6jdLn9vBKE2Jwd1MTEovXQJGoUSJeftH6ZnjoNBify5t+S4ylH14AENZ127zqptlJw7L5iNE5QPAYD8WMM5Otbb1l2xivRvpvOzncZlRxwFE8fwubaW4GoU9tt/HgCwJHgJCEOQVJbk8P6Z5dn5Zgff/XZvuuo+/S6dmt3T7m23BzJJEEpIiMYpFynLshjiOQS93Xvb1YTBeLAmIeFIGpp0+Of6e+i+JRBanR7jjj4RDNi5/MEfLj7l1+HygD5cK+USvq9wOUaEIYLaXD3de4IwBAeeHXDIdnV6oSBcfPm56HVvJ9/m+7z1DM0JejBXfP08izzc0/rMRF05sP0vwBFDzqLfrK60D2v6m80x7CiU37iJ/G3bkb91G4qOHkXu+vXQdOkqEE1lXrbV/LMWtyep/LlvTRg1FRdbXSMRAAp27RYKQu58nB9rWIgLIb250JbdsJrEIUOh6UrA6hxn1mTMsZfHQBgCn2Qfi8twJjLddtMQzUVBi0AYgtQK60t92IXXnvSchGyze9MNycnQKJTw+qKr3dtuD2SSIJSQEI3TLlTOaTSjMsNubRrnykhIOJKiqgbBDOCHRi6Axi/VDYPRwLfnDXmEXs+ynNV1CRvJr8kXWNLviqL5Y8Z1/uwdBs/R0KQTfK8WuYsXhDcSb/D9czlIHRrvLzNyoSyIsxzyaYnqIuB4PzoQzXvd8rI5L+g2mvGbTaggXPZ3YMu/Q+/y7x1OEDamp1sseJ7Qr3+bi59bi9ezLP7ciyHp0xHQKDtDV13Dv6evr+dLN5gj+6efDfupVBjOx+XJhoUaqoCnblToOxh9fT3NGxw9xuHb4tgZtROEIXiQ+cDiMutD14MwBP/aTvMY5wfON1vEvt3Q3KXnyU9l96abSkuhUSjhO1zZLjO09kYmCUIJCdE47ULdGrGVOo1m2s9pVJ2q5gc+Uo1DCUeSWVIrqD242eeNWUF4INCQV7LQ/Rn//uVI+z0IkWgfTr0+JRCELuEuAIBabS3/3lz/uQ7Zdm1jk+B7teCS+Jpn1+Kv8f3buGUEFWOqefRDbnbBGkMKvR44YGQ8ojd1Y2yJe3O60T4s/htwchAOnD4Ltw3TO5Qg5PLpEvr1p8XODxxAyudjkTF7DhpSU1EZEIjM+T+iqbh96lH6v8m3ShBmr/gJGoUSNdG0LAPLskifMZO+FxEBlmXRVFTED/Ib09MR36074rv3QEKv3tAolGA3t6+j6LvUv31Laz3+0D4lLgBg7ZO1rdYU3BS2CYQh+PvWw6huMFz72VXZ7dZPASn3m0uDLLN702xTEw0x769EfVPL9UA7IjJJEEpIiMZpF6qHxgOEITgbc9bubRKGoLze8U8wJf64aPIqBSGh9VrDDE7XzQG8yQwTns6v85PnS36Zc6FpTuq5hK3siNwhEITrntAcrbL6Mv69L25+4ZBtV9ZrBYLwRysEofF9cfXKHtAolAjfvYoWlT/RHLbpu1J8Z+rKDOKt1nyR9Ja49113Oku5+APAcxamn4nAxLWHO5QgLNi9BxqFEuW3bzu7KwCA0KRiqwRh8dmztE7iL79AW1iIouMnzM52lnp4QF9fj9SvJ1KTnJMnkfLZ51QQbmw+H7eXOHjvzFN65Uqzcc/Rdtvm0pClIAxBYlmixWW4h9l/33YQK4LW8tdWfk1+u/VTQFY0PU/X54pfR6+nhk93W6+j+aJHFzzvpkRZfZntfXQSMkkQSkiIxmkXKuc0uubxGru16frKlb85Z1VKIXkSjuN5RinkKjWWG9WDG3XwEeQqNcjmAIQlF2Pc0SdIKzaEbKluxPCDOteHKc7otkQb4OzludfKhytRq60VmLb0vdzXqtCq0vpSFNQUCN57VfgKe6L3CArfl9U08oZFcpUa85mn7zZlEc4ogzAEO76nDp8xFw4BycEGEXbNisLTJSl0HeYr8esY4TeXitL7iz4AfJZi3NEn+HrtkQ4jCNnGRhpyqVCiMT3d2d0BAESlllglCGsiIy2GvL77Sp89GxqFEhnfzQXb1ITU8V9Bo1BCt765ZMi93xy8d6Y0FRUhbeo0aBRKVD9+3G7b/dbv21bFHRdW+vft+0Au9uCvraLaonbrp4CCt62bO71LdRFdZ9ufAG3LM3/hg+n1mlv+/o2pZJIglJAQjdMuVEc4je6K2sXfnJ1WE0jiD8HjxCKTHMGd9zSQq9RY6WW+Fp3LHYN1/F7/+PbqqoSdmOgzUSAIl4Usw88Pfha8RxiCioYK0W12Y7qBMIQ31+JmHwhDcCvpFr8cl7P6r+ZahMZmRa1x/s15vs0LE6ggzA4LAtwnmTcOMUdTo6E+oC0zEkao5/WkgnDhB0DAegzZcx/j1p7oMIKQqzGYtWixs7vC8zKzzCpBqKuqEoi+3A0b0JCcDJZlUep+GRV37iBpxAj+88TBQ9BURAVN2uQp0CiUaFrbnNsZtNmRu2ZCXVwcEgcMbDbG+Qr6upbrLtqTr29/DcIQ1GprLS6zJ3oPCEPwzeUz6HrBIAhL6krarZ8CyjLoebpgRXRCocZwvWVGtbjogzH9oFEokZIqPm+5oyCTBKGEhGicdqGyLIve7r0x7Nowu7XJ2UEThiAyL9Ju7UpIvIv/mzzIVWpsvfuWf0+r08PnVY5FW/jdfvH8oG7tTeuKRks4F61eyzuJci/OTOLdl1j7eZZlBeFmWr0WfS/35d8zDqfPr6jnw5HlKjXmXYgW3fczMWf4NgOGUgHQmJVAB4P7PxaWFjC78/XA3r8bZiAS/Og66lWi+2DMjTndeUHIPtqHf23wQ68t/sCN+cCLSza1aQ0sy6L2+XOwTYY8c31tLRqzcwCAuokqlKi8d8/hfRFLk06PGWcirYosyF7xE1LGfYnap+YfHtTFxQkEIweXa6hd3SwIH+1rc//F0pCWhrQpU6FRKJG3aXO7ikEAGOk1Ej0u9Whxlv/gs4MgDMHNBF+BILTmQZBdqSmh5+n0J+LXSXtiEIRhR1pcNHDSEGgUSrx95rgaq45CJglCCQnROPViHXZtGPpcbmEgYgWFtYXo7d6bvzl/4mn55lhSV4Kvb38Nr4T2sQyX+P1x43m2iWlMaxjXErOmbICE80mtSDURflx42buvsJwwUW2W15fz6zzNf4q3JW8F7RjXOcwuoyZGPbYGQq5SY64VgpALpe92oSted1HiWc8u1PnTpRPgOQvY8T/NoYGrqfhLCgKCNgFVBUBlnrD+XFMj8NKD/n5/h9XHEQCuzaaCMGTBB6gLOwW5So3PDrVfWGDxqdPQKJQoPnMWtS9eoOjECSR9Mgzx3XtAW1CAxKFDoenSFboKJw3w25HU8eOpW+pdX/69jO/m0ocGv/4HPc8Rlou02wNtQQEKDx1Gzm+roelMa1SmTpzUbqUmjOl7uW+LYwcAOPriKAhDcDvpjkAQVjVadnB1KE0N9Dwd7SV+nbhbhmv66swWF1V/OxoahRKvgq62saPtj0wShBISonHqxTr2xlgQhkBrreW5Gbgwjs+8P+Nv0JaSoLkbulSeQsJW3CPSIVepcfJhsuh1DgYm8IJw+pkIB/ZOwt4EZQSZCL9pd6eZFYTGoZ4tkViWKFjnavxVQTvGdQ4zSmogV6nRd0cw5Co1vjsvXhBy97sRR2gNvaDP+xhm+XxXCks+qFe9Uxfw34R/5zwHwo7S3yNPWX0cAeDKrOYZwgUfoCDMHXKVGrPdWg5bsxfvhlK++8rftp3Pq/sjoC0oRMWdO4IZscz5P0KjUKLhl/+k5/n5Rbtsq9TDAyUXTdvKWfWrUbmLzig6dtwpYrxR1wjCEIy7Oa7F5U68OtEsCG8LBGFLYaYOhWWBrf8J7P+X4b2SFPowh8sPZFng0V5aosLYJdilE539z3kB3Fxg1iTq5s/UcOjZKdseADkTmSQIJSRE49SLderdqXZxBC2uK0afy33Qz6MfSupKsOrhKhCGwC3WDbFFpqF5XGFZSRBK2MrpRykmLqKtsS/AEDL6+eH2mxGRaDvvlpwgDMFXt78S/N3zEg0pPfVanFAyrpt69MVRqJ6oBO3tid7DL5taVA25So1Bu0IgV6kx55x4AXXo+SEQhmD2Jjr74jNvNB3ku3Sig8Tzn5svEG/u9WgvzSlz6QTEiI+wSC6sQlgyLdFweRY1qQj58QNoHntDrlLjl2vm827tQUNKCoqOHoW2oBBFx46bisDtO5C/Y6fgveIz9nO/ft/IWrIUGoUS9T81C8JY7za3qc3Pp7N/ys7QNzTw7zdm50DTlSCh/wBUBgaiIUlcuLUj4HwNZvjOaHG5069PgzAE3oneAkHYqGtsp56aYfffgJ1/pb8nhxiu1yvT6XtcnuHW/wTub7d8fYceAqrygXhDrqr7lbVUEE51jIOyI5FJglBCQjROvVjn+s8FYdpev+eK5opgAGVcd4swBHHFBoMZY9MGwhDoWf17WXBVwrlw4Z/XrSgwv8ffIAj77wx2YO8k2sqtpFu4n3mf//u3R7+BMAR3U+7yhd77efQT3EvG3RwHwhBsjdhq0p5/uj9W3F8hmEW4lXTL7Awj9zJuJ6mgCnKVGsP2PbBaEO57ug+EIVi9jArCWxtnU3dBl07AcwaoyKGOo9v+BGz7MxC40ch9dLZwwHhAAZwdQX9PeyK6D9z3/nVWOS7NpqYyIfM/wJP79P2d9zSi2xILq9ejlGEQ350K0KShn9Aae6Qb6mJjURMZhbpY+sBQX1eH5JGjeEFYn2C57MDvneyff4FGoUTd8v+i5znBr81tFru68se2IdkQVZG7Zg0tLXHseJu30VbSKtJAGIKFQQtbXO5c7DkQhsAz3hNdjVxGnVr7+GBnOpvPssDtpcJrVq8H0sPMC8A9cuHf1+cBZ0fS3197AgDUyXfxtIcSb0hXQd7t+4BMEoQSEqJx6sW6LGQZCEOQUGo+D6ugpgDjb42Hf5p/i+1sj9wOwhCEZNAi99WN1dgTvYcP6bqbchcAkFSWZDLomnJnCqb7Trfvjkn87tnu+xZylRr3YvNEr7Or2YVUrlLj4w1+0oOIDkqDrgHdL3XHEM8h/DmadGcSCENQWk9Dqnpc6mFyL+FMZpaFmBaIXhy8mN6jMkP494zNXsy91oeu55fl6l6OPEDrW85yE2+atTt6NwhDcHgGdRj1PWAk8hKM7q1Z0UBxEh1Acp8HrAdCD9NwtEsTDO/v+hvNJxQJ971f4x0DZnYvfobQO+A+5Co13J6kim5LDE1lZXwunEbZWTgjuHWb2XXqYmOhUSiRPOazP/S1mbN6NTQKJWqXND80SGtbNAOr1wvEdmVQEBqzs1H3+jU0ys5IHDQYuuqa1htyMKE5oSAMwa+Pfm1xOa6Mi4fGQ1B2wqnfmeP96Lni8nuNXwVv6Wy+Syc6i2j82bPzLQtEn2XQFL+F12f0GqpPfL8elMgkQSghIRqnXqxrHq8BYQheFLww+/nep3tFhXbOD6ADsdRy4aCCK8h8/s15AMLcwXdff+QBgIT1rL0ZC7lKjYcJhaLX2aF+KyguXtv4fj1t/aPAhY4RhiCjMgMA0M+jHwZdGcQv09+jPw0TNXIeXRK8BIQhGOk10iR8bJ7/PBCGYP/T/fx73IMsS68V91fwy77JqeBDjeUqNWaeFS8Iue1wg7pHZ6YbBnz5b8yvtKXZYfKhIWwVej0QfZaKQRGlCDyiMjDFNRxxuRWC7/3FOb2hUSgRPF+O47dp7U6fVzmi90cM2St+ouYkE75GfUICCg8d5gWJttDyNVufmIjG7LZFrLzv5G7YAI1CiZpFzYIwL6b1ld6B1euRs+pX5G7YgOonoQJBHt+rt+DvUvfLDtgL67iXeo+f8b/w5kKLyxqPK4yvV6dyYVyzoPvQVBAGbTJyFD0KuI2m13B9BTWOaiVMvC4rCnu/pfeO0itXnLufViKTBKGEhGicerFui9gGwhA8zjb/BFKsIOSsot81pwlMD+TX//XRr7yJjbmXPYxtJP44fHs+GnKVGjHZ4vNfHyQUCgbGOeXta6kuIY7UcoOjqG+qL/SsHoQhGOM9hl/mE89PQBiC7ZHbkVKegvmB85FQmoDl95eDMAQ/P/hZ4Do43Xc6CEMwSz2Lf++n+z+1KAjn+c/jl32VVQ65So3xx0KtNiVyCXcBYQhC+yoRp1Qi7synrbuEFsQBPsuABjPOiSxLX60wyy2Szoav9xN87y9824cKwh/k2HCFCsLw5vxCe6AtKKQhop8Mg76Gzjw1pKUhcdBglHp42G07v1fyt26FRqFE1YI/0+9JjfXnpszLyyD6mp1Dc35bLTCPSR7zGTLmzgPb6MTcOwBN+ib08+iHHpd6wC3WDXpW3+LyXErKhtANHUcQ3lkhLgc47jag01IxyMF99voacLgb/f1QV5ov3Gw09cP2vtAolEjoPwC66mrn7aeVyCRBKCEhGqderFw9H7808zkK+5/ub/VmW6OtAWEIvrz1pclnLwtftjjgMn7VaJ0fsiLxftCk06PLJn903uQPra7lwYMxLMsiNrsCs92iIFep8Sbn929r/z7yqvAVf1/YFbULtdpaEIaayHBMvTsV/Tz6obBWONvEhZMRhmD2PYNT5YTbE+iM4qWeqGuiDwJmqmcK7kHDrw0X3PMm+kzk13+eUQq5So2JJ8MgV6nxzWnxgnBD6Ab0OUsdRh8MUKJ4+5+BvR/RGT8HMvVUuEAIci/P+QN5QfjDWSoIkwvtZ9nPiZH8HTvt1uYfiYJdu2ho5w//TQWBldEzTWVlfGF5flaQdKPGMs1/Z8z51kG9t56y+jIQhroGi4HLIeZeiqNzEFMY1/qKjiT8uKn4q8oHtvyH8L3CeNN1Qw8DrkPow5/MKFqG5v4O6ji67U/A7r9h7I3PcWoKnSUsPnUKVSEhYLXCh+hlTyNR4e/foaKtZJIglJAQjVMvVs6t63ridbOfc4KxJUEYVxwHwhAsD1lu8llWVZZoQWipRIVEx0an10GdqsaZmDOtPtm1F1z4nq1W+b9efw25Ss27Lkp0LB5nP+bvC7PUs1BSVwLCEHzj+w2/TF51HtIr0k3W9U70NjtrYFwO52k+LRQ+6voodL/UnX//UdYjgZvpsGvD+PWjUksgV6kx7VQE/WmFIFz3cA0uTqCDOWZCF+hdOtEi8A5mwvFQs4Lw5hJa6Dr4eznGHqI5kRW19ovQyPj2OxryGNk+pSx+bxQeOEBrE85rFoQi0ZWX8yUrNAolspcvNwjAeXS2W9OFPpio9Gu7UY29UKeqQRiCHwN/FLV8dF604Rq/2AMfrvdEdYOTw/8TAwwze66DgWO96fucAZRLJyDqjLi2GmsNDwGuzwVcOmHm9c8wbl9XgcjPWb3asHm1J/9+mVfHqe8skwShhIRonHqxcrH4lmL2Dz8/3KogvJtyF4QhOPjsoMlnDboG9HLvJRigGQ/MjF/vPumX6PgU1xVj8p3J/DkUWxC8rdx8QYvS77LRGZHLJfSNybVzzyTsAXdPIQxBL/devPvgXP+5ra7rl+YnuK+4xbrhcfZjPsSUMLQshZ7Vo8elHhjpNRKB6YHYELoBTfom/iEZYQi6Md2g1VOhFJ5czOcOylVqTD0VLnp/jhz/lp8dnHW0j8BB0JGMPfLErCD0WfYJFYTz5Oi9LciuBkuN2dk0XHTECLAOngFtD57mP0V8qZlZHQdSdPQYNAolyr/7iyhB2JCUhNz1603KeTSVlRmMZPwDAAC1L1+i9JJ7hzk36RXpgrQSMVQ0VPDr9HebB7lKjbIa68Jem3R6ZJTYMSpJW0cdQhMDAL3OMPsfuMEgCM2Ff7dGcwmLxW50f+OnfSU4x/UJiUibPMXk3Get/g3aAuePqWSSIJSQEI1TL1Zu4HX0xVGzn3P1sywJQuMb882km2aXic6LxubwzYIwLnOCsK2lLyTaH27wPPjqYBCGwPWVq8O2pdOzWHszBrdf5mBvc/kILytKThhz4kEy5Co13CMz7NxLCXvAlbHhXlx5iMXBi1td13h2kXuN9BopKFGxMGghb1zzrsPxu86j3IOqx4lFfEF6uUqNya7iBeGJPd9Ao1Bi57zOmOdG6OCw2vGDNc4Rtcsmf4EgvPvTp9AolAia9yE+XKvG4N33W29MJEXHT9AyBkfN/095n2jSNzklP6341Gk60zP7f2jR8hZ41zDmXQFYdf8Bik+f6VBhhMZE5Ebwx3hbhHn3WXNw63x+6gLkKjUKKuut2u7Zx6mQq9Twfu7gcUdZOnDlG+DtHdvW1+uAg12w7vhHIAzBi40jhKHA3brzvx+b3hlb5xscfQv27bPrrtiCTBKEEhKicerFyg2eLN2Id0XtMvmH+Dj7MT9I8k/z5z8vqCmwuJ36pnpsj9wOTYkGc+7NAWGIiW18aoV9bc8lHA9nynH57WUQhmBR8CKHbSs6rZQf0P546RnkKjVeZtoWZnwlKhNylRrHQpxXhFnCMlzY5sjrI0EYgnVP1oEwBCsfrmx13RcFLwT3FWMhyAnD/h79eUOt5feFoe7vCsK3JW8BAA/iqSHREo/nkKvU+OJYCOqbLA9CWZaFf5o/CmoKcGLHZGgUSpxYMgj39/4FODW0bQdIJEP30pISg3aFCAThvZUjqSCc+yHkKjW+PmGfmX1Wr0fyqNHQKJRozMy0S5vOhMttI0z7umCXnL9AHSX3rQYqLUcxNKSmGoWHrkD5jRvQKDujOrR9IjXswbP8Z/wxtvRg2hyPsx/j4puLmHaa5slmlda2vpIRXNpA9y2BKK5usLbb7UvESew5+gGNWrjQFSfm9UbUmMEC4bf06gwQhmBvxC4ED6WhpWmzZ7XetoORSYJQQkI0Tr1YOfMGS6Eam8I2Cf4hhueE8wM0wFBk3pIpjTm+9fsWhCGC3B3CWK6FKNFxGeM9Bt0vdUdlYyX6XO6DwVcHOyyP0P9NHj+gHbGfznxU1tuW9+QXa2hr7JEnVhnTSDgezt2Yc+fkZqCN6wJaIqE0gb+nROdFY2nIUv7vCbcn8LUKLc1KvCsIORM3SrYAACAASURBVAfmoLcFkKvUWHszBnKVutWZo7clb0EYgo1hG3HC5WvqELhmBp0dDN7StgMkkgE7Q/DRWjVGH3wkFIS/jhYIwh8vPbPL9ip81dAolEifPbv1hd8DMioz+PPcnjnupe6XoVEoUXLufIvL5W/bzosCXQU1yHrfCpeH5YTxx/jEqxNWrz/nHDUISy2yznlz3oVo/npYcfWl1dttb/YZPZwnDMGII12hmToB4ed2YvP9X0AYgp6XekCn12GJ3wLEdlZCM6C/08NGZZIglJAQjVMvVi5+f36geYOD3x79xt+ASutL+bqF3/h+A61ei2HXhqH7pe4oqSsRvU1LgjC2KNZeuyXRDrAsC8IQjPYeDcBwXtMq0hCeE46Z6pnw0NjPYt7tSSr/D/yjtWr03xlsc1sRKSWCAXJ8fqXd+inRdrgQ84dZDzHgygD+HrE9cnur62ZXZfPLa0o02BO9h//7G99vcPLVScF959TrU4L1z8acFXx+JoYaQfi/yYdcpcbWu2/x8XpDnqIluFC4uf5zcWLDlzSvbulQKgjTQ9t2gETSa1sQFBv9eDHLvfx+HSUQhOtu2efem/zZZ9RMJlx8OG1HxTfVV+BCm1jWfgXBy655NbtJnm5xuaxFi6FRKJG7vvUHJR2VkIwQ/hgb1wgVy/cXn9p0D/+q2XCJuARArlKj1MocxPbmfuZ9eg88Jsdi13+YTbsZc7EHAGBP9B7cHW4oL1IVEuK0fsskQSghIRqnXahA63bPy0KW8TebaXenoe/lviAMwRDPIXiQ+QCEIVgastSqbS4MWgjCEMFAjzAEzwue22OXJNqJBl0DCEMw/tZ4AIZZHXWqmn9wYM/cm80+bwSD2llu4guDv0t8fqWgrT9a+YnXWeWosnF2tT3gvj8vCl5g9aPV/HfJnHHVu5TXl/PLZ1Vl4Xridf7vuf5zEZIZIrjvXH4rLMrNGW0RhprKfOr1KRp0DVDH0Fnlnfc06LUtqNXvNxeOP/bGWJxUjYVGoUTKnA+BnX8Fmtpn8Nl1cwC6udBcspMPkw2C8DcqCINnfwS5So3DwdaLHbaxEbXPnvGhlNpCWnsw5fOxdt0HZxCZF2nywLK9DLMAoPzW7eY8zGMtLpc64WvePOZ9xTfVlz/G7m/drV5/kTsN4Y7Ntu4ePmhXCD5cq8ZCd5p+8Dyj9WPY2OS8SBKWZZGX+wxw6YSo3X/GmHNKjDynxMqHKw1jNLcuQEkKvOLcMfpQVxyf1xuRQ3ohPvWp0/otkwShhIRonHahAoak+c+8PzP7+fcB35t9EkUYgvkBNPQqKCPIqm2mV6Rjhu8MvCx8CdfXrnx7EbnibdwlnE9lYyUIQzD5zmQAgFusGwhDcC3+Gv/dsKcgnM88E4i4zT5vbG6roLJe0FZUagnuxebhuo0mNe8TnFvmt+ejnd0Vi/z84Gc+f89Y0IkxLdLqtPzy5fXlyKzM5P9eHLwYcSVxgvuYV4LQor1WW4tfHvyC8Jxw/PKAhmJ5J3rD51UO5Co19vjHY8je4Fa/38EZdJle7r1wsjlEM33O/wEufd3m4yOWj9f7oc92en8+8zjFSBCO5EMNu6z0hkeU9eZKRSdP8vXtMhcsMOSyrfjJ3rvRruTX5GOo51CT/3e3km61Wx8q1DT0tvDAAYvLsCyLhN59kNCrd4c1jBEDVyamp3tPNOisz+VbfvVls6ArFb0Oy7L4eIMfem8Lwm4/alB280XL5jLPM8qoEVlEutV9tCvH+wnrGqY9Ru8LXUEYgiln/gVs+Q88vTDS8N292BVxJc6r0SiTBKGEhGicdqFyDLo6CAOuDDD72QzfGSb/GId4DuF/H+o5FFqd7TMNelaPRUGLBLk6Eu8HnEvjTPVMAIaZFSaOwde3v27OaejZto00VAM6mhMzxVVYZLst/5gbmnTCnKrYPCg3+uMf6+5Br39/B1di2Ob7lt/vjgp3T0gtT0VqRSp/v7n45qKo9bnltXotH9pMGIIZvjP47y13L2vUWZ6tiy2KBWEIvrz1JbyfZ0CuUuNAYAI+P3LfRBBq8irxLN0wKL2Xes8ws7mMFgnP+u5/gWtzbD4u1sCyLG8oAwAx2eWQq9SYcy4Kfr8ZnAq//uEwAuLyrWq7qbhY4G5o/Cr1sF+YuDM48uIICEPQ27234P/el7e+REVD+0QSVAYFUbOQXbssLtOYkQGNQonUrya0S58cBWdIdinukk3rr/R6BblKjYgU8WkrVfVayFVqjDn0CJ7R1GBsimt4i8J68eXnHeO+GbBeKAi3/QkDLnQBYQi+PvsvwKUTirf9O/+9nXxnslMfGMgkQSghIRqnXagcY2+MpYMnM8KOG9hP950OwlCXPs4CnjAEu6N3t3n7XI5PSIb4OPe6pjqE5oS+109G33dyq3P5MDwAuJl0k8/J4h4a9L3c1/YNVBXQf3g3FwAAxhwSGmNYMwAwx782+PFtrfGO4X+vbXy/TBmsZanHC35fO6r4nes/F4QhyKnOEQg6Jo4Rtf67Yo3Lb+3v0R96Vs9//qLgRattfef3Hc1veuTPh1dOOmUqCLljyt2Tbiff5pfZ/kMXWkh67v8AN8QV37YWTV4lvr/4FDHZ5QBoeJtcpcbwfQ/4ZdKKa9DQpIPfaoMgnPT9QYQlF4vaBtvUhKITJ5DQqzc/O1hx1xf1CQnQlZejOiwM+saOnYvVGlx0g7EZEff6IeAHh5lmGVP96BE0CiXytpg3H2JZFpk/0lnZouPWG7F0JLjIkndn6sXCmTw9Sixqcbln6aV8nmB6cQ3kKjVmnInE03SDe/Uqr9cWxxRrb8Z2DEGY8kAoCF064TsPOqO9/LQCcOkE1qWTIQw3co9TuyuTBKGEhGicerECwLS700AYUxe16sZq9PPoh34e/bAxbCMIQ3DgGQ1hicqLwvbI7SiuEzeQaImDzw+CMNY5lS4JXgLCENxJsbG2j0Sb4YqFLwxaCMAwI8LlEhKGGgfZLNo1dw3/9AD03xksEIRFVW2zCu/WbCZgbCwgV6k7vgV5Gxmy5z6/r5kl1lm1txdcZAJ3f+G+T2JNJ7KqspBekc7/nVudi4k+E/l7DNeeGKMQribij74ukKvUOH4/CXMuCAUhNxsnV6nR1OxY65XgxS+zcx6tDZb//V8AH+tyrsViPKgFgOqGJn4W5F38V3/KC8Kpc/fhabq4cLvi02d4IViwazd05eV23QdnodPrwLIsXwKh7+W+vFDhwkW5h6NxxY4Pv6sJD2/RLKby3j0+X1Pf8H7fr46+OArCENxNuWvT+puac8uD31oue6XJoznjA3bSh87PM6gIXHblBViWhduTVPTbQf+/HAwyf0/YdU/TMQRhUyNwbTZwYz6w9b8A/7Uori3GjsgdKKsrBd76AC6dsPzk39HtYleUen/v1O7KJEEoISEap16sgCFPMKtKmD/FDWg2hm3Eq8JXWBi0EPk11oUWieH4y+MgDIFPso/odfgn7yJcByUcA2fvz9Vx41zQVtxfIXiqrtXbGFL8wt0gCO9vh2KjH5Qb/U1mYmylz3ahwORe1tazep8orm4Q7Gt0mvi8m/Zkos9EEIagRlsDAIjOi8a0u9OQV51nl/a50hO12tbPNfc9/8p7LuQqNVwfpmCBh1AQltc28se0rlEHwBAKRxiCvd9SQVj0w18A9Sq77IMxdY2GEOgZZ6jZUmkN7dO4o09Mlvf/bTgvCGfP2YnXWa0LO111DRL7D4CmS1fUJ7Sf46ajuZNyx6Qm7vL7y3Ej8Qb/97P8Z3xN3uAM292NxVL77BmdUV692uznqV9NoG6ukVEO74uj4R4gWutFwMGFwPvFWr43PEgoFIi5gDjqGOxyxyDuE/Kr0HUzfTB4+2WOSRsbbxtMzeq1uhb7lJBfxc/UOxRz5lQsC/gsRb3vzyjf8wEVjZX2uW/agkwShBISonHahcrBDeA1JRr+PZZlMeXOFBCGIKYoxqHb5+p+XU+8Lmp54xAyW+oWSdiHmKIYEMZQwzI8l9aonHRnkmBwJWbQbZaHu3lByB7swoe/afIqkVhQ1eb+D95936wgTMhve9sdlfvxwvIDDxKcW6PKElwYe5PeMeG7elaPuqY6UctyZSzGXpsBuUqNM49T8LP3A/77zbIskgqq+GNaUUcfgJx/c96QQziLCsKy+f8N+K8z2UZjkx6rvF7jcSthb5ZIaw6Bk6vU6LuDChbOOGniSVN3TP/fhvGCcMH0TdDkUct+tqkJ9RoNGrOzwb4T+lly8SKdtVqjsqmPHZUfA3/k0yFGXR8F19eu0Oq1CMowOMmW1pfiXOw5EIbYtZSOJepiYqhBz8+/mHzGNjVBQ7ohcfAQh/ejPeBqGT/JNn1wIYY9/tQUxueVqYjj4Iy05Co1tDo9rkTRvMFjIUmC5R4mFOKjtWp8vN7PxKTmZ8+XfBvJhS3/j+gQM4kAELQZ2PU3IMnxDzEsIZMEoYSEaJx2oXKse7IOhCF4mm+wJuYK1k+5M8XheXoX31y06h9tfk2+XXMYJWzjaf5TEMZQLPxl4UsQhqCfRz+BILSpoHNlLrBHzgtC/Z6/Q65SY8Jx+9Vv+7S5uP27r5eZ76+Fe2u4R2YI9tU3JtfZXTLLCK8RbTckshOcCc0oz8mQq9Q4F5oGlY9hhrBJ3yQYcJY0hxyfen2KX+bIDCoIKxf82WxR+lsvs60eRKYUVSOvgora8JRiwXlNKqhCVmkt5Co1vjlt6t7sv8YwQ/jLlNV8Ue+SCxcNBjGduyB37To+JzDju7nQKJSoi/391IvV6rXo59EPA64MMHn4wD3g4maB76bcBWEIDj0/5PB+1cfHUxOiJabhxY1ZWdSxduYsh/ejPTA3/rCGg0GJkKvULTpEGz8ISy6swrGQJMhValyNzjRZ1j0iHXKVGr23BQmiRbh6h3KVGiEay+GpOr0hfLy1mUSHU1cGNDj3AadMEoQSEqJx6sUKADujdoIwBA8yqflAjbYGo66PAmFoCQFHY+xOyRGSEYKf7v9k1oaaE6uEIVjzeI3D+ydhnrCcMBCGwCXcBQCgKdGYmDAQhlgXZqzXAZ6zAJd/EyTN63Z9wDsk2ovPDj0WDKIVG6nJTLhIg433kQthaYKcyWtPTQdEHYFBVwZh4JWBzu4GAKCqsQqEIfj06njIVWpcCEvDyTCDWNDqtHxJCrlKjfyKegCG3CjCEJyYRgVhzaI/0Znvd+AGoWIFofGgEwBuvqCC8sO19L3PDz/Gm5wKi9dM4N7FvPBbP2EFssvowDdr4SLqXDlpEhJ694FGoUTi0KFImzIVmi5dkdh/AFi982qx2Zv0inQQhuD7ANM8Ky6fkBOE0XnRIAzB2idrHd6vhtRUaBRKZM43NSCqfhJKZ2rXms40v49wdfTeFNtWRujs41T+QY0l/GLz+Otl1z0NXO7EQa5SI9CCuy73+fQzhocpxi7X581sq7SmEYN338dOo1zDtua5/x6QSYJQQkI0zr5eTZK6uSejX9z8okVLdnvB5SqejTnLv8f9IzaXrxGQHsB/vihokcP7J2Eezm12VxS1RudMZt59ZVVaUdsv7zUVgXs+BM5/Dlz5Btj9AfTb/htylRpLr7TuCimW8cdC+X/c8y5E8yFBLZkTvO+4PaGDp6F771sc2HQEern3wvBrw522/SdJRfjZ8yXqtTq+ruEQj88gV6lxKSIdz3MNtQwbdA38cTXOQT3w7AC/zKkpVBDWLvkTEGo6w3TJSkFYYpQLCgAnHtCi80x4Oma5RUKuUmPSyTDIVWr8cNF05iV470+8INwxbiEKq+rRVFZG3+vSFfr6emgLCpA85jNBSYn8nTvbcFQ7HnHF9DyufLjS5DOWZeH6ypV3ouXE4w8BPzi8X43Z2dAolMj49juTzwr27oNGoUTxmbNm1uzYpFek4zu/7wTib3HwYhCGILks2aY2uYcxu/w0FpcxnoH/eL0fJhyn935Lxeh1ehb/XH+PD78GhA8QjXMPOR4a5SlyL27m/Y+MTBKEEhKicfb1yue6eMZ7AjAItFOvT7XL9jl7di4fUKfX8QMpc3kF7m/d+c+/8f0GAHUV3BKxxcQYR8IxFNUWGfKjnh0EIAzlNX6J/kef9xo4P5YKwgdGA8+DXcC6/BvkKl+su2W/cLXJzU98P1xLB9Wci9yd1x0zjNIeuD6kxcm/PPbEbA6Ns8iqzMKNxBtgWZa//j+/8bnT+sMN6Nwj0sGyLLox3TDg8nDIVWpcjswQFLev1dbiYGCCySCQMyEhDIHbxGZBuOy/gIiTJtu72DxzK1YQJhcachavRGXyMxr+b/JQWFWPPtuD+M8XX35usv79bUt5kXd4zHcor26gs4AKJVInTuKXY7VaaAsK0VRaCl31729wG5UXBcIQbAjd0Oqy1Y3VIAzBRJ+JDu+XtqCAhoVOnyF4n9VqEd+9B+J79IQ2z3lGIbbClX8Zd3Mc/x7nVVBQY9uDuMjUEshVavxy7ZXFZbhagx+v9xMItpYMxLq5BIBsDuD/HrgrhF/vezMPWbyfZ5sIQjFmTb93ZJIglJAQjbOvV14AusW6AQD2P90PwhCoU9snKZorV8DlZhgXog5IDzBZ3vjJ+0ivkdDpdYJSB8b1FFmWhWe8p835CRLmCckM4Y/38ZfHAQAVDRUCITjaezQIQ/C25G3Ljem0wP3twJZ/N4SJJhvNDB/tBbh0wj9VPtjjH2+3fbj+LAtylRq7/Wibh4MTO3QYpT3gcme4WaSWnqq3J73ce4EwBCGZIajV1oIwBBNuO6/gNjeg2+xDZzK4vFjFsZk4ERohCFuv0dbwgkyuUvOGR1sitvDLXJxABWHdiv9CVehp7LqnQWFlPb+986HWCULj2mlylZoPZ+NcY41DWH/yfGmy/qNNC3lBePbTaSi550/LSXTvgdqXpsv/XuHuY2Jy0VmWRS/3Xhh2bZjD+8XN1qZNniJ4vzE7hwrFGTMd3gdHMMJrBAhDMMZ7DACgtL4U3ZhuGO092mavAs5QaebZSIvLcA9cjgQnCR6WcCVizNF/ZzD+se6eYBv/XH8PcpUaIw88NFn+1KMUE0EYmvT7TT8Qi0wShBISonH29Qp1qhqEITj8/DD0rB7jbo4DYQhii9rHPCA4IxiEIdgTTQuoRuZF8gOpW0m3+OVuJt3EyocrMfzacIHw2Bi2ka+lSBiCq/FXAdDcH874ZIbvDLPblrANYwc+LtS3QdcgOC9cQe9XhZaf3EKnpaGhLp1o3uDJgdSFUWdk8HByEODSCV1V13HqUYrd9oFlWaQWVfPF2c88TuFzxBwFy7KIyS5HQ5NzzAY4A4YlHs8hV6mx8bZteTv2hvvOnIs9h9L6UsHsvzMwHtRFpJRgqOdQvo9L1LsE+WWVjZX49fprfvk3ORUAgPWh6/ll3L+kgrD+5//EI89DkKvUcHuSym+PC/kUKwg52/x3X5z7YW1jE//eEg/TGcLHqh94QRij7Ir4Hj2hUShR/ci0ZuHvmTspd0AYgmMvj4lafuT1kehxqYfDi9PrqmvobO34rwTv10RH03IUq3516PYdRW/33vzDntWPVvN/c8ZktlDTXG/TnEjjON0s1i5FpOO789GirrXh+x5ArlIjr6KOX37CiTD03BqIjzf48f83OLY3l7/oviWQX76lUhh/FGSSIJSQEI2zr1c8zn4MwtCafv7p/jRfxnOI7eUCrCQ0JxSEIdgSsUXQH8IQXH57GQBQ11SHbkw3weyTpkRjIg4JQzDs2jBcT7wueG/sjbH8E8jiumJsjdjKF72WsB7vRG/+2HJmQFxoHWEIujHdcGHrNMzd0AVReS0YwaSHUTF4oj9Qmmp+mTOfAi6d0Ft1BVeiHDd7xzlwnnhgWy5LazzPKOVNPw4GJjhkG62xt9mife3NWMhVaqxsIcyqPfn/2XvPuKiudm2cD//3q895zvue55T3PWfyJDGMulFs2HtNNMau0cRo1Bi7JupgxR57j924QVDBgsrQRGkWFCwoOHSQ3nudtq//hzVrzWxmgAEGBnWu32//lF3Xnpm197rWfd/XxWrtos8gpzKHTShYC4YkayEfxUS2OJ7D994rRJNWZXVl+MUtiu3/Wpcmtj50vX6SajwhhHVr/hU3LhNCeMTAAJt+L+YSQpoCV3+hCqcA0EdntD3CxED50dp5otrA+J69kLF8+UclGGMOPBQe4HgOf8X8Zdb+NL2xrK6sTdslKJXEeH6sOG267M4dKOylyD90uE2v31ao/67ufaU31gSvQWpZ6ybhuG0B6LLVH6oGIn7HghJZ9scyj5dm9bVxR0nN4E2DVNBlHi8x6dRjRhQNQWvQ70Vns/09I20lLHY2QmiDDWbD2v2V+cmtCV7D0jFpPWF7gM62y8KJv5Vh9Ols9FkAYIPEGfdmoKC6gM3Qvit6J3rBOIc7m6xj43gO/T36wy/Vj0WulgYtbbd7/FhQparCveR7OPriqBEhrEtKwtblPdD7fDcs29mPDTbDM8NR++4dslYsgbqoSH8yQQBuLiKEMPxQwxfV1RUOkPGQv2m7GVeq1HgwoG3I2m75OzZQGPjHwza5RlOgdZLUu2uxa5RV2lEf9Ld04tUJljK+OHCx1dpjSLK23YnBhNsTWBvHeU5FeGY4+7u4thjfn49g+0emkbTN1cGrwfEclj9YDs+xhBAqf/s7zpwmhHCPrz5dd9sdvel1Y2lsFH+GJBmRwc+cxcemFFRizJFQ+McYKyk+WTaH9c+vfr/V5tZC1oBKo4J/qr+ohKA+zr85D47n4BnvadY5qWdhawlMUxAEAQp7KRJHjBCtLzx9mvhZXmu/97OloNKqjN7JjWaPNAPUEiKgAdXQ/QZehVQAytREiSEm60SZ1t/QR/8X8lFYeZUQv4iUItH+cy8800XpK9k1DLMAPlXY2QihDTaYDWv3V1b7NfnOZPxy/xdwPIf44vaLYFCBhlUPVwEAfFJ82Avj8AsyE0qJH93HEBXKCgy9PhSrg1cjqzKrQULI8RyGew6Hk7sTu18bmgfXWFdwPIfurt3ZZ3o6+jSKXV3ZAHPp711xfVpv9veD9w+Q0MsBCnspcn4aA7jPADxmAWcG6WsGkxshSK7fAS6dMNz5QpvWZPjHEGnyHfeaqHlsIdZcfy0awNefYW4P7LhHSCmtd5l7wXI2Hq0B6+9Rh1kK+9bHW63WHsPvadPtt5hydwprY58r/fEwXe9DWFhTKFKspbYlS4OWsmdp3PRJUNhLoVr3d+w8fBQSmRybvfUp+b956ged5bUNExgKw8kFuvTYEWj2/YU7L4LCXooXXDezo5IfGqh69rYn2xrch05smVsvvz6MRH2p8mhbIo5zQMKgwaJ1OVu2kNTesLA2v76lkVGeYfQ+tlSWDk2hNpUeDeife/4xOdBoBfz1OBXZpY0/f+kkD1VkJsfn4g8/Qi5vv8oU7f/1MSLUVVKlxPXIdKMsgE8VdjZCaIMNZsPa/RUAMPjaYDi6OaKve184ujk2OqtqadCIwC/3fwGgtzOgaayAseddfdSqa6HRkrqsYy+PiQjL0OtD2f+/ufUN2zbLZ1a73N/HhAORB4xe6vylNVBIuzAC6Ly0K8KdurK/73utZ/9P6vWlyF8QLp2A04MAZVXDF/WYBbh0wjjn03iT2XaqbcE62XBLKpkags4gU3XTwNhcvEovgUbbftGZrbpI1FVdyuF3px6327UbA/0t7Xu+j/mSUV9Ua6DLVn9RDd738u9Fv3kqxMXxHPKr81m9kUQmR2hCAQBgmfdP8B0qRbLHBaSOHQCFvRTqDf+C5btIhHCtpz46ssTtBTs+z0BspiEs5KOMCOGIgyFm35/3K3cc+b4LRm5a9NESwlk+s9h31BB2RewCx3MIzTCvdvKP53+A4zk8eP/AUs1sEPG9eiPeqZ9oXfrPC0nqcWLHUAduCtWqavim+KJGXcPsrAwXtVbd9EnMQK1Kg65b/WG/xQ/5Fcb9Z+NtkiIfHJ9v9jl/NjCi77zJD4qccgB6i5j6pQX0GaBUaxGoI6jrb0S37sY+AtjZCKENNpgNa/dXAMBc37nsIU3VRtsL1K7gR78fAQDX4q6xtszzm4e1IWux7/k+cDwRvmkKgiCgqKYIOZU5iC+Ox+Q7k9n5HF0d2f/n+s5t61v76ECFMmiUdeiJboju1R0KeykztT4+q4uoPunpd1+x/7+T2kM43gvIfQtkRgHVxU1f1HMe4NIJk5yP4X1RI8SxlXiSXAiJTI7fPNvmJU59rI7ohF266kiHV1T71ZnQ2kFq1Dz6cMcQEaF9cvOjzejr3hd93fuiVt00MWoLaA1M3yUyOWafi8B8//migSwlBhzPIbcqV6RcSH0stx35jhi7z5qBlJEkhVrt/DdM33gYEpkcS9z00YwfLj5jx5vjXdZvzwMWvYxKK8bnG33x46XnZt/jrcRb4HgOnQ+u+aAJ4fk355mIWH0sDFzIvqM7SXdM7kNLDKJyzUuddle4g+P1ysptiYT+AxDn2FO0Lnn811DYS6GtarvnoCVBLaJuJd4STaJwPIfB1wY3fYJmYIs3mewafywcZTXiCW0agX+SbH5E0rDWcNrpJ2z9/Xd5kMiMBbn67NarkpZUKfFPZzmc9gR9lOnYzYGdjRDaYIPZsHZ/BQCce3MOA64OMGnz0NagKavT700HAPCxfIMpn7RerTkYe2OsyXNNvD3R0rfy0WP5g+Ws9uNyzGUcXDuYpIK6uKAiOBgKeylCnaQiQhjbxR4KqRTPHMnfmifN/A5v/QK4dMIM54MorVa2zY0BePG+BBKZHCuuto3sfq+d99F5sx8eJxWKCEd7CszQephHiYX4zNl6tYz1UT+ab8oovL1AVQud9hBRlnFHw7AkaIno2UFryTieQ2Z5Fjpv1vub+ceQOtcdu8eTPuDYE8nD+5Pf/qa/YaLzCUhkchGBo/VKNOV0zfXXDZpmF1QQU/oxR/Rk/lV6SZMpr3QENAAAIABJREFUcIagWRgfOiGk34GpQffE2xPZ9oZULFc8XAGO5xBXbJ6dTWJJIjiew/fytrd9SBw6DIqu3djfgiAgrocjEupFDTsyqPXK+TfnRXZRHM9hwu0JFr1WnVrD7HQMJ1sAPblrqE+ZgqFy8E4ffRlBTFYZW1+r0qtFd9sWAM5FP376Tic+k17UPuJ8HRV2NkJogw1mw9r9laGtpbQbglKjFL0gaKG/qeVu8t1mn59Kxo+7OQ6RuZG4GneVne9A5AHUaeqaPsknjrvJd7E7YjeLJOdWkeL9nK3boLCXouJhMKpfvhQRQcPl4ZT+eqXF5GZaR9xdCbh0wg8b97ZpeiV90beF0Ipao2UErFalwYLLkfjpr+cmZ5rbEmt1dYzPUorQdas/um83v+6sLVG/n/uk+FitLfkVtZDI5Jh08hE+3+gLpz1BTCCGLtRPjeM5JBW/FxH8u9HZAIDdm4Yb9QPtlk4Y43wGEpkc08/oow4jDoWw4w2jhc/qCVcA+ki2KX9Bc6EnhKs/WEIoCAL7DgqqSZrukqAlmOM7B2qtGo5u+myQDWEbTJ6juSIxgiCwCcYffH/AutB1uJV4y2L3ZIik0WOgsJdC0GhQdvcuMlesIFYUU6a0yfXaAosDF4Pjicdw/T7k5O5k8etV1qnx+UZf9NkdJFpPU6xjs81Xh6URR4mMKIdSFFXWsfWTTj2GVitAEAT801mOfnv0qcQ0Dbwtyxw+BNjZCKENNpgNa/dXq0MQBHR37Y6RniMBACdfnRSllRhG+MIzw5t9fup1ZOhrNvXuVHbOU69PWexePlawlFvdIIum873/kcjX16Wkoi45WTT4jZ44lv1/5XYnnJ1KCGHlc/NT2wAAvusBl05YsW13G9yZHkn5FZDI5JjXjNQ7c5FfXssGEBQv3hNz8eUebS9QQbFCp5D34n0x+upSnDpCSpPhQNHR1RHlynKrtSVNZ0I950IEiepu8sOGsA0NTlK9yk4UEcJbL4nYxM6VfYwIobC1E75xPgmJTI5vjuufZb126lNOP9/oy/5vymzb/RkhoEeDWi5Y4Z3k/cETQrVWzb6DqNwo5l9Ja/wMSwQaijj/5P8TOJ5DVmWW2deNLojGSK+RomciJaSWRPI3E8gkQk0NEgYOYr+hnC3WE1tqLr6+9TU4nmgBUMsOlycu4Pi2q+F3cAmAdIs/zoQms/RrOsmSlN90OjbFHp0is0QmR0axPsonCALWGUQPI1KKUKvSGNXxbrjxBhKZHOGJlv9tfEiwsxFCG2wwG9burx0C/Tz6YcDVAQCAw1GHwfFEZTC1LJXVIXA8hypV82snaC0JNb4HAFm4jJ2zn0c/mydhIzCcied4Dn2u9GHbEocMhaJrNwgqFdQFBfrBbzcOCTs3QWEvxaM+UnT/qxv2/0gIYYG8eVFebcAWwKUTtuzeaelbEyGjuBoSmRyzzj21+Llp9HEhH8nWJRdUQiJrX6XPX6+QWevojFKMOEiiUnVqTdMHtjEMf19UXMpaiM0m39Ui1yiMOhxKhIbCNjdICB+lKUSE8HpkOjRaDXb93FVMCKX2gEsndJXdEA0eBUEQkUDDxZA0UlAD7DuvzScx9XEn6Y6OEK76YAlhnaaOfQc3Em4gJCOE/b0wgDzzaf34yocrTZ5jju8cUYTRXGgFLaILojH6xmhwPIepd6da/B2S8t1kkmZcVkYUR536oTYuDoLaMkIsbQ2NVsMIOX3f9vPoB5VWBT6WR3JpMzNFzET/vQ9Y/6EZEDPOPIVEJkdmifnpm4d1td49d943OWlGvUC33olBSZXSqL9SJeC2tEr6EGBnI4Q22GA2rN1fOwSGew6Ho5sjAL2S28N0Ut+k0qhw/OVxROZGNnaKBlFYUwjXWFdUq/QvA/80f9GgbvvT7a2/iY8UhTWFos9qlNcoAICgVou8srQ6M2WFvRSpU6ai8JoHFPZSuCzqCo7nsHkJGSBn8c0TLaoN2A64dMLB/S6WvjURaBRv8p+WV96kCqbOt96wdcUmBhFtDcPUqQkniEx6cVXb1WWaC8Pfl7mecM9Ti5tUDSytVmKJ2wuT0bSKWhWziKh/XpqSOf0MUYTd/eQwa18vtz6i9gYkRItInFvEexTXFuPQXLG4UlxXe6zcuIntR9PLKmpVRkSQpvYOO2CstErVD99mttwc/W7yXUIID324hLBaVc2+g29ufYOdT3eyv3tf6Q2O5/BbyG/geA6/Bv1q8hwz7s0Ax3MorW1ZWl9YZhi75hz5HKZ0bQmkzphJrEpycohC85ixFjt3eyC7Mtto8mTq3altft2RBunX9Lc93sASwlycDiHWPAsumx535JTVsBrjrNIaozTwkw9J5oDHs/TW3dAHDjsbIbTBBrNh7f7aIUBTS1RaFStEf5zVdpL4giAgLDMMmRWZ6OXWCwOvDmyza33oeFPwRvRSn3FvBgBAXVJCalom62taWFqTiwu0BSnYuP4r9LjUDRzPYcsmkvaUsn9Xs65f6r8HcOmE80e2WPS+6qOsmgzMvz5meYLmFZVhJCCj0QrtLuwyX1e3mJBXgZlnnxqlQ1kL9LflwDuYHa2hAz6l2nTtc3ZpDYvwmfqMad3ei/dipVuqwLr9XiwWuxICffHlXdbGcV6TRP3h5huxBcRfj1ORWJKI09PFhDC5zxf4aeMuth8VoKCRafstemGaoHd56LzZD7133W+w3RVm+BU2hHvJ93SEcCXWeX2Y0vhUjKyxhZYfLAxcaPIcNILYkswTQK+QTRfXWNfW3JIIaXPnQmEvRa1CYfSc7Uio09QhIC1ANOEKAM9znht9H6dfn27z9nx78pERIey7Owifb/SFthk16J6R5Jld317CEAP/eIjPnOVMkMxQKIraU5wJbZtI6IcCOxshtMEGs2Ht/truEDQalN66jdyduyBoyWCO1vSVK8uZtUFLI4LNBa1RtOTs7seE+tHU1cGrAQDK9++hsJfi/byf2L7ZzhuRNncuVFlZwPsn2HNcwo5zOTsLCnsp4pf83Kzr5/geAFw64dqJjZa8LSPQOpCRh0Isfu4/Q5Igkcnh+jRNtL779kB02epv8es1BFpLk1xQySJNcbnWq9ej6OveFxzPYWnQUrP2p9HVxlT8fnHTE7W+9UQmKPmXyOTwjBTbfrgZ+IzROqBbb/STIj/JV4j6g9uLp6IB6LmwZETkRID/VkwIUwd8jtkb90Mik+MzZ7Lv/L+eIzKtmEWmKTGsUWrQc+d9fLXZDwAQkVKEzd5vUavS4AsTohnNBSWEh6OOdoga0paA1gxOvD2RRfrqL74pvuQ78//J5Dkm3J5AJiJb6LtrmE7v6OqIPlf6ILsyu+kDzUD6ggUkMjhyFBT2UqTN6Zg2SdQSaudTcUo/tTahS3fX7hbzHWwMs86J+6MgCPhyky9672pen6lVaeDxLB01yobHBauvkZrsY0EkGmiobnrndRYkMjn2+ZunYPuxws5GCG2wwWxYu79aFIJWi+wNMhRfcTe5XatUImXyFDZIqo0nEROqXplXlYffQ38Hx3OILmifmevWpg197LgUc0n0Yj8QeQAAUPP2LRT2UmSuMF2fg+jrKNrxL1h8bSTCMsOwzmcp8SIcM7JZ10/2OQK4dIL8tGmlQEuB+s8N2keiSSVVSnxzPBzer1peq0Wx4x6pJ/F7K64noWbGdWoNyqpVOBqUgJwy8+0Dmgs6WEovqhYJzFgb/Tz6wYF3QI3avHunaZ0SWcPeYjR17DNnORx3iNVUqaAPJXCGoLVDnpEZ+MMvDhKZHN6vMjHKbRE6H1qJ7WEnRf3hzNMwfLbZA18dXYQvdu/DqeAkyFPk8BpLCGFCf2JKn/P1f2Oy81H2G6PXp2qG67yisfVODC6EpwAAhuwnvw2VRsvuhUYtZpxtXZ2rT4oPOJ7DsZfHWnUea6KguoCkavrOQV5VHibfmcxsceiiKFKwfUyBTga2hhT7p/njetx1HH1xFBxvnleuOaC+rnRJX7zYIue1NOhnSEsJKI6/PC76LkZ4jmiX9hgayktkcuTpSgHGHgmz+LWuRBCBp6mnSWr5Ws/XbBstE9h0+63Fr/shwc5GCG34xPC/7OzsTtnZ2ZXolpN2dnb/n5nHWru/WhR1qal6RT0TL9liDw/RS648gAzUqDx1SllKs72hWgsqOvO+/H27XO9Dw66IXaIXOzWCrnz8GAp7KbI3mfb4ov6BiL4OAFgfth6P+kjxrmtXaGuJSqkgCCIvJ1O2Em/ungBcOiH03G8WvjNjdN7kx6Iv58KSRWlHrQElX5FpYvJFvaryymux1pPUjR2+33L1yKYwTTdwyS6tgfMtEv0KS7C+Cl7vK70x9PpQs/f3eJbOvpsbLzJN7sO5BKDbtgB03x6IbtvE/qqhCQXs+F0GHmMA4HzrLSQyOR7G5eFsKPkNXH6cipW679DtVZCoPxwKfYDOB/WS+kfux+Fq3FXIh+kmveLikDd/CDSb/oavnU+xgSO9/nCduM8eX4WoHV/r6p6oETYljRKZHBtuvEFrIE+Rs+jah4qcyhxwPId5fvPYutLaUvY99HXvy6KIhgrThjCsXW8tcqty4cA7YNzNcRY5X+aKlaJ3ZeaaNRY5r6VBLVjG3xwvWr8+bL2onzT0HVgayw0M5Q0XU4q9rUV8boXoGpu99eSPppG2p4p0R4SdjRDa8Ilhh52dXbSdnd1/6pZoOzu7bWYea+3+alFUR0WxF5gyMxPa6mqoskkKjbamBomDh4hecgWniOUDfXm4K9zZCySlLKVd2kyFB94UtG6Q9bHi16BfRS/2sEwy01ru5weFvRR5+/aLDyhMAkozgF3/APb8X6COSH1ve7INFyeTqEnZvXsA9Ck3xVVKZJaQWqrjDxJFp3ty+0/ApROiLq5u83vltgXAQVfbdSE8xWKEcPY5YpicViiuVaI1fYYEZ+udtvMlnKQjoPkVtdipU6v0jMpA391BOFHvc29P9HDtgZFe5keOaYoWTdeqD5r+O/xgCHrvCkJnXeolBa0TlMjkWHFV7Oe3SFc3+DazDJ609vN+AjO3fpqagyl3p7D+sOt+AOyP/8D+3usXjQtvLyC4n25iTKkEXL8DXDphhPN5UdSCLp9v9DUSuJmhq/GktZ4SmZzVD7a2LommUnI8h8wK04S6oyOjIgMcz2FBwAK2TqVRiQRMKpQV4HgOU+6arr8bdG0Q+rr3tVibxtwYAwfeocUpqIbIWvub6F2ZLXO2QAstD+rz+633t6L1c+RzRO+NhoR9LA3q/1d/mXHG8urRNKuELobkj9YGD97/ECqNdTyeOwLsbITQhk8MmXZ2dtMN/p5hZ2eXbuax1u6vFkW5r69Yap1zIAp7nAOynTca+XKlLyD1ZLQOwXBpjjdUa7Dj6Q5wPIdHWY/a5XofGr7z/k70vdDU2pJr16Gwl6LwzBmyY0oIiQgaLvdWsfPsfbYXs7cTpdHEocOgys9nL9KA2FycDohBl99uGBGwAK9zgEsnxP61rM3vtfcufd2WW4TecLy1oOImlXXiGhqqJmm4rG6F4XhTMFQWpamRhkbo1oBW0BKxlmZEVqike0PRsvSiapZaOUAnQ2+YsUBFfuqnX2q0AsYeCYNEJkdOWQ2Lzm29EyOy7ACA/hfmg+M5OMt90OXM16x/bPV5iuMvj+OZoxSxDhw58aVxgEsnDJDxmHSSPGeKq5RMOCbChAH9gnqpb4ZLQGyu2Z+VKfil+rX7xJulkVaWBo7nsDhQnEpJFUZXB69GjbrGJFmhcHJ3wqBrgyzWpnl+8yxCsr0SvPBs+VzRuzJrrWkvRWujn0c/RsANMfT6UPR064lJ3kSEaXdE2/rIUvx46TnrJxW1KvTbQ/p//TpiS8GwX9afXJqna8uViE83+8jORght+ITwdzvyg//SYF1n3bq/mXG8tfurRVF0+bJYat2hu5gEdumK+F69RevqUlNx7s05I0LYXt6Ax14eA8dz8EnxaZfrfUgQBIEJfnC82IOw8Px5KOylKHbX1Yvu+oeeCO75L2DXvwN5+nS8TSF/gLvcDc+X/0BENqbPQOd13pDI5PB9m4On383C4+598cX6O+yY56nFmL9xF+DSCSmX296fbuAfDxl5oOIiliBK3bcHQrrF3yiNmtYWSmRyOO0JgkTWsMy5JTDuKCE75bUqlhJL61+sRQiVGiU4nsOE2xPMPoamdUpkpn0caY3gco+XrE7TcJbeMPpLrR0EQcDG229ZZFGjFUTnoYqjMVnE7qH/xQXgeA5rvG+j20Un1kfWeT/AH8/24m0XKWIGOJELnh0KuHRCT9lVkUhFSkElyqpNR5NoiiodzBoOPBPzKsz+rEyB2k58yIQwqSTJZORp6PWhJJU36hAzr6+fzkjR060nhnsOt1ibqN/e0RdHUVRjTPID0wLBx/JNnqeXWy+cn9tL9J7MWNr2E2INYU3wGmx5bFrluZdbL6OUUGoJMvH2RJTVlcHtnZvFxHaaArWKoc+z1xml4LYFGNVvWwoBsbnosSMQCy5HIqtUXANN/Wf77g5qVJzmY4adjRDa8Anhv+3ID/7/GKz7N926/2di/+26bWz5mJC3/wCJGp07j5qYWKiLiozSXioePCBiCwMGQmEvRe6ePbiRcMOIEJbVtdxnqzm48PYCu6ZK2/pUn48JtAZn+r3pCMsMEw1y8g8d0qV/+gCCII4MFsQDGn00TKnWovPBNeB4Dt7vvJD2/Rwo7KVYOpP4st2VR7DfSK9VHuw4iUyO7zfuA1w6IYdfgLYGNWs/FZyEU8FJbGChbkXKT52apC8O2W/sKXfigT71Uf6GpDFOO/3ExFksAypOUqPUMEEEShKtRQjp4HHynclmH7PCgCwN1xm8G4KmhO649w6jddHZaiX5PT5NLhKRK0rUqWBL711BLLU3uaCSkc6FPInYvcsmqqwDL5La4wWerqLn1gKPO9j+kGRDxIzWkY1TToBLJwzccdfse6TkVCKT43yYnsB+5iwX1d22BIYTcAklbVez2paIL44Hx3NY8WCFaD21MPKM92QqoKNvjDY6nm4bc2OMxdpkKKRiStnUnMlOlZakvZ78sUe9bJq2f/6ZgkarYe02BQfeQZ8+HbELKWUpTLRoSdCSdm6tvva2PdWbG8Myd5Jqfu35p+lHaGcjhDZ8QqARwi8M1n1p94lGCLN++x0Keymqnuv9eGrj4pA8dhySRo6CupiIaqgLC6EuKkKcQ3fE9+6Dh/G+okGVpU1+GwOVYOd4DrlVrUvF+tgQUxgDjuew6uEqo23ZG2Tku37yhEQCDaODWjGBevG+GF/uJ3WiHgoPVD4igjSnR86GRCaH34bdbOAz7Fe9cb1EJsdU58OASycUu/7Q5vdrSI5otFAik6Owsq7F58zWmRZPMWF472oQhSzXGZSPORLamltoFEMNomXer7IYUbUmIaR+ctPvTTf7GFp7KZHJ0Xmzn1HklX9CPtfTIclsgEgjcYYRUcPPfpOOgMnf6CMJJTp7i6+PhbNrxueS6Nygi0QIa9qVo6Jn16hTl7H5zjIo7KWI/XYsoFEBRx0Al07ov1ssbtMYPKMy8JkzqX1KyteLV9RXTG0J/nj+B2uvokjR9AEdELFFsSRCGywWW6Gq0U+yycRKT7eeGHZ9mNHxtN7wm1vfWKxNtxNvi34L9UHXv8h7YeJogkplJYlwzncQRwiXtE8NXn3QOkxT9xNdEG00kWu4nI0+2+7tPa6bZNtx713TO7cDqP3EbnnHaE97w85GCG34xJBpZ2c3zeDv6XZ2dhlmHmvt/mpRpHw3GQp7KVT5+aL1giAQcYV6yJY5Q2EvxRuepG06ujmajAyqS0pMHm8J0DoTjueQUvphpk9ZGodfHMaa4DUISAsAx3PY93yf0T40yqfMzASenSVkUP4bUGWcKnU6JBlf7tsMjudw5vUFaCor8a5LV4Q59oNEJsezYWPYwGfCwuMAyG9GIpNjgjNRGa3k216ljoqu1F8SWpGi9yazFBKZHL+4RRltM4xCCoKAfzrL0W/Pg9bcQqMwTIml9XG9d923KiEsqikCx3OY7TPb7GNmnHnKyJFEJkdBhZiwHwggdhE3X2SKhHQAfQTBcEnKr2DKn0+T9b9fjVbAZ85yDNj7gNUD0XTNwZd+IemIl7eJBsHSvUex0e1HkjI//HPg4hgIu/4dym1/Z5Ym5qKyTg2tVhD5LtIU19YgsyKTtTemsO1EjNoSlIz8Hvq7aP2yB8vgwDuwyb2G6gRbEpluCtWqaoy7OY59tnUa/e/SUPDmZsLNBs9RWFMIjuewdwEnIoTKdOtEmKiaK8cbe/XWFxyj9YR0iS+Ob/f2qjRaRKQUQanuGEIu1CKnfn3hpwI7GyG04RPDTjs7u1d2dnb/oVte2X2CKqOCUgkF54CEAQPN9nWi6aOpG35H7yu98VuIsbWAMjOTFNWvW8/WqfLyUHj2HLQWIolrQ9aC4zm8Lfi0PYMo6Av95CviuXbl3RWjfRIGD4aiGwehrgY4M5gQwlTTXk8rr77CF3u3kwHcfaJK6uM0Egp7KabNPyga+Myatw+1Kg0KK+sgkckx2pmQzTretFKgJTHj7FOThNCQJBRXKVFRq0JuWS1+vPQclx+nNnrOMJ3FgSnxE0oW11wn/lU9drStUb3TniB8vtEXAPAkqZClTFqTEOZW5YLjOfzga34EeLyO1FEFTir0QkHtGcITC1hNEa3voUqdEpkc/XWCM4+TCo1EYygcd5D6Tyq+k1xAVHOHXCKD4aEXV4kGwV/s/gO/nSITY4ljPmORc8XWbibTW82BxkDNkIrStBbrQ0nE/nX+66Z37oB4mfcSHM9hQ5jYnzS3KhfPc/QZKgOvDoSTu5PR8TQyPePeDIu2q7S2FBNvTwTHc3hXpI8KUaJHUysbQlZlFjieg8uiruyZaKTk3I5ILElk7a5UVrL1NHuE+hByPLGKCssMw7OcZ/CM97RamzsSmMBVG6icfgiwsxFCGz4x/C87O7s/7ezsSnXLKbtP0IewNj6+2bUOtMYwefzXyK3KRbWq2mgfQ+9CirSZs6CwlyL/0GGLtH3L4y3geA4ROZb3KuroyK/Ox3z/+awWh9bWcDyHlQ9XguM5BL0XK7Rpq6uhsJciaexYIITU+OHiWKCBNN+vj4Xji90kTe2rw0uQX1GLfeN/hsJeige9BpEosSMRG1o0exvyy2sZWRrifAlw6QTNX+aLjrQUhqmIhgtNI6yqU7OI2hcbfdn2vb4KZBQb/3YBsNrA+n53FFmlNUzwhKZv0no3S6PXTr2KanRGqdF9WgM0WjXff77Zx9DPaesdYuruW08wgkbz4nMrMOeC2PKDkkCJTM623XqZiZ903339aDCtK53y52PReYZeWgaO5+B0YZ6YEO7djsXbyWRH2jf/AxzhAJdO2LJpVavSgWmbf7hoLKLTEjiHO4PjOUTlGkeuPwRE5kaC4zlsetSAD6oOw64PQy+3XkbrmbG93LRpfWtw5MURUi+d5M3WUREcjufg6OqIjPIMk8emlKaA4zlsXqInhPnHjlm8jebiVf4rk7WPKx4Qv2CvBC/cSbqDk69Omj0R/CmBWuCYqiH/FGBnI4Q22GA2rN1fLYayO3fIbOYfxumFjSF57Dgo7KVQl5SwdaqsLJT7+kJbW4vUGTNFZvd1ycns75SJ30KVm4uKh8GtehnRmpoH6W2XrtcRkVKaglFeo8DxHPHP0qpYKhXHc2ym+1W+ON2lNi6OkP8fZwM7/hXY/R9AkWlvNI1WwFeb/fD5TlJr9dWx+QhNKMCPc3eLIoP3FhHfrTXT1iMhrwIh8fmYsuAwxq4iPoS4YCwMYWns9VWYJIRjjoSiolbF6u5MLTPOPjX5G7weSTwGTfnl1cfEE4/Y+XruvI+pp5/g/rs83H6VCY229YMtB51ZOwAk5Vd2CELYkH1AY+i58z7st/gxtdDzYeJUb5oWWlylZEQvMa8CGq0gIvKbvd+yWkMaHa5P7CkRpPWXdPuwv5aTwf15Yssy0pNESr7ctwkLf+8Hhb0UOZP+H1Bbhso39/BP2T18czy8xZ8TbfP8v543vbMZoJNgz3IsQzDbG0+yn4DjOWx7sq3R/UZ5jYID72C0Prsyu0Hxl9ZCniIHx3PYH6mP7EXlRokmDtaGrEVccZzRsbQ2csMyPSFk1j5WQHhmOGszJbE0ajj6xmiLeC5+7Oi5877JWudPAXY2QmiDDWbD2v3VYqAKo6Xe3k3vbABaR1gRrJ9BS50y1cizUGEvRVzPXibXMwuL5JYZNlN1uHvJ91p0/IeKjeEbGRnkeA55VXlsoGS4vC8X+yiV+cgJ+V8+jZC10IZTmmjKzD9dzoDjOdifmI0zocnovM4bj3o4QWEvxe3+Y+CyfD8U9lJs/XY5gt7lQW6gPFo08z9JWmobw/3Z+wYJ35Q/H7MIYo8dgXiUWCgSoZHI5CalzSlpufio8dRSAFh9Ta+e2XmTn+jce/2I+Idao4W2heSwy1Z/dN9ORElyymo6BCGkkZOlQUvNPob691E1UZe7sWybWqOFg0sAOm8iA7BFBnYRmSXVovulNZwud2MZGS+qJyBEo420XpGlnl4mqaIOF0aA4znM9SG+hJ0PrMPKVT1J/5j5BQC90uCkU8bCQuaCtvnHS5YhhC5PXIj4Slbbqdq2JShR2fF0R6P7jb853mT92/vy9+B4DosCF1m8bZQwLQxcyNYFvQ9iRNDJXW9TUr+ekKbCrl2lJ4RFl/6yeBvNhaFnJa0JpEJsh6Msk6HzseOb4+Ema50/BdjZCKENNpgNa/dXiyF9AUkBrI0znvVsDCXXPUlazJGjAIDa+IRGSV/SCJKOlThkKDKW/Craljb7+xa1/eLbi+B4DtfirrXo+A8JgiBg2t1pWPVwFZYELRFFAmMLY/Gu6J0RIaxQitPo8o8dg8JeihLnbwkhTDZOh9FoBTxPLcbd6GwOdKWgAAAgAElEQVRIZHJ8tvUyEd04NZnZBoz55TRurtiKgcsvY8ZPZEJh//ifcSwoEbdPuOu/815fAif7tvlnk1pYBYlMjvHHwvHVZj8jwiSRyfH5Rl9mMG+oRCqRyTF4/0PUqcUDzyM6A3jPSNMpYoYwFJkprVYaXbu0Won+ex9gzoUIo+uYA0qkADBVU2sTwrjiOJaebA6Uai0kMiKuQtOK6XImNBnhiQUi4kTJ2Kv0EjxJLhSlXkalEcGHZe4vMaqePQXFUvcXohTh3DIiTjPy8mpwPIdufxEj9A0hRDSp86GVkP1KBEGSvu+CSN01JLLWWYoYprlaArsidoHjOYRlmq777egIyQgBx3PY82xPo/vRZ1utula0viUTEeZCpVXB0c0RQ64NYVEhD4UHEdWKPoP08nTsebaHPV8NJyJp5HPlWj0hZF6vVoBXghdrZ3RBNADgatxVcDyHi28vWq1dHxJoffLL9JKmd/7IYGcjhDbYYDas3V8thoSBg6DgHJqtBlodFUVEY9YSQRlKNjKWLUdtAvHIqomJRe6u3ahLJVEWrVLJXrTa2lqkTJ7CXp4VISEo8fJCRZC+7q0uJRW170gNl7qkBCVXr0JTqS+QvxZ3rUO94NRadZvZbqSXp7MX/Dw/Uv+07AGphwrNCGUDErr0dOvJPuua16+RNHoMFN3IgLd67T8JISw3Nh2+/SpTNFj/bBP5jLucGc+EPfb7xzFJ/dG/nIHCXorLQ6dgyP5grJm2nn2niT06E+n+dkBqYRXKalTY66eAg0sAaz+NBk48oRf1WHCZeNNtuPGGiY48SRZ7jO30eddg9LA+HiiI8qf9FlLnN3i/mHBOOqlPKfV50zyjZ7WGEKmBfxClS0OhEmsSwrcFb1nkxBxQK4hvjocjv6LW6B5+1n0nHs+IKuOa60Q99HlqMUvfPRxIIh1ZOkuQaaefMHJfP/r6u06ghi5UrXQ0v1bUT06+PEtSoo/+jJ0/d4HCXoqoH3qJosjfWSBCOPOsZcQpaJr8w/TmKZ92FDx4/wAcb1oB2RBT7k4xEkQBwCa+TFnqWALT7k5jdXfVqmqMuTFGlKKbUZEh+v1QBKcHE6K6Tk8IS2/caJM2moO/Yv5ibaQ19uffnAfHczbhGDOxR1eKcOd1lrWb0u6wsxFCG2wwG1bppIIgQJmWZrHzqQsKSE3fpO+afSxVEU2bMxc1MbGI604MeZvbvorgYKNooqayCkUXLzECkzRab29Q7KZXzqQpMMdfHm92+y0JRZECuyJ2YfC1wRjpNdJoVtsS8E3Rez5+c+sbNqjieA43Em6IUoQ4nsMor1Eove2NvD/2IXfHDijspUjo1x/pM8ZBu6UTsOsfxJi+Hg7rImN06bGT1NV0PTecrfvrcSoEQcCgfQ/x5TpvvJWSQdBvU9chspsj+67iHb4CDn5l8c+iKRjW2ZVWK/G7VzSC3uWx7blltTgVnIRalYbVH96NFhO19Tf0ipdNQRAEXI9MR6pOuIRGpwwjVHRxfZrWrHspqKgzIrT2W8RRUGvUuFDRivVh65veGUBGcTUjRqZI7WfO5N8nSYSY08//cVIhDgbEQyKTwyuKRGtptHHw/ofoufM+pFuMFV636YRr6EI9Kcfwv4v6SWTOC/L7Pj8Eh+YSQvhwwWDRseOOtjwaR+si19+IbvE5DHEg8gA4nsP99/ctcr72hn+aPziew6GoQ43uR30JS2rF0RlqW7EudF2btG/To02kLv39AxyOOmw06aHWqk0SQv9Ucl+LZHpCWHbPeqUMJ16dYG0MTieZIIdfkPvxTfG1Wrs+JLhFkFKEEw+ariP/2GBnI4Q22GA2rNJJ02bOgkLahRnFtxaV4Y+gsJcie8OGpneuB0GphELaBYnDhrNIX/7hI/odasuAU07A0z+bPFfGsuUiQpi+cJG+/lBHNOmSu2MnO+5B+gP20lsftr5d/ZMEQYCiSIGimiI4ujqKBgmxhbFNn6CZoOTPsHaQpgCdjj7N/k+X2benIb53H0IEBwwkZD0jA7i7gkQHPX80eR2Xu7GiwXBkahG4yz3Q9WJ/fL7RFz9cfIacMlKPtcWbDLqfdO9juna0mz3wx/9Y/LNoCrUqDb7a7GdW3dbZ0GRIZHIjGwpK6l61IF3o5MNE9vkdDRIT7LOhzauXjc8lkdh5Bvdi6EEokcmZ2ml74lHWI3A8h+1Pt5u1vyKnnEUCARgRQrpQewhqOB8cl4+VulTliBS9jQgVfLDf4oeeO43J0T7/ONF5S6pIBsQ4fj3rI90uO0Cj1WDY9WGkH00nhPDW4vGiY1tqOwEQIrzL5x27fmtBB/V+qX4WOV97gwq3HHvZuALnHN854HgO+dX5SCpJgkpLRFCoyMvG8I1t0j4+lhc9R53cnZBXlSfax3A7Fceh5vY/bdYTwvKAwDZpoznY+2wvayP9rex8uvODTjdub4TqrIfWeuotXsprVXiaXPTRC83Y2QihDTaYDat00pwtW8nMo49l0sQKz55rVfF7wuDB+jrA7+dA0BoMTF9dYV5eTUGVnY2EwYORNGasnkxwDqh++RKCUgllRgaqX7xg26pfEfVMQyU1jucwwGOASQuMtsClmEvgeI7V9Mz3n88EHywlclOuLGfRxh/9fjRKCQ1MCwTHczgQeQCno0+Ltl85u1JEzhKc+pGXmNdP5DvJiDR5TZqqRxetVsCQa0PQy603SqvFg9qHcSRVcvW0DYgbPBT5hw7j/IgZuDlgHBRO/aGQ2gO7/t0in0VzodZozVL49IrKgERGTMwv6QRkcsv0KY1J+ZVNnMEYhmm3SrUWlx6lskjkkfsJzToXrZ8zHJRQ5Uy6VNW1jd1FY2hudJ7W5K26RvoubfvAPx6K7ofeC52Y8I/JwXc6k/psnTAMAFFKJ02nNYQhKZfI5CirIYRivOsGfT+51A8A8HsoiRry3xJCeG7pLDi4BDBBmgF7O46K8YcupHU3+S5J1X11stH9aFo8JTGusa4AgKfZT0VEzNKon3pvKrXVXeEu2ketVbPyhbnb9ISwIiSkTdpoDmikk+M53Eq8BQBYH0YmQ17mvbRauz4k0PfAhBN6leFJumdRcHy+FVvW9rCzEUIbbDAbVumk5QGBUNhL8XLpGkSmiaOEjxILcSo4idXSqLKykLF0GUq8vBo8H43MVb940aL2pE6bzl5+tde2AneW69MQoy6ZTQgpBLWakczSm2IVN1Venj4V0YkM5Ghd3cTbE7H8AZGTP/X6FMrqylp0P+bgXvI9bAjbgP4e/cHxHIsuHIw8yGaJm5r9NgfVqmoM9xyOFQ9WQK1Vo8+VPqJByKBrg5hAw+6Q9ay2aO+zvTj1+hTS16wRR11/1innXdEpjOYrTF6X1tcZ1qd9fetrcDxnJFVeo9Sgs07EhZJF/5hc7PVTsDRfYdu/mExN7SigpJYutSoN1nrqSXFeefPTf6vq1Jh44hH+DEli6+7pRHr2+pr+3BsCPW63XO+HSA3eDdNi2xtu79wIiYrlzdo/OD4fEpkcm26/BaAnhGuuv8YffiSax+msNQCxlUiXrf7ovMlPRPCpiqhEJsfow8Y+gZcepYo+Iyoo9LXbRn2kXWeJQqPrXmMJITzjvBJuEe8xUlczayoCaS38+fpPcLzYK+9Dwq3EWyyroTEsDFwoet7RtM2H6Q/ZRFxbwNCIvrFaTcN9kkqSWGRx5g49Iax6aj1T89XBq1n73BVE3GZp0FJwPIeEkuZNSn2qEAQBPXYE4vONvlDrsjDo8+Tkw487jdTORghtsMFsWKWTasrLoejSFY96OGHIPvGLij6o7r/LQ3B8Pp5Pm8NUPU1BEAQkDBoMRTcO2poak/s0heIr7kgcPgKFZ8/qyV+1jqg+Pt5sQggANdHRKPcPMFovaDT6aFe//mx9QkkCatQ1bKBQv+bDkqhfP2K4uCvc8Tr/tcWuH5ETAY7nMNJrJOKL442uN+bGGL2n18nPILs1FRxPDKu11dWIc+wpIoRUDRYXx5LvpCzT5HWnnn7CfkvU6mCWzyxwPIeCauN6uoMB8fjFLcoohSZ5wgQo7KXQbvob0IE9r17XM3p/X1SFvruD2N8tUQU1haB3hHhuvRPTrOP4J2mQyIjnHsX0M09Ebc5vAWltLWiN0t3ku2btX58Q07a73I3Fq/QSI2J3IECc8lk/bZPWGEpkcnx78hHqgwrR0KVGSb7HCW76yEnP81MA6O0G5MNIX1E/uw5ALzvfZatxjaK1cDaaiODUtz34UOAZ7wmO53Dh7YVG96NKynSZ5D0JAHAo6hA4vm2Vpek15/vPb7Ae3LBtd5Pvsu9l2PFu7Jlb8/q1yWPbAwsD9IT6UNQhlk3C8RxyKpsWyrKBYPa5CEhkciz3eAlB0Nc+80/SrN20NoWdjRDaYIPZsFpHfTmReP2NWSlW1qQPqnU6db2A3kNZDZ4pqLKyoLCXInXK1NY3qjBRT/5K0sg6/436dRYiBCzatcjYDFuj1bCoHcdzJo5uPWi6kqklOD2YKdBZwjT59OvTLDX0ZsJNcDyHcTfHset95/0dXuQRQQzZqX9iyekv2Gx1ua8vmQwYMUJfz3JfF+U4PZB8JzWlJq9LZfyPBiUwM29ZuAwcz+FJtvny+ylTSF2p2vlvQF1F0wdYCVTshC4ezwiRGHU41KJE60kSSf383at54iKHTdhfGEbHJDI5MkvaJ03aEM2tR7r2nHyuVKAhMq0YCy5HorCyDoIg4FBgvEjRlZrP06V+PeihwHi2zZSCJyWg9Yn9t1e2sD7U9/w8AIBW0GLQtUEI7kf6ipBKfud0cuTzjR1HhOPC2wvgeA7X465buyktAo3G/hXTeJkCjXBte7INwz2HGz3/siubp9bbHGSUZyC1rHH/UddYV1Fa6bGXx9jfL315FJw6BUHdslTuwppCkZiOh8LD7Eg8BZ3EM7XUtyOyoWGExOeD20ZUq71fZbHniVszxcE+NNjZCKENNpgNq3VUtyWbobCXYu3UdaLoBX1QTTgRDskGH7zo1oPV4gmCgPL796HKzWX7l925oxNpadwguFEIAvBwF7EWoOQvl6SEsVo1l05AuWVmJIsuX4bCXorMNWtMbqceVRzPtUnaKK0R5HgOuyN2iwhoQkkCqlXVotns1mBR4CJ27vWhpPaDyoZzPIfv5d/rpf///Byzz3UGxxO59Ly9e0narbc3crZsQc6WrdDW6cx1j3LkO2nAHqPP7iB8uclXFPG7HHPZrEGcIdJmzYbCXgrVhn8BqgqbPsBKqFVp0HWrP+s/tF5tn3/zfDmbwktdFGyZR/PqdygxeqDQC1tQjz66pBQ0v86xtVgbQuwb3hS8MWv/C+EpkMjkrE6TQl1cTMSO6qF+6vJm77ei7VQBkE6C1UdwXL7oeCq8M8l9G+tDgy+sYPuvergKzxyliO1mDxSnAADmXIgQpU53BNDURJoG+KEgoyIDSSVJLNWY1gQ2hFf5r3D4xWHUqGtE6aPjb463uqo0RUpZCjie2AAZin49zW55qqhW0GLMjTGYcW8GAKC4thg9XHugp1vPZp1nwu0J4HiOPbsNF63Q/iJUHzIiUorwmTOZGKLPA8OMjY8RdjZCaIMNZsMqnVSjFTBj5TkW9cl+rVezpA+qzzf6ouvaG6J0wdKbN4m9xMRvAQCq/Hym3ll2507LG5QXqyd9dDkzCLg6W7wuxzKS6zUxsYQQrljR4D6/hfzGUicp8qvzcfr1aUy8PRGT70zG24K3DR7fGIZ7DoejqyOKa4uhFbRsoNLnSh8IggBBEND7Sm8Mvja4ReenUGvV6Ovel73AKfHMqsxi6xYELGCppMtPf4HxF+zB8aTOL2s98QKsem5CZXPfZ8Du/2jw2oYm6BQ0Mtoc76/3P84jyqa//73B9NSOgqT8SiMxnag0yyj5UsTlEpXNBZdNi/k0BGqObKh2apguKZHJEZ/b/jP+Pwf8DI7nkFFuTOZM4QiNdEaJ909fsADxvfuI/EUBfaoWXeqrsxrWfro/e290vWcpRaLjaW31ZPcdrA+NvrSJ7f8q7yViukgR79gZqCNt+dmAlHYUXHl3xSxC1dHQy60XOJ5jojgeCg+zj6X10RzPtZtomDnQClo4uTuB4zkWxWxO1NwUaJZJ7yu9AehTbDmea5ay5bDrw5gX7aqHq9DDtQe+l3+PTY82NX2wDUYwrGmWyOTY46tgfrwfI+xshNAGG8yGVTrpq/QS/HP9Xb24yp4DAIDY7DLRw2rYr+dFhDB15ky98llwMIvevJ8/v9mG9CLE+RLCd2814LPWmBzSJcG4JrAlqI2Lg8Jeioxflza4z5noM+B4YskAAKEZoUa2EAOu6tVIc6tysTp4NV7nN17vUa4sN4r+5VblYknQEtEAYMyNMXDgHaDWtlz5MbYo1mhWd7jncAiCgIFXB4LjOQy5NgRpZWngeA6Lz3yBAZe6oh9P0oPTFy2Gwl6KukQThe87/jdwsLPJ69aqNJDI5BhxKES0vk5Th0HXBsHR1RGFNeZF+6h1SN2afwWKOv5samBsLiQyOaRb/NvEiPh9URUkMjlmn4to1nEzzj6FRCZHepF+IFzfGuRtZtuJKDWEqXenNisSv8vnHSQyOXzfirMFEocOI8JWkWKirMgpZ9FaiUyOa8/TRdvr1Bq2LS633Oh6MVniZyJrt8dO1qe+5fez9ZrSUjJp1v9LJoLk9pTUby7ko4zOby3QlMtLMZes3RSzUamsFEX4OL555uiUBLdVKUBrQNVQDZcH6S1XpTWsha9V14pqAeuLejWG3ld6Y8i1IQBIOUVuVW4TR9jQGOrUGuYpariMaIUlTUeGnY0Q2mCD2bBKJz2sq5uZPv8gFPZSvF2+BiqN1ughNf2nAyZ94QyX5HHjoSk1XUdmNp7pxGQeHQHub9MTwItjgReXgcAt5O/n5y1y/3VJSQ3WEFI8eE+8CXc8Jamw1LdrQ9gGZh7M8RwWBy5GVmUWs2sYeHUgUstS4Z3kbTIdK6YwBhzPYcXDhqOTADDTZyZL3WwONAYpnDStqrtrd9beFQ/IdXdF7EKPS93w3ekByK7MBsdzmHuWpIuOu0wIYepEYt+hjq6njqiuI9/HcdPpR1Rme/Kfj422UUPspsQgKKiCbe2qfyWR5A4OpVqLi49SW2QzYQ7yK2pZSmpzQGs6Kw2sJahRO11evLdsNNMcjL0xFhzPiX63jUF28w0kMjlCE/TCRNUvX7LnUTFvukbKaU+QUYSUIqWgEj5v9LVk1S9eIHfHTggqFTJLSG3oF+vv4Mcf97KJr+lXd7M+Ndv9LDu2ThFDni2ju7B1Gq2AsIQCq9h6NAQaMTr/xjLP1PYAFdsyXJojikM9Lx1dHduwlS3D9qfbje7NP63lIkRUnIbjObwreid6B1Spqsw6h0qjYuTbBsuhWqlmNkWmJps+JtjZCKENNpgNq3TSiSceQSKT49d93lDYS/F62mwmVmG4LJq9TexBN3CQ3t/PoTvKAwMhqJop9FKWBXgvA94bCIsEbCIEI+YmEHZQTwjlv5Htb2+QvwNMpKlU5gNJDxq2JMh9C7hPB8r1Az5lWhqLbDYEakXxg+8PAMB8AkMziIJhZkUmJt6eSCKFHgPwza1v2AuX2itwPIcatVh51TvJGxxP7CUaw69Bv4LjOSSWmC9L/Xvo75jkPYldk9ZnLQhYwNpDRQWqVdW4+ytR8ExZuQzDTnTDuEvdwPEcTizqgry9e5E0gCiMCge76FVfAaCqiHwfZ4cYtSEpv4KZh//0l3GqaWpZKiGdN8eZVYOSqbO9qFn+v4GsltmafEyoqFVBIpNj7JHmpZP13HkfX232E6WLnQ5JFvX3p8nEsF0QBOSUtUwxuLkYcHUA+nn0M3t/ai5PU3E1lZWiZ1T2hg0mj8svr8WTJPMmV1iK/I0bUGm0+MxZji2TVkBhL0XOli0AgPlueh/CxZ56YZYqv6ukHdPNvydrgFrbNGXb0JFw5MURI9J0J8n8UgVBEHA78TbSytLarpEtBBX5MVx8UnxafL51oevYeahwE11Ka82bwC2pLQHHc6wO0QbLgSoi06XbNstkP3U02NkIoQ02mA2rdNK3mWW4EJ6Cg/feQGEvRfSQEdipS8WSyORwWuGKldOdsWHyWijspdj27XKsmOGM52/SUB0ZiexNm6DKb4GhqlYDXP1eT/iUuvS16z/oTc6fn9dvD9WlYmW+IH+f1tUV8t8C2a+AoO3A3v8m22Ib8NM60Ytsd/2OrVJmZhJC+MOPDTdV0KKve1/09+gPQRCwMZz4jkXm6lPS6jR1cA53Zi/aodeHMhJGl+RSkuaYXp6O6fems/VeCQ37OgLAlsdExTA8M7zR/Qwx0mukqK5mkvckcDwnmlnPr86HVqmEoFYj9evhbPAbOEgKx8scJu7rJhpgx3Nfkc/v8gQ9KYyT69cZgJqf/3DxGSQyvXl4fdC6sSdZTauNZm+QkTrGX/+PeBLhE4VaF8kfsj/Y7GM0WgGfORsbo7vqUhnpQqNudP2zlCKLtr0+BEFAd9fuGOk10uxjfnGLgkQmR0wWSTEt9/cX/V5TJk5sVZsKT59m5yo4eQqCUomLX/8ougYA7Nw/A+MOkQmU370D2fFlZ12gsJci79fWtaOtQY3dT7w6Ye2mmIVadS16uvVkWRmWIE0dCbXqWiNCeDvxdovP9533d0bno/Xkpmx/TOF9+Xs2oWiDZZGYV2E0AW8NH9i2hp2NENpgg9mwamc9F5aMx937IqZLNzhu1yskHho3Hwp7KSJ69IXCXop5c3cRieQIY9GFJqFRAe/uAJUFJFJnWBNYmARotcCBL4HtfycWBtHX9NujdGqUNCLV2HJ2iOko4eGuZPsf/00ikDd+hirgCBT2UqTNmtlo02f7zAbHE7+lVQ9XsfQbQ2RUZKCXWy84ujoiMC0QNeoafC//nr2EQzJCAOgNksfcGINdEbtQrjSuVzIEVXUzJRMekBaAxYGLMd9/Pub5zWNRnwEeA9g1VFoVBl0bhL7ufSEIAh5lPcKD9w+gqaxC0tixeD9lHBIcvkJcVykSRxJbiX5nuuHauC6iwW9Sry+BQ/b6z/lIN2DHv5L/v3QTtevPkCTRC25bA155HgoPs9NGc7ZshcJeispf/g1INm3u/Kmh8yY/9NkdZPb+hZV1TDnYEDdfZIq+r/vviAIpFT640pL+3gy0RE2XWmVQEYbcHTvEaexdurbYD7Uq4pnYc/PgQVRFRBilyWtra9n/OZ7D0cveyPhlCZRpaSje8hMU9lIUbf+lRW1oL8hT5KTtL45auylmgaa1z/Gdg5TSFPZ8lad8PKl2NJ2eLs2pjzSEUqNED9ceonPN8pmFn/x/AscTUbHGoBW00Apa5mG7MXxji9phQ8PILq0xIoSx2e1fw93WsLMRQhtsMBtW7axeURm40280FPZS9Fh9jT2YLg+dIhoAfffzUUhkchwOjG/+RW4vERO3k32Bc8N0IjGBwJ3l4mgTjT65dCL/BwjR898I3FgAeMwU1xgWJRMy6NKJpI4CJD1UpfN+uzDKiDyqZf9CRHJGNC7BTaN0YZlhzL7BVLpRenm6qNi+tLaUeV3N85uHXRG74MA7gOM5s0ViaL3L5kebjbbVn/lNKUuBIAhGgwBT9R/5R46KIypOXyBj0YIGa0RTB3xOPs/9/xR/jq+uGLWL1nfRpaHfS2hGKEtlagq5u3YTEaOF/wDi/cz67NoLSo2y0dq3GnUNrsddt7h1SfftgfjMWY4ZZ57iVHASlOrGU28TdLPR8+p58L3LLhd9X/I3RKhlt5xkC5x8aH66ckuQX53PBvnmYqZOHId6W6YvMP7ttsTIW1tXh+Rx40Xnydm6DSVXrxqdP2nUaPb/3ue74tHk2fr+NESnunzpcLPb0J7wTyN10IeiDlm7KWaBCmRRheKPkRCefHVS9OxuqSUIVY02XA5FHWKR1cZSZtVaNQZeHYifA37GrcRb4HgOJ1+dbOEd2dAQympUTM19IU+yHh6bmdL+IcHORghtsMFsWLWzhiUUMPI3Ysk57PJ5B7enabg/7GvRAGjYr+chkcnhfMs8rzAGQRCTiL++AWrLAX9n8vfhLvptgaQ2BxmRjdtMvLis3x6pizDF3iZ/XxoHPP2T/P/CKLLt3LB6kcSh0Dj/jQze+n3RaPOpafCFtxcwRz6nWek2YZlhRi/lQdcGmXUsQJRHOZ7DTB/jKGb987or3FGnqQPHc0yWnS7s+NpyqNyWIo7jRN9txkgJ8n5fKFoXMaSzXqRj3j/J8XmxhLSfHkiIvAnUl/i/EJ5icj86YFka1LDKK0XefiJsVL7gH+R7tiJSSlOwPmw91oasRWRuJIZeH4otj7c0uD+dkbd0Wt7RoAQ47ghkn/OjxMYHEk+TiXXC2uvGROn2K32U8NZLYuux4x4hhDvuvTPa35Kg/mu/3Dc/mjbp1GN8sf4O8kqJMEbSyFFGhK3Yw3wrAoqivy4bnSd98WI2IdHQMuWwFJFjJ4gJY5+voMrs2BYpVDRr3/N9bJ1Kq2qWJUF74nHWY3A8B5cnLgBIxPB09GkoNR9Pml39OsLmmshT+KT4gOM5ZmVB3xHLHixrsi6dvnfoc6u1qas2mIZWK2DOhQg433rLlJMNha0+FtjZCKENNpgNq3bWuNxyHB5LUpymzT/I6nKeDxgqGuA4rr6qk01vnvcZMp6LyRhNAQ0/ZJzyGUqsLyAIwOurwEtX0ymgyQ/1x5TqJOS1GuCUE1lH0xldOgF1FcARTv/33RXA01PQbPobi441BuqbJwuXYfKdyeB48xXatIIWPik+8Ev1Yy/Yr299be4nB0EQ4OTuBCd3J6NBWn1CuPzBciYAMNNnJosu0ghhzauXUPK/ImvM/xgNaCsW/xuKZv9f9vcPW7vi/k+fsb+F472abOvlx6kYeyQMXxgY7kpkcnhFmfaWo9Ybk+9MbvLc+ceOEeXyk1EAACAASURBVIGPef9O0omtiGHXhxl99hxv2tPMsCaoMdLYUmi1ApxvvRVF9hqCz5tsSGRy7PIxTfCOP0gUWTJQOwpTBNKSeFvwFhzPYW3IWrOP+fpwMIJ7DkDSlGmoS02FoktXKDgHZK5ajaLLelKXuWo1BE3TyqVVz5+jIjgY6YuJxUra3Ln6+tm+Tkjo1x8KeymOjJ2HzZNWGvWf3zd/hZievUhEccVPqFj4DwieDYtVdRSEZISA4znsjtgNQJ++uzp4tZVbZhqU5HwoKa4tgbvCXfRcMVeJuT6o+M6GML3w0cP0h1gTvAYczyG2qGG1ZtonOZ4oYXM8h+c5JnxobbAYTgUntUuKvjVgZyOENthgNqzaWUuqlGyQc2u3Xm1O0bMXYnr0RMKgwXjZrQc+X38XEpkck04+Mu/EGhWJAv7xP2LSl6Y7/qWbMSGMOGPeuYuS9ccYojgFOPiV+JzpEcQ8/Y//IemndZVAahi0mztBYS9FspN9o5cqrCkEx3OYencqxtwYA47nzFLGrI9B1wY1u1YKAGb5zALHc8irymPr6MDNcHFyd0JaSTI4nsN8fzIYpQqooy70FQ1gE3t0RsFUQgBTh/cALoyG8ve/I2iQFD9v7AqO5xCw5b8Q1/UrFM36T8BtSqNtrFVp0MMgWjXiUAgmnCA+S4Gxpj2rBEFAP49+InXJkIwQkylSVOSj5If/INFhK8IUGaTL4ReHRcQ9MjeSbdv+dHubtOewzqS9IeJNQUVi/gxJMrn9TChRG3V9mgYA2HonBhKZHPNNqMRaEk+yn4DjOWx7ss3sYya53DaO5C1cBABQ5eUbbUuZMgUlV6+aPJeg0SDBqR8hlfZSKDgHFpE2XB6vcoZkgw8kG3yMtkX1tCdt+HkhcHclee5EXzd5vY6E8MxwcLzeVudNwRv2e+2IoGTpcsxlazelzUBTNOnSXAXYSmUl6jR1LBJIawA5noOiSIH1oevB8VyjXrmG/oU046S4tv3taD4luD97b5SiH59bgfyKWiu2yjKwsxFCG2wwG1btrIIgYOnMTVDYSxGzj8y8auvqSNrT2LGoS0nFjLWX2GC/vkqhSVTkEuERl07EvPzWYj1Bq9ARm3h/Y0JooiatQby+CmSbeKnlK4BjPQCXv5FzHvhSV7fYR79PVRGErYQQJjl1a/QygiBgyLUhcHRzRD+Pfujr3tf8NhpguOfwZkcIATAF04gcvQk5tW2ov1y7ScjjsgfLAABeCV5k/bk1ogFsweZfoN38NxTP+Q9ozk8gRNqlE0ZflLJzPT3yOYRtnSBs6wSUpDXYvsl/PhZFBCUyOX698gJB7/Iw/cyTRlXTKGGl0bVRXqNMRmCLLl4iaYDf/yfxq7Qi+nv0Z58RHXQZLjPuzUBMYQzqNHUitdl1oevapD2UyPFP0hrd74iOOHpGmiaOfz1OhUQmx/kwkuK76fbbFnkdNhf3398Hx3PYH7m/6Z11mLbOVZ+aOXYs8vbth9IgPbNMLkfGcuJdyYiePbGLqG+RU/vunbheduo0kcpotvNGVEdFITyxgP2+szdvhqJrN8i/H6w/dvgAqAsLgUNS8uypalt1VkuAZj9QMm4YGWpr5Fbl4reQ3+Cd5N1ofW14Zjim3p2KlNIUVl/nndSAmvRHAMNsEo7ncPzlcbOOy6zIxJbHW+Do6ojFgYsx9PpQOPAOqFHXsHOV1ZVh06NN4HixUnZ9UH9Kulx8e9FSt2dDA5C/yRFlcFTWqT8ab0I7GyG0wQazYe3+ilnz9pGZ9C0uAABVTg5JnZr9PQBg0L6H7OH05SbfpmtMbv2iJ3nJOmn8sANk9pweW5wCbP8XcTpnQ7YRLUFxCrDvM/25fcQpacI2QggT+zo0eap5fvPYy3G45/AWNYdGF0ffGN2s4869OQeO53A1Th/hoOqAdBnrMRAcz2Hh+a5G5CO+OB7Zu3aKU0R9bgFxvoSsU9GeXf+OoZe6gOM59LnSB7XnR5iOwhqgVqUREUGaLno2NNmse6P1dRkVGSiqKWL3U1gjrocrdrsChb2URCsfH2vGp2d50LRhjucgCAJq1DVILUtFTGEM+nn0azB6uOT+kjZpj5su8nc6pPHPfIs3ifgFvcszuZ3OUJ8KJhFEmoo67ID51hYUJVVKswzY1Vo1tj7eCo7n8OfrP80+/5ylJwlZkzk3ua+g1aLkuqd+MuTUKSgzMlB08SLUJSVGdYN5e/dCXVyM5LHjUHrjBjtPfK5eIl5QqaApLwfvTARowkZ0Rvb5+UBujK52uXl93FqgEexNj4i3a0xhTLsRwh98f2DXWhiwEAB5rm1/up2JNGkFLdtn8p3JTKSL+sB+jAhODxZnHUQ1LUyUUZ4hmqiiywjPEQCApJIkPM1+CgBweeICjm/Y7qdaVS0ysJ9xb4bZImg2tBzUA/o3T6KZkFFcbSOENtjwCcLa/RU3vYKhsJfi/YKfAQA1b2OI2Miy5QCAUYdDm+eVc9xRTybUjexbmAi8f6rfN8mM6GNzUF1Mzl+RZ1yL+OgIFFJ7JPZpmhBufrSZvSC/ufVNi5pCTeubSygD0wLB8Rz2PtvL1i25v0T04ve4Pkn0d/30u9RvxogGvcr3ujoFjUG05Ile3W7Vw1WEeOkEeBpCQUWd0e/i8uNU1KmbrtsCwCJo0QXRTDCC440l0Us8yYC+cPp/6X0prQRDX8f6eFf0TvQ9zPefj9hCooxoqKLpleCF30N/t8hA64bONuJQE+q/S91fQCKT42V6SaPnORwYj5isMqy6RszfHVyaZ5as1QqQyOToutW/8f0ELX65/ws4nsMAjwFIKjGdylofhimhefvM/y1UPX9OagJ794GCcyDHHziAjCW/ivpGeaBpsaTiKqXRAO3S+bn4bm83XN//X6g4PRqIuUX6jP+HIdH/Mu8lOJ7UmQFgv9W2JoSGRI8uGq2G/Z/WtyWUJBjtN+DqABTVdPzoa0tRX4jMUPCnIVDhs9XBqzH+5nh27CivUUb77o7Y3SCpzqvKw4x7M/SftccApJSZFgWzwbKIzS6DRCbHz5cjRX9LZHJotB1T5Mlc2NkIoQ02mA1r91cISiUU3TgkDBoMbVUVk1TP3UEsAWg9GF0S8yoaPplaCez8NzIwylc0ffHCJD0hzGjHwvXs14jr+hUSejY9+DkbfVY0Y9oSzPSZSaJ5N8Y267jEkkRwPDFiBshLu7trd4z0HIkTr07gRsINCMccsOLPz/WDiCf6ejVNZSUUUikSHTsjoXdPxHXvAUFrogZSEMQpQloN8OycXrTHBFIKKtlv4uaL5isq0sHJw/SHInW9lFLxIKTU2xsKeynyp/xf4MGOZl/HkhjpNRLdXbs3GCWntaI9XHtAK2hN+uzR+4wuMKGg20z4vSWpRjv/f/beO7iJqw379vfOfDPvXzy9J4/yJCQSsPTeA0kghJKEQAoBUgmEEBJSEN303nv32mCDMRiMZRtsgysYGxcwRu69G/duWdrr/eNod7WWZMm2bNlwfjM7WKvV2aNylnPtue/7MlMshuez06T6a8Yz0wWRvB6RojNT9ocYhQA3a63Pma1q0Igraa1EEqRVkHzXqVenIqe69fxHQwp37BDE27NTp61+HQBkzP0YarkCif0HkBtgn89H0tBhSBwwEGUsi+yvvjbrX6jTcRi6xR/zzz4Q9kWdWoq8LX+CzrEXNLt6Aw/PketYyJ429ctePCp5BIZl8GvwrwA6J4ewWdeMs/Fn4ZHsIQi5h4UPjYTeoZhDwt9+meRmgmeKJxiWwbLAZbiafBVOT5yQVfX8Fd0wxLAYGMMy2BKxxeiYmqYaXEq8JPjY8qt+wTnBQtg9w4r+t4bsitoFhmUQkCX1MM2uysZk98lgWFIJe2fkzueqemt3p1x/w2nszjvgOE6oCi1TqvCsptHe3esQDlQQUihWY+/xCgBInzkLarkCeb/9bjThmn38nmSCeK81r5y8aDIpujDbuhNXF4mCsKhzS9xLKIxHEvMGkgb0tXioT7qP8J9se8uAJ5UlYbbX7FaT+U3RqG3EAOcBQqgpL5z2RetDiSrzAMdecNv7H3Fy5T5DeH1NEFn9zZvyCrRFWWguN71CBACj3YipfVKZdV6TcTkVkClVkklyWzj+6DgYloFHsock305dKr2RUOXjQ1Z03n8JuLWmXeeyFSNdR2K022izz0/xmCK5ccB7Q052nyw85t9neF7H8/OCk0ussoOZdSQMMqUKJdWmJxd+TwqNhCC/lbZhQlJQKZote7RykyC6KFqyOmUt6XM/Ea5P5ZfbZtrdkJSEZ6dPQ1NUjMQBA4V2sr60riKoVsdJRG70qSXSHOjATVIrnG4O7+v3892fAYgrhrYUhIY3ega5DMK9vHvCjSBz28lHJE940/1NYFgG/ln+NutPd8cwUoJhRYsNQ/g8QF7IL/BdAIYlofe8v2tYnunibweiD4BhGfik+0j2747aDYYl1bQ1Wo3J11I6l1lHST5+UmE1biWI12N1QZW9u9YhHKggpFCsxt7jFQBQsG69UfW8Si8vAMC8M1JvuRtxeeYbenCKTIqCdlh34qY6AwsJ61cKOkzRUyT3fwOJjGVBWFBTgNGuo7HtwTa7eHTxYUB1mjrMvD4TDMsgrUKfMxbvAc1vf8KTKUPw44q++OGXvrj1pX4FS6dF8VLij1a+YrLF8+RW57ZabKAlfKGNlR5t9KbUwxcvOPnopCTUqaVorg4MJCvWM14CVL+061wd4WHhQ3zs/bEQUveOxztmj31U8gizrs9CcnmysG+M2xgMvzgcOk4nhJwyrG28vaIyyyBTqrD8Umyrx03aGwSZUoX6JtPhvHeTis0KwtTiGqv7k1JULXktb2PTksDsQKNQaEtoCgsl16fSc+etfm1Lsj6fL974OmFldeMWxJ38FnDsBe0GfQEr5/fJv0+utrtfXQnvBboscBkA4EHBA5sKQkNx81vwb2BYUq154uWJGOg8EAU1BUIu4bRr04TrAS9Q+aJTxXXFNulPT6CloTyf32kIn0s5+cpk1GnqMNJ1JIZeGCrkXrYm6I7GHQXDMriRekOy/4fAH8CwDJ6WduFNWYqEfbeThAJh37k8FK6hIcnW+R53VxyoIKRQrMbe4xUA0JiSYiQIax+QEM6vnKIkkzy+EqFJ+IIyKQHmjzHE0Li+3vzqlc0pSULywNeR2LePVYfz/9nag+8DvgfDiiXEZ3iKK4Ba96VIG/4a1HIFbo9V4P5g8t3V3PYC4lyROfZ/UMsVaPS2fTGWlpXR2gp/N5ufjPDbgwLpimNNaCipEvney4Bn5xRnaY0N9zYIQpBhrfNONISfwPH5oPx24lH7hIghfK7JN+zDVo8bsS0Ar642XxCKL2pgaovKtL7kfGx2ueS15mwr+HDAthST4YsL8VtjevvzmzRFRcRvUNEHDWorQttNEH/iK8CxF9LX661utr/UObnQnURmZSYYlsE3t0lRF0MBZwuUoUrhO+Y4ThB4hiHwSWVJOPnoJOqb61HVVCVEKfB+eW0da88D3uneQoXo30N+N3qevw694/EOPJI92rTSzhcp80j2kOznbzRWN7WSDkLpVAKeFgn514bX0PakY3QnHKggpFCsxt7jVSD3x+XSCVcqKfSw2CVacoHa5tPKBOrkBDIpqmrdKFsCLwi1XVjN7FkqUga9DrVc0XXnbCd8OM/2B9uFyZL2WTHqQ1TInsIYCXm1XIHMtwZDd/FzqPvIkTzgdXB1thfblyKzIVOqcCgwxfLBJqhpqsEQlyFGIWMhuSGS42ofkIIg+VP/C7h9ZouutwnDQgsMy2CB74I2vf5T70+FVRDDdnj/t46Q8awWMqUKn52OMHtMZZ3GYoGY6Kwys4LQnJekKQztGVoTlOefnAfDMiZ9J82RNX8B1HIF3vv2CBYe6rjo4pqbJXYVbeXpiQWAYy/cWjdZGjqaF9PhvnUFlY2VwqodIBrV20IQchyHcZfGYbDLYMFWxjAs/FrKNZOviyiIwCDnQUbhoy8afDTCiqAVRs9NvjJZyL/dGbmzTWG1Tk+cwLAMXNWuwj7e39GWocKUtlNU1WDy+usUnmHvrnUIByoIKRSrsfd4FWhQqw3CqMT/iH90i5VcoH6+bCYPjuOAbf8Gtv3HuKpna5ydQrwDu5KyDKQO6Q21XAFOa7/VP2vg7wLzd4YPRh9AxqRBwneVPFCBvBUrTApDtVyB3MWLOqVfp0PSIVOqcL4D/2EtCVgi5hjpJ4K3M6WVHutiY0ke5DsywGl6B3vdNjRajeBByfeT93m0Fj7nhxeFywKXgWEZfOT1kcUQ5EZt6/l7xfpJhDm/QI7j8MZaX8iUKoxqxUM0PrfSrCA0511oCr8nBcLrjgWlQqZUYe6J+0bvk89l8k73tqpdXW0t1H37QT16LF5ZeRNfmFl57DIyQpG/fyLg2AvH1y2QCsKynlGZkeM4DHIeJFQ+5j0hGZbpcEREYW0hGJbBJ96fCPv475xhmVa9BxNKExCSG4Lsqmy7hOh3B1qG8xrCe9q+d+09rA5dDYZt3VfQEF78GebCz/aaDYZl8O7Vd23Wf0r7+PzMA8w9cV9y/eWtgHoqDlQQUihWY+/xKqH0vBPKnJ0l+3698khygfr8jJkiIlX5ZEJ0amLbTspxgKnKl51JRTbShhFBqGvq3tXU+FBRfruhWixdDXxnOMpcXUWz7jcnSHNBvTvHy2ivPuehteIhltgTtUd4X5+pPgPDMriZdlNyDG8enjNZBpwY18Fet430ynQSVnfrG3ileeHHOz8ipqhtK0CGhTVU6aT6Jl91lq/2x3EcKhsrkV+TL0yC44rjMMRliORufkuqDap6uj7IRnFVg+T5NINKsEO3mA/jNvTZa7kZ+kpyHIe9t5PMFpa68jAHMqUK+/yTodVxeFtvWdPyeL4yYmhuaOsfnp7aiAio5QrEL1oKmVKFxS7RVr2uU9AXcuK3VY5rpIKwK0PfO8hk98kY6DwQK0NWSq4xDc0Nll/cCrx9wvrw9cK+s/Fn6UqUlaRXkOuOKf/S8ZfGg2EZzLw+E0sDl4JhGUnOcmvweZpn4sXCR3xeM7WY6D4YXn93+SXauzsdwoEKQgrFauw9Xi3Cm1Tz25T9IaYPTA8mE6Kr33ZtB9tDZZ6Qe6erNV2Kv7uQUZkhmaxlb/izRPDlLf1aWEVTyxUov3QZxRt+RsGCt9AYb32RmLay6tpjyJTmzc6tgZ+gMCwjhD+1zG9pTE2FWq5A9puvAAcHdLTbbYIPo+tIeCdvNj316lTBe5DP15p1fRZOPDqBoReGCp8D//6/uf2N2VUCHq2Ow6urfYSx+b9VKhwMEEN4nfXG9TKlCn1a8QbM1Ieemtq2+4oh4tFZYo6gKZzCMyBTqnAqhIjI67F5kClVWOoqFdF8+GB8SbyFTw+oi4oSftuBWw4a9alL4DhiPF9dCORGSwTg11uOAhfniPu6+uZWB5hzc45RyDbDMoKlQXvhb4JceHpB2FfVVIWf7v7U5hsqLyI5VTnCjaiWjHEbI+RXfu7zORiWQVGtdddgPnf3eNxx1GnqoON0GO02GsMvDrf1W6B0gIT8Skw9QCyAHL0S7N2dDuFABSGFYjX2Hq8W2XgjHkOVrpApvfHKKhUGbzaTrxB5mkyIgnd3bQfbQ3Uh0kcSQaitNB++1B3gvewYlsEnp15HzeK/SQRh8YED0NXVCY91dXVWtVtR14QPjoVD9Zjke3o9yscaz3irjXCnHST+lAWVpr3brIEvLMOwjJDf0jKvrCknh9gDTHgN2PlKu8/VHnjTZ6cnTu1uo6G5AWvC1kiK5XAchy/8vpBMwvlKq2vC1kg84SyFco3aHgiZUiUIwzE77uBMaDrKa5uwVfVUIu7MkV9Rb1YQGlaRNSw+Y4ojd1KE1UoAaNBo8cZaXwzYKA0D5oVIYa3l/MTUyW8Jv+3dzqRaaquVjjuDiOPk2nZ8DJDkKxGE3+7Qr7YUPAKy7ndtvzrIYv/FJgVhR83ffw/+HQzLILLAzqG9PRQ+5Hah70Kj5/jw9Y+8PhIK9Vi7ouud7g2GZTD84nCjaw+lexGuv9b+dqXjfrX2xIEKQgrFauw9Xi0SeXwR4NgL7NqPMGxrAGRKFTSmzKp9V5JJUkLHy+l3OjUlyBj1KtRyBZpLOzb56Qr4/7j3nBuB7E8/MGkP0qBWoynbvJF8S/gy1/zknv87MsO4CEhlnQbvHgyFWyRpv66pGa+u9sGIbVZWkzVDVVMV3nR/Ezsjd8It0Q0My+Dck3OSYzRFRSQ0drwc2PTntuWndpAtEVvAsAwCs21fOTK5PBkzPGdg2rVpeFDwAAU1BcL3/KHXh5IJW1mD+UqfY3bcEUJCeXEoU6rw4bFwo/xfc5TWNJoVhIucxQqmDzPLjNoqq21CYzPJOdvhmwiZUgWvR/nC8yO3BeJ/q0Sj+uqmavRn++Ntj7fN5ohxHIfsr79B0pCh4sq3mxs+OUXya1KKurga4rVFoggM2SMRhEv2Olt+fTeFz0FruVkj1Fvj/evvg2EZlDf0nPDZ7sSz+mdCGH1LeDE39+ZcTLg8AUMvDLW63ZaVjvltoHMX5/BTLMJXbF56MQYPM8uM0gF6Cg5UEFIoVmPv8WqRwt0jAMdeqNvwN7yvN0/NLTexCuXygd5gvgeEONSVIXMMEYSaom7uc2VgZu7tfYDkCb79DpqfPUPF9evtzoH83eORSUFoavWFLxDCH8vbHZizFWgrHMfhWso1Es706LjkuebycqjlCqSP60t+X03WrYDagu/8vwPDMkgpb18l1bag43SSSdrkK5Px092fjHKxWjJaLwKHbQ3A/LMPJGKOF1CWBKFhLmLLbe4JcdWrZchobWMzZEoVJuy+C0AMI76bKI6pt/R5hHVNJFw2LC8MDGtcKn+nXyK8HxMh2ZSbR4RgPwbJI0eh4ponOI7DgI238fpaXzSbuiHVmbh+IorAE+MkgvDHw5e6ti82JDgnGAt8FxiFjuZUtd8TtlHbiIHOAzHZ3bL3KcU0fAXYOTfnGD3HV2b+4MYHbf6cH5U8Er7jdzzeEXJ5B7kMsmX3KTYgWe/pOnp7IF5ZZRx231NwoIKQQrEae49XixTsHStOfvQrDvfTTKyq7WcAxz8AmvaHEHYZDZXIHEc8+jR5XRx+1laqC/HB6TfAsAwSF31JVksuu3e42W+dRfPbL85HCn8fCDAuUGAYeggAdxKJZ9JqT8s5YNaiSleBYRkciD4g2a+rrYVarkDaGIb8Dqs7tnrRFvgwzo4W2bAWw1Cuc0/OCfmjc2/ONfuaL/Xf3YJzkdh4M0Ei5nhDeplShflnzRSDAtDYrDUrCN/aFywc9yC9VPI7MCxaAwDTD5Mw4rwK8RowS38TqbiafIZ8cRHnBHFlrby2CTKlCu/sJ+dK81SR/Nh1G4Rj+LDWGYfD2vKR2oZz70oLxxhsvxw3baHQk2hZVCatIs3yi8ygLlWTgigBXe8Z+rzApwmY8mEc6DwQDMtg3KVxZo8xR3lDufAdrw5djcrGSvwQ+APC80xXKabYj7wWYfwfHOuZ35EDFYQUitXYe7xa5NnuYcLkZ7cfEQZXHpI7yFejc7H8UiyaG2rIMQf627m3VtJYg6zxRBA2ZWXZuzetk3UP5Zv+iMTjJFQ0ZfwEm1RG/ej4PZMCYJlbrNGxhpVmAcD1AfEgNCxg0lECsgKE4jKGcBoNWRUd2Z/8xkqSTDdQXw48uWazkFKNVoMBzgPw1pW3bNKeNSSUJuBA9AEcizuGJm0TdJwOg1wGYZL7JLOvKattwsabCSitacTFB1mS7/L1Nb7ou94PdxOLUdWgMdsGx3FmBeHQLWLOcFiKmEPIcZykOmltIwkjHrktUBIK+vkZsmqZXlIDQDQsv58vrjwWVhL7DD7XcNPsn6CWK3Bru2hcH6gmNyF+97BDTs3xMeS3d3sduellIAiVZ62zzujObLy/USIIE8vaX9nQK80LDMtg38N9Nuzhi4VGqwHDMpjuKbXZqWmqMQr3/OnuT1a3yxlEm7TFA5TS9VTUNUmuw5P3Btm7S+3CgQpCCsVq7D1eLVK5ixEmP56hcZApSVl5juOEcLX0JxHkmAuz7d1d69DUI3viK1DLFWhMa//d8C7h/lHAsReKls2BWq5AybFjll9jBXwoX2shgjwfnxRDD6ceCBFCES9HWZ+zaInQ3FCTFT05joO6T1+kDNcLwhwzlVNPTiDPx9pmopNZmQmGZfDVra9s0l57eevKWxjgPMAqbzjDFTx+M1sVuAWv6/0KW26vrfYRBN7dxGJhf11TsySElC84s/SiNLRpsUs0ZEoV4nNJ8Sbe9+xZvWhFkVNWJ7TToNHi0NvzoZYrcPG4WHGWL1jTEd/LdrO/n76CqBZIuwscGixcE9e73Lb8+m7OrqhdEpHxuOSx5Re14PyT89gVtQsfeX0EhjW2j6FYDy/cpnhMkexPLEs0EoSPStp2g4R/neENGUr3o6lZJ7kOD9vasXx9e+FABSGFYjX2Hq8Wqd3eW5j8xD4k4V8rLscJMe4ypQpJAefJMX6r7N1d62huQs5kGdRyBerjbRf22Clcmgfd2l5IHjYU6n4MNMW2yXkcuS3QpACYtCdIcpxOx4HZcMvksUFJtsu/jCyIFEKZWpI4cBCSB+sFYaqZ/xj5VZvba23Sn3v598CwDNaFr7NJe+3lE+9PjASUOcpqxbvKqcU1OBeWgegs6wp7MI7G3zG/j19dvJVQKDxXUt2I4OQS4fGeW6RI0dkwqWD7xZ2sLt9LewaO4zD84nCMdh0tOcYw9DSnrA7nJ86GWq6Ap/td4ZilF2MgU6oQkW6HIlDbXwa2/Ud8/PSG8Hvbcimo6/tjYw7HHpaIjOgiyz6PudW52Hx/M8obyoWcN8MtqczMSj7FKkxFBgRmBUo+4+8Dvm9zu0E5Qdj7cC90XM+xR3lR6b1GtBR6Y62vFs1aAQAAIABJREFUvbvTLhyoIKRQrMbe49U0lblAtBOg06Fpy0vC5Kcg6gaOrF2A63u+Q/UOBRatdoRMqULR8ZnkmCdX7d1z69BpUfzBf6CWK1Bxtfv2uS4qClVLXkPx7JehliuQ+/PPNmu7XwuR994hkv/FbLglOS6lyLxpeWJhx/zKDEkuTwbDMlgSsMTouaQRI5E0gKxUOwX8IoY7NVSJOau8IAzda5P+3Ey7CYZlcCjmkE3aay8/BP7QpjC+4VsD2hVeNHSLv9H3y1ct5fP/vB/nC89lPquFT3yB0e8nLqdC0q6jF8lrvJ1QiIqGCjAsg9le0kgCw9DT6KwyXBkzjQhCX7HC6aQ9JB+yss586GunoNORMNF9fcV9KQHC722nZ89faTE0jbd29ehLvy/BsAzmqebhYeFDI0Go0Xbx9/ScMfzicIy7NE6yj01gJZ9xwrMeUMCN0m4GbLwthP7z0RM9DQcqCCkUq7H3eDWN6hcy4Unyg3bTX4TJD2fwN1959MfVa8jjvQqgp0wCOA5VX/0darkChZs227s3JtFWVEDdj5FYTNRG2qaqp1YnzRnji3m8qZ90G/7H4/4wx0goqB4XYKdfolnbgPbAFzwwVUAledw4qPuSKqPDnQdhiMsQ6JrqgF2vAifHA7Wl4u8yYKNN+nP+yflukWvDVwIMzQ216vimZp1pWxgLjN5uvGI8bhextCisJILQMzZXeC4hv9Lot/HGWl80NUvPza8cesbm4mnpUzAsg2WByyTHPMmrFNpwf5gDv2ETScjonacAyO/11dU+GG6PsKmGSvK7OjZK3Jd1T/i9HfaxvJrW3XFVu0qERkhuCApqCtCobTT7mgmXJwjH82bphhulY4x2G41RrqMk+3ZE7hDyMwOyemYIIcV6Vl2Lx7fODzHzSJgQldHTcKCCkEKxGnuPV9Ncnk8mPIGbAMdeKN7wX9xZN0EiBis2/EtacS/sgFEzHMfhUGAK3CKzUVnfvcRi069/Jf52n3xq764Y0ZCUhKJdu0l1zWG9kf3hJJS7udms/aoWNgPrbzwBAMw5QQrN5JbXoa6pGW8b5Bn214cPjt5ue08+gNguDHI2XUCFNyfXbeiF/voJZ35WiIEVgFgJF94Gq6g6Hdnawe6o3WBYBn6Zfu19SzbhxKMTYFgG7kkdryzbGvzNgJbhwzKlWDXUPUoUgJEZZTgXlmEx//R4UBpkShVc7mciMJuEvG17sE1yTEy2mIu47voThA0cgSeKvjgTQvJ7+aIz7x+1Q6W9ihzyuzo3VdyXHyf83rKLLIfydneup16XiLn3rr0HhmWw/cF2k8fXaeoE+wNT27Rr07r4HTx/mPIYXB++HgzLIKIgwk69otgD3k6IL8zVk3CggpBCsRr7jtaKbODiXKBYLd3vPItMeM6/Bzj2QuL6fnhNeQPw+Q1w7IUn6wdgtJKFq+MnaNzwFyTsn2XSH87QyFqmVEGr6zpTcUtwm/6KpP5yJA4cBE7bfUIxqm7fRmL/AcKqYOnH/waSbVu4Ir9FSWuf+AIAwJILpABIbHa5pIAIv8/lfibSOvE/pclXJmOg80CjAipp75IQwsa1vYRJ572I/aatAK58Ib7w+BjgUPs8tvhS/A8LH1o+uBPxTvcWVgU0Og1K6ko65TxT9ocYCcJ39gcLeX0AcCFCrGJ6N7EYhwNTJMdvuvnUqF0X/WuOB6XhaDQJTTwac0ZyTGSGeJ34/MwDxPVhENF/KI7eTQUgmjQvuWCH1bjCePK7cv1Y3FeSLP7etM1d3ycbcyvzlklhZ2q1XqvT4vuA74Xwbh2nE8Kr+a2jxvYUsZiUIb+H/A6GZRBbbFwJmvL88v3FaJPh+D0BByoIKRSrse9o5UNDHXtJ9596k+zb+EfAsRfi1g+GTEksBwxXEjZ7ExsKvrLgjbg8zDsTgce55MLFF4Lgt/Lajtsl2Iwt/0DWxDeI0EhNtXdvwGm1KHVyglrRRxomuvhvJGzNhvAFgV5d7YMV7nGobyICbIv++7wanYszoenC9zZks79Nw0PN8bH3x2BYBqX1pHBIemU69kfvR9KM96CWK1C95o/CpPOSz2Lxt7vl70CCJ/nbeRZpTKsRn2/Ui9jHV4CI42bOLqLjdFjguwAMyyCzMrOT3q118GbSK4JWCKuWLSux2oIZh8OMBCGfF5hVWgsAOB8urgg6hWdgu69acvyRO8Y2JDcfkbzDraqnGH2eFMiZd8FVckx4qmhn8eZWP6jlCvgPHY+9t0lhEl99ruLGm3bImUoNJL+hG0vFfZW54m+rC8ZFZ8NX+DW0JBjlOgrDLw43GvcHYw6CYRnMuj4LFQ3iBJVfVZx4eWIX9/75hPdANbw59tPdn8CwDJ6WGt94oTy/KK8+hkypQqC6yN5daTMOVBBSKFZj39F6a404sak1qN53eIhk1eX+ulGCIFzp8VgQgVmltSRU7OR9NGi06LPeDzKlCjOPhCG/oh6vrvaRTBi7VcjDtn+jaPZrUMsVqPTysndvkPfb71DLFUjsPwAlhw6RcNHhr4E7PKJD7TZrdZh9/B5+uyKWJ+ftAlp6Dqoek4n3Gs94rHCPE763qQessy7oKEsDl0oKqKwIWgGGZeD7Vn+o5Qo8W/VnYdK6020K+X3GOJMJeu0z8TdbmQeUZ4mPixOJoT3/uMF8MZy44jhhMjbQeSBqNbVd8t7NUVpfCoZlMPP6TEz3nC68f1sLdFO+lLypfMYz8hmcCkkTnlvhHoc1nvGS401ZQvCre1+xIejnNAB9z44E4+gjOeZukrgaPXi5KykoM2oKtvmQyAU+NPVUiB0sYh5dMs5NrSszfSOth5JXkyf8ruKK4wCI1W0NV/v4SsCjXUcb3SiZdm0aGJbBm+5vdmXXn1tmeM4AwzKSPM4lAUvAsAzSKrq5VRLFpvC+v6s9u3lFdBM4UEFIoViNfUfrzeXixMZw5WR3b4kgDFw3URCExVUN8I0vgE7HoUGjhUypwoTddyXhZAM33cYO30SjCaa1JfC7hO0vo/Jb4kVYtH2HXbtSHxdHTOfHjUf9Y+IBVnfnOrSr/wC4fNihtg2rhEZllgEAgvQT8FXXpP/B8LlaUw+ECPmEMqUKXzuZ8f6zMXsf7gXDMriafBUcx+FN9zfBsAyuv9MParkCeSv/IpZcPykHNv+NTM4BErrH/2b91wOZ4eLjFH8g/JD42Iy5/dXkq0L7833mIzgnuEved2twHCesvhhuBTUFNj3PZ6cjjMYrLxJTi8mNnKN3UyXhpD9dipUc7/4wx6jd0ppGyJQqvLZtKxiWgfzgF5ApVdAZhI/fNrCzmLjkDNRyBZwnfIAN+tzWb9iHkClV8Hti2/dsFfzvxvD6qGl4rgQhIPrT8SHSylAlGJZBZIFYyIrPYfNM8TR6PR82ejW5+1Zt7kl86PUhGJZBTZN4E/XrW1+DYRnkVBuPM8rzS2Udyfkft+uOvbvSZhyoIKRQrMa+o/Xy5+LE5ty74v4tf5cIQu917wiCsCWDN/uj9xofTNx9VzI57L3GB6+t9sErq8R9AU+7UcjDThkafyfWE5mff27XrpS5XCArYCdOiDvTg8nn77m4Q23zIXsypQong8mdZb6i5FaVcejRmB138MoqFQZtIiWvJ+8NQnapcX5oZxCUEwSGZbD8znLkVOUIk1SPaaTaauZvfxP2TT8jB9wXShtw+5R8ZmenADEu4m846ixwaZ74OO2u0bmbdc0SwWUYDmdv8mryMPfmXEn/ArNtW9zny/ORRoLwk1P3IVOqkFxUDQDY758sruRt9heKHfCbb7yxYOM4Dn3X+0F+eB4YlsGrW3ZDppRWsjW0r/h0wU6o5QrsevdrKK8+Rkk1EZQjtwWisdkOub6315LfTLyH4Zt67gTh7czb+CXoF2h0pPjXoZhDYFgGN1JvAAA0Wg0mXJ6AQc6DUNVkeoW9stG2oe0vMnz4fHmDeBN1ng8ZQ8V1tvN/pfQM3ljriyGb/e3djTbjQAUhhWI19hmllblAnCtwfpo4sdn4J6C+AmhuMirU4bFuhllBOO1gqDCZ+/jkfSw4J04sl7nFSkLRrphYQbAbu18Dt/FvSBo2XL9KuL1L8uRMkbv8J5IjF2BQSjzeQ1ztsoJAdRGis8qM9u+9nSR8/lu8nwoTbJlShZ1+xt52P7qJqz6DNtm2mI0lqpqqMMp1FBiWkZS1vzCjL1lBXf2qsG+gUz9oQvZIG9BpgW3/Ni40471Cuuod52p07gcFD7p12fyG5ga4JbphS8SWTrHD+M7loZEg5AUf7ze5y09c9e+z3g9vGVShlSlVCEk2XfBm6sE76HduCPqdHwxmozdkSpWk6vBtN1/smfoVXvv9Bn6d/SvUcgV++mglfroUi/hcYkmxyNlOxX2ufUd+MxktwqafM0HYEvckdzAsg5OPTgIAfDN8iWXInWUWXkmxBZ/7fG4k/ubcnAOGZajwfgHp73gL/Vp4BPcEHKggpFCsputHqLZZzBHc+k/yr/sC8m+Cp5iLZZBHeGjtQrOCcNYRsRjFvbRnWHVNzCu6m1iMgkqxouXpkPQufrOtsOcNYNOfUeXnJxRw0eTnd3k3Ss87CedvyswUn7h/jHz+945YbKOmsVn4jFvyrbM40V9+KRaB6iLhMZ8bZojz/cwuzx00RF2qFvKX+O3c+6TQTsJeaehkVpyzcQO31gC7XwOOjQaODDddibSlkASwP3q/0G5LW4TuxI3UG2BYBodiDtm03WVusUaC8CunKMiUxHMQALaqngrP/W+VCv023LIYEs57DzIsg77H5grXC0NPLf73//3Ha7B/ykKo5QrM+WIPllyIFqrdtpo/0/JGTuRp4N5hm3wucJou5qEaUpYBlGfa5hzdkJDcEDAsg433Se4kX+GyO4RRvwh84fcFsdepEf9Pmnl9JhiWQUNzgx17RrEHw7YGoPcaH8sHdjMcqCCkUKzGPqM0yU+oIIrNfwOeXCN/n3lLnDQ7TQfOvgNuyz8xROmKaQdNG2OvuEyKj3xxnuSaXI0m5tUDNt4WwsKux+aZXZGyG/v6AI5/AADk/vQzqegZ8aDLTl8XE4MKDw/BfD55xEhwzQYl7P03kO/h8RWLbRmuAhqG4gHA+F1iKO+npyKwT3+sS0SWybYMTcIXnos0eUxno9Vp4Z7kjlOPT2HW9Vk4NZsIwkdHv5QIwhC1BW8+jgP2EUN7nBwPxF5A4ra/4KLHHGE1ODgnGB96fYhhF4aBYRmklqfabaXYGviKkPxE3Vb8euWRkSBcpL+Z8CSPCEJHrwSjYww3PrTUkOV3lgvf1y8BW4TcVN7bEBAF4Zbpi3FzBPGcHPUDi6+couD+kHgf7vNPNt95p+nS8GFbVQCtzCORE7v+BzT3PFPojpBcnix8b5EFkXjH4x30Z/ujusn4O6bYnm9vf0tuelWJ1+mpV6eCYRnouPZ5q1J6LuN23YFMad66i+O4bvn/lgMVhBSK1dhvpEazZNJ0gCGhohv/JF1Fufw50FgN1JaivLYJGq3p/4Ryy+twJjRdsC4AgMe5FUgtFicOvB/h4M3+giWF3dnPCJPGkkOHoZYrUOHhYfl1NqD03HmJtUSZszN09fXSg65/T/qXHtRqW49zKySTcsPPva6pWfjcZUoV3toXLIT0mvsemrU6oa1V1x538J12nE+9P8WRj4kgfHjsO4kgdEkwsULYkjg34Noi8htPD8KKYyTs9EEBEf/8xGuQ8yB8H/B9t/xP1ZCEZwlCniUPx3EdniSublExVKZUCb6Uj/T+V6aOedsgbNRQ5PHwIa4My8BV7Yp5ZyKMVqf5ceAzfBLUcgVuDZ0A2UpvzDsTgWNBpJCN8/1M0x3X1EsFoGFxocYOipc7W4wrjL4gVDdVoz/bXzLe3r/+vr279cLAez2mlouWSBMvT8Rgl8F27BXFXvDh+XVNpn1PFzk/xIzDYd3u/y8HKggpFKux72hNVAFZ98jf596VCkK/VTY7DcdxwupC3/V+CE99ZrO2283BAYKxdIXndajlCuSvXNnpp214+hRqpr8wCc5d/pPpi/iF2aR/Ra17TvElqfntVoJYJj4uh4jFb9go9Fnvh/6OtzBw0228vsYXTc3mBYRTeAZ+dItFpomQ0q7mS78vceAzIggfHCW2FJPOKsCwDLZEbGlbY5nhWHz8NSHkUsfpMNp1NIZeGCoU0+juFNQUgGEZLPBdIOxThiox5+acDonCjTelq3+vrvbBUlfiIxqbTUJBfzOximjoNVpZZ/wZnnh0QhAUQTlBQvGapEJRrBneHFHLFVg+RwmZUoXZx+9h000SpupjomANAKAiR7xm1ZcT+xz+cUV2uz8PNDeS0OONfyTneAG5mXYTu6N2Y3Xoanzn/x38Mv3s3aUXBn5lXV2qFvaNdh2N0a6j7dgrir3gPWFNeTlzHCdcg2sbTQtGe+FABSGFYjX2Hq8ioXulgvD+MZs2z3GcULZ+7M5uUD750GDyPpsbURcTI0xGiw8eBKe1fTXDmtBQlJ53Qto0YrJe5nIB2ppa83f0Towz9oc0wbrrTyQT9PcOhQptukeRcLvdtxIxwaAK7PtHw2399jqN7wO+x64FRBCGH/kRDMtgiV7UfeH3Rdsay4nE1yd6E3N0n3kIzws3ElfdnYbmBlJl1XO6sI8PJetIsYmWJvOvr/EV8gr5YkW8zUTvNaK/qGG4crOJKIKTj04KgjChNEEoXnMnsUgIb07oJ94gOfz253hl5U0hh5UvShWZYVwwCQCQHytes4qeAqVp4uMCvffmnS3A9peA2AvWfRgcR0K1HXuR6rQUShfza/CvYFgGj0vEKI0hLkMw8fJE+3WKYjdm66+DBZXGURi8tY+55+2JAxWEFIrV2Hu8ihTGSwWh+mannGb09kC8ssp8LHyXwRccaaoFp9Oh5NgxJA0ZCrVcgfSZs1Af/8Rmp+I4TrICkv3tIsuhHXveIGG8utZXffj/KBLyK4V8wRR9LhcvFm/E5Ul8BR29Emz11jqdFUErsO1LIgiDD5G75nsP/hfDnQdhlOuotoXI5MVgwcneguk8b0BvyletOzPi4giMdB0pvPe3rrzVYX+yfQbCTqZU4Y21vvjVNQI+695GcgjJY+VXA/kQZJlSJVmhNgVvX8CwDOo0dZIqtj+4xgAAYsZMICGjHyzAq797Ga1CDt3ij+oGMyu4KQHiNSs1AMh9KD5ODyLFX/jH175r/UPQ6Uje4K5Xxdck97zKfpSeD+8DGVNExoiO04FhGUzxmGLnnlHsAe8Ty0ftcByHzGe10Ok4IRJIphQrQncXHKggpFCsxt7jVYTjgD2vixMhPpTUxkw/TEIfSmvsXKTh2CjyPhvEC2hTVhZS35kiCLei7dttcqqmzEyJIGwuMV2eX0CnI2Jwr9zCYRz6rPdDvw23oNNx2HNLXzDmfqaQt8mH531/MVp47Bmba5P31RWsCVsDx2+J7cTdAz+BYRkcPfAy5l19r+0iqPAJPjv5uiQv6iOvjzqv853EfJ/5YFgGKeUpAEhuEcMySHjWfqFvaDovUxJbiUsnt0rsFfiKtYaeo3cTixGVWYZ7aabDwPdE7QHDMriZRm4wtSxeU9PYjJiRY5Eg74NzoelGYnD+2QdILa4x2TYA4NElsY8xLkCKv/TG1vn3xL9bW+2LcwW2/Qdwfl/6+sZWzk2hdBLrwtdJcp35yIAZnjPs3DOKPWgZah+e+gwypQo/XYqFl4HXsNlICjvhQAUhhWI19h6vUppqgavfkKp6nTQRWqgvamKqImGXcnysmHdkgK6xUSLeNIWFRi9tTEtD/aNHVp+q1Em0lqiLiTF90INTxDJB20xynxx7kbDRVsh4VguZUoU5J4h4D0sh/0l8fzEayquPIVOqMGJbALQ6TlIhMr2k50xyN9/fjLWLiSAM2EsE4Zn9L2FN4HLJhMkqSpIw59QbEkF4Jv5M53W+kzgad5QU1XnqAgAY4zYGDMvgXn77b+KcDpGKsX4bbuHaSUeJIOTH7ozDotWMuqD1O9JbI7ZK7ApaFqZRPS5A3JDhiO3bHzfi8oT9lyKzEZ9rRQjsvSNiH68vBR67m7YacewFOM8CtBoSOlrXYuLkucT4eLfP2vNRUigdZtP9TWBYBmF5YQCAysbKHnsDi9JxWhb4OheWIVwrDdNB/J8W2bmnUhyoIKRQrMbe47XL4W0qzK0odBknx5vN0ctfqRRXCXfvFvY3l5ejaNdu4bnqoCDhOU6jkYQvaisr0VxaCk1xMZJHj4Fa0QcNSUmm+5IdIU5CH18hdhiOvQCXD1p9C96PyZ3BDTdIeGtdUzN6r/HB4M3+GLY1AK+u9kFFHUlC51eA+juS1cSewu6o3fj9ByIIb+/4AQzLgD30KvZ7/orBZ/ohJLcNXomlafjgtFQQZld1oPCInXhY+BAMy+CHwB8AkBBShmXgl9H+oh+G/pP87+TaqU0SQciHJBsWkuF/X4ZUNlbCN8MXu6N2C5/z/fz7AIytK350i0U8MxAR/YfAN74AS11jwGy4ZbaankBpGlDwWLRncexFCsDwK//85r0CuLtNtNV5eJ78fWiQ1JbC5UOyf/vLwI6XgeoiIh4pFDuw/cF2MCyDu9l3AQAldSVC7jPlxYPP3+ZXAHf4JhpFU8iUKlyN7l7RPw5UEFIoVmPv8drl8ObW3o+J4W50VjlCUyyEUHYGp94kE8CaYqOnuKYmNKalIZHpj6Shw6CtqUFdTKyQY8hvySNGIue7xUibPl3Yl/X5fDw7eYqIQINj89euNd+XGGdxArvpz+Lfca6tvoVdfuQ/hctRoqjhi3DIlCq8a+Adyfu5zT/bdV6LtuBw7GGsWE4Eod+mRWCc+uHOyjlQyxXwH6NAYJLp3DWTVGRj+hk5GJbBr8G/Ym1YK99JN0aj1WD4xeEYcXEENDoNhrgMAcMyuJx4ud1tXoqUVqsdtOk2PE9vFn6LZbVNkClVmLQ3SKhI+sZaX5M5nJ/7fC4R3QzLILY4FgCw3UcsXvPaah8w6/2glisQMmgkAp4WQaez0k/r6EgiAHf3Fq0hNv1FKgaP6SsyNlbrH48CLs4Vnzc0lucjBqrygdpuUAWZ8kLDh1r7Z/kDAFLLU8GwDL669ZWde0axB3zEDz9X+sWdhN5v9n6KV1aJ1+1zYRl27qkUByoIKS8I/3JwcLjp4OBQ4EB+9IPa0Ya9x2uXczwoDTKlCk7h5MLFX8g4jsP12DyM2h7YNauHZ97STwDNlLMHkL9mjVFJ/HzlKmgKCpCz9Aej50xtyWPHoWDjRmhrWrFwCN4lnchenAM0G6+8tOQLfV4BbxwOSE3qV7jHCftTi2vQe40PXB/0rBWxM/Fn8MMvRBD6rlkoFJjhtzuXd1tuhKeqAFPPEMsKi6JDp+u4sXknsiRgiSC0BjgPAMMyOP34dLvbuxaTKxGEQzb7w/OMmEN4N6mY/KYux2Gn/kbExN13jdrhOA4jLo7A8IvDsSJohaTCKCAtXvMN+xC9fyOWL/5DxyM4uQ03hna8LI6XXf8j31dGCLDjv8DpyUDECTEcXKclx+3rQ1YA+ddlhont7X4N2PzXbv2dU14cDkQfAMMycE5whjJUKXhCLgtcZu+uUezAhhtPJCGhvJ9wSlE1YrLLhRXDUdsDMXH3XXzDRtm5xwQHKggpLwj/cHBwWOrg4DDCgQpCq+EToKcdDIXGwAT9QkQW/qe/03UwIKXzO3J2it6rzHxRksaUFCOBp6vVV/nS6dCQlIyGpCQ0JCWhJjgYdVFRqL1/H0W7d6PSywvN5eXgLFQJBQDc/MlADM4FNA2tHp5TVodrMbkYstkfr632Ecr3A2KyuUypwqmQNMnrrF596UZceHoBi3/XC8IVHyO+jwIJgwYg7LNpRBAeaYNfZm0pJp9VYJATY/lYj6+Bw0NITqee5vJyVAcGgmu2v9cTm8CSAjv6fEKGZbAnak+721M9LpAIwmFbA3D97Dbhd7nfPxkyJTGIPxiQAplShU9O3Tdqp6qpCgzL4IMbH+BK8hWhb7zB9pE7KcI53CKz0W/FFajlCngPn4x71vqTchwpurTt38D+flLjeE2D6cq8W/9pnCPI21A0N5LH+/u19WOjUDoFw3HNsAwGOA/AypCVeFraui8t5flkmz6ygo+smnogBDKl6P3q90R6/e67vnt4hjpQQUh5AaGC0Eoam7X48Fg4ZEqVUWVDftvuq7bcUEfhqw8aho2ZoGD9BiT2H0DsIr6zULa+vbh+QvqSF2PVCsWkPUHCZzXvTITkuQaNFrOP38PQLf5ILbZz4R4b4JHsga9W64vKfDQRarkCjz9+H6r9PxFB6LjY+sYaKjH+XB8MsyQINfVi+GGNuGqVv3atcGOgYN06aCsqWm2mKTcXeStWoDE11fo+WklSWRIYlsFnqs+ESeO68HXtbs//aZFkDI7YFoAb53YK4unLcxFCUYOTwWSV/+fLcUbtpJSngGEZLA5YDL8MP6FvOVXkxovhmE/Ir8Tg5a5QyxW4NmoqojKtrJCnqSf9OjzU+hW93a+JQvDgAPHvRB+yIu/YCzg9ydqPi0LpVE49PiURhOMutV5gjPJ8w0dW8DmCgzf74/U1Ysh+eW0TPj55H0svxgi2QKZ8YbsaByoIKS8gVBC2gYT8SiFPyXASylfLWnfddh6AZmFnkElgaZrlYwE0l5ZCV99O09diNXB0BJATafr5kxPM5jO2hOM4yWd25WH7ved6At7p3liwjgjCyBHEwDxl1S+4eWEj1HIFgpZ9Yn1jTXUYfa4vRlsShFn3RMFQli7sTh412mjFOPOzeaj08gLXZBzimzH7I6jlCqS9N93ouY6i43SYcHmCZNK4/M7ydrcXklwi+V2N3h6IG+fFUOa49YPx+hpfNDZrhQI0O/0SjdoJzQ0FwzJwvOeIsLwwoW9FtSTUiV9plClVaGrWYeyPzlDLFXAbO13w2LJITQmnxsHLAAAgAElEQVTp16mJ1r9BQxEYtNN4tdCxFxDZ/pBbCsWWnH9yXjK2J1+ZbO8uUewIfyPN9UE2CisbjGoEGDLtILH2Kq+1nHbS2ThQQUh5Dvj/HRwc/m8r2//X4nhrBeFG/bHC9qLyrv6iZbit18fJG+a+dRq839izLghPdftUnHRq6gG1txjWptUAW/9Fwt+sCC/N1FtNyJQqLLkQDW0PqhjaHgKzAvHRln4SEVZ89gy8/Y5ALVcg7LNp1jem1WDY+b4Yf54heWUpAUSkB26W2qyE7kXjz39G7fd/JZUs9aS+/Q7UcgVqgoNRsH4DkkaMFPqUOmUKqvxJAQhdUxOq/PwkfW5MT2/Zmw7zW/BvkknjF35ftLutiPRSyVgcu/MOvJx2SwTT+0fDAQDJRdWYcTgM0VnlRu14JHuAYRkcf3QcccVxQt8qG0meK59/KFOSYkDfbbwMtVyBG9PaIOzL0kmfnNogtI+P0ecbvkpuvOyUkXxD/v2FH7S+LQqlk3F56iIZ29OuteE6R3nuOKP3aD0XliGEh666Fm/y2E9O3YdMqUJWqZU32DoRByoIKc8BKocWwq3F9kqL4+kKYRsxFS7KX+gWu0R3fgcuzCYTwWLjVQ6bc22R1BzbsRcpfw8AOVHk8YXZVjXFVxbd6ZfY4/IB20N4Xjje3SMVhHWxsVDFXIJarkD8AAbNJVYWI+E4DHLqh8nn+wFPb0hXh5ymE5EIgLvwEVKH9EZiHzm0TwPJPq0W6n4MkseJoVucTofaiAhkf7tI6FvJkaMSoZgybrwgGLO+/BL18ab/E28Ph2IOSSaNH9xo3aakNWKyyyVjcfyuu/Bm90g+I0cvy8b3fG7jRfVFpFWkCX2rbyar61u8n0oEYUHEQ/L5fN+GYhkFj/U+gZ9a/xo+Z9jja/KYLxqUcJ2MxRdgLFF6DpcSL9lsbFN6Pm76KtCHAlOEAjKG1cUN+c7lIWRKlXU+rp2MAxWElBcQKgjbSIbBShe/pRRVd501Ai/McrtAfLovNB2idnsdsK8v+TvsgMVmqho0YDbcQu81PiiobGf4ag8jpigG446KgtDvveEAAP8sf1yYTiqOljk7W9WWjtOBYRlMPddP9KaTGJe/D4QfRP2PfxHF5/XjKNq5C8ljx5EQ0U9Mi5Byd3eJaM1a+AXK3d3RmJoKdT9GrDo7clTrFWfbwIWnF2wWVsaHcfPbm3uC4O28T/L5uNzPtNjOmfgzYFgG7knuKKotEvqm1YttPgqAF4Q1wcGkeu+aNeYbLVYDV78Rq4byIb1Xv7X+DfI+g3whGQqlG3M1+apkbH/s/bG9u0SxIwH6HO+11+OFFcDEwiqTx/52hVhShFtbpKsTcaCCkPICwYeQwoFUG/2/Dg4O/6cNr7f3eLUr7x2Sho0WVNZDplRh9vF7nX/y22vJBPGRBe+2xmqyEqH2bv+5+NUJc5vHV0CTZZFwLIisqq70eGzx2OeFp6VPMfisKAjdv5gAAAjJDcGilSS3sGiXddYTTdomMCyD6Wf7Siu7eq+Q2BgUf/gfA6/JYcLfScOGmxWfnFaL/FWrkTJhIp4dPy5ZvdVWVBCrkh+IVUnx3r02Wd31zfCVTBqHXRjW7rZSi6slY3HS3iCoLuyX/E7dI7MstnP80XEwLAPPFE/UaeqEvvHsM8ghBIBnJ08RUc+y5hvd+i/SB5/fyOPk2/rv7Wfr3+C9I6RqLPUYpPQAvNK8JGN7vs98e3eJYkficyv1Vj1R6LveD33W+5lNF9msj8LwiTdvqdVVOFBBSHmBMBVO+mZbXv8iw97LlExCK+s1kClVmHogpPNPHntBNLRuDfVNcVJcXdi+cxkWtDg0iHgfnp9G8pmsFJo6HYdhWwPwyioV0kpqLL/gOSG9Mh0MK66wsT9OAQBEFEQIuYV5K36xqi1eoHxwpo9oUF6oD+E0MCxPH/GaZLUvafAQNGVZFkOWaMrMFCvWfvU1msuNc/C0lZWovnsXusZGi+09KHhgZADfqLX8OlNkl9ZJxuLb+4Lhc/GgRBB6RSVZbIcPY72ZdhMcxxkJwuoGDVZ7xiMhn4Qz5f70M9RyBWojzRRcAsQ+XP+ePH5yVVxhp1CeQ1re7Fnou9DeXaLYkeIqUkjm1dU+kClVWHjO/PWStwW6FGl/z2EHKggpFKux93i1KxzHCf46s46GC76E43cZG17bHD5379K81o+7d1ickEYcb/t5tBpgy9+Bbf8BAhyBfH3BHI6zqogMDx/SN/eksffb80xBTYFEEJ5eOwsAEFcch0kH+wn5eRkfzkbp2bOttlXZWAmGZTDntFwoMqItyERNaBi4jDCUz/8n0ob1NqokWnLosM3eT3VAAFLfepv0e9JkNKamQltTi0pvFQo2bkTau8RfMXnMWBTv24+aUNOV5ADR4sFwK6lrg7m7AUX6CQe/TT0QAt8WgtA/8pHFdvZF7wPDMvDLJD5Y833m45vb35g9Pn3GDKjlCvMWHhwn9uGmvopq6F7yOHhXm98nhdIT8M/yp4KQIqDVcYJP86urfYQbaqY4H55h0ofYHjhQQUihWI29x6vdadbqcPNRvlAi+fW1vhi6xb/zT9xQKXqZAUDuQ6DexKTUe4W08Ehb0DYDD8+JhvMd4FwYucjv80/uUDs9jfKGcokgPLXpIwAklHTgOWmxmfQZM1pt61n9M+Ldd+oNUmFyyz+Qv3o11HIFcpZ8L2krZ95MUhRmxOCOGdGnBgB3twN1oseerq4Oeb/8aiQ8DVck1X36Co9rwsJNNl3WUGYkCHkD+LZSXtskEYTvHgzFbVdpyGjoA8u5vTsjd4JhGQRm6YvxcFyr4bHJI0YicdBg88fEuIh9cPuUVAjlH98/1q73SqF0d4JygiTjeoHvAnt3iWJnhm8NgEypwhbvp60edzU6FzKlCntuWY7o6GwcqCCkUKzG3uO12zFo0230We/XNSfbKycTyytfmBZ8HCf6FTr2Avb1sb7tsnSxfcdepJphB+Arh91Le7FyoOqb66UrhNuIPUF6BQkljRw5kDzXpy/UTH9wGo3ZtgprC8nk6mRv8p2cGIvUyW8ZCbKUCROhuXsOdT/8BTqvlR17A4eHkHOdeUuoYgoQoZS7bJlwzvyVK5E27T2oFX1QfecumnJykP3Nt0ScfrfYZNNandZIEMYUxbSrm3VNzRJBOP1wKAJcpUVlIu9bXrnfErEFDMsgJNdy2LeuqYmslL79jvmDzk+TGsqzM8XHXWEZQ6HYgfC8cCoIKRI23HiCWUfDUdvY+g1KvgDN+htd4OdsAQcqCCkUq7H3eO12jNlxBzKlCrqu8NcznFzyW8gewFdJ/Omufkv2bX8Z2PU/YOMfSQioTgdUF4ntqL2By/NJbiAANDcCZ9/Rm2e/CTx271BZe52Ow6BNt/H6Gl80aLSWX/AcwVcGdZpJKopuu0EKieRW54JhGXyyqS/KfLyRtfALqOUK1CeYt0bIqcoBwzL4+kRvaFf/AWnjBhPj+KnvIm/FLyQ89OhRYjKfEiANU2wPhuGOjr2A8EOSpzVFRcj64ktU3boNgOQPNqanAbWlAIDm8nKy8vnBh2ZP0VIQ3s1uX7h1sz5cm99mHQnDXTep7cSjcF+L7TjecwTDMriXb7kwlKaggFRu/fQz8wftehXY9Gfp53hwADGnp1CeUyILIqkgpLSLyIwyyJQq/HQp1t5doYKQQmkD9h6v3Y5pesP6AwHJne+z5/Nb69U/HXsRW4jsCLFSaLFaX8L+D0B+rFgC37EXcGsNEYtXvxH35XXc1iKpkFSAnHOiC6qvdkOGXRiG/k79MPJEPzjecwQAlNSVCJMlt0Q3FO3eLYgnPsRTW1MLbY1YgCf1vh9Chylw8IfeKJv3T2F1rvTsOQCArr5e/M0VJZDv7/Qk8jhkN3B0BNkXuNm6jtc+I8dv/qt++5vlVa3AzcCmvwA5UcT7sE9fpEx80+zhLQXh9dT2r0TzOSoypQrvHw1HiNsuyVhQh16z2MaasDVgWAZRhVEWj61//BhquQK5y340fUBdGTn30ZHk83dfAMQ4Aw2my61TKM8LscWxVBBS2kViYRVkShW+crJ8De5sHKggpFCsxt7jtdvBF5mRKVV4lGOm0IStiDojTnhTA4HsB2Q1kN93/j0x94sXeTtlBisVA8mqoaGA3PZv8e8d/5WECbYX5/uZ3SYnwB6MuzROmBhtidgCAKhqqhL27YzcCW1lJTI+mgO1XIGKq1fBcRxSxk9A8pixJI9NoxEEYPD4N1A06yWo5QpUeqtMn5TjSEVYx15AtJPxjYIHJ4G8mNZXfvPjyLGunwDBu8nfKgsVUfn2T4wFACSPGo3EAQPNHt5SEDonWOfJaArFOj9h7M0+fg9hrjsk7zkt+KLFNn4P+R0MyyCuOM7sMZxWi/y1a5H52Tyo5QoUbjIjsDPDybkv05L7lBeL5PJkKggp7SK/ol64jt+Iy0NVg/k0is7GgQpCCsVq7DZQuyvqgirhYnY1OrdzT5YRKk54y9LJvuYmwOUDcTWQ584W8dgjw8S/d/2PVB/lJ/yb/0ZyETPDrfIWtIalrjGQKVUIS3mx8gd53vZ4WyL+AJKDN8ZtDBiWwYHoAwCAmtAwYkPxy6/Q5OcLAlBTWIgKz+vCY/+330DuWzISYvq4FU/HO1ulIvDad6ZXkR+eI8KQ44CqfPH1vGWJ9wpyY2HzX0n4Y/YDEl6cHysVlDmR0nZ9VyJtLMmR1NXXm+xiS0F4OLb9FVEHbLwtjL05J+7hntt2SX9y7py22MaKoBVgWAYJz8yH7tY/SZDkbJqtDhuwUV885mh73xKF0iPh852pIKS0lZpGaT54oLrI8os6CQcqCCkUq7HbQO3O8AbsnV5R07BiYXOTuL+xGijPbHFsCckvLNCX3o88TcyuGw08AcuzSP6gjeHDaEtrbN92T2CG5wxhYrQvep+wPzgnWLJqqK2uhlrRB8mjxwgm8Gq5AjXBwcj+dpHwOGzsG0gfLYdarkBzWZm50wIlSeLvw+Mrsq+5CYj3ANwXSsXb5r9JH7MzgAOMtBqm4U0FfuO99KoKgN29jZ7PHPs/Imrz8012kf9cBjgPkHwW7YGvYidTqvDpqQhEuEkFcbHvDottLAtcBoZlkFRmfjW7ysdHqOxa7uYGbXW16QOPDNffrMlo71uiUHokvGcqFYSUtsJxnHAdV6zzs2vdAQcqCCkUq7HbQO3O3E8rhUypwvLOTormODIJPzykc8/TQQZtuo031vp2fk5lN2XuzbnCxOhQjFiYJbooGgzLYGWIWAk048PZxlVD35wEdZ++eDp8GNRyBeIGyJHYrw+Shgy1/JnGexDbiIYWvk9VBcRbcuu/gFMTge0vmV49PPO2eNOgWC3u3/mK+Pe5qWLhFHYmWU3UhyLnTJa1WiyH/1xGXBwBhmXwe8jv7fiECWN33hEmEp+feYAot82S91J52XS1U0MWBywGwzJIr0g3e8yzEyehlitQdtFMCCrHkRsvjr2IXySF8oLBcZxEEM73oWHTFOvhr+OLnB/atR8OVBBSKFZj18HaXSmsJCbZE3bfhbZFtVGNVoeSahuulDU3SlcHuxn1TVrIlCq8uSfI3l2xGwt9FwoTo+OPjgv7k8qSwLAMlgYuFfZp8vNRqVKhOiAA5ZfdRWHI9MfDS0cQMVgUigXr1nesY7XPAI0+lJPPd+O33IckBNQwh7SpVnw+bD8pQiQIRBlwey1ZnQaE5wqmvQy1XIFnJ06a7AL/uUy4PAEMy2Cxv2XRZo51158IE4mF5yIR7bZR8p4aTrViD6Hnm1vfgGEZ5FTlmD0mf80asnIbGmr6AD782rEXcHdbe98OhdKjoYKQ0l7467hbZLZd++FABSGFYjV2Hazdmbkn70OmVME3vkCyf+nFGLy+1hfF1Q126lnXkl5SA5lShc9OR9i7K3bjO//vhInRmfgzwv78mnwwLIOFvgvNvjZ/pRLJI0ai9v593Mm+g9tj9YKwb1805ebZrpPaZuDiHOJpWdJK8R9e6Ki9geJEYMs/AO+fRWHJ09wEPDiJ6m//BrVcgcSBg6ApLjZqbrDLYDAsg3evvguGZTD35twOvQ1+IvG1UxRi3RwlglC761WLr+fFe2FtocnnOY0GKZMmkTDYPBOfv6ZBKqzzzRenoVCeZwwF4fYH2+3dHUoPYtbRcMiUKhRX2Xee5EAFIYViNXYdrN2Z4OQSwSCbD+t7nFshTFijMlvJ/XqO8HqUD5lShV/cH9m7K3Zj+Z3lwsSITWCF/Xyl0Q+9zPv0cTqdYEPhleaFq2/rjeBX/NDp/TYJL3SKE8ljbesmwzjQX6iIWrDB0ejpUa6jhM9goPNATL4yuUPd48fXt84P8dhtvXEIbH3rlX8/U30GhmXwrN50AaQqX1+o5QpkL1pkuoGcKGnF3hc0TJpC4a95c2/ORZ2mzt7dofQgKus1yK8wXYisK3GggpBCsRp7j9duC8dxmH6YFFMJTiYm1F87RQkT1lsJplcgniciM8oEKwDvx6aLirwIrAxZKUyOLqrFvDOtTguGZfC2x9tWtXNRfRFbvuqDx0MGoCnbTqE0JUlAohmrC1McHwPtqj8giXmDVOQ8dx66RjFkmg8VnXl9Jia5T8Ig50HQcbp2d48fX0suRCPeba2xILTgq8nne1Y2Vpp8PmfJ91DLFai+e9d0A/Ee5DwXPiJFmiiUFxT+mueqdrV3VyiUduFABSGFYjX2Hq/dGn51bPmlWMnqIL99cur+c1topalZh0GbiA3AyeA0e3fHrjjecxQmR+5J7pLnRrqOxGCXwVgTtsaiGfqJRyfAsAw81Jc7s7u2Re9r+ezjfwu5jznfizmTU69OBcMymOE5A3NuzgHDMqhoaL9/Jz+2fnCNwVPX1caC8FHrn90HNz4AwzImVzQ4nQ6Jg4cgafAQcBoz3lihe8l5Ii1bXFAozzMfen0IhmUQUxRj765QKO3CgQpCCsVq7D1euzW1jc14fY0vGMdb+PRUhBBCaigKH+d2snm9neAL68w8EmbvrtidHZE7BEHomeIpee4jr4+E56Z4TEF+jfmV1D1Re8CwDG5l3ursLtuOfX0Ax17QreuF4o+JVUbS4CHgdGQVMKEgCrMvT0JC/gOhwmdqeWq7T0fGlTeWX4pFoqtSEIIVG/5F/r6z1fQLm+oAjsN0z+lgWAYarbHga8rOhlquQOannxm/vjyLWLvcXE7Ok9yDviMKpROobqrGo5IXN1WA0vNxoIKQQrEae4/Xbs/nZx4I4m/crjvwjM2VCEJHL/MG2D2Z5KJqodrji86B6AOC6LuZdlPy3LP6Z/DN8JUUYDDHhnsbwLAM7uXd6+wu2478WODaIsBpOvElnPU21HIFGtP1tg6ei4mA8lyCtWFrwbAMIgraX4Do+NrPod3wB6xzDUKS6++CIIxeP5T8feVL6Qu0zcCDU+S5BycxxWMKGJYRV+7dFwJXvwEAVPn7k1xIR0dpGzUlxL5j81+NcywpFAqF0iNxoIKQQrEae4/Xbs+eW0mC+IvNLkd46jOJIByy2R8abftzprorDzPLIFOqsMytk70YewB8qCfDMvDL8DN6vqWJs7kKlyuCVoBhGTwuedzZXbY92Q8Ax14omke8FCu99XmIexVEQB3oj/3R+8GwDLzTvdt/Hr0gcz+9HSmuv4qP184kf58YKz3+7nZJSOlk98kY5DyIPKdtFp/jOOQu/wlquQLll6Vhv4h2koalnhgH6J6/MU2hUCgvEg5UEFIoVmPv8drtuRGXJ4g/AHiSVyk85q0p7iYal+Pv6dxJLIJMqcLa6/H27ordYRNYQewFZgUaPa/jdBJB6J/lb7KdRbcXgWEZZFRmdHaXbQ/HAfsZlM37J/ElPKXPsdvdm4iow0Pg8tTFqBJrm9GLMs/Tm5F68Wfh8dG184HtLwFb/ymt/Lnjv6KQ2/pPjL80HsNdhgDRLFBVIDxXc/c21HIFUt6cBF1di/xC9wXkuNiLxJ+xMrf9/adQKBRKt8CBCkIKxWrsPV67PbWNzZh3JgKXo0hVyKoGDWRKFT44Fi4UnfnxOVxF40Njd/nR0LnLiZcFsRecE2zyGENBuD58vcliQ594f9KqJUK3J5pF9Td/h1quQOGmzWTfzleImDo6Qgid/SXoF2h12vadQy/gvE9vQKrLj8LjI2sXAKcmksdVBnmaR0eIgnBfX4xyHYXRTozeVH47tKv+gLwp/4W6T1+o5QpU3bptfM6jI8nxdS+GlQyFQqG8CDhQQUihWI29x2uPpLJOgwaNFvVNWvTbcAvydb6objBTtbCHwt7LpBVG9dxIvSGIPXP5f4aCkGEZDHIZhKlXpyKpLAl3su8IhukDnAegUdtoso2eQP2W8aTS6DcLyI7tLxExdXwsogqjhPd/7sm59p1AL+78Tq1Bmssy4fGhtQsBlw/J45Ik8fiz74iC8NhoDL0wFF9t7ouqr/4OzvGPKJj+slAdNWvBQlGoVxcBzU1ATiR5rRWm9xQKhULpOThQQUihWI29x2uPZ/mlWMiUKgQlPV9ho4cDUyBTquAWaSe/vG7ErcxbgtAxZy1hKAZnXZ+FsZfGGonEgc4DcSb+TBf33rY0X18PtVyBjHcnkh1b/0kE1cnxSK9IF97rYJfB7TuBXtwFnFqJNPZ74fHBtV8AF+eSx0VPxeOPDBMF4cEBGOg8EHfGEAFY/MF/kPu2TBCEZRcuAhkhgOcSYOOfpK/dKevgJ0OhUCiU7oQDFYQUitXYe7z2eI7eTYVMqYJTeA/MC2uFLd5PIVOqoHpcYO+u2J2Q3BBB6MQWmw4P5p//Pfh3AEBZQ5mwb4bnDITkhrQ/jLIbwal9oFbIkTx0ANmx6S9EUJ2ehMrGSuE9T3Kf1L4T6AVa0MkVSHP6TioI3T4ljwsMivLslBFRuu3faNjxMhiWQeRghSACE/u+IfzdEBcJbPuPsbdha3YWFAqFQumROFBBSKFYjb3Ha4/HJ75AYj+h0/V8o/rKeo1gSh+W0kPz3WxIXk2eIHSePHti8hj++ZUhK4V9rmpX7IzcibKG5yg3rSof6SNfIwJLrQYc/0AE1dkp4DhO+BymXZvWvvb1Ai3sxI9IO/eNgSD8Erg0jzzO14tyrUZf4ZQB9vVF6M5/kCqu/eRI7KdA8tAhghgsnPkSuM3/IMdfng9U5AC+ep/DiBPSQjUUCoVC6fE4UEFIoViNvcdrj+dpfpXg1/esphHDtgZgm4/a3t1qN1UNGnxyilRPnX44FA2anr+qZQt4oRNfYrrqKv/8qtBVXdyzLobjUPqFXmT9Igo2nHkLAOCX6QeGZTDswjCThXUsom/v/oklSDv7tfDYydOHeAo69gJyH5Jj86LJY6fpwPGx2HXov+h/vh/UcgVSh/dFQ1IykseMQfpovTXG9pf+X3t3HudUeff//2OXu8u3N13uu717/+rdaLcEOIC4Ufel1l3riq1aq+JWrUutNiwqiKCiKCqCuwZEEFTcwo6AIIvIpkJYBNlk33cYmHn//rgmyWQmGQ7jzJxJ8no+HnkwSc7JfPJ5cE3yTs65Lum11m720aQdGwiDAFCAjEAI+Bb0eM17O/bsVSga14mPjFGfSW4ilvN6Tgi6rBpZuXmnzujxoULRuM56YnzBTZTzdUxdNVWPffKYSsuyr0+XDITtxrer58rq394pg9xho81/p7J7GmnXbT/R9nZHSaX7pBn9dMmgP8qLeVqz4wDPq53YMxUAp/a+Tote+JvUsZHatLvf3f/GNe7+pVOkdV+4INixkTSpl/TKOYo+faiOetYFwkXHN5MklW7frtK1i93kMawtCABFwwiEgG9Bj9eCcHTXUfpVuyG6uPdEhaJxtepada26hu6dmV/Ju2+4QtG4rnxxCmHwACUDYfsJ7YMupV4su+wMt4zDtT9LHZa5b3R3qWMjde71O3kxT0MWDTmwB33cSwXC6b2u1qLnr5Q6NtKf23Vz9791vbv/oyek+3/ifn7ck7avk16/Qv/o9Sud+JQLhIv/cHjtP2kAQN4wAiHgW9DjtSC0Ll+gPnn5dbsh1Z5LWKND6erYn5+brFA0rhv7TlPJPr5JOVDJQNhlcnFMTrJ11CglwhEtPelXqUC4s9PvpY6NNLLb/6TWYzwgyTUNOzbSp09fri+fc+cMXtr2UXf/4JtSy0uoYyNpyN3SnvJF5t+5RVc/8xud0d0FwqXntKrdJwwAyCtGIAR8C3q8FoTom59mBMJQNK5127KvNTdm3hqFonF9MHd1PVdZvVO7j1UoGtf23XuDLiUvTV01VdeNuC5/F50/QGUlJZp/zLGpMJgIR7TpKjdpy+b7f6RmsWY67Y3TDuzDjwd+lgqEc3q21pfPullFL2r7mLv/nVsyZwbduDi974h7dOlzv9OfHnSBcPklJ9Tq8wUA5BcjEAK+BT1eC0Lf8nMHQ9G4Du88UqFoXHNWbMm67XEPf6BQNK4jHhhZz1VWz7tvuJreNzzoMpBHVnV+ICMQrrng4FRYu+ydC+TFPC3evNjfg+3bmxH25j11kRY/01rq2EgXtn3cbfPebeltHmucORnM+O4664Ww/typiRLhiFZceVqtP18AQP4wAiHgW9DjtSDs3rtPF/b6SGf0+FD/fsN9W3jP29mXJzjtsXEKReMNKnwlJ8Y5pfvYoEtBHtkybFhGIFx22dlS/79IHRupx4ft5MU8DZg7wN+D7dqcEQi/ePJ8lfR35xCOGll+LmL8zvQ2E3pk7v/JSzrxpca6oZ0LhKtuOK92nywAIK8YgRDwLejxWjBKS8tUVlam2Ss2KxSN68guo7Jud17PCQpF4/pVuwOccKMOLV63XaFoXJc9NynoUpBHSlatygiEX/zx9NR5fpOnPycv5um2D27z92BbVmQEwi+fOKvquoND7k5vM29Y5v6fv6XDX26qu+9s7L6tvKN17T5ZAEBeMQIh4FvQ44Vz+54AACAASURBVLUgNe80Qk3uHZb1vj8+Pi51eGlDWcT+4y83KBSN67YBM4IuBXlmbc+ntbF/fy045RQlIo1V+q4Lbds+HyQv5un8t8/390DrFmQEwqU9Tkt926iVn7pthrVNb7Mg8wOXPQtGuEl9bgkrEY5oXYdravmZAgDyiREIAd+CHq8F6ZgHR+uQttkDX/NOI1KBcMWmnQFUV9WI2asUisbV8d3ZQZeCPLX0uuuVCEe0q68LhHunxeTFPJ355pn+HmDFjIxA+NXjJ7tF5Ds2klaVH349okN6m0VjM3bfuPhDeTFPT1z/OyXCEW145K5afX4AgPxiBELAt6DHa0H6Q/l5gjv2ZM7Y+dnyzRkzkU5c2DBmpBw8Y7lC0bgeGT436FKQp1Y/9LAS4Yg297jdBbaJPdW8T3OdOuhUfw+weEJGIFz12HHSqxe762sSbpuR96W3WTwhY/dlyyfLi3l6/urfuhlPn+9ey88QAJBPjEAI+Bb0eC1I55efJ7h2a3rpibKystR6hUd1GaVQNK7XpiwNsMq0vpOXKBSNq9fYL4IuBXlq46BB7ty9tuWLx4/urCNfPVInDPC5/MP84RmBcE33VlLfC9z1tfPdNqM7p7dZOiVj97krpsqLeep3uQuEmwf1q+VnCADIJ0YgBHwLerwWpOQi70vWb5ck3dxvun7TfohC0bhOe2yc3pzmvpHrOiQRcKXOM+MWKhSNq8+kxUGXgjy1Y/oMt/7f1eWHeb59s46JtVCrPi39PcDnb2YEwvWPHC7FznPX1y9024zpmt5m+bSM3T9Z6QLhW61/o0Q4oq0jGtayLgCA+mUEQsC3oMdrQWoTm5pai3D1ll0Zh4l+MHe1Ppy/VqFoXNE3Pw26VElS9xHzFIrG9ea05UGXgjy1b9t2Jbxmmn/UkSq7t5H00P/ppBcbq+Urnr8HmN4nIxBu6tZceuUcd33DIrfNuG7pbVbOyth93LJx8mKehlzoAuG28ROy/BIAQLEwAiHgW9DjtSDd2n+GQtG4hn2+KiMMhqJxlewr1cSF6xSKxnXnwFn7f7B60Om92al6gZpaesMNSoQj2n7jf0sdG+m0FyPyYp7KynzMpju5d0Yg3PJwE+nls9z1jUvcNh8+mt5m9ZyM3eOL4vJinkaf5wLhjqlT6+AZAgDyhREIAd+CHq8Fqe1bbnH633YYWiUQStLUxQ1rmYe735ilUDSuCQsaxiQ3yE8b+vVTIhzR2osOljo20tkvhOXFPJWU7N7/zh8+khEItz/4W+nF0931zeXfXE/okd4meV5huYHzBsqLeRp/pguEOz/7vA6eIQAgXxiBEPAt6PFakDq/PycVAE98ZIzOfWpCRiCcvnSjQtG4bn5tesCVOjf3m65QNK4ZSzcGXQry2M7Zs5UIR7T0lLDUsZEueP538mKetm/5av87j+qYEQh3dj1EeuEP7vqWlW6biU+lt0keRlrupc9fkhfzNOW0XysRjmj3ggW1/vwAAPnDCISAb0GP14KUPCcvGbLaxD7JCITJ5Sdu6PtJwJU6V730sULRuBas3hp0KchjZXv3am7zFprXvLHUsZEufaGxvJinjSt9HBo95K6MQLj7gV9Iz53krm9b47aZ1Cu9zabMGXqfnP6kvJinaSe7QLhn2bJaf34AgPxhBELAt6DHa0FKHoKZDIBPjV6gUDSui3pPlCTNWbFFoWhcbWIN4zyni3tPVCga14pNO4MuBXlu4VlnKxGOaN9HL+qKPkfLi3lavXDU/nd8++8ZgXBv559JPTx3fe8et82U59LbJL81LPfglAflxTzNOt4dMrp37do6eHYAgHxhBELAt6DHa0HqMWq+QtG4/vzcZEnS3n2l6jdliTZud29sF6zeqlA0rqte+jjIMlPO6PGhQtG4Nu8oCboU5Lmlba5TIhzRrnnzdU2/4+TFPJ32YkSa+kL1Ow78a0YgLO30Y6nzT6Vuv0pvM/WF9DbbMgNf+wnt5cU8fX76yS6QbuXbbgAoZkYgBHwLerwWpF0l+9R38hLt2LM36/2L1m5TKBrXFS9MyXp/fTvmwdE6pG1ce/eVBl0K8tzKe+516wCOHasbB5wqL+bJi3na3alR9Tu+elFGIExdeh+X3mbaK+nbd2ae73r7mNvlxTzN+YMLhGUlfLgBAMXMCISAb0GP16K0bMMOhaJxtX52UtClqGRfqQ5tG9fvHxwddCkoAOueeUaJcEQb+/fXPwadlQqE6zr/qPodXzojeyB89aL0NtP7pm/fnfkNYJsRbeTFPM09/jglmjStg2cGAMgnRiAEfAt6vBalFZt2ZpxTGKRkOL3kmeBrQf7b9PbbSoQjWvPY47r5vb+kAuGirj+rfsdnjsseCN+5Ob3NzP7p20t2Zez+5/f/7ALhUUdpXsvD6+CZAQDyiREIAd+CHq9Fac3WXQpF4zr/6Y+CLkUTF65TKBrXHa/PDLoUFIBtEz5SIhzRig4d1GZ4m1QgnPnoIdXv+ORh2QPh6M7pbT4dmL69dF/G7ucOPtcFwuYtNP/Y4wQAKG5GIAR8C3q8FqWN2/coFI3r7CfHB12KXp+6VKFoXN1HzAu6FBSAXYmEEuGIlt14k/469K+pQDj+4f+R9lVzXt+jv8seCD9+Pr3N52+mby8ry9j9lIGnqGWshRLhiL445dQ6enYAgHxhBELAt6DHa1HasqtEoWhcZ/T4MOhSdMULUxSKxjV89qqgS0EBKFm9RolwRF9e2lqXvX9ZKhDGH/m5NO4Rafv67Dt2/UX2QJh4L73N7LfTt1dQVlKitre30JWPtlIiHNHi1pfV4TMEAOQDIxACvgU9XovSzj37FIrGdWr3sYHWMXvFZoWicR3f7QPtKy3b/w7AfpSVlKS+pbvgnQtSgXBA9/+v6qyhqZ3KpI4/zB4Il3+S3i7xftZAuP7115UIR1KXr+6+u46fJQCgoTMCIeBb0OO1KO3ZW6pQNK6THhkTaB23D5ihUDSu2MTFgdaBwjL/6Faa2+Iwnf3GmalA+PzEB6SHfind/xOptMLyJiU7pfULs4fBjo2kzcvT284bWiUQlqxenREGE+GI1vZ8uh6fLQCgITICIeBb0OO1KJWWlikUjevYhz4IrIbPv9qsQ9vG1bzTiJzrJQI1sfDsc1Lh7KnLGsuLeer+SXfp2RNdmNu62m1YViY91jh3GOzYSNq7J/3A80dUCYRz/n1blUC4+d136/kZAwAaGiMQAr4FPV6L1qFt42rVNZi1/yYscDOLhqJx3TVoViA1oHCte+YZzT/+eCXCEY3+fURezNMDkx+Q+v/FhbmvprsNx3WrPgx2+1XmA38xOiMQDpr7uj46woXAqzo00VMPXKhF552vkjVr6vkZAwAaGiMQAr4FPV6L1m87DNURD4yst9+3Z2+pdpXs07xVW1NhMBSN6/kPF9VbDSgeZWVlSkQaa/yRLhB2nNhRiv/Lhbm5cWnsw9WHwY6NpN7HZj7oorEZgfD+Jy5SIhzRG390v+PuDzl3EADgGIEQ8C3o8Vq0mtw7TM07jai333dhr4/Uqutonf/0RxmBcMxcvk1B3Zh7WEvNPupIeTFPHSZ0kMY/5sJcz6Pcv11/IT3RPHcgfPWizAf88sOMQNjv0iOUCEd0491N5MU8XfY+s4sCABwjEAK+BT1ei1azjsPV9L7h9fK7vtq0MyMEVrws27CjXmpA8Znf6vea06KFvJin6PioNH94ZuBbOll677bcgfDtmzMfcNG41H0l+0o0uWVEnzWO6Ijnm8qLeeoyuUswTxQA0OAYgRDwLejxWrQO7zxSv+swtF5+14CPl2aEwCO7jNLEhev0yeIN9fL7UZwWnHSy5kQay3ulqf417l/S3t1S55+6UPfSGW6jYe1yB8LRnTMfcNHY1H1LZk5QIhzR4FMjqZlMt+zZUt9PEQDQQBmBEPAt6PFatI7qMkq/bjekXn7X4yPnZwTCx0fOr5ffi+K28PQzlAhH1PLFprp9zO3uxk8HSm9cK62Y4a5/8EDuQPjx85UecEzqvmlPP6BEOKIHrnGzmLZ+v3X9PjkAQINmBELAt6DHa9E69qEPFIrGVVZW9wvCtxv8WUYgnLaEbwZR9xad/yclwhG1eqapbhl9S/aNkucVVr488DNpxczMbRd+kLp/8t8uVCIcUZuuR8uLefpgaXBLuAAAGh4jEKJInGNm481sk5mtNbM3zezgA3yMoMdr0Tqh2xiFonHt3Ve6/42/puv7fJIKg959w+vldwKLW1+mRDiiE3o21Q0jb8i+0ZRn0yGw04/SP+/LsjZm+bITZfc10qwjWujTJhG9P+ctbdjFBxwAgExGIESRuNxcKPyBmf0/M3vZzCYd4GMEPV6L1indxyoUjWtXyb46/10X9krPLPr3ftPq/PcBkrTkqr8pEY7oDz2a6trh12bfaHrfdAh88OAqC89nWDBK6thIu277SWq5iZlrZmbfFgBQ1IxAiCLV3MxKzexbB7BP0OO1aP3x8XEKRePauqtEM5Zu1END52ruqrqZFOP4bu7w1DemLdeaLbvq5HcAlS294QYlwhGd9WhTXTX0quwbff5mOgR2j+wnEI6UOjbSxit/njp/cN3OdXX3BAAAecsIhChSt5rZ7APcJ+jxWrTOemK8QtG4Nu3Yo7OfdD+f9MiYWj+cs6ysTJF7hqnF/fW35iEgSctvvU2JcER/erCpLo9fnn2jeUPTIfDpVtUHwh0bpI6NtP62PyoRjqjdbS3q5RxcAED+MQIhCsC3zey71VwOqrR9SzPbbGZ/3M/jdjI3QFIXBOP8nhMUisa1dutuNes4PL1Q/LzaXSh+w/Y9CkXjOqPHh7X6uMD+fHX33UqEI/pbhya69L1Ls29UYW1BvXFt9YFQkvbu0fIe3ZUIR9S5w8l1UzgAIO8ZgRAFIG6VglulyyEVtm1mZmvM7Moa/J6gx2vRSp7Xt3DttowZQB94f06t/p5ZyzYpFI3ruj6f1OrjAvuz8p57lQhHlAhHdMlbf8q+0ZcfpkPgsLb7D4SS5nT6txLhiHo8kiNkAgCKnhEIUUQ8c2HwmhruH/R4LVqXPjtJoWhcY+etUSga18mPjq3Vb/J27NmrLbtK9P6nKxSKxnX/e7UbNIH9qRgI737wlOwbbVrqAmCvY3wHwo/vvFaJcEQvP/+POqgaAFAIjECIItHUXBi84Ws8RtDjtWj95fnJCkXjOrSt+2bwrkGzdNIjbimKNVu//sQv5/WcoKO6jNI/X5+pUDSulz/6shaqBvxbes21qUD4zLVH595ww5fS7m3SsHa+AuFHN7ZWIhzRoNc71m7BAICCYQRCFIlXzKzMzLZXuvzyAB4j6PFatP760scZh4o+PeYLtS9fQP7tGV99rcdes2VXxmOHonFNWMBsjKhfX/zx9FQgfPGKI/a/g89AOPGq85UIR/Tme4/UUqUAgEJjBELAt6DHa9G6fcAMhaJxtYlN1cCpy7Rt914N+3ylQtG47hw462s99pDPVqaCYJf4HI1OrGY2RtS7bRM+SgXCV1q33P8OPgLhjpIdmnjpGUqEIxo8umctVgsAKCRGIAR8C3q8Fq3123Zr0sL1GUFt844SHdo2rqO7jlJpac0DXLdhcxWKxjXwk2W1USpQYzs//VSJcESvXth8/xsPb19tINywa4O8mKe3T3Uh893JL9dytQCAQmEEQsC3oMcrKmldPtnMuPlrq91u+cYduvm16Vq2YUeV+27uN12haFzTlmyoqzIBX3bNm69EOKL+5zbb/8b7CYQTvpogL+Zp6AkuEMY/HVjL1QIACoURCAHfgh6vqOTdWW5W0PN6Tqj2W8LeYxcqFI3rvnc+lyRt37039W1jctH7ddt210vNQC57Fi92E8Cc2XT/G+8nEH701UfyYp7GtHKBcNjCeC1XCwAoFEYgBHwLeryikn2lZTr3Kbdo/cxlm3Ju13VIQqFoXMd3+0BPj/lCoWhcf35ussrKytTk3mFqet9wzhtE4EpWrnTn+/2h8f43ntnfhcHHvax3T/xqoryYp0ktI5rVJKLRS0fXcrUAgEJhBELAt6DHK7J4avQChaJxvTgh91IRdw2aVWUm0eQ3hqFoXBf0+qgeKway27thgxLhiN47KbL/DyhKS6VPB0lbV2W9e9KKSfJinmZ4EU05LKLxy8fXQcUAgEJgBELAt6DHK7KY+MU6haJxXd/nk5zbtIl9kjUQJi9vTV9ejxUD2e3btl2JcETDj4+opLSkRo9RsnKl9m3ZoskrJ6vFS02VCEc0tlVEk1dOruVqAQCFwgiEgG9Bj1dksatkn7yOw/Wb9kO0Psd5gBf3npgRAJ8avUCvT12qZ8ct1ICPl36tWUqB2lJWUqJEOKIxrSLauXfnAe9fumePEuGI5nrNNGXlFB3Xq2nqG8fpq6fXQcUAgEJgBELAt6DHK3Lo+O5shaJxPTtuYdb7T+0+NiMQDvlsZT1XCOxfWVmZZkcimnBkRFv3bD3g/ZOHnCbCEU1dNVVndHeBsP+ZjfXZ2s/qoGIAQCEwAiHgW9DjFTksWL1VoWhcJz4yJuu3fYd3Hqnfdhiqx0bO17EPfaBNO/YEUCWwfzObNdGUwyLauGujSvYd2GGjJStWpALhJ8sm65IHXCB8/sLGmrdhXh1VDADId0YgBHwLeryiGpc+49YknLBgXcbtZWVl+lW7ITq666iAKgP8m9ayqWZ4EQ39cqgO63OYBs7zv37g7kWLUoFw2qxhurp9EyXCET12eWMt2rSoDqsGAOQzIxACvgU9XlGNt2d8pVA0rptenaa9+0r1xZqtuvLFKWpy7zCFonGd8xSzLKLhm3J0M30eiejOsXfKi3nyYp7vbwp3zp6d/oZw9Gu69Z8uEN7fprGWbV1Wx5UDAPKVEQgB34Ier6jGrpJ9anH/iJwzid706rSgSwT2a+JxhykRjuj6oW1SgXDV9uxLS1S2Y9q0dCAc8JTa3eQC4d23NPH9GACA4mMEQsC3oMcr9uOqlz5OBcDfdRiqHqPmp653HZIIujxgvyaecpQS4YiOebFlKhDO3TDX177bJnyUCoSzWx2lUce4n2+6q4k27NpQx5UDAPKVEQgB34Ier9iPe8sXmg9F49qzt1SSUtcfG8GkGmj45v7pXBcIezdNBcJJKyb52nfrqFGpQFjxcsV9TWo0aykAoDgYgRDwLejxiv2o+I1g0rlPTVAoGtfw2Rwyh4Zv8V8uVyIc0UlPpQPhsC+H+dp383vvKxGOaE33xzTjxitSgfCcbk21e1/2NToBADACIeBb0OMV+9F30uIqgXDTjj36YO7qAKsC/Ft6bRslwhE92fWiVCAcMHeAr303DhqkRDiitb166eN7/5EKhMf1aqrSstI6rhwAkK+MQAj4FvR4xX7s3rtP977zuWYs3Rh0KUCNbBk5UonGTZRo0lQjXuooL+ap96zevvbd0KevEuGI1r/0sib1aJ8KhIe90ryOqwYA5DMjEAK+BT1eARSBze+9p0TjJpp9WAu1eqapHvr4IV/7rXvueSXCEW3s318fxh5MBcKWfVvWccUAgHxmBELAt6DHK4AisfK+jkqEI2p3UxO1G9/O1z5rn3xSiXBEmwa/rbGvdUsFwiNePaKOqwUA5DMjEAK+BT1eARSJXfPmKxGOaOgJEd017i5f+6x+2IXALcOGaeikPkqEIxp+fERH9TuqjqsFAOQzIxACvgU9XgEUkTmn/8F9S/j2331tv+Ckk5UIR7R17Fi988U7+sPjTXXE803V6rVWdVwpACCfGYEQ8C3o8QqgiCRuvUGJcEQP9r58v9vuXrQodYjojmnTNHjB4NQspccPOL4eqgUA5CsjEAK+BT1eARSReY91USIcUa97z9vvtjumT08FwrLSUr05/81UIDxl4Cn1UC0AIF8ZgRDwLejxCqCILHy7nxLhiPpft/9At33yFCXCEa2ItpUkDZw3MBUIT3/j9LouFQCQx4xACPgW9HgFUEQWTxyhRDiiwZcdu99tt42foEQ4opX33CtJGjB3QCoQnv3W2XVdKgAgjxmBEPAt6PEKoIh8NXOiEuGI3rtw/5PCbB0zRolwRKvuv1+S1C/RLxUI//T2n+q6VABAHjMCIeBb0OMVQBFZveBTt/TE2UeqdPdurX36aZWsWJF12y0j3LeJqx98UJLUd07fVCC8+N2L67NsAECeMQIh4FvQ4xVAEVm/fKES4YhGntZSqx5wE8x82bp11m23DBniAuEjj0iSYrNjqUB42fuX1WfZAIA8YwRCwLegxyuAIrJ54yolwhGNPbGFFp55lhLhiOY2byFJWvtUT331r7tUVlbmtn3nHSXCEa3p0UOS9NLnL6UC4ZVDrgzsOQAAGj4jEAK+BT1eARSRHbu3KRGO6KPfe5rb4jAlwhEtPP0MSdL8o1spEY6odPduSdKmN99UIhzR2p5PS5Je+OyFVCC8Zvg1gT0HAEDDZwRCwLegxyuAIlJSWqJZTSOa5TVOrTE495STtXfjxtT10u3bJUkbBwxQIhzRumefkyQ9O+vZVCC8fsT1QT4NAEADZwRCwLegxyuAIlJWVqaPW0RS4S8Rjmh20ybaMWNG6vq+zZslSRv6vqpEOKL1L70sSeo9s3cqEN48+uYgnwYAoIEzAiHgW9DjFUCRGX9UZiBMhCNa//IrqZ/3btggSVr/0stKhCPa0KevJKnnjJ6pQHjbB7cF+RQAAA2cEQgB34IerwCKzKhj04eLTjrc/bv8H7embitZvUaStO6555UIR7RxwABJ0pPTn0wFwjvH3hnkUwAANHBGIAR8C3q8AigyQ05uqkQ4olnNmuiFC1w4XHD8CelAWL4u4dqnn1YiHNGmN96QJPWY1iMVCKPjo0E+BQBAA2cEQsC3oMcrgCLzzh89JcIRvXfmYXr0ysZVDh/ds2yZJGnNE08oEY5o8zvvSJIe++SxVCBcuGlhkE8BANDAGYEQ8C3o8QqgyAw6p7kS4Ygeuqap7r2+SZVAuHvRl5KkNY8+6gJhPC5JemTqI/JinkYsHhFk+QCAPGAEQsC3oMcrgCLT7yK3/uDfOjTRHbdnCYQLFkiSVj/4oBLhiLaMcAHw4Y8flhfzNHrJ6CDLBwDkASMQAr4FPV4BFJkbHj9ZD1/VWC1eaqo2basGwl2JhCRp1f2dlQhHtPWDMZKkrlO6yot5GrN0TJDlAwDygBEIAd+CHq8AiszZb52dOhfw0s5NqwTCLUOHSpJW3nOvEuGIto2fIEl6YPID8mKePlz+YZDlAwDygBEIAd+CHq8Aisz5b5+fCoQnPlUhEDZOf1u4e+FCrWjbTolwRNsnT5YkdZrUSV7M04SvJgT8DAAADZ0RCAHfgh6vAIrMRe9elAqEXszTHbc3UfykiJZcfXUqEG547TV99a+7lAhHtGPaNEnSfRPvkxfzNHHFxICfAQCgoTMCIeBb0OMVQJFp/X7rjECYvCS/EUyEI1r3/PNafvsdSoQj2jlrliSpw4QO8mKepqycEvAzAAA0dEYgBHwLerwCKDKXxy/PGgiXtU8HwjU9emjZzbe4SWbmzJEktRvfTl7M09RVUwN+BgCAhs4IhIBvQY9XAEXmqqFXyYt5Oun1kzIC4YL2d6UC4aouXbX0hhtcIJw/X5L07w//LS/mafrq6QE/AwBAQ2cEQsC3oMcrgCJz7fBr5cU8XR6/XGOXjU0Fwk/b3ZYKhCvatdfSa65xE8x86Raqv2vcXfJinmaumRnwMwAANHRGIAR8C3q8AigyN4y8QV7M013j7pIkPfTxQ+5Q0PY3pwLh8ltv05Ir/6pEOKI9y7+SJN059k4XHNd+GmT5AIA8YARCwLegxyuAIvP3UX+XF/P0+LTHJUk9Z/SUF/P0UfsbU4Fw6TXX6suLL1EiHFHJ6tWSpDvG3CEv5mn2utlBlg8AyANGIAR8C3q8Aigyt35wq7yYp9fnvi5Jis2OyYt5+qBDm/SahE09JcIRzTvqaJXu2pWxX2J9IsjyAQB5wAiEgG9Bj1cAReafY/8pL+Zp/PLxkqS3FrwlL+ZpaIer0oGwPAzumJ6eQOaW0bfIi3mat2FeUKUDAPKEEQgB34IerwCKzDtfvKNL37tUm3dvliSNWDxCXszT4A6Xp8Lgsltu0a558zP2u2nUTfJinr7Y+EUQZQMA8ogRCAHfgh6vAIrcxBUT5cU89e9waSoQZpOcjGbR5kX1XCEAIN8YgRDwLejxCqDIfbb2M3kxT6+0+1O1gfCS9y6RF/O0fuf6eq4QAJBvjEAI+Bb0eAVQ5BZvXiwv5um5u86sNhAe2/9YHfnqkSorK6vnCgEA+cYIhIBvQY9XAEVu3c518mKeet5xSs5AuL1ku7yYp3MHnxtAhQCAfGMEQsC3oMcrgCK3e99uty7hrcfmDIRfbPxCXszT9SOuD6BCAEC+MQIh4FvQ4xUA1LJvSz180xE5A+H45ePlxTx1nNix/osDAOQdIxACvgU9XgFAJ75+orpc1yxnIBw4b6C8mKdnZj0TQHUAgHxjBEIUicPNbLqZbTSzzWY2ycxOPMDHCHq8AoDOGXyOOl/bOGcgfGL6E/Jint5d+G4A1QEA8o0RCFEk/svMQmZ2UPnlIjPbZmbfO4DHCHq8AoAue/8ydbkmdyCMjo/Ki3maumpqANUBAPKNEQhRhL5hZn8y95//0APYL+jxCgBqM6KNul6dOxBeNfQqeTFPy7cuD6A6AEC+MQIhisxmM9tn7j9+3wPcN+jxCgC6Y8wdeuhvVQPhup3rNHLJSJ32xmlqFmumkn0lAVYJAMgXRiBEAfi2mX23mstBlbb/npldaWbX7edxO5kbIKkLAATtno/u0U13NVEiHNEXp5+euv2st86SF/PkxTydOujUACsEAOQTIxCiAMStUnCrdDkkx35zzOz4A/g9QY9XAFC3qd3U7JWmmtC3m/auW5e6PRkGvZinK4ZcEWCFAIB8YgRCFLEFZnbNAWwfkKWdUgAAGQ9JREFU9HgFAPWe2VtezNPgBYMzbq8YCO8ed3dA1QEA8o0RCFEkzjWz5mb2LTP7vpm1N7OdZvbrA3iMoMcrAKjvnL7yYp76zO6TcXvFQPj4tMcDqg4AkG+MQIgicbWZzTez7Wa23szGmtkpB/gYQY9XANDgBYPlxTz1mtkr4/aKgbD/3P4BVQcAyDdGIAR8C3q8AoBGLRklL+bp4Y8fzri9YiAcvXR0QNUBAPKNEQgB34IerwCgKSunyIt56jChQ8bth/c9PBUIP137aUDVAQDyjREIAd+CHq8AoNnrZ8uLebp9zO2SpNKyUknS8QOOTwXCVdtXBVkiACCPGIEQ8C3o8QoAWrplqbyYpzbD22jY4mH6/Wu/17wN83T6G6enAiGL0gMA/DICIeBb0OMVALRh1wZ5MU+t32+t7p90lxfz9Mb8N3TBOxekAiEAAH4ZgRDwLejxCgAq2VciL+bprLfO0sMfPywv5un5T5/XlUOuJBACAA6YEQgB34IerwAgSTry1SN1woAT1GVyF3kxT92mdtPVw66WF/M0e/3soMsDAOQRIxACvgU9XgFAknTywJN1WN/D1GlSJ3kxT+3Gt9NVQ6+SF/O0ctvKoMsDAOQRIxACvgU9XgFAktT6/dbyYp4uevcieTFPN426SVcMuUJezNPq7auDLg8AkEeMQAj4FvR4BQBJ0oC5AzIWor/s/cv0l/hf5MU8rdu5LujyAAB5xAiEgG9Bj1cAkJRenD55OePNM1LfGm7YtSHo8gAAecQIhIBvQY9XAJAkfbLqk4xAeHS/o3XJe5fIi3navHtz0OUBAPKIEQgB34IerwAgSZq5ZmZGIPRins4dfK68mKete7YGXR4AII8YgRDwLejxCgCSpM/WflYlEB7T/xh5MU/bS7YHXR4AII8YgRDwLejxCgCSpDnr51QJhMnLzr07gy4PAJBHjEAI+Bb0eAUASdK8DfNyBsI9+/YEXR4AII8YgRDwLejxCgCSpIWbFuYMhHtL9wZdHgAgjxiBEPAt6PEKAJKkJVuW5AyEZWVlQZcHAMgjRiAEfAt6vAKAJGn51uVZw2CzWLOgSwMA5BkjEAK+BT1eAUCStGr7qqyBsEWfFkGXBgDIM0YgBHwLerwCgCRp7Y61WQNhy74tgy4NAJBnjEAI+Bb0eAUASdKGXRuyBsIjXz0y6NIAAHnGCISAb0GPVwCQJG3evTlrIDy639FBlwYAyDNGIAR8C3q8AoAkaXvJ9owgeFifw+TFPB3z2jFBlwYAyDNGIAR8C3q8AoAkadfeXRlh8OSBJ8uLeTpuwHFBlwYAyDNGIAR8C3q8AoAkqaS0JBUIj3j1CF3wzgVMKgMAqBEjEAK+BT1eAUCSVFpWmgqErV5rpSuGXJG6DgDAgTACIeBb0OMVAFKa92kuL+bp2P7H6prh1xAIAQA1YgRCwLegxysApLTs21JezNOJr5+oG0beQCAEANSIEQgB34IerwCQclS/o+TFPJ068FTdMvoWAiEAoEaMQAj4FvR4BYCUVq+1khfzdPobp+u2D24jEAIAasQIhIBvQY9XAEhJBsKz3zpb/xz7TwIhAKBGjEAI+Bb0eAWAlKP7HS0v5um8t8/T3ePuJhACAGrECISAb0GPVwBISQbCC9+9UG3HtyUQAgBqxAiEgG9Bj1cASElOKnPpe5eqw4QOBEIAQI0YgRDwLejxCgApyUDY+v3W6jixI4EQAFAjRiAEfAt6vAJAypGvHpkKhPdPup9ACACoESMQAr4FPV4BICUZAK8aepW6TO5CIAQA1IgRCAHfgh6vAJCSDIA3jrpRD3/8MIEQAFAjRiAEfAt6vAJASjIA/nPsP/Xo1EcJhACAGjECIeBb0OMVAFKSAbD9hPbqMa0HgRAAUCNGIAR8C3q8AkBKMgB2mdxFT05/kkAIAKgRIxACvgU9XgEgJRkAH5v2mHrN7EUgBADUiBEIAd+CHq8AkJIMgL1n9dazs54lEAIAasQIhIBvQY9XAEhJBsDY7Jhe+OwFAiEAoEaMQAj4FvR4BYCUZAAcOG+gXvn8FQIhAKBGjEAI+Bb0eAWAlH+M/oe8mKdlW5ep75y+BEIAQI0YgRDwLejxCgAppWWl2rx7syTp/UXvEwgBADViBELAt6DHKwBktbd0r7pN7aYZa2YEXQoAIM8YgRDwLejxCgAAANQqIxACvgU9XgEAAIBaZQRCwLegxysAAABQq4xACPgW9HgFAAAAapURCAHfgh6vAAAAQK0yAiHgW9DjFQAAAKhVRiAEfAt6vAIAAAC1ygiEgG9Bj1cAAACgVhmBEPAt6PEKAAAA1CojEAK+BT1eAQAAgFplBEIUoRvN/ce/4wD3C3q8AgAAALXKCIQoMv9rZovM7HMjEAIAAKDIGYEQRWawmV1tZuOMQAgAAIAiZwRCFJGLzWxs+c/jjEAIAACAImcEQhSAb5vZd6u5HGRmPzKzxWYWLt9nnO0/EHYyN0BSFwAAAKCQGIEQBSBulYJbpcshZva8mXWssM844xtCAAAAFDkjEKJILDGzdWa2uvxSYmZbzWzQATxG0OMVAAAAqFVGIESR+KmZ/bzCZZKZ3WtmPz6Axwh6vAIAAAC1ygiEKFLjjENGAQAAUOSMQAj4FvR4BQAAAGqVEQgB34IerwAAAECtMgIh4Ft1M5ly4cKFCxcuXLhw4ZKvFwCoEf6AZEdfsqMv1aM/2dGX3OhNbvQmO/qSG70BgBrgj2d29CU7+lI9+pMdfcmN3uRGb7KjL7nRGwCoAf54ZkdfsqMv1aM/2dGX3OhNbvQmO/qSG70BgBroFHQBDVSnoAtooDoFXUAD1ynoAhqoTkEX0IB1CrqABqxT0AU0UJ2CLqAB6xR0AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC9OCjoAhqQZmbWNOgiGqiDcvwM5BI2s0OCLgJ5j783Dq9PufH6BAAH4Odm9oiZtTOzU8zsG8GW02D81MyGmNliM2sTcC0Nzc/N7AUze9zMLjSzbwZbToPyP+amMr/JeKNW0c/MjaeEmV0ScC0Nzf+a2ZNmdp+ZHWO8ea2M16iqeH3KjdcnADhAd5nZZjN73swGmdnHZnZb+X3F/KbkO+ZebPuZ2bcCrqWhOdbMVprZi2bW08zmmHvxhVlbM9tiZi+b2Ydm9oGZtQ60oobhx2Y23sz6mNl3K9xezH9jks4ws/Vm9pKZDTaz6Wb2QPl99IfXqGx4fcqN1ycAOECnm9l7Zvb78us/NLN7zWyAZb5pK0Ynm9lHFa6faGa/NrP/DKSahuUeM+tf4bpnZmVmdlUw5TQYfzYXAFuUX/+FuWD4kPEJ9fnmepN0tLlvOL4TTDkNyqNm9nT5z98zs3PMbJ+5vznFjteo7E42Xp9y4fUJAHz4doWff21mV5f/nPyUsbOZvVufBTUQ3650/Qwzm2TufKcxZrbAzCaY2UQz+7/6La1BSB6i9U1zh+E8Z65nyds7muvRz+u/tEBVPHQtbGY3lv/8H+X/vmAuFBabyof0/dXM3jSziLk3snPNjaf3rDjDcvKbrf9nZm+ZWXvL7FlvM/u8votqIHiNqorXp+rx+gQAPjUy9+b0VXOH2/yo0v3JNyidzaxbpdsKWeW+/LD89svNvVntbe68HjP3jc9UM3vC3Bu5QvefZnZthevJ/w/dzGyomf1Xpe3Xm9nfy38u9HN8Gpn7VqenmV1sZj+odH+yV6+Y2T/Lfy70nphV7UtynLQzs7iZdTf3Cf5BZnaYma2y9Pgq9L83PzDXk6Tk833NzN4u/zn5f+QnZrbNzC6qtG0h4zWqKl6fcuP1CQAO0KHmJnLob2b/MneOyjhzbzrM3B/S5B/TSWb2t3quLyjZ+jLe3GFsPzF37kGZmf2hwj5nmnsTW+iHK11u7nmWWfpNafLwvl+Y2W6r+ma1o7n/V4WuhbmJHF4zs8fMbJa5b7+SDjL3huO75fedU98FBiRbXwaX3/e/ZrbdzHaYC4JJfzazFfVYY1D+ZmYbzGyXmZ1WfltyPDUzN86OKL+eHE9PmVmsnuoLGq9RVfH6lBuvTwBQA1eYO5wk6XtmtsTcxAU/rnB72MxWV7h+kZldUNfFBShXXx4qv361mW209KeKZu7N28fm3uAWqoPNHXZzt5ndb2bzK9yXPHSph5nNNvd/JqmLmT1b/nMhfwJ7i7kJHZIOMfcG5DbL/MailZktq3D9LDM7ta6LC1CuvtxZfr29mZWYe9OadLaZjbb0Nx+FqIm5CVHuMzduhle4L3m47GtmNs3c3yCrcFuX8p8LeTyZ8RqVDa9P2fH6BAA19Ddzn4xVfNN1uZl9am4K76RzzB17/ytzL0SrzL1hK1S5+jLbzI4vv/6quV78y9wSApMsPQFEofqOmTU390bsEHPne91Tft9/VNhuspkNNDeL5qFmNtPMbq23KoNxkLlPml8z9wYtGQD/YWZfWeb6eteZmyr/F+Z6tdTMTqqvQutZdX1ZZek3qBPNHep2hbn/M5MsHXoK1f8zt5TED8z9vf3Y0ueaJs+L+4G5/z/PmtkJ5s4Dm2GuT8WA16iqeH3KjtcnAKhGdedSXGVuhr9WlW4fb+6wpOT+3c0dgrHFzB6s7QIDUtO+9C7/+RfmPoEdaWbzrHD6Yubv/JtvmAs26y19TkbycKSm5j6tnmzuzezDtV1gA9XW3JISlT+FX2zp83n+w1w4KrTxVJ3q+pJcRqGZuU/1J5j7tqNrfRXXQPzQ3JvXTyz9Rj95qNvx5g4RnWZma604/s8kFfNrVC7F/vrkB69PAOBD8g3/983sM3MTO1SclvpCc+v1JLcbYO4NyU+ssPnpyyrLDEzft8zDuQpZ5aD43+YO6+ufZVszN3Nb5UlV8t1Ps9yW7MsPzE340abS7Teb+1YnaaK5ddMKaTzVtC8zszxOoU18ka03FSX70dLMRphbbiKb35ibTKTQnGBV/4YW+2tUTXtSDK9P2XpjxusTAGT1R3OTFVxX6faDLHM69zbmXlz+VOG2i8zNxpU8R6OQTkSvjb78wApzSny/vUn6hrnzvtab2W/NnQv3r7osMECnm5vIoZNlznJYuTdtzZ0f2LzCbXeZ+1YwOY6+X2dV1r/a6Ms3rTDHk9/eJH3P3CGjM8x9w3OaZc6WWGjOMDcBygpzh+4lFfNrVG30pFBfn/z2JqmYXp8AoIpfmJvAYZVVPS6+4idov7T0+SovmvtkuoO5czAmmjs5u5DQl9z89uZgc9/qfKvSNm+bO1xrb/n9hSL53O8w9ybkNnNv2pMTFFR8E/JLS785+8DcGnLXmNn/mDt/5966LrYe0ZfcDqQ3B5tbbqLiRBbfN/emfq+5mUf/WpfFBuQQc39vVpo7T3S7uXUFzar+3ymWv8WHGD3J5RDz15tie30CgJz+09ybkMmWuWBt5U/PuptZqaXfjP3c3CeOY80t0lpoJ5/Tl9wOtDftKtx2kLnF1cvMTRxSiL5hbp28MyrcVvlcuCfM9SA5a+ZvzfVjsrlvxXrVcY1BoC+5HUhvKn8AkxxP99dZdcE6ylzQfcoyl4u4odJ2xfS3mJ7kdqC9KbbXJwCoIvkG/mEze9fcuRTXmZvK/GVzM5N9z9yaYL3NLJTlMX5gmeckFAL6ktvX7c3PzL1xPdQK12HmZn/8nrk3IbPNzfD3tLm+HG3ufMBs/29+alUX0S4U9CW3mvamhblp8Q+ppzqD8GNz53Yl/cjcIbJtKtx2rJn1tOL5W0xPcvs6vSmG1ycAMDP3iXvy0InktzvfMbMvzM1GN93cIUdPmpuhrlOl/b9p/maUzDf0Jbfa6E2hrtVUsTfJsPwjM9tj7lCjt8zN+HiOmfUzN6tfxV4U6v8b+pJbbfQmeb0Qe1SxPxWf3zct/fdnkLk+ZVOI/3foSW610ZtCfX0CgCr+08xeMre48+OWfiOS/IN5kZl1q7TP381ssLlzEMwK848mfcmN3uSWqzfJyU5i5mbJ7Fxhn4i5pRQurrBtoaEvudGb6uXqTzZ3mzvP64eVbi+0vzf0JDd6AwAH6Jvm1qt63dw5OG+a+/TZLPMPYvKQrOShJOeYW6Pp5/VQYxDoS270JrfqepN0rplttPRagmbucKTPzezkui8xEPQlN3pTver6k+2brdvMzR6Z6/5CQE9yozcAUEO/Nzd9+8Hm1l/qZenFV3N9StbezJ61wv5Umr7kRm9yq643Zm7tty5mtsPc0hxmZq3NLaKe7ZyeQkFfcqM31auuPwdV+vdQc0sDNKnPAgNAT3KjNwCwH4eZ2UPmJvj4vyz3/9XclMzXVLr9G+XbX2RuVr95Ztaq7sqsd/QlN3qTW017Y+YOaZpgbpKQ5ZY5i2S+oy+50ZvqfZ3+mLm/MV+aW3exUNCT3OgNAPiU/CTsLnPnoTxl7hCJoZY+lOI/yv/9jrlvcV61zE/MvmFmJ5jZJ+bWKSoE9CU3epNbbfTGzK1v9UNzPSoE9CU3elO92upP0qV1U2a9oie50RsAqKGDzGyYpScg+K25Q5CWWPoQv+SEIKebW/cquWDtX8wt/GyW/iNbKOhLbvQmt6/bm8rryBUK+pIbvane1+1PIZ6bTE9yozcA4NP/WPrNeMTM5pvZkZb+dO1/zWyWpReg/VaFfduZm7Bgj7mpzX9W18XWI/qSG73JrbZ686EVVm/oS270pnr0pyp6khu9AYAD8BszG21u8eKxZnZm+e1LzOyW8p+TE3tcYm69uIMr7P8Lc8fULzWzy+q21HpFX3KjN7nRm+zoS270pnr0pyp6khu9AYADdI25P3oPmTskoq+5E6qbmdm/zGxFpe1D5g67+Ev59W+Zm5Hrkfooth7Rl9zoTW70Jjv6khu9qR79qYqe5EZvAKAGHjCzmypc/7GZLTaz483sv80dYvFohfu/Z2ZfWPoTN7PMwywKBX3Jjd7kRm+yoy+50Zvq0Z+q6Elu9AYAauBgSx8b/11zx9Z/bmZnld92tpmVmTvM4r/M7CRzs0AW+ho89CU3epMbvcmOvuRGb6pHf6qiJ7nRGwD4GpInWf/OzBaY2X9WuO2fZjbK3MnXGyz3+jyFiL7kRm9yozfZ0Zfc6E316E9V9CQ3egMAX8M1ZjYiy+0HWeEtEn4g6Etu9CY3epMdfcmN3lSP/lRFT3KjNwBwAJIzbsXMLd5qZnaDuZm6jgiioAaCvuRGb3KjN9nRl9zoTfXoT1X0JDd6AwA19G1zh1F0NrMJ5qZdPiPQihoG+pIbvcmN3mRHX3KjN9WjP1XRk9zoDQDUQFNzJ1uvtPQnaqAv1aE3udGb7OhLbvSmevSnKnqSG70BgBr4DzO708y+E3QhDQx9yY3e5EZvsqMvudGb6tGfquhJbvQGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACggFxgZkuCLgIAAAAAUP/8BsJDzExm9qO6LAYAAAAAUH8IhAAAAABQJA42s5FmttXMpptZe0sHwjvN7Asz22Zmi8zsHxX2W2suEG4vv1xRfvvhZjbWzDaa2UIzu75OqwcAAAAA1Nh4M+tjZt83s4iZLbZ0ILzYzP7PzA4ys1PMbJeZHVd+3yFW9RvCn5vZBjNrbWbfNDPPzFaa2R/qsH4AAAAAQA38n7lQ97MKt0Ut9yGj75hZh/KfD7GqgfBuM3u70j5dzeylr1knAAAAAKCWtTL3rV9Ff7Z0ILzCzGaY2SYz22xmJWbWo/y+Q6xqIOxlZnvKt01etpnZ0FqvHAAAAADwtWT7hvDf5gLhL81sn5mdZmbfKr/vHTN7ovznX1rVQNjWzF6vu3IBAAAAALXpIzN72cy+Z2Zhc5PHLDGzJmZWambNzewbZna2me20dCD8Xvn9R1R4rF+Ym2zmYjP7dvnlMDM7qo6fAwAAAACgBn5pZqPMHdo53dw5gkvK7+tsZuvNHTLax9y3f09U2Pc+cwFws5ldXn5bS3Ozlq43N9PoRGNSGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACo7P8HyjMiPx+VkcEAAAAASUVORK5CYII=\" width=\"900\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>3-5</th>\n", - " <th>5-7</th>\n", - " <th>7-10</th>\n", - " <th>5-10</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>min</th>\n", - " <td>24.179207</td>\n", - " <td>18.932223</td>\n", - " <td>12.110608</td>\n", - " <td>31.924565</td>\n", - " </tr>\n", - " <tr>\n", - " <th>max</th>\n", - " <td>34.068608</td>\n", - " <td>27.213778</td>\n", - " <td>22.397303</td>\n", - " <td>48.664671</td>\n", - " </tr>\n", - " <tr>\n", - " <th>mean</th>\n", - " <td>29.324689</td>\n", - " <td>23.817895</td>\n", - " <td>18.031090</td>\n", - " <td>41.848985</td>\n", - " </tr>\n", - " <tr>\n", - " <th>current</th>\n", - " <td>26.739304</td>\n", - " <td>24.610743</td>\n", - " <td>18.685848</td>\n", - " <td>43.296591</td>\n", - " </tr>\n", - " <tr>\n", - " <th>zscore</th>\n", - " <td>-1.164417</td>\n", - " <td>0.346738</td>\n", - " <td>0.417601</td>\n", - " <td>0.438474</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " 3-5 5-7 7-10 5-10\n", - "min 24.179207 18.932223 12.110608 31.924565\n", - "max 34.068608 27.213778 22.397303 48.664671\n", - "mean 29.324689 23.817895 18.031090 41.848985\n", - "current 26.739304 24.610743 18.685848 43.296591\n", - "zscore -1.164417 0.346738 0.417601 0.438474" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Table of Spread Differences, and Z-score of current spread differences\n", "ct.spreads_diff_table(spreads_diff)" @@ -1747,114 +59,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th>tenor</th>\n", - " <th>3yr</th>\n", - " <th>5yr</th>\n", - " <th>7yr</th>\n", - " <th>10yr</th>\n", - " </tr>\n", - " <tr>\n", - " <th>series</th>\n", - " <th></th>\n", - " <th></th>\n", - " <th></th>\n", - " <th></th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>23</th>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " </tr>\n", - " <tr>\n", - " <th>24</th>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " <td>NaN</td>\n", - " </tr>\n", - " <tr>\n", - " <th>25</th>\n", - " <td>0.000796</td>\n", - " <td>0.002174</td>\n", - " <td>0.002758</td>\n", - " <td>0.001844</td>\n", - " </tr>\n", - " <tr>\n", - " <th>26</th>\n", - " <td>0.001000</td>\n", - " <td>0.002093</td>\n", - " <td>0.002569</td>\n", - " <td>0.001756</td>\n", - " </tr>\n", - " <tr>\n", - " <th>27</th>\n", - " <td>0.001362</td>\n", - " <td>0.002289</td>\n", - " <td>0.002491</td>\n", - " <td>0.001678</td>\n", - " </tr>\n", - " <tr>\n", - " <th>28</th>\n", - " <td>0.001654</td>\n", - " <td>0.002405</td>\n", - " <td>0.002372</td>\n", - " <td>0.001617</td>\n", - " </tr>\n", - " <tr>\n", - " <th>29</th>\n", - " <td>0.001702</td>\n", - " <td>0.002350</td>\n", - " <td>0.002144</td>\n", - " <td>0.001547</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - "tenor 3yr 5yr 7yr 10yr\n", - "series \n", - "23 NaN NaN NaN NaN\n", - "24 NaN NaN NaN NaN\n", - "25 0.000796 0.002174 0.002758 0.001844\n", - "26 0.001000 0.002093 0.002569 0.001756\n", - "27 0.001362 0.002289 0.002491 0.001678\n", - "28 0.001654 0.002405 0.002372 0.001617\n", - "29 0.001702 0.002350 0.002144 0.001547" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Theta per unit duration\n", "ct.theta_matrix_by_series(index)" @@ -1862,802 +69,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'] / mpl.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", - " var x1 = msg['x1'] / mpl.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys (original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object')\n", - " obj[key] = original[key]\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * mpl.ratio;\n", - " var y = canvas_pos.y * mpl.ratio;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event)});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value,\n", - " guiEvent: simpleKeys(event)});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " var width = fig.canvas.width/mpl.ratio\n", - " fig.root.unbind('remove')\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", - " fig.close_ws(fig, msg);\n", - "}\n", - "\n", - "mpl.figure.prototype.close_ws = function(fig, msg){\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width/mpl.ratio\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\n", - " });\n", - "}\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\" width=\"900\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#on the run theta\n", "ct.on_the_run_theta(index)" @@ -2665,86 +79,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/guillaume/projects/code/python/exploration/curve_trades.py:98: FutureWarning: pd.TimeGrouper is deprecated and will be removed; Please use pd.Grouper(freq=...)\n", - " groupby(pd.TimeGrouper(freq='M')).\n" - ] - }, - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>3-5</th>\n", - " <th>3-5-10</th>\n", - " <th>3-7</th>\n", - " <th>5-10</th>\n", - " <th>7-10</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>Sharpe</th>\n", - " <td>0.238939</td>\n", - " <td>1.461529</td>\n", - " <td>-0.413742</td>\n", - " <td>2.435553</td>\n", - " <td>1.265817</td>\n", - " </tr>\n", - " <tr>\n", - " <th>Mean Worst 10 Days DrawDown</th>\n", - " <td>-0.000748</td>\n", - " <td>-0.001212</td>\n", - " <td>-0.000872</td>\n", - " <td>-0.000646</td>\n", - " <td>-0.000639</td>\n", - " </tr>\n", - " <tr>\n", - " <th>Monthly Sharpe</th>\n", - " <td>0.409692</td>\n", - " <td>1.720837</td>\n", - " <td>-0.445668</td>\n", - " <td>1.702420</td>\n", - " <td>1.161168</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " 3-5 3-5-10 3-7 5-10 7-10\n", - "Sharpe 0.238939 1.461529 -0.413742 2.435553 1.265817\n", - "Mean Worst 10 Days DrawDown -0.000748 -0.001212 -0.000872 -0.000646 -0.000639\n", - "Monthly Sharpe 0.409692 1.720837 -0.445668 1.702420 1.161168" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Curve Trade returns\n", "ct.curve_returns()" @@ -2752,10 +89,8 @@ }, { "cell_type": "code", - "execution_count": 143, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "ct.cross_series_curve(index)" @@ -2763,799 +98,9 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.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 overriden (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", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\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": [ - "<div id='c679d979-e016-4b8b-a8a1-595330c18d29'></div>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Theta with 3-5-10 Strategy\n", "df = ct.ratio_within_series(param='duration')\n", @@ -3564,799 +109,9 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.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 overriden (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", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\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": [ - "<div id='f8e66a92-1610-4a0c-a3a7-64d3207c77dd'></div>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Theta with 5-10 Strategy\n", "df = ct.ratio_within_series(param='duration')\n", @@ -4365,809 +120,9 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.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 overriden (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", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\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,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4XuxdB1jV5Rd+2UOQLYI4ABHMkWnmyG3mypll2nDPcpZaWWr+nTnTNGeOssxtliO3puYut4KKbFBkyh7/53yX3/VeuMC9/C4I3HOepyfhfvP9fffy3vOd8x4jsDECjAAjwAgwAowAI8AIGBQCRga1W94sI8AIMAKMACPACDACjACYAPIhYAQYAUaAEWAEGAFGwMAQYAJoYA+ct8sIMAKMACPACDACjAATQD4DjAAjwAgwAowAI8AIGBgCTAAN7IHzdhkBRoARYAQYAUaAEWACyGeAEWAEGAFGgBFgBBgBA0OACaCBPXDeLiPACDACjAAjwAgwAkwA+QwwAowAI8AIMAKMACNgYAgwATSwB87bZQQYAUaAEWAEGAFGgAkgnwFGgBFgBBgBRoARYAQMDAEmgAb2wHm7jAAjwAgwAowAI8AIMAHkM8AIMAKMACPACDACjICBIcAE0MAeOG+XEWAEGAFGgBFgBBgBJoB8BhgBRoARYAQYAUaAETAwBJgAGtgD5+0yAowAI8AIMAKMACPABJDPACPACDACjAAjwAgwAgaGABNAA3vgvF1GgBFgBBgBRoARYASYAPIZYAQYAUaAEWAEGAFGwMAQYAJoYA+ct8sIMAKMACPACDACjAATQD4DjAAjwAgwAowAI8AIGBgCTAAN7IHzdhkBRoARYAQYAUaAEWACyGeAEWAEGAFGgBFgBBgBA0OACaCBPXDeLiPACDACjAAjwAgwAkwA+QwwAowAI8AIMAKMACNgYAgwATSwB87bZQQYAUaAEWAEGAFGgAkgnwFGgBFgBBgBRoARYAQMDAEmgAb2wHm7jAAjwAgwAowAI8AIMAHkM8AIMAKMACPACDACjICBIcAE0MAeOG+XEWAEGAFGgBFgBBgBJoB8BhgBRoARYAQYAUaAETAwBJgAGtgD5+0yAowAI8AIMAKMACPABJDPACPACDACjAAjwAgwAgaGABNAA3vgvF1GgBFgBBgBRoARYASYAPIZYAQYAUaAEWAEGAFGwMAQYAJoYA+ct8sIMAKMACPACDACjAATQD4DjAAjwAgwAowAI8AIGBgCTAAN7IHzdhkBRoARYAQYAUaAEWACyGeAEWAEGAFGgBFgBBgBA0OACaCBPXDeLiPACDACjAAjwAgwAkwA+QwwAowAI8AIMAKMACNgYAgwATSwB87bZQQYAUaAEWAEGAFGgAkgnwFGgBFgBBgBRoARYAQMDAEmgAb2wHm7jAAjwAgwAowAI8AIMAHkM8AIMAKMACPACDACjICBIcAE0MAeOG+XEWAEGAFGgBFgBBgBJoB8BhgBRoARYAQYAUaAETAwBJgAGtgD5+0yAowAI8AIMAKMACPABJDPACPACDACjAAjwAgwAgaGABNAA3vgvF1GgBFgBBgBRoARYASYAPIZYAQYAUaAEWAEGAFGwMAQYAJoYA+ct8sIMAKMACPACDACjAATQD4DjAAjwAgwAowAI8AIGBgCTAAN7IHzdhkBRoARYAQYAUaAEWACyGeAEWAEGAFGgBFgBBgBA0OACaCBPXDeLiPACDACjAAjwAgwAkwA+QwwAowAI8AIMAKMACNgYAgwAZT3wAk/dwAJ8obh3owAI8AIMAKMACNQwgjYAggDkF3C85aK6ZgAynsMVQCEyBuCezMCjAAjwAgwAozAC0LAA0DoC5r7hU7LBFAe/BUBxAUHB6NiRfonGyPACDACjAAjwAiUdgTi4+NRtWpVWqYdgPjSvt7iWB8TQHmoCgIYFxfHBFAejtybEWAEGAFGgBEoMQSIANrZEfdjAlhioJeziZgAlrMHytthBBgBRoARKP8IMAEE2AMo75wzAZSHH/dmBBgBRoARYARKHAEmgEwA5R46JoByEeT+jAAjwAgwAoxACSPABJAJoNwjxwRQLoLc36ARyM7ORkZGBjIzMw0ah6Js3sTEBKampjAy4oucouDHfQwbASaATADlvgOYAMpFkPsbLAJpaWkIDw9HUlKSwWIgd+PW1tZwc3ODubm53KG4PyNgUAgwAWQCKPfAMwGUiyD3N0gEsrKy4O/vD/Jiubi4CALDniztjwJ5TolAP378WHhPfXx8YGxsrP0A3JIRMHAEmAAyAZT7FmACKBdB7m+QCKSkpODhw4eoXr06yIvFVjQEyHv66NEjeHp6wtLSsmiDcC9GwAARYALIBFDusWcCKBdB7m+QCEgEkImLvMfPOMrDj3sbLgJMAJkAyj39TADlIsj9DRIBJi76eeyMo35w5FEMDwEmgEwA5Z56JoByEeT+BokAExf9PHbGUT848iiGhwATQCaAck89E0C5CHJ/g0SgJIhLmzZt0KBBAyxdurTcYlwSOJZb8HhjZQ6BmO3bYVLRDhU7vil77UwAmQDKPURMAOUiyP0NEoGSIC6lhQCmp6fDzMysWJ5zSeBYLAvnQRkBHRFIDQjAg7e6iV6179zWsXfe5kwAmQDKPURMAOUiyP0NEoHiJi4DBw7Epk2b1LClrGPKmv3ss89w6tQpVKhQAW+++SaWLFkCZ2dn0ZZIY/369UVG7bp164Q8zciRIzFjxgzlWEFBQRgzZgyOHj0qpFc6deqE5cuXw9XVVbShtnv27MHYsWMxa9YsBAYGCqmW4pC5KW4cDfJw8qZLJQJx+/YhbNJksTa/WzdhJFP2iAkgE0C5B50JoFwEub9BIlDcxCUuLg6dO3dG3bp1MXPmTIExkTC6Eh42bBg++ugjJCcnY8qUKaISybFjx5QE8OrVq5g4cSL69++Pc+fOgcjkoUOH0KFDB5D+XqNGjQR5pKtl6jt69GjY2trixIkTSgK4cOFCtGjRAnPnzhVah/Xq1WMCaJAnnTetLwQeL1uGJyt/EMP5/vcvjC0stBqa3rMR06YjKzkZ7vPmwsjUVPRjAsgEUKsDVEAjJoByEeT+BolAcRNAyZunGgM4bdo0nD9/XpA5yUJCQlC1alXcvXsXtWrVEh5AIoqnT59WtnnttdfQrl07zJs3D4cPHxbEkryJ1I/s1q1bqFOnDi5cuIDGjRsLD+CcOXMQGhoqRK6L00oCx+JcP4/NCBSGQHZGBh5//z2iV61WNq118QJMbG0L6ypeT4+MREDrNuLfrtO+hmP//kwAc5DjIpJaHaF8GzEBlIcf9zZQBEqCuOSOAezatasgcLnLpj179gz79+8XxI76EJlbsWKF8sn06NEDTk5O+PHHH7Fs2TJxZUwEUNUcHBzw3XffCc8iEcAtW7aISifFbSWBY3HvgcdnBPJDIDstDYHv9UPKrVtqTXzOnoGpo6Pa7+IPH0bShYtwnTJZ6eWjBolnziB4yFDR1sTODp5798CscmX2AII9gHLfeUwA5SLI/Q0SgZIgLrkJIBE8qjoyf/78PJhTPV261tWUONKzZ0/Y29tj48aNguTRfw8ePFAbg16nOMAPP/xQGQP477//FvuzLQkci30TPAEjkA8CiadPI3jY8Oev0vVtRgZqnjguSJyq3farLX50/3Y+7Lp3V770ZM1aPF68WPlzhebNUe3H9UwAmQDKft8xAZQNIQ9giAiUBHGhBA9fX19BzMimTp2KnTt34saNGzDNiQPKjX1hBLCgK+CLFy/i1VdfZQJoiAea91wsCMT8+isivlHE8Dq8/z5id+9GdlISvA//BfOcEAx6LSMmBv7Nmot2zmPHwGX0aPFviv8LaNceGeHhsGnbFonHj4vfW9arB7sF38LJ05N+tKOQwGLZQCkflK+A5T0gJoDy8OPeBopASRDA4cOHg7xw27Ztg42NDdLS0kQSSOvWrTFp0iSR+RsQEICtW7di7dq1IlmjMAIoJYHQeKpJIPSzahIIZQGzB9BADzdvW28IRC1ZiujVq2HTvj08liyGf8tWyIyLg9f+P2Hh5aWc59GAgUg6f178bNupE6osXCCugVPu3cPD7j1gZGkJn9OncK/xa8o+aTVrosGffzAB1NvTMryBmAAa3jPnHesBgZIggPfu3cOAAQPw33//iYxfitsjTT7K/D1+/DhSU1NRvXp1IeOyePFikaVbGAGkrWsrA8MEUA8HhYcwGASyUlIQ9sUXsGnVGva9eop9h02Zgri9v8Nl4kQ4Dx+Gey1bIvPxE3ju2Q1LPz+Fly8rS3j/iBhKZlqpEjITE4W3kEy69r3b+DVkJSSI3yVmZuK1ABGnyx5Agzll+t0oE0D94smjGQgCJUEADQFKxtEQnrJh7DF2xw6Ef/W12Kzf9WswMjND4AcfIPnSZbgvWAC7bm+J69z0sDDU2L4NVvXqKYhcTpKHkbk5XMaOQfS69ciMjVUDzX3RQth17Yp7TZspX2MCyEkgct9ZTADlIsj9DRIBJi76eeyMo35w5FH0hwB55BKOHIFlrVowr1FD64GjN2xEVE6CVrWNG2DdpAn8ibDFxcFz105YvvQS7nfshLRHj1B9y8+wbtRIxP497NkLGZGRsH+vL9xmzEBaSAjuv9FBOW/lmd/A/p13hIf/Ye+3lRnFidnZeO3eXfYAav2EuGFuBJgA8plgBIqAABOXIoCmoQvjqB8ceRT9IZBw4gRCRo4CjIxE3J1pTpWdwmaInDsXTzdtFs0cPvgATsOHIaBVa8DYGL5XLsPY0hIPunVHqr8/iCBWaNoUkji0uacnPHfugLG1tegvZQRb1q0Lzx3blVMnX7+BwP79Yd+zJ6w/nQh7BwcmgIU9GH49XwSYAPLhYASKgAATlyKAxgRQP6DxKHpBIDM+Xki0VGjZUlzPRi1aDOePRyPxxEk8XrJEzFFl+TJU7PDcG1fQxEHDh+PZqecC7FJb8iJ6HzwgfpQ8eFXXrIZNq1YImTABCQcOotLnU+A0cKByeIkAWvj4wGvf72rTktfQxMYGCcnJsLOj8D+OAdTLgXjBg7QCMAlAIwBuAHoB2FPImt4HQMUFfQBQBOlBAJ8BiNZyL0wAtQSKmzECqggwAdTPeWAc9YMjj6I7AlFLlyqrc1i98gqSr16FiYMDbNq3Q9yOnWJAl/Hj4DxyZKGDp9y+LcgdsrPztLXt0AEey5eJ35ModPK//8Jjxfewbd8egf3fR/KVK6iydAkqduqk7Bv4/gdIvnw5DzFUHZxLwZWvGMDOAF4HcAUAnb7CCGALACcBTACwj76sAFgFgNKCqK82xgRQG5S4DSOQCwEmLvo5EoyjfnDkUXRDgDJs773auNBOJk5OqLrie1g1aFBg26DBQ/Ds7FlU7NpVxA9mp6Yq2zuPHi2SO8geffgRki5eRJUli1Gxc2cEvNEB6SEhqP7LFlg3bKjsQ0kgSVeuwqZlC5FMosmYAJYvAqj6jOlrRGEEkDx9owB4q3SkU0YeQUWRz8KNCWDhGHELRiAPAkxc9HMoGEf94Mij6IZAxJw5iNn8U/6dzMxAIsPZ6ekiho8qb1DMniZL/PsMgocOBczM4H1gP9KDgkCEUDKJ7NHPQUOG4tmZM6LaR8Vu3XD35QagcnHeR47A3IN8ONobE0DDJoAkG06y4EQUKcCgEoBtFD8KID+ftQUA+k8yqkYdEhcXh4oViQuyMQKMgDYIMHHRBqXC2zCOhWPELfSLgLiufbsPkJX1fGBTU0HeqNKGmYcHbFq2RFZSEkInTRJxfUTWqiz4Ns9CsjMzxVipd+7AccAAuH7xuWijWr/X6499sKhZU/w+eOQoJJ44AbfZs2D92mu43+FN4eGjJJH8PH357Z4JoGETQDoXfQBsoMowAEwBULQo/S49n0MzA8D03K8xAdTvBwyPVv4RYOKin2fMOOoHRx5FewQiZs9BzE8/wfbNN2FW1QNxu3aj+uZNoISL3PbswgUEfTQApi4uIiM48dQpIcNi37cvTB0cELt7D8K/+ALGtrbw/uuQ+B1ZelSUIgNYRROQ/h0ydhwS/voLladPg4mjE0LHjRPyMCQTo6sxATRsAvgSgCMAKF3pUE7iyAIAFwE89z+rnyr2AOr6LuP2jIAGBJi46OdYMI76wZFH0R6BwH79RcIHXcPade8uKnEYGRtrHCDr2TPcbfSqeK3m0SMIaP+G+LfTiBFweL+/kuRV+uxTONE1sIrR1bBxBWtYv/KK8rehkyYjft8+VJoyBTT2k++/h93bveE+e7b2G8hpyQTQsAkgBTCQ5+8dlZNDiSGUh+4OIFyLE8UxgFqAxE0YgdwIMHHRz5lgHPWDI4+iHQJE9ojQZScn56nHm98IUvUOp+HDEb1mjWhm17Mnkq9fR9r9++LnWhcvwMSWIqoKtohZsxHz88+gsTIiI9TKxBXWN/frTAANmwCSzzgDQF+Vg9EMwNmcjOAwLQ4UE0AtQOImjEB5IoA//PAD6L/AwECxrTp16mDatGno3JmECErWmACWLN6GPlt6aKjCi2dmBr+rV2BkSpFTBVvQ0GF49vffao1s2rYV8YKS1b5DofeF2+OVK/Fk2XJR2SM1IEB4InNLwBQ+iqIFE8DyRQBtyMuc8/CvApiYk+TxlJKHAMzNIXYf5bQh1ci1AMaqXAEvBUCRrU20PERMALUEipsxAqoIlGXism/fPpiYmKBmTmD6pk2bsGDBAly9elWQQV0tLS0N5ubmunYT7csyjkXaMHd6oQhIGbvm3t7w/vMPrdYS9sWXiNu9W60tycKQnh+Zy/jxcB45QquxYn79FRHfzIRN+/ZC/y8zJgY1duyAVV3d33dMAMsXAWyTQ/hyH6RNAIjsbQRAhQmpnWQk+0IZv54AqHr0MQBTAIRqdRoBJoBaAsXNGIHyQgA1PUlHR0dBAs+cOYOoqCj88cfzP44ZGRnw8PDAnDlzMHjwYLRp0wZ169YVpG/z5s2CNJ48SZKkuhsTQN0x4x5FR+Dpli2I/N8sQcBI308bi1q4ENHr1qs1JcFoIm9kftevaZ3BG3/wEELHjxcl3yjL2MjKCrX+OQdjC1VxDm1WxR5AQomketiKjgATwKJjxz0NGAFNxCU7OxvJ6ZkvBBUrMxNRLF5Xy8zMxPbt2zFgwADhAYyNjUWrVq0QHBwMNzcqSAT8/vvv6N+/PyIiImBjYyMI4OXLlzFq1CgMGTIEtG8/Pz9dpxbtmQAWCTbuVEQEpOofDv37o/K0r7UaJfrHDYj6ViEBY//uu4jdRmprCjOxtxcETlt7dv4CggYMUDbXhYjmnoM9gEwAtT13+bVjAigXQe5vkAhoIi5JaRl4aRol5Je83ZrZEdbmhcczSSu7fv06mjVrJggYkbpffvkFXbp0ES+TR48I4eTJpCkP9OrVC/b29tiwgRSnIAggSUcRYZRrTADlImi4/ZNv3sTjxUtQoWULtTq6VOUj6cIF2LRuDSMTEzWAwr76SpR5cxk3Fs6jqI5C4Raz9TdEzCAFNaD6L7/gUf/+yk4Wvr7w2ltYxdbnc6SHhYGSSiSrsX0brOrVK3wRGlowAWQCWKSDo9KJCaBcBLm/QSJQ1gkgxe0FBQUJj9/OnTuxbt06cY370ksvYcmSJVizZg1u374troPp+vfo0aNo2bKlkgD6+Phg7VoKQZZnTADl4WfIvUPGjUfCIcUXLtLgy3j8GFYNGyKgfXtkhClEMCq0boWU/66JpAsqx3avWXNkJSai8v9mwuEdVQGN/JGM27sXYVMUAs9+t28h8L33xJimbm5wnz0LFZpTTQbt7fZLdYQItXWzpqie86VK+97PWzIBZAJYlHOj2ocJoFwEub9BIlBeroClh/fGG2/A29sbq1evRnR0NNzd3XHixAmcO3cOq1atwr1795TPmTyADRo0wNKllHMmz5gAysPPkHs/6NYdqf7+ahC4jB+Hx0u/0wgLVdoQpd0AePywErZt22oFX1ZqKiKmTUOF118XuoHkYXx27hxsXn9dxPLpagnHjyP+z/2iaoipk5Ou3ZXtmQAyASzy4cnpyARQLoLc3yARKG/EpT0FxVetio0bKdcM6Nu3L+zs7AQBpPi/L774ggmgQZ700rHp1Pv3Eb1hA+x79YJ1o0bIiI6Gf+s2QAYpoRVslnXqIOXmTbVG5DE0r1atsK6l+nUmgEwA5R5QJoByEeT+BolAWSaAX375pdD8I8KXkJCArVu3Yt68eTh48CA6dOggnufhw4fx1ltvgZJE6KqYPIKSsQfQII/8C920VEGDFuEycSIyo6PxdBMJZBRuVPEjbDKJYwBOw4aJEnBW9eoW3rGUt2ACyARQ7hFlAigXQe5vkAiUZQJImbsU0xceHi68fPXr18eUKVOU5I8eKGX2enp6ioSQP//8U+0ZMwEsX0eekinSAgJQsVu3fEuivcgd01n0b9UKmY+f5FkG1dGl2rwFWfWff8KjDz4UTXzO/C3r2vVF4pB7biaATADlnkcmgHIR5P4GiUBZJoDaPLCkpCTh9fvxxx/Ru3dvbboUqU15x7FIoJRgp+h16xC1cJGY0fnjj+Ey5pMSnF27qVSrd5i6OCsTPKwaNYJ9r54I/0pdzoWkWTJjSRYXqDxjBux690LQoMEw9/CA+/x52k1aBloxAWQCKPeYMgGUiyD3N0gEyitxycrKEnp/ixYtwo4dO3D//n2YalEuq6iHoLziWFQ8SrrfvSZNkRkXp5y26rp1sGnxekkvo8D54g8fRuiYsbB4qTbsunRRElb3Bd/CrIqHmiwLDWTf7z3RzqxKFZiphC6Uqk3pYTFMAJkAyj1GTADlIsj9DRKB8kpcqD4wXf2S9AslhFBySHFaecWxODHT59h3GzYSFSkks3u7N9xnzxY/pj16hMfLvxdxc5a+tfQ5rU5jSeLNdn3eRuWpUxH57bcwNjdHpc8+A0xN8XT9euHxk6p1VJo8GU6DB+k0R1lszASQCaDcc8sEUC6C3N8gEWDiop/HzjjqB8eijJKdlYU79eoDmZlwHjsGT5YtF7p51VavFsP5t2mLjIgI4Xnz2rWrKFNo3Yfi/FKuXxeZucYVKiB04qdICwmB/dtvI+7335Fy7Rpcp30NRxURZtXBldfEAKos+w4V33xT67nLakMmgEwA5Z5dJoByEeT+BokAExf9PHbGUT84FjQKEb20wECYe3qqlQvMiImBfzOFiLHHiu8R8vEnoKQKz107xe9u+9UW/zeytobflcvFstD4v/5CdnIyUu7dw9P1PwoCSlp7YZ9+lme+Gr9thdXLL2tcR3ZmJu7UUWT2FtSuWDbxggZlAsgEUO7RYwIoF0Hub5AIMHHRz2NnHPPHkbxiyM4uMDOXiE/agwcwr1EDJHSsyaIWLUL02nVwmTABziOGIzstDcnXryPp4iU8XroUJnZ2qPrjegS+3QemLi7wOX1KVNXwb9lKDGf1yiuo8esv+nngADITEhAyZizM3NwQt3u3+rimpoKEksePzPrVV8X/LWrVgutXUwvEImb7dqQHBcNl4oQi1cXW2wZLaCAmgEwA5R41JoByEeT+BokAExf9PHbGUTOOVG3iQffuggxV/f77fMGOWrIU0atXw7J+fZDcCcXGUV8TGxvRJy0oCPff7KjsT1e98Xt/F/F9khHJcl+0CAGtWwMmJvC79h8S/voLoRMmKkkYja0viz94CKHjxxc4nJG5OWoeP1ZuJFv0hZ3qOEwAmQDKPVdMAOUiyP0NEgEmLvp57IyjZhyf/fMPggYqEhk8d++CZW3FdWxue/ThR0i6eFH8murbkkV8PQ2VPvsUTkOHImT8BCQcPJjvw3IaOgROI0bA2MoKd15pCKSno+axo4jfv1+ZbWvh5wevPbk8dTo8/pQ7d4TH0b5PH+GZI02+pEuXChyBEj7cZ83SYRbDa8oEkAmg3FPPBFAugtzfIBFg4qKfx844asYx/sABpQfOoX9/VJ6mrnUn9Qpo/wYoAYJMxMeZmiL5siJez3n0aDxZuRIwMoJ9n7cRu2cvLH19BRGzrFdXkD4LLy/lAu536Squk6uuX4ekf84jeu1a8ZqZhwdqHjlc5AcuxRK6zZ4NIzNTZVUO+/f6wv7tPnj2zzlxtRu1YKFyDs+9tNYXl3lc5M2WYEcmgEwA5R63cksAKX4mi65CbG3lYsT9GYE8CDBx0c+hYBw14/h080+InDNH8aKZGTy3b4Oln59a4+yMDNx5uYHI4pWMMmiznj1TaydJu9BnInng8rPgjz9B4tGjcP3qK6T6+yP2t99EU4oRrHX+nyI9cJrzTu2XRF9K8KAYvbSHD8XPVKKNEj7IstPTFRnJgDIOsUgTGlAnJoBMAOUe93JLAB8vW4Ynq1aj+qaNsG7cWC5O3J8RUEOAiYt+DgTjqBnHqMVLEL1mjfJFuoatunoVjC0tRZzes7//RkZUFCLnzAXFy1V4/XUkHj+ucTBtvWmPly0XHsMKzZvDuII1Eg4fUYxnagq/69eKlFiRHhmliC3MZc6ffALnkSNgpCIyLnkKrZs1RfUNG/RzwMrxKEwAmQDKPd5aEcCYX39F5LcL4D5vHip2LN36SpS99mT1GsT8/LPAhoKjPbcpvsmyMQL6QqAsE5cZM2bgm2++UYPC1dVVVAApaSvLOOoDK/LiPV6xAqYOjrDr3g3p4eEi3i9k3HgkHDoEh48+RNzuPchKSBDTGdvaKv8tzW9RuzYqTRiP4OEjFL8yMRFVMNKDgsSPtS5dVCaFFLTmpCtX81TVkNr7/ntVQT51NIpPpDhFyYwsLeGxfBlsWrbMM5JEAKkmcZUF3+o4k+E1ZwLIBFDuqS+UAGYlJ+MuBQfnWM2TJ2Dm6ip33mLpT4KhEd/MVLsCsXq1EWrkkMFimZQHNUgEyjJxIQJIZd6OHMnx8AjOYAIXF5ciPcu0tDSYm5sXqW9ZxrFIG87VKWLm/xDzi7rEStW1axA8+mORkFFj+3bEbP0VcTvzF2K2f6cPKs+ciXC6ur1zF86ffIyYn37Gs7NnxWx+t29p5b2j61qKw6Or39zXyCQNQxIxupp0lU1fxCs0aQLbN9+EVT2FXl9ukwigJFej61yG1p4JIBNAuWe+UAKYcOw4QkaPVs7jMm4snHhdFUUAACAASURBVEeNkjuv3vsnHD0qhExzW4UWLVBtnSKYmY0R0BcCZZm4EAHcs2cP/v333zxwzJw5E9u3b8f169fVXmvUqBG6du0Ken3gwIGIjY1FkyZNsHz5ckH+qIRcUaws41iU/ar2oRJsdxu9KrT+VM3EwQGZMTFK/b3UBw/xoEsXRRMTExHzZ+HrC5exY/D055/hOmmSkItRNdXs39p3buu0VNIJvFNfXXDZ68B+WHh66jQONQ6bMgVxe3+H85hP4PLxxwX2j925C4knToBq/BbF26jz4sp4ByaATADlHuFCCWD4tOmI3bZNiIxSoC5lmlGpHVMnJ7X4DbkLkdv/4TvvilJCVLaoQuPX8HTTJjGkVaNGqLFFcR3MxgjoCwGNxIX+kKc/r6uqr7m0GsfMWmR7amNEABcsWAA7OztYWFgIIjdnzhx4eXkhJCQE1atXxz///IPGObGz165dQ4MGDRAQECDaEAHcuXMnevXqhSlTpoA8R3XravbqFLYeuQQwIzoaCceOwbZ9e5g6OhY2Xal6naRRAt95V7kmU1dXZERGKn+usngRKuYQP8I4IywMpu7uSAsIgKmbW4HXuiS98rBnLxT1OpVuU5Kv3xB6gLQm8kRq8txlpaUhbudOpD58KASmXT75BKbOzso93O/6FtLu3xfxizYaYgFL1QMpY4thAsgEUO6RLZAA0odOQNt2oh4kaUyRvpRkTsOHo9LECXLn11v/e82ai2/NNbZvE9IGVMT86caNMLazg8/xYzC2thZzUYxNys2bsGnfXqtrEb0tkAcqVwhoJC5pz4A57i9mn1+GAeYVtJr7wIEDSEpKQq1atRAZGYlZs2bhzp07uHnzJpycnNClSxfUqFEDK0lCBMCECROEt/B4TpIBEcCDBw8iKCioyFe/0kLlEsCgwYPx7Ow5MRyVMMvtCdMKkBJqFP71NKSHhcHj++VCguXpli2I/N8sWDdtKmLekm/cQMgoxW0LkUGSXsmvuoc2S8548gQm9vayvqg/6NYNqf4BqLbhR1Ro1izPtJRoR9VEJHMePQouY8eKHzMTn+EefYnIzobP36fViKE26+c2BSPABJAJoNz3SIEEUPoWaWRlhVr/nBPfVlPv3VPOqevVgtzFauqflZKCxGPHRPFwsloXzsOkYkVQcPX9zl2QHhwM1y+/hONHH4rX6XckQ6AqQVAc6+IxyzcCZZkA5n4yz549g7e3NyZPnoyJEydi9+7dGDx4MMLDw0VsYJUqVbBo0SJ8+KHiPUQEMDQ0FIcPF10bTg4BpC9xJFNCkieP3v9AuR36kurwzjul8uCpxlI7DRsqxJcfdO4iSq5Jos1Us/fx0u9A3jf6ci1JpLzIDQX264/kq1dRZfkyVOzQQW0pVL/3Yfce4nfmXl5CQ5CykautXyd+JyWAkLeSvoSz6RcBJoBMAOWeqAIJ4JNVq8QHkk3btqj6w0qETfkccXv3Kuf0PvwXzKtWlbsGWf0j585TXvdShpzvxQvK8WK2bkXEjG/EdUnNQweFXIIUaGzVoAFqbP1V1tzc2XARKMtXwJqeWocOHVCzZk388MMPyMjIgIeHB5YsWSKuiAcNGiTIoHWOF12KAaQ4QrlWmAeQBJGpDqyFt7eYiojUvdeaiHAU+mKanZysXEKlyZPhNFhRPaO0WW5PmbQ+s+rV4PX77zC2sChtSxbrCRo2HM9On4bbnDmw791Lucbk//4TMluS9Ey1jRsRNHCg0Az0IWFnIyNEb9iIqPnzYfNG+wLL2ZXKjZeBRTEBZAIo95gWSAClb3+VZ8yAw3t9Rf3IRwMHISM8XMxbeeY3cHj3eQyL3MXo2j/p8mU1D4BD/36oPO35NXVWaqq4ws58+lRR8Hz9egT26SOmMa1UCT6nTuY7ZWGiqbqulduXLwQKIy5labepqanCAzh8+HBMy3n/UGzf1atXBQF0d3fH6tWrlVsqKQKYcOIEQkYqEs6k24bH36/AE9XauKamqNC8GZ6dOi3aWfj4oMa238QVa2kxVTHk3Guiqhs2r79eWpaaZx0hEyYg4cBBtVuUtOBgcZOCjAzRvtKkSXD88AOR0ELE3PuvQzCvVg3Bo0YLgugyfhycR44stXssqwtjAsgEUO7ZLZAA3mvaDJmxsfDcu0eUEJKM4uuerFiBil06o8rixXLXoHP/tJBQJJ0/j2dn/kb8/gNCKd/v6hWNsS5BI0bg2clTYg6KB8yKixP/pky7WucUMgm5LXr9ekSvWQv3xYvEhzNlQhtZmJfqD2qdQeQOshAoywTws88+Q7du3VCtWjVERUWJGMCTJ0+KzF9KACHz9/dH7Zz6s2fOnBGJIpKVBAGk8mZU5kwyqkQRu2MnohYsUHtulORgVrmysmwZvVht8yZUeO01Wc9Xn50zYmLg36x5niFLq6KC6kIpbjF2+3aorlW6WRHtzMzgtWunIN4P3+2LlGvXFJ+1KhVJvP7YB4uaNfUJKY8FgAkgE0C5bwQlAbS1tkbytWsifo7erKLMUN16YvzcAbxUyJsKehOJ8jnzt6jjKFkayUGYmuLpxk2CpJm6u8Fj+XIY66ATRsHD2elpMHVwEMNSpp8IZiYJBACB7/VDsoqEhfuihbDr2lUjFpHz5otkkNxG18G+//2rMRFEuiamPqRbRZlwZLUuXYKJTQWQfAPFQhpXrAhzT09OJpF7Cstg/7JMAN977z2cOnUKT548Edp/TZs2xf/+9z+8lEtKpFWrVoiOjhbJIaqmdwL44AEsN22GhbExKk2eJD6DAjp0QEaY4qahIHP9+itkPUvCY5UvouQRpC+m9JlRGizpyhU86v++WArFKdq+8YYgShVatSr1nx2R87/F0w0b4Dh4MFwnTxJ7CJ04UXzxdhwyGE6DBimTO+L370fop5+pydqYODuj1t8K7yybfhFgAsgEUO6JEgQwNjoaseMnIOnCBRhZWIBi+4jU+bdoKaQlRBkglZI9lO5/t2kzZCclwXPPbmWNysTTpxE8YiSQlaW2LtepU8UVgTaWnZmJh73fFgXO6SqBMtko0NimTRtUXfWDyOKla13JiMhRO/ICaLKEI0cQ8skYja/5nDurJJlSA7o2vkv1NTUYZcKZODkhaPAQZD55Ilo4DhgA1y8+12Zr3KYcIVCWCaA2j4GuLf38/DBixAiRGFJcRjg+uHsP2ePHwzgntKSwuehG4mGPnqIZyYtQZi0JwOc2206d4PbNDBH+8SItds8ehH/+BcpiiTOqUvJk+fewf/dduE79Ukht0Zd/suo/bc5TZjM9MlIkgwQNGizamFWrhpp/HXqR8JfbuZkAMgGUe7gFAbxQ0wc2Od41GrDyjOmweqUhHvboIb5FUwZwbgsaPlzE3agGXodOnoz43/flaUukqebhv5RSLAUtWpWwefywUgQgx/yiSNagmr6UWUZGyvJuM6YDxsZ5iqSrjk9/yOgDjGpckhFhJAJLRhqBTkMGw7adglAS+aREl/g//oCJizOsGzYS5ZgkI4V6UsmnPziSCU/iv1fVvKBirKwspN65I7yp1EayxytXIjslFS4Txuv12z/NF7drF6xfe03E37AVLwLlmQDStfBPP/2E6dOnIzg4GA45nvjiQJRwvH/7NjDx0zwEkMqGkaRI1LfPy4L53bwhbgIoTIO88G6zZyNu3x8I/+ILjctzX7gQdm9pvh0ojv1oGpNKUz5esgR2PXvCfd7ckppWL/M83bxZ1BumK960oCBkp6Yqx/W99l++NzvKZDvWYdXLc9A0CBNAJoByD5caATRxdBQJExS/QYkfYZMmwdzbG95//pFnHinDi16Qak0Gf/wJEo8ehfWrr8K6eTM4DR6MB926CykWKslGBb4L07WiupESyaPg4oyoSDzdtDnP/LadO8FjyRKt9k+ByRRPRBmEVdesFkXO6VqD9KloPbUuXhDK8xGzZitqCJuaCq0ui5o+QoFfIozm1auLRBhjGxt47f9TEaOUno6aR4+I2puqJn3rt6xbF84fjxbfnCleiaQfyBw+/BBGxkZwGjkyjxdSq03lakRiuCFUPoqu7DV4NosyJvfJH4HyTAApg9PZ2Rnfffcd+vfvr5djQF+uhC6dnZ14r5GAMMkxpdvYIig8DJg0GbZeXnh25oyYj2RFvPb9LshezG/bEDF9upBOoZq3uY0qSIRPnapxnW5z58K+l8Jb+KIs4n+zELNlS77rf1Hr0mbe/LAtKOyGxk25fRtRCxeh0qcTS7U2ozYYlNY2TADLFwFsBYCCLBoBcANAOfeF6SyQdgClvdL9Kt2BhgCYDeBHLQ+tkgB69OsnsrUe9esvSI5k+V1bpAYE4MFb3UQzt9mzYP/225BEWamUj103xWtPf/oZkbNpSUCFVi2FHICqR0x1nZLsjPQ7u7d7C3IUvW59nu3U+G2rqEqirWXGx4umFF9ERl48Wj/F83n9+QeI/Po3f12QwipLFqNi586iHanh07qI2EomiWBLKveUXGL9yiuwbtoEyVeuwnXKZDxetkyUQCrMSJC66orv822WmZgoMuukeMj8Gj754Qc8/m6Z4mVTU1RZuAAVO3UqbHp+vYgIlGcCWERICuyWHhEhCCAZybqQaDtp4KVmZSEkORlGn38Bx5YtYd/nbVCWae6YXvpMMnN31/gFkt4jFJeWERGpplNKc5UGbcCQMWPEl07XaV/DUU+EujiekaYx4w/9hdBx49ReIuHqamvXFPplvqTWaKjzMAEsXwSQGAfpAVwBsFNLAkiifK4AvgIQQBn59OcfgOb01rzvlDxZwCl37+Fh796i3iQZBVk7vq8IYM5t915vgczoaKWQaWDf90D6UB4rvhelmcgoAy6gTVvl1QFdL9u0aydiCnOXbpLKuUnzUDC3ha+fwltH8XZDBou6l/qSaHnQoydS794VcURpQcGCqFKNTa+96rxb9Vqa/ghRVhtVFgkZMxYJGsRwSWKGrs5VRbPz+5Aibyt5IFUTaaS2FE/zoEtX4bn03L0blr618v2si1q4UI0oV2jeHNV+zEucDfXDUt/7ZgKoG6JUKizr2TPRiTTv6EtTRlSUIIBBJNP0zUxU6t0bLmPy1vPWdqbMhAQRG0gJbBZ+viJEpfL0aXDo10/bIfTeLj0qSsQ0U8ywx8qVsG3XVu9zFOeAz86eFTHPkpUGj2px7rcsjc0EsHwRQNWzR9XBC/MAkntnKwAvcrQV8eBqlIGhOLUny5aLLNeax47mW3MyYs4cxGz+CU7DhglXP133kkJ/7rJBdP1DcXxEsIgYUbwaER8KDla9EvansnPh4YJQ0vUBZZDZtG6FuJ27xPYqTZkCp0EDi7jVvN2kK2squ0RyNxTfUunzKXAaqD4HeQEDcyoMUFyibVvFh3js7j35xh5Js7l+9RUi584VuoMey75DZly8mIv25d+yFbJTUsR1srmHBx6vWAnLunWUivsxv/6qDG4vzHsQOmky4vftE3FGcXv2gOKnfC9dlFUGSm9Al8OBmADq9lDTQkLEuc9tggA+fgyTWbPhMWG87OoX5A2kPwsR074WmaqqVYB0W7G81vQlNfJ//1PGL9OVtufOHaVKn1CbHZIyROC7fRVNzcxQ8+CBPOEu2ozDbfSPABNAwyaAlNVALqFLACgti75e053j13RzqeVx00gA6Rs0xaxY1K5doJ6WaoaY28xvREwcZe9qup4lLxa9TjGGkqkSRSGWWv9lEVNHOl5BHw3IswXfK5e1SiTRcu9q19PUhzyTFPuX2xsnkkMmT4F59WrKOpfUnogsxSda1a+HoCFDBZlTM1NT+P33ryimTmTaxMZG7eVHHw0QmdeuX34hvCHSVbff7VsiQUQiqNTJcdAgcbWsyaSSS/Qalbgj7S4is6WhUou2z6KstWMCqNsTo2vdzBwNTtWeqgTQa9l3sKqnkJ6Sa1JCGsURU6JXSZtURlOa1/vQQVAMcVkz8txKccuUYFZ986aytoVyu14mgIZNAA8CaAPgCADSQHAGQKSQii7m94lHMYOqNYdsKW4wLi4OFXNi43R5t0jxfSS34LF0Ce41ay5ieyh4m7LGcpskIC393rpJE1TbuEGQHVWxVN/Ll4SqvKpVWbpE7zFtRDojZs4UArNOQ4fAZfToIse1POjdG6m3bufZc0H1kp9u/gmRc+aIpBmKRUy5dUv09zl9SnhKSYhbujajuD5KNiH1/YSjx0RlFimj+X6nziKmkeIYPXdsF+Wb0u7fF1fAdBXMpn8EmADqhmlqYCCyEhNFDK4Uj0sjqBJAv32/53vboNtsQNiXU0VWPGXuO48Yrmv3IrcnjdSQjz9RI7uU8FV56pdFHvNFdqQEOPHFnGK4mzdDtR+1DS9/kas2jLmZABo2ASR14pY5yR+K8hZAbwA76L2ajxdwBoDpud8eRSWAVLScPGPSB8OdlxsIz5OmrFiaU7W0k7QGKeFCxB6qyM6o1R02MxNl2wpLhCjq254+5PJLTNF2TKlkErWn+p7pj4KER7HqyhX5DpFb01BqSJnKuQvd02u2HTsKjS26ZpcyImN37ED4V18LUW7vA/sFcSQtxsSTJ1H5m2/g0PfFlerTFruy2I4JoPZPjTzl9IWENDZJoijj6VNBBo1MTJGSnqa8Aq5znL676sfCp01H7LZtcB7zCVw+VmTHF4fFHz6MlGvXhazTk5U/qJepy0l8E0L4pbTWrzaYSJIuFV5/HdXWr9OmC7cpAQSYABo2ASRfPCWNqNbYqQ2A3Eh0Neyv4Qzq1QMoETqSQPE+eAB36tUXU+YnQ5L64KGQVSGzrFdPSKOI4uHnzoosOco2o997bt+GhOPHETJqtGhr26EDPJbnZLiWwBurKFPE7tqN8C+/FMSNqqPE7dkriHFhmnyqpeqkee3Ju2dqJiRpKnbpAgufmiLDlxJPyFNIZmxri1oXzuP+mx2FzI5qfGTk3Hl4umkTHPr3R+VpXwvCGLd3r/iZkljY5CPABLBwDAXxCwoSlTqQrRCHt/D2FvGplGRGiWCx164VCwGMmEnxd7/AadRIVMqVxVrQyum9QmL49IWQ6glrEpGmrHy64iWJpzu1XxLDuc2bK/RGKQSGjG4sqG+FZs0KB6qUtyAVhCerVgvhZ31d0ZfyLZeJ5TEBNGwCSPcaS3MyfynymawHAMqYoGAzbeIAC6wFXNi7ID0yCgFvKLTwPFauUOrQ5ScQqnqd4Ll3r/D4CYLXsSNMXSuJhBJJLDX55k0Evt1HvE5jS2LNha3pRb6ecPSoIGa61CElaQxRcYVC162skJ2s/tg8Vv2ACo0b4+6rjdVKLFH7Gtu3IfAdhYdPNT5SlGSa+Cks69QRHpCQkaNEGxLkprJ+dOXOJg8BJoCF45cRG4v0EFKmgiB75KWmZCjV8xd//z4CAwNhvW07aq5eVfigWragxCuKz3UaNhSVPv1Uq15UcpKqDEm6n0RUKZzFvGpVtf5R332H6B9WCVmXyJn/e/4alcTMykL1n38SYR3lySguXLUaVHnaW1ndCxPA8kUAibRJ3ryrAKj+0vGcDN8gACQhT2rDH+UcWGpPQWf/5FzrUgwg+edPAhim5aGWRQBpDkn7z2X8eDxeulRo0InScfmQDCoXl5WUjIod34R/6zYiQULVKk36DE5DhojYt4A3OogPHbpSlntFqyUeL6RZ8vXrIgHE5ZOP8fDtPso/QLQYKYbw/ltvIS3gvtr67Pq8jbgdOwXp9L14QfkaxQMGtGsvnoUQ3RWZkc+NAuNtO5AwdkqB0jIvBIwyMmlZJoA1atTAIxWtTwny0aNHY8WK/EMWdH00qY8eISshASa2tqIkmKbPhKSEBDy4dQvV3dxgq8cKNpELFuDp+h/hOHAgXD+fkmfppEGYmZAICy9P5WsJx44jZLTi1kEy508+Ee9LVVOtFZ5nYDMz+F25XORYYl0x5vaGiwATwPJFACmhgwhfbqOrXtIl2UhOn5zED6mNH4DlOVfB0QC25WgCauP9ozFkE8Cwz78QsiN2vXuLoGvKdvW9cF6rdyWJu97vqBArJhJDV71EAKVYP4oVoozc0lLUXatNyWz0aMBAJJ1/jp9EACWcaXhTdzdkhIUrZzKrWlWU2pOMklsCiFxHReW7GnENR984jhxWFnOXuXSD6l6WCeBjIj85Op/00G7cuIEOHTrg+PHjaNOGPoZ0s7S0NJirlDuk3pQ5n3L7Dv1LJITlFwNXXDhGLVmK6NWr4fDBB6j8laJKCCkRpD54IBJR6ItWVnw8VAmepGpg4ecHx48+EiEdoiLJn38oyWvKvXuiNnl+RtV+qix4XrpONyS5NSOgPQJMAMsXAdT+yeuvpWwCGLVoEaLXrhOl3pIvXYZp5crwOaGJx+ZdNMUI3XmpjnihytKlqNipo/52VkZHUpVdsGrYEDV+2SJ28vTnLYicNUv8m8S0I2Z8o9whxSJR9q+qhX42SdQ0lsxz9y5QYDzFXapalcWLRJwhm24IFBdx0W0V+mk9fvx4/PHHH/D398eQIUNAtYDpZ8kyMjLg4eGBOXPmYPDgwYIk1q1bV5C+zZs3o06dOjh5ki4enpsgW/fvi0QPy9r0PVWzFReOkuIAxdO6zZgBEmQOaNVaK8BIO9CuV0/4v95CeOOrbdyICk2biL4SscxvoFrn/9EYN6jVxNyIEdABASaATAB1OC4am8omgJRsQEkHpi4uorQTfWP23v+n1usiMeW0B/eFXIOmahhaD1SOGlKiR8yvW2HXvZvAlSz5338R+J6iooHn73sRPGSowJusQosWqLZurRoCqt5VeoE8ieQZ9G/VCpmPFSW5yOz7vQe36XkSw8sRmsWzFU3EhfBNztDW+a7fdVmZWhUptpO8d+7u7pg4cSK+/PJLnD17Fq1atUJwcDDc3KgiJfD777+LmsARERGwsbERBPDy5csYNWqUIIy0bz8/dZInxf9R4pKFF2nVa7biIoBSWUm7Hj3gNneOqBBCCR6qRlV/qBJQbvPcsxuWfn4Inz4Dsb/9Brse3eE+f75oRnqfVK+YKowknv4biceOibhGKgNJAvKWLymSQtgYgeJGgAkgE0C5Z0w2AYw/eAih458XaNfkjZK7SO4PZKWk4G7DRiIWkrwMJAfzsBep/gAVu3ZFlUUL88AkeUFU6w3H/fknwj79TNnWvKY3vP/4Q2/l9QzlWWkiLknpSWjyi8JTVNJ2vv95WJtZ6zzttm3bBLkLCgoSRJCMPHoDBgzA5MkK4fFevXrB3t4eG3JKMhIBJOmoq1cpVDmvkdwLfQEh7xklfphXodBlzVZcBDB63TpRTYiMJJPoOlgymzZtYOLsBLdp0xA+c6aIoyUjHU0SOyavOH0ZJSklklQy9/QUEkviC1TTZkLjr8b27TCvVhV0bWzb/g1UaPKazthzB0ZADgJMAJkAyjk/1Fc2AaQPQ8piJWkEMlaLl/tI8u9PtYHpyJu5VgLVPb3XWPFHJz8vHv3BenbmLCz9fNXi/OhqjjwzlPEonlnjxkgNCBDXyCTpw1Y4AuWFAHbs2FFc5e7bt0+56SVLlmDNmjW4ffu2uA6m69+jR4+iZUtFtjoRQB8fH6xdq+51lgagODvyYlOZR/MaNQrUwCsuAijdTGh6kjVPnhTvIcnos4veK8a54hgpBpmugZGdjYpvvQXn0aNEbW4qiUZi9bnbF35quAUjoD8EmAAyAZR7mmQTQFqAaskym9atUVWPcg5yN1ie+z/o2Uvojnnu2plHqkKbfUu1m6W2rlOnwvHDD7TpavBtysMVMGUCe3l5YdeuXeiRI8lEDzY6Olp4A4/s24dzZ85g3S+/4J7K9SkRwAYNGmApZf1rsJTbt0USCGn+kZZeQVZsBHDLFkT+TxEzm9uESoGZmVZnOPrHDaA4Z9ItJE9g2sOHsHipNrx2KeqTszECLwoBJoBMAOWePb0QwPgDBxA6gVRrgIpdOqPK4sVy18X9tUCApHLous3U0VGL1nmbSAHtlGWdGRsL286d4LFkSZHGMrROxUVcioojJTlQVivJrWjrmZoxYwZWr14t4v1MTU3Vpn73nXdgk52NC//9h/f69MFXc0mFSmEFEUDypKXcvCnaURxdYdpxxYVjzG/bEJFPbGtB5Rk14R+3bx/CJj2vw23/Th+4/U9F/6+oD437MQIyEGACyARQxvFR8DWAwnmKVgtYmpwy/uiqhK59SJvOPSdbVe7iuH/xIkDiruTRIEHv4KFDdU7goWoIiSdOwmnwoHKt06jpKRQXcSnKE6f4ULrCl4y0H03d3GFSIf+YwKysLHh6eqJfv36YN29enmkP7tiBHv37IzMrC/6nT8NTpaJFgQQwI0NUyRAEsE6dQhNTigvH2J27ED5VIf+iakVJeiJSS/V9KeGDjLLwHd57ryiPivswAnpDgAkgE0C5h0kvBJAWETp5MuJ/3wfHIYPhOmmS3HVx/xJEID0iAgFt2gImJvC7ekUrMqcag+g+fx4o29KQrLiIS1EwpJhO+hKmasZW1rDwzj/79q+//gLF/929exe1alHlSHVLefgQvi1aoLa3N/asXQtLX19lAyKAL7/8MpbMmyfKuqkKPEtk1MjEBJa1qTJlwVZcOEqlGWl2urJNvXUbzqNHw2XsmMKWpPH1tOBgkUlMX3KpOghpG7IxAi8SASaATADlnj+9EUC6ghLK+x99yIkEcp9KCfcnD8e9VxuL6itUos/U2UlIzlC1lkqfPc8YVl0WVXQJHkbVCAH7vn3h9s2MEl71i52uuIhLUXaVfOuWKEGmRgAtLWFRU7VMeMEjkzdYlEAzNQWRt6dXr8K7XTv8MHMmer7xhpA3UZVpoixf+hJg5uEBU3t7kURBlhkdDfpCYWRmrlWVmeLCUVU3s9ali0g4cgQV33xTJD8V1SgJKz00DNYNXynqENyPEdAbAkwAmQDKPUx6I4ByF8L9XywCjwYOQtI//wh9s+yMTETOni0W5HfzhiAEZCR5zgk1UQAAIABJREFUkXjsOKr9uB6xO3YiasEC8XurBg1QY+uvL3YDJTx7cRGXomxDmXTh5Y2Mp9EinpOSHFS9dgWNm5mYiPSgIJAwO10NRzx5gmWbNmH34SO4efAATI2N81TzSL5xQwxJhIoq0aQHBgJGRoJE0jgkV2SpwbOYex3FheOTVasVpSlVyikWBVvuwwiUVgSYADIBlHs2mQDKRbCc9JfKYJHchdXLLysJIBE7Inh0xXj3lYZitySMm3TlKtKDg8XPJs7OqPX36XKChHbbKC7iot3sz1sR2UohD2BO0gX9X4rBM6/hCWNrq0IF1lP8/ZGdmirGeBQaitqdOqGKqyvWLV2Kto0aiUQj8+rVRU1fMvIWSnNQWTW6Bs5ddtDMzQ2mTk6Fbqe4cIxauFDU12YCWOgj4AZlFAEmgEwA5R5dJoByESwn/RNOnEDIyFHC02PTvh2iVymEc0kjsNrmTUg8fhwhoz/Od7e+/14FJR8YihUXcdEVv6y0NKTeuye8b+Ka1sgIqQH3kZWiiAkkgmZerVq+w4qsXSKQ2dlCtiUjWuFBJDOvWlX8W1z1qhC6tNBQZMbEiDaUgU5jSD9LE+W+Ms5vAcWFY/L16wh8512Ye3vD+8/nZe10xZfbMwKlFQEmgEwA5Z5NJoByESwn/dPDwhDQrr2IASMpH0rokYwqIySeOYO4nc+1zyx8aqJCi5aI3bZNxA567f+zwJJf5QQm5TaKi7joihNd36YFBqpduWbGxyMtKEgMVdhVcG4CSbGERPiISBpXrIiMyEhkPHki6tsSISRLvkmEURFzaOrsLDyEWQkJgoQSkSTpF5KA0caKE0eKU6QybYVpEWqzTm7DCJQ2BJgAMgGUeyaZAMpFsJz0Vy1zReW7yKNj4uKsVjdY2qpdr15wnztH/Pigew/hgaq6dg1scipFyIGErhfj9uxBhZYtYebqKmeoYu1bnMRFl4VTtQoi73Q9S9e0kuUmdkTSM6Iew6yKu1pljsxnz4QUUH4xe3T1T1nGwsPo6yvInRRzKAigo6PIjKXsX+ExTEyEcYUKIjFEGystOGqzVm7DCJQmBJgAMgGUex6ZAMpFsBz1p7qnVP9UMsrujf3tN7Udeh/+C2aVKysrKQSPGi2uhyvPmAGH9/rKRiNq8RJEr1kDy/r14blNfW7Zg+txgNJCXNLDw8W1LcXb0TWtZGqxgbVrK2L2cjJ1SZ5FSuzJiI1FekiIIG0Wnp4aEZKulOm5UztBCHOMviyQ94+IuzaVP3JPUFpw1OPR4KEYgRJBgAkgE0C5B40JoFwEy1H/J6vX4LFKJRC3uXMR/sUXyh2aurvBJ0cMV/plxKzZiPn5ZzgNG4ZKnyqqwcix2/XqAzl1pXWt2CBnXl37liRxIQ8bXc2rVvigUmsZjx+L61kySY5FdR/K7GAfH6SqlHKjNkTkKDaQPL0k26J6xZsbC8nLSDGeRlZWavF+1I/qgZNZ+PrCWMsSa9IcJYmjrs+Y2zMCpRkBJoBMAOWeTyaAchEsR/2TLl7Eow8/Uu7Ia/9+POjSRflz9S0/w7pRI7UdR2/YiKj581GxSxdQrGBRjLxVj5d+J4hF7PbtyiF8zp2FqYNDUYYs9j4lRVykK1raEJXsM6tSRcTnpYWEKJM1SJ+PyJfk1VOSq5zsXvMaNUTN6OwcYi29TmNR9i+RyNweRFUAldfJ9MucOD+J+JHgdFZykmiuTeWP3A+mpHAs9gPBEzACJYwAE0AmgHKPHBNAuQiWo/4Ux3W3wXORW79bNxE8dBgyYmNQY+tWjTVm4w/9hdBx44R0TI3ftuqEBhE/unJ+unkzks79k6ev65dfwPGj54RUp8GLuXFJEZeMJySsHK7cjSTHohqHZ+LoCHN39zw7puoV5J0zdXERAs2Et6oZ29gIiRhKGqF4S2qnyVSvkwUHNLeAqYuzIJUUE0jXv7okfqjOUVI4FvNx4OEZgRJHgAkgE0C5h44JoFwEy1n/237Py3dpcwWbfOMmAvv0EQkjtU7rpgUYv38/Qid+mgdBhw8+ENfKVg0bosYvW0olwiVFXOh6VrrmlYCgGD7VmD4LLy+NFS4y6HqXSJqZmdL7R9m5dH2c+0pY0xWyGlG7dUtJIIWsTHY2iGBKRtfDulQekfqVFI6l8hDxokoNAqIaUsw9eNl5wczErNSsS1pIdHI0spENZytn5dqYADIBlHtQmQDKRbCc9X+6ZQui5s1Hle+WwrZdu0J3RyTDv1lz0U5XLcDwadOFjIxl3boik5Q8SY7v94ftG28goP0bYsyKXbvCbfasAjUGKRYu6epV2HbooFaXttDFy2hQEsRFaPTdvJlnlZTsQckfZAURN7ryTbl7V9mfMn1J5/H06dOYN20art66hYjHj7Ft7Vr0GTRIeYVM837zzTdYs2YNYmJi0KRJEyyZPAV+1aoqPX2qUjM0AXkTLWrU0BnRksBR50VxB4NB4ODDgzgbdhb+Mf64EX0DtR1r47e3fiu2zxGax9LEElUrKiSVtLHUzFR03NERyRnJWPvmWlSxqYLIpEhsuboFczoINQY7APHajFXe2hiVtw2V8H6YAJYw4GVhOvIQ5Y4ny2/d4ptzo1cFgaOYQQsvzZmkqv3JoxU2eTKenT0nfl1l2XeiTquqRa9fj6hFi0WNW+ePP4bLmE+ENyt2zx449O+vFhtIcYsUv+jy6UQ4DxtWIhCXBHGRNP5yb4jEnYmAUQaueZUqBe439eFDodNIsXvCU2hlhQMHDuDUgQOo7+WF/hMmYPfu3ejZs6dynPnz52P27NnYuHEjatWqhVmzZuHUyZO4fvwE7Ku4C8mZ3Guj+ERzD49815KWlgZzc/M8r5cEjiVyIHiSMofAubBzGH5YUc9c1fb33o/d/rvRtmpb1HOpp5d9BccHY+vdrdh8azNcrV1x5J0jWo9LBHXE4RF52mcmZ+L2qNtMALVGkhvmRoAJIJ8J2Qg86NZdXClWXbcONi1ez/tH/vZtQTwoGYG8fEFDhiLp/HllO5KWkUSGVTvH7tyJ8KlfwcTJCT4nT4DmIc06KkXnPn++sqnqtbXjgI9QacqUQsufyd10SRAXSaKF1kpJGiT3QmZkbILsrEwhx0NCzAUZJXAIIWd7e5hYWyubEsnPjImFmYuzGgEkQu/u7o7x48djypQpon1qaipcXV1BxHDEiBFo164davv4YOGYMcrxKA+4eqNGglzS6zVq1MDQoUMREBCgHH/Tpk15z0ZKCh4+fAhPT09YGlAlGbnnj/vLQyAqKQo99/REQnqCGKiRayNcjrws/t2pRiccDDwo/n2+/3lYmz1/3+g665PkJ+j3Zz9EPItQ63r5g8swN1H/QjTrn1k4FXIKmzptgpuNG0ISQmBrbotJJyfhXLjiy7KqMQHkK2Bdz2Pu9kwA5SLI/RE8chQST5xA5W++gUPfd9UQSX3wEA+6dwcyM1F17Vqk3Q9A5Nx5am38bt7Q6HGkK0z/1m2Q+fSpuAYmMkhmbGcH3/OKpBEiLHdqv6Q2HpFAVxX5muJ4RJoIIK0lO1lRgq0oJkqqxccLskySLxnRT5EeGQET24ow86giBLeJuElGhFoidSTPQtnBuhr1UfUAPnjwAN7e3rhy5QpeeeV5QlCPHj1gb28PInG//PILPvnkEzw4cgQWOV69VXv3Ytm6daD+NCYRQLo+/vrrr5XexZo1a+ZZXkkQaV0x4fblG4HYlFgMPDgQ9+MUepa9fXrj66ZfY8LxCTgRckJt8182+RL9/PoVGZBfbv+CuRfm5ul/qu8pOFg+VzhIyUhB4y2NRTtTY1N8+NKH2HBjg7KfqZEptr61FX329VH+rl2ldljWZRn9zFfARX5Cht2RCaBhP3+97D7if7MQs2WLuJqtPO1rtTFjtm5FxIxvFB9sOZmmKTduCD05iSwVlGwi6QzmXihJxKSHhCIt8CHCJk3Os4+ax4+pCSPrZaMqg2giLnQNfrehukyOvufNbzzfK5c1JoIUNn9uAnj27Fm8/vrrCA0NFZ5AyYYPH45Hjx7h0KFDwiNIry2bPh29c+JEm/Xrh159+mD69OmiCxFAIpBELgsyJoCFPSF+Xd8ILL28FOtvrEcl60rY2Gkjqtoq4vF2+e/C9LOK86tqQ+sNxccNPhbErCCLT4vHmKNj0NKjJagPGf1MpNLJ0glbum5Br729RCwfXTNL81K7BRcXiOvh/KxD9Q5Y3GYxPj76sfAStvFog9mNZ8POjrgfE0B9nxFDGY8JoKE86WLcZ8z27Yj4epogdT6nT8HExkY5W9jUqWo1hKUXamz9FXF//AmbNm00XhtL7Z6dv4CgAQO0Wr1FrVpCHJn0BKuuWQ2bVq206leURuWdAIaFhcFNpbLIsGHDEBwcjIMHFVdj48aNw51r17Bn+XL8d+cOmr/7rrjKrZ5Tjo4IIPWZOnVqgfAyASzK6eM+hMDJ4JP4+szXaOreFN+2+lYJSlZ2lrhydavgptErTiQsIDYA81rOQ1evrmpgBsYFimSQoPgg7Lu/DyGJIeL1iY0mYlDdQQUCT3GD085OE212d9+N6hWro8XWFkjKSMK2t7ahtlNttN3WFnQtvL3bdvg5+ol1Lr+6HL/f/130G15/OOwt7PHtxef7mdx4MnrW7Cmug5+mPMWNJzfwquuryEjOYALIbwVZCDABlAUfdyYE6Ko2oF17Qb5yE69HAwaKeD/7fu8h9tfnOoH5XfvmRpSSDe69qrgaMa/pjcwn0UoBZPodCRLb9e4tytCRRl7IhAlIOHBQSJ/4Xb9WbA+oOK6AU4OCkJWYmGfNItbP0VH8nq6JNV31luQVMK3j+vXraNCgAe4cOoQlGzbgXlgYjhw/rlw7EUCKI6T/CjImgMV2RMvVwHTuH8Y9FF4zSaZl5JGROBN6Ruzzp84/ISk9CY3dGmPssbH4O/RvrHpjFV6voh6TTISrw44OMIIR6BrW3rLgmtV0Dbv48mIhD7O3594CMc3txfN18MXdmLtwtHTE8XePw9jIGN12d0NgfKDwPFLcIcX9/XZXUfKytUdrLG+3XLy/621SJJ/Q9TNdQ2syloHhGEC5b3ImgHIR5P4CgbAvvkTc7t1wGj4clSZOUKIS0LEj0h8FofpPmxE0bDiyU1LEa9poDEqDPHy3L1KuXUP1n38SkjEkXpx4+jQyY+Ng16unWsLH059+RuTs2aJrzRPHRaJEcVhxEBdKpMlKTc21XCNY1PQuUAZHzv5yXwFLSSATJkzA5MmKq3XK4K1UqZIyCUSar8lrr6F9o0ZYs3Urvlu4EO8PGcIEUM7D4L75IkBesjXX1sDGzAajG4xGE7cmGHhgoDKJQ+pYx6kObkY/l06inxPTEzGu4TjQNeqegD3Ca1jfub64ki3M6Fq3xa8thAYfXdsefnQYNe1rokWVFoLQSUZzDvtrGBLSFEklqtbFswvmt1Ikrb33x3tifSvar0Arj1bo+0df3Iq+hc9e/Qzv135fec1McjG7A3aLq+cKZhU0LpMJIBPAws5vYa8zASwMIX5dKwRid+5C+NSpsGrUCDW2/Cz6UA1Z/+aKb+CU6ZsRFSWEnylBo2KnjlqNK8Z58kSMZVmrVqF9KMv4Tl3Ft2dN8jKFDqBlA30TQFFt4/ZtIbBsZGEBUwdHZGeki7g+kn3RpyUmJorsXDKK01u8eDHatm0LR0dHVKtWTRC9uXPnYsOGDfDx8cGcOXNw4sQJ3L17F7a2tsqlrF27ViSDWFtaIiw0FFYqV//sAdTnEyvese4+vStEkCn7tTSKID9Lf4bWv7UG6eEV1axMrcQ17I57O7Dp1iZ8UPsDTHlNkeVemElXxhTHF52iyMT/tNGnGFh3oPj37ejbGPrXUBBZfKXSKyK28FDgIeWws16fhR41e4ifhx4aivMR5zG/5Xw0c2+GdtvbISMrAwd6H4CHbf4ySprWyASQCWBhZ7ew15kAFoYQv64VAmlBQbj/ZkfAzAy1zvwtSEvYlM8Rt1dxbeL7378wtrDQaiy5jcI+/wJxe/bAZfx4OI/Mq59F46dHRiJ+3z6YubuLOsa6mr4JIJXhSw0IEN5Mi9q1i5TRq+0eiMwR4cttAwYMENp/khD06tWrlULQK1asQN26ddW6EJEkeRjqt3LlSrXXmABq+zRebLsf/vsBK/9VPLtaDrXwfbvvhQQJGXmzKO6sOC09M10xvBFw88lNsQYia4ceHcKD2Afo7t0dd57ewYQTE+Bh4yFEkIlAkTVza4bm7s2x6HLBNchVJV6kvVDW77u+6ooF+e1zyqkp2P9wv9rL5NWb+fpMXIq4hCmnpyAuNQ4vu7yM1R1WC88gJZMceHhA9Dn6zlFBCsnGHRuHY8HHMK3ZNFDmL8X6FVV8mgkgE0C5700mgHIR5P5KBB5064ZU/wC4zZ0L+149RVxgeliYqBLhe+liiSFFMjNPN22C07ChsH71VZAUjePAAYJUUbwiiSIHtG0nYhbJqixepDMJ1BcBJLJFlnr3rtBIJAkYC2/vEsNKzkSUFEJE7+LFi2jYsGGRhtIXjkWavJR3ong1ImD5XQHqY/ldd3VFUEKQcqi3fd7GjOYzcDHiIoYcGoJqFasJUljDTvcqL/mtLy0zDfMvzIedhR32BuxFalYqHCwcRGwciS8TYVt4aaHoTpm3RJCuP7kupFEG1x0s4uZcrFwwodEE0Fh0jUqZtTGpMaIPJWsQIaOsXiJa5sbm+OqMQkJKsh87/ojGlRWxxYXZsivLsPb6WrVmDSs1FM/mZMhJ8Xu6UibyZ2OuSICjRBSKCaQ9jnx5pLLvjLMzsNN/J0bUH4GwxDDse7APnzT4BCNe1vxFtaC1MQFkAljY2S3sdSaAhSHEr2uNwOOVK/Fk2XJUaNkSbrNmIaB1a8DYGLX+Oaf3a8yCFvX4+xV48v33sGnbFok5iQmeu3YKXb3QceNgbGuLjMhI5RBGlpaotn4drBtpL+GiD+KSFhKKrMQEmDg6ISNKsR6qskHJLKXZ0tPTER4ejs8//1xIw5w5owjEL4rpA8eizFva+zxOeozOuzqL2q9UmoyIRFGNsk7/CvwLb9Z4U4xHV46UnFDNthqa/6oo4zi+4XgsvbJUZKZShqqqZ7Cvb1981VSdQOmyFqpkcT78vIjdo+tc0tu7EnVF4xCUnGFhYoGUTEWssKpRGbSmbk019ktMS0SzX5uJ14iwtq7aWtmOqnB02a3w8tPVLV3j0n5NjE202sZPt35SZuXOaDYDM87NQCWrSohKjlL2P9PvDCqaFx6qsfnmZiy4tADtq7XHo/hHIht5adul4mddjQkgE0Bdz0zu9kwA5SLI/ZUIUNmxB527AKamcJ08GZFz5sCyTh147txRoihFb9wo6hmrmsfKFYheuw7JV68qf12heTPAxBTPTp8Wa/basxsWGsSKNS1eH8Ql+caNPEObODjCvMpz/b0SBU7LyaQrZCoTt2PHDtSrV/RyWfrAUctll6lmx4OOY+zxsWLN5JWb3mx6kcIC6Br3owMfCaJBBKVN1TY4Hnw8T7ICJTh02dUFJDh8/v3zggwS8SGjZAVKWiiqqWa00jrIu1iYkczJ3JZzsfXOVgQnBKNyhcr49NVP1RIvco9B+n7kzaT4utyxjERAiUQTwdXVrkZdFRiSUTYvSbmompTRq824Z0PPYsSR594+EyMTHHz7oNifrsYEsHwRQBItm0RVaQBQEEYvAHu0PBQUaU++aPqL0kDLPtSMCaAOYHHTwhF42PttpNy6pWzoOHgwXCfTsS45i92xA+FfqQtSV54+DZHzvxVZyFQpJD0iEk6DB8Hc0xMBHd5EVlwcKn0+BU4DFYHdhZk+iEvyzZsi6UPVLP38YGRasOBsYWsrS6/rA8eytF9t1yrJj0jte9XsJa5mVTNP6TXKKN11bxfef+l9IVVCGaWr/lslSCNdpY4/Pl4ZM5ff3JS4QOXHSLOOEhnI40jk748Hf4gukldQ27WrtqOr0Jc3v6yx69auW1HToabQxcvMykTX3c81+XZ13wUfB5+iTFksfUhzkPCtWrGqUtyZJqLEmQWtF2g9JxFyyetKnWa3mC3iHItiTADLFwHsDICIHPnGd+pAAOlugPpQWp8rE8CivJW4j74QSDh+HCGjRiuHq7p6FWzoKrgELf7gQYSOfy5FQ1Pbdu4k9AEpq7bWpYtq0jFP1q7F40WLYduxIzy+W6rVSuUSF4r9SyECqGKUkCLp/Wm1iHLQSC6O5QCCPFsg0jT88HBxbUoacrGpsSKm7Lu236FdtXZq7UccHgG6YiVb/+Z67PDfoUw+kBpSUgVd4ZJXkWLUKIGBPE5EushcrF2Ed4wyWWlOuo48GnRUOQ+t4WRfRaybrkY1d9tvf369SWNNaTxFeCJVa+zS+6H+5vpiePJU0pVqaTXSG/wn/B+BIWn9aXuVLO2HYgpJ+29m85loX133q19pHCaA5YsAqp53cgto6wEkdV1/APRu7skEsLR+bBjOuu6/9RbSAhR1Nn0vX4JxBc06VsWFSOLpvxE8bJjG4VVlaqQGiSdPInjESJF967V7l1bLkktcqKavkH1RMVHbV0VKRauFlPFGcnEs49sXGddUlowSFd7yfguWJpbC+/b9v9+L31H9V0oUII8gac/98MYPyi0TgWvwU+EXPkQ0evnQn5OCbe21tVh2VdSWzWOXP7gMcxPzwobI8zpd9w4+NBiu1q6iWgdl+UqJErkbS1fFufep86RloEN+gu66LJ0JIBNAqk1D7haKfqUo3cIIIOlwqGpxUI5/SFxcHCrqWWtMl4PMbcsXAkmXLuHRwEFwGjQQlT79tMQ3l3TlKh717y/mtXy5PlL+e14RxOHDD1F5qrqyfsq9e3jYvQeM7ezge/4frdYrERcqfWZtba1VH9VGlI2ccveuWj8qZWdsrvsfWZ0nL0UdkpKSRCKJp6cnLC0tS9HK9L8Uuv6jrFUnKycxOJEA8rpdiLigcTKJuJEcSo+9Ch250S+PRh3nOsLLR9e1VBeW4sjcbdxFrBwZedkolk9KUrj64dVC69hSP9LZm3RykpA2SUhXFzSmODWSYMlt5Jkkr2FMSgyykIWO1Tuqxd9J1TE61uiIha0Vmb352acnPhWeR7qC9nX01f8DKGcjMgE0bAJIARJ/A2gJ4B6AGVoQQGqTp9o1E8By9slQCrZDunYkaKypbFlxLy/t0SPc79hJTONz9gzCPvsMz/45L8rGUTKI9SuvqC1BtdxcrUuXYGJTuMcyKysL/v7+MDExgYuLC8zNzXXaa1ZaGtICAwEjYxiZmIhPMvIAvgi8ivt5aBqfyA9VGHlMtZszM4XgtLHx88oKL2JNxTkn7Zeyeim7t5NnJwyqM0hUl+j9e2+N077l9ZZIgpCs6S9NRQatJiMtvLENx4IIFHnaSPpk+73t2HJbUeni+oDrOm+NMlRDE0Ix85+ZCE0MxebOm4XIsWREFon0kVSMqowMVdwYWm+oaEbkkMqu0TWwNpmuRI6JJEsEWedFG1gHJoCGSwApf51cFesBrMo599oQQPYAGtiHhKFuN3bnTpi5uaFCc4XMRWF2t/FryEpIgOfePbD01c77QASG5FDIi6WrkQdQ6BAaG8O0kkIklkSgDc3Ie+rm5iYIdHm2nnt64n6cIiyCzMzYTCQ5UNIG1atd3Hqx8ASOOTZGvE5JGQ1dn2sr/nbnN8w6P0sNItKhI8JEMXUfvPSB2mski0LkjeL5yPtWVBtwYICQbKFEB0p4ICONPappK+nu0e9IXoaSOar/n73zAI+q6r7+oiMl9N577713EBAQlS6KooIVxNcCogIi2AAVBBURERVEmqJI77333nuH0Dvvs87MHSbJJJnkJpNksvb3vN8fM/fce8/vnplZs88uAXkw4/EZ5oeMtf2bOklqLGq3KFJbyJG97/gwTgIw/gpAdrBm1UtHFK/D+O2RwPm3xgAWePEmUBawF5B0iP8TONTpadxYvx7ZPvkEaZ/07JXxRIGenbt37xovVkTsxtatOPHOu0iSMydyj/4hIkP95lh6TxMnTuz3Xs+DgQfRcrrnTE+KOJYRYWwcjVug9PQFzwzlOqPgSpssLbac3YK8AXmRMmlK0y2DQjJ4dnBULRJuCc86NAtvV3wbz5RwlELhtvOr8191XaJrya54sfSLpjwKCzKzpy2LNjPZgR00Hi/4OD6u8XFU3ZLO4yQgARh/BSDFXvFg7wTGAjJF7CkABwF43i8IOshvBSA/GFnGgB9MzIKTiUBYBE4NGoSLvzjqnrE0DLeKk+XLF23QrixahGPdX0bykiWRb/Kf0XYdnTjmCbh779iC7ONVD8XQ+KbjUTZz+IkcMTULK4aPXkoKz+wps+PU9VPGC8gOHZxPqUyOOpCDVw/G77t+D3GrLPfCuEVZ1BKQAPQvAcgeMgWdS4TVanux7iSACwDYq4cBIYzCdfwMC2nebAEHH+U3ApC/kPdf2o85h+dg7uG5pvApja2D2DJIJgJhEbixaZPJBL4XGGgOC6uPcFSQDPz7b+MBTFGtKvKMHRsVp9Q5YikBti5j2Q/rs2jQ6kGmwPF3Db9D9RzehSjE1NTGbR/nassW/B5YnPqpwvQ3OIwdRpicwvZuVr/eAmkKYPrj3pazjalZxs3rSgD6lwCs6xR8wVfjOACsTvszADZk5HESgMEIDFk3BD9vJ6Kgxp6N45oSoUwEwibAHxGnBw3GxfHjkbZDe2T7KES+VJQhtLqVBDRvjhxDws6OjLKL6kQ+JcDkB3rNPln9iYmPG1RzEFoUaIE79+6YdmSR6f7g0wkAmHVwFt5e8rCQe52cdUy8H7ed2xdpH2oNPKuVXP/q/fFEIe9DKnw9v7h8PQlA/xKAMbEWvfIAstzAzbs3kTmFI1g9thnvjRl2/JCtlq2aKZy684KjxlrOVDkxrdU0JE/sKDGx8sRKRwxL2VdDrUcV2+an+/EdgYsTJ+IkjAuvAAAgAElEQVRUv/5IVb8+co2MfPur8O7Y2nJO90xnZO0TtCxNeGP1euwncOraKZMBa1mu1LlMTT9v+sXGptltOL0Bz8561twSi0UvarvIq5IyPJ4Fk92LPcemefnDvUgASgDaXcfhCkC2wHlz0Zu4c/8OupXuZoQTeyMWz1DcJars3oSd8VP2TEH/lf1NSQXWvlrZcaW5ryOXj6DjzI4mVoVtlN6p9A5SJklpApX565vZcSxN4E/GsgvRFQzuT5zCmsuVBQtx7BVHJ5PCq1YiUVrmW0Wd3dq3Dyf79cONdevNSaN7qznq7tz3Z2IyBOPlqmarahIJaCx+PG3fNKRLng71c9U34R5MNOhSokuMx9KxNMqfu/80OxGnr592ASuRoQR+bPxjnPzByR/VVu/bGtlr4LtGVtEJ368HXTEoAQlACUC774kwBSDrMjHd/8S1E67rMPvs0OVDqJS1kvlQi27BceHmBXSf2x3N8zfHsyUcv0RZOoEilKUOWDHfsuDFRuntY6skikPa+1XeN9sxtFRJUhmx6MlY32rbuW1gfa2Itvmx+0AiO56Ct/2/7dEifwv0rtI7sqeJ9+NuHTiAA80cPUmzDR6MtK0fBzuFJEyVCikqsE135O3+jRvY16Ah7l1gWK/Dsn48AOnatIn8Sf1k5KKji3Dz3k2Uy1TObDFO3D0Rn6751DW7Cc0nYPu57Ziyd4rLu18la5UgfW7pYaPYsmP0eLGuHT/76PHyVEKFma5rTq4x5VsY38cdBYaZ/LTtJ0zeMznI5UtmKIlv6n9j2q3FVRuwcoCpKzi68WgjxmWxg4AEoASg3ZUYpgBkIVF+CGd6JJOJXeEHnLsNrz/c9HSMaqOw45cBvwiGrR/mui4zzvhrf/1ph/fEMrZPmvnETHN88EK6n635DL/u/DXELYbV37LXol7Gs1A3Z11T/+r63etIiIRImzzqvEFbz241X3KN8jSKEoY/bv0RX2/42szzm3rfoF7uelH9WOLN+XaVK48HN24g05tvmpIwe2uy1rpDEN49fQoJkidH+meeiXDdvqtLluDoS92CcMz53Sikrhv176HY+LDoIVtxfIVJfGCbM2bpV8xS0ZQOsTpd2LnvPlX6oEPRDl6dYumxpUboseAyhR7tQOABtP6rtSlgbNm3Db5F7Zy1g5zz45UfY9KeSXix1IsYvXW06zX+GObYUhlLYUSDEUiTNE2c+QEZFjR6XflDPC6LWK8WRRw7SAJQAtDukg1TADaf2tx8SFJ4sZdknYl1grQIohfwpyYPRSE/KFjMlG2JuHWw/PhyJEuUzJRi8dZTyC+JNjPa4PS100bUDd843PzqD2780E6ROIU5P3+ZhhZQzfjFRn82MiLO3dg+if0tg3v4eP2Kv1Z0Hcp6XMuOLzPX+fvxv403kQVO6XFjXa7GeRpHqG0RY4Om75uObzc54ssoWue3me+RD5MSuN1Fb0Sbwm3C/DLps7SP6RlKY62wyS0mI0vKLHbXR7wcf2bIUJwfPRrpnn4aAY82weGnO4f8AdGlC7K8926E+JwZ9hXOf/89EqVLh3sXWcYzZnolR+imo+hgJj4wTpdbo1WyVUGnop3wxsI3kAAJTHjGZ2s/83gl/lCj+HA3eqFWnXS07Hum+DMmPGXCrgkmMeHJQk+aOnSejK3S6LljKMg7S94x72W+VyjYKG52nt/p8i5a43l9xhDz/9KCx/YFvw7Pt7DtQq/j5KIIr04TDwlIAEoA2l32RgCeu3gOQ7cNNd61fGny4demvxpBUvm3yuZDkoG/bM/DrdfX57+OWjlrmVT/uw/umr6NjAekUaz9sCVkUdtXyr6Cl8u87NW9fr/5e9e2LmP0+EvdXQDyvkpnLG22VRgH5I1RmLKK/vkb54237aMVjuxOa17WORi03GNhD9eXS/BzM6ONZRHoKbCM3tF5bea5BJzV5Juxh2yuXjpTaXMo2XYv092I2+DGchAMEmcsY8WsFV2s5h2eZ+IvaUPqDEHjvKzv7dkssW69yi/Z0Y1G+32RXW+ef0SPufDLeJweNAipmzRBqnp1cfI9z1vqOb75GgGNQ38mwa97rOebuDJrFjK//TbunjmNR8qUQUCzZhG9vTh5/IiNI/D9lu/DvHd+TrAF2eYzm82PTqtECuOQWTqFrzMUhOVGav9R23gOp7WchkXHFrm839YF6Ankcb0q9DKxd7/v/B2D1zxsrRbWjQyrO8y0Pev8X2fTX5dFjSlSaZ+v/RzjdzjqRXqyHxr9gGrZ2ZpdJgLRS0ACUALQ7gozArDtn22x49oO17meLva0Cbp+asZTYKX65e2XhxAS7y5514gamiWkXpv/GhYfW+zxnvjLnDF4SRIlCfWePRUSZRFnftDTWHOKtafsWp0/6ri8CtzmpZikdZ3T1Xj3eM0R9UeYWoKevjTofWSsEr94LOPf8gXkw8HLB9G3al8jlsduC72+G7eemBHIwqllM5U1XHht2uqOq809tPunXRCPBD2Fuy7sMmP6VumLnKlzmuOtL7fECRPjt2a/odPMTubLb2brmcgVkMsurng3/vKsWTje800kypQRSXPmwo2NLMvpMLaWS5IjOy79ORnpOnZE1g8/8JrPgdZP4NbOncg5aiRS14tfW/Rcy3xPhGVjGo9B5WyVveJ5KPCQSeaqkKUCpu2dhg9XfOhx3Be1vzC9d0uNcxQrtowe/V+b/Wpi9lijj8ZdgQJpC4DxhkkTJXV1vOB7kdvLrQq0wqNTHjUx0RSJ9EJyLHdCmCDBH2j8IScTAV8QkACUALS7zowALDaqGJKlTGa2QphcQaOYoIigB4uiIrhtP78d7f9pb/7cu3JvdCzW0QgWfsi/UuYV80HK+Db2o7QCo4ukK4Jh9Ybhn/3/mExdZu65x+zR42iJPU8TY4/JvGlYCtGeBf8VzzgfBnLzw5wf9kxusTx3/Dt/8VtbTsw0/rHJj+aLp8eCHlhwNGTHPfb55LaU4ZggsfGUulu9XPWMR49byE2nNMXt+7eDvM4tLKuRu/sLrMFlCWyrvuHUvVNdHs22hdvig2ofwOrfSS9K2yJt7cGKh6PvnDqFg62fcG3TEkGmnj2M+HukdGlc+O03nP54IFI3aoicw4d7Rej+9evYU70GHty8ifz/zYzWLiNe3ZAPDqI3nMkD9KwPWT8k3Cuu6bQmUl17GE/LjP/Q7IVSL4AxspZZHvfcAbldf+O90tw/jxjP99Lcl7D65GrzGhOsGGbBz4gl7ZaYsJCt57aaz6S4Vt4l3IehA2I9AQlACUC7i9QIwEo/VsIPLX5AmUxl8MuOX4JUfv9fxf+5sm+DX6zjvx3NB+BzJZ8zWy31J9XH2RtnTb0rKxuPMXhvLHgjROIGz+V+bvfYmllPzjK/tC2jN7JH+R4mXi6qjBmFzJoNbm9VeAtdSrLu9kM7efUkmk1tZrx03JZmdjBtz8U96Dyzs+njGXg7EOz5GdxmPznbxFHyGGYe08vgHnf474F/8cHyD1yCMfh4imR6F60ED/fX2Uaq6+yuRkDSa8ttKn6Bjdk6Bl9t+Mp4Fj+v/bmJr+IX1Bvl3zCClLW56OGQhU7g3qVLOPvtSFMUmlZg9iwkzZPH/PvKvHk49trr5t9Fd+7wapv98n//4fibvZAkT24UmDXLqzFx/fn8vf9vvL/s/SDTGFxrsPGU88cWE8uen/286/Wtz26N9JT5Q42fISwbw7XOnYvjV497PN/KDiu9LsnCH8EMbXFPgOMP26F1h0b6XjVQBKKCgASgBKDddWQE4IFTB5Avy8O+p5YoKZi2oGlUHloxT6tNUNO8TcEP9vK/ljdZcAvaLAiRMcaq+Nwitgo0WzdOTxbHsuzKW4vfMv0lJ7WYZApPt/2nLVInSW08btHRz9e9RycLRlMgNc3X1CNTbr0ywDt4sgnvkx6//w79h95LHbFiVqkcegnJLzxjtwB+WdLzN3LTSNN83bINnTeY87ed0TYEO+sYBqhzG97yXpy9ftYUob334J7xUjCxxd1YA5HeQXpbrW3k8O4xvr7Olm0P7t035WAsu7FlCw61bWf+M2v//kjXLnwv67nRo3F2yFCkadUK2T97WN7EX7kyk7/+n/VdHn0r8SN4djrDJIauH2oyavn+s2tXbl8x4o8xg0wM8WRbntkSIQFO7yDLR1lbxZ/V+gzN8seP2E27z0Pjo4+ABKAEoN3VFWoWMD9ImWUbVh282Ydm43+L/2fE2T+t/0GDPxuY+9nYeaPHLLjNZzfj6ZlPO744U2Y1v9gt47WYqduuSDsTQ0fjBy//n7cZxJGBwe0pei1zp84doS+F4Nei8KXXLUPyDCYTkYkrtXLUQv60+SN0WxSULL0z78g88IuGtcZo7j056enjNrZlntrdWaVsQrs4PYF8tkzi4XZ9RI33+dqC10zQPgPfmTwUX+zuxYvYW83hBU6aNy8KzPov3Kmf/vwLXPjpJ6SPRPZwuCePhQcwSazv8r7IljKbydIP7f3FBC3uIpTMWDJKM2fpMXff9rUQhVX+KSyM/Czi7gi9/h9W+9D8sJKJQEwSkACUALS7/sLtBBLWBViqpeHkhuaQ18q+ZrJ36bFb0XGFx2EsBUHPFLdLmdDAzEDGCFnG7dGRDUe6tljtTs6fxtODagnsZe2XGZHIOmo09tpkhrK7BS9XQaFH0Ri8hiLLcHxS8xOzRV0kfRGvkS04ssBkTNPouXyv8ntej/WHAy9NnoyTfT9AwpQpUWT9unCndKLP+wicOtXUFszY7aVwj4/LB9CD3XtJbxP7yvg7hm/42tzrYnK7liVemJ1bKG2hKK3n6et56XoiYBGQAJQAtPtusCUAefG+y/rir/1/gV6oDWc2IEeqHGAMX2h24uoJk1zCAGz+qqYgZG0wFi8un6W8qyir3Yn54/h1pxxCg6ViyI5Fa09eO2myGVkDLbitOLECPRf2NDUE3670ttmepwhkggkFH70Z7saajsxopDHphbFa7rUEj105ZprbX71z1XgkGdtIyxOQx3iA45Pdu3oVeyo6WBXZsB4JU6QIc/pHX3kVVxcs8HrLOC6zZPwu4+/YRWNgjYEx0jKSiVuWl5x1+aIyfjguPxvdu/8QkACUALS7mm0LQBY1ZhKDZVYMn7c3xoLKLPRaNnNZb4foOCcB9kplfJ9VpNYTGBaRDp7wwRIaFOr0vnKrjNtZzEi2CnszHrPDvx1MtwZmZnKrmFvlbAt45sYZj/wjEljvDw+QAnx3+QqmY0iBObORNPfDjFJP8zvUoaMpJ5Pj668R0MT72oFxhRV50ONHjzILqTP+dN5T82KsGPl3m79zFVvf/MzmaA0jiSvPSPfpXwQkACUA7a5o2wKQsYL8xc9sXxr7czJpQxY3CNAryO1ldmmgZ5YlMlj/8Mt1X5oJsPAuay9yS829yDfjHOvnrg/2CaUHl8kuTHqJT7avUWPcOXoUeX7/DSnKlw916rcPH8bBNm1x//Jl5Bn/C1JUcngO/cUYx8eELa4flnlqNb2VyXb31GnHV3N2L0pvJ7vYV/er64hARAlIAEoARnTNBD/etgDkCd3jbVjjziqsbPfmNN53BKzaiJWzVjaxgGF1OxhUc5Ap4UF7fcHrWHR0kYkBDK0Fl+9m4dsrHer0NG6sX4+s/T5CuvYhSwpd+P133L92DRcnTMDdEyeRrFAh5JsyGQmSxo0SPFY7Rwp9Zta6G+NPWRrlyzpfgr24m0xpEuT1zCkymzjfmDJmwrNOKddpzwo9Y+o2dF0RiDYCEoASgHYXV5QIQG4PVvm9irkXxtow5kYWtwgwNpNf4tzCY3zg7ou7TUke97I9LBTOouDuxXJHbRqFkZtHgj2TmUwSn+z8mJ9w5osvkKxQQeT7++8gXG5s345DTz7lwpE4ezbkmzQJiTNGXS1L6+QMBThw6QBypM5hMmlnHZxlyhkFF20ReTb06Lec1tJ022AMKTNf3c3qrMHr8HX3en48jiWk2EM3Js1qyxiT96Bri0B0EZAAlAC0u7aiRADyJljwlbXsWBCahaFlcY8Av8StdnS8e3r6+izrYybCUj9TWkwJ0Vpu4ZGFeGPhGyYJZWrLqbYnzS9tlgWhgAit/qTti0TRCe5dvoy9devhwfXreKR8ebO9iwQJcPH3CTg/ejTunj7tulKGbt2Q+c3o8URZ7z33aUUkM5uFztnWkLX6DgceRrZU2Ux7wWn7HAKOpVxY0NwS/uxzXXNiTfMahT9jR93jgPn3cY+OM0ldMhEQgeghIAEoAWh3ZUWZAGQc0LrT60wyh2pk2X0sMTOe23pWMWvewdyn5ppsX3qDBlQf4LEmpFVuhjFfqzutjvSzZ/wYz2F1omHf1YE1B8YMiAhc9dQng1zdQnIM/8Zs+Z58z1EQ3N0KzJ2DpLmip09s8D63vC7rPLKIuLu3NrRpcauUrR3DMve+0l+t/wpjto0xh3cu3tlkpP+681cjBJlZzjACdcqIwCLSoSIQCQISgBKAkVg2QYZEmQC0eyMaH/MEmFHMDE7LvMme5Jd/3Ul1TSb3hOYTTEHf8IyJQ2xXRw8f67JlT5Udr85/1SSTuFtcKN/hXhQ6YUCAqQt49+TJEAiK7doZHpZQXz9/47xh5akbDjtuVJtQzYyl952leibtmWT+m6KdHSvC+kFGcV9jgqPYeHBje0H29mZ5J6vfN49pM6MN2BmH1rpgayw/sdwkErGUEwuXs3ONN8Iz0kA0UAREABKAEoB23wYSgHYJ+tn4UZtHmXZ0z5d8Hm9WeNOr2XWb2w2sOcj2cm2LBG2LRlH54fIPTWzaWxXfAgXLy/NedtUQDOsCjDkcUmeI2ZKMzXZ9w0Yc7tjRdYuJ0qVD6iaNkTh9ejBOMOeI4UhVq1akpsCe1R1ndjTij5nX7J/tLq5WHF+BbvO6mc469NjSWPtx/hFHAkbdnHUxvMFw7Lu4D1P3TUXtnLVRNVtV171Y41nAfVzTcaY8kJUAxJ7YE3dNNBnhLDX09+N/m84vnWZ2co0vnbE0tpzbYry3KzuujJaWjZECp0Ei4OcEJAAlAO0ucQlAuwT9bDw9epduXUK65Om8npm1JeipIwm7Qry9+G1zLvZbpng5euWox3NT5LQt3BYN8zRE5/86u44Z1XAUauZwxJzFRntw5w72P/YY7hw9hnQdOphuH4lSpYySW6V4tmLxeEJ65d6t/K45N7N0P1vzmekd7c6eXkAKecbkkilrNL6z5B3MOTzHjCuSrojJ9GZLQdbxpMBrlKeRx21b1pGkx+9A4AET70ePIMsEsT0jSwhZFlUxoFECTScRgXhAQAJQAtDuMpcAtEtQ47H02FK8Mv8VZEmRxXih3D1UnhIUiIzZxBN2TcCd+3fQvXR3FExXMAhJbhFTnBy6fMhsK7I+IeMEufVYIkOJINfYeGYjZuyfgdfLvR4h4RqVj+7+rVt4cOsWEgXwLRV5Y7vEJImSmBMcDDyIltNbhjgZWwFStJEPjWKMdRjLZS7nOpYxudwavnH3Bqa3mo7u87oH6b1tHVggTQHsD9yP7mW649Wyr3q8cSYGuWf50htI77B74gezgT+v/bA/deQJaKQIiIA3BCQAJQC9WSdhHSMBaJegxuPm3ZuoNbEWbt67icktJrt6CjNblK3+KEK+qPMFftzyoykvUydnHYxoMCJccuwS02J6C+Np+rbBtyZOkMbC1E8Vflhipf6k+jh746x5rW6uusazlSt19CRchHvTNg7YenYrus7parZ66eWbtHsSPl71sTmjJdT4b8598p7JriuFVoOx6+yuWHNqjfEC8hk9wINQ747xe/Vy1/P4Or3Cdf6oY7rF0EbUH4GUSVLiudkPs/2fK/EcelXsZWP2GioCIhARAhKAEoARWS+ejpUAtEtQ4w0BirMlx5agR/keeKHUC+Zv/Vb0w5S9U5AheQbMbTPXtJObuncqmuVr5nWLMGYlMzs5uLHHLLeqeU7WIXQ3eqjYm9hOHTxfP1bW8mMdRopm2uBag00sHrdcOxbtiBdLv4h6k4IKNHbdaVOkDRrnaewx6YKsP1rxkWsqFbNUNHGaLNI8cPVA/HvgX/PaZ7U+w6P5Hg2zXRqPfW/pe6iRvQa+a/QdmMjTeHJj0xea9m6ld/F08ad9jU3XE4F4S0ACUALQ7uKXALRLUOMNASYLfLL6E7MN+UvTX3Dx5kU0/LMhbt+/bbx3TD6IjO29uBdP/P1EhId662WM8ImjcMCIjSOw/PhyvFbuNbNFG5qNaTwGlbNVxtD1QzF221hzGNvuseNOQNLQt5yZgNP6r9Zgnb8Pqn0AltZhX2canw/FOYs4p0mWxqtZsdg0xWOqpKnM8e4dgL6o/YURkTIREAHfEJAAlAC0u9IkAO0S1HhDgJ1E2BOa24x9q/Q1tQO/2fgNimcojonNJ9oqC9Lp306mTh23jSlCuI28/vR6U3qEW74Uncx2TZM8jdlmHrvdIZJ+avKTqU3nyeg5XHVylcluZe3KmLDS40qH2JbNE5AHZTKVMdm2jH9kTT1mQjOuktu4vGdm6jLpwhuj0KOXLjq2xLm1X/m3yuY2prWcFiKO05v70zEiIAKRIyABKAEYuZXzcJQEoF2CGu8i8N3m7/Dtpm+DEGF7OGaP2jFuN3JrNGfqnK7TMC6NCSRJEwXtq8tjH5v2mKlL+FLpl1AyQ0kjpLqU6GJiCTed3WRK0jAz+eS1k6b1HevnPVviWVsiNaLzY0JLufEPkzY4nrF6C9oscHnYInrOmDj++NXjJqvbvbRMTNyHrikC8Y2ABKAEoN01LwFol6DGBxFlg1YPwsTdE11/W/f0ukh3B4ks2h+2/IDhG4cjb0BeI/5oLFI98+BMV4274OdOlywdJrWYZOrp+cJOXzuNhpMbBrkUt87dM3l9cR+6hgiIQNwkIAEoAWh35UoA2iWo8SEIsLjwT9t+Mm3C6uSq43NC0/ZOw4crPgxyXWbKsl4hM5UtY9kTJop8uuZT8yf2sKY30BfGAs/t/22P5ImSu+5pVcdVJrtWJgIiIALhEZAAlAAMb42E97oEYHiE9HqcI8DEitCSKugV/Ovxv8yWctpkac22L0uq9F/ZH4XTFcaUllOidb7zDs8zW8+8/vdbvjcxksygZS2/mIpFjNYJ6+QiIALRQkAC0L8EINMk2TKhAgD2vmoNwFHp1bMxNfJlAIxgTwaA3dz7AZgdgdUmARgBWDo0bhBwL6DM7GOWp7GsZ/me6Fqqa5CJWNuxbGe2osMK03c3Ooz3YdUytM7/aN5HTY1EmQiIgAhEhIAEoH8JwKYA2JV9AwC6IcITgF8x+RLAQgCXuIMF4H8AqgDY6OVCkgD0EpQOi1sEftv5G7KlzIZ6ueph9qHZJquWPYWb5m3q6rThPiPWtKNnjkkj3ApunLdxlE6YbduC1/HjBV4p+wpeLsPfcTIREAER8J6ABKB/CUD3J8+S/eEJQE8rhV7APwAM8HIZSQB6CUqH+TcB9s4duelhQemhdYea/rhRZezZ++vOX83p2DLv9PXT5t9RfZ2oul+dRwREIHYTkACUAHRfoQkBMOWRDTnD77PlGCkBGLvf47o7HxFg0eS/9/+Nn7f9jCNXjph2bP2qM6IiaqzP0j6YcWCGORm3fWcdmmX+zXjE/GnyR81FdBYREIF4Q0ACUALQfbEzfvA9AMUAnAnlXcBYQf7PstQAjgUGBiLAZhP7ePOu00T9msCcQ3Pw1uK3zBxnPD4DedPkNQkbrB246Ogi828Wa66SrYr5m7c2cNVA/LGbznmYdnlfb/ja/Htj540ROo+319NxIiAC/k1AAlAC0FrhHdiZCUArAPPCWPZ0aTxsDuo8UALQvz8oNDvvCZy/cR51J9U1A1gSpmm+pmgzo43pO+xu3Mb9qt5XKJmxpFcnf2vRW5hzeA5YjqZmjpqmWHW+NPnw9+N/ezVeB4mACIiAOwEJQAlArod2ANj7qg0AR3f30E0eQH2GiEA4BOidY59bevko9Lg17G6sHciOIxHZJn5+9vNYe2otPqv1GZrlb4ajl48iXfJ0carrhxaOCIhA7CEgASgBSM/fTwD4f8MqGRPaqlUMYOx5P+tOYgmBZceX4eV5QTNz2XM4e8rseKP8G1hxYgV6LXIUjP6zxZ8omr5omHd+7/494/E7dvUYvm/0Papnrx5LZqrbEAERiKsEJAD9SwCmAlDQuRhZxoXfMCzxcgHAEQCDAeQA8IzzGIq+XxhSBGCq2yK+ASDQy0UtAeglKB0WfwhQsP2y4xcsPrYYm89uRtYUWTGt1TQkT5zcQDhz/QxYNubeg3uhbuPyHK8teA0Uk5ax1+9/T/yHDI9kiD8wNVMREIFoISAB6F8CkIFHFHzBbRyALgB+BpAXgCNACVgEwFOfLet4bxadBKA3lHRMvCXA7ODECRIjUcJEQRi4F3Ve1HZRCFHnqRvJgOoD0LoQqzvJREAERMAeAQlA/xKA9lZD5EZLAEaOm0aJAB6f/jj2B+5H78q90bFYRxeRXRd24ZsN32Dp8aWuvz1f8nmwCwlbz8lEQAREwC4BCUAJQLtrSALQLkGNj7cExm0fhy/XfQm2kGPNwMcLPm7iA7vN7RaCydZnt8ZbTpq4CIhA1BOQAJQAtLuqJADtEtT4eEvg/oP76LmwJxYe9RS58RBLuyLt0Ldq33jLSRMXARGIegISgBKAdleVBKBdghofrwlcv3Md7y55F4uOMST3obGNXKdinUx/4fq56iNFkhTxmpMmLwIiELUEJAAlAO2uKAlAuwQ1Pt4TYKJI55mdce3ONYxpMgZZU2aN90wEQAREIHoJSABKANpdYRKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mGdTHwoAACAASURBVIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoASg3SUnAWiXoMaLgAiIgAiIgI8JSABKANpdchKAdglqvAiIgAiIgAj4mIAEoH8JwNoA3gZQAUA2AK0BTA9nTdUBMBRACQAnAHwO4LsIrEMJwAjA0qEiIAIiIAIiEBsISAD6lwBsCqAGgA0ApnghAPMB2AZgNIDvnWNHAujgHO/NGpUA9IaSjhEBERABERCBWERAAtC/BKD70nrghQD8DEBLAMXcBtL7VwZANS/XqUMAnj2BgAD+UyYCIiACIiACIhDbCRgBmCk7bzMNgMux/X6j4/4SRMdJY8E5vRGASwBsBNDD7X65bTwJQAoAdzzMIxkA/s+y1ACOBb6XGgHJ/BVlLHiaugUREAEREAERiEICl289QJpPr0gARiHT2HIqbwTgHgA/AxjkdtPVASwHwJ8FJz1Mph+Aj4L/XQIwtjx23YcIiIAIiIAIhE9AAjB+bwFTAI4FMNhtqTCGcJkzieSU1x5AbQGH/27TESIgAiIgAiIQSwhoCzh+C8DIbAEHX7pKAoklb2bdhgiIgAiIgAh4S0BJIPFbADIJpAWA4m4LZhSAshFOAgkMVBKIt+86HScCIiACIiACMUxAAtC/BGAqAAWda4rJHb0ALARwAcAR51ZvDgDPOI+xysCwBAxLwTDzl1nAKgMTw29MXV4EREAEREAEopOABKB/CcC6TsEXfM2MA9DFmfCRFwCPs4yFoIe5FYKmV1CFoKPzXadzi4AIiIAIiEAME5AA9C8BGBPLSTGAMUFd1xQBERABERABGwQkACUAbSwfM1QC0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlACUC7S04C0C5BjRcBERABERABHxOQAJQAtLvkJADtEtR4ERABERABEfAxAQlA/xOArwB4G0A2ANsB9ASwNIx1xddfBpAbwDkAkwH0BnDTy7UoAeglKB0mAiIgAiIgArGFgASgfwnAdgDGA6AIXA6gG4AXABQHcMTDousEYAyA5wGsAFAYwM8A/gDwppeLVALQS1A6TAREQAREQARiCwEJQP8SgKsBbHB69Kw1thPAdKdXL/i6GwGgGIAGbi8MAVAZQC0vF6kEoJegdJgIiIAIiIAIxBYCEoD+IwCTArgOoA2AaW4L7GsAZQHU8bDo2gP4DkBjAGsA5AfwL4BxAD71cpFKAHoJSoeJgAiIgAiIQGwhIAHoPwIwO4DjAGo4t3OtNdYHwLMAioSy6F4HQK9fAgCJAYxybiGHtkaTAeD/LEsN4FhgYCACAqgFZSIgAiIgAiIgArGdgASg/wnA6gBWui289wF0BlDUw2KsC2AigL4AuH1cEAA9hqMBfBzK4u0H4KPgr0kAxva3uu5PBERABERABB4SkAD0HwEYmS1gZgevcmYNW6viaQA/AEgF4L6HN4s8gPoEEQEREAEREIE4TkAC0H8EIJcivXjrg23h7gDwVyhJIDx2HoB33dZxBwA/OQXgPS/Wt2IAvYCkQ0QgsgQePHiABAkYoSETAREQgagjIAHoXwLQKgPT3bkN/BKAFwGUAHAYwC/OOEHW+aNxO7cXAB5nbQEzBpDCkOfyxiQAvaGkY0QgEgRu372PVt8uR76MKTCyU4VInEFDREAERMAzAQlA/xKAfMqsAfiOsxD0Nmc9vyXOx78IwCEAXZz/zaQPK0YwB4CzAGY4/3bJyzeNBKCXoHSYCESUwPrDF/DkKEdI766PH0XyJIkiegodLwIiIAIeCUgA+p8A9PVSlwD0NXFdL94QWL7vHDr9SOc8MK9XbRTMzKR7mQiIgAjYJyABKAFodxVJANolqPEi4EZg09FLWLLnLDpVyY0KAxmi67CxXSqhXtHMYiUCIiACUUJAAlAC0O5CkgC0S1Dj4zWByzfv4I81R1G9YAbDof33q3Dl1t0QTD5uVQKdq+WN16w0eREQgagjIAEoAWh3NUkA2iWo8fGWwNkrt9ByxDKcDLwZLoM36hdEr8ah1XMPd7gOEAEREIEgBCQAJQDtviUkAO0S1Ph4S6Db+HWYvf20V/PvUDkXBj9R2qtjdZAIiIAIhEdAAlACMLw1Et7rEoDhEdLr8ZbA/fsP8NL49bh26y7GPlcpSBbvnXv3Uab/HFy/HbTc5oQXq6LDaNZnB/o0K4p/t5zE5mOByJ0+BVImS4zudfKjVVkm7ctEQAREIPIEJAAlACO/ehwjJQDtEtR4vyNw7/4D/LLyECavP4btJy6b+fVrURxdauQz/2Zx58dHrsDmo5cQkDwx+rUsgUPnruGNBoWQOFFCTFp3FGsPXsDA1iWxePdZIyItS5IoAfZ+0szvmGlCIiACviUgASgBaHfFSQDaJajxfkdgxb5z6Ogs3+I+uVTJEuPNRoVRJV96PDZ8mXmpQ+XcGPxEqVAZ7DtzBQ2HWqU8HYftHvgokiVWTUC/WziakAj4kIAEoASg3eUmAWiXoMb7HYEJa46g99StKJUjDeoWyYThC/YFmWPV/Omx6sAF87dl79ZDznQpwmSweM9ZnAq8gXenbDXHvVqvAN5uUtTvuGlCIiACviMgASgBaHe1SQDaJajxfkdg6Jzd+GbBPlPL77X6BVFt8AKPc+zfsgSere5daRduG+frPdOcJ3/GlFjwv7p+x00TEgER8B0BCUAJQLurTQLQLkGN9ysCjP8r0Mch1P7XuDBeq18If206jkeSJMLpyzfxwV/bzWsUhwNalUSihAm8nv/Y5QfRf8YOFMmSGrPfrO31OB0oAiIgAsEJSABKANp9V0gA2iWo8X5FYP3hi3hy1Aozp2HtyqB1uZxB5rfhyEWcCryJpiWzIkEC78UfT7L/7FU0GLIYKZImwsYPGykO0K9WjiYjAr4lIAEoAWh3xUkA2iWo8X5FgJm///tzs5nT9v5NTOmWqLJbd++h8ifzEXjjDjKmSopyudNhSNsyCEieJKouofOIgAjEEwISgBKAdpe6BKBdghrvFwRu3L6HiWuP4L9tp7Dm4AWzxftJ69CzeyM76WV7z6HruLW4dfe+OcXX7cuqLmBkYWqcCMRjAhKAEoB2l78EoF2CGu8XBL5fvB+D/9vlmsuAViXwTDT17uU28hMjHdvMbzUqjNcbFPILhpqECIiA7whIAEoA2l1tEoB2CWp8rCQwcc0R5Ej3CGoVyuTV/XUesxpL955D/aKZUbNgRlPf75Gk0Verb/j8vRgydw+eqpATX7Yp49U96iAREAERsAhIAEoA2n03SADaJajxsY6Ae/Hlbf2bgAWcw7Lbdx1t3W7cuYdZPWuhaFa+LaLXmFncY+ImU1T6j27VovdiOrsIiIDfEZAAlAC0u6glAO0S1PhYR2D5vnPo5OzkQe/awt1nTNs2Crt+LYuHKNy89tAFtPluJTKkTIq17zdEwgiUdons5FcdOI/2P6xCvowpMalbNTChOGOqZJE9ncaJgAjEMwISgBKAdpe8BKBdghof6wj8vfkE3piw0eN9PV01NwY+HjS54+t5ezFs3h40L50N33Ys75P5HDh7FfWHLEbihAmQPmVSc80l79RD8iTRt+3sk4npIiIgAj4hIAEoAWh3oUkA2iWo8bGOgFVw2dONpUuRBKv7NMTd+/eRImliU9y53fcrcej8dXzSuiQ6Vcnjk/lcvXUXJT+aHeRav79YBdULZPTJ9XURERCBuE1AAlAC0O4KlgC0S1DjgxC4cvMOxq04hCMXruPVegWRJ0NKnxMaMmd3iP69zLYdt/Iwzl295bofFmRmKedrt++Zunyzetb22TYsW8MV/3C2iTt0t1W9GyBrmuQ+Z6YLioAIxC0CEoASgHZXrASgXYJ+Np5bk3+sPYrudQognXNr0tspUtQ889Mak01Lq1UoI8Z3reLt8Cg7joWcWdCZbdrY2o3Gentnr9zCwH93hrgOe/P+/Fxl5M6QIsruwZsTtRyxDFuOBQY59J1Hi+CVugU9Dqe3kvPK6cxutraOvbmWjhEBEfAvAhKAEoB2V7QEoF2Cfja++TdLsf3EZTQomhljulSK0OwW7DqN539eF2TMoU+bR+gcdg/efiIQzb9ZZk7zfrNi+GSmQ/BNebkaKuRJj9UHziNxooSYsOYI5u88jbK50mJo27IRFrt275Pjj164bgRgsWypTTwgrUWZ7BjeoRzOXLmJvaevolCWVMic2uER7D11q7lvWtoUSTDl5eookClVVNyKziECIhDHCEgASgDaXbISgHYJ+tF4CpJany90zejg4GZe97ulp63xsMXYf/YampfKhn+3njTnWde3oe1t1f4ztmPl/vP4qUsl3LxzD5dv3gU9ldw+bVw8KzKlfpg9a3n/eO2dAx7FtI3Hsef0FXz4WHGfZPdGdjks2n0GXcauRcHMqZA7fQos2HXGnCpl0kT4541aJlu49cjl2HjkkusSjYtnwainKxhPZ2SM3U+is9ZhZO5JY0RABLwjIAEoAejdSgn9KAlAuwT9aPzQObvxzYJ9rhkxHu231Ydx6fod9G9ZIkwBte14IB4bvswIlhW9G6DDD6uw4+Rl2O2owZjCUv3mhEqZ2ocFnzOkTGa2RlkC5uL1O+jbvBheqJU/zjwdevzYJ9iT9W5aFJ2q5nEljZDph39tN4c+Wy0P+rcqGeo82Xruz/VHcebyLdQslBEv1sqPJIkSYMyyg2Y7fFi7MmhdLmeEOd25dx/vTt6CyvnSo33l3BEerwEiIAL2CEgASgDaW0GABKBdgn4ynvF7NT9biOOXbrhmxLg5Fiu2zNpG9TTlX1YeMqKkduFM+OX5yrAycfNkSIF5veogSaKEkSI1a9tJdP91Q4ixZXKmAYvnsb5fcEudLDGWvVsfaVIkidQ1Y2pQxYHzXEkqjJ+smCe9KU9De6VuAYxctN/8e9fHjxoB98Xs3UiaKCFeqVcAr9cvFMIT6GlLnuNzpX8ERy84njNrD/K5hpess/7wRczcehLPVstrYiW5fd51nGO7f98nTc22ukwERMB3BCQAJQDtrjYJQLsE/WT8sYvXjQBkXboq+dNj+b7zKJkjANuOXw4yQ4oPT7XqekzciL82ncCbDQujR8NCuHT9NsoOmOsaG9lYwPembMHEtUdNNw+WTqHRy7h9wKPm38E9ZxQ3wzuUN7F9cc2sdnS8b9YjvPfgQYh6hvWKZMLY5yqDgr37r+sxe/tpM01PnlYryeTRElkxa/upUHHQi/pn9+qokCddqMc0GroYe89cNeJx6Tv18c+WE3jtd0etRRayrpQ3ndfhAnHtueh+RSA2EpAAlAC0uy4lAO0S9JPxlqeteLYAIwTGrzrscWZNS2bFNx3KBfHoUYzU+HQBTgTexPiulV39d1/6ZR3m7HAIlC39GiMgeRLcv//A61g8y6vI8eOer4x5O06b+/rsyVJoV+nhtmP1wfPNtSmOGBMXV4spv/rbBlfsJIX2tVt3UWHgvCDP4bunK+DRklnN38idXkB6Bi3PK//+66rD6Dt9m2vcmvcboNnXS3Hu6m3X3yjkWpTOjvk7z2D36SvoUj0v+rUs4fGZB48NZUkdZnqvOXTBdXzLMtlN2Z8iWVP7yTtC0xCB2E1AAlAC0O4KlQC0S9BPxr8/bSt+W30EHavkNrF0n8/abWZG7xHjvdYdvojAG3dcs6XXqF6RzPi2U3mwr+27U7YieZKEppVa6uSOrVfW3OO2Jm3mG7Vw9OJ19Jy4yXir2lTMFSa5FfvPoePo1a5jKIiY7MAMZW7/JmDvNKcxyeO/rafQrU7+OCv+OJU/1h4xHJMlTojdA5ua2Y1atB+fzdrlmut/PWqhWLaHvYp3nLiMZt8sRUDyxFjzfkNMWnfUFR/IQaVypMGM12ti6oZj6DVps/lveuz4rMjQEv5Fs6Y2dRA9We+pWzBhzdFwVzpjC3ktX/RSDvdmdIAI+DkBCUAJQLtLXALQLsE4PP7W3Xs4cPaaSfJ4esxqUzPvpy4VTfmRwf85RMfWfo1dgs7ajg1tyu8+WhQv1y0Q5OVWI5Zh87FAfPFUabw9eYt5LXPqZEashGYXr91G46+WmLp9tP81LozX6heKw6S9u3V69P5cdwyV8qU3Wb+0DUcu4omRK8y/C2VOhX/fqIWkiR/G27l3FKlRMIPZurdsSJsyqJQ3fZj1DS3vHmMJdwxoEiKWj9nWjYYtMWtjwotVsfvUZXy3+ABOXb7pcVIUmNNeqa6YQO8euY4SgUgTkACUAIz04nEOlAC0SzAOjqewCngkMdp9vwqb3JIo6hTOZEqtHL94Aw2HLQb/e/QzFYPM8MK12ybu7rdVR4JsE5fOmQa/vVDFJRatQezJy9687pY1IDlW9WmAJXvOgp6nzAFBO1/0+3s7fl5xyJREmfFazXhfquTQuWvG+5kj7SMet89LfTQbV5zxkRZn9zjJsJYot+RLfOToSEJv7/+aFAFL0jxdNY/xplrPon7RzGZt0LgGyn/8ML4z+PnDKmbty7fLycAbSJciaZz2CvuSl64VtwhIAEoA2l2xUSYAuRU14J/t6Nu8OErmSOP1fc3YfAIrD5xHogQJzJfQe02L2q4b5/XFo/hAJj4wG5IJC76ww+evmcSIEtk982adt8kbjqF6gQyugsEshNxh9CrjYWLNPssYP/dV+3JI84hj+5ZeONaICy2ebunes+g8Zo05tnnpbBjevpxHcWJtPbrz4PYxiy/3/GOTEYDTX62BeTtP49jFGyifOx26/rzWCBpmEzO2TRY2gbzv/es6gDGaTPhgMenHSmf3Cp178ok1gNzHPVfJFNVmOR8mpfA5W8YfDn+uOwoKQysb2Hote5rkphRQTNp+ei6HLjbJQCyY7R4yEJP3pWuLQFQRkAD0PwH4CoC3AfCTloW+egJYGsaCYarjJwCeAMAUvoMA3mLIlZeLLMoEoPUlVCBTSsx/q26ol79++y7u3n9gEgIoMqoMmo/b9+67jucWIrcSaeNXHjIepcfL5fByOhE7jEWFGTDPLU+KnQbFMrsSGCJ2JmDVgfPoMnYNsgQkx9gulUwBYn5hRmU81KS1jjistpVyme3RSp/MM56hf98IGXfFtmHcOmRZF24N/vZCVdy+ex/8sl998GHwfonsARjStkyE75Psin4wy9zPJ61LolOVPB6RMZGh8bAl5j6YIfz35uNBhCcHsRXbgXMPxah1otAyjiP6bPz9+BfGrTMC2urewu3aiBSH5nty7o7T+PifnUF6JT9VISembDiGBw+A1X0amLXtydwFqPU6t5NTJA3/hxC3vRnXyeSRyJYK8nRPU9Yfw1t/bjYv/fFSVVTJn8Hfl4HmF88ISAD6lwBsR83Dkl8AlgPoBuAFAMUBOPo/BbWkzuPYMmAQgGMs8QXgCgDHJ1/4FiUC8OC5a6j35SJzNXZlYCKAJ+N2E2O7WNx3bq86+HD6Nkzf5NgebFIiiylpwQB3Brqz8wM9VTR6iOyW9WCLMH6R0TvJ5AQKJG5Nfr/4QJBbZe27VmWDCs7A63dMoD2/rF6pVxCdquQ2HgV+0dILwnMO/HcHVh14KKx40sp502NS92rhPwUvjjhy/jpqf+Ho0rH47bqo84WDN81TMWCrLIt1TK9Ghc22Krfv3O33F6ugeoGMXtxByEO2HLtkhMNr9QsiWeJEoZ6DYpWFormlzF6270xxxAKGZaxPxy4isvAJcIuYHlkm1tjJgOb7YsicPa52c9aVrdIvod3Jk6NWgHUCedzVm3dNIW5u3ZdircZwbOjcPfhm/l70aVYUL9UOGj8a3tiwXnfPhM6YKqnxhrJeotVWz865NVYEYgMBCUD/EoBMeWTF25fdFhcbmU5nG1APC66701tId9nD9MyIrUzbApCCounXS3D6siNgv2KedJj8cnWPd+FeToJxYAwkp6eCsWN5M6RE1cHzzX9v+aixiUtyNxbGZQmMk4E3TUYjS06k9GKrlSKNXox3nAkI3GJmQVv2YHW3RsWzGDHD6z9TLQ/ebFTYCEZ69dzbb3HMV+3KGq/kD0v2Y9DMhxmawSdtslb7N/HqS9lqy7X1WCCe+cmRkMGMSqtA7+glB1x9bQtnSYU9p6+6Lmd5+NyvX+eLhTh8/rrH58DtX24VXrl5N9wOHxFbTt4d/fvqI/jgr21mjqEZYwr/fq2mdyfUUVFOgNnE1nvmyfI5jZc4NDtx6Qa+XbgPz9XIa8rP8IdQmwo58UUbz2MYQ8pj+AOJ73mae+ZzZCfDH6If/rUNHSrnBv/NEjnu9kLNfOj7GH9PR9z4g3HY3D04cuE6fnimos/CPCJ+pxoRXwhIAPqPAKQ3j9/WbQBMc1vAXwMoC6COh0XNbV66nDiuFYCzAH4H8BmAe16+CWwLQHp02H/VMmYq0rvnydy7B1ivWxme9K4xsJzeg49blcAHzlZX7ucpnzstNjh7obLkR++mxcKdJj10Vvapp4P5xUNPE7ermOX653o6UoEUSROBNfFY/iS4Ubz2fawYBs/cFaRzhvtxzNTklmvPhoVAMVO3cGaPMXIssdJ32jYTq8d+tSz5cf224/Fxe5ZZnzTLy+J+jcfLZjce1GxpkmOlW8wVxWTxj2YZARvc2FasXtHMKJwlZuu1UQTQ8/PrKodzmyL20ZLZzLY/xS3L0QxqXSrc56sDoo8A2+rRE89nkT3tI15daOGuM3ju57XmWD6/ukUymR965XKldcXhdR+/PkRhanaMWfx2Pa+u4emgyzfv4IfFBzBioaOVYcNimTFvp6OfsmVV86c3mcwRjQdkbC/rKLLWJG1o2zJ4onzE2+dFenIaKAIeCEgA+o8AZLT2cX4PAnDUfHBYH+7wASji4fnT9ZQXwG8ARrJKBBsIAKBoHBDKOyYZf2y7vUYVcCwwMBABAQ9ri0Xk3WbVKaNYYrB4hpRJsf6DRh5P0WfaVtD7Y1nw7gXP/7wWC3YF/dBmNuM1pyByP6m7OArrfl+fsBFMNPFkzFakF6Ji3vSul7mV9uIv63DzzsO4RL7IsnN/dquGl3/b4CpPYg1i6ZSkiRIhYUKYWnrcbh0yZzdmbn3YfSG0nq2v/r4B/245GeoUWD6lav4MqPW5Y/vXMgbfD2tbFmUGOPrkzutVGwUzO0Qdt7aZfUuhyi3tT2ftAr00IzuVR4U8D+cakeccHceuP3wBT45aGWQLm0ktaw6eN8+EcaKyuEWAP3pK958d4v3TrXZ+9G7m+MHmKWaQiUH8ERNanGFYFJgM1WjokiCxxNbxLFpdvWBG8wOKxlCT7zsHzWwP69ynAm+akAVmrFvG2F4mxchEICYJSAD6nwDk3ulKt0X1PoDOABxZEUGNTUIZlZ3PzePXyy2JxNPa7Afgo+Av2BGAH/+zw/QlbV0uh0l84Af5noEhe4PuO3MVTb5y1BMrkiU16hbNhPceLRrk1zi3iPlBfcZZ/40f1o8kSeSKE+R9U2Ced8axMU4sR7pHjLBhiYzgxszk1iOX49bd+6ZLBEtcMKuRFlayCr2a3y3ebwRUr8aFcefufZPdyw4ZLDo8YsE+Vx20x0pnwzPVqMOD2rSNx/DmH0FDMVuUyQ4mT/C+GfPEbehOP642zNx3Qwc+XhLkyvt2NxZAZizkALMK5QAAIABJREFU8Us3TTFlemUoVrl1zXMz85PWbfw6E0/5ev2CeKuxp98OMfmxFfTajAdl1nREvTKxZwa6k+AE6NllbF9wY1mfz58q7apraL1ODzZDO7gb8HzNfBi95KApPs4wjNCSWRgSsevUFQx6oiT+WBu0+LX7dfu1KI4nK+REqX6OH0o0fj6xaLX7mmN8Mj2V9Nzz/Ulj7C/LIVn1KF+rV9B4GNlresOHjaI0aUWrSAQiSkAC0H8EYGS2gBc7Y//cI+XZPoBbw/wECxrt71hdUe4BtJINGFs3dM4e8yt86Tv1kCt9Ctd6puhhLB3jfhoWy4Ifnw39F/iKfefQ8UdHBwhuIfFDmV8otL9fq4HSOdOaTFa2onI3bm3SU1bG2QOW26AUnIzZYfIBM3PpxcvX25Egze3kqa/Q4Ro9xi1tekQZw1cyWDwjr0gPJo0ZkGzDxSSVtYcc283b+jcxZXGqfTrfFGm2bOJLVc0c3c3qBMG/sWZf7cIZUW3wApPsMbl7tSDezeiZqc4qAiEJcIufGf6ewhB4dLoUSYxnv2Nlbi8nN7G0fJ8ydo/vWRoTyii2GK5wIvAGOlfNY8oXZU2T3PStptHDzRhdJjhZxjI01nbtD50roHGJrEG8juyawuoCTC77bfVhfDXP8fliXXPJ2/VMVYBP/9tlfgjmTp8Cw9qVQdlc6VD5k3nmByi3kqsVyBCh1oZaJyIQlQQkAP1HAHJdUPWsd2YBW+tkB4C/QkkCYeZvR1bRAGC5inoAeBeAdwXAANsxgJ1+XGW6DzAuZviCfeYD3D2zlFtCTGqg+KM37583arpq0oX2ZmAJB7YNe71+IVMbsOfEjaakSutyjrgblhbZejwQO09eRv8ZROQwegGXv1ffZOuOXX4IA/7ZYbpOzHmzNtKmoMZ+uP3kXm4mKt+Uns7FZJFxKw6bLwx6F4Pbqt4NTFZyx9GrUCFvelP/jvbl7N2umCYK3G51PGdJWsWW2d6LnRgoJNOmSGJKd4SVnRvd89b54zcBxt+y/zB3BxjawRAQGgUYY1vp+UuYIAGW7z/nqikZFcRm9axlvHPL9p4zGfv03nvadg7tWuxnTW9l3S8WGS/8mGcrokGxLObwtyZtNkllTHKh1/2NiRvN/LirwR7N1udMVMxD5xCBsAhIAPqXALTKwDC7l9vALwF4kc4iAIcB/OKME7QyglnyhernZwDDnTGAPwH4xlkb0Jt3jy0BSM8ef+WzRyz7iw5fsNd45j5/srSpVUdzDwr//YUqJh4nKu3HpQcw8F8mSzuM28bcuh23kshgsl1HPV3B9frC3WfMlikTLuyUzIjMHLjN9OzYNYYRS2YcvXADzG4e37WKOR0D2VMkSeRqo8WyHNwSZ2mNaa/UCLWlF5/D498uN1titMQJE2Dsc5UiXdMwMnPTGBEIjwDDIthTuEeDQqjh9jnAuM8mw5aAnTuypXnEvL5s3zlXB5ngWe+ersOtW8be0uPYvU7+ECEFjO3tMXGTKYrOBK9J6xw/xPijqWKe9KZlHvtPWzUyrZjmSnnTmc82a7t43aELeOo79yidh3fD9/TcN+v4/HMlPO563T8JSAD6lwDkKmUNwHechaC3AXgTwBLn8mXhN+5zdHFbziwyN8yZKcwkkjFRlQVMUcH+oAkZoBaKMUuQMWxZApJhxXsNTAmICWuOmA/wrrXymdiZwTN3mmy8thVz4vOnQi8lEdm3KL19Z6/eQtef1xmvYHCLrXFwFIPc/s2dIYWr+0ZoDDjH8GLk3p+21SSg0NwFeGS5apwI+JIA3w/3HjxwxdXdvXcfe89cNZ1iuPa/nrcXpy7fwPvNi+P31Yex5uBFsNcxReXiPWdNeZcCmVJ5fcuztp3CjhOB5odqznSOcBV2yWn3g6P2KI2ffxNeqmpif92tSN//QsTnWq9H1+ec1xPTgfGGgASg/wlAXy9ejx5AJmw8MXK52c7gdq71ARn85pjRy20dJliMfa4yvpq3J0g8jXU8A7kZM1M5X/RloG4+eslk+87ZcdoVQ8Rf8awxmC6lY/vXn83dE3pwcLNwBaM/s9DcRCCyBP7a5OhUw/hD9xaK7ufL1/tfV2xj3gwpcMit3iY/6zZ92ChET+zI3o/GiUBoBCQAJQDtvjtCCMBdpy7j5V83mFg+Wquy2fF1e0d2aXCzgqStEif0/vWe6ojzsYzbLd92Ko96RTLbvVevxtPr+NL4dWabZ/zzVcL0YHp1wjhyED22fB6NS2SJdGePODJV3aYIxCgBfs7R487qA/kzpcK4FYdQNFuAKQzPsA4mdRXKksq0mOT7sVr+DPpBFqNPzD8vLgEoAWh3ZRsBmKvnJFQvlhONi2c1hYjdy48wnm5VH8+N3bv+vBbzd51B3+bF8EKt/HAv9MzCrsxaZRJC+njggbP7IDReBEQg7hBgchvjDt2N4S7fLzlgYnDZ79yywU+UMt1JZCIQlQQkACUA7a4nlwBMmOxh2ZYq+dLji6fKuHrPru/bEBmctbGsC7JlWYsRjpp6/7xe0/TDZb/Xx4Y7/sbM25juNmEXjsaLgAiIgLcEGKvbYMhiHHDunljjGCPNto7qQ+wtSR3nDQEJQAlAb9ZJWMcYAZj/rcmoVyo3Vh+4gIypk2HKy9WN167R0MUmEDv4L1h+0LX/YZXJmGM7sq+cW8T8OzNyGRfT2UNxZLs3q/EiIAIiEJsJjF1+0JSmypgqKd5uUgTvTnGExPC/Z/aoJREYmx9eHLs3CUAJQLtL1gjAfUdPo0DOzKZ+nnu2qZVYwBpXrK3F1y5eu22y7nr+sck0cF/wv7oeu3DYvTGNFwEREIG4RuDW3Xv4btEB0wOZRenZOeiFcetMYhoL27OvskwEooKABKAEoN11FGYdQNb3qzZ4Pq7fvmeygW/duY+Xf1vv6vPp3t/T7o1ovAiIgAj4I4HPZ+3CyEX70b5SLnz6ZGmcv3oLW44Hom7hTCGSQ9gqM7T2d/7IRnOKPAEJQAnAyK8ex8hwC0H3nb4Vv646YgoWs24dW4zR2FZtXq86Eaq9ZfdmNV4EREAE4hqB2dtPodt4NnlyxEZ/PX8v/t1y0vw3286xFiiNFRieGrXSfNZ+27F8hCsYvDBuLVjCi/GGbHUn828CEoASgHZXeLgC0L03Ly/GqvzP18iHLAHJUa+ob0q72J2kxouACIhATBFgm0d2TPJkbF/Jagnsnf7twn34YvZucxjjsIMXoA7r/tlFhT3AaaM6lUfTUtnA7ieFMqc2vZNl/kdAAlAC0O6qDlcAMqalSN9ZruvM61UbBTOntntdjRcBERCBeEMgrF7EVq3VV3/f4PIMfvZkKbSr9DBe8MrNOzh07rppIbly/3kTX0j7b9spPFk+hymC/8Ff283fXqtXECVzBKD7rxtQIFNKzH+rbqQ5s0PL+9O3YeORi6bU11MVHP3YZTFPQAJQAtDuKgxXAPICTAYZNHMnPn3iYY9fuxfWeBEQARGILwR2nryMpl8vdU23TYWceLJCTlNNgcY+xqMW7ceNO/fMf6dLkQRFsqbG50+Wwe7TV/DiL+tCRcXC04t2n3F1JKHoY/cmJuvR7HQGci/tRW/l8vfqx5dHFuY8vWnPGd2gJAAlAO2uMa8EIBc7i0MnT5LI7vU0XgREQATiJQGKqUvX76BmoYxm/txdqThwHq7cvBsqjzfqFzS91HecvBwus+AFqK0By96tF2o7z9BOuuHIRRNPyHP2mrTZHMa4710fP2qK+8cn43P6YPo2VM6XwZQ9Y79oxsK/Wq8gahfOGGOlfSQAJQDtvg+9EoB2L6LxIiACIiACIQmsOnDe5QXkq2vfb4g79+6beMDfVh8JMuD7zhWQN0NKMKaQbR8bFc9iEkoso1j8Z+tJHDjraONpWYfKuTD4idJe46e4Kf/xXHN8udxpsfHIJdfYgY+XxJ/rj6FcrrT4qEXxUFvccev40PlryJcxZZxvg8eEHW7P075uXxY9Jm5y8aicNz0mda/mNduoPFACUALQ7nqSALRLUONFQAREwAaB/7aexFfz9mJAqxKokj+DOdOkdUfxzuQt5t8sC/NTl0qoUzhTiKuUGzAHF6/fMX+np++13zdi01GHYGMs4IiF+8y/X6qdH8cv3cC7TYq6so493TITR3pO3ITzzmoPYU1r7pu1USjLw3hwCtcTl24gd/oUeO7ntVi0+6yrTagNPDE+9KO/tmHcysPmPlj71r1VKv/WrU5+9G5azOf3KQEoAWh30UkA2iWo8SIgAiIQxQQYv/fsT2vMWT9uVSLUzko9J27E9E0nUDQri/XXxoQ1R9B76lb0bloU3eoUwMf/7MCYZQddd8e2dCvea+Cx1iDFG7s/XbvtiEN0t05VchtReufewx7HyZMkRLNS2TCgVUmkSpYYPSZuxF+bTgQZx5I247tWiWI6vjsdazbW+GyBq/atdWW2S2UnLMu29mscovTO9hOBZru8YOZUruMozundpVimoGdSTWRL9kgASgDafSdIANolqPEiIAIiEMUEuA1b5/OFKJglFaZ0rx5qTUCKtrk7TqN1+RwIcNb+Y8awJSpu3rln+rMzns+yz5/0nMzX7+/t+HnFIZTPnRav1y9kvHiWrenTACmSJcbh89fQ/BtHv3fLmMDCTOY6XyzySIH1Yt1FUGiopqw/hiV7z5qOKSmTJY4w0SPnr+Pqrbsonp1fa1FjM7eexCu/bUD+jClRNldaTN143Jy4ftHMSJsiCaZucPw3t4J/fr4SUiRNjANnr6LruHU4eO4aApInxoreDYxApr0+YaPJ2LasZZns+KZDuUjdrASgBGCkFo7bIAlAuwQ1XgREQASigQDFDJMw7CbfUZCMXnoQzES2tof7tSiOmoUy4ZGkiZD2kSRIkTQRan2+EMcu3sDoZyoawVbvS4egS508MbZ81NgVy0dx2vTrJTh9+ZZr1sWyBZjzl8qRBmOerYhkSRKhww+rTPJKu4q58NlT4ccgWqVymNXcr2WJCBFlzGH+PjPNmJW96yNrQHITq1gpb3oThzhr20lkSJXM/Le3NnrJAXy/5ADOXb2Fp6vmRo8GhfHkqBWmrR9rN1L0rT9yEc+PXYsrt+6iZsGMGNGxnBHc5GjZp0+UQvvKjpI+nX5cheX7ziN7muQ4EXgTaR5Jgo0fNIpw0W+eSwJQAtDbtRzacRKAdglqvAiIgAjEAQK3795H42GLXeVirFuuUTADhrUti8qD5iNhAmBb/yZImCABin7gqP+aIWVSrP+gUZAZ0rPIY+gdm7fztOu1t5sUMdmxNKuJAD1lTG5JkihhmJQsAcjjN33Y2Cui3EodPHOXyVC2trpHdioPdl+xtqOnvFwNT45aac5Hj1yLMtnBZBb3vvfWxRbuPgOKyQKZUqHekEV48MAhgH9+rhIq5PEsHtcfvoDOY9aYlqmejJ7D6a/WMC89Nnwpth2/bER2rz82GeH4Z/dqERKm1jUkACUAvXqThHGQBKBdghovAiIgAnGEAJM8KFaCG3u9dxy9GnkzpMCit+uZl60EE8apfdmmjMcZskTKXxtP4GTgTTAmsFPVPK7tTvY1rjJoHs5dvY2hbcuYVqIUm/WKZA4ivlhmjOKpxEezXdegYKJwunH7nulokjhRAtQvmgU8lp69yzfu4Lka+cAtWm6ruhuvQS+bZSyKTdHlbn+8VNWVcGP9/Y+1R/DulK1BjiuTM43J8g2v9M2K/efQZexaUGRTRP/6QhXjRa0+eAHu3n+A2T1rm7qOtT5fgKMXbphOL4zXnLz+mKtHtPuFd5y4jKkbjhkxnS5lUtdLnD/jQ+lxfQS3kSZNGr7G/y/8OkFxZI1G5DYTRORgHRuCgASgFoUIiIAIxCMC9Jpxa3nNwQumph2tWamsmLn1FBoUzYwxXSqZv7G93M/LD+HpqnlMq7rIGOvnjV/lyKC1jN1MmpXMhjcbFTZ/ajliGc5eueXKZubfuG3LxBZmElvFsenZY1KG1fGExbRPXb6JpXvPeXVrtQtnwhJncew+zYripdoFgozrPGZ1iHP1bV7MdEDxxlYfOI8flx1Ew2KZXV1c2J+ZdRxp9KRa2dWMi+TWMguBMz6QHlJux1tW/8tFOHDuminD89sLVUxsIY0syZRtAn/qWAJp05qOMBKA3jwgHROCgASgFoUIiIAIxFMCwVvUuW/hRgWS4HUO3c/JuoUUd4xPtIxlVpImTuixODaF48Vrd0yiR0SMXryejQobz+PIRfvw+azdeKx0NozoWN51GnrWyg6Yi8Abd/DXqzXw5ZzdoBfuv561bBV6Hr/ykEuwut8zBR8FYZ0vFxqPILO2O1fLg92nrmD00gNGjFtGzyp7OrMG4aNfLcXte/fNS+mT3MXGgY9LAEZkMejYIAQkALUgREAERCCeEnj51/WmnzCNnquRnSoYARZVxm3gAs7kjFfqFkDJHGlM3GBoRmFWu1AmvDNli9lSHt6hPPJkSIHGw5a4hjD54tnqefHe1C0uoTjjtZpGGLH0yofOnsgcsL1/kyAZxcv2nsPTY1abcy52bnXzuIW7zpis55RJE2HDh42QOKGDAWsw2rGL126j5bfLjMhztz0DmxrOTDT5ZOZOj5eoVyST2TY/c+Vhso37gfdvXcfRr9pKANp5QPF8rARgPF8Amr4IiED8JXD33n38s+WkieHrWjNflIo/iyq3XVceOI8eDQqZjOaxyw+i/4wdQaC/WCsfMqZKhg5VcptyNluPBSJlskTInymVifur9IkjlpDGLN9saR7BN/P3YujcPWDvY26pWkkdRy9cx7rDF9C8VPYQ8wm8fgdlBswx51n6Tj2ztX3t1l0jwn5ffQTPVsuD/q1KRumC4JY7r8E4wsZfLTYeRcYA0phwwjlYBbv5N2779mtRAmVypQVL+gybuxc/LX/oJf3wseLoUDk3Pp2xAQOeqiwBGKVPK36dTAIwfj1vzVYEREAEYpzA2kMXTHbt35tOmG1XFpMOy9tGETlo5k6837wYahVydEShd5GlZ/JmTOlKPPFmYm2/X2niH1MnS4xMqZOZWDvLuM3aqmwOb04TqWMouClUg8+VtQGtZBaW6OlSI5/r/EyEqTxonhGRfZoVM0Kd51AWsLKAI7UI3QZJANolqPEiIAIiIAJxhsDe01fw/Li1IbZlOYE5b9ZGYbf2dr6cFBM8Vu4/hyFtygZJCOE9sJbj/QcPUDDzw9Z7EoASgHbXpwSgXYIaLwIiIAIiEKcIsI4ht3yHzdtj4girF8iA4tkCjIfRU33A2Dg5CUAJQLvrUgLQLkGNFwEREAERiJMEGJ/HciyMKYxrJgEoAWh3zUoA2iWo8SIgAiIgAiLgYwISgBKAdpecBKBdghovAiIgAiIgAj4mIAEoAWh3yUkA2iWo8SIgAiIgAiLgYwISgBKAdpecBKBdghovAiIgAiIgAj4mIAEoAWh3yUkA2iWo8SIgAiIgAiLgYwISgP4nAF8B8DaAbOxiA6AnC5Z7sa7aA5gA4C8ApjmglyYB6CUoHSYCIiACIiACsYWABKB/CcB2AMYDoAhcDqAbgBcAFAdwJIxFl8d5/AEAFyQAY8vbU/chAiIgAiIgAtFDQALQvwTgagDskv2y23Jhl+jpAHqHsoQSAVgMYCyAWgDSSgBGz5tNZxUBERABERCB2EJAAtB/BGBSANcBtAEwzW2BfQ2gLIA6oSy6/gBKA2gN4GcvBGAyAPyfZewrcywwMBABAdwNlomACIiACIiACMR2AhKA/iMAswM4DqAGgBVuC68PgGcBFPGwGHnsH06BeM5LAdgPwEfBzyUBGNvf6ro/ERABERABEXhIQALQ/wRgdQAr3Rb5+wA6AygabOHTc7fFGS/4n/M1eQD16SACIiACIiAC8YCABKD/CMCIbgFzW3gjgHtu6zyh89/3nR7D/V68B5QF7AUkHSICIiACIiACsYmABKD/CECuKyaBrHd69ax1tsNZ2iV4EkhyAAWDLcaBAOgZ7AFgD4DbXixWIwCPHj2qGEAvYOkQERABERABEYgNBCgAc+XKxVtJA+BybLgnX99DAl9fMBqvZ5WB6e7cBn4JwIsASgA4DOAXZ5xgaBnB3mwBB7/9HEwCicY56dQiIAIiIAIiIALRRyCnUxtE3xVi6Zn9SQASMWsAvuMsBL0NwJsAljjZLwJwCECXUJ5FZAQg+TEB5Uosfb6RvS2T3QyAbwzNLbIUY2acnl3McLd7VX9+bmTjr/Pz13lZ6zk+zO8EgAd238Bxcby/CcC4+Axi4z2brW0/dY3789y4lvx5fppbbPy08O6e/PXZ+eu8rKfq7/PzbvX66VESgH76YG1Oy5/f9P48NwlAmws/BodrXcYgfBuX1nOzAU9DY5aABGDM8o+tV/fnDzV/npsEYGx9R4V/X1qX4TOKjUfoucXGp6J78oqABKBXmOLdQex2wmSZwQBu+dns/XlufFT+PD/NLe6+Gf312fnrvKyV5u/zi7vvqCi4cwnAKICoU4iACIiACIiACIhAXCIgARiXnpbuVQREQAREQAREQASigIAEYBRA1ClEQAREQAREQAREIC4RkACMS09L9yoCIiACIiACIiACUUBAAjAKIOoUIiACIiACIiACIhCXCEgAxqWnpXv1lgAbPLK6+z1vB+g4EfABAa1LH0DWJSJEIBOAc/G1E0aESPnhwRKAfvhQw5hSFgB8w59x/s/fZp8PwDcA0gFoCeCiH32wpQRwB8Btf3toALQu4+5D9ed1yc/KVADOA7gMgN+X/tIyLC+AkQBuAHgSQEIA9+PuMtSdR4aABGBkqMW9MXzOXwN4CsApZ4/fdgAWxr2peLxjzm8UgBcA7AGQ39mj+YKfzO9LAI0BvAhgtZ/MidPQuozbD9Pf1yV/RPIzhCKwGYB9cftxmbvne+47AM8DOO2sG8qe7/5W79UPHlX0T0ECMPoZx/QVqjnF0XUAbwO4AqAfAP4CLB/TNxcF1+ec+gLYCeAVAHcBTHLOdUYUnD8mT8EP5qEACgAoCeB7AH0AXI3Jm4qia2tdRhHIGDiNP6/L+s5dBHr8+F5L7vy/9JQ1iQHWUXnJtwB8CGAXgG5OR8BnAJ4BsD4qL6RzxQ0CEoBx4znZucsuTrHHrVHLI9YGQA8ADfzgl990AH8D+MkJid6/TQA6A/grjm9tUPTRq/kbgIIAxjk9EfPsLIhYMlbrMu5uufnzunwHQFoAg9x+aPFHZi0ArZ1xxXFxK5hb9VMA/AFgrPMzoLRT+PHH2Lo4/lkZSz7W4tZtSADGreflzd0mdnrBrGP5YcY3/3HnHzICoGeMW6VLAEwAQO9gXLHg83P/ME7k/IDmr9mlAHrGlUkFu08rHucRAHxeR52vrwIQ6BS3jOOMS6Z16fCyaF3GrlVrfWZYd5XeueV7xPkHxgH+A2A5gEXOH5uxawah303wubl/VvIzht8NnNfPAOgJlMUzAhKA/vXAPwZQxhnn9wOALcGSBpoC+Ncp/LhlyhgX/vL7BMCaOIAi+Pw2OxMj3D/oUjhF7SUAL8UhDydjcij05np4Dtb8+Iud3s3nAPwah7KctS4BrcvY9wHzEYDCAA4D+NZZOcA9yaOt87NkpfMztZ5TDHIblWNis4U2N/fPSopdft7MBPBBbJ6M7i16CEgARg9XX5+VXqKpzuxXCoMOzhuYBqC/W/ZaCbdffTyEsWXzAQxw20L19b17cz1v52f9wmWsHMUStzZi+3ZNDWfMUTnn1gzjGU96uG/LK/gLgEoAmgM44A28GDzG2+emdRmDDymUS/vzumQ5Hn42JgUwGwBDYpjpSxFohZIQC0NkmHnPnRIaY6bpMWsBILaGYYQ3N+vz0Po8YZgMvfP8PIntn5Wx710Sx+9IAjCOP0Dn7fPNy4w8evgOAUgCoDeA150fbty68JTmz+fPGlAcOzgWo/BmfvwQY90//oLv5JxTRbet79g4PW7BUHwncz43xvtRAHJbPrhZz4/b+Xxm9NqOAECvBOfMWMjYZt48N63L2PbUHFuD/rwumfTQy/neYakoJnowM5Y/wro6d0U8PRUexzjqNwD8GPsem7kjb+bm7gWk5+8JAI2cnyuxdFq6reggIAEYHVR9f05uH/IDmx49K52fmXpfAf9v71xDrauqMPxS0I9SowuWCVpWWlZoSEkRZUIYVhT9MjG7QGE3ulMgQaAWZSZRWGT+SCG6WERQmZiVmEWWRhfBLAw1Mu1uUlFBPJ25cLk9X9/e+8xz9pxrPROi+s7ec83xjLHWHmvOcckTk7DDst2gLMxby5EiMYGtjmXlG95gKXFDEDfyXd+qUGUH4lmlXiHrZDcC/RF0fuM2b+TDg5u/k8l9W5LDSkzgpQ3KuazeFpeuXW5WmeyMTdkuOR4l/OX4Ubz0cUnOLrXweHHZbhB6gYPI0TCF5lscy8o2PCuJkz4jyXNKbdip1DlsUTfNrUkHsDmVrLWg15VsUW7ka0czUNLgs8WhIIOUwdEoxYTfmARHCSeR3b+Wi4AuK9+QaPCwJHeWI5yeah1yZI0j98FSume7os9kOfPW/opSFgZnsNWyMMvqTbtc67bfsy9NzS553p1QXhCH5Dhg4txxP/GfoYTU48sOO44SR8UkS5zfcEHoZWUbnpVPSHJDkmNLzPieGZUX2jwBHcDN62AnKxje4tgFYgeJYHuquw+Ow8HFwWPn6JTy0GKn8NRyNMpRBokUrY515EOWw8vO5nlll6yHt9rhKPTCJE8pGcxk/Y7HgSVGiVikFyf5WaOKW0dv2mWbypySXQ6yDE4PHTCIBRzGUeX5SUIcITR0FKJ2Hs9Ldvze0PDzclXZBpnZBWWnnp1DCkP38Kxs807pcFU6gO0rjeNbjifYGVos1zIurUE82AuTvKRkig6SUfOJmB5qWDEeVQqAtpL1W1O+1toZLSsbehl0eUgJNKdeF2/zFKTlaP9X5TOUpSBJZNODnRGO0YaZ8VGeAAAOKElEQVSSQuP1TMEua8rXml0uK1uPdkm9TBI5eJG6ZCGMYmyXFIvns3TYIaZ2GGTFEkdN1x3G0eX5ec2mb7iy3lqytWaTDeCd3xJ0ANvVOXE4tDcj7oRjhzNHx7Tjm5fAZOL8KPnCg+vyshPI/2ZQRJgdQeZpaUxZvmVlI1nn6cXhQzdDjN+7SlwfD3sSe0gSoRVVC0e9rJGi4hyXkZFMaAGZkYwp2OWU5VtWth7tknuOxAx267BDwijeXexynPTA5zgx4ZlIRwxCYPgsZaP4Pbys7PJRELqVMWXZWmE8y3XoALapdrJ3SWLAqaO92b6OaTnCJXCZsifErXCkgfNApig/0ry9khF7WnmwtSLtlOVbVTZ2bjm6p9XUcHRKKQdKvPDDRZkGdiPGuxSb1CN2xvEzR2PjvsTjEhK92iVcpyzfKrL1ZJc4esTFUtOU2Fj6npPdS7eZsfOHXbKrTmksnD7uK56XvCxTAoZuHziQZMW2sOOHPU5Ztk0+x7x2+cERRFsEDioPJGL6qEPFYIePJA1iNOgEQZwGpVvY1eOhRtmQIYmDJA/eXqnBRszYO5JQyLSVMWX51pHtMwtxN2TAcjzFjxn9OlvJYsbBo5gxR2TsTLLbQnIA8YoEkVOgmh1KflgpZ4Mj3JNdTlm+dWTrxS7ZiR5eOL5QHnIUaqYcCke8DHbQ2enDsePFBdmG5yVhMyQrESbDzidzLcbeburZOWXZNsXU644IuAPYjjmMd1Bw7HDwSNygmwUZWoy7S7Fg3nBJ8PhHiRHjb4tFPHH+7mpHvHutb2ry7VR3YzVRu5AkDzq5tDaIHaOVGWukfBAFx28uP7QkpFAgFyeRUjaD7bVul2PGU5ZvHdlatssh3IBuFuz2jZMXcPLY/SMemthZbBBnkBdoYmoZizFwPE9baa84Zdlae6bNej06gJtXPzFgJGSMH0johbdQOj6w20KvRn5YTyq7KziGX1843ti8JNuvYMryzU02ehNTZojdyQPKsRs/qiQW4RheVI5Qe8gk3E53U5FvDrIt9rkdvwTTxYTuHVQDoFZmL2PQ2xRl60UHs1qnDuDm1M3bKXEnJHGQ5UscyvjG59+I6WMnkOrzDDJAie0jiJmHXMtjyvLNVTbKYnDES/1IjoKpi8bgOI1dXeqjkcVMPGOr4//prnf55ibbvjJZhxaXFEvn5bn1sZ3epiJb6+xnvT4dwM2on0BjCotyPEHHjp+Xauzj1aAbkjkWMz8Jzj6mlODg6KPFMWX55i4bx74fTXJ1OWIbXlqoJ0ZJmOcnua5FoywB/vu773qVbxm7nLJsY5M7NAkF4HkhoZJCy2MZvfUqW8vcXZtJIHtuA+MfS976eDixm0KwL1086Nm73fb/sFCCmSlcelOSN+/56vd/wSnLN3fZKEVB6QxeSsg8x/6ooXZFMQvirghRwAFsravMMrrrVb65y7b4vBxiTglJIJOerOAWa94to7deZdv/L4WfaIKAO4B7owayeHHa/j263FCUlGLBlHzh/w89KBcD58lQI8OUau0c/fJQG5fg2Bsp9n2VKcunbPfY5fCD9JjSi5gQhaF/Mc4f3RNIXlm0303Z56q660k+Zdv38xL7Y/ePGGpeUkiea2WsqrfFe6ll2Vph7DqWJKADuCSoNT9GjNS5JSuSjF2q01Oz718LP5LET1GuhXg/OneM31jZUaHuGnP9tNSu+uWa66n9tSnLp2xbcX1juxx3UsCWKFNDvBUlhyhWfmNtA1tzvnV114N8ynZfu9xuh4/TFZKROPLfrqf2mqa19tfW1VsPsq0NxS9uloAO4O7xp4YfDh/9aCmR8dxRUU8eTsT2DT84xKxQnJQafieWvw1HUmSysTPIj+s3d2+5K888ZfmUbWu3eju7pFYaLzCtjp3qrmX5lG3/djns4rakx1p6a1G2Vp8DrmsJAjqAS0Ba8SPDlj2V6Sk8SnD88AZKFXoeBmT/0kJrPHDyyFr7apIvlWNhCpTeuuL1d/vjU5ZP2fZvl+eU7jRTtcsW5atll8q220/He88/Zb3tLUmvtisEdAB3Bev/Jv1sSehg6394G31w6c3LcfDbktwySvqgzh/HxTh9/ym7fRz9UlS3xTFl+ZTtnmQk7bKdu0+77NMup6y3du4OV7IyAR3AlZHd5wvPKx0QKOlCyzWKOjPoM/nhJNQW4zhtcALpzUv/SdoVfbl8lsxKPk8MINlrtCMi3q+FMWX5lE27bPG+0y77tMsp662F3yLXUJmADuD6QCl4S8Yj1dspikv8HgWayTrDCTwyyZWlkwfO3hDTxxVJ4uAI+Kxy+aPL5zgavmT9JVX95pTlU7atDjPa5RaHVu477bJPu5yy3qr+qDhZWwR0ANfTB8diF5QuHpS+oB8qA8ePos5kT9KLl528M5McVWL5howu2rhRxJkioC2OKcunbNpli/eddtmnXU5Zby3+NrmmigR0ANeHSTkXijJfNsrmZUfl5CTPKCUIqJfGjh7ZvlThx1Gk8wcOIJ/l+62OKcunbNpli/eddtmnXU5Zby3eJ66pEgEdwPVBjssMDNleOHv0QX3taNqhLRE9f68tWcEcAZ+S5Pb1L7/r35yyfMq2VeKFdlna5a7fSktfQLvs0y6nrLeljdcP9kdAB7Cuzq4qsXw0IOe4l0FbrMclOa5Upv9JkovrXnbPZpuyfMqmXe7ZjbTChbTLPu1yynpbwXz9aMsEdADraeeIJNeUos0/KtOOEz/qXWkzM01ZPmXbjE3VuKq6q0Fx7+dQb3vP3CtK4F4EdAB3bhDD8e/pJa6P3T4GfXsfWf77jp1fZmMzTFk+ZduYWe34wupuxwg3MoF62wh2LyqB+xLQAaxnFR8rTcevKOVhyA57eZLL611iozNNWT5l26hp7eji6m5H+Db2ZfW2MfReWAJbBHQA61gCgfQUbn5safvG7t8H6kzdxCxTlk/ZmjCxtRah7tbCtvEvqbeNq8AFSEAHsKYNUAz6ptLijVZvUxtTlk/Z+rVWdden7tRbn3pz1RMi4A5gPWXev/TwrTdjWzNNWT5la8vWVlmNuluFVjufVW/t6MKVzJSADuBMFa/YEpCABCQgAQnMl4AO4Hx1r+QSkIAEJCABCcyUgA7gTBWv2BKQgAQkIAEJzJeADuB8da/kEpCABCQgAQnMlIAO4EwVr9gSkIAEJCABCcyXgA7gfHWv5BKQgAQkIAEJzJSADuBMFa/YEpCABCQgAQnMl4AO4Hx1r+QSmDuBbyf5cZK3zB2E8ktAAvMjoAM4P50rsQQksEVgFQfwhCTfSvKQJH8WoAQkIIHeCegA9q5B1y8BCaxLQAdwXXJ+TwIS6J6ADmD3KlQACUhgCQIPSvLxJC9NcleSDyV50egI+LRyFHxUkruTXFn+/x1JHp3k5oVrfDrJK7PVT/2dSc5IckiSXyQ5K8mlS6zJj0hAAhLYGAEdwI2h98ISkMAeErigOHyvTnJ7kvcl4Vj3ouLo8e+/TXJjkoOTnJ/kT0lOTkLf2hcn+WISHMS/Jvl7kr8kOac4lcQR3pTk2Uk+keSkJN/ZQ/m8lAQkIIGVCOgAroTLD0tAAh0SOCDJH5KcnuRzZf0PTXJbkk/uIwnkaUl+kOTAJH8rzuJiDCC7ir9PcmKS7424fCrJA5Oc2iErlywBCcyEgA7gTBStmBKYMYFjylHv4UluGXG4vuzSsXv31CTvTXJsEpzD+xUn7klJbtiHAzg4iRwZj8cDkjD38TNmrugSkEDjBHQAG1eQy5OABHZMAKcOh2xfDuCZSX6d5PJyfHtnksOSfKM4hpSK2S4LGAfv++Vvv1lY5T+T3LrjlTuBBCQggV0ioAO4S2CdVgISaIYAR8B/TEKix+fLqijnwhHwhUkuSfLD4vQNThuf5d/ZGcQBfGaS7yZ5eDlOZhqOh3EWX1M+24zALkQCEpDA/gjoAO6PkH+XgASmQIAMYBI6SPb4XUneIHaPJBASOXAGP1J2AJ+c5NwkR44cwEPLjt6rknytJIEQG3h2yQB+e5KrkxxUnEX+RqawQwISkECTBHQAm1SLi5KABCoTYBdwXAbmvCQvGJWBeVnJDKaUy3VJ3p/kKyMHkOW8J8nrkzwiycWjMjBvKv9+RCkSzffJMr6qsgxOJwEJSKAaAR3AaiidSAISkIAEJCABCfRBQAewDz25SglIQAISkIAEJFCNgA5gNZROJAEJSEACEpCABPogoAPYh55cpQQkIAEJSEACEqhGQAewGkonkoAEJCABCUhAAn0Q0AHsQ0+uUgISkIAEJCABCVQjoANYDaUTSUACEpCABCQggT4I6AD2oSdXKQEJSEACEpCABKoR0AGshtKJJCABCUhAAhKQQB8EdAD70JOrlIAEJCABCUhAAtUI6ABWQ+lEEpCABCQgAQlIoA8COoB96MlVSkACEpCABCQggWoEdACroXQiCUhAAhKQgAQk0AcBHcA+9OQqJSABCUhAAhKQQDUCOoDVUDqRBCQgAQlIQAIS6IOADmAfenKVEpCABCQgAQlIoBoBHcBqKJ1IAhKQgAQkIAEJ9EFAB7APPblKCUhAAhKQgAQkUI2ADmA1lE4kAQlIQAISkIAE+iCgA9iHnlylBCQgAQlIQAISqEZAB7AaSieSgAQkIAEJSEACfRDQAexDT65SAhKQgAQkIAEJVCOgA1gNpRNJQAISkIAEJCCBPgjoAPahJ1cpAQlIQAISkIAEqhHQAayG0okkIAEJSEACEpBAHwR0APvQk6uUgAQkIAEJSEAC1QjoAFZD6UQSkIAEJCABCUigDwI6gH3oyVVKQAISkIAEJCCBagR0AKuhdCIJSEACEpCABCTQB4H/ApoII9zKa5hbAAAAAElFTkSuQmCC\" width=\"640\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "<matplotlib.axes._subplots.AxesSubplot at 0x7f3cb4e33358>" - ] - }, - "execution_count": 149, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Relative Spread Difference\n", "spread_ratio = ct.ratio_within_series(param = 'closespread')\n", @@ -5176,802 +131,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'] / mpl.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", - " var x1 = msg['x1'] / mpl.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys (original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object')\n", - " obj[key] = original[key]\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * mpl.ratio;\n", - " var y = canvas_pos.y * mpl.ratio;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event)});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value,\n", - " guiEvent: simpleKeys(event)});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " var width = fig.canvas.width/mpl.ratio\n", - " fig.root.unbind('remove')\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", - " fig.close_ws(fig, msg);\n", - "}\n", - "\n", - "mpl.figure.prototype.close_ws = function(fig, msg){\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width/mpl.ratio\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\n", - " });\n", - "}\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\" width=\"900\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "model = ct.curve_model()\n", "model_results = ct.curve_model_results(model[0], model[1])" @@ -5979,139 +141,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<table class=\"simpletable\">\n", - "<caption>OLS Regression Results</caption>\n", - "<tr>\n", - " <th>Dep. Variable:</th> <td>ratio</td> <th> R-squared: </th> <td> 0.972</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Model:</th> <td>OLS</td> <th> Adj. R-squared: </th> <td> 0.972</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Method:</th> <td>Least Squares</td> <th> F-statistic: </th> <td> 6334.</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Date:</th> <td>Mon, 27 Nov 2017</td> <th> Prob (F-statistic):</th> <td> 0.00</td> \n", - "</tr>\n", - "<tr>\n", - " <th>Time:</th> <td>14:47:03</td> <th> Log-Likelihood: </th> <td> 2133.4</td>\n", - "</tr>\n", - "<tr>\n", - " <th>No. Observations:</th> <td> 742</td> <th> AIC: </th> <td> -4257.</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Df Residuals:</th> <td> 737</td> <th> BIC: </th> <td> -4234.</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Df Model:</th> <td> 4</td> <th> </th> <td> </td> \n", - "</tr>\n", - "<tr>\n", - " <th>Covariance Type:</th> <td>nonrobust</td> <th> </th> <td> </td> \n", - "</tr>\n", - "</table>\n", - "<table class=\"simpletable\">\n", - "<tr>\n", - " <td></td> <th>coef</th> <th>std err</th> <th>t</th> <th>P>|t|</th> <th>[0.025</th> <th>0.975]</th> \n", - "</tr>\n", - "<tr>\n", - " <th>Intercept</th> <td> 5.8498</td> <td> 0.113</td> <td> 51.951</td> <td> 0.000</td> <td> 5.629</td> <td> 6.071</td>\n", - "</tr>\n", - "<tr>\n", - " <th>closespread</th> <td> -0.6201</td> <td> 0.007</td> <td> -83.803</td> <td> 0.000</td> <td> -0.635</td> <td> -0.606</td>\n", - "</tr>\n", - "<tr>\n", - " <th>duration1</th> <td> -0.3168</td> <td> 0.020</td> <td> -16.105</td> <td> 0.000</td> <td> -0.355</td> <td> -0.278</td>\n", - "</tr>\n", - "<tr>\n", - " <th>theta1</th> <td> 0.1283</td> <td> 0.014</td> <td> 9.501</td> <td> 0.000</td> <td> 0.102</td> <td> 0.155</td>\n", - "</tr>\n", - "<tr>\n", - " <th>theta2</th> <td> 0.3950</td> <td> 0.020</td> <td> 19.401</td> <td> 0.000</td> <td> 0.355</td> <td> 0.435</td>\n", - "</tr>\n", - "</table>\n", - "<table class=\"simpletable\">\n", - "<tr>\n", - " <th>Omnibus:</th> <td>1103.214</td> <th> Durbin-Watson: </th> <td> 0.938</td> \n", - "</tr>\n", - "<tr>\n", - " <th>Prob(Omnibus):</th> <td> 0.000</td> <th> Jarque-Bera (JB): </th> <td>640506.151</td>\n", - "</tr>\n", - "<tr>\n", - " <th>Skew:</th> <td>-8.019</td> <th> Prob(JB): </th> <td> 0.00</td> \n", - "</tr>\n", - "<tr>\n", - " <th>Kurtosis:</th> <td>146.038</td> <th> Cond. No. </th> <td>1.74e+03</td> \n", - "</tr>\n", - "</table>" - ], - "text/plain": [ - "<class 'statsmodels.iolib.summary.Summary'>\n", - "\"\"\"\n", - " OLS Regression Results \n", - "==============================================================================\n", - "Dep. Variable: ratio R-squared: 0.972\n", - "Model: OLS Adj. R-squared: 0.972\n", - "Method: Least Squares F-statistic: 6334.\n", - "Date: Mon, 27 Nov 2017 Prob (F-statistic): 0.00\n", - "Time: 14:47:03 Log-Likelihood: 2133.4\n", - "No. Observations: 742 AIC: -4257.\n", - "Df Residuals: 737 BIC: -4234.\n", - "Df Model: 4 \n", - "Covariance Type: nonrobust \n", - "===============================================================================\n", - " coef std err t P>|t| [0.025 0.975]\n", - "-------------------------------------------------------------------------------\n", - "Intercept 5.8498 0.113 51.951 0.000 5.629 6.071\n", - "closespread -0.6201 0.007 -83.803 0.000 -0.635 -0.606\n", - "duration1 -0.3168 0.020 -16.105 0.000 -0.355 -0.278\n", - "theta1 0.1283 0.014 9.501 0.000 0.102 0.155\n", - "theta2 0.3950 0.020 19.401 0.000 0.355 0.435\n", - "==============================================================================\n", - "Omnibus: 1103.214 Durbin-Watson: 0.938\n", - "Prob(Omnibus): 0.000 Jarque-Bera (JB): 640506.151\n", - "Skew: -8.019 Prob(JB): 0.00\n", - "Kurtosis: 146.038 Cond. No. 1.74e+03\n", - "==============================================================================\n", - "\n", - "Warnings:\n", - "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", - "[2] The condition number is large, 1.74e+03. This might indicate that there are\n", - "strong multicollinearity or other numerical problems.\n", - "\"\"\"" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model[1].summary()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "module 'curve_trades' has no attribute 'curve_var'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m<ipython-input-13-e8b1ca15c614>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#Var on current position\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mct\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcurve_var\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m: module 'curve_trades' has no attribute 'curve_var'" - ] - } - ], + "outputs": [], "source": [ "#Var on current position\n", "results = ct.curve_var()" @@ -6120,9 +161,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "results\n", @@ -6134,9 +173,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } |