StructureTensor3D_Examples-checkpoint.ipynb

       "        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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // 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,iVBORw0KGgoAAAANSUhEUgAABAAAAAMACAYAAAC6uhUNAAAgAElEQVR4XuydebRkV1n295lruEMPGRkSCAjK9DEGBUIMAQRlEBJQGUWmT2UK04KFy/WxQJbMi2BYiILggBDQRIgSCQkEArgSICCTCAKBSJKe+95bVafO+K19kqpznqe67+3u292pe+upf5LqW+ecvX/73fucemo/7+uUZVkavURABERABERABERABERABERABERABDY1AUcCwKYeX3VOBERABERABERABERABERABERABCoCEgAUCCIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACIiACIiACIiACIiACIiABQDEgAiIgAiIgAiIgAiIgAiIgAiIgAjNAQALADAyyuigCIiACIiACIiACIiACIiACIiACEgAUAyIgAiIgAiIgAiIgAiIgAiIgAiIwAwQkAMzAIKuLIiACIiACx5/A7//+75uPfOQj5uyzzzZf+MIXoAH2/TnnnFP9209+8hNzl7vc5fg3cJNc8cMf/rB53vOed1i9ORzmz3nOc8zf/d3fjc9fluVhXUsfFgEREAEREIFpIiABYJpGQ20RAREQARHYNAQkAByfoTxcAWD79u3mF7/4hQnDcM0GXnHFFeaxj30sfE4CwJrY9AEREAEREIEpJiABYIoHR00TAREQARHYuAQkAByfscuyzMRxvOrFvvGNb1Q7MezrJS95iXnve9+7ZuP6/b65z33uU+3QOOOMM8yPf/zj6hgJAGui0wdEQAREQASmmIAEgCkeHDVNBERABERg4xJYTQDYuL3amC1/2cteNv7Sf91115kHP/jBa3bk1a9+tXnnO99pfvd3f9dEUVTZOSQArIlNHxABERABEZhyAhIApnyA1DwREAEREIGNSUACwHSMW5qm5g53uIPZtWuXufe9722+853vrNkwu2PgzDPPNHNzc+a//uu/zOte9zoJAGtS0wdEQAREQAQ2AgEJABthlNRGERABERCB25WA/dJ44YUXmi9+8Yvm5z//ucnz3JxwwgnmlFNOMQ9/+MPNk570JHPuuedCG4+GBWDnzp3moosuMpdffrn50Y9+ZJaXl83JJ59cbUl/whOeYH7nd37H3PnOdz4gG5to8IMf/KC55pprzM0332yCIKiOs2294IILzNatWw+b6eH67adhu/y//Mu/mN/+7d+u+vq2t73NvOY1r1m133ZsH/KQh5jrr7/evO997zN/+Id/aEZjaQ+chj4d9sDpABEQAREQARG4jYAEAIWCCIiACIiACKxC4GMf+5h59rOfbazX/GCvA/2yvF4B4OKLLzbPf/7zzcrKykGv+9znPtfYL+XN13A4NC984Qshcz2fwIoIl1122SFthW8euxEFgKc+9anmkksuMZ7nVeLNqaeeumq8v/3tbzevfe1rza/+6q+aL3/5y8Z1XQkAWiFEQAREQAQ2DQEJAJtmKNURERABERCBo01g37591S/s9kv43e9+d/PGN77RPPShDzU2k3yv1zM/+MEPzJVXXmnslvHPfOYzcPn1CACf+tSnql+t7a/N9gvr61//+iob/UknnWT2799f/Tptv9R2Oh3z/ve/H65rPesf//jHje/75o//+I/NM57xDHO3u93NJElS7Qb40z/902pbuxUBvvnNb1a7GA71tVbCvR/+8Ifm13/9183S0pJ5wAMeUHFpvlYTMw6lDXYXg/XjH+pr9+7d1fZ/2/fHPe5xE2PE57GJ/mziP2sb+PrXv27ud7/7VR/RDoBDJa7PiYAIiIAITDsBCQDTPkJqnwiIgAiIwO1G4NOf/nS1Zd6+vvWtb42/EB5Kg45UALDZ508//fTKs26/uH/pS1866K/W9gu5/aI/el166aXmKU95SvWr9b/+679WX3r5ZQUEu8Xdflk/1Iz4h9LfPXv2VL+a2/PaL93XXnutueMd7wiHOo5zKKc66GcOtONhtRNa+4Tto33ZnRzWMrHa6zGPeYz53Oc+Z2wCQLsTYPSSALCuYdPBIiACIiACU0RAAsAUDYaaIgIiIAIiMF0E7K/sdgu5fVk/vvX9H+rrSAWAD3zgA+bFL35xdZnPfvazxn4pPdSX/fX96quvNs985jPN3//93x/0MJvR3rZv27ZtldCw3i/m9hd2206bI8HuSrD/fdCDHjRx/fVe53AFAJvIz2b9X1xcrPIgtFqtNZmcdtpp5nvf+57pdrsSAA418PQ5ERABERCBDUNAAsCGGSo1VAREQARE4HgT+J//+R/zS7/0S9VWfJt0793vfndlBTiU15EKAE9/+tPNJz7xierX8xtvvPFQLlV9xu4c2LJlS7V9/UMf+pB52tOedtBjrQXA7gKwL5tc0O40WM/LfjH/27/920pI+Kd/+qdqF8Lt/fr+979v7nWve1XNeNGLXmT+8i//8qBNsuLOr/zKrxhrGbD2iyc+8YnwWe0AuL1HU9cXAREQARE4WgQkABwtkjqPCIiACIjApiTw0pe+1PzFX/zFuG/2S+VZZ51lHvnIR1a/ep944okH7PeRCgD2l3Prnf/N3/zNahv/ob5spYL73ve+h/rx8ee++tWvVlv3j/T1pje9qcorYF9vfetbqwR60/CyeRP+/M//vGrKV77yFfNrv/ZrB22WzZPwj//4j5Vw8c///M8Tn5MAMA0jqjaIgAiIgAgcDQISAI4GRZ1DBERABERg0xKwv/7/9V//tXnPe95jvvvd70I/rf/+vPPOM+985zsn/O5HKgDYHQf2V3nrV7e+9UN92Yz1j3jEIw714+PPff7zn68S9x3Jy7bPfnm2jP7gD/6gKju42ut4JQEsiqLKo2B3UNzjHveokjUe7GXtCmeffbaZm5szdtfAne50JwkARxIMOkYEREAERGBDEJAAsCGGSY0UAREQARGYBgK2jJz9xdwm5rMJAm+44YaqWdY3bpME2i34o9eRCgBHugPAXv/+979/dfkDbWM/2vwsh0c96lEmjuNKQLD5CmyW/tVexysHwBVXXFFVTbCvN7/5zeYNb3jDQZt1uKUNRyeyosEXvvCFo41V5xMBERABERCBY0pAAsAxxauTi4AIiIAIbFYC9lfmt73tbVWJPvt617veZS644IJ1CwD2l/+LL774sHMA2Oz+NqmfbZfNVfCKV7zimKH/yU9+UpVDtN55u2PhP/7jP6prr/U6XgLAs5/97CoJoq2G8NOf/rQq5XiwlwSAtUZNfxcBERABEdhMBCQAbKbRVF9EQAREQASOKwG79X1hYcHYre2caO5IdwBYu8ELX/jCqh/2l+xHP/rRh9ynhz3sYdUOBfvl3H4pPxYvKzRYP73dLm+/9Nvr2W320/JaXl42p5xySpUU8dxzz63K+q32suULf/azn636GZvjwO74sK/rr7+++q+1DBxqQshpYaN2iIAIiIAIiIAEAMWACIiACIiACByEgP2l22bjD8PwgJ/4xS9+UXnGrRBgdwK85S1vGX/uSAUA+8X1Lne5y/jXdWs3OPnkkw94/SzLjM1DMHrZDPznn39+9da2ZbQ74UAH2zb/93//t7nnPe95yONvr/f4xz+++lJtt/vbbf9Hmj/gkC96mB/8m7/5myofgX3ZygR2N8B6X0oCuF6COl4EREAERGBaCEgAmJaRUDtEQAREQASmjsD/+3//z7z//e+vEvJZT/m9733vyue/d+9ec+2115o3vvGN1S/hdqv517/+9bEH33bkSAUAe6z9tfnJT35yJSxYAeJ1r3ud+Y3f+I2q4sDS0pL55je/aS655BITRVHVvubrWc96lvmHf/iH6p9sJYEXv/jF5oEPfKCZn5+vjrVf+m3iu49//OPVL9iXXXbZIXN/5StfWdkL7MsmRRx90T7YCeyv5Mf7dc4551TefNvfm2++2XQ6nXU3QQLAuhHqBCIgAiIgAlNCQALAlAyEmiECIiACIjB9BKwAYL/kr/byPM9ceOGF5o/+6I/gY+sRAOyJbIb95z//+dVW9oO9nvvc5xrrYW++0jQ19ot6s3ThwY4/WNm7g33e/tp/9dVXH/JAWQHjeL5sUsa73vWulXDyvOc9z3zoQx86KpeXAHBUMOokIiACIiACU0BAAsAUDIKaIAIiIAIiMJ0E9u3bV213v/LKK83XvvY1Y7f828R31hJgt+nbL8T2i/+97nWviQ6sVwCwJ7zpppvMe9/7XnP55ZebH//4x1XGfetvt19yn/jEJ1Y7E+wOgQO9/vM//9N84AMfqL6wW497r9erfhW3xz7kIQ+pdgfY7fwHszcc6JzTLgC86U1vMtavb192F4DN1H80XhIAjgZFnUMEREAERGAaCEgAmIZRUBtEQAREQAREQAREQAREQAREQARE4BgTkABwjAHr9CIgAiIgAiIgAiIgAiIgAiIgAiIwDQQkAEzDKKgNIiACIiACIiACIiACIiACIiACInCMCUgAOMaAdXoREAEREAEREAEREAEREAEREAERmAYCEgCmYRTUBhEQAREQAREQAREQAREQAREQARE4xgQkABxjwDq9CIiACIiACIiACIiACIiACIiACEwDAQkA0zAKaoMIiIAIiIAIiIAIiIAIiIAIiIAIHGMCEgCOMWCdfnMR+MQnPmEuuugi861vfcskSWLufve7m2c+85nmggsuMEEQbK7OqjciIAIiIAIiIAIiIAIiIAKbioAEgE01nOrMsSTwile8wrznPe8xvu+bRz3qUWZubs5cddVVZt++feYRj3iE+exnP2va7faxbILOLQIiIAIiIAIiIAIiIAIiIAJHTEACwBGj04GzRODSSy81T3nKU6ov/VdffbV54AMfWHV/165dlRjw7W9/27zqVa8y73jHO2YJi/oqAiIgAiIgAiIgAiIgAiKwgQhIANhAg6Wm3n4EzjzzTHPdddeZN7/5zeYNb3gDNOSaa64xZ511lomiyNxyyy1mcXHx9muoriwCIiACIiACIiACIiACIiACByEgAUChIQJrEPjf//1fc6c73an61I9//GNz17vedeKI0047zfz85z83H/3oR83v/d7viakIiIAIiIAIiIAIiIAIiIAITB0BCQBTNyRq0LQRuOyyy8wTn/hEs23bNrN79+4DNu+pT32queSSS8xrXvMa87a3ve2Iu9Dtdk2apuakk0464nPoQBEQAREQAREQARGYFQI7duyoEjH3er1Z6bL6KQLrIiABYF34dPAsEHjve99rXvayl5n73//+5vrrrz9gl1/+8pebCy+80Jx//vnGVgo40lcYhiZPM7Mt7IxP4TglnM5xC3hfGvw7vjOGDp9sGh9An2ie33Ed/Cu9LbmtPn6g9PBihUMn4Nbl1LiMLp/T+7X6UtAHShfZcnsmukusGS7zaZy9LPnaqzfWMauzmTgfjwWGiTET1+fO4fu1rm8o7iYCa+L09T8U5UTj8HBC46wxLpNsJ4KY/oH6yqgxLEzJf/co7uh9QWyclC6f+as2sHm5sqQgXxs0xvQa6wOH2UTUTcwBmtN8fh67ibBfY87TWLv0ntc704ylVWLOQpk8lsJuoq0Yp47h9YIC5bAXflrbJ9ZDWm94DnNUr7L+VP1f5Xie7xMxPzHf17gX0LX40jyujI4/n7nMnm9F2J6JkaE1p5y4F9Rj7dKkKOk9r0eTa+Xq9+jJpZP7tkZc8Fo/wRqPdx08P8+DifZP3EsOfq/imHJonNa4jU3el+iAifk/EZi3st49HBr72bTge8thT0odIAIzQUACwEwMszq5HgJvectbKt//wx/+cGP9/gd62b/bzz32sY81//7v/77q5UZ2ggN96KabbjLb/Lb5xzOfPf7z/Dwq2m5nDxwaBzG8L+gG6CT0ZSeju3tCLaHvG3njC0i0NYIPp238ZpMv4sGdX6qFDHvg8h0GcPxSC9tSFPjFyNmB53d/hO+jG/HBJFjGBx0/x29m8T5ilWL7wmgO2hcEeHzQ6sPfkxDhufON/tAT6CDGvid9PDYwWEYycPA9P2gNEjyf62Nbh70htDVbRnZFD/seRfPwec/D83kedijPaWz4S7GPrFuL9fWW4iXkOMTPuvRw3ulQdQ1mO0AWhp4B82WMyzLHvnc69IC7BS+QzNM3+DvgnGndFefFUr4fPuB+E+Pc+9Hd4e8OzdnQq3kMejdRTGJcZBleOwhC+LxP45B7NMEnxg3bakXJ5ssL8YAsRVUuiTGuvQQ/n8bIvixxznsevu908Ppliecf5vV6yG0LWsSqxLba3VbNV5Fg4PT24drrm23w+bm5BVo8se15jnMwirA9eY594SoyOcXRcIjnMzR2rXli62JcJ43j8xzjoBW0oC8lHZsSO5/YFjwnqa1Jhuw7DZHbXtilKTYkcfZHW5G9T3Gy1UEYC3SbK3q45hRL+L5cWR73f4FYZHyfaHWBVRTQF2wat4zYFSkJSw6uvSHdVzo8riQ8r8QrGMd0fpu8uPniORu4GJce3UviPsZdmtRxm1AMz22hORESG1rb8xTjMKCgniPWaYLrgePcOkefeNVV1X93xHgvoQmqtyIgArcRkACgUBCBNQhIAKhv0BIAJACMposEgHrhkABQs5AAULOQANCICwkAYxgSABpzRAKAnsFF4HYhIAHgdsGui24kAsfTAmB3Bwx37tMOgJFCqR0A46miHQCNVUM7AMYwtANAOwBGwaAdAPUaoR0ANQvtANhIT5xqqwgcHwISAI4PZ11lAxP49Kc/bZ70pCeZ7du3m127dh2wJ6MkgK9+9avN29/+9iPurRUAkl17zaVnnz8+RxBg4sGkhdtGsxC3VrK3MfRwy1w2wM97tE0+pC3ESWO7n9/BLa5lm7yGtHW6OAO3Oi4/GLci/ncPv8nF+3Er4+kObg88+Sbcptr6KaLOdtD2P94ZPsT2hAbZ5LTVsyzrbaH2SkWExw8dvJ7TrvedJg5theb9upTPwM2RBW/h5y27mcETRCFtBadtnSlZANIe7rnt0lbL4ZC3M9MWWmcNryXlfygau0yHGW2Npm3mJf0qxJ5ZFkN4K3d/GXdqGLK5uOTlnp/HLbj+IllRTsCxCe9McUPWl8EQr+/fgOcLfkpzMsOt21laz/l+hudqRTgHAg+37/LW6O4CblemkDchbbFvzncb87xduJ9ge/jvBc2xqMC4NDmWSfWo/TaRV/PV6WB/k2Qn/H1fv7ZbFAVtJ6Zt6p055Mxe7izBOZX18X3cw3Fs0ZwxNMdL2vod0FbxLNsHfcnoV3LaBW/8gHJHUM6AsI1xRWFu8rzuT07XarWQM7eFLQAB2RnYV86/cscruBjz39kSNdchO1a0HViRs82Yhm3GftCNONcErlcTWTiaPGgLvU/2LOPiNnf2qa8s/WLVcXXJJ2+T/zZfbONzW7j+sKUgTXAt5y38/EDSiXAeeCXaJ/bvRQtTTNvqm3OU15eE7Q5kJSk4X8EEa7KecZ4eQ3aG28btBd+9turmroRsMkf8NKYDRWBzE5AAsLnHV707CgRuvPFGc+c737k607EuAygBQALAKGQlADQm70RyNvwHCQA1KwkANQvOASABQALAKDokANTzRALAUXhQ1ClEYIMRkACwwQZMzb19CJx55pnmuuuuM29+85urhIDNl00MeNZZZ5koiswtt9xiFhfxF67DabEEAAkAEgCM0Q4A7QAYzQPtAGiIO9oBMIahHQB1XGgHgDHaAXA4T5r6rAjYCmGr1YURIREQgYrApZdeap7ylKcY66W7+uqrzQMf+MDq33fv3m3OOecc8+1vf9u86lWvMu94xzvWRUwCgAQACQASAGQBqJdRCQASACyBQBaAcSDIAlDPiZFVRQLAuh49dfAMEpAAMIODri4fGYGXv/zl5sILLzTW/3buueca69u78sorzb59+6oSgVdccYXhMk6HeyUrAKS7d5vPPPax40OLDnoXg3kqJeWj79VzqXQdeWwNWeTKjPZXk7W7mVOgcMlDT55TZwv6LrNfxs9/5XT0A/8Eq2yZ4T4scfiAbehLfeAAvdrmP8mDvw+vl62Q0Z76zv7pIZU7cqnkmUdeTKeD/W36tbMCrx36VJ7NwU2ofO00pjJ75BvlMn3soc0TjAuH6if7dP0yxTjIyU/N/en3yWdPllv2DBuv/gB7lVs+xkWvt3pZK65rzZ7XAfuNqbxbK8S48n0cC7dLdbkXKa4XcGxbJ+D5eOyivdi/zjJ6cLm9aVGPPft/uWY3+9gnMowH2PbuFvQbB20qAUblH3s9nKScY4TZcQ6AoodzMlmh0pnuVlgmWy3y2Xcxjpts7IFxI59ERmX92GvtNGLQHsslDtlKMlzBBcPNMC6CANvO6z3n7YiHmM+FS+1xe/n3Ga7G7lCejTxDViGN7TCt+5NluL6wz5vZuJS/YCIuyNvN28qLjO4dlJsmH1L+BrpvMUvHw512KeVTyA3dF9vkLfepZGyz9B3dE3mtHFIM8zj5NIcKqkuapDgHeNdgTmVBMwfHikvv+RHOGbsbsflyClq/KLcFPwO45LtfXsZcOM0cAGyz8bpUvpZKVXKM8n3PJBjlBd3HAn8L9G0UF3/8o2/d+qMMsT3cZzB9XgRmhYAEgFkZafXzqBC4+OKLzUUXXWS++c1vGvuweLe73c0861nPMhdccMHEw+SRXFACgASAUdxIAKhnEH+plQBQs5EA0PhSKwEAbjsSAGocngSAegeBBIAjeTzTMSKwqQhIANhUw6nObHQCEgAkAEgAMEY7ALQDYDQPWtoBML6taQdAQ/jSDoAxDO0AMEY7ADb606/af7wJSAA43sR1PRFYhYAEAAkAEgAkAMgCUC+SEgBqFhIAJABYArIA1HEgC4AeqUXgyAhIADgybjpKBI4JgUoA2Lvb/Nv5jxmfPyBPnUP1jYsSvZXtVhvaxvXe2dfK/j8nR79g1Kr9hOw/Zp9l7KAnP7kjefJ/4xRo23/20au4ey/W+L73VmzLXW6hvv4YDYYOlqo3hmzqXOe766Mf2nHxeuwJdkLyUoboBW/yCFvo+Z/wYQ7oWPLAttrkK6ftzYM+1tVmz37goBczcpD1hMef6oI3/cJ20Hp99ILz1nPOPeGE7LGtfaoTuWfRrmtK8sCyBSAk//DKCuYM4LraHLdJTD50B9taRBhneQcb2NqOYxPNE9sBfn64E73k8S6cJzHlnphfrGtdL2bWaq4AACAASURBVGzHmuPs2WdvNM/nOMVrcVz2hzhJOO7YbuF6xIryK0zkIBhScggu001jz55in3ICcA6ANG3Moxy/Ije9yjaG0xy91Ib8yZzPII+xceyN5r4Oh9g59tE382DY9uQOnn8wwDnN88SjXBVZs+/2iyHVQPcoh4lp+PR5/o6SqY0WaB4H5r68dHBfuD2HVyDc/jLGWTvA+5RrqNY9rUcFrQm8nu7v4eLP/eNcGty/Zj6FuQ7eF/or2HaOA55z/D6IcC1m1qXBuHUo3wKhMX6XihgiOsNz1ElxDnpDynFCf3ddXHMyyq/QFCD4GcDQ84lH+QkczmVTYpxkPVybDb8dIssguHUtftH3r63+u7uR5+KYPKTppCKwSQhIANgkA6lubA4CEgAkAIwiWQJAPaclANQsJADgl3gJAHVsSACoWUgAaLCQALA5HhDVCxE4igQkABxFmDqVCKyXgAQACQASAIx2AGgHwHgp1Q6A+q6iHQCNL7WU2V47AGo22gGw3icxHS8Cm5+ABIDNP8bq4QYiIAFAAoAEAAkAsgDUi7YEAAkAloAsAI05IQvAGIYsABvoAVdNnSoCEgCmajjUmFknUAkA+3abf33mo2sUaCU37FtNBmiS29rF2tQre9AfzTkBApf8iQnVOG/Vfucw4MbgiMUl+o3LLtVevivWbv7vdBecII7QZ36nk9DruLAHvdbBfmx7/yb0aoYFttfLqD3kU4172H7Orsz5F5wOeiubdb3ZT5wNkWvWw/dc9q/VRZ95VtLxOb0nz2xQIJt2hJ7beIXGiup4R11kPWzUW68eyB30yZONdWIqN3+9ZA9+FuO27sgjT31KNcIpZnlOTGz/ZU8teb+5b6WDntxwDuOIPbhpgu3nOeWnGMfFkNhR3g0/ajSQphzXfg98HOdBjD7yqI0sOa9FklA+BMrdwPkT4iHGDeccyalud075ELZ3t0NsDHvom+e4Yo9xRnHfCuu4dgv0NqcF9i0vydNPccFtjwJkx1YUHvcwwsHitjfXBwuB14iYcgiwV5zHjicZr89cTaPdrll5VKue8xcYQ/lOSoxxXo8M5XLgceUcAJGPbD2exNQ5zs/C+RE4FwYLBryWc06AXlzfOxyy2HNccF/5Pa/1c3N1Tg/brYm8HbT2FrT+eM31wBjTXsS1PMkwzjmXBOdjcGMa22XKR5Pj+cMQ15jCqfM/cP6T1MFzcT6DdofOTflcihUOJFyLc2pbctt684Lv/UcVMbspD8asP1Oq/yJwMAISABQbIjBFBCQASAAY7wCQADCembkEgDELCQAkUEoAGMeGBID6Zi4BoGYhAWCKHvLUFBGYEgISAKZkINQMEbAEJABIAJAAYIx2AGgHwGgeaAdAfW/UDoCahXYA1Cy0A8AY7QDQM7QIHB4BCQCHx0ufFoFjSkACgAQACQASAGQBqJdZCQASACwBWQDqOJAFoCF+yAJwTJ9JdfLNS0ACwOYdW/VsAxKwAkCyd5f55NMfXrce7XcTvfJdNCz6Ob4PcjxBOURPHdcs5hrHzQfwZIheQ/YP+wFeu0X1lAuqS72nvx/6E94BfaYL/+cU+HvQw7anN6EfuVhC/2C+H997KZq/uT6yT+ZP9pInHvmlO+g5bi3Uvv1+H/MRDPajNzsocVzYE2vIh1r46BvnutwTXu6S6rXHeLyXIwuX6jOzP5m92QkVaOat6fy++eulR7WfeYuqoVrxzI7jLOpgvoSJnAAt9LwGCzQnfKrDTbOMs2qz97uk+vPsCQ7J59rxOngFB9vnNrzpCeVe6CcYV+xrZzadObwWb41mn3nTJ24byZ/n2vL8S+xgBePcLzCQ3RzjMunjnOIvemmOawL/fa4zP2bJ3upeDwXF7vzhsWAvt+finOHrsVe7yHHOzW1BL/hE7oiA8rHkuH5x/oVhTPkTCvw8r2fNOT0k7jz/eX1JMxyHkGrbs00nH9LaS5OS8yl4PrHN8Hi+Pt8IOU45r0dA7c0MWklMWM9BPpbTnXCOj06IccU5TlyH1uIM46LTxuNLD9ejQUL5WtzVc5QEFEf5CvZ1eUft4bccJ3KUFOjTNwbnkdeqxyp1MS7cxt8q4SbAtc2nnCU+5eFJV/B8ZR9ZFQWyym5j+eL/+loVErtTunlswOdANVkEjgcBCQDHg7KuIQKHSEACgASAcahIABijkABQLyASAPALhQSAOjYKCQBjGBIA6riQAHCID2D6mAjMEAEJADM02Orq9BOQACABQAKAMdoBUP9iqB0A2gEwWhO0A+Dg93DtAKjZaAfA9D/rqYUicHsTkABwe4+Ari8CDQISACQASACQACALQL0oygJQs5AAIAHAEuByklymVAKAHitFQATWIiABYC1C+rsIHEcCVgCId+8wH3r0fcdX5drzUQfrJ4cGa0/HS+gX7LjomWt76O/jzNJcH7r5ywon5GIf50Q+Aao1bcjrPHTRLzx4ILbNPWUL0C93ohdx2wr6RudTZNPKqAb6fhQYCvIXZvT5hOq7m2AF2pO3qa54u/7lNgypJjh5YpMeep9NgVubC/L/cr1lzgnAnn22uFIZb1NQToBkBdvDdcHDFvqT/TZ6FMIt2F/Hw/40z+eU+DeO4eE+9HE6xIa9zSsxeVQ72DbO3TB/Su0btwPa3dKFcU1TynXRx/a4GXp6OQdAy8ecBOxv5vYnA4qFhsWX65f3htjXJF+91j17cHk54zwXHLcT5dR8ZMv+ZR5LzoeQ9mkOkk+eys+bwRDXCM6NUTbjjOKE+8oxXBboL+4vI1teKzsdXEubQo291pD8x7xecs4AZh21cL0yaPU2Q6pxznk5OJ8D53NprvUlWeB5nFYof4JP+VvSBOOOY5znbCdCdjl5/DnfAveNc02wT55LIHLcxineFyfKabbr9Yu/YGcpxqzBsDHdFq4fE9wHeHwU4ThP5JJw8L62Z/8eCOWw0dYDrV9BiGv1YB/OoXwF71udgHJjJJRvhvrvN9bXIsDPlpRPxY2wL5z3YriCa6tHa6uh6c/PGKP167xrrqkY7YhxnI/j45suJQIbioAEgA01XGrsZicgAUACwCjGJQDUs10CQM1CAgDeBSQA1DwkANQsJADULCQAbPYnR/VPBA6fgASAw2emI0TgmBGQACABQAKAMdoBUC8x2gGgHQCjaNAOgHpeaAdAzYJ3MGkHwDF7RNOJRWDTEJAAsGmGUh3ZDAQkAEgAkAAgAaC59VsCgAQACQDGyAJQP+HIAtDYHXabrVAWgM3wBKw+HE8CEgCOJ21dSwTWIGAFgP7OW8xfPPiM8Se9efTQtbv4JTly0U/I3u5sCc2eXG+e62rzg1bzYSNqk3eRyk5xTW/2SnoB9mWwSDXAH3oKEOo1ajPbP+R70d93l3wRPh/txPNFMdUgH6J32y8xx8BwiKyGQ7zeILkFrld00P8YzNfey4WFBfzsEA29WYLXSskn6lAZQNfHtucO5R+gv7sGP9+i3A/5AI83ZEOPe9j3nE3DaDM17e0Yl3FOxzdMxtz3KMe48nKME/aVe+SR7Q37OLMizDEQe+QL7eDfO4vogY3IQ1tSvgQuS8j9aQWYA4B9r2GE+RJ47Js++IS81iwIBF0aCBx2w555vhb/qsy5JLodyo8wRD/zYBm/oLNdYzhAj2/k4VizH5pzEqQOXi/3MW4zr56DBXnmfaqHvshzkuagoTna34c5ASbquZdkBqeh8Mj/zL73hHJNhC7GBf/KnaVk3Kc1IqM5OpHfoXH+IeUgcXKcE7x+7e/thznm+vh5zh3DbW2FOCfKlNbDjJMS4JR2Qwxszp9gcMkwnNsmoBwmnL+haNysUm4LLZU5/d13eSCw7ZwfIXAwUJIYF19m57o0qamvnXnKr8D35SGefz7CHCh8r5iIM+p/My6DCPvCuRWcFra918c5VQwoh8AQ33O+FV5bR2LpuZf+awX9lj7dC/TUKQIicEACEgAUGCIwRQQkAEgAGIWjBIDGL16U6FICQM1GAoAEgFE0SACo54UEgJpFIgFgip7y1BQRmA4CEgCmYxzUChGoCEgAkAAgAcAY7QBoPLxrBwDcHbQDoIFDOwBqGNoBMGaRaweAnihFQATWICABQCEiAlNEQAKABAAJABIAZAFo/JIrC8AYhiwAjV1BVGZVFoCajQSAKXqoU1NEYEoJSACY0oFRs2aTQJUEcOcO88GH3WcMoIjQE8c+fPb0+wXVQCevZ0716DkHAD9IuQ0PX6uDPk4/wGtx/XOu7TxI0S/sn4a+8fAhp8LA7zboH971sx3w9y170V940gr6i/296DN1KQdAmaG/2VDnOR9CL/4FXN9pow822lpf3/Mo/wB58hfnMH8B14IekJeR62InGeVPuC0Z0qiBaUa1p10aOzKHc9zESzhWTY+svUa0gKyzAD28zbixnx9m9VhynWzOR9AxVJeafKHsN+a63V4b2aceti1xkR23td0ivzLlAFjeswxx4JNfg2uec0ky3pIbU66JwK19tT7FUTCHnlvOCRJnnLeCxjHF9YTjjuvBl2ysJz/woIfnb4c4p9OYPPxU/53jlON8yzbM0+FQ/oZeXl9/WOA4swfe5/mdIQsnoSQCMb7PU+w8zwm/i3HHW/Jzgsv5Eya82OQ190L8mZvvBcMc10vuf1DWscP5BnrL6M1utXEcOfeES/lZymbmSjvfh9SWpqpljGHfvFvgWs7nY/HDb9G9h+5NXBKRffKuh9dr5gRwS+TM85dLtAYezsmAck9wbhzOk8G5cvh6E32n+y6PzcryCj5A4W3KdOfxvsc5BlhA4PUtjimnSnNTCuUE4DjgJ7tyYg5iY8ucckVQnp5RDoIn/9sXqlPvGBy8bbP5VKlei8CBCUgAUGSIwBQRkAAgAWAUjhIA6olZSAAYw5AAgF8QJADU80QCQM1CAkDjwUYCwBQ95akpIjAdBCQATMc4qBUiUBGQACABQAKAMdoBoB0Ao3mgHQD1zVE7AGoW2gHQYBHhbgjtANADpQiIwFoEJACsRUh/F4HjSEACgAQACQASAGQBqBddCQASACwBWQAaX/hlAah3RN1mOZAF4Dg+qOpSm4KABIBNMYzqxGYhYAWAZPcuc8ljHjnu0r5kH3SPfaVRiF7swFAxaqrvzt5ProfsUA31YaNAfDTPNbyxbjWPA9f87g3RZ5otor/P+2X0+/bn0ac56KGvdHE/9nX+ZjyfczP6j4MUP7+yRD5QqsOd5+QVd9H77S2SV9SvPcU8TiHVPw89ZodtLx18z95uhzy17N3mOtnsX2Yfvkf+aPblUwoD05pDn3zucn129GM363B75LGNl9C36eY4Lk6Ce1gLqr/OtafZ0+93cdz5770Y45LrtfsOpRinOcWef65xzp5a9tCGAcZCs1a25+K12ctcBqvHCW+FNlRundvGcZEmOIfY889xw3W6+e9Fjr57zgEw8Sv3HK45RQuP72V1DoAkxc5xPfdsiH1x8VQm71Eei5L2TlP+A66B3s+wBnmzXrpdG12f4prydrDf2dAc98i3zvkSJrzqlO8B1giu7Z5hHEUdyqdCvzKXPuVHoAWI86eEEZ6P17+JvCCUbyGgXBiUwmQi5wDnxgjauAZw+7rd2hfPcy6mfAbcVlMii3aE+ROcHOMo4coeLpVzoBup71NuCcoNwfcCPj/fizhnAMcR5/bh9bDZf/b4B5SckXOMpCndUzOcE3xvmMgjFGPOkVGcPulTn6+o7egrB8BmeR5WP44tAQkAx5avzi4Ch0VAAoAEgFHASACop44EgJqFBAAJAKNokABQzwv+IioBoGYjAeCwHsP0YRGYCQISAGZimNXJjUJAAoAEAAkAxmgHQL0jQTsAtANgtCZoB0DjTk4/mksAqNloB8BGeeJTO0Xg9iMgAeD2Y68ri8AEgUoA2LXLXHrO2eO/pT5uW20t4tZrqr5kCiqrM7GVm7d+0lbzcBG3I2dhfQBvceWt11GEx3YjLDfED2lDD7cDts5YACbpHfDhv0fl3Do93Nbpfw+3cvv/i78WLrh4/jzB9g0GyLqgrZ2ei1uEozn8vGns/GS7A2/P5S36EW2R5TJ/HCzdFradx53LQ7KHlrdmctmtpg/dXjstsK9pSn0nRwNbS6CcHcUglyDs78et1D7t9+WyfwXt5S4aVgzb9gmLQIDb6j0f3+e0xZbLeHFZLN6mOrktdvUyYbztNWlsk+WdINzXgOwNvO29LHAO8JZ8thDx1mj+MuHQtnguK2p4SrRwO3Szb3ZsJrYfh/jNjvvL9o3Ma9hucgysPMH3vO08T3A+ZzT/HbIIcFk9Hptmqcsq7lpU0ozWWio6aFZ6WL6Ny8lNbvVGSxSXYWVLQXNOsxVsmKxeQpCdZTwHuSxo2Ma1O6H1Iu7j9QxZEOZofZuwMJE9gtfXVpcsSgUtOuTqaZa75LW43cGypOy+GvRxWzqXtpuIOyqFGdO29bnuHCz3PDaBj+sJzym2/bS6OAebdqwDzUG24XD7m84VlyxKEyVPye7ANhze3RU5GDdcrpFLqI7uM2f//aUVs5tX8N6hx0wREIEDE5AAoMgQgSkiIAFAAsAoHCUA1BNTAkDNQgIAeoYlANSxIQGgwUICwBiGBIApeshTU0RgSghIAJiSgVAzRMASkAAgAUACgDHaAVDvjNEOAPwZXjsA6ntlQr/aSwCQAGAJaAeAnidFQATWIiABYC1C+rsIHEcCEgAkAEgAkAAgC8DBdzxIAJAAYAm4sgCMA0EWAGNkATiOD6q61KYgIAFgUwyjOrFZCFgBINuzx1z11CeOu+TNH7zUnP3Q8hKWpiuG+ItZy0EvJPuTXRe31OYNz789v79Q+w0HBr2OqYOG3y55JZ0CPbAd+jt7DYsF/Hx6V/QD79+Obd1Dnt1tP0IPbes/0OMbDii/wQDZpClev91GL2ZGZb6ybDeEXmuhPl/SKJ9oP9TrUak5Kps1v2UezhW2sK08TuzLjJex/FEa49iwf9knr/Ugx7ENKZ/DMEbPLnvFB1Seia/XLLPFZbFcLgWVY8yvrOC4Rl30ibbmaRxd7Du3td+nHANUZovb57jk5ebcEFRCccKnSnOMcwawp7hZKo+3/HMJL+NTqToyls81ypvZAONxbXqf7d/37N8DcZgMME/HQhdFupK822uVc1sZ4Fh2FzCXBeeW4NJ5QRvnhdeq14gipXJsIcYFl5LLcsoBQD71iXGiGw374HlOuSGuVyakcnBUZpTzN/AcSgbk0+d8LjH2P/SRVTMHAK8nnIuBr805PbwW5dEI8T2X3uwN6N4xRPbFADtTUhlAzjXBCRFbEXn+HTwf+/TDDiUtaaCbyNdCn2Xfu0clElOaMwX1hdcXnkOck4QTgXJZQM4nMyDWhspN+l28ryY5rZeUU4Wv327XOQU8D8edS5xyHo6IYtJNcY4kPaqxyqU3A8x/MMpN89h/+kw1O2/pYZxtlmdD9UMEjjYBCQBHm6jOJwLrICABQALAKHwkANQTSQJAzUICgASAUTTQd1xTSgAYT5RcAkC9aEgAWMdTmQ4Vgc1JQALA5hxX9WqDEpAAIAFAAoAxnnYAjFcw7QDAXwi1A6DxvU47AMYwtAOgjgvtANigD4BqtggcRwISAI4jbF1KBNYiIAFAAoAEAAkAsgDUK6UsADULWQBqFrIA1CxkATBGFoC1ni71dxFAAhIAFBEiMEUEKgFg7x5z1e/WOQAyH72Sy330/HOt5y3tLdCjjGpdsydvwuvZwl/cnHb9pbxoocc097BtrkP5BKguN9eW54Re7lbyft8J/YA/OhU9+Vftxvb0hugnfs6pe4HFyZfh+VZ+hn5kbz+2f6FzGhw/ZN9qgb77LKv9034HfZYheZc5f4ITofjBdazZW9nfhz72MMet0WkPfZ0R1eVmH6jXRfbsb+7FmMOgSDHXBOccMFRDvTn2vSU8V9bDOOpEWHfbD5Bl5pB/OKC2UG6KuIfj5BYUp+TR5V8TOas25wTwPWwfzzH2+HOOAPYcN/ubU64Ifu8GOG6Bhx5Zj/IPhAHGSenhHBok6KHN4tXHZuJ6lA+Bc46wnzgr8fx+w9NvJx/7nZ1V6o63yPPPfS8LjJOc1if+IsW+eL5VNPNa2L/xHC2p1nx7DuuxFz6y5znPcZHGuH6FKY61wSlvKHRM0cxd4eK1PYqjokRWCeUrYCsKCzWpwXENQszbkVJccd8cWj8iD+M2HuCcZkHAUPqF0mB/OfdE83y864bnXNjBfAPA1Rizsoz36NDFcfJpjnRauN7xnOM5xPlWAp/igNKCsE+f1wyP7lU+5XPgOBxmdS4KziXBOUP27d4H04bzArUKjIvIx/e8lgYh9nXE/smf+Xx1nR0UF1P0eKemiMBUEZAAMFXDocbMOgEJABIARnNAAkC9GkgAqFlIAKCkqI0v9RIA6A5KFgEJADUfCQCN3RQSAGb90VP9n0ECEgBmcNDV5eklIAFAAoAEAGO0A6DeUaAdALi7QjsA6vuXdgA0vsR69JO/dgCM4WgHwPQ+86llInB7EZAAcHuR13VF4AAEJABIAJAAIAFAFoDG7g8u0SgLwBiOBAAJAJaALADGyAKgR2oRODwCEgAOj5c+LQLHlIAVAIa7dpqPPeqhtXpP9ZbZS+6UaPjrRuiD5xwB7N1eJr9i1Dl4jfWU6qsPC6xLnSToUW0F6JV0qGZ5GVDd7tPQI9s/A/3I152KPtB/34d+QMfZBuNz55PRJ/qHe3BPbHoltn/313fC8ds698TxLsh/WKCXPc/rnAJBC8/dXsC+rZUDIC3R0OuQkTyPsS/xTuxr6CAr9mrOnzgPfXPmMY56KfZtmGN/0gG2rxiiabfl49gPGzXMh0t4Ls76zzHLMc/5FZwOJY+kutb79+7Hvub4eY88uezt5hwASYpx3kzaZy/E9eOZ/TDB/nPW7s587Qlu1ty2545THOelpSXoW0he6SjC+cz13JMM+xK0McbLlHIErOCcjBw8P/uF2Us+MZZUQ71pU7cdi1rkHac8HE228x2MadIKDHup+X1ANcYnSi7S6s/rG3vBOb8B++TbW9D7TWFoeOzYS55Rng9DJdT53pA3EnO4IeV6ob6lCc5vjsNR/fXRYSUNXIkbN4zv4nrku/iBeIXydFDpOvb48/XzDHMO8L2I83RwToBmjoPSwZif34pxxTkAmlwtj+EQ+1JQroksRrZuiWNRDum+2MF7B/eN82q0WnTfdXG9S2h9HKQ4p4MO3ecoIUNzjnMOIV5L2cOf9XGc0gEGrV/Qjp8C254X5Gu5LU7Ou+JLVSgqB8AxfUTVyTcRAQkAm2gw1ZWNT0ACgASAURRLAKjnswSAmoUEAEo82khyKAEA74ESAGoeEgBqFhIANv6zonogAuslIAFgvQR1vAgcRQISACQASAAwRjsAtANgNA+0A6AhhFE2ee0AqNloB0DNQjsAjuJDmU4lApuUgASATTqw6tbGJCABQAKABAAJALIA1Ou3BAAJAJaALACNX/DJaicLgDGyAGzMZ161+vYjIAHg9mOvK4vABAErACS7dpl/Pvus8d/Yh5q5uAWWa5JzbWvOqM5+ZPbscg6AZj1lvjZ7l9kHGgXk302pUDWVL/ZPRf9f6yz0Mn73VDz+q/uwxvACeR+fQO/LfyH/4XfRTzjYtQBjMte9A75vY39Mid5yY+ocApmP1/IiKl/mo2e+H/fhWpz9nVnOh+hLzZcov0GMYkpMvlPDRcPbdf4C25BhiN7M+cU5aB/Xk0+oRrlHRdBX9tbn9zJk4RX4Pstw3LsL6In15zBOehnmK5hgmSKbwCGPa4pjwb7WLKe4oTjmHAFcT55KkBuec+xrbc5h/jWP/b9ce54XlbkujltrDtn2YspjkSEr9vQOepQDgOp2c18n4r5Rts+2lcLEJEMyslOOE2brNPI55DROJXmXeVzbLZwjvHbyesZsuSa56x28RGHVV1rvuBRd7iF7nxIgLkQ457M+rocTY0U10Uu3nkfcN69hpbBt5Vrz7RBZ8fGDBOMiDHGtdJo3EnsBsnJz/gX+UstjuXXrFhiOZt+qP+CUNRNzmHIcNPN6pLQ2TuSuofwGEXn0yxLXk5Jjnv9OeTZ8By/AZVDZzsD34YLiPs0oTig5Bq6uxnCeEC/EuG6Cz6lvnGMo5LwalPvBUL4DzhnAzysr+/E+VWa3tv7Jl3+h+q9yAOjBWgQOjYAEgEPjpE+JwHEhIAFAAsAo0CQA1FNOAkDNQgIAJpOTAFDHhgSAxm1aAsAYhgSA4/L4pouIwIYiIAFgQw2XGrvZCUgAkAAgAcAY7QCofx7VDgDMAq4dAPVdUDsAahbaAVCz0A6Azf6kqP6JwPoJSABYP0OdQQSOGgEJABIAJABIAJAFoLGkygIwhiELQB0XsgDULGQBkAXgqD2E6kQzQ0ACwMwMtTq6EQjcmgRwt/nkwx49bm6rhWbJsIVbYMsAHXzLK8vQVf5lhD117IvlGshbTqi9lsNs9frlIdV65trw7MvkfAPOVvy1LzsD93HG90QvY89Hv3BrBespt3+EPtT8h8gq+RntE3XuAuzCYCu8dw3Wdy7zX8Dfo22N9pFPtGjU4LYHsYfW9bDtPE4p1fzmWtFcj73Xw77HMeU7GKD3u91Bn2fQJa/3Fjwf14oOyK/MXs5mLAyXMY4CMkdH0XbgGgT4+SzAcRu6+PdmTW97ok4H66339mPfueoA5y9o+oOrhpF/mceKPbTsb56o403e8abPdSKfAC1kHEd8LbaScC360sM5MZHX4zaP7eiyboZx6lHbmQWvP1y/nX3z3J+DeX5H7Zmfr33x3BaHrMuug23nceB67JzbwQ3x+Mk4oFwWtODxGlAE6BVvdTE/A/eH4zL0KJdFgudjf3ZzLDimffKFOymuxRHleijIx85zbnE7evRDD+9bgxVcX9IhzulkiHO63cUcBPNbMLcFjxXf1wKqoMBrQLP9Tgv76HuGZwAAIABJREFUzh54zhGQUW36bYvb8L7Qxr5nJd3XYrqv0JzjvBqcz4DzBHHuiLLAOR738Xqck2RIeTjm5pF1c46mMd1Dac7xepRR/hSf1g+nQPa8nnCumbh3a1/O/8yXq/8qB8BGeNJVG6eBgASAaRgFtUEEbiMgAUACwPiLFiXlkgBQLxMSAGoWEgAkAIyioZAAMJ4YEgAaa4QEAD1jioAIEAEJAAoJEZgiAhIAJABIADBGOwDqTNfaAXDgrN/aAWCMdgA0RMGMquM4eC/RDoCalXYATNFDn5oiArcTAQkAtxN4XVYEDkRAAoAEAAkAEgBkAahXR1kAahayANQsZAGoWcgCIAuAnqhF4HAJSAA4XGL6vAgcQwJWAIh37DQfvM/DxldxuJa1j/5lP0SzOXt+kwJ98lzrmj167BFu+iG5Zjh7+rlWNJeaZ/8wtyWaQ5+5eyJ6brPtVM99K3krl7Gvzi4UFHo39GH0/PhEeN+dxxwArovecd9F9k50Axw/bNW+VfZdsneR2bVC9P9GDr4PJvy+yCIZIIsgwOPjGP3BRYFmzbLE8znkq+9uxV/Yyg5Vj27UGK+gkE++TOrPOzGOS5l1gaND5u0gwLb6bfSwunPkzaZ668OEclcsU36DAOOOv2hF9HdeAngbPnt8uY44e3Q5X0LTb50MMKbZS82e+pD8xnFBfl8f44BzivSWMMZ5DnPuCfZe85eR1gLGIedHYI9vNsTA4XwR7NNvetl57eMa5OxT57J581FtJ7BjzB78lRXcjRD4GGiOi3FdOJRfISXfu4M5TXjsPIr7MqU5TO85jrwW3hua5yvJWB6SR95Nae1NcP5nOY6TG2Hf17rPeAW2LVnBOO/1MA69gHKktPB9kSObbgvXFI7jlLzozbH22rje5CH11af1BrtuIo/yrwxpvYrw+KCFccTrFa8vUUjrVYjt5b6t5avPU5pzlH/BKbG9aa+OhYn8J9SWrMAYj3OcA7w2upT0s9vBceT1cHSfOf+yr1TL8k7Kb3AMH9d0ahHY0AQkAGzo4VPjNxsBCQASAEYxLQGgnt0SAGoWEgAokV9af3GUAIBf5CQANJ4Q8HuokQBQs5EAsNmeJNUfEVibgASAtRnpEyJw3AhIAJAAIAHAGO0AqOeBdgDg7g3tAKhvR4V2AIxhaAdAHRfaAXDcHtl0IRHYsAQkAGzYoVPDNyMBCQASACQASACQBaBe3WUBqFnIAlCzcGUBGMOYKFNI9gZZADbj06L6JALrIyABYH38dLQIHFUCtwoAu8xH7l/nAOj1boFrsOc3auOXZvbU8cMB12/mHAITdcGz2rPHHlfOH8C1o9kvzL7wYR9/3Vvctgh99ebIp06+8zwi72KM5yv66AvtxOjpN4MT4HorgwV471AOALfcBX/3T/k5vG/64pue9+pDaH00Bi2vJnRwHH0HPbIl1YaeqKfs4+c7EfbV87A2dULXp6TZZjBAD27p7sax2YZjU5C3nPNBZMsNDzGx8AyOe4v8u3FM3usIG5+F6E8uIqqHTn7lVgt96WGJ+RP4gdnJyORL6Q9yB+OQWfCXFc7sH9HYl/36AoP9CGsiZwd5o1cSZOV0qO2UH4Fr28+1sea3n2JccdzmGfY994gFjUW0gHFepggzNDgWE97tGPdyN3MGsAUgJs89e6nn2+j5LwfYlpSuxaXl+Hyc34A9/dw+jhNeux0Px84hf3Q6QBbsHef2GL8+38I89j1wMDC47Oigh3EYp7jWthdxTpWU/4DnVDagOdvDOTvx+ZJyENB7xyCr0Mc44rgOw62wnuX50vh9nKNnn3MATNxjKWcJt2VInvqgS5MQl1Jj6D3f8zk3RUw5Bii9g3EN2mb4eJ7DnNdjeQ+uKb6p2+9T7ojOPN53CloP+inlGKHcMTxHOA54R9ToPvmMf7uuGr+d9ExxVB/QdDIR2EQEJABsosFUVzY+AQkAEgBGUSwBoJ7PEgBqFhIAJACMokECQD0vJAA0nn84P6sEgI3/cKgeiMBRJiAB4CgD1elEYD0EJABIAJAAYIx2AGgHwHgd5eRt2gFQo9EOgDELCQASALQDYD1Pnzp21ghIAJi1EVd/p5qABAAJABIAJADIAtBYpiUA1F9yZQEYs5gotSkLQD1ptANgqp/z1DgRmAYCEgCmYRTUBhG4jYAVAAa33GL+4u53HzPhutpzXayL24vRU+dSjWI+nv1/JddvJwvuoFG3l7cfcz3zpEfe7D76Nt2M6ifTQ1vaKOllAXD+An+Oakc7eD3uO3ur3QFdv38SxN6wOBne7+tjaJb5L+Af5u+DOQDaJzR8sHvw2Gw3ssh76JUOyPvMGb6LAj2yUYgDVTj4d/aBspeyHZ0IDaTTm6LA9qbOXvi8t4BGVfa1cg4A07DVsr+YfeURtS1J0JObFtiWPKA63V0c56iFvvMwQHbcnpaHfuZsSGOXkM+d2Le3tYFVGeATOXuIgww9wc33cY/8yHTt+S3o5R666M1mT77XpdwNNPC+i3PMjZElW1O4DjjnY+DrDUtsH+djmPMwB0G6TFv+aU1p1ptPKLFF4eGc4LWviPHvnAMg9HF98D1kt7y8D8Y5CKhvXYwjXs+cEH3r7PXmOe0HODbxCsZGkZGPvuH5tw1t5gRIMkoCgiFtAg9jkr3Zy/1l6HurQ3k1eH2iigWcE8VLkW0rwPws7KPPMmTfpftip4Ne9CTB/hQFzskkqRdszs0QdCg/AiXZaybttFCaMWnf832zn+ONJZrD9Sn3V89tM+HhpxwnHAfs8Z9IGujgHOP2DlYw/4PXzAtC+VGYa+nSfSki7jnOmUGC1+LcN1vnKXdDeiur8y/5cvXfHX2cE3q4FAERODABCQCKDBGYIgISAPChVAJAHZwSAGoWEgBqFhIA6i9LEgAkAIxmhgSAeo2QADBFD3lqighMCQEJAFMyEGrGsSdga+N+8YtfNJdffrn5whe+YH74wx+aXq9ntm/fbs4880zz4he/2PzWb/3WQRvyuc99zrzrXe8y1157bXXc6aefbs477zzz+te/3szN4a9WR9obCQASAEaxox0A9SzSDoDGw7x2AMDyqh0ADZFQOwDGMCQASAA40ucwHScCs0BAAsAsjLL6WBGwX+Af85jHVP9/yimnmAc96EHGbhv83ve+Z77zne9U//6iF73IvP/97zdc7und7363eeUrX1n9+1lnnWVOPvlk86UvfcncfPPN5p73vKe55pprzAkn4JbFI8EuAUACgAQAY2QBqLccywIgC8BoTZAFoL6rygLQ+IIvC4AsAEfywKljZpqABICZHv7Z6vxVV11l3ve+95mXv/zl1Zf45uvjH/+4eeYzn1l59z7ykY+Y5zznOeM/X3/99ZVYYL2un/70p83jH//46m/9ft886UlPMldeeWW1E+CTn/zkuoFWAsCOW8xF97rH+Fy+j97INtUwZw9uXqJ/MMvJy13gAzX7kdsL6F9ueoiH5NdjX7khH2nGfl3ygbYC8lpn2NaAatuzn5nrJU/kACDvt9dHlk58CoyZ06252z/cnG6Dv9/YR9/pvZ7wWfj7fFTnZ/BvQb9ueiP2rdxPXsj9KH6w93G5h55bN6D67lQ7OgrRV9rpoic271P99tu8lKMOcQ1zr00XwKEzA6q5znXF51u1V72gmt85/artuuhrj+PdwNmNyJc+j6w5HwFbSXh3xf5d++H8kYfsIhffc5wPs9V999EiHs8eW69Atl5evy+HlD/AwXHnvjEbnjN+B1nx+sB1tjk/g1sg+36CfuZgHv3SWUBzmmqgdyKMS87bwTkA2i6uT1lSn58987wesI0mdDAXRNvQuYcY5D3Kx1BSLXrfR/9xP0Y2E/lYaE4llNOEcwL0l/F8C92FVeO2zCkbXKO7cYptHaYYw1zPvT2HbOz9r/masF9QbolOgOPccfA95wSIezhnhpSHg24NJggwLpME84RwrolmPoSqH43DJxIM0pyb4Er3PV4feNx5jpYhjtMgQx+8wSlrSspfEPoYx8M+rUf0TEDpZgyFvYnmaf3zKUdBI3/NcB/etziXTenRfY7Wypj62mrjnOPcD7x2B+6t680TPnFV9d8dPWK37qcynUAENicBCQCbc1zVqyMg8IIXvMB88IMfNOeee261W2D0evrTn24+8YlPGPv3v/qrv4Iz33DDDeaMM84w9sHy+9//vvnlX/7lI7hyfYgEAAkAo2iQAFDPCwkANQvenSQBQALAKDpYuJIAUM8bCQCNRxNK9CsBYF2PbTpYBDYkAQkAG3LY1OhjQeCiiy4yL3nJS8w97nEP84Mf/KC6hP1VY+vWrdWv/XYHwTnnnDNx6Uc+8pGVHeAtb3lLlQ9gPS8JABIAJAAYox0A2gEwmgfaAVDfUbQDoGahHQA1C+0A0A6A9Tx36tjZJCABYDbHXb0+AIFXvOIV5j3veY85++yzqySB9mVzA9z3vvet/n9pacnMz+PWZPvvNjeAzRHwtKc9zVx88cXrYisBQAKABAAJALIA1MuoBAAJAJaALAB1HMgCULOQBWBdj5w6eIYJSACY4cFX12sCNpmf3b6/f/9+c+GFF5qXvvSl1R+t59/6/Lds2WL27kVP4ejoUYLABz/4wea6665bF1YrACS7d5lPPqrOUeCS/3BA3suMfPO8RThorV7DOGzhfkC/i4bDZg1z9rRO1NUmj39I3mne1s7vPRe90P24Bzy5vrIbUr33NnoVJ7Z9DvHz+cp2OL936tnw/poA2V2z97vw95Pvh37F3394Pf7t76DHNfw5ci52ozdyaccSnLugxE7cd6+FfWFPa1ni+aMI2axV29518PxFQPWcEY0ZxOi97ITY/5Zbs0pW0DeaU/4Bjiv2QnP99HALsnWJDdcILxLsS0y1o7l9nOuCc1dYcbD56mfojz7x5BPh76VLvv4Cff1N3z/PEZ7f7LFNc8zx4bdwPre76OVmfzLHhds0R1urdEk5AMjnXkQUJ3g50+rinGm38QMre1ZwHvTpfFS+PnTrsec44TnB64FHSUQcqmke70WffJqSN5rmFPel39+B65eHZvEixL61Fyn/ioOfT4bY+WyAf297yJb90nnDnO50MOYmfOnk3fZDjCOuNV8MsC/8qzTnjkh62Bc3w7gKSqz3nmXkJad68XmOeTx4DQjncI3gHCdJVreH46IpyFUDSjGYJcg9jnEOFpR3xw0of4JHLCjHSU5xwOujQ3k5khjP53t4Xy0jZOlvpzWC4pB5lP36eDel3DAJxtXyCuWu8fDvaUo5BOh5JfDxRuM5eL1RvoPHffzfq6G5RTkA1vUMqoNnh4AEgNkZa/X0IATsF+jHPe5xVTI/+2v/1772NROGtz4sfPSjH62SA97xjnc0N9544wHPYPMC2OoBTevAarDtl/yDvW666SazPQwkANwGSAJAHSkSAGoWEgBqFhIAJACMokECQD0vJADULCQA6PFXBESACUgAUEzMPIFR8r/t27ebr3zlK9UX+dFLAoAx2gFQTxHtAGgsF9oBMIahHQB1XGgHQM1COwAaX8j5V2rtABjDSbQDYMyCdyxqB8DMP6ILwDEiIAHgGIHVaTcGAVsS0G75t4n+7A6ABzzgAdBwWQAkADQDQgKABABLQBaAxpdcWQDGMGQBqONCFoCGKCYLwBiGKwvAxng4Vis3PQEJAJt+iNXBgxF41ateZd71rndV/v4rrrjCWA8/v7797W+b+93vftU/r5UE8Pzzz6/KBa7ndWsOgN3m048/t/51YEg1fdfw/HP9dz9Af19ONYG5dnZaon+x6Z3kz3Jd7ZaDXkh+CPSooHGa4bUGffSRk93PuB76RNnP3OtjzgAeizCnfAf5yfCRG09+FLz/YgvzPtyS3wR/nz8VPcH+1lvGfz9/6dZKEqNX94Y5eO8v4U/o7D8uqY52EOE4DsgD2/Sw2gvx1nBm0fJxrEpDNcOptnUQYXs5/0Ico1+aY8NJa+9nFmOyR6dEX+jIgjNq80offeHtLeiV5l+ducZ5t9OF7k94+kNkkfep82RDT8nj6/jYfmbluPj3OEFWgxWM+1FiK9to9ry2IppjHYzpLEW27HXmuOA5N5FLguKCM9F7AfmLA4yj9jwlAaCdI2mKa8BwBdc7XlOKIQ6Gk9dsOQ/F4tZFGHfuO9cYZ596tkJx2ojhao6VGFeUtsMUBa4fbF1JW9j37nY8H8+xlOZN2ieveYxs5ucwaW3p1H9327iWctu49rzvUTF6DGFTrOC1uQQh5y8oSvy8V2IctX3Kh5DgnFzuo7fcn6fcNVTqjnMAcM6DZm6N4TLG4NItmF8gyMiXnmOcOQ62ZSL3hIfr2VKCOUS4LzyH/RCvz+sp51SJKDdO6qPv3ltYfQ5zXpBm3Pkpcaf8CK0WzX/KTZNwDgCKs3SIMc5WuFFaiydccmU112+hZ4j1PI/pWBHYzAQkAGzm0VXfDkrgta99rXn7299uFhcXqy//D3nIQw742dujDKAEgHooJADULCQA1CwkANQsQgkAYxgSACQAjIKhlAAwnhcSAPQwLAIiwAQkACgmZo7A6173OvPWt751zS//IzBPf/rTq1/2ba4Am/Cv+brhhhvM3e52N2NV6e9///tVJYH1vLQDQDsAxg+w2gEwnkraAVCvKtoBoB0Ao2jQDoB6XmgHQM1COwDW8xSmY0VgNghIAJiNcVYvbyPwJ3/yJ+bP/uzPqm3/n/3sZw/6y38T2De+8Y3KHuC6rrnsssuqigH21e/3qxKBNnfAeeedZz75yU+um7MEAAkAEgDMuArHiIUEAAkAIwKyANSxIAFAAoAlIAuAMbIArPvxUyeYMQISAGZswGe5u5/61KfMk5/85AqB/UJ/73vf+4A4TjjhBPOOd7wD/vbud7/bvPKVrzTWJ3j22Webk046yXzpS18ytmzfPe95T3PNNdcYe9x6X1YAiHfuNH//0DofQUYeWddBP/HcInrLuQ0TNYPJr8z14nsx+uibfmb24NsSis1XOyDfJtV3d6iGeGcea8VzDfOAapiXDvqL2WceBOiN7C1hX9wcfa9eehK0//u/VOdesH/4+YnoP9yd7obP+9swB0D3DvX5z4+/DJ/1vki13tEGarjW8jBDH+pgiLWj2avdXUD/MNft5twOnCuCE9utrGADs5y85beVyhx1kn377PnN49rD2/RtVw+wQzy3Fduar4ncEz7+Cswlv5wAWbPXu1k73l6H62azH5l/UeM4izqr14fnuOZcFZyToMmn6U22beV8AtwXL0Q/L3tmgzbOkT7FVZqQ55ZqkJOF14RUt5stCYbKhPP5rc2q+eJcFEGJ7fWTg9ejHwxQQPQpbwb7voeG8quQz7xjcH3q7cb1xDOUY4ByWXD997CLbDkHgNOhGuk5fj6he4GTkY+fchS0WhiXzfwvCfU9msPPUkYQ4xm8VqvEXBQrO3G9cKltPIcdSgZXZDin+d7is6+eatUnJcVRC3vQWqA8H7TDqrnmlBke65Cv3Y1pnJZxnLwcgz4Mt9FtGVlxDpMiRBZ+B2O+08K1nvMtLC9jfoSJe0Mb27eSYXsmngFcyv/SuI9zX12a8BN5gijfCt83cspzUaQUFwneK0a5Kc752Kcqxjf38D653mcyHS8Cm5WABIDNOrLq1wSBD3/4w+Z5z3vemmROP/1089Of/nTic5/73OfMO9/5TnPttdeaXq9nTjvtNGMT/73+9a838/OYbGnNixzkAxIA8EFKAkAdKBIAahaFBIAxDAkA9RcECQD4xVQCQL1mSACoWfgSAI70EU3HicCmISABYNMMpTqyGQhIAJAAMIpj7QBofOFvZC+3/yoBoGYjAUACwCgampU27L9JAJAAYAloB8BmeDpUH0Tg6BKQAHB0eepsIrAuAhIAJABIADBVvo3mSxaAmoYsALIAjL/wywIwnhiyANRrhCwA63oM08EiMBMEJADMxDCrkxuFwFgAeHCdA2BI9dWbtZxv/ZUHvY1ZiR459vgvbkPfKn/ZWlkmL6dXfxlrt9Hjz8ca8krGPSwWnVLOAK6fzts0O1vIg0v14NmX7hjy2ZOX003wi6VfnAih8b+n/hq8//Yd0Au64mF/vFMw/0J0Sn3+Zwy/CudyLif/bw89t2GE730P/cy9lPzH5PVudTEOOF9C6pK4Qh7+jLzfzJazzxu0ZhquE8617Zu+2tDHGl35EGt8x33knGQYWJz/gHMAMAvfxy+N7C8e9tELnpHP1HXIa+1inE14zX38POfO4Dh1KTdGkxW3JV5BNgHVBOecH7w+MDvOGcCsc8oBEFDclC7OkazAOJvwcvNYFLheOeSj5/wI2TLli0hr1tzXhBakoYfj3FnE9WU4wL97Q/RKJ0sYh06K898lr3RIc7T0KfEHXt6kHuVf8HBerFBOE86dEdD1ee0v8vp8mUfcI4zpOEYWZojj7A4xxoOcfOIkTmQ8zpyLxqye34Xv4QHlnggW8PqJoTik+6KhXDrNNYJjbnFxAS7vFbQeDJFdEePiWBI7/oKeBTgWXhfjjnOa8H20E1IgYdgYzlGy/dTt0J+9+/fA+2GCY8/zqrk+DSlOHBJv0wzHoUiQzVwb51DLwfsg52fhtXKUa+ZJl3++6sOOAa6PG+XZT+0UgeNNQALA8Sau64nAKgQkAOCXWAkAdbBIAKhZSACoWUgAkAAwigYJAPW8kABQs5AAoMdOERABJiABQDEhAlNEQAKABIBROGoHQONhXjsAxjC0A0A7AEbBoB0ADSFMOwBqGNoBMEVPdWqKCEwnAQkA0zkuatWMEpAAIAFAAoAxsgDU26FlAcDt1bIA1DdHCQASACwBWQCMkQVgRh+a1e0jJiAB4IjR6UAROPoErAAw2LHT/OWvnDk+eRSgH7DVwl/ABgl6xeMUPXD8vtulGsJU2JvrhjcfMiP2qVNtZq6fXJZ4LfYuFsUSQHSpPFFA9Y+5jvdElusMf/rwuAg52QMXWneG6w+H2N6borvA3795V/Raxqej77S3rS4f+btXfx2O9W6mxHYpnou90mGIfmP2vOYG++qS73zLCVvg+lmIn5+oTR9jjoGMvJuLC5g7wi/QV58MsL2Rj17OZl3wiSR/VAOcumY4JodD8mpT3Mxvw7Kc7GMf+UZHgDwH5xjHcZGjb5XPF7Yxp4EfIpu8QPY5xWlvGdm3/FoI4zrbXC+dY5xZ8SrFnv8JH3xObCPsC0+pLMX1KKLa84M+1uXmfAwFJZPguuGDHq5vaQ89xVFRx9nCAnq1wy7lmujgOAwL7Gt/gG0tVnDc2wnmQPEKnBOG4HCc9/s3wXAE87h+cD14rv/OZQ49Wn95Den1MOdA4NfXKwPK3WBwHDlu8j6x24fsOAeAV+KcKkqq5045AZIC148wwLHjPBp8X4vmKIcK3TsSyk3B7TF5LTRxHo00xba1QrwWrx/xHrzR+CXOoZTyrfBYeHPILqdcEEmKc6AVonDuUo6CQYxziPO1tNt4PK+vZYGx0nwO4Go1nK/AjzDGWdDMehh385QTgNc3ztMxmnLP+eL1VcjuiikR0dF/TNMZRWBTEJAAsCmGUZ3YLAQkAOCDjwSAxi9clPRKAkDNxpMAMIYhAaCOCwkAEgBG0SABoJ4XEgA2yxOj+iECR05AAsCRs9ORInDUCUgAkAAwCirtAKinl3YA1Cy0A0A7AOqdK6tXt9AOgHreSACQAHDUH9h0QhHYwAQkAGzgwVPTNx8BCQASACQAGCMLgCwAo3kgC0B9n5MFoGYhC0DNQhYAY2QB2HzPw+rRsSUgAeDY8tXZReCwCFRJAHfsMn/zfx45Pi4gb3eWob+wcJbhGlyXmx+U+NdU9vWzl7sV1F9GUvIeck3eTuckaMuAfOET126hj7SgmuK9DD25TogJweYX0bMfNjyutiH8aynXrnayrdDewEff/MoK+l4dB32p3TmsYRwP/md8vjzE2speRjXFYzxXkpDnP0DvpEN1q9nvzPkUUqqDbeaRXT9HthP5FTqr12OODP697aA/Oiiw/U1ffeDh3ya2rVMW634f8yew17nTQX9xOIdsDTbNsG+VfezsU2XfuutQDfQ2ebkdbI9PPnrH4Fj45OXOG3HX9rDxxZBqjFOeDa7Z7fiUX6CLft8+zTGDXTNeC39lXlnGbeUe9a1NfuR+D6/PtemjNsaRQ/Xh0yH+4u+kB08KSOlMDJUUN63t2PdegW3bt3sfrAdFn3IA5DgWyRK1ndaHMMQ4jAeY82RhK8JOHexr7uJE4LV9IpcG+ewnvOaN9ZV955zbwSmQcx5jW/wU42JIOQGKFNlxDpPSQV853yj7Q1yfOK4578bQ4L2ES4WmlAPAM7R7Ylh70TkHwCBFD71LMcr3QUM29HQ/jiv3tQyRhdvBuOC/L26l3BM0Vr19GNdcOaSgnCTbF7dDkxLy0U+sj418ER7lKIq20H1hnvLm9PH5ZbBMOYxW8D2LG5wjZJRv5f9+9QdVH3bTenFYD2D6sAjMEAEJADM02Orq9BOQAIAPQhIA6piVAFCzkABQs+BEmxIAGnMGv4tIAJAAMA4OCQD1PJEAMP3PhmqhCBxtAhIAjjZRnU8E1kFAAoAEgFH4BNoBMJ5J2gFQLyraAaAdAKNo0A6Ael5oB0DNQjsA1vEQpkNFYEYISACYkYFWNzcGAQkAEgAkAEzmAJAAIAFgREAWgDoWJABIAKgIyAJgZAHYGM+4auX0EJAAMD1joZaIgLECQLJrr/mnR5w/ptHpkJ+ZDIb9/n4glxt8z3W/C/InNz3+9kQTdXf7tbeS/XdZRvWHXfIulqt7t9OMaklH6JUsqeuZgzWDC6pd3WrRAeTFdBJqT4J1w7MU9wxHIdaT5xwA7F3Pstq/6Djo9+1QXWr2QrdamM+gT/kTuBY1+3tdF38ZDQJklXrob3YoJ4DXwRwF7LHlvibLeH6PPMHJLvR6hkGdb8HzcJwmcku46M/NKSdkPxqWAAAgAElEQVSA46Dn3qXcEQ57qT3Mx2AwbLl8uwkjbF/kk9ebPPxZTnFZUM3zEv8+R7kj5qj2dbPmuksxWxr0/2YZ1XOnHCGei559Q1OEvdGFj22fm8c5wDXIi5zyHXgYRx4lFYgHGBfRPLLl8pY5+ZVDWhSG++s1JKRxMlTrvmyR7xxTeEzcgdwY14t4N65X2QoGUl5Q313KDZFTPgNaix0f1wweq7zEiRBQ7gnOTcG5Lnr92hveXsR8Bu02vmebTbyXvNt70KudD7BtnP9gcZHilubEch9z2XDeDc4NwbkqJsqitnHsuLY93+ecxr2KcwAMUxx3P8Rxnlgbl/DGUw4x7kIXJ2HuIzt3gdruUNzRfc/Jce1fKycBi2huhtcLaX2Oybff5NE9Ee9bW07CPDoZ5bEYJtiXlo9zaN+uvTAPHbqvcRyMnm9ecOV3q+N20X1Tj5UiIAIHJiABQJEhAlNEQAKABIBROEoAqCemBICahQQA/PIkAaCxI4CSU0oAaOwQGOIXTwkAjbiRADBFT4FqiggcHwISAI4PZ11FBA6JgAQACQASAIxxtQNgvF5oBwD9sqwdAOPY0A6AhkhItUNd7QCo4fBOOKqkoR0Ah/R4pg+JwKYiIAFgUw2nOrPRCUgAkAAgAUACgCwAjS92sgCMYcgC0LjDU7lKWQAav+iT9Y7LEsoCsNGfFNV+EVg/AQkA62eoM4jAUSNgBYB0935z2bn/d3xO38cnHc9DP7Ghu7vv498dBz11vRhrBLPfkbdGpmldx3fYqJVsG1iSj5NzBDCYKMKawDl7pXP8qcIPyYOb7oZTZtT3Tgv9hFxDPRmin9k42B5T4vFlQf5k2ippyKTbZJmm6Of1PBQ35hfw3EGA145j/HyS4C+h7Gn10ZZqHAfraOc55oYwAb4vuujlzj187/rky6dfkfK95HvvYX8iv2Zf0gMqx+DCQp0vwA44e2z7fYwTx8VrRxF6bn0P/coJ5QTop8gqalEt6wD90VzjnPNopBnV/aaxWcuPHDnbxnEex+Rbp1rzRUk5AKgvQYBshjHOoaiDfeVa88ZDf3Gni57fPMW45DXA47EOcE7nHh4/kQOAfO+cj8E0rOktHicSD3oprn3+PMY016qPPGSTLWFbywSTCIQh5hSJyY88jHEbeppifoYwRNZeC+PWCagCQoFrfWkwFjg/wzCvrz+/iGthFGFf+/tp/SCPP3v+uRxlu42sMmqrQfSGcw5wFRSeMxynYZfydlBuCS6j2lvB/jW/FMcx5S9pYS4HvrZDOUHCHNsS78PzpZRrxvExLjkHgDuPc2YlwbjpdOm+OqQ5FVPuiAL748QYV+kyrl++j/kbjKnbm3i4FvdLjFnOQeTRjYrHudPCtbbfp3Hysa2j9eIZl11XrZk7GzmLjtqDmU4kApuQgASATTio6tLGJSABQALAKHolADR+BaYkABIAajYSAGoWEgAkAIyigZNLSgCo50kgAWDjPiSq5SJwlAhIADhKIHUaETgaBCQASACQAGCMdgBoB8BoHvC2d+0AqO80/Ku6dgDUbCQANARU7QA4Go9nOocIbCoCEgA21XCqMxudwK05AJbMJx/+ikZXqLQUldnikmdpilv+PQ+3H05sBefkSVS6yvPqLXmcnG04xO1+bEcIaLtvStuF5+aoZBCVexumJAjQNnSH2m5om2nKO7ED3KLrevg+5W3ttOW/oK2dvodbgB2n3vYeUSm5OMYyV46L24EjKmFYljjuPpU4y6hzMVk7hkMsfee6tM09wusXJcZNZnbBdMp9/HXRITad4FT4fDs8Ad47zvbx+34fty7z9mMukZgktBWayqcltLV7bo5KGoa4Db7bwfe93i+grbxFt93Gbe8ebQ0vS9yWymUKy5JyW9DYsv0jz5uscWt2QnNiQOMeUOk7l1iVtKXeUEkxLi8ZD3H96JIFgMu9FTQH+43ScxZySX9PEozTzhbczuyHuFfcc2heOPXfI7+OMXstnjO8tTuOb8EYp/XEo/XGFLhtvjTYFi4TWlJ5tjDAvqQpsnWo3Jvj0dZwSmw3YbkitwizgjKBGLKGxzFZocxxBtc6tnMNBri+pGTX4lJ6nXkc5wkrGm0Vz1JcM1yyh3ktHIulmEoq0sPBXBfH0svq47nsXUZWN0NlR8MAt/zPhchqeSeu/SsruKXf95GdvwXjhC0AHq1vQYhb+vOMbqQ0lAMq4Vj0yCbUKK1psbXbJxO9+vNcdnjgYExntN54NG4cw6GPfeFEl0lGJRa9W4P+vE9eU/13Rw+vv9GfCdV+EThWBCQAHCuyOq8IHAEBCQAITQJAzUMCQM3CkQAwhiEBQALAOBgkAIxRSABo3EslABzB05gOEYHNTUACwOYeX/VugxGQACABYERAOwDqWNAOgAYL7QCARcLXDoCahwQACQA2aap2AGywJz81VwSOPwEJAMefua4oAgclIAFAAoAEAFtdAr/JSACQADAiIAtAHQuyANQsZAGoWUgA0EOmCIjAWgQkAKxFSH8XgeNIwAoAgx1L5q9+pc4B4Pvok2+3sSRPkqC/OMvQyx2R15vLApaG/NVUn6lpNW+3qRxagR7VlRX01LKFNsvIR+5QmT3y2Lfa6NHvduvkaHZYogjbEw/Q/zcYYN9cD0vT5SVefzikpAFU5q9o+ETt9bcsou/dcZq+UvSFeh76PgfkUU0zbDt7Yn3ynbeo5GGS4D7PLENfacklE7voqfUD/HwY4djGVD4uHWIOAbfEsYgiZJMkzbhFn2cUoed1aWkHzLo8p3GcyJ+AhuYg4FKZOK4elZ7zXBybdhs9vM08GLZhXJKRihRMlDTzqXSV52Fs8Lxodt6lnBxBiF7nYYL+4oRLhHXId07rRVngnGQvOC9/LM64LrJNKe4GAyxZ5pJ/OiDPb0j94zJhXBJyOKzb7/sYgzyOKScFcTBukgTnYEJzkn5gN+02jSPlonBIyKIqfcaluOMSr+yjL8j6MjFWZP3Oc4zjpo1oolyjRz7yHH3hbEEylC8hpb67LsYll85rdXAt5nJvGZWc5TwhuY+djXMcu8KnMqYcVzSv3LyeV15OZfeWMYb9iPLyuPje5XKxKY5DUeCcdBxcu4sI2UXb8D4VbVm9dOdghUrxUd6MfAXZuUPsL+cECAIsywrrU0DX6iCLJMf1oXCoRGGGazXfxxa34fPOch/ZeMGt13vCx66s/ntLj/MSHccHOF1KBDYQAQkAG2iw1NTNT0ACAD5QSwCoY14CQM3ClQAwhiEBQALAOBgkAIxRSACo10veNSMBYPM/S6qHIrAWAQkAaxHS30XgOBKQACABYBRu2gFQTzztAKhZaAcAfsvVDoDGDUoCgAQAY4x2ABzHhzZdSgQ2KAEJABt04NTszUlAAoAEAAkAxsgC0NztQGWxZAGAxV8CgAQAS0AWgDoOJABszudD9UoEjiYBCQBHk6bOJQLrJGAFgOHOvvn4r75nfKZm/XT7jzv3oB+R63YnQ/x7t4POVc9Hb7fnof/QdfDzZVn7FYPb/HajxpUl1bZ3sPYy1/iOY/QD5jn7xk8Cgt0uvi9LrMceBPi+LNHLyB7Zkky4yz1sf7+PvnZOppRzDoCtp0B73YZ3fC958tnLHPfJo5+RV7JAD2tGXsnSob5G5BONKAcB+Z0dul5Ata4DD1l0u5SYj+rDJzF6OT0Pfa+lW48V52LwXexrnu4Hrg7Vll5a/v/svQmsrVl93bnPPJ87vqEoqHKwDdVpbDk2pt12DA3YAuyItsVguwmWhxLtyHGSLrXtVDqJIjlxohBcVuJuGaHIQ6fxQGHcBtMRXUWIKJG4UMBtkAuM2k1BDe+9O98zz63vvDp3f+t3q+pW1X3v1R3WldDjq/MNe6/93/vbZ53/Wv8nFXdIAgoF1tlWrTd17MWC6pFnM/3SPRrp9Rl4VxSLiv1wqNjlcrxej1mffpwamwzGrQwfjgo0t+Wy9j2XZT13/Zl4DF38aKRtZ9yOx/r5dKpxy7FieyiLz6Pe++CQ9lvrxWdSrv9JEKQ9UTIZPXc04hxSnfgsQCf+VE3xRXB1+7qWzqB7LxXhLZFV/XGlBM+ToPpoekfQ7JJYU3dfLmt/i0WtbT+ZMI5jf/f2tG85bVpYWVHtNf1cWq0tmYMTaPCLRa4HijVflcx4GsBjJARtL+xZQmVJ3yWZms6DCcauvafvwbRFSgVeMdSl5/Ee7Hc1rkZtjYti/oJ0t1RinGrfClWds4Oizrl8Qz0E6KeQmWG9g/fOtK9jMe1hnrR07Hi/tJfGIW+Huo7DrKBzgL4XWayNI7yXivDZoI/H4vM3/OZH5xhfaet79ZhbMl9uBM4sAiYAzuzQumOnEQETACYAFnFLky4TAHFGmwCIWJgAiF9UTQCYAFjMDBMAcY2YmQA4jdtBt9kI3FQETADcVHh9cyPw/BAwAWACwARACM4AiL8gOgPAGQDxLaLZG84ASBFhzgA4AMMZAM9v3+WzjcB5RMAEwHkcdff5xCJgAsAEgAkAEwCWAMQlmunSlgBEbEwAmABIELAEIARLAE7sttYNO6EImAA4oQPjZp1PBBICYLw9Cv/hrf/XAQBP7qi+cKOtesHdlurYx9BOVqCxbRRVF5qF9hvl6kOvH/WIGWhmC3nVJpZK0Crmte3U+/b7qmXMZtdl4Itl1U4OUau6UFMPgFxRde95CFeJzQg69l5Hsc0EaLdxvwy03yGlz+6zxjgEv3l8vru7K33vdFSjurOzI59TIlCt6i+lNWBTb6gmv4Aa5M2y6uDDSHWoeXgStHa0vYOOai/LdX1eL+VhMCtoDC43NHW5AZyzPb13v6vP7vW2gY1qcIkNtdfZrPZ9mvK9SG7cT82B5LhQ1rirAPssdfuYcxn4bEzGinWvF7XkHdS17vZVZ94Azs2GanArGFaWUOx11W+BHgBZ+DO0sN7QZyOfV81vraZznB4AOSw49OHI5zHH4S0RQvyc3g2cI6UStNFB16vxRMchV9Dzu12dg8OhHteh3a7XVFg/gi9IPq9z9rD3xLPr5kNQnXsBXhasN19JeZTMsO7zjZvNsj67xl0mQ68IHfdCgR4ArN6g763D/jL67hgO4ccw0/bMCvCjqSo2pZpOBPpujDqprBvAXsHaeCjm4Usx6WlfSyUltjMZjYvBQNs+yun6Rs3/NKMN7I8Vq9xM75+D9wTsEEIPawymRZiO9Xn5XGpO6xQJ9FrIl3T+F8q69vNzZjzRCyKT1wf2utfj4G/8wYPzf6+yL+dzK+leG4EjETABcCREPsEI3DoETACYAFhEmwmAOO9MAEQsTAAosWQCIMaGCYCIRcYEwAEYJgBu3R7OTzICpwUBEwCnZaTcznOBgAkAEwAmAEJwBoAzABbzwBkAz/bqcwbAAh1nAMQ4cQbAudguupNG4FgImAA4Fny+2AjcWARMAJgAMAFgAsASgLiumgAwAZAgYAlAjANLACIWlgDc2D2o73Z+EDABcH7G2j09BQgkBMBoexQefOt1PVvyt4Va1lehDe9C888a5+WCavAyEOEOUI++31M9YVpHW0Sx6DVot1dRozwzffaa4inZ5byvm6hJvpvSjSef56h3XlmRUS1AO96DX8IE9y/h/Ak0usSmVNJ6743lZXn+KKX93oZWOgdsWM99AmH61StX5N7Xrl2TY2ojx7j+9kuX5PzbLqoOtVJVrTjKgAd6FPQRJ529fbn/FNiyfnw+hV0GOLI2NP0JJilNfPLQIvqag18Bx70Nb4c+2jqF10MRY9WfqAa2gs/rS1oznZ4GrHHOOKOuPn1+C7hzvi+vrck4LMPrYRl+CzlgOe5BfzxUv4VuVz8/vIxq5NBvgWNLLEYjXW8GA9WO7+5re/YHEGin9Nkr60ogMgZz9OGAr8V0rOvVDOvXcKC68057U+CoVrRt1YrqnTNB1+LBQPXM5bKuZyGjniaDIeqzw5OlVNT7cyzSx13EFT0BhlgLx8CG47a2pmthAfXfx2ONo8FANf25nGKfy6mPRwjqVTGdqU4+k4FuvqDHkxx1+bqWT1LvmlFfn13GejWbqt9BDpr+SkW9a+hrQW+KbFaxmRTR1rq2dZbT57d2MEf18pCDD1BmCuE+JnUxq3HHPUW1FL0rpjONeUrXckVdHwolnRNHkRmHqqCU9b2VyV7vyxs/+LH5v1fhRXMKtn1uohF4URAwAfCiwO6HGoGnR8AEgG68TADEODEBELEwARCxMAEQzd1MAJgAWMyMvAmAg0XCBIB3nEbACBABEwCOCSNwghAwAWACYBGOzgCIE9MZABELZwA4A2ARDazK4gyAOE9MAEQsTACcoE2em2IETggCJgBOyEC4GUYgQcAEgAkAEwAhWAIQ02YtAbAEYLEmWAIQ9wmWAEQsLAGwBMA7aCPwfBEwAfB8EfP5RuAmIjAnALZG4eNv/vcHTxnVtUa6KidD2IKWc4oa5GPUuqcGdzxWwSC16OWUhpjaRXoCsJY8tc789XJYVK3hHvwJduBvUEA9Zmr4K9A7UwseoPmtwtNg2Fc9cgbnH9K100MgFRvpuvfJf641mxI5OehKWSP869T8o20TtK0GbArAcgn+CWvwLyggblRlGkIfmuAp/BnSGtqko/msOpTPUvfvYFw70KWvrK4KVprYHEIZcRPQthE0/0PMgSm04CNgtbmt9d3pEbAOrfkhTwBgPYLnAGuQc0lJ/8Y9YFtxcqlW0/+C8ys4bkD+m4XnRxnjVsIcYV/aGLtSVWvbZxGX1BNzvcljTu3h/jyupPwXMri2Dq8G+lxU0LdOS30tevuqO+d6wvXvkEfKkuriO0MlOK/BJ0QdBkLI0r8B7Z1hHnHsmoiNNLbU+NOrgR4BaWPKJOC4FnNc6SHCturKH0I+6IpTymumx2S8LXGezenY8Bf/SlXX8uFQ53SxoH4K2Uw8ns10nHK6lIUi1h8e93pDaesUmvvJhJ935PxKE+/kjB5Tw18MiiZsggKWt1As6vPrWK+ou89mdQ8SUp4ps5mCMxhoXybwTymVFNtZVsd9CGwyBb0/14d8/rqnwJs+8vH5v1e7nEU3ccPmWxuBU4yACYBTPHhu+tlDwASAbgZMAMQYH5gAOADDBECMCxMA0YDRBIB+WTIBEOeJCYCIhQmAs7d3dI+MwPNFwATA80XM5xuBm4iACQATAIvwcgZAnGjOAIhY0BvdBIAJgEV0OAMgzhNnAEQsnAFwEzdtvrUROKUImAA4pQPnZp9NBEwAmAAwARCCJQCpzA9LAGSxtwQg9cXOEoADMCwBiHFhCcDZ3B+6V0bgRiJgAuBGoul7GYFjInCdABiGj33/9Zq2yd+1oer/VMkYQjhUs1zPz0EX24Dej5o6aj/TXUr7AST/fQYdOM3bstCs7rGmOTSuXeiPd5D2zrbVqJEF/qvoaxZfpqhD7eyprrSNnVQDWFepsU31l7XuqeWmV8NwoprU7ba6PexDqz2Frny1oTpNYrMMbTb9GeinQG12AZ4FfYz9EFrtCb6cpO9HbXMWuFKDymlFLXcWfghhqnNgOoamFzek/nkIXwyOVTajqdZsbw1xMaZfAn06MJbd1Plt+lJgHDguGfzcV8ccXMIxSyoOoEunlwQ9RIgdNf8DzOkB1wysT1yveoijHbQvl7p/EdjQm4Eafa5XOejQ93e1lnwf3hIl+BtkYJwxy2qkZqAd3z3C34CSBnqScI6XEFf0BUm3huM4AM70dqAHwO6++iUM4MNRwLheXFuTWVfCWNWATR5zOoe1O3RVa14YD+T+2aDmkYWCfl4q6XHaY2A4UL+ByUTXYkyhcJSvBdevYlHjot/Xt3o+r/4F06muN9NpSW5ZLqvXRD6vn0+nuv6VStd184u/2UyxGGO9LBb1fmn/CPoClUr6Vs1m9b2Wz6sJyRjjNh6rhn8W9PrpDGv79Dp27/4v/2X+7ybi+JhbMl9uBM4sAiYAzuzQumOnEQETALrRMQEQo9gEQMTCBEDEwgRAXDNMAOiXKxMAqXliAuAADBMAp3F36DYbgRuLgAmAG4un72YEjoWACQATAIsAcgbAM08lEwAmABYIOAMgxoIzACIWzgCIWDgD4FjbMl9sBM4kAiYAzuSwulOnFQETACYATACEYAlATHu1BEDTky0BiG83SwBSRJglAAdgWAJwWneAbrcRuHUImAC4dVj7SUbgSAQSAqB3rRfe/1fff3DuLuvsss42tN8F6t6pk4cml/XaWR86rf2k3i8HvTE1/+lf55IO7UPr3IPus4u2PnbtmmBGzwG6XrOudxP3q0N3usw64dDQUteepZ0yRrScuj9r3e/CT2A00zrX2bLqLDMY136q9nLy2PxUBcfsawVtO6pmOMd2RK029M49aH4H6F8GYx1S2NbQtxzGAVLqsEO9MbwkRmjLylJTer+EOVGBTpX65nK1JtfTeyILbTd9NIhNNqup2QEiYuqx26la1tfgS6Hq4BCqwJJ9pcafcUIfjBLWhz6wpw49xzmMuKEHwAzacGJBbwuuKU2sf+mxY+156szHiBOudfQ4yaEA/Bj64iFiPIf1JpPT+hUj6Nq70LUPcL8pxqIOrFebGuc53J/VMwq4Ph3k9ADoYj7vIw6euHpV5ghjuIY5t7wUqzUkFzZxzLYOMMfpbTEeKjHUgzfEoTgC1lwfm6k5WYTOfDZWP4HhUHXqXDsLhbJgMw3au3xB1/osdO7DgXoO9Pvqd5DNqoafXhcFxCH9XIZDvT89AGYz1d1zvUtnFAwG2rb19RXEhb7n+OxCQdfG0VjbNpm05H7ZnPoZlCvXPQF+7D99cP7vBrA7ctPlE4zAOUXABMA5HXh3+2QiYAJANzYmAGKcmgCIWPDLgQmAiI0JgIiFCQB9z5kAiHiYAIhYmAA4mftBt8oI3EwETADcTHR9byPwPBEwAWACYBEyzgCIk8cZAGkiSBcVZwDEX2OdAaC/tjoDIM4VVoAxAWAC4Hluz3y6EThTCJgAOFPD6c6cdgRMAJgAMAEQUIwtWAKQWtgsAajKMm8JQITDEoCIhSUAEQtLAE77ztDtNwI3HgETADceU9/RCLxgBBICoH+tH37j23/74B7tvH4pbkEXOoF+mnW4u6gjPoKOnbpXGrANUtf3cC96AMygbc7geAQN/i76MsbnWvE3hBk0vFO0J6Cu9gw60suoRb3ebMhYrUFPnYXOfgQNMFPR+ykN7xBa6C1oVOkB0A3a29ptl6VtQ9RiLgU1TKyMVLdZwPMDsOPx/r5qLVnHuwAPgDE0tVXoi4vQeqdT08fQKlMH3kVbd3e0TnYX41zEsyvQwF66sK5zEs8v4foSdOZXNjbk+sM10/Vr+WSiY8EFgRrdJeihc6mx7lAXjjk1hW/FCOdnEAeqPg6Bvhj02ZhiLOgNwTT7AbDtoH0zjM0Y6xErPByq/47+pX/1pz/ACnBtt1VfzHGklERnWAiscc6+57F+TeHbMcBYTIBNG3FNDxV6kHCOVbCecqyKKexZMnGItXIPmn9+idze2tL1CetBGe+lixcuyPnVmvps9LGWcz2hzwb9G7pYm7f39+R5I9yfWC5VIrHETBLOiTHGkWt9H3OgiPfKiB4gWCtHjAMcL+H8CtfeZ/F6SEDhHJtgjvPzHuZNGjtis7KiHgAVzIlD6wvmcwUP39u5IuOYzep7qlwezj+/+4v/bP7v5lDH/QVvxnyhETjjCJgAOOMD7O6dLgRMAOjXExMAMX5NAEQsTABELEwARBMxEwBKWZgAiPPEBEDEwgTA6doXurVG4GYgYALgZqDqexqBF4iACQATAIvQcQZAnETOAEh94XcGgKyuzgCIcDgDIGLhDIBn3oSYAHiBGzRfZgTOEAImAM7QYLorpx8BEwAmAEwAhGAJQJwHlgAgD8gSgIMXnSUAqawgSwBiXFgCcPo3g+6BEbjJCJgAuMkA+/ZG4PkgkBAAg61huP8NHzu4bA8a2Q71gjjew0aINcmpM6VGrwKtd1r7eVTqdRvP7qP8eQ8bk2vQUo7Rl+WG1rkuAYsMdJ3UvRdw/iVo/sdt1RM2oFcsQsM7G+uXkSG0mdmUxrYHTewW6mp3oBNtT7W+cXapLqFTBhYVeADU0daQqiU/vxG+OLVRX34HOvtiQSvEZ6DdXl1dlfatLS/L8Qp09Ol67vQXYEzu0C+BbYcmdYZxXl3SuGFpvICxoaaXzvr8Er65uSl93djeluM6aqBTv1xCnDcwttUUdjnMmT7avgvtNrXRTH2eIGariHliw+czDobwO2hhTu8PNa5n0KlncXwBcVXG2NLXo5q6nlroPLIlWoibDuYkPQFmmKMcxzzmRAW69jzWUvpoTNA36uA7GNtDniPoTx26+wbak8aa2PA9NR4O5D/RG6bT1vrv9HJIx3ByIx7zfpQr1NH2IvpGP4UW3j07GNsW1pRsTuUStZTXThFx08a9ckd43WRKunaWmroe9TEnuP4VMceX8LwS5lgN60kZ64/WhgihhLikN0afXhk4Tq8RTcY81pNSWUl9rv1hoq0rYz3gO34Kb4rc+Pr68rceec/8362helM8n/2XzzUC5wkBEwDnabTd1xOPgAkALVxlAiCGrAmAiAU3rCYAIjYmACIWJgDUaM8EQIwNEwDPvJ6aADjxW0U30AgcGwETAMeG0DcwAjcOARMAJgAW0eQMgDiv6GxvAiBi4wyA+EuuMwC0ur0zAOI8cQZAxMIZADduz+Y7GYHTioAJgNM6cm73mUTABIAJABMAIVgCEEuSWQIwk7XeEoAIB3+ptQQgYmMJQMTCEoAzuV10p4zAsRAwAXAs+HyxEbixCMxNADeH4bdf+5GDGw+h19tnnW0cD6EX7EIv2IOulPWYy9C1pmtjs+RYn/cOutVoB928b0MvPMSzCqWyAFqvagprptOVz3PQUmbRHta6X6no/avwKMhDa16DDr4EnT213NcrEl//22FdbWKFcbra0Rrls1pg4kEAACAASURBVCLIEOg6S1PFdhlxUsnp9dR2b6O2PT0AOn3VADdRy/rixYsyFmuo/6wq2BAyqTilvpdxtQ+d58aOauy3UIOcOvL0s5JGLqPtK9Dk5qCh3YXmlxrdDrwnDml4odtvwA/hJRcvCXbLbE9KGz7C/OZ8HqKWPDf7ffSlir7mcD213BnEacAc2u3pnNxDnG+1NK5LmOPEpg7sZtBur0FjnI571k+ndrsHnfju7q6MA7GeAvsy5hiPK5ij1GJT/5zBWFC+sYu+b167Ju3NoH57QHtJCKRrtNPrhVrtdHWF5KHMuulifWvDE4D+BstYH5aWlqQvXF/oN7OH5+3T9A/HGcQJfT2yWV38Z6nr6fWSrnufNDrtizM/xnukyjiATn4Xc4I+HQ16hHCOA4sZ3ltcz2rwZ+kCK/qAcOy78ADopY55bQG495/S6C8Gu4j5Xa9EsjM5h/OffggkADtP+bH83Od/fP6I7aH6s9zYHZrvZgTODgImAM7OWLonZwABEwAmABZhbAIgTmgTABELEwBqKmYCIPXiMwFwAIYJgBgXJgDOwObQXTACNxgBEwA3GFDf7nQh8Au/8Avhve9977zRv/RLvxT+4T/8h0/bgQceeCD8yq/8Snj44YdD4hx95513hre97W3h3nvvDXT8Pg4CJgBMAJgACMEZADG7wxkAWqnDGQDxDeMMgIjFtjMADsBwBsBxdmG+1gicDwRMAJyPcXYvnwaBz3zmM+F7v/d7Q+IgnvzvmQiA++67L9xzzz0hKVuUnH/p0qXw6U9/Oly5ciW88pWvDA899FBYX1+/IRibADABYALABEDOEoCD9dQSgPhqsQQgYmEJQMTCEoAQLAG4IVtQ3+QcIWAC4BwNtrsaEUj0i9/2bd8Wkn+/8zu/M/zhH/7h0xIAn//858N3fMd3hERj/NGPfjS85S1vmd8kue6tb31rePDBB+eZAPfff/8Ngfc6ATAIv/3d8X4daOo2UCO4A31ggK6e9egDNL016Fqpn07Xph5AczqG9rGN435eay2P8znBqY+2s852bqI693rQ+9Whc6dWk5pa6tIbqFGcQ430pay2N8+64KhZnE/pG+nF0ELN7yegc28D2xxqSfPZQ+gyqduk7p3H/JV9Bk+BIeKMztEsvVdjTXT6O6T7z5gFNmPMpg78EXrAKq1JTS6lJwDd4QvUteP5j29uSAsG+HwEbIbjiZxfgM51tal65wvQ5DYxx4spDTC11Ic8PRCT1OwP4Vcwxi+l1OAfqmWPtnWm2tc9HHeAzUCncJiNdHRHaE8FY5NH+9fhQVBMxUKlqPIA1oqnBwC10NS19/DsLLTZM8z/Gdq+vrYmcZHW4CcfjIFVD+vPkH4K8ADgnB/ies751VTcNZsNaRvL4lUqWlFggnFqQcfe7vXlfjPE5QTHVfhiMJNuAO14e5B2WAlhF+3ZgQ6+CF+NtUvqWcL3XHtv76D99H7he4XjxLWw2qgLFtS99+Bdw7Y0sD5mmN2AcWYclYBt+r2UNIztxRSF000I6fVofn1qXgzQtoC2F/COZUYT42wJa2c1o+/8AXw7uk/Nib9nD4Absgf1Tc4PAiYAzs9Yu6cpBP7u3/274V//638d/viP/zj8/u//fvit3/qtpyUA3vnOd4YPfehD4e677w4f+MAHBMNHH300vPzlLw+JUdQjjzwS7rrrrmNjbAJAjetMAMSQMgEQsTABkMLCBMABGCYAevIOMgEQ4TABELEwAXDsrZpvYAROPQImAE79ELoDzxeBT33qU+ENb3hDePe73z3/4v8TP/ETT0sAJL8eJ7/YJL8KffKTnwyvf/3rDz3qta997VwO8Mu//MtzP4Dj/pkAMAGwiCFnAMTZ5AyAiIUzAFQm5AyAGBvOAIhYOAMgRR6zsgYympwBcNydm683AqcPARMAp2/M3OJjIJCUMvrWb/3WkKTw/fmf//n8C/4zEQBf/OIXw7d8y7fMn5akSzdQSiz574k3QOIR8I53vGOeSXDcPxMAJgBMAIRgCUCcB5YAaGq5JQCpL3ZItzYBYAIgQcASgOPuxHy9ETj7CJgAOPtj7B6mEPiZn/mZ8P73vz985CMfCT/0Qz80/+SZCIBE85/o/JeXlwNrpC9uuTAIfPWrXx0++9nPHhvrhAAYbo3Ch9/4sYN77UCDu4lN3wBa6za0k31oI4cTrRSemBum/6h3rKR0r0U8awLN6yCn92pPRnLvrW5Hn8WawdDc5ob6VXCloBrfEnTr1JEyVZz1llkTfQntqUCjG1B/mXrqtL9CEbWgB/gVpg19L2vLs4Y3tZYTjCt1qVmM68rqimBPDe4I2uxDta6BBTW+U2q50d+llNcENa+78DMoQ8PKGC3CH2E4Un3wGNhM4BkwQ18KiOvdjsbplZ0dwU6jOoQ+sFtFjfNaSX+1LmPerCFW0qpX+mLsYo600LddeEsUoFMvoa+r0ErTI2QIjX8fPh/0uggY9xEUxTubW4Ilx4brz0X4JSyjfnt6jjZRb30ErfUW4qzFWvY4pifAEHOqBJ18iesHPk9r8BMQqH9OKsyk/waI47QfS3Ietdld6KMD4vzi2urB7Q97AKjfCdcHzsEhNPkTvFfa0KmzLTnMgSniqgBvmhbWyz3E/R7WH34JziLu2Z60T0gV83Uf85/jQM8Rridl9IV9L9O3J+VHkAxYFXE35TsdWDQxp4klf/GnVw6GIlQR161U+9qIuSWsfRn2vViQGB8OB3LcwLPq3O9sbcv50/3rVULu+dzfnP+7Pdg89j7MNzAC5wEBEwDnYZTdxzkCn/jEJ8Kb3vSm8KM/+qPhd37ndw5QeSYC4IMf/GB417veFW6//fbw2GOPPS2KiS/Ae97znvCKV7wifPnLX35OSCdf8p/p78knnwxrxXUTAE8BZAIgRooJgIiFCYCIhQmAaEpoAmBXXy0mAA7wMAEQQ8MEwHPaqvkkI3CmETABcKaH151bILC3txde9apXheRLVJL6ny7bZwLAGQCLOHEGQFwznAEQsXAGQMTCGQARC2cApNcLzSxzBkDExhkAEYucMwC8MTcCJwIBEwAnYhjciJuNwE/+5E+G3/zN3wy/93u/FxJn//SfJQAmAEwAhGAJQFwVLAGIWFgCkMLCEoADMCwBiHFhCUDEwhKAm72b9f2NwI1BwATAjcHRdznhCCQ6/kRf+T3f8z2HWvqlL30pXL16NXzDN3xDuPPOO8Ply5fD7/7u74YvfOELc8PA5O8oE8C3v/3t83KBx/2bewBsDsP9r/3Iwa0eh2NvB3rhLjR2W9Cx7kH3Sv0haxRTnx1S+sI16HH5y8YA+tztXlcg+drmNTlmPfVD2uyx/qpUz6pJ4Ao0v8k4p/8yqNtNnTxL69WoSwV2DWCdlIBM/6XrgusnIQygxa7CVJK60hF0nqxlv9+6rn08+GNtezyP/ggcO/olUMfagbZ8AN1pH7rVIutBp9qTQ0xPnucXK9Ysz+W0VjTnIePqkCcAvCS2gO0G+jZmexGHK9DgVgpFaRLjtkBX7pTembXsr0KP3EMMduERUMIcYBxRfzylsRw8AGYFnYMtaK+H6Av9EXqoF0/NP/XL9ADID9QUsJqaJzVo7kfjKA9IBmACLFiTnMe7iIM9HLcxBy5e1Frzh7wg0L7Acee8OOKFktZiJ6duPVUTfXHZEO1dT/mAXLh4Qe7exHrUwbjyvZHLqmcACcQhrq9BG06Pks5Qx7W+1NR3BeJyp61+Cds47uE9WMT6yDT4tBdGsaheM7vQuQ9wb2JDTT29Hg75E2CtzmDtp+ZfkQ/zUsTpP0phcoj7PvwZ2lgzODZdvAfT3jecv0W8I8v1mrStiGMMayhhLc8Diyr8Vqq96x4Cf/s//+j83+3BxnG3Yb7eCJwLBEwAnIthdieTL4aJDOC5/CUkwFe/+tXwYpUBNAEQR6lgAuAADBMAMS5MAEQsTABES0YTAEqwmgCI88QEQMTCBMBz2Qn6HCNwthEwAXC2x9e9ew4IPJMEILk0kQskv+zffffdITH8S/89+uij4Ru/8RtDopV+5JFHwl133fUcnvbspzgDQH+xMwEQ48UEgAmABAFnADgDYDETnAEQ1wRnAEQsnAFw7K2Yb2AEzjwCJgDO/BC7g0ch8GwEwOc+97mQlPhLNH4f+9jHwpvf/Ob57ZLyUEmJwAcffDC87W1vC/fff/9Rj3lOn5sAMAGwCBRLAOKUYXk1ZwBEbJwB4AyARTRYApCaF5YAHIBhCcBz2n75JCNwrhAwAXCuhtudfToEno0ASM6/7777wj333BOSOsive93rQqLz/PSnPx2Skn2vfOUrw0MPPSRVBY6DckIADDYG4fe++/cObvN4UH3zNjR2HdbohfaSta5r0CtTC96C3nGS0gtqBd8QVla0tnwBbWmjPnsHemLq5PvYtA1abYGzCE1vnXW2V2Od6/mF0H0WcJxHmSxVaodAbXYOgsUJNLutFFYjnJtHffQC2s7ay2Poi6mb70EbyZrlxJZlsKhLJVb0huhCTzxCXe4cjmdo/zCFTR0xPMakaUAvzBglATCe6B3Y9kMaWgiASbbsoB57BxrZKTS1dbQ3j89ziNsyYqH6LF4V1OTPUDO8Rf0uPqc7Qpb6YuiHqV/uYQ6zNv1oppGmFF4IAVrxEDTS6TXRxJrSKGFWor/FVJwVoKUOOfUrKME/ZYrzOW5trEfbkJF16X+A9eTS+rpENiUK9KLIYeyIJWNhBCw24QHQh29HOeXRsgSNfQZYZBGTmYxGEr0pBoOh9JWeIznEfB7jmsmrsr2H+vDUzbM9Lbwr6KnSgnfGGOvVxbW1VPs1Rqmxr1arz/qap2dA2hsmuZDHbAt9O+jTQUK0jvaMuPYiTjh2iT9S+m8Pe4AO5kE5FRt1eEdU8V5rpnwnkmdkSthF5DWuevsq1Rxu70jbVmY6NutPreU//2c/PT9ve7h5nC2YrzUC5wYBEwDnZqjd0WdC4CgCILnugQceCO973/vCww8/PDcTvOOOO0Ji/HfvvfeGBl6Ax0HaBICaBpoAiNFkAiBiYQIgYmECIH7xNAGgHgAmAFLzxATAARgmAI6zS/O1RuBsIGAC4GyMo3txRhAwAWACYBHKzgCIk9oZABELZwCoB4AzAGJsOAMgYuEMgIjF0BkAZ2SH6G4YgRuHgAmAG4el72QEjo2ACQATACYAQrAEoHewllgCYAnAIhgsAYivWEsAIhaWAIRgCcCxt5++wTlDwATAORtwd/dkI5AQAP2NQfjfv/P/OGjoY9DMPo4uDKD/y0CHTx1pBppf6huHqPmb1iPmoHGtQ9eZhca+BD1gF7pLaqvpdM9fLqhDL0IzSz1iBX4HRehaA7SSBWBD7eUhrSSw2nsWD4AqasNXgV0Junhqtfeg52Wd6y3ok2vUZuL5NcQNx45ab9a+JhYVxF0JHghp3T916TN4KVB/TBOrbErLnEyHxJ8j/XeotnRedafUK1ODy/rse/gFbYbnL4t+OAT6K0yG0aguaWcNcUvdfRqPFnTmY3RuTOyg5abfQFq/m7RlhPsPcNyFPngbGl16jJQRVw3E3RL8EopYI5KqKjKW9OmYqOdAOs5Y6o0a/x7uNcXxobcD1rNNaKOHWM/4q/MSPAf4RY011PkFP485lcMawefRU2CMeu/5lAfLDL4ZE/SF2GXhAdBHPXbOmRHWUvalsbwscGcL6tfQ6akuPUePAnhLzOCzQV+PjStX5Hn0nqgUSwefN7lWI0a5Vs7Q1x7eK3t4T/Thw5FDnNFj4JAnAN4ddbzn6A1BLNpozy78Xfhe5vqUjuMGYpzYVeA1McmoAcs46Hzu4j02hXSjsLsv41jdb82P/9mVe+f/7k3UM+Bk7/jcOiPw4iFgAuDFw95PNgKHEDABoL/2mQCIIWICIGJhAiBiYQIgkj8mANSIzwRAnCcmACIWJgC8+TQCRsAEgGPACJwgBEwAmABYhKMzAOLEdAZA6gu/MwBkxXYGQITDGQARC2cAPDMWJgBO0KbPTTECLxICJgBeJOD9WCPwdAiYADABYAIgBEsAYpqsJQAqCShaAnDw6rAEIL5FLQFIfeGHZMkSAO83jYARIAImABwTRuAEIbAgAH7zv/ndg1ZtQC98Dce9ouqbJzhm/fl0PfbkIcPeQBGAfrGR0qE28GzqiamZp//AEJpbar8L0DZSd96HpnUP+uQCNLJN6OC10nQIRfyamkVNc2rLO33Fagd6xf2UfjoDv4Hl1VXBmZr5OnSmeehKu6xJvr0t95tACz5B36ihbaDeOus3U8NLHej2xob+EovYWIY2NK1Fp+9EHhrYEfTI1KVPUZue49RDnCyzVKfKUAPralegY9+H/4KqVkPIoaY5Nb1Z6JWZqs6yXOn68/vczCMuGPNczmqYE5yjXA8C7n9o3Bl3eGAR68/K+rqcQWwYC2M8n1/s8vQ8SJ1/1HrCOckvRtSFs+9cvzhuvD7te5GAUMIcoVab/ge7WN9q8E/gnOfz6f+QSa/tKT+ApG3tvV0Zp50dPc7Sb6XekPP5nhkjLvguoD/LBO0hFrmcOofQLyYPnw/O2Z3NLWlRFf4K6XdFDWsxY5ZzjJr+GfwKGNNd+nogprk+VDGHWe6S744s1n7OMfp2PH71qnRpD54A47F6mKRLHy/DL6EJb4chxrU11CoejUZd4YQ/QqEbDVGTE8s7e3L++uC67OVv/dlPzf/dGm6eoB2dm2IETi4CJgBO7ti4ZecQARMAmgFgAiBOAhMAEQsTABELEwCRjjEBoGSwCYA4T0wARCxMAJzDzaW7bASAgAkAh4QROEEImAAwAbAIR2cAxInpDICIBTMzTACYAFhEhzMA4jxxBkCKMEVWjQmAE7Tpc1OMwIuEgAmAFwl4P9YIPB0CJgBMAJgACMESgO7B8mAJgCaPWwIQ3xyWAEQsLAGIWFgC4P2lETACRyFgAuAohPy5EbiFCCwIgH/7mt85eOomtOS70C7uoKh6X0uih4DjYkG/ZGdnOAGau0GqZvAKtNHr0P+xXnEPej5qcLlR6UBrfUgHCiw6uP8IHgNprWIC6ITacVzfhfaRutUArXofv6zspXT6GWhmL164KJG0AuwCvBcKeFYWz2LtepaDow6VWPLXwhJqSVPvTOdo1g1HGAbqUospPKhL57VjjMvGpvoN8Ne9GTwDmArerNYE+9W1NTlewljkoKFlBkIHHgOsC07NMM/nkjLE2KbrcLehF2Y99Tp04YxRYj0Ftn3EPPXFPXhP0HiOfS/Bx6NUjvXVk35TS37oGPrp4qF676ouT49NH5p5WD2EKtpGr4gG4oBeD8SWHgF5rE8cZ3qOBMQt15sW4iyDNaEBvXUR7wbO0UHqfrmg6HAOMeYH8D/J4VkleH7w8ynW5j7imv4u9PXge+wCPFU459qttsDfQZznMTjNVPuPGscCxplZOTOMUw1xtb2r/gr7jFtgtYS1mXN6hvO5thP7LTx/A74e9DTgHE8vj3W0bXld19Y+PQAG6gFAX4wafYawH6nu67i+9Kmx+PH/9CPzEd0c6LviFm7f/CgjcKoQMAFwqobLjT3rCJgA2JchNgGQ+lXHBMABGCYAYlyYAIjGnCYAlGwxARDniQmAiIUJgLO+k3T/jMDRCJgAOBojn2EEbhkCJgBMACyCzRkAcdo5AyBi4QwAZwAsosEZAHFeOAMgYuEMgFu2ZfODjMCpRcAEwKkdOjf8LCJgAsAEgAmAECwBiGmylgBo8c5nS1V3BoAzABbrpyUAcYdkCcBZ3C26T0bgeAiYADgefr7aCNxQBBICYLg5DB9+/R8d3PdxPKEF7eUeJPzb/WggllyarimeHI/HqjQtZHSDvQJNXy6lL6xCn0c9MWvNU4M7hOa1AE1uBfWXy9BasrY07zeAjn4AvSFrP7MO996e1hjm4O5Bk9ul9jzV3ipwvHhRPQCoSx/j3sSWtepp9cBfwKgrz0JbzWPqj6l/bqN91IIf8hjA8y6k9MqHatFj3KhPpv/AJmp684tfEXFVg3fF5QsXZGip/aY+mHE86KuOdYo63tQzX9nU2tSsH58ravm2tNY87QeQNJq/+gZo5JkhwF8DG8Di0ByG1ISfjzBWHHdiP5ppJDFOD/mCIG4KqO/O9uym9Myc/4yzKtYTYtGFFpva7im8IehfwDk0gd/CMrAv4H4jepIA6ynaT68LehRwPU1jP0Ntd/qfcO0bDbUWfA5rNeOOOvgSzh/DA2ATc2QbunR6pqytLEsTa1hvB0/Vh1+cxC/B9LrIpOKUJBNjPIOYZAwfihN616Dv9HMh9nxvcQ7M6LWDOUQ/hzb8EKjx5/o0xppQb9QPmshxryw1pfml1LnJB9e2t+TzHrwa8iN9y69gfavAJ+j23PXV+me/+NPzf7eGutbe0A2ab2YEzhACJgDO0GC6K6cfARMAFRlEEwARDhMAEQsTAKlpYgLgAAwTAErmmgCI88QEQMTCBMDp3yu6B0bguAiYADgugr7eCNxABEwAmAA4+MUKv+qYADABkCDgDAD9JdoZAKkXENznTQCYAEgQcAbADdyk+VZG4IwgYALgjAyku3E2EEgIgPH2OPyHH/6PBx16FOWXrrKMV0nL+m12tEwOSwxNp5rQnH8qhW7xwBWUFUv/psSUVf29KYQ8Ulqvbmm6Xwvpe+VyWQaugOMKUrnrjYacP8Pzpkg3PlRKCuWSmIbKtFOWwmM69gi1qVYuXTpo36GUe6SJs/wRU1KZ1sk0TaYbM+38qPJqvB9TxQeIM0oAeMzUb6atVlJfTgrAIl2eLAGwDJkLU6N7SMFnOTeWTGTa+Td/8zdLHLF8JVNsWRZsipTYLkrltZFKvrOzI8+jC/cA6djVVJxPofXIlHTOVFB+rV6L6bnJQ5lezDmxwutZhgvHLZbKBBYsVTdE6c0WsGJ6Nce631O5BeM2XV6S6wPHtcn1hZImxGWLkgB8rlRECOxLHvevIDWbcdZLlVxNxq4HCQCPy0irb2DtpsRK5jTiimthFpkllHdNsPYWIG/g2sn1ME3cJH3dhgSghjVgFSUPD5XuxBbgqHKVLEE77kXpHNeTDuIgCwlAHnE1QZyUMcdI5jLFnusVpSyMG7ZvC/KJAeYc3zUVxCnjhiVl0+tTrqLrUQYxWWrqO5ttvXLliozctN2R42XEYR1StJc91faf/bOfnF9nCcDZ2Au7FzcfARMANx9jP8EIPGcETADgy40JgEgo4Nc9EwBxWpkAiFiYAIhYmABQctgEQIwNEwARCxMAz3mL5hONwJlBwATAmRlKd+QsIGACwATAIo6dARBntDMAIhbOANC8I2cAxNhwBkDEwhkAEQtnAJyF3aH7YARuLAImAG4snr6bETgWAiYATACYALAEwBKA1Bc5SwAOwLAEIMaFJQARC0sAQrAE4FhbT198DhEwAXAOB91dPrkILAiAB//7Bw8a+fhAy+JsUn8MLeZWuyUdzEDjz5JF1CMeKg+X0s1Te0gkh9Dn7UHzv50q2ZVcm0N5JG7q1i9flkdUoTPdhba6gHJq9BDIQptJreXm1avyvD508DNoP0soPZUudcVfrQP0vBnqRKHD5PV5yCH4ZeAJtJ1jQ43+IYMwjMUhHT7iLqA9lCSwrFg+df0Umlr6BeShlZ7h2Swxxpilzp0O4PSqOKR5PcKAkeXjuAFnOUlqw1micR++HaVa9WD4CtBCZ4H7LJOVoc4XtRb8IU09/BNYmu4SdOTL0PTSaZ/jPoYPxy48A2hIRl8NehbQA4D9uZAq6chyjk2sF9RSB8QV4yggDvuYs5vQWrNsYBGynfQcmA8ank8dPn09drCerqysyNivrq7KcROfb6eu7/R7ci7bOkG5WHovsK8N6Nwz9FfAgsSyf/TRIDYsT1uD7p4+HenMkOTR/HyEEq6DbtSecxwYwyP66GBOFjBnmk0tjcd3MLMVcsCOfQ145xM7SqJ24K+gwpAQiG0dzz+EXWpejPDeyNdrMtI9zjG2HetDf1/3L3msV0u436Wn2vI/feGn5s/ddhnAk7vBdctOFAImAE7UcLgx5x0BEwC6UTIBEGeECYCIhQmAFBYmAA7AMAFgAmARDCYA4hphAuC87yzdfyNwGAETAI4KI3CCEDABYAJgEY7OAEh9yXUGwAEYzgBQ731nAMR54gyAiIUJABMAJ2hr56YYgROHgAmAEzckbtB5RsAEgAkAEwAhWAJgCcBiHlgCkPoiZwnAARiWAMS4sAQgBEsAzvPO2X1/IQiYAHghqPkaI3CTEEgIgNH2KHziBz9x8ITNoK7XG9Au7qK2/TY0dQEaPWq/We+duvy0fpk68gLuvQdNPvW+e2jbELp4pvzfdtttgjR/FWed7nxWi1uXC6p2pPZ7BM+CKevTQwvOX18L0KGmN2I5jEsTWm7W/GZN795gIH1nXe0idKY9PG8PNcXpd1CAzlOV5CEsQ9M7hXaTx/vAirrWNPYZ6DormE9FxFUOGtss2j7GuLHE14T11IHNDM9fbmjtatbNrgMbamR3t7bkjii5HlqIO3oA5EsxbpurqvMulhWtMRpPTwDOQWqr1TEghBLGmceVMjwGEHcjXH8oTtH3LWDV7ao2fYD1boSxXE7Vh6cmnrr1OuYrsZjgWf2xZhv0kYnSQhyPiQXmRAHa8Rp18nj+DHHNOFuD5r+E/k0R161hXFPotcD3wriv6w99LibAgusJn53DenVoPQFWU2BRYFzCn4Fj18Ac5hpBbHOpScr52wEWrW5X5zffsVgfluGrUcHnxJbrHceGWHMO8Zjr1wripIQ4y2COlnF+IdX+CWL4McxnvpcO3QvjSK+cHOJiFb4adz7l8/FT//GH5mOy2b92k3Znvq0ROFsImAA4W+Pp3pxyBEwAqOmfCYAY0CYAIhYmACIWJgCWD8AwAaBVVEwApOeJMmUmACI2JgBO+cbRzTcCLwABEwAvADRfYgRun0vPXAAAIABJREFUFgImAEwALGLLGQBxljkDIGLhDIChLL/OAEh9kXMGwAEYzgCIceEMgJu1Y/N9jcDpRcAEwOkdO7f8DCJgAsAEgAmAECwBsARgMQ8sAYgvOksAUmSHJQAHYFgCEIIlAGdwQ+wu3VQETADcVHh9cyPw/BBYEAD//gcfPLiwhV91vrq3Jzd9HMZQrM+8j5rrdegRS9CmL+HzdOo5dZZT6ECpoT9Uvx1awza0hjXUS66ijjd1nB3UT6d+sBhUfZ2FRpf1nqlXpsa/hPZQ5572FCgBmyZ1l8Cd48Q09w40sSwLeEhrDa0067XTfyGLsSlAa0lXbcbZHp5HT4D0/avQ8+bptYC2rK6tScwPjvBqyOD+Sxg3ej/MEBe8Po9pzDlD08K0b0Zy6QBacXoADAZ9ecIoZciwmqpzn5zEDIDOUHXqQxyztj3HeYj1IYdxnEEHX4eWm3HKL+ycQ/wSy3rzrGHONYUeACEVpwO0nX2v17RGeQZxNIVZA3Xq9NWgFpweJ1PENeNwfUXL9nFsuD6x/Usp/4MkNrhe7iPu0mv5eKYCAcb8DOvNgN4M8Cihx0ge61sGOvkZjukv06WXDbCkr0eFniY4zuCYWI5T/ggtPHs8Gsv83MXnW7u78vkSvBmaeK/RA4BrKeUJfM9yDtETgO1nBkAF2DdBphQx9mPMq1wKywnGuYv3HuOA3hEZrL2MuzraehFr+cIT4Ef/6PXzMdjoXnl+my6fbQTOKQImAM7pwLvbJxMBEwBaBcAEQIxTEwARCxMAqbgwAXAAhgmAWD0iAcUEQJwnJgAiFiYATub+z60yArcSARMAtxJtP8sIHIGACQATAIsQcQZAnCzOAIhYOANAPQCcARBjwxkAEQuunyYATAB4A2oEjECKFJ0x18joGAEj8KIhYALABIAJgBCYCm0CwATAAgFLAGIsWAKQ+lJrCcABGJYAvGhbOD/YCJwaBJwBcGqGyg09DwgkBMBwexQ+mvIAuApN3RZ0q1e2twWabeoXobEbQt+3Cr0if0Uapp6/j/rpLE3HMlysl0439xFrP0O73YGGlZrc/r76IYz2W4JFE/XjWXebuvYszp9ABz8B9ozJZmoTmoFGdnqEPpkp/lXUis5Ba0nNrCrBQ0j/Mpq0k+nAu9CthqBlsgqoL9+AfpolxqbU/EKrmfY42N/aFOgm0BdznNbgAUA9MfXLA2Cfh965UtRa9jnWwcaco+6d9d7pp8B50cac7CPuR2jfXkqPvHThomBVrNU17BCj1NAvYxxmjEvUNJ9izoVUW5IH09+Av7QWgW0e7avBC6MMTwHen79RUHef/rLDmOQXZGqxOW7UxXMcr2xsCPZdeDfQc6BciGaOyYWrmNOlHNwlEHcDjM0Yazd17PRbGCGucyms8/mc9IW16HlMP4IZdPE19I3r1xRa7hHWemKdwRzhcR/YZIEd47IGb5tqtaLzKPWepC9FGz4ZXRzv8J2LtvCd2sfnXM/odcP3JD1Ibr+s5rn0BKAXBT1XeFzDnA3YQ6TnGfsyAhFzaFzx0izjnctxpAfAOt5D9afa9jc/9sb5nTftAXAetsru4w1AwATADQDRtzACNwoBEwDqwmUCIEaWCYCIhQmA1IpjAuAADBMAZXkVmQCIcJgAiFiYALhROzbfxwicXgRMAJzesXPLzyACJgBMACzC2hkAcYI7AyBi4QyArqz8zgCIcDgDIGLhDICIhTMAzuBm0V0yAsdEwATAMQH05UbgRiJgAsAEgAmAECwBGBwsK5YAqBbFEoD4xrEEIPWF3xKAAzAsAbiRuzLfywicTQRMAJzNcXWvTikCCQEw2BqFD73lEwc9uAYdp6reQ6BOnTr9vf19QYOaWv5SwhrDaS15Hzp26v8aqEu9vr4uzz6kje715PM2jqnRLbF2NOu3Q5vJckfUH1M7XoS+kDrV7T1Fn7WqC6mxKlNHCf3uFLWXqfusQBtdg5Y7Byx4fRGa3F3qVhEXY9R7L2RVI5xHHM644Ya2O4fn76f00nvwH8jhXuVMVuKCGvxGoyGf0zQwn1UiaTbROt4TjEWYaPI462Yv1/V5GYwd47bHOto4fw/z6DHo8r9Wi44OtVdpX6olxaa8uyRYFK+q7vylOfU7KELjn8Wz6/ByGEDnvoc5UC5p2jnnaB1xy89LnCdYu/toL/0TNlIeKBwHegCswEuC/gPUWu+11VOEkqT+SCsSLGP9W4XuvBh0LKmtrsAzYAId/ADHATp6rs8dnF9KjQW9Fti0fawPPK5Cu728siIjt7K+JscteAb0sZ7swr8ljzUhx7WePhqI0zLimNkRdawh6S/NWfif8J1JjxGa7hErrr0z6OTHOM6g7Xx++j2TgMx3xVJDfUIqWH+WMHahHwnH5H5FrF8TrFfpedDBOI4Rk3t4p1O+Ra+aBtaLyxinMtaDRdT9zIN/Yx5vW72rp3T352YbgVuLgAmAW4u3n2YEnhUBEwBKCJgAiOFiAiBiYQIgYmECIJqgmgBQQsIEQJwnJgAiFiYAvBE1AkbABIBjwAicIARMAJgAWISjMwDixHQGQMTCGQBa78IZADE2nAGQIsacAXAAhjMATtAmz00xAicEARMAJ2Qg3AwjkCBgAsAEgAmAECwBsARgMQ8sAYjvRksAIhYsCziyBOAAHEsAvJ80AkbgKARMAByFkD83ArcQgYQA6G0Owwde/0cHT92H1nsKjdwAGrwe6iOPoOejzpWpkVk8L60152fU9B+qX3xEveMRPp9CP8i61zVoGeusMY7jLPrO1PEBscHz96F97ALbNvTQvZTOvg6dZYX1z3HM9OXtlLY5CQZqI6u4Po/nse52Gxracq0qkc2+jdHX2VB/eaV+mZ4DGbQnXYO8UFZd+gA60Vq+IG1jDfIA/W9+OpHz6QHA5zFup/AAqKCWfRW/JrZabXneUZr/CfwcvpZTLfj4zbrITO766sF/+P8e+ax8WBypvvfO4l+Vz/c+o583HlUvh5dBZ76G9WRlqfmsK97VjU35nFpy1vVGtfWQxxzLIC6LJfUw6MKjgOvXMD12rHuPGKxCTwypdyhCi72POTCFhH+EuON6dmF19VnjeNjry+cVtLfMmupjjfM29NA7WI/YnvRxppCXZw+xFvZw76PquWfhu1FdWZb7FxoaV32YDmThOZLB8wfoW+grWVwv6prRbOrz0v4H1xumgzlMrUHNak3XE7wTO/BH2NnZkfPpFUEvmX3MgR3MgRnXTszIAq5fR1+Xm+pZUsZ7cw3rWQb+MHnEQheeLdvtuP5N0NZ94NrCs1t453fxLK4Pd8BX45Xwlrn9Ke+av/fAdQ+AbXsA3MIdqx91mhEwAXCaR89tP3MImADAFyNsDkwAxJA3ARCxMAEQsTABELHImQCQd6QJgDQcJgAWaJgAOHNbSXfICByJgAmAIyHyCUbg1iFgAsAEwCLanAEQ550zACIWzgDQTBRnAMTYcAZAxMIZABELZwDcuj2cn2QETgsCJgBOy0i5necCARMAJgBMAIRgCYAlAIt5YAlAfPUNLQGIYFgCcICFJQAhWAJwLrbI7uQNRMAEwA0E07cyAsdF4DoBMAi/9t33H9wqAx3pCPq9JzZVk0vNfxaaO1WRhrCE2tjU8XdTWswCNPaQxAZqandSWsGkQ6zhzXrIJfRtDfq/DrSW45bW6b6AuttZ6A9rNdV2dqh7xXEf2OWhBS0Cj1nq+jb6zr7xeA9960JnWoTuswEtZLGqautsWY+nSIemd8RgqLWgZ52uhDP9FKjVZD3nEvTWaQ+AVrcj9y5gnArQAwd4MZSg9S5Df5zPq+59nMvK89q43wSBm8/o+cOu6o0LwHILGtkedOsr33CnPP/xS+q/UPwZnZXD8PDB+V/5iz+Va3ND1fd+8/Jr5fP9T5TlePiZXTn+JsTNCvwJCtSGQ588zal2PIO4TGupkwdzzlbo04FFk34N1KrTr2GW+lJMn40q5ntAnPUx3+lxQg+SXcTtDH0ZwBOgDJ8Oro/0M+B6Qu8J6uS3sPaz5noLHgatVFwe0qVTm43jXEV9OyZBY3Y8gw9HXeNk6aXqCVBp6vo00ykWelfUH2HwpOrsl/DyqeC4AP+EFbznClgfc6mx5No2HGh5xT5wpQ/Gzv6eRPUO4qJTUWxGdcWuO9S1t5RR7CtFxa4U1DejWdc1osrrR/q8Vczx+lQjNQvPlc3Ue3cH3gtPFHUgRrchThpjfa+Uda2djTFLFMpQfUzXt+8O16//tc+8c/7vfn/juNswX28EzgUCJgDOxTC7k6cFARMAutExARAj1wRAxMIEQMTCBED8gmECQL9FmwCI88QEQMSiYgLgtGwJ3U4jcNMQMAFw06D1jY3A80fABIAJgEXUOAMgNX+cAXAAhjMAprKwOgMgwuEMgIiFMwAiFs4AeP57MV9hBM46AiYAzvoIu3+nCgETACYATACEYAmAJQCLeWAJQHyFWQIQsbAEIJURZQmAJQCnaqfrxp4EBEwAnIRRcBuMwFMILEwAf/21HznAZAAdaxv652vQH8+g56NOv4i633no7lHtPWRS+mpVVodAd/Y266NDOziGXngJ/gYFaGapDad+uIfa0APo7tO6zgTQIrAcQRO8j3r09Cygbv8idKVpDe8A+uIBdOFZjGPAuG088YTMixzu10S99pUL63L+iFrtiurO91Fnm2OZwdiN4LdAbwmWXKutrEh7xHOAOnCMA7XR9B+osJb8SDW61LEH6FT7eB49AIrAroe45tixYsOUung8/9rFumBT/hnVwW5nPnnw+ZWNL8u5ly++XI5Xq98nx1fuU1+M/P+zJZ/fDv+Cy6s6TvTJGGOs8ogjej90UFN848oVef4OdOs5YBPyikUengT5iWYAFJ/SACcPWYX2mZKAQ+OCN08GHh88nsJbYgta8DZ8NDrQ0RdqOgfZ9z6M7bjerTeXgKWObRvr1+Nb+nmoR4K1+DJo+tcU18yarvaZkr5JZio7D62Bxt0kB08A6N6z8OWYtVT73Rg3pa/Tr2v7Oo/GWvTJiYNr6hlQKyvWjYuKXW1N/WByjdjf7kg1+AEvvslQdezjqb418zAkGFV0feqVta3DPLDKQdNf0bY3irp+ZGDsM+yrn8vOFfVPGDyB9fJx9SRYG+kcxFCHXmrO9v+Knjv+K4rN4II+K9PQ8zN5jauLaxd13Ps67sPHtW+Zz1+Pm//84f9h/u+gYw8Ab6iNwHNBwATAc0HJ5xiBW4SACQA1+DEBEAPPBEDEwgRAxMIEQPxCYQJAPQBMAMR5YgIgYmEC4BZt6PwYI3CCETABcIIHx007fwiYADABsIh6ZwDE+e8MgIiFMwCcAbCIhp1NZwAssHAGQFwjnAFw/vaO7rEReL4ImAB4voj5fCNwExEwAWACwARACJYAWAKwmAeWAMQXjiUAEQtLACIWlgBYAnATt6W+9RlFwATAGR1Yd+t0IpAQAP2tUfi3b/zYQQfa0Ow+Dp37hFpydL0LXWgBOldV1IVQW9Z6zbmUVnPQU21kF7rwXk+1jWPUEy43Vde5tKTaxkNf/A7Ve4c+GBrbTWheWce7z5rm8D8YQxtOzfAyattXMDaVVE31LOpQUxvNWtNT6H/bO1q/vQevB2poVy9fkpGvXtTjDrTTXXgSDKBnnsIjIAcn/j603iV4SxRRb35SikrSYk01rMSKfgkTxPAM9dirKZ+KBIQpjgO8JSbQtbO2Pcc17TSf3H/c1VRrelG0MFaTihJbu2s6D3I/qiLjjfX/eDCWO/uPyLje9pI75Tiff4McD96rmtoLT2pbawNqpbVtFcT4CFjNSnp+D3Nql7XnETddzFlqywslxWLcwwrV0favZwsH/W9mVctcgheD+FAkVyFGS+w7rqc/ykZPde/bPS1anl/Svlz4K+rTkWvqehaw3rV3VOc+3lN9dW6i/d1F3HWCXl++I87B2itUAz9aUyF59YLWkm+sa8w2VvR4ONJxabe3JS6vXVNt9v5+Rz5vNtfkuJHR58+21CNgdFVHY+/rin0GY1de1rht3qHtL6xGLDe616QtvYnOoRW8I6vFipxfwXuli7WyM9C+h5LGwaWLt8n9inn1axgPNA4m8IcZwr/l2pPan86T+vzchsZpfkvjKgsThEzKNiRzh64303WMU0Hnb7uj77X1dR33y5cvS99rVR2nMNW27nz1epw99NPvmP/b37QHwOnc/brVtxoBEwC3GnE/zwg8CwImAHRTR7O1Mr6g500AHESTCYA4sUwARCxMAEQsTACYAFhEgwmAOC9MAHhbagTOHwImAM7fmLvHJxgBEwAmABbh6QyAOFGdARCxcAaAMwAW0eAMgDgvnAEQsXAGwAne5LlpRuCEIGAC4IQMhJthBBIETACYADABEIIlAJYALOaBJQDx3WgJQMTCEoAUQWoJgCUA3kIbgeeJgAmA5wmYTzcCNxOBhQng+9/w0YPHbELLuAFN7RLqrXdZmxr6w50drQlMXWt9dVW62E3Vth7CA2AEnXi+qDrLKjS1TXgA5KAvLvIYYA/Rlyo0+DvwANjc35c7dKBX7uF5IaXhTy4sQDtegEZ3Gbr3Rqq/eehAWxiX3p5qITOoZZ8fqSa3g3GbqvQylFbUu6ECbWVAW0dZ1PlG3/rwIJh21P+BngGDsUZSdU3jKNuIWs4Onj0topY07rVzdVPGMdeBthltby6hhjjipLScErGGEIoY9z48B0bQ/A92VW9cHutYTaHB7WOs9lZUM1z6YWh8/+uvHPS3P/iS9D2T0XOzmdfL5737VK98+77OyUt11X6HoJrdNjX9+nEY5PU/TIrqyt+G7rx4SauIL9+hvh+5soKTQXv6W9qfvSd0Tg+fiHro5Z56S5TR9hZ8Lyov0RgtX8L6taS15AczzT7ozlRLvdNT3XvzourY65e1fZU1fd40r1hub+j92lc07qcDPZ/vpsKyarkn9YjVbE3BGea0bwUNs3DbS1SbvbysfSsUdT0JQefEtWuqQ3/iiavS3EpVsbl48WU653P6OYYidFu6PvUwh0O0ipjftwZswixe3+3q2ry/p7ryRmotS+7VbOjaG2b6MCxnYXtbx5W/2C/BY6AOr4oRvvBPJkPFEutZG75BgyG8J8Yah7mhjuVsrLGSb8S4Ki9pjM2CtqXd1koVrZZiu4y+XrxwUfoyxH6nAD+E2fT68z/+5h+e/9u7qnF2M/drvrcROM0ImAA4zaPntp85BEwA6MZDvzqEYAIghrwJgIhF2QTAARgmANJxoa8IEwAmABYRYQIgNTdMAJy5vaQ7ZASOQsAEwFEI+XMjcAsRMAFgAmARbs4AiBPPGQARC2cAOANgEQ3OAIjzwhkAEYt0NZrkvzoD4BZu4vwoI3BKEDABcEoGys08HwiYADABYAIghLElAAcLniUAlgAsgsESgLgPsAQgYmEJgCUA52OH7F7eSARMANxINH0vI3BMBOYEwNYo/G8/8H8f3OkxlLrbgv6vDE1vKaf6vl1ozff29Be00UT1fR08b5w6Hk9U553Lqf5vCM3tCvwJqtDUr0LbWIXfwSH3d2h4Zzhmbfs96ED3oPnncRc1yCdBNbbjltY0fhn6VyhE7eeAxkzQMpZzqn2uIY2dGQAZ6MrbQ9XsllCXu7iuutRWVvvSmqhmlpKCrSuq1aQBWS2vAg16HOTq+nn9JVH7XX2Z6tCnRfgdoL76tKOfDzZ0HPqb+iUxg3KRS+uqO1+9jJrj8Krook737pZq/p/4yysy03NtHcv8TI9niKvcK1QjvPQD2r7aX41zdDL5ujxrioEa9P4r+Xz0R6rBbVxV7XRmgLrdJcU2NPXzfkWxHhW0Bnlnqjr4aUXjbAma/7XbVXdfqmiczGbwFNhqSf8e/3+fkOPJTmz/8ljvPdOwCJOK9rX8UtU+51egmZ/p+SX4emTh7TCkx0BN71+/oGMRKnqD9kA1/ru76tdSgJC9lFOhfrmizxtMdew6s4hlr6f3Ho8VrFnQay9Am53N6WK/DF8NvBrCPvxYtjCnlld07FZXVQs+gicK58FspuTxAHM4n9f3YgZa9Uwmvtv299VzZGdHdey3oVZ9s6meIrmsjksuq+PSgZfNlSvqMVBEnNXwnpxO9T28tKRxVSzq81ttnUMzeBSUSnr9cKhx2WrpHJ+knl+v67OqVXgCzHS9eOyxx2T+pt+ZyQereKdiioU8AmvxWvz4m985v2/vqmJ5zC2ZLzcCZxYBEwBndmjdsdOIgAkAfd2bAIhRbAIgYmECIIWFCYADMEwAmABYBIMJgLhGmAA4jbtBt9kI3FwETADcXHx99xOKQOIs++u//uvh93//98Of//mfh8Q5f319PXzLt3xL+Imf+InwIz/yI4da/sADD4Rf+ZVfCQ8//HBIGPw777wzvO1tbwv33ntvoEvvC+22CQATAIvYcQZAnEXOAEhh4QwAZwA8hYAzAGIoOAMgYuEMgBe6A/N1RuD8IGAC4PyMtXv6FAJJCtqb3vSm+Rf/5Ev/d33Xd4VarRa+/vWvhz/90z8Nb3nLW8L9998veN13333hnnvuCZlMJnzv935vuHTpUvj0pz8drly5El75yleGhx56aH6v4/6ZADABYAIghI4lAAdLiSUAlgAsgsESgGcmwkwAmABIELAE4Li7UF9/XhAwAXBeRtr9nCOQ1Ab+9m//9vClL30p/JN/8k/CP/gH/yCkNWhJJsBf/MVfhG/7tm87QOzzn/98+I7v+I6QzWbDRz/60TlBkPwl5771rW8NDz744DwTgKTBC4E8IQBaW6Pwi9//xweXb9dUL73ZU+32iDrVrGozWy3dQO/tqgfAeKbayH1oLfOpGupF6HUzVdUyV5a0vvkIuvXJnmoXGxm9fg3axxL9DqCTD6hZ3oPOfh+a/62y6hNLr9T2hgs6aruoB93eUI1uvqX3G+3H/hVK2rdqVWuKL1dV953pQjfeUv1xBuPSh753UlZsb78LnYE2u1dQje/VXdW97u1r3LCWdSEH7PDLdAN1wtdeHnX3pVXVjQ6hN+51VXO6e1X1ysNt1blPW6obn6Ju9folJedYxztX1Dmw11bN/wia2+4uPAcGqj/OYk71cnp+9k593oX/Vseq0oj+C7mcxtwMOE+nt0nQDv9C2zLdUGyazaac34NQflzWuNtoq6aWterzZY3zPOrB15q6fpWbmqbeRE31LDxMAub8tSe1zve0G9e7Yk79BMY5+BtUdW0cDnWci6m1LgGJx1lou7NYv2YwQaF+OQPfj2xBzxgMdG2nx0ohj/UGa0KhoGPf7+s8unLlawdj3+tp37N4bxQKGqOrq7pe5fM67iX4u/T6GvN0ou/1dA5fuKia/0JB42QGX41MRts3HOp6xl/Bid14DG+LUcSq39e1r431oNlsyBxaggdAuaxYTcY6B/f3dE5vbW/L/RqYo+sXdH1IMhjTf3nEFd+7+byut5mMxlGjqZ4og4HOk91d9YPJpPxkajWdc5hCIQSdg1evXpW2s630AMhjTg8G6inQ7V4fx4fe/tPzf/sb+h57IfswX2MEzgMCJgDOwyi7jwcI/ON//I/DL/3SL4X3vOc94f3vf/9zQuad73xn+NCHPhTuvvvu8IEPfECuefTRR8PLX/7yMJ1OwyOPPBLuuuuu53TPZzrJBIBuVEwAxEgxARCxMAEQsTABYAJgEQ0mAOK8MAEQsTABcKxtmS82AmcSARMAZ3JY3amnQyBhml/ykpeEzc3N8JWvfCV80zd905FAJUx74mSf/Nr/yU9+Mrz+9a8/dM1rX/vauRzgl3/5l+d+AMf5MwFgAmARPzNnABxMJWcAxFXFGQDOAFhEA53xTQCYAEgQcAbAcXZhvtYInA8ETACcj3F2L0MIf/InfzLX+yckwOOPPx6+8IUvhD/4gz8ITzzxxPxLfqLtT9L7k1T/xd8Xv/jFuTFg8peUMWqgXFjy3xNvgMQj4B3veMfcVPA4fyYATACYAAjBEgBLAA7WUUsADqCwBCC+XS0BiFhYAmAJwHH2nb72fCJgAuB8jvu57HWSvp+k/r/mNa+Z/5L/L//lvwwzbC7/2l/7a+EP//APwx133DHHKNH8Jzr/5eXlsLOjOuQFiAuDwFe/+tXhs5/97LGwTQiA7c1B+IG/Hk0IRy9VDW1xRbWXk4HqAQdt1ZG2dlTzv7Wner6JykZDZVVrAmdr8YRcRU9mXevqmurcIf8LO19XDK99RX/Nm22p9nAtq/WVV8raNj07hP2J6k4nl1R7ufZq1CB/mRIO2RXVlV7b1fbtAcviUPWP2W68fjxUrSIrRVxYUV3nbKK9mfRUOzmEZrYFDW+loXGxsq461WIJNc6zev92SgObBPH2vsZJoaFYDdC/DPTJly5clrlQqsbrS7jXkHpc9HUDdbJnAx3XSUePe22Ng0pR/QqqVZ1TpaqOY6ak2uxxVscSEv8whhcF/R5ydZ03vbxqs5eX9XnFYvRzKBY0Lvb3dX4PBjqu45HOwVpJ9cg5+GIMZ6qFbrVUj0z9cwk+HZWKYss1NY+44DHrgGexHk3gA/Js9+/2VFudyfQlBovwJzikpUZby2WNEy7ukGKHzQ2dM1no1EslHRtiyftnszqnE6lZ+m8w0LFjfXge7+xEffRgoDp3fomcThU7mtyuraluPJPVGN7b0xjf2t6Stvf76llCrPm8BnT33a6+93bxfk4T+cmDy/Ao4DwopeZ8t6vYbGxckbbX65hjNV1rK3hP9Xs6Tltb6r/QgefJ8oq+9y5f1rWUfaHPTwfrX/HQ+qftzUFnv7Gp7+nRSLFO+z2sr8PLJqPjSq+Ffl/jih4f04nGeAi6/rXb2pZu9/ra/Gc//bfn/w43Nc6OtSHzxUbgDCNgAuAMD667pgj8i3/xL+Yp+smGM0mR+9mf/dnwd/7O3wnJyzUp7ZccJwaAr3rVq8LnPve5+Xkf/OAHw7ve9a5w++2YSRN5AAAgAElEQVS3h6R6wNP9LYiFV7ziFeHLX/7ykbAnX/Kf6e/JJ58MpcKqCYCnADIBECPFBEDEwgRAxMIEQCRATADoly8TAHGemACIWFSrJgCO3Kj5BCNwxhEwAXDGB9jdiwj883/+z+eu/8nfj/3Yj82/3Kf/vva1r81L+iUM9W//9m+Hd7/73SYAQgjOAIhR4gyA1BdPZwAcgOEMgBQ5g6wqZwBEbJwBELFwBkDEwhkAEQtnAHjXbgRuDQImAG4Nzn7KCUDg137t18LP/dzPzVvyqU99Krzuda871Kq3v/3t4cMf/nD48R//8fBbv/VblgCYAJAYMQFgAiBBwBKAGAeWAEQsLAFIkaWWAByAYQlAmvixBOAEbIfdBCMQTAA4CM4NAh//+MfDD/7gD877m/za/7KXvexQ33/hF34hvPe97w3f//3fHz7xiU/MjQK/9Vu/dX7eUSaACXmQlAs8zl8iD9jY7odX/8C/O7jN+KWqP159merYl5rQxQ+gHX+qTu7ihhs70GJmNW00W1dN8TCl6bt8h2oRa8uqkaV2mnrdyVDbtvlVrdlb7KkWuzzRWtBB5X9hDL1h6TbVqRcv6f1GFb1BZRW17POqP7xy5QkZzm5PtaHZnGpBq4WIx7AD3SS00zSUzORVQ0v9cA51uVtd9XYYD3Uca1XtWw11tSs4HkNrvbkLLaXKkUO3r8+v1jUWVla1Pv04VQt7BM3/dKo6T9ZP391RzSy127UU7smAtfdVfzxG7WjWi6+jVn3joqbIjoNuWnf3VBMMWX3gl+JKVeMkk9F5MB6pZ0E/hS1135mMiuSzWZ0jvZ6uF/k85hCMOWo1/TyT0TlALTXndCaDuE2ZqF5fN3UsBhDO0wOAdcOpIT7kr5CCYzLROUfNP9s6xHrEtZvPOqy9Vj+Ga1d1PeOv3KxtX6k05ZGwkgjjsc6LpabqrctlnZTEqtVST4LhMMZZNeXJkTRiPNYYTJ+bfJ5HkFOjP5ly1iqau3u6du7tqV8DsW02FRt6qND/4No1Xa/4eaOu2CXGv+m/WerlMhjouO7gnYmQD7Warn11PGs80nHchh/Copb9oj3NJW0r+864nIGR3NtVrBn3a2sXpe/0Qxhgvdxv6f1a7Th26+vLcq9iUfcPxPKQBwmwLuM9yTnK9aTVvr7ePfI/XvcAGG3ZA+A4e1Bfe34QMAFwfsb63Pf0ypUr8woAyQY20fgnhn/8+6mf+qnwG7/xG+GHf/iH5xUCXowygCYA4qiYAIhYmACIWJgAiFiYAIhYmACgoaMJgEV0mACI88QEwLnfDhsAI+AMAMfA+ULgta99bfj0pz89rwDw8z//89L5xBjwrrvuCn/5l38ZEr+Av//3//7883e+853zX/bvvvvukBj+pf8effTR8I3f+I1hMpmERx55ZH79cf6cAeAMgEX8OAMgziRnAEQsnAGg2RTpH6ZNAJgAWMwUZwCk1wzNzjABcJxdmq81AmcDAWcAnI1xdC+eIwIPPvhg+L7v+76QpP8lkoDv+q7vml+ZpD/fc8894d/8m38TktTsr3zlK+HSpUvzz5JsgaTEX5IK+7GPfSy8+c1vnv/3brc7LxGY3PNtb3tbuP/+WLrvOTbn0GkmAEwAmAAIwRKAKK+wBEC/1FoCEF8blgBELCwBiFhYAvBCd2C+zgicHwRMAJyfsXZPn0Lgn/7Tfxr+0T/6RyFxp37Na14zLwOYfMn/6le/OtfuJr/2L7wCFqDdd999c4Ig0dIl5oEXL16cZxIkZfuSygEPPfRQoCbyhQCeEACbrWF43f/8BweXD9ZV11peUp17oayauyrqcrOGb7sHfXRRNb8z/Q4eZqk65KxPXCipBnVGbfNYtc65XFZgmapcOTQLqr0edVTXnmRppP+KNX3+pIDnQdM/Hqu2k2WyqEPd2t6Q5/X7it3Ssra3WIp+DKyDzV+k6tDMFwuq7S5A859kmaT/9vdUF8+a4sWCYlPMa9zkMno8HunXbrY3wG8hl9fBm+Fb+zRoIGVTtaapWR0MFFfOHX4JLpVUtz6baQxPpxpnISi21DPncvAgyGjfJhPVK4/H1C/rHMwBa2q/qbHd2romXU7/kl0sKo61mmqjieXOjmLJ66nBZZxRR8517bCOXtcnyjO2t7efdSksV7R/9CDgnKcnQfqYXgxHaZu3oBdOSN303+23q+dJo6HZB52OekOMRhqH/Z5iQ917qaTrR7O5hjhQ6JaXVbc+Smn6kzN7PY3LSlmxTcd5BbiPRtqXwUA9ATgHa3WNwxB0DkwxJ4nVHtYvrr2VinrbZLM6R1lPnnHHObbUVOwO6ehT3hjUrXc66ncyhN/K+rqOWx7zP5NRbGZTjZP9ls7ZQkHHjXOYc5D334e/AucM+04/mulU3zXb2+pt0Un5Cq2sqifRYMA40nstLalfAtfiWlU/59q9u6dzdNa//uL51Dt/aP5vf0PX0heyD/M1RuA8IGAC4DyMsvt4CIHE4O9Xf/VXw5/8yZ+EVqs1JwHe+MY3hl/8xV98xjT+Bx54ILzvfe8LDz/8cOh0OuGOO+4IifHfvffeO88auBF/JgBMACziyARAnFEmACIWJgCU3DEBEGPDBEDEwgRAxMIEwI3YnfkeRuBsIWAC4GyNp3tzyhEwAWACwATA4UlsAsAEwAIBZwDEWHAGQMTCGQARC2cAnPKNoJtvBG4BAiYAbgHIfoQReK4ImAAwAWACwASAJQCpL7mQ/ZgAMAGQIGAJQIwDSwAsAXiue0yfZwQWCJgAcCwYgROEQEIAbPVG4c3/678/aFWnovrASVE1daxhXkRt6AKOhyNo6FL1j5OHZrOqfx6ntOfUuE6gZeTmnPWSqSXM51XryFJNpSIdv1XLPYZudX9/R0Zz0Ne+rq6qbpVp9v2+Go5t76gHQAlYLq/o/SqVSGB0uqqF5C9UY3yxyedVRF8qqkZ/MtFxefzxq9JX6kIvXlT9ci4Lv4SRplJnZvq8TqrWc/KgXF79F2p11bVm83rc7ur51VrU4Nbgf0C98WSs48C44rgNB3o+dfGJyWf6j8ewpggZeFlMoPlnrfpqTT0JAvwPQkbjdoS64Pv7qpNvt6PmuFJVLfTCnDT2R++dS3ktJOcwe2JzE3rejq4vrA9PDwBqtfs9aH6HOucSr5X0H/XVxZJ+Ti+LNuMQQv/0WLJt9M3oHdLkq49GIu1K/12+fEGOq1UdZ3qalMuqXx6invpjjz0p96ul5kTywYULt8vn1JKHmergr159Qs7vdrRee6Oh6+vyclyv6A1DnfnOjq6lw6Hq1hO/nPRfFd4Urba2Jcf1oa1xsrS0JPdrNHRtHY3UkyCbxZwaqt/C17+u2FThKZAYAaf/sqm4og8FvWK6Xe1bva5tZxyMx/DZmeo4DvEu4Fp+yPumqNhzC9MGtlubW3JKUgo5/cd3D700DvmQ1OOaxHv1EfONhvoj1KpK8h/yM4Bfy1RfI6Ew0PdYbu96HHz4XX99/m9n48oJ2tG5KUbg5CJgAuDkjo1bdg4RMAGgGykTAHESmACIWJgASC+OJgAWaJgAMAGwiAUTAHGNMAFwDjeT7rIROAIBEwAOESNwghAwAWACYBGOzgCIE9MZABELZwAgCyiV3WECwASACYAQnAFwgjZ1booROKEImAA4oQPjZp1PBEwAmAAwARCCJQCWACzmgSUAqXehJQAHYFgC8Mx7JBMA53P/6F4bgeeDgAmA54OWzzUCNxmBhADYHo3DW//4kwdPylRVGz5CLXvWep5MVCvJ2vWzmeqlM6h5vrKiGr20fHpnVzWyw6H6EVDnSX0fdaUTaLPLJdX8N1FesYz670PUwd7ZUS317o5qH1nXm3pj1kBvo/5zDjr9Q/rllAaYWmx+ken1VAO7vLws0ZWDxvXKFa1vvLevY0Ed6uqq6peLBdUndzuqS81NVFtZhgdBpqBxky+g/jvGcrelcZhPPb9WU117CTpwxmwhr21l3FAjy1+CWe99d1fjolRUrXS5pP4IBYx7uaRYFYqqDR9gXtCTYDRWYevensZtWo8cYKTBWvDlio5rFRrbfdRbv3JFNbK9no4T68NTm72+fknilGNFffRspv4LlYp6TZQr8KZIeY4kD6LBGY877TgPhvQfKOi9WRqOc5Ja6KUljVN6PzDOSli/Bn0d515Pj5tN1UfTO4IeAL2urhlXr6jOPZ/X9fjCutZoLxZj9kTaaDLBeTrV98ygD936TOcEfS3y1KVnVWdOL4qNDfirlDQuWKueY0MZEErXB8Y5P2ccl8pxDlPzz2cN4DlCTxGOWxHrw2yqWG5vKxZl+CvQb4HbEEyZQL+Z3d1IKCbXdlIeI8kx33vLy7oH4BqgnieakVNEHIzH2tc+4ioDf5SpvlZCb0PXp2Jb1+rJV6/H/Gfe9475v/19xfImb9l8eyNwahEwAXBqh84NP4sImAAwAbCIaxMAcYabAIhYmABQ00ATADE2TABELEwARCxMAJzF3aL7ZASOh4AJgOPh56uNwA1FwASACQATAEmJL81uMAFgAmCBgDMAYiw4AyBi4QyAiIUzAG7otsw3MwJnEgETAGdyWN2p04qACQATACYATABYAhBXcEsAIhaWAKSyggqaWm4CwARAgoAlAKd19+t232oETADcasT9PCPwLAgkBMDmcBD++od/7+Cs2VR1n9Op1t2mNnI01M9nMz0uo5Y9a/6ma9knjcim6sd3UNu93VZ9HvXI9Tr9BFRHPkLt5tlEdaese81677msbgKpzexCZ1+vK8FAbWMIKkCcQr9MzX8Pv1TPUjWMs1nVhVMDC2l3qNVUy03/hE4H9dZRb7lSUQPFSlU9BWYz1dj2W6rNHu7q2JSKqp9euk3rcg+GWid8v6M11UcT1RTn87F29RR1sKmt5jgEjEMppWVOYpR1qll7/oknVCvdaWtbqXldTdVLT+5Pz4EOatOP4H+QjoPk+ulMsZggzvsDzXjI5uL5jabOoYuXVINP7fZ4rNpr6ty3tjZlBcpmdA5R9760pDryfp/ri8YRa9NTa/7Sl71Enk+PgC507isr63I+58Fuql49tdoFeDtwDvKXUn5OPwSutaxOQbKCHgAcK2KbCapvDqyJPtX18drVJxVLvBsuXVLsatW4BnQ6+l4Zj+izoTFLf4IyvCZy0LlPYFjIcaYPB/0U6nWtdc/rC3lIQTo6h7Y2dX3KZHT9o+dKo7lygCXHnevTlSuPC+700aAfS/odmlxIIqeF9SiT0bGgHwKxyhe0b5lAbHTOtlpaLWJ/Xz1ISkW9/uJFjaNmM74LpmBe2Ff6BG1uqR9BNqvjvLaq69vgGrxmntDj4sb199RD/+rt83/7e+qV4w2nETACT4+ACQBHhhE4QQiYADABsAhHEwCpiWkC4AAMEwD6ZcYEQJwnMxMAB2CYAIhxQdLMBMAJ2vS5KUbgRULABMCLBLwfawSeDgETACYATAAkCMAK2gSACYCnEHAGQHxzOAMg/SXXGQAH7w5nAHiDaQSMwBEImABwiBiBE4TAdQJgGP67//P+VKtQSqqrJcwyGf28hBJms6l+zpS9GVI1c1lNQ83l4/HWtqZOTyZaAmhlNaZRJh0oopQcUymzQctWDfuaht5GquJ4pH1hujPLMdXrWsYrwTf9l0WpKpb9m+AXtQmxBHbjVHdyqZT35JksOVhHKTyWBWRpu0JBJQUs/ZQvqLwhn9fjMFOJwaSt2Pf2VM4xHOgvrdUVpOSWNNV8OGoLtkWU9UrX7Wbq9HCo497raZpoq6XpvJeRkspx5i9cm5ua9j6daBzdeccd0vZllH8bIu29jzjd2t6V6ykJ6PaU0MjmNO0+XZ4tudEgVd5yZU1Lxb3kJZpCzzjpo/QcJQAbG1oGkDKYMsaNccv1gunPV5GWPoC84dJlLU/J5zONnvKObldj5drVKO9oNDTmGRcsr8a0csobiB1fFbw/y7+1WzonWIZwaUnXy0Je5/hwqPKKCeQdm5ua7pzLKoG6tqaynbXVKBPa3dGYbe1rW5sNjbtsVteP5op+3sK49AYqMTic1q5p61wTWIpvALkV45TEENfHRgNlVnP6nstko+ThkEQHz2apS753ctDVTdCYDsrLsq+UmvB6lpusQI5RxLuiWNT3ILPL9nY1Fvb2tJTeyorG6cpKjCv2nWsv1yPOkTKka5TO5af63uk9ru+p8NSr4TP/y/UygIMdlwE8QVtaN+UEI2AC4AQPjpt2/hAwAWACYBH1JgDi/DcBELEwAWACYBENJgDSGQBKWJoAiNiYADh/e0n32AgchYAJgKMQ8udG4BYiYALABIAJgBCcARB/5XIGgP5S6wyA+EIyAWACIEHAGQAhOAPgFm5U/agzgYAJgDMxjO7EWUHABIAJABMAJgAsAUj/emkCYIGGJQAxLiwBiFiYADABcFb2wO7HrUPABMCtw9pPMgJHIjAnAAaD8D2/Gz0AMkWWU1M9camkus/ZFKX2RpoayVJX1NWzVNVsFvXK9ABYX9eSPatrF6WP47G2hX4FhZy2vYtySNtbqk1krec8dJzU2LJc0m3QT1Mz3B9oeSQeb6dKjiUdZdXCUjnqZMfwR2BpunpdNbXUpVNHOjzkf6D6YJa5YtpnpaLl3Gp5LRu4fUVLQV29elXGMoe62+Vl1StnC9oe6lirqRJkIagGfgJN/lG69WpFvxRevKC6cmJNnWqnrYZhFZTGrFfhn4CZS917C+Uwt7bVp4NlAVlO8tCcnMQ5vrSs2mXqcanRH2G+b21pW6hzT+t5k25WK/B6QCm6ZhNeEsi1vvKklkjb3VX/BpbmW13VsaNW+xA2KLm4uRHjtA+t9vq6YletaswWSxpHh8a1pTp2fk7/ghq02CwzSM+S9No6D7HUWpscsszq/p56sFDL3TzkgcA4jr4fWdQhnU219Fulov4B9CBRB5AQ9lGGj2UAWaKRvhc0/uzifvzCz1J3/b6+F9lelsrr93W92tuP2HK9yOd1veLaTA0/vSWo4e/11G+BpTIPewho346aM5Q/FOAPM9Guhw6wbuM9PBxqe3OpMqUlzKHDniS6/+D85p6B7y2Wr53t635otHu9M//h7rfO/+1vuQzgkRtNn2AEQggmABwGRuAEIWACQDe4JgBicJoAiFiYAIhYmAAwAbCIBhMAcV6YAEhjoUSQCYATtOlzU4zAi4SACYAXCXg/1gg8HQImAEwALOLCGQBxhtC53gSACYAFAs4AiLFgAsAEQIKAMwC8vzQCRuAoBEwAHIWQPzcCtxABEwAmAEwAJKnPmnJqAiAuQpYAaP6yCQATAAkClgDEODABcAs3bX6UETilCJgAOKUD52afTQQSAmCjNwivfv+/O+jgxZeozv6QJ0BFN8SdjtY8LxYUq/19rbFOzR519mndai6vmtnlFW0b62KPRuoBMBiopj8TtKZvLqN9GaB++qFyRkHbs7ur2m76GxzSO0MTnM1FjWyCWrur7d2FBrfR1PrI9UbU1dOPIAu/gtFQdZ35gmobx2P9fJiqDZ+0jXrkYlG128SqVluXQMhk9Pz9bdQsR13vckn105VlXN/S+vKzmY59JaUtT///p5vJm5saw+zr8pLWtW6kcE/uNx5pHDGbYm9XdfHDgWK9sqT+CPQUYBxMZ+plMRhqHI2xI6fmNwQd+/T9mk3VYtcbDYGsVFLtNu9N3Tj1xw3cj8+jBj8PLwhi24F+eH9f5yR17fSuWIOPCHX2rKGe7s90qnrjQiEnWOVyquUuFnX9mM1U2d7t6vrEWvMX4D1RKGht+0pFU687Hb1fu6WeI1evatzTE4DadJJBly7hXQGdf3qtL6f8ShKQNAJDyB3hr0IPgC78F6azkWBfqSg247H6K4ywvpWKen4GviGzmb7YigVdj6h7H2C93W9pXF7biNhns4rGhQvqbcP3XD6v839/X30vWhhn+nRQxhMyer9CQftag0cJ19Mh1p8p/GgCfD1yWXocYFVGe9JzkL4b3E+04bdSq+n6dfHibXgv6XrG91RmonGxd/X6jwb/P3tvAmxrWpf3vmue157OPud0N9ARlSFBLcSolQhcDFBARYwCbaXUSiQELEnlWuSWVRCL3BQCVxPFVClSV2JVHLgJdOIAl3tVGk0arhENDpAgg5KGHs45e95rnm996/Ta7/f8Vndv+kzss/ezq6jD12ut73vf5/2/w3rW/3n+/99r75n/O9jeOp2HQ/fKCNxgBEwA3GBAfTsjcD0ImAAwAbCIHxMAcSaZAIhYmABQAtMEQIwNEwARCxMAEQsTANdzKvNnjcDpRMAEwOkcV/fqNkXABIAJABMAITgDIP4C6AwAzcZwBkDc3JwBELFwBkDEwhkAt+kB0M02ArcQARMAtxBsP8oIHIeACQATACYATABYAhBXSksAIhaWAEQsLAGIWFgCYAnAcWdLv24EiIAJAMeEEThBCCQEwJVOPzznne89atUdd98pLVzZ1F/ERnnVWo5mquXOZlUXe7CvRnv0BKD+sVSKmr1KRfV7haJqsfM51SpmsqqFHg611nyYqQZ2PFJdaBGa2tkUhgYz1QvmcqoD3dvVvs5Qb359TfXVlareb/9QteLZvGqKa9CeZzKxfb2+6n339jR1mYf59Q0d13JZn7UP3Xqrpf4E+bxqI++4426Jm3xe9chbWxonAX4KzabWUB9AJz+Dxnc4ZP90LCuVqLemzptT8PLlWNoteW0HngB33XWXfKRS0TikZIA1z6l3nk11DlFjOx5rHG+hPcOReggUSzoW1Jazv1locFspE0Rq9HlN/XClrLr2Vkv1yI88/LA8PqPy33DhgnpFFKCTHwx1XFnjnL4b2azOWUixA6/X1vT51On3uvr8djuuKazH3mxqXEwm6kuRy+l87/X03vtYKxtNXf82Ny8Klhxn9r0HTxN6VfR62r5CHutdUOU921+Fvpo6/tE4Zpbksrq+9Pu6TwyH2pYqdOdL2MEDYDLV9a9Uwt4QdM7MZkr+9uC/UC7pWDYbGifl1D6VDMo41dfkugvst7Z1XozG8fn1hq59zLTIZnUcBgONm0xG1xP6buzu6bOLMOopwM+Aa3Gtpn4ssLYIk7GOHX04ZlNdAUcj9Ryo1WoS16urGvfj1P0vX3lE3nsAn5zBgHNO425lZV0+32jodZg9sc9P7+BqnP3ZD792/u9wBz4aJ+h856YYgZOEgAmAkzQabsuZR8AEgAmAxSQwARCXAxMAEQsTACYAFtFgAiDOCxMAEQsTAGf+KGkAjMCxCJgAOBYiv8EI3DoETACYADABEIIzAGJ2hjMA9BdAZwDE/cgEgAmABAFnADgD4NadUv2k04KACYDTMpLux6lAwASACQATACYALAGIy7klAOmtzRKABRqWAKSIIMh4nAFwKo6D7oQRuKkImAC4qfD65kbgySGQEADbvWH4zl/44NEHMyXV6xXr+ovYMKdaymxd339woBq9fl+/ZFMfXa+rLn5lZeOoLZWKagM7HdU6TqEl7AxUZ97vU5+nOtFKWU8yK9DwDod6AM4E1VpPJ/r5FmqQ51AXu1lTzwDWEZ8GeBikdKIJKKvrqldMewSgpHigJwB16qUyNLLQkbZRX526ceqPV1Y2JfjoAdDrad9Qqj7wl2fWQK/V1FMgk1EN73J96KgxZu34Uknv1e1qje7dHfWO2Dyn9c4bTY1Z6k6n6By113x9A34MxPoQdb0fhq6+Cg0tjexY13tnR70m9vejvwM/u7qq+mTei/XU2deDA8WyVFIdfKWmc2oEPfEMc6JcVj0yHcgD6rVXKup10e+r/pjrz2ior1NP3UnNi25XfTHY9kpF44y69nJZsSC2w5Gud9WqaqMZJ/2+vp9kRrejuvt8Xp/PuOTaTewLRV2fe0vPj+tdv6/7xsGBenhMp4r7xYs65woF1XLv7Gr99ZUVjYtCXtfm2Uy14d2u+sHs7+lYZjO6722sa/34sUId6GmSL+j62u7o3hMyEftyWXHkHBxPFDvGZLGoezA9AnZ2db7PZopNs8m1W7EuFjVO8jldy/f3dJ8dwN+hUNCxyab6nmwaNBXkPJmm/Br24Gewizjo4dn0DKksYa19z6Bt/Z7uM4Xs1bj44x/6gfm/A/izPLkTmN9tBM4OAiYAzs5Yu6e3AQImAEwALMKURlImAOIENgEQsTABEI0+TQCYAEjljigBagLgCA8TALfBYdBNNAI3GQETADcZYN/eCDwZBEwAmAAwARCCMwCcAbCYB84AiDuIMwAiFs4AiFg4A8AZAE/mnOn3GoEEARMAjgMjcIIQMAFgAsAEgAkASwDiomwCwARAgoAlAKncBksAYjaDJQAn6ATrptxOCJgAuJ1Gy2099QgkBMBOfxRe8cu/e9TXaUm1mId91WoOZ6pHHOdxPVbN/3SqGroMdPEXzqu2stGI9ZdR0jf02/qsSlU19X08u9O5ImOYg3ax2VD9MbWHw4FqHYvQvI5QVLzXVZ1pGWmguaDYTqHx7w9VJzqElrxY0f7WG1ETPBypvrfVVk3rkmYftZYDtNbZrI5bF3WyRyPFpoS62NS1FgqaLjwEdtRy51DPnXpmxhH7n67zTX0xNfsBmth+D14RwL3ZXJO4Yl86XZ0zo6EKhisV1RfTo6Be1xrk7PvururqiQU9DopF1fSOoC1P+0OwPnqtpm3JoDZ8twMjTdQYn06079T0H7RUn5xVuXHIZHTONBrqvzCb4QNBsS0W9f2jkeqlOcepqw8w1xin5tk+/A1GmIPEknrku+++W+JoZUU1/geHUW6QvJH11Xk/+nysrWnt+ho8BDgvssA6l1OsAi6p+ae2fDKJcUdPj91d7VsW1vJ33KH7AmvDMy6WNP4dXf9aLb2mjn44gM6+q+tfqaTzoNlQb4y11ehdMx9UaMm7Pb3/KGUiUCjqus4YpPdCFiZ82ax61UzgGbC7p+tFCLoe0K+Fz8/ldA7OprrXbMQTcX0AACAASURBVF1R358BvCCaqX0qgYbrJ70oGNe1lMdJHxp/+qPQc4RrPTX+9bqu5WkPoqSt+ZyuJ4st/P7ve/V8mPtbesY49YdGd9AIXCMCJgCuETh/zAjcDARMAJgAiHGlX+hNAERkaFJlAiBiYwIgYmECQL+ZmgBIzRMTAEdgmAC4Gac539MInGwETACc7PFx684YAiYATACYAAjBGQAx48EZAPh51RkAcYlwBkD8EusMgCMsnAFwxg6O7q4RuAYETABcA2j+iBG4WQiYADABYALABIAlAHEWWAIQsbAEIGJhCUDEwhKAECwBuFmnUt/3tCJgAuC0jqz7dVsiMCcABqPw0n//4aP2T/Oq99vr7EnfhtD/jUaqe683VM8YIBzNQetZr6vuNV0yKJNRreIAOk2mZvfhV9Dtatupcy+VtFZzPqfPW9K0QrPf6Wj9+ApqnNdQB3wMU4NhX3WmIavPH+PXx3xR9Yj1ZqyvzFrRV6DLLJW1rxcuqD6Y2FBjS/3xeKy60wZ+EUun/14NIO0b9cp71ATDAyAHLSbL0VVTOtHkaaVSfB79Dzhu1PxT913IK3bnzil2Y3g1bG1fljnD5zebqkunB8AQXhD8Urqk+YeGmJ4BY8Qtn3d4GOdJr68xff78eelLA/4EW1e0HnutqqRaEZ4AI/h0jKBXHgz1+YeH6qdQLuv9V1e1fdOpvp7J6PXurtZ/n0z0Z236J9DnI5uN6+NoqFro4Ui9I5rNJ/ZyKJW0bbzudLTvrIF+cKA6eno7bG5elLE7t6FY7e8rFoW8YlGAd8R4rDr2/QP9PNeEtO/HZKpeDb2eekfUajon6McygZfE6qpim8uqhIl7wZe+9EXBotvV55ewtmJKhzI8TuinsLKyIvcvlePanLwwGOpaP53G9XOKdX4w0LhiXFDzn8sptpwz7Y7e7zx8d2Yz+GJg/anXq9K3zEz3/O0tXQPaLY2LVkuxXl9T3X29rtilNf/Jg9PrF303hvAzoR8L5wSfRa+aWk3PI7WyxmXl0bX2N1/2nXNMupcv3ZZnPzfaCNxqBEwA3GrE/Twj8AQImAAwARDDQw/QJgAiMiYAIhYmAEwALKLBBECcFyYAIhYmAHzsNAJGgAiYAHBMGIEThIAJABMAJgBCcAaAMwAW88AZACniyxkAR2A4AyDGhTMAQnAGwAk6yLoptwUCJgBui2FyI88KAiYATACYADABYAlAnAUmAEwAJAhYAhDjwBKAiIUlAGfldOx+3mgETADcaER9PyNwHQjMCYDhMLz4P37o6C79ieoFD1BPvgNPgMFAda+1utZ7r9e1XjL1htRHp+uOUz88Hmua+nSqmtTpVHWW5bJqIyG1XEJuNNT7s3b0ZALN/kyfX6uoprdRUx3oaKD3z+X09S7qJ2dySlBUqqrFLJajdnM81nHY29f66tPpE9eib6BWM2tJU0c+nUIvXNBx5xcp6oN3drQu95Ur2l5qbOkBQF08daMrq1FXWizquFBj2+vqONILolFXX4s6rkdj1cRSp0pN7tq6amCpQ2Wt635f799pq/abemlikUPhcGKX1v23cO8SfC2yGR33HrTU9E8g9vSaSPtYJBOyP1APgK0t9VMoFHROb2xovfhcTrXh2SzmGOq7My6naoES8vB/aDbjHJxCl845Q5xZ35xeDKxZTuyL+EX+8mXFpt3WNWAVtelXmhp3jAvOcfqKjOAlsb+vc5ha73RcD3X5Cfm8zsk6PABWV3XfyBe0OsMUXjStQ21LAe/v9dqy3tMDgHMum9E4K5d07eUc29zclPsvjS109WkPk8OWtn17e1vulc9rW6pVjfHJRIN2f1+9IzIZeJjAG6JU0vWNlUBmOBP0iSW8cLpdXa8GfT1TUGdPT5VqVfeSbsov4vLlRwSbPnx16K9C7xl6x8xmii3nTBNxGUZX17/ffMWL5v/aA+A6DqD+6JlCwATAmRpud/akI2ACQEfIBEAqHwDmbCYA0r+I6YHZBEBqHoFlMwGQnlMkAGlyql+cTABE7EwARCxMAEQsTACc9FOm22cEriJgAsCRYAROEAImAEwALBBwBkDqywaqQTgDIGLjDABnACyiwRkAcV44AyBi4QyAE3TIc1OMwAlBwATACRkIN8MIJAiYADABYAIgBEsAYtq9JQC6JlgCEPGwBCBiYQlA6gu/JQA+UBoBI3AMAiYAHCJG4AQhMCcARqPwsv/7w0et2j9ULTZrmmezqoPP5rQe/MbGBekhtdtDlVtLjd/kg7Va/IWN9Y0HA60nPELdbeo+qSUcQGOfRa151le/jBq/o5E+v1xSPfT5zXXpezaj2Az62vnDlqb8FlDPfW1ddaVBHxcymTgWw5Fqp8fQpVMDm82opraK+u3Dobat11N9MWtXl1Anuwm9cb+vOtWHH1b9cge1qpnmWixo2v10qunUjabWay6X4/vpJTGbad/78ACoVIsyjiuo5x5QB7vbQz12YD+GoxhrnlOHPkTN8MNDravd7er12pr2nTpY/mo/HOlY5FJzmF4S1LVTw9/l4b+jcbPSVC13sQhtdVXHtT/Qvu3tqR6adb3Tteavrh+qc2806EGiemh6WWSg/d6Hl8b6epzjlYrei7pvtpXjmMmoBCCD9QKl6cMQ6x+14vzldTLW9eeuu54mcX0eWvB8XheYg0PVkh+29LrT0fWQeuu0D0gPa+9ooG1bXdNxunjxorR1Ag+TtHFl8sYpdOrt9hNr/unHQB+Neh3131PrSfI86vLT3hDJ64fYR+kns7ISdfzTqWLR7apmnj45vZ7uI4OB7skVeARUKoptD5r81ZXol5K0nR4AY+yz/a7uBdwbcthXSZaUy+rLwetKRdeEtEfJYUvXhwlMO8pl9ZZI7wNX+6YxzjmTCfh8QduafXTO/vYrXzaPz94V3cdO0PHOTTECJwoBEwAnajjcmLOOgAkAPcCbAIgzwgRAxMIEQHqlVOLFBEDExgSAEhomAGJsmACIWJgAOOsnT/f/LCJgAuAsjrr7fGIRMAFgAmARnM4AiNPUGQARC2cAaEaUMwBibDgDIGLhDIAUEeYMgBN75nPDjMBXCwETAF8t5P1cI/AYCJgAMAFgAiAESwBiCrIlACpRsAQgbhyWAEQsLAGIWFgC4OOlETACxyFgAuA4hPy6EbiFCCxMAP/Ob/3m0VNHY9WSX77ykLRoMFQN3uqqam7X1vSa2vAu6nBXqw25fyulM33kkUvyWrWqh3P+OkntM+teF6Gxp963BX3h3t4WRkPTn5sN1QfW66odX3JMh/Zye1s1tVXUHL7zzjvl+cORaj/T/S8olxGIzSOPaP3kEcwYWGOcGtkOtN5Md948/xRpazr9N3mBOlVq/vvQCFOrmUUta7ZvLaXNTp6X1pHOZijuHjRVeTxSDW2tpjrQMNPXc1mNg/FENbEho89ThW/SNtXcjqDJJ1as957N6h3X1/V+RYjH6SkwQn/r9ahHzue1YPt4rDpv1rYfo+3tlr5/OFCs1te5PijWmaz6Mxwc7mEOaPu2t/V16u7vvvvp8vlz59SjhH4Qw6G29/JlXf+GqXlz/vw5ufcadOytlurQ6XvBZ128iPutaj30dlu9Jjq45nq2tbUr7WvCD4FYcOuZwGdjf1+fv3+g1/z8NOW1MRrBs6Omfinliq6l1Zpej0aqiw8zvR/Xu/FY44SeAAV4ihSg9W404pxI+lWr6XWxoHE6HOpYdzoal92uYpWeo6WS7huMSfrocL148EFd2y/ecZcMBWvbj0a6ftBPZTjAeob1r5DXOUsCoFDQ11EZNLC/1OmPJ+ojMhzGsR8iDkolfVZWl/aQy3GcsHbr0h7yeR2LyVQ/P5lcxe7jr37N/N/+FZ4RbuEBzo8yArcRAiYAbqPBclNPPwImAJRQMAEQY94EQGr+mwA4AsMEQCThTACYAFhMDBMAcb00AXD6z47uoRF4sgiYAHiyiPn9RuAmImACwATAIrycARAnmjMAIhbOAHAGwCIanAEQ54UzACIWzgC4iYc039oInBIETACckoF0N04HAiYATACYAAjBEgBLAOIvuZYALLCwBCBNCloCsEDDEgBLAE7HCdi9uJUImAC4lWj7WUbgGASumgAOw0s/FD0ACiqBC1e29Beww5a6Yq+ghvDmptauZ53uTke1mSHoA0cpnTu1z6OR6otLJRX80cm+XldtdBX1kHmQ2dlVzezBgV4Xi6oHXFmpCsIZaL+pT6Rx1M6uptBSgnDxonoAsEzhdBoFjPwFPwT1C0hrl5NGz1A/OQvn5gH8CqYQco7HKp48t1RTXMkV6laJxf6+eku026oD7aK+PEObdcOz2ajDz0IYynHkvaiR73W1bcOhamRZP319Q+tus68D6Myp+adXxWCgWPCadbvLZdWOsz4764pXKnEO5nL6BTib1XGmvwA1/3t76muxu7Mv8G6s6/pQr2lbqcVm3NEj4PIV1T+3UP/9woXz8vxKBV/klvwSdN7Q6b7bjWtQo6Hzn7px+locHKi/CufE2prWnq/X1NiD3hMTaKUZR9vwAOB6VIPnCP1YOC+6PY37vX3VuVPrne5fsaS13RvwI2Dt9yx8NvK6nIThQPeCK5e0HvtEwziMxurLkcupdryW8sFI+n3hgq69uZzq5kcjjqWuEZ227h37+3qd9spZX1fvhz7WXu6RjKvLl7dlqOrAdmND50ANc67T0X2o19VxplfFeaz1Y/g79Hs6h5ghUCxrXKfXn6QjGXicjCfxfr2eri9cC+mHQr8U7oOdrnpLHByol0MBB6LF2vnJH/wnc8yH23oe8qHTCBiBx0bABIAjwwicIARMAOgh0ARADE4TABELEwARCxMAJgAW0WACIM6L0cgEwAINEwAn6JDnphiBE4KACYATMhBuhhFIEDABYAJgMROcAZA+zOuv3iYATAAsEHAGQIwFEwAmABIEnAHg86QRMALHIWAC4DiE/LoRuIUImAAwAWACYHnCWQIQMbEEQFPNTQCYAEgQsAQgxoEJgFt4aPOjjMBtioAJgNt04Nzs04lAQgDsjkfhe37vt486OAv66+fBoWrcuj3VC+ZQd/c4XSnKz4fpVG+Q1o1egq4zhOP0yXovaq/pR1ApN2RgpxPVie7sXJHXyxX1AFhbU4+B4Ui1k5mMvp/aa9YwZ63q1VXVkjebep3Go9dTTSp16tTYNuCPkMupRndR73gBwHSqGtheT7WSq6iBPkOdbtbx5tj0oBulnnk40LgsFFRHWk3p2JM251I60iXvhGP8DOjFwHEbj1WTX62qFnwVWm4+fzjSOGNpPdYB5/On8G/g/an5H8F2o99XLNMeBtVqRufEVDWyxD2kar0nH/zSAw/K5zmOqyta//0c9MmNBuYUFowe/BB6fU29brXVc4CShXJZPQDqdfUgGI91jWm1VHOcjuNqheO+AewUy+M8ANiWooZ4KOR1IAuoRd9pa1vbbV2PVlbWpH3M+qEnQS6v62kmow3aP1Csu/DKyGajt8TKqo4ra79Tm13BWkssuh1d765cUh18v6869IFehkxWTQWe9rS7BZsmsJpMFPtMRq97PdX4P/TQF+V+rZZiddeddx29vr6ucyKXU5w5hw4Pte+tlpJUubwS25vQ7Oe4aWPPz8EzJZ9Xn54MfHsyM21vmiRLOtlua3v78FBZWdU5Wanq2GRSfhDcd+i7Qx8getWw7/QQ4JwZYfGcza6u/Z/4+2+a/zuAz8bpPCm6V0bg+hEwAXD9GPoORuCGIWACwATAIphMAMRpZQIgYjE1ASDrrQmACIcJgIiFCYCIhQmAG3ZE842MwKlBwATAqRlKd+Q0IGACwASACYAQ+CuRCQATAAsEnAEQY8EZAGksnAGwQMMZAKfhNOg+GIGbi4AJgJuLr+9uBJ4UAiYATACYADABYAlAXDYtAYhYWAIQsbAEIEV+WAJgCcCTOmn6zUYgBBMAjgIjcIIQmBMAo1F45X0fPmrVCPrmIeod5/OqX55Bl8+av6zrXSiobrbXU81tux1/WWm3oW2E30A+r1rmhT5v0Rlqq1egPw5BtYv1mupUBwPVLuZyquktFKmRVWyozT48VI3ulSvqr8Bfnlm3+8KFCxI96VrSQ2ijW231aiiXy/LZWk31wOOR9mU61Ov9fdWwFqDTXFlRD4HRSMcuBNUjM45Ya3oyUf+E6USxL5dQx7uq1+NR1K7ncqopzeb03i1opff2tL45NfcTFBmfTvXXQNbZLpVVZ16u6FiktdLJIA1Q45zPY8ZCsajYF4v6vGxGn7e9pWM5Tfk1QNYexmP1eijCe4Ex2u2oZ8B4rOOWS+nCk75euHCHxOV4rF4Tw6FiyxriE0gUrlzRevADiL8LBY2FfF7XgF5PPQW6HY3jRiOShtRucxymM+17v6/rwxBeDGXEcKOubZtOUXt+qFh3oLWmd0S1qlrrckWvcznVeoeMYsX1aXtbdfeM08k0ru3Npq6tnCPTqYr0SyWdoytNjeFuW+Py8qUtiaPJRNevGXTq9OGgh8mFixflfl14ngwG+vzhUK/39zQO6QGQXrvX13Qtnk4xZzAuWH4C16tGU+9XKun60Otp3OSwHtILJw9PgWIB6xnWmz72IursD+CHUChqfzfONQX7XC7GURv7GjX6XIuX/VV0feEcoVcOfTYWbfndV/zwvI29y7qHn6DjnZtiBE4UAiYATtRwuDFnHQETACYAFnPABEBcDUwApH8RNwGQ3idMAEQ0TABELEwARCxMAJz1k6X7bwSWETAB4Kg4cwh86UtfCj/1Uz8Vfvd3fzck/z9hnO+4447wghe8ILzpTW8K3/RN3/SYmHzkIx8JP/MzPxM+8YlPhE6nE+6+++7wqle9Krz5zW8O9br+cnOtoJoAMAFgAiAEZwDEX9icAeAMgKP9xBkAR1A4AyCeMpwBEIIzAK711OnPnVUETACc1ZE/o/3+wz/8w/CSl7wkJKmTd911V3je854XkjI0f/qnfxq++MUvhqQU2vve977wmte8RhB617veNScHkhTy5z//+SFJ/b7//vvDpUuXwjOf+czwsY99LJw7d+66UTUBYALABIAJAEsA4lJqCUBqWzEBYAIghGAJQJwTlgBc97HTNzijCJgAOKMDf1a7nfy6/+d//ufh9a9/ffi5n/u5sKihnWiK/8W/+BfhJ37iJ0JS6/2RRx4JC432n/zJn8yJgkS79sEPfjC8/OUvn8OXlNZ55StfGe677755JsC999573bAmBMD2cBCef++vHd0rixrAIag2swCZ6AT6Z9ZIZ21par2pww8hpeWeqa67D210NlUf+GoHVGdeq+kXfGp22ZYZNLvUBxKbbKrWfPL0ZCzTf9Q+sjxSktmR/mPqeUIQpf+e9tSnynVa18/a8b2+YsFxyGRUx1nIqE4UUIY2NLeTlC4zaVRzU70dJhNNHR8MVCuZzV6tp7z4o1Yz0GgK13nE6QxxOOhHbKlTr0ALjdLvQVWiIfT7qpm9fFn1vRzHO+64U/rWaGhc9Aeqa+cBu7miGthWS/0c6EkQguqdhwPtQamgZpcZtd0IIe1tgXE5OLwkfZmMdT1g30oljYNsVrXbS/rmjM7x6Vh18oWyLjjDiWry02X5koZOp+oLwrHLZlVvHIJeX3rkQelvPxVHyQv1Wpw3T3mK1o6fYRwODzVuyhWdc/QXyOV03DY3ddwC/FbCTPtK/xXWNF/sP4sO1hGXjcaG7imAqt/XuH3ooYfl/RyLtN/C0hys6HpTKulaPYKmPq0DTx46Ri156uKziKvhSDvTamkcTWfA/vymrrUVjVNq0RknrRa14Trp0h4mXOeXNfg6B4hlNqvY0XeH/i/b2+pxsrWl/gncK86dOy9Y0CunUdf1ilhSp39lS9fP6Uz3guaSn0zaz0VDlDHNGOQez32Gezb3dJ5/QtidN+Cj3/Xm+b/9K4qlts5XRsAILBAwAeBYODMI7OzsHP1Kf+XKlbC5qQeKxDAp0ZMmh7ZPfvKT4bnPfe4cm3vuuSd84AMfCK973evCL/7iLwpeDzzwQHj6058eki8An/nMZ8KznvWs68LTBIAeykwApMJJ+QMTACloTABEMEwARCxMACjhYQIgvT2bAFigYQLguo5t/rARuC0RMAFwWw6bG30tCCS/mC4Mo44jABJvgKc+9alhOByGxB04+aX4ox/9aHjRi1609OjEOyCRA7zjHe+Y+wFcz58JABMAi/hxBkD6i5zOKmcARDycAeAMgEU0OAMgzgtnAEQsnAFwPacyf9YInE4ETACcznF1rx4HgcWX9SeSACQp/h/+8NUyfJ/+9KfDN3zDN8z/f1IyLu04vXhE4g2QeAQkvgHvf//7rwt7EwAmAEwAhGAJQCo92hIAWVMtAUh/ybUEYIGGJQAxLiwBuK5jmD9sBM4EAiYAzsQwu5MLBD772c+GV7ziFeGv/uqv5iaA3/It3zI3AUx0/g899FD4vu/7vrk3QLN5VUOXaP4TnX+iS6MefHHPhUFgcq8/+qM/ui6wEwJgazAIf+s//OrRfaihXV/X+s2suz2ZaK54qaS6deqVr1xRbeQY9d4nk6i1nIz1XuUCatmvqDZyNlPdOfV7tZp+nrp56glZb52/BLOv1arqn6m93NnR+uv7+3pNDS/rQ9P4Md3+Xk+12SGjuvB+XzWu/b6SH8WZYlNA3ewkbtN/46zqj0NJr8tlfV6nozXDczltb72uYzmdQIA801jIQKjfQX3oxFdj8ce2X7zjKdKXWl1jPIu62P2+alT39lSTT13pchyo9nuCWvedjqZOV1M686ShGejWp1PtPDXEw4GORbWsdcFHXXgQpPTX2YJ+dmvrS4IVK5Dw2QXUCM/nVes9gD/BGG1dgY9GtqBxd2X7IWnPYKDrD+cI53A+r/fb3VX98zb0ydmMehI0UhVYSNDmUK+9j77msX7RV2M41Lgqwm+F6xPNKnI51YKT2CrihvQkGA61r2PE6XSqawY9Abge5nJxzvKz+bzO79lM7z0eqT9KFutNFR4C45HGbTaL9QKeAMSm01VPAI5tvaF+DPv7uo9RR9/r6V60tqY6+Xo9rrczzOcpDQ3gLcFxrGG9oM8G9znuQ4lcMf1Hn4x+T9eLMnw+VlbWdT1Fe3IY605PK2202qqjLxS4vsVYof8BseB5g33jgYnrRb2u69V0eqj73uiz8+vffvn/Mf+3d1nn7HUdyPxhI3CKETABcIoH1117bASS9P8f/MEfDL/zO78jb/jrf/2vh3/2z/5ZeO1rX3v035OKAN///d8/JwsefFDNqBZvSnwBkoyCZzzjGSEhGI77S77kP95f8iUpv75uAuBRgEwAxEgxARCxMAEQsTABEEuwmgDQL4YmAOI8MQEQsTABcNwpza8bgdOPgAmA0z/G7mEKgY9//OPhe7/3e+fl/v71v/7X4Tu/8ztDwlgn/z1J5f/85z8/JwD+7b/9t/NPmQAIwRkAMYCcAZCaTM4AOALDGQAxLpwBkPqi5QyAIzCcARDjwhkAj38sdQaAj+xG4NYgYALg1uDsp5wABJL07uRX+u3t7fAHf/AH4du+7dukVYksINH7pw3/LAEwAZAOEhMAJgASBCwBiHFgCUB6TuhGZwlAxMMEgAmABAFLAE7AYdhNMALJOWbGwtqGxQicUgR+7dd+LfzAD/xA+Nqv/drwhS984TF7mWQE/N7v/V54y1veEt7+9reHT33qU+Ebv/Eb5+89zgTw1a9+9bxc4PX8XfUA6Ie/9f7oATAeaVpnraa6UqZ5jsaop4x67DnUsr98WbXg1JFOJlH4Wipp/fSNlXPS3UpDazP3+6pl7Hb1mn0hdpReUjvOeu2syz1F3yvQqfJ5BweqEz08VN1r7RhPgWJKU5zLKxYhowLiTkfHddBXvW+zrBrVSlG1kNS50wNgCvO4GWo7b21pzfDZTONm85w+n88L0Mmm62gnuHY7it3WlVi/nuO4tq5xROwm0DqPoIUeDtQToF5XfTCfV8AcyOd1bAaorz4cqQa2UNQ5GDKqn6b/A9u30lQPAHQvpL0tZkG9GSYTvaa/QbWqfZ9MVGPP0nhbW+p7kZlqXzbO6diU4A0xGqkmN60zT+KARwx+ERzAz2F/X9ejXveJtdu5bBybbCYrU5pfwPf2NcaLmFMrq+oZMp2qF0S7rX1td7RtrNe+sXGHtCeDOClCu01strYUC65PIWh/y2VdI6pVXkfvC8qrWG+91dK1ensrzt+kU7mcegRswJtmbVVjnPXfOaf5qzjneKmsvh2MK3oY7O5erQ+/+KP3xNqa7mVpPLIZnd9c+wZ9XdtgxxIy8AigFwX3nUuX1Pci+REi/cfnc31pNrQv9bpildUwCVldEsI0qF/DeKJ7Ez0A0jp/9p1tJ+702eHaTBnPyorGcC6nGv/24X+dQ3Xfd713/m/vivoZXM95zJ81AqcZARMAp3l03TdB4J3vfOf8i/1zn/vc8MlPfvIx0fme7/me8Bu/8Rvhh3/4h8Mv/MIvfFXKAJoAiENjAiBiYQIgYmECIGJhAsAEwCIaTADEeWECIGJhAsCHYSNgBIiACQDHxJlB4Jd/+ZfDP/gH/yAkvwInZnsrK+o0PhqNwtd93deFL33pS+Enf/Inw4/92I/Nsbnnnnvmv+y/7nWvC4nhX/rvgQcemGcUTCaT8JnPfCY861nPui48nQGg8JkAMAGQIOAMgDQp5gyA9CrhDICIhgkAEwAJAs4AuK5jmD9sBM4EAiYAzsQwu5MJAklZoK/5mq8JnU4nvOY1rwm/9Eu/FBYO2sPhcG4C+PM///MhSQX8i7/4i/D0pz99DlySLZCU+EvS8D70oQ+Fl73sZfP/nqS6JSUC77vvvvCqV70q3HvvvdcNtAkAEwALBCwBSH3ptQTgCAxLAFSaYgLABECCgCUAMQ5MAFz3Ucw3MAKnHgETAKd+iN3BNAK/+qu/Gn7oh34oJLq019T2WQAAIABJREFUzc3N8Df/5t+cf+H/4z/+4/DQQw/Nv+QnJEAiAUj/vetd75oTBImG84UvfGE4f/58uP/+++eZBM985jPDxz72sUD32mtBfk4A9Hvhm3/l544+Tq3msn5ZNbulstaPp0ZvDA0xUyUHqAM+S9Wfz+dVX3zu3Hnp5nComlnWlqdudGcn1oZPbsR0ZtYUXtKJjlQ3z5rE9ACgDp41ipfrbCu2eYBZgoY3pLAaQ3s9GKpmNgQUFZ/ps8qoUd6s6ReffFHramcLKvQcDFULmcvp/a9c0bKWBweqQ61UtH2NunoaVMq81ve3W6rV7HVjexjTzMbp9lSTOpnqOFPHHqBhbTaAVar+eRJnk7FqXIf6o3pg3W7Wi8/CM6DVVi14p8N5oGNfKavGmGOTEJKLP+rYez29Vy6r871SiWXxknuwLSGjcdPt9HSpgk59Y3NDXs9ktG/UyY/H6seQwfOKRW3voK9jPRxqe0YjHZzzaE8+pWce9LVt1NyzLbOgWJQrKo6eTPXZaW+GBBSOewNa7GpVtdm5dGNDCNOpztlWS7XfX/6y+nR0u6o9r1R0Pa5VdexZIjK9njaa+l5+gb58WZ99sH9F4oDvr5SxXjT0/hyLhIhP/9EjgHOOfi/Fkj6PlTgG8AWZzXQNof9DuRwzAnOI2UpFY7bXVy+I1uGe9IV7ND0FpiA09/bUh6M/0DgejXSODPD6+fMX5Pmb8O2YBfUw6fc1zugbNMIcLmG9SsdRsahzhh4A1Pyn17ak0fQIKOP8ks/rWl0u61pbr149Q/zu333P/N/eZXsAXMvZ0585ewiYADh7Y37me/xnf/Zn4Wd/9mfDf/kv/2X+pT8xE7rjjjvCd3zHd4R/+k//afjWb/3Wx8ToIx/5SPjpn/7p8IlPfGKeRfC0pz0tJMZ/b37zmwONa64VZBMAasJlAiBGkgmAiIUJgIiFCYCIhQkAEwCLaDABkF4vTQBc65nMnzMCpxUBEwCndWTdr9sSARMAJgAWgesMgDiFnQEQsXAGgGYkOAMgxoYzAFJkkDMAjsBwBsBteRx0o43ATUXABMBNhdc3NwJPDgETACYATACEYAmAJQCLeWAJQNxDLAGIWFgCELGwBMASgCd30vS7jUAIJgAcBUbgBCGQEADbw174jnvfnWqVauxGECzPNLsvFKCxbaLaQQiqIe50VM9ILWZaJ08NLesbU3OfyajukjV9uyldeNLhPOqzU9M/GqmOnVUCyqgV3YdWk7WuC9DN0wOAngNhpppd6lIHgzgYo/ETvzeT0XFtt1UTW4LGlbXtZzPVhVKTq0iFMBqprnRZa83XVWuZy2rcpDX9yditIs6yGPtMiLFA3edyrXjVyAd0ZtnrQeNsaVxHOklYr30yQaFs+DMUS1qLuofa9XnMOS4p7Tb9FbS95bI+v9uLGt2VlYtyu0Ffdeu9rn52jLgbDVHje6zXGYC7inruubyO+2ymGn16ALRaWn99OFTsi0VNU59NdXCTaizpP2rHL5w/J6836ml9tt5rBu+Iw5bOsfUNrVU/ntB7QtvSx7h3e+p3QP+FZlO9KMYTxWIy0fZ2u3q/L3/5y8BCx75QUB+OfE518Rcvauyk19fJVPtKH43hQMeZ/i3cRxjzXH+oDaefAveSKjxPWC+e1/QVYRzt7+s+12xqHFVyMS5z8G+ZzHQO7PU1xrtd1fDnsrq2r65onOUyur5lsk88B7Z2dP3YP9gRuOkh8pSn3CWvFwoaF0u+QND8t3EmqNV1/Utjz7Wbe/j29ra0pYc50+tpnOXzup6VyzpnCgXFul67Oq4ff/XVM1N/yx4AJ+hI66acYARMAJzgwXHTzh4CJgD0gGsCIM4BEwARCxMAEQsTACYAFtFgAiDOCxMAEQsTAGfvLOkeG4HjEDABcBxCft0I3EIETACYAFiEmzMAUhPPGQBHYDgDwBkAi2BwBkD6S67+qm4CwATALTy6+VFG4LZDwATAbTdkbvBpRsAEgAkAEwAhZLOWACziwBIAZX8sAUh/sbMEIJIhJgAWWFgCcJpPie6bEbgxCJgAuDE4+i5G4IYgcJUA6ITn/8d/dXS/cllrSZeKqsfb2tYaxNSR0gOgVqtJW1nHl3V6t7cvH72fOstqVU376tAKEpTBAPWHj9H7VivaV/Ytl9cDMDX89CSgTr5UUsKBOlR6DnTaWhe8As+BbjfqanspP4AEB+qBqZXkOFAbOZmoVpL+ChybMWrdU0tdKumBOZtRvfNkop4A/Z56ArQOVVO7uoqa59DB5nJR2zmBDn041GfR24F6X/ZlhNrxKyvrEnrdrt5/PAbBAM1/Lq+a2SHilNfsO7oeOh3V7ObzqkUvFOGvkNLFlpbmv+q6hwPty2Si1/u7Ok6TqY4z14NGg3pf9SsYDg8E2/GYngA6Rw4Pta+zGeIOZA/9GbIZ1QBT114uRb01S7+NhoxpxblQ1LYUirqe9Afa9l5f46jV1r6TuLoLWuzZTLXhLHPaxv0OD3XODdGfclnX32ZDKySsr+s8mKX8X+g5MoEOvFpVLLjejPF+zklq/g8PNG64z5Qrui+trWmmR6mUlnqEMJlonFHXXsDewOoZ5bx6UQw7MVa6BzquPexbh0PMqYy2pVFvyBypoW8FxDzX7ha8cdq47g80LsbAol7XvlXKGufct/MFJdkG8H/IF/TzaZ8getlQnkW/l05b5xDnbL+vcy5fgGdJRs871epVzf9//b53zf8dbOnY3JCDmW9iBE4hAiYATuGguku3LwImAPQgYgIgxrIJgIiFCYCIhQkAEwCLaDABEOeFCYCIhQmA2/dM6JYbgZuFgAmAm4Ws72sErgEBEwAmABZh4wyAOIGcARCxKBWdAZBeWp0BENEwAWACIEHAGQDXcPjyR4zAGUPABMAZG3B392QjkBAAO6N2eNn/87ajhlYqF6TRqJoTrmxpSaKQ0fRlpoFmsyx5pmmxTKXsdmJKHtM+azV9VgUp+/yldmtLyxmFoCmxlYqmeU5Rqmo61bZyNPf2tUQQ01BDqhRd8tlz587LLVZXNYV2NtP2zCYqGWD64+FhTCMdDLWtm+f1WeWy3pu493qaMru3p+WU9vaiNCPpBNNImYp57pym1FJysJTSGzR9OpvV615X02QLBe3PUknFVLm3SgUp9iht2e9pmmgRqdpFPIvSDaZasxTdDCn/KyuKDdOTWy0tLcUyWTxwM316MNQ5WihoyjCzO9JJ72OUKGzUlQAYjxX3bFbTwg8PmIKvKf09YL22qunLTP1m2T+W7drauiRzilKUAOwpaaIkganfjIV0ubp2W1OjsxkWo1M5QS6vqc0NlO1rd/R+u3uafsxSdhOUNFxDCj7XR0oAWHaUcUdpTBFyMJZBrVY1FTykSj4eHmpM9roqz1pd1RKGtRrWQpQhJUk3RPnJnR2VwVCC0GxqqbzNzU2Jo0JR1wxKFhinI6y/nY7GfdAlJox7cb3uQooxRl/7Qde+MWQ15zZ0PVldXZG+TEfalgnaOoXsZRi0PORopGM1mep6wn2Ra/vamkpDKN2jdI7Su/2DuB6urmpf17CHDgaaws+1dW9X4/AAUpFiSbGaBX1/vX51ffuDe94x/3ewpfvmyT7xuXVG4KuHgAmArx72frIRWELABIAJgEVQmACI08MEQMTCBAD0yCm9sgkA1dGbAIjzxgRAxMIEgA+fRsAImABwDBiBE4SACQATACYAQnAGQFyUnAGga4IzANLEmBo2OgMgYuMMgNQaAsNGEwAn6NDnphiBrxICJgC+SsD7sUbgsRAwAWACwASACQBLAOLqaAlAxMISgBQWS1UINFXcBIAJAJ8yjYAReHwETAA4OozACUIgIQB2RwfhFf/vP46tyj5NWthqq4718FD1f9ncE3sAUKuZzahGj2W3ut1YVmdvX3WcM2gj63V9dqejQktqCVnqiTp1Ds1wyLJYev/DQ/UYmM4UK5YkqlZV79xAGa1KWXWp07H6J/R7qjHe24/tmcy0jNbqmt6LGnyWtaIufGdHtdX0BKDfQq2mGt477rhD4FxZUX1wv6/ayXJJ+zqG7pRaTeqXqeEdpkr1jUY6bsOhalx5r4119U9gecZeT2O4VEJJwhx+Ka0oNiOU+aN3xGyqWNCgkWNZrXIe6Lyp19X7YjrTOTxKlXAslVTTn8tpmncIqAWf174eHOicGQ2hqZ1pDNNLIpPSjScB1OupH0KtxjKE6hVRKLB9ej2d6PNZ2o4eAwFz+sqV6IXRbmlfqbFfxxysoVzaCOUpuz3VWm/v6BzJZLXtGfirULdObCf4Rk9/FpYppX6aHiosscjX054B2/BjOTxUfwN6iDSaGnf0BKjVdC0d9HVOsxwkPVAaDZ2z9FcY4Qs/PQDyeY3rUlHXt0Je2zfs6vsHqRKvrR2N8QHK7B2iFGYe5WTpn1Ct6pysVuDNoMtXyGBO0oNgiPWigDJ+47GuJyxnWa0q0c7yuNks90291rDV+V8ua9/yOI8UcH1lW/e1Bx74kuxT2azGUams/gvF0tX5/+l/9PPzf4fbOnYn6HjnphiBE4WACYATNRxuzFlHwASAGgqZAIgImACIWJgASM8MEwALNEwA6JcxEwBxnpgAiFiYADjrJ0333wiEYALAUWAEThACJgBMACzC0RkAcWI6AyBi4QwA/TXSGQAxNpwBELFwBkDEwhkAJ+iQ56YYgROCgAmAEzIQboYRSBAwAWACwARACJYAxDR6SwBQttQSgNRmqVISEwAmABIELAHwedIIGIHjEDABcBxCft0I3EIE5gTAcCf8vV//zqOnXhlrPeTJVPXLvZ4eAvOokb55Tmv+lkr6/uFAda2ddtT8J43YT+n+e32tKT6Zsha8/jqXzaJk10g1s6WSaiPvukv9Dgh9t6tt7XZZl3tfPlIo6JcH6k4nE21vuazYVkqq289MNd262461o5MH9wZR+z0Jqt0ulvWabRuPVb/c7WpfBgPVI09Rc5x1t+t11dSuren16qr2bTDQcR8PVUvZ62r76AGQ1bAKzRUd+2w2tj+fz8s4jTEOlcqGvL6+fkGuhwN9WKej4zCZ6Ou9VI3v5EYb59RTIJvROBmyLjfudwhdfbGgcdyEXjoEavx1LHd31btikqorvnle5z914P2+au5HqDFOAqFe1xjPZdWvgNrr6QQ1y6eKdbms47zsbaHvpw9ILqt65GZTScAS6r8PUVc8nfa/s70tcbK6orrvWk117L2+rl8TaK9z8C84bOmc6HR1HAsFxXIF9d/pSZDDnMlkdCyZBTQe6/PGY12/SkWd4zP4kORyUZ/NOLp8WbEbpDw7ElCp+W80FNt8HmtjV30+6L/SbOq+VMCaQF16CBpHe3sPy1iPhvq8ZT8XXVPK8Hdp7cVYeOh/6r0DxmmEccrmdI7U4IVD74ci9ugcPEqaBexDRZ0jA3gAzHIaB31g0evr2s31qFTSOUxvH45dCHG9HI/02Xl4kCzFKPq+vaNrXx9tHWFfzOY0TvOFv5rHwWd/+APzf0c7eka5hcc3P8oI3FYImAC4rYbLjT3tCJgAMAGwiHETAHG2mwCIWJgAUMc0EwAxNkwARCxMAEQsTACc9pOj+2cEnjwCJgCePGb+hBG4aQiYADABYAIgBGcAxF+CnQGgv6o7AyBuP84AiFg4AyBi4QyAm3ZE842NwKlBwATAqRlKd+Q0IGACwASACQATAJYApH/VNgGwQMMSgBgXlgBELCwBsATgNJx/3Ydbi4AJgFuLt59mBJ4QgYQAOBhshTf+2rceve9TM9UXHmRUx1qtqZ6Z2vBM0M+HmepMB33Vte7vxrraSSPSpa3rddU6h5RWOXnvbKA6TFVthtCF1nsyU+11Hprbel11prOppv9Ox/q8Evp6cUN1n9SttqDpPYCmN2RU/Nntqd6x3db2jCapLys5bXuxjFrQNdXBD4e7EhutlmojOx3t6/r6RXl/oaDPK5VUD1wua9xkMurHkMtBq91SD4K9XfVboCZ3PFF9crWq2FRz8bpQ0L73EKKVuuqD19fvwrxRzep0qhrZVkux2tvTtlcq+qWSOvkQ9PUM/Bz2dlU7XimpZndtTeOuVNT+hoxi3YG/wv7BzlF/qQNnvXPWR+f8p+b/3DmNmymw39+Lz77aCG1roUhfDcWKte3TeuHkbv2+PrDX0zhcXVHPg1plRcZ+As3x5UceOXq929EYXF3TcVlZRS34EdaPivp0DIY63x98SGuWD0e6li7p5Jv6/EZD14B8Tj8/Huta3O9r3Oay0JrXtD+jkerwczn6fMR5Mx7rHBqNtS0Hh+oJwrV/BjPGdlvnBA0Jh2qDEejHcuGCej9kobM/PNR9aTLW9s1mWi++kNexDDO9nk4Vu2w2ro+HLcWC49xoKnb9ga6VuZxikcnAq6Gk45QJ0ZshCeZS8U6J+Y0VXf/GE11bK1V4BMC/od1RXfz+ge416+s6x7jGDHG/bmqf7HW1LaWS4ppJ+QUknRrAw4P+A9ks9viZYjsc/w/BptP5/fn1X7zhk/N/RzsINJ85jYAReEwETAA4MIzACULABIAejEwAxOA0AZCeqCYAFmiYADABcBQLJgCOFgkTAHG9NAFwgg55booROCEImAA4IQPhZhiBBAETACYAFjPBGQBxTXAGQMTCGQD6a6ozAGJsOAMgYmECwASAT5VGwAg8PgImABwdRuAEIWACwASACYAQLAGwBGAxDywBiBuUJQARC0sAIhaWAFgCcIKOsW7KbYKACYDbZKDczLOBQEIAdAZb4Sc/8LeOOvw5dL2/qtruEfSE+9D7DYeqZ8ygrnfoq2ZuCl1roxa1k+dWVdNazqp+95FLqpE9bGv94dYEtZzR1lDQ1O4GNLQ56E5XUdd7vYJ67GXVRmahe9ffEhPDA9X87+xBB7+nutMJ3n+Y0tGOS6r7LpS0LeOB6pVzGKcqioSPUX997ZxqZstrqvcdZ/X5OdRfbkGzO+irhrbT0rGbYex6PdW5lgrQJ480rvIpbLI51ZHPMO4zjltV9bt5+Ck0VhSLvX0dpwe//IDMojy01JWKjk2+qH4JtfoF+Xy7pZEzHcMzIKNEVhljT/8F6q87ndj+HnTg+bzO51JJ5+BgqONITf7aumrsG3XVH4eg95tOdZz7A9Wph5nO6elMP5+Bj8bBgba/39fPr6+p3nm1qe0d9lQjfOnhK0djMwv62rkLqkdurur6MB4rVnTVp+xmNNIYn2BOVhGnHJtmU+MqBMW201ZsWQo0n9c5vbqiXhOZoP2bjDWue724vrU6iGGMG5aPsIyVYt2FFrxe1zk5HMIHI+jz63X4F2R1/RiP4jgnA97tqCfAbKZY5rB+lgrqKzLow4ck5e9Sq+s+N4TXTKGkcZDLa1sHA9XY93q6llar8ADAelEo3C3rzflz8TyQvDAZaRwV8jruWfR9F/tWt69YFQq6fuXy8ChpqxfFZBL7W8hrX8JM9/AC9p1BX303CgXdcwdD9b6ZZb4sWFQrfyzXzx5dncP//rV/Pv+3s20PgLNxWnYvrxcBEwDXi6A/bwRuIAImAEwALMLJBECcWFkTAEdgmAAwAbAIBhMAcY0wAZBaL00A3MBTmW9lBE4nAiYATue4ule3KQImAEwAmAAIwRkAzgA4+pLrDIAU+eMMgAUYzgCIhxxnADgD4DY98rrZX0UETAB8FcH3o40AETABYALABIAJAEsA4spoCUDEwhKAiIUJABMACQKWAPgcbQSuDQETANeGmz9lBG4KAgkB0B/thF/50N85uv8j0EPvQ/O/BS12ETr4fFE1ep221gRuQeudhc5+pRr1hbUKTPqKqh3sDlRTe2VfNfS8PkjVE046PIXGdQzdeQ2p4Gv0AMDrFepAgd0Ifgf5nP7CRl38pSuqT5zCU2Cc0rW2oMXuoXYz62gXgHsdbV2BVrvRUH1zBa930LcpsBgA2xb8GA5aGifEYgovidUyYkOl4KGYuj48PJD5U0DMrsDfgBkB/bGmgU+AHb0dSuh7+0Cfzy9WOWCvqtUQRoiTTE77vrev2IWgOtdOW++YyynxlW5uLq964yo0/9mpYrG/p/rjblfbsrKiNb95XcOcCoijGbAnlgOsAX3E2Rhjwbis1tXjpNlUb4tuW9eYbipue331fphOFecm1tIKxpkeIdm8jktA24u4bh3oepeZ6tiV4XVB7XXIqDfGcGmOqm8IPVJKNfVzoGfBYStqv3f21G+gN1DtdGNF15fxRHXjY8RBLqd7QTaLevAZ9fHAlA156M4zQftazuu4D1s6h4n1BP0ZYlEY4zq99m9gbc0F1cRn4HuRzev85uGgD907/QkKXG+wr/Szd+gtJ0+T61LhTrnOZBT7HhawTk/HuoS1ezZT7EcjnVfZbMQjz/mMmO129F6Dvs6RQgFxNVHN/8Wiej88D22969FAevvrPzPHYH9HPUZuykHNNzUCpwABEwCnYBDdhdODgAkA/QJuAiDGtgmAiIUJgIiFCYBIcJgAMAGwmBkmAOIaYQLg9JwR3RMjcKMQMAFwo5D0fYzADUDABIAJgEUYOQMgTihnAEQsnAHgDIBFNDgDIM4LZwCksHAGwA04jfkWRuB0I2AC4HSPr3t3myFgAsAEgAmAECwBiAuXJQCWACyioYV0ahMAJgASBCwBCMESgNvssOvmftURMAHwVR8CN8AIRATmBMBgK/zSv/+2o//4EHSjY9R71wrDIQygzWyuaf3jLuq9H+yrlpL6xGJK117KqbA7m1XNahka2xG0jJd2VZ/84BXV97WglRwMVau4Bm3mnRe0PvsF6Jup0aV+uQsPAnoAdFuqkx1AV9pDPeV0a7upuvfJYPagjRxinAoYZ+qTqUtda2qt6oD7s/67qlhDoL6YcbMLb4hGHTXVG/r8EmJhOlDh6TCF1QCvFeElkYEmdsY4g9fDFFrrDATGxIL65RnidAh/gxHuX0CcV+G/sN/WWUlvDOqt6WGQ1uVXocnPMY46+qwZNPg56JMnS9pt1S/Tm4K/rNbg10D1M/XOjKs8Pk85Rx6xMA265gxG6nnQPoz65NFA9cRTYFHBvc9hLa1jHJuYYzPEAdenTqotyZzf39mR7Y2eIwdYX2aox97cOCefr2IO1rgGYDPtdRWP9NgcIEan0LXni+p/UIP2OoM52cZa2mWcYdyJRRX+L034LzQw58YY2yG8cEbY5/rYSzLwWyilfD3YluxEdeUFYFNpqPSCfiz0jnj48mUZKc6ZDtq6tMdXlRQbjzbkfrmsxk0+r2eAPgwRxhPV6VOXPxhoHGezcQ7mcSbI6ZEgzGba+vxMPUnOY9/LwsPkroL+KPA1lbL0dXV21Wfjf3vtp+b/7m7rmcHnSyNgBB4bARMAjgwjcIIQMAGgXxpNAMTgNAEQsSibADgCY2gC4AgLEwC6mZkAiHiYAEhjoQ6IJgBO0CHQTTECtwgBEwC3CGg/xgh8JQiYADABsIgTZwDEGeMMgIiFMwCcAbCIBmcAxHnhDIDUGuEMgK/kuOX3GIEzjYAJgDM9/O78SUPABIAJABMAIVgCEEv1WQJgCcBiTbAEIO7YlgCksLAEwBKAk3aYdXtOPAImAE78ELmBZwmBhADo9i6Hn/2FZxx1+0Fo5Kbrquernj8vEFGv3IcWsouaQF3o2lkT/WlPiTWGc1NVkvMQRl0na9E/tLUlbe1B6ziBrpR+BPwyxLR4ajfz0OxS80/dfA11tAN0rPQQyECfeJiqSb4DTewO9L5TaF5r8DdgBsA56H3XoVfOoq3UlU5Rz53a7CI0uvwSnklpZJNBTGtmk+sJxjKPsRyNojZzZ5eaUhWONla1FnwengCspz6g3hdmaR3ogwOw5/2pZy5AO76OsVjygmD9dox9LqvK+SrGvpzS/Wcx/3tI+W/to672o5rYxyOS6IdQKqmmln4E9BDgHKLPBv0YuJ6wP/QcoF46II6GQ9Vj91Jju7OlniL91HxM8KhBR76xodppltrMwBuCbc3j9Sy8Jw4O1F/lEXie0IcjwAOg0oxEUNL+1U1d6+kbQqyX1qtU+3YxB9vAan1ddeaNpnqA5BCXe4jxPfQ9i3rxVaw3BYwzPUUalarsHfSe2Lp0SV7fR3voV5PFHAzjuLdNeqqJ38R6tLKq41KqVvSYgvUiPZ+TN3Lc2dYdeEc8jH2zC6wO4VkyCOrfUK6qJ8AE+/hkTJ2+VtpoYv1N7yV9eDGcA1YNeDmU4eGRxb5Rwj5WnmjGzwb23IX7wv/++s/Mx2B/xx4AZ+nM7L5eOwImAK4dO3/SCNxwBEwA6BdBEwAxxEwARCxMAEQsTABEozsTAGqYZgIgzhMTABELEwA3/OjmGxqB2w4BEwC33ZC5wacZARMAJgAe75dbEwAmABIEnAHgDIDFTHAGQFwTnAEQsXAGwGk+JbpvRuDGIGAC4Mbg6LsYgRuCgAkAEwAmAEKwBKB2tJ5YAqBrgiUAcasxAWACIEHAEoAQLAG4IUdQ3+QMIWAC4AwNtrt68hFICIBO93L4qZ97+lFjv4xmZ6D5z0KPXEPd8L1D1LKHhnZnX3WqU+gDN9aiHnsVOtAV6DiH0PPtQge6tbsrvaH2OkcdOrTa1LGvoe+rKA+35AEAXSh18tQIV6F9nEBHT7+Fbur1NrDoQh88gn54jNep560Dm81jPACY/ku/hrR2OhmUDLAuQZc+g2a2DD01NbkD1qNPFYjms7t4bxXjWMI45FEbPkAD24PPBTX99D9YhRa8CA0v04cDdKm9gZpXTqBjnbIm+pIeWvXNs1RsdIeqx2VFhAIKb+9tb+scQ5zVoaUm2UKsssCi1dU63vQEoGyHccsvrUu6esRhgfXfoSFOz+HWgfohcA5wXKn5r6Cv9DTJwFOEfgecA1xf2vCioFr5EHHbWFePAsbpkkcB4oweBZnUGjPAOHL9qWN9mQQtHTeFDp2fZ9k9jsWU6x3ilN4STexr7Pus9knLAAAgAElEQVTly5cl7nldLJbk9TLWlFnKA6CAttWKqqlfXVEPgAJq09PHgvvaFH3l+tein8LhobR9H9cHfV1/OBZsD/cWeuew0kgRY5327uF8V7ouBK7VhanGUQ2+FwH75kqpKH2v0zvn0bF622v/bP6+/W17AJz8k65beBIQMAFwEkbBbTACjyJgAkDNlPil1ARAnComAFLLhgmAIzBMAMS4MAGgFRRMAMTYMAEQsTAB4COoETh7CJgAOHtj7h6fYARMAJgAWISnMwDiRHUGQOpLLX6NcwZA/PXTGQDqmO4MgDhvnAEQsXAGwAk+BLppRuAWIWAC4BYB7ccYga8EARMAJgBMAIRgCUD85dYSAC1TOLYE4GgrsQQg7qqWAEQsLAH4Sk5bfo8RONsImAA42+Pv3p8wBBICoDfYCu/5v771qGV/BX3fPuovz6CRXYE+cZjSNiY3HcED4PK21mTf3VOd/oULsfb0xfObghg1r0y5pYb2CuobUxNLT4ALd94pz+MXwymwoYaXHgD0KGD7WV6O4TFGffcunp+WLPShFx5AV5qhBpXjivdTl9rEuM+go3/kwQel+Yd7ezp21KFD819fX5f301uCtezH0G72oXcO+Yg262DzF6mlX/yh++zA16Ld0jrW44HqQHt91dHngV0Dc2YNNdAn7Fs/lp5LQBqM9HmdjraH0pVcTsu1rQL7Tgo76tZnGLd8CtekLUPijpitwAOAWLcQR2lfi/n6MZtKXFCmw1+d6aPBeu98P7Xn9Gs4bKsHQXqNySM7ogLtdglxlMUc4/ynbwbjlH4G1EMfQqvN9e4AY1WuRvPHBOQ+9NJZ+iNgzVhazxAb/U7Ejmvhkq6d6wviLoPrCRbLLdSuz6EtXMvpKTLC2so44dpMv4Ud7DX0qshjDjbS8wJeL2XUnt+EZ0i9ruNG/5cO+lKAn8EEc5QeAJ3UuM3jAvejRwn3XXoOMM4554j9Ez2Pbed1A34uxayufaW8+ivQh4cxPQUWpUfn8Dt+8I/nIXGwrWv9CTviuTlG4MQgYALgxAyFG2IEQjABoEZNJgDirDABELEwARCxMAEQywKaANBdtGwC4AgQEwAxNkwA+LRpBIyACQDHgBE4QQiYADABsAhHuqObADABkCDgDABnACxmwlIGAvYyEwAREBMAJgBO0FHPTTECX3UETAB81YfADTACEQETACYATACEYAlAlBhYAqDGdpYApLKCLAE4AsMSgBgXlgD4VGkEjMBxCJgAOA4hv24EbiECCQHQH26H9/6n5x899RK0ll1qx1knW8vsLmn+96EF39vX2tkV1Jsv12KN8hIOnIWslpmivpd1sqkPpL6X2nBqE3md1rQmgLUPDmS0qMll6iN/ZWft6aV68NTpQ3OcrrfMvvShK6UuM4t78xAXoBOlJlarJYdw5ZFHBAvqSKnBZa1o6krX1tbkftmMVnwedLvyeh81yUOqXv2SbhzaZuqBOY7U5D/80MPy7MODllw30faVlVV5vQJNLp31uz3t23gc086TG3VQU51fRpZct6GLZT36tLnbGDhS2zyAZj+HWva8dwGaW44zvSu+dOmSYFVt1OW6hL4UsF4tabnhjcE45lizRjp18usprwp6LQyGqgeuYY7x2e1d9T8Z9bS+eh6fX8ICazPnFPsyCbp+9jHHd/Z1PethrGtYq3NTVeJnOQdTngfEhnHTXFMPkHqzKePO9Ykxv729Le/vQbe+Ap+Nixcvyvu5V3D94jW3acY113KaSVZS9eg72BOnA42DNXh23HmXetVwX6MnAP0SlmIeaynXAHrt8Jrvp7cOCVbui1yvOBbpfX0fWDHTgn1L45yMWbmgpD/X/vPwoslh/Rg/6v/y1lf/53kI7F/RsbqFxzc/ygjcVgiYALithsuNPe0ImADQo5EJgFTEmwA4AsMEQIwLEwDxi6oJABMAi5lhAiCuESYATvvJ0f0zAk8eARMATx4zf8II3DQETACYAFgElzMA4jRzBkDEwhkA6rjuDIDUPHEGwBEYJgBMANy0g5pvbAROAQImAE7BILoLpwcBEwAmAEwAhGAJQEwNtwRA0/gtAYj7nSUAj7/3mwAwAXB6TobuiRG48QiYALjxmPqORuCaEZibAA63w3vu/dtH9+ihRvkAmtvOROtyHyzp4LXu7nFmSXU8r9lsHLWFX0aK0G6PUA+dmnr+ksu62Ev1hqG5bUKrTb8C1u2mHrGHuttTYMeBq1DfXFa9InWzs5QnAGs/UxdK3SXrHzO1OwPtI/0VmDFwAD0zsTp37twTxil1n6yZ3jpUnX3rUS3m4qbsb30laogba6rBZ1/YMGpWebjf21Mfiy6026ur+rwy4ohfpJaw7UdTvqRtj1xSfwXWe69BL72BuuF0b6fmNq3p7bYUZz6rNxwKXOlfxJMX+KwlLTRqzdOrgvcfzXS9oZfEkmkhdOgdeJAcF9c1jFVzVb0o0l4b9PQgrgFYjVhfHVh3Dg8F2zI0/pt33CGv00tiFtSQpTfQsRpiTg9wPcJ1u92W51H7fQ5xV8L6nE21ZwgsOO79kZov0r9ghrZxTk7o9QBviJUN9Rjg59NradJp6uYvX74sWKR9M5IXVrCP0cMkB6+ckNoLOO59xMEY3hLZjHo5lBCzpWpF2lqEdwPjlGstpS18nesl/RF4/wbWQ34+h//AvSCdhcQ9lXs4Xz+/ofvO+c0L8jT2dRMeABXEUe/R9eTHvusj8/vsXdG1+poPY/6gETjlCJgAOOUD7O7dXgiYAFADHxrjmQCI8WwCIGJhAiBiYQIgYmECQMlfEwAxNkwAPP7ZyATA7XVudGuNwLUgYALgWlDzZ4zATULABIAJgEVoOQMgTjJnAEQsnAHgDIBFNDgDIM4LZwBELJwBcJMOaL6tEThFCJgAOEWD6a7c/giYADABYAJgeR6bADABsEDAEoAYCyYATAA81qnHBMDtfxZ0D4zAzUbABMDNRtj3NwJPAoE5ATDYCj/3H7796FMH0MG3i6pDb6M8XMhqAl+hWJAW9FBj+Ilq/CYfrKb0jONUHenkNX62gmcxBZf+BNQH8v784rcGjSvN4pgWz4MQdepTYoexWuofaqDTLyFdQ53+Bmwra5Ifp41ecsJH25c093Wt106t9hTa73xe44b6YabMttsdQWtne0eu2f+05nft3Ia8N1cqyjW9HBgnvE7rwJMbsewVpST5nKZGV+HtwOfTr2EPOvatrS1pP9Pw1zc35XXGArM90nHHL3nUbjMueG9q+DlHJmNVV1N3XkEcMU5G0Pjz/nnoo1nCkXprZjhwDVk7p1jOUvenQWAG69UY9dy7qGE+G6jhYICOvQT98bkLql9eiruUJ0gSAIxT6toHaG8GGn5uJYNeV/5Ts1yW6wY8C9IeAvQM2YenBzX/Hewb6gQRwgrihBp8+sFUU94ySaMZd8RyDzr8ffg1MAOA3hF5jN0AfgzlfGqfhD9CG88mdlwvQi6r40Ide0XHif4HnDM5rPXUyXPO8X70JCE2h/DCCHgefUTS692SX0JfSXz6cqzWoxdMAtLFi+qjsQrvhhzmYFHtFkL20TnwIy/58Bzzncs6J57E8ctvNQJnCgETAGdquN3Zk46ACQB1ZjIBECPWBEDEwgTA48eFCYCIjQkAkMUpE0ETAGrIaAIgdToyAXDSj4punxG4bgRMAFw3hL6BEbhxCJgAMAGwiCa6o5sAMAEw/xUZv046AyD+JOgMAGcALFYJZwDE9dIZADfujOY7GYHTgoAJgNMyku7HqUDABIAJABMAIVgCEJPDLQFQuYYlAHGrswQgle0BqYkJABMAp+JQ6E4YgZuEgAmAmwSsb2sErgWBIxPA//SCo4/vwwPg4Y5q3PrQxFWgA83j8yXorZd089DwpbXiQ+h9c9SNQ3PahW6U+l6+Xm00BDbWb6cunW1n+SJ6Duzu7Mr9mUqehU60iXr1a+e0hnFzTR3J0x4A/KWWmtrMaCRtGUFnWoAemDpx3k8TWkM4f/683L9Y1lrUq/BToEaW2ssqxvbwQGukf/mhR+R5A/SvXK/F16GRrdSq8tkarpkNwXroUxz+WUOc2utKUT0H6qjLzeeNMCda0B9zrEtV7Q/9FwqYo/wVPw1GH/pcxixT/qmd5jpURN/7yChgavgkoMY54iBdWi55FvXLS/ejdwXWiH3o8jnH6UlQKMVfvXPo2yRV2z1pWwPjPEPfy4jLLNY71l8vAwvG4QB9ZRxyPaUOPoO1m/OCcUxtuEa5EmuMo539AwmV3QO9pua/0VAtN70a6AlQh+6d/gZZYE8s6GXB6yLHFmtCPq3xDyEszblUrNCnog1sWojRPrwl+lj71tZ1n6BHSD29NoYQuDcU4CVxHCnI9YgafmLP9YjkCQnZK1euxPPJjnq/cK3c2NA9s17RtXGluSJxt+RVA2xzI/XpqDw6R3/0e++f32f3inoQXMs5zJ8xAmcBARMAZ2GUT1kfP/vZz4bf+Z3fCf/tv/23+f8+85nPzM3o3va2t4Uf//Eff8LefuQjHwk/8zM/Ez7xiU+ExCDu7rvvDq961avCm9/85lCHiVH6Rl/4whfCT/zET4Tk84kBzubmZnjxi18c3vrWt4anP/3pNwxhEwAmABbBZAIgTisTABELEwBqbmkCIMaGCYCIRdocck5MmQA4AscEwA07svlGRuC2RcAEwG07dGe34T/6oz8a/s2/+TdLABxHALzrXe8Kb3rTm0LiFvz85z8/XLhwIdx///3h0qVL4ZnPfGb42Mc+Fs7hF97kIR//+MfDS1/60pD8Wv03/sbfCM95znPCpz/96fDf//t/DwlTnpAC3/7t0bX/ekbGBIAJABMAITgDIK4izgDQ356dARBjwxkAEQtnAEQsnAFwPacwf9YInA0ETACcjXE+Vb1873vfG5IsgOc+97nhm7/5m8M73vGO8Cu/8itPmAHwJ3/yJ+F5z3teSMrjfPCDHwwvf/nL55gkX+pf+cpXhvvuu2+eCXDvvfcKVsnrX//1Xx8efvjheZZA8qzF31ve8pbwzne+Mzz1qU+dt6eCFMRrAd0EgAkAEwAmANJrhwkAEwCLeLAEIM4MSwAe/wu/CYBrOX35M0bgbCFgAuBsjfep7O0//If/MPy7f/fvnpAAuOeee8IHPvCB8LrXvS784i/+ouDwwAMPzNP4E61pIid41rOedfT6u9/97vDGN74xPOMZz5i/lq6vm7z/2c9+dvjc5z4X3vOe94Q3vOEN141vQgD0RzvhvR9+6dG9OiAWWtCG70OfPBqrtpyl9Hhwoj6QWs5+6v471D5C67gkozhGA8t0Zmpo77hDawTXoJ1O10tPAKN2k1rthMhJ/w1RC3plVfWIG9DRU2NMTe8gpRnOwE8gx5re0B8PUyW6kjay9jODq0OvBtyfbc3n1EyN/gqsdZ/F2OXUnzFMR2NpUgveFD3UVO+n4jIPH4oGvBaa1MRCz8txHUOrXSpq+TNix/dTt17DnFv2AFD/g0ROlP7jnKMun3NsdWND4zIVG5wj9D/gs7LQjVNTe1wc0ZeDcSbl0kIIF5A1VYPWm8/jl5O0nnhByqY/wzrixDKd6p1P+QHM5xBifh2+FyvUjY/gpIE5yl/cWS99F+vjAeb0EDXNJ1jLx1gzak0lRKkd53pIrTglAYOU3wJ17PRHoQZ/llWHFfq1cE6dR0xvrK5KKAyGquVO7zPJG7kXTOF1w7hswUuC7csgFuhp0u32jtrXhv8BPQC4Z44nuhYuxSy8claAxQb2nSLigOsTvSjodcP1iD4hY8Qd9wK+zv6kScl9eAAw5lbhFVGvaUyzbTOcX2rFgsRNHq83H+3Lj/y9/zx/3449AK77HOobnA0ETACcjXE+1b08jgBIDpxra2vzX/s/+tGPhhe96EVLeLzgBS+YywGSX/iTX/oXfy95yUvmKf6J1v9f/st/ufS55L8n0oNEIvDbv/3b142zCQA95ZkAePyQMgEQsTEBELEwARCxMAGgZLAJgBgbJgAiFiYArvvo5hsYgdsOARMAt92QucFE4DgCINHrf8M3fMP8Y4kLfQNO88l/T7wBEo+A17zmNeH973//0SMST4CdnZ3wW7/1W+G7vuu7lsBP/vt3f/d3z00B+UvWtYyUCQATAIu4cQZAnEGJb0f6zxkAEQ1nAMTYcAZAVuaJMwBSa4gzAI7AcAbAtZzO/BkjcLoQMAFwusbzTPbmOAIg0fwnOv+E5d7b23tMjBYGgd/yLd8S/uiP/mj+nuRLRvPRlNE//dM/Dd/0Td+09NnEWyDxIUj+ktRcls95sgNiAsAEgAmAECwBiKnolgCo9sQSgLirWAIQsbAEIGJhCcCTPXn5/Ubg7CFgAuDsjfmp6/FxBMD73ve+8P3f//3hrrvuCg8++OBj9j/xBXj9618/1/onhn7JX6IXTz6T/H3+858PX/d1X7f02eS/J59ZvJ8p64/1sORL/uP9PfLII2F9sxTe9/vfffSW/wl98T5qW/dnqNAM/eBxNceZPk2NbpI1sfjjL6/UMgc+G/WLl/wHoOln/XRma1D7SIO0AXTnLB/H19l3tv/CnXfKUE2hs9/d3f2K5xNNIqnzLAMr6otZv30X+uJ2L2pYk0aNp/rFqQR9NOuzN6oV6cudm5tyfbCjfc1n9NfGwwPVxe+n4ia50SgVpxsXzsu91+ABwJrgrAXPL8UF6JOn4wnGRduqbggh5LNKPOWg2Z1Cd9pqaV/ZnvScSRpCHT7HsoZa2KWURwK12GmfieTeXcQ8n03slrCEzp310RvQK9fLGicXESdFzBHOue3tLRmb/WN088xw4HW6pNlyzKsXxBo8AIrILClCG13F6/WS3o9YbWE92KOWHFhzvZth/SzXtGY6M2G4VnONYSlRWVPg8XGA+btEZheLMm4TeIJwIeT6xphnbXnqzFtd9dVgnA+CNqAND4AayvrSF4Rrf68dn8c5wn0uCy+HJU8RzIF8QVcczpHVhpa2pC6e/ix8Hud8WurxWBsUx6IPLx/GFVfTtCdKCX2ltGIyVBkK1+oy9qUyPEQKY/XlaAD7tUczO9749/9w3tWdLfWW+Io3aL/RCJwxBEwAnLEBP43dNQFgAmAR1yYA4gw3AZBe7UwALNAwARDjwgRAxMIEgAmARTSYADiNJ2X3yQgoAiYAHBG3PQLHEQC3mwRgMN51BsCjUekMgNSXFfwC5wyAiI0zACIWzgCIWDBbwBkAqd9ynQEgZx9nAEQ4TADc9sdid8AIHIuACYBjIfIbTjoCxxEAn/rUp8I3fuM3zrtxnAngq1/96nm5wMXfxsZGSNK8jzMBTMwCt7Y0tfVacEvkASYAInImAEwAJAhYAhDjwBIATcO3BCDGhiUAEQtLAB7/BGIJwLWczvwZI3C6EDABcLrG80z25jgC4HYrAzgnAO77u0djeYhffv9ye1vGeR8a4BxqW9MDgFrLCX4JojYz/YsiXaWpmac2kQeN9GF93gloXusrK9I3Gn6xzjV1phNobGeoD089NSfMABpgto+62Cx0+7spEoj11Ple1sWmdpL6Yuo02ZcstJj9vmohE3+J9B9r29ehmb3jvOr0m4iryUhrX7dTGtrkOZRj9FI11ovwG6jXa9I2toUxyV+oxtD89zrqhwC5cKihL7RfKMADoIha1InhZ/qPcUd/Bfo5MO4K0MFWUprgItraZUxDv8ua4DQ+Zb111jTn81bW16W5RfgtUANcwJzuA6vdwwONQ7Sf84ZfalnmMD0nD/CsJmuQI8bzmO8VBEoDc2oEnfkMPhskZ9pYj8YItAw8BQKeP+P74UnAOOS84HqZHqtVVMOpc9/Ia/11roX7XZ1jHJfdK1d0n4IfAttWwdgUgE0ZawRN/7iPEQv6dHDO5lPYcu3lnslxyQOrKcd9omtlBX1bazYEq+P2mTaw5JymCSDXn+P6R8KVe03aE4G+PEtxhBimJ8AkqP8KvWiyva5gs4Y5u/noHHzjP/4f8/ft7KhnwJk8FLvTRuArQMAEwFcAkt9yshE4jgBIWn/PPffMf9l/3eteFxLDv/TfAw88EL72a782JAeIz3zmM+FZz3rW0cvvfve7wxvf+Ma50V/yWvpLXLJJPvvZzw6f+9znwnve857whje84bqBOsoAMAEwx9IEQAwpEwARCxMAEQuSDSYAIjYmANT7wgRAjA0TABELEhwmAK77KOcbGIETj4AJgBM/RG7gcQh8JQTAJz/5yZCU+Eu+wH/oQx8KL3vZy+a3TX5tSkoE3nfffeFVr3pVuPfee+Vxyetf//VfP68I8Ja3vCW8/e1vP3r9n//zfx7e8Y53hORLe0IC8Jeq49r9WK+bAHAGwCIunAEQZ4gzACIWzgDQX6adAfD4xJgzACI2zgCIWDgD4FpOZ/6METhdCJgAOF3jeSZ6k3yZ/5Ef+ZGjvv7lX/5l2N7enn8RX5TtS1789V//9ZAuy/eud70rvOlNbwpJKaUXvvCF4fz58+H+++8PSWr0M5/5zPCxj30sJFp+/n384x8PL33pS+dkwXOe85z5/z796U/P/5ccPj/ykY+Eb//2b78h2JsAMAFgAiAESwBiWTBLALTsoCUAcauxBCBiYQlAxMISgBtyHPNNjMCpRsAEwKke3tPZud///d8PL3rRi47t3Be/+MXw1/7aX5P3JV/Wf/qnfzp84hOfCMkm+bSnPS0kxn9vfvObAw3n0h/8whe+EN72trfNv+wnZn+bm5vhxS9+cXjrW986lw/cqL+EAOgNt8P/+Zv/y9EtR9BGPgLNfxsa/g40tdRu8qBE/WC31ZLupGtPr1OjD40sNfnU81JLSA1sBffvoa9jaCszqAlcgV8CPQio0Z2yDjh0sHx/WieagLR16ZJg1UrVNOchjF9q77xwQT7bRI1yjhPbSm8Hau67HdVO7u/syPNY2zoxvEz/ETvWoh4OVGtJj4MptJrDYfQkGEMTu1TbHePK+XWcidX+3j4+ojrTFcTZ2tqqvL8/6Mt1D9pypswy7hknw57qpdn+HOI2/SWXitbjpCCMA1YFoH6Y40YfjhXEZbWqfg3UANMDgHKNacoLIgGZviH9jtZ/r1arMhYcu04/jlULMV9D28vAOSAO81g7m3g/PUV6LfWCoMZ/Bq13G33nHF6aB1ifqD2nv0NiWJv+Yyr3SmovufspT9H5Du+GMec3PUbgfzDCPpSQ8um/NsaVbduA10QVungSYYybXmp9SZ67DQ+CCfozwt6Szpbg/KRPRqqWwryLI+xLXPsnWM/Ora0JNtVSUa55FuFewPWQcob91D6UvDeHD3DPZ4YV9wauEeVaXAPS54PkMVz7VIQS5j/ApP9Gw5Fcz8Z6XcM+wp9oNvpX/RX+1x/9q/m/u7v6eWLlayNgBK4iYALAkWAEThACJgA0A8AEQAxOEwARCxMAEQuSaiYAIjYmAKayu5kASM0bEwBHYJgAOEGHQDfFCNwiBEwA3CKg/Rgj8JUgYALABMAiTpwB8PgzxgSACYAFAs4AiLHgDICIhTMAIhbOAPhKTl9+jxE4WwiYADhb4+3ennAEFgTAz9/7t49aOkAK7ABp6m2kyM0KapLVQ3ril7/8ZUGBruEsR1cul4/ez9JR55k2jjRSOpQzfZkpsyzD10bqNFOpmX7M1EWmGzKFlqnXTDM9TkvJdOphL6YjU55QQuk7pnkytZlGTSQEmIa+ZBqYSo1OBnCEsn2aiBlCBXGWQ/mmpRJnKPsX8P4hU71TKbpME6VZGUtJ8Qs/deBMB2Y5OKYbN1Y15Z9p5kyRZYot28dSeAOUi+MvbDQM5ZxNpxhzTkyOmWOMWabUdw4PZf4T2zvvvFNXSZT94/vZ96Uyo4gDptHnj5Hx5Cb6K3Z6PUoa2k3FeZclTbE27qPvhZwmKK9gba1DAjDFnOJ6xvUlm0qVTtraQ/uWSh7ieVzPxujPFlL+L1++LGPHNSZdepRp6PySyPWmhFKVk5mGSR9961OqBmlZoRL3leROlEhlsrpCsYQs44x+CJwHY8zJtFwreX56vWbKP9cHjkMP8oIu9i3O9/OQO5TKJQGT6wvjgHIxlnRdqgQCOQbXN67HXE8D52gqrpcqCCDFnyUI2ZelMsQ4r6zjPEMJwFMyVyP3df/oz+f/7my7DOAJP+a6eScEARMAJ2Qg3AwjkCBgAkBPlSYA4rwwARCxMAEQsSDJZgIgYsMvaiYAIvFlAkB9QkwApObN+Kqu/ujPBIAPqEbg1CFgAuDUDak7dDsjYALABMAifp0BEGeyMwBSRJAzAGSJdwZAhMMZABELZwBELPacAXA7HwvddiNwUxAwAXBTYPVNjcC1IWACwASACYAQLAGI64clAJYALKLBEoA4LywBiFhYAmAJwLWdOP2ps4yACYCzPPru+4lDYEEAvPs3XnjUtg5KSfVZjgm9yEHH2oUWswd9IvWCBCWt2WtC00r9L7WE1OBTR17A/R66pBrWNnSjna6WCGN7qNWk9pIlEekBsKR9JBjQue5ubck7CpmoKV6DzjOTV5Utf6FiCTDqPKljZ1upjeY405NgDA1vEVrLCbScA5RI68JTYIZfptttLSc57KRKpkHnuYmyfOwLNbl8nXGVNoZLBohfnNJlrJLXM2j7UsYBtNd5XGsRrxCou2eafgl+C2zfNDXn2RfqzgPawvKLU4wb/RbSzvAJFsR2GlSLXaOuHevJcqlOLZqWQXuos1+paNm/ZsqDJGkf43qYmpPU2B+gbRNgRZ15BXFAPxR6kAzRlzFLnCF1+jgdO3XwS3MYaz/jnp4CS+XgUv1bY3lH7DNLPh159ZbJFVW3vqSDR1k+tiWP0neb5zdlLV0q4Yp9jKX4WP2CY3W4tyf353UjNSc5J5ZKomIODMbaGlav4TgWMY4rK80n7DvL8NH7htd8HkvAHldWkOsXn5/2q6Eci/sUzwA8M/D9JDNYmnMFe/BTHt23/koufAsAACAASURBVMk/+vQcw117AJy4c60bdDIRMAFwMsfFrTqjCJgAMAGwCH0TAHERMAEQsTAB0JPdwQRAhMMEQMTCBEDEwgTAGT1QuttG4AkQMAHg8DACJwgBEwAmAEwALP8KbQLABMACAWcAxFhwBkAKC2QImAAwAXCCjnZuihE4cQiYADhxQ+IGnWUETACYADABYALAEoC4C1gCELGghMAEgAmABAFLAEKwBOAsn5zd92tBwATAtaDmzxiBm4TAnAAY7YT3fOjvHD2hD23mPkr05KCRZYowD4k8RPZTteuTh1LLPZmkSgJBI0s9H7WFS/WFoTunbrOFWs2sTZ2Hjp6vD6Etp66eekX+skw9Iq9Z3539XW1ELWcRXgwj1EMfQR9MnTj7Qm12WrOajBtrftMjoNtKafATXTyez760geUAY5dFXNJfYZyOm+R5ve5RTE+gzQ541mqjITOMfc/n8vJ6D5+fTFWTm8Uc4fVhR70lWIHhwoZWny4HBYP+Cqx9zbHoUDue1Xr07dQc34Z2OYta8cRqCo1sGe+fscQX3l/EHJ+lfC3m6wN09C34dJTQl0pO+zbt92XsNlkTHc+jZwGxnKWexzhgbfo84qBarUhbuJ4cp7XmWsv66mwP2871hXG+dE3/BcR9Af3jnE4/j94v7GsD83sMnftsqnNg7/BQsOS+M8T6V4MPRqGoHgNLPh3wV0iPe/LgPNrb2tcyfzs7O9I+xmE67teP8SRZkmfBJ4Nre7uta28H+9w6PAB4vKCOnnOY+xj7Sg0/52wFawT3Ze7jaa+dFc5fjMNx87eOONi6dEnXdoxjGevXYmX+8R/5/Pxzezujm3Q6822NwOlCwATA6RpP9+Y2R8AEQPySmAylCYAY0CYAIhYmACIWJgAiwWACoCw7oAmACIcJgIiFCYDb/KDo5huBG4CACYAbAKJvYQRuFAImAEwALGLJGQCPT36YADABsEDAGQAxFpwBkPqS6wyAIzCcAXCjTmi+jxE4PQiYADg9Y+menAIETACYADABEIIlAFF2YwmASggsAYgbHTMeTACYAEgQsATgFBwG3QUjcJMRMAFwkwH27Y3Ak0EgIQA6w+3wr+7920cfa0Fz24Zmd0nnCg0e9YrUJ2YLWsWc9ZWHKc1dF07L1ErzV+s89MAz6M4hKw9ltL1W0ZTWGjSu1CZSK8lUR14v+SWw1jQ1to/WHF4Mzuam1q5uNleOxm1J0w9NfA66yz1ovXlN7fXa2pqEVlqXmbxQyKqAghrfEfrWoy4dGt8Z+j7BNWvZQxYbeocHsb14NjX01KSyPnoGOvE86mpTi12BxnYbmv8t6INZTq2GOXIXapbTj4G6V8YZ/RVmiPt2ap7sHqRwSxDEerCBOMhCKz0B1ktab+jKs5ijPXiEHOzuStzxfgPonQuzqbw/j/vTp6NWVl0+5zTHepbqbwf+AlOsP+ub6uXAcWIc0uOEaznXuw7iiusN+0IPgDa8MWpNrQ9PXfzSGgDvDLY33T7qvCm32t3ako+PB0O9RhwyK4f7yP/P3psA25bV531rD2e+w5t6AlNCAWK5yhAJgakyTkq4WuAI7LJQuVI4tgLBQjZyWUiKqXJZ7ViW0iUVkWVJRhESwSJQSaWE1IoTKQQ0QpsIQWMExECZSQh186b77nDms4fUPt337P39Dv3e6zd033fvd6u6Xu0+Z++91rf+a+11vv3/vv8G1nLKE0r4avDZwucWr09vG66/Y3hVUEffnMP33nuv9HV7Y0P7Dh06fTIYF8R6B2t9NlNfjB78YxiHa3MAcc642oc/A0k0xkkXazvjdtBYM9YqtOBc9oWeJMRqiPVuD3EY4xl99on5/y9+4AvLbuzaA+CpbDn93ROMgAmAEzz47vrRQ8AEQEcGxQRADYcJgBoLEwA1FiYAohUYJgDUPNMEQI2ACYAaCxMAR2/v5xYZgacbARMATzfivp8RuAoCJgBMAByGhzMA6oniDIDGouEMAFlBnQFQw9F3BsAKDGcA1HHhDABvO42AESACJgAcE0bgCCFgAsAEgAmAECwBqNPmLQGo3/BXc8MSgPqBZQlAIysIMiATACYAjtDWzk0xAkcOARMAR25I3KCTjEBFAIznl8P/+H/+1RUME2gjvwYN7hi6V+pET506JZAW0Agnbf3R3eoP5PvzhnadP0b4ZoF6YGqp29C9883uXWfPyr1j6Iep2+Qx3Y4ZS2taTGDJTSO1j8Ty3DnVFDd/nPBe1LBSs7oL12pizbT3c8BqE2//+qzjDe1kjHrv1M0PxxOFD2MXoDulJpea3n6n9pqYI2bn0D5Tw9pKtUY4a9WTMKD2O2rcu+rUFWi1LwN7Zl9kwO6+u+8WbFg3nLpX6lxVTR0CPQDONzS7B8Amg1cD50yb+l1kDAxYpxtxMAQWI2inO0kqfe/h/PlIa553cX+mYhMbrhG9geqvWe89NH74TeYzaVsbWupz8EsI8FOhJwDXF+rSKcu5cOGC3J/rI/XSTMXmHDqFOX4GniPNCgjVjbleURLRbO8Uc4B9f+xrX5O+jIYjOaaHSR9+BR2sF9SVF4jjItP67ezLPtrL9ZRrPZ9zvD89CJo6/2c/+9lyOWLDOOA4zha1iWd1IfZ1iL5w/eu2dI7Rx+da/ggcGz6L6FXBZw+/f+bMGV3vGsdtrAf0KAnw/DiL/Qh9Mvbhj8BjegBsPhE3b/uhry7buLej2J/k/aT7bgSuhoAJAMeHEThCCJgAMAFwGI4mAOqJaQKgxsIEgBKWJgDq2DABUGNhAqDGwgTAEdrkuSlG4IggYALgiAyEm2EEKgRMAJgAMAEQgjMA9lcLojMAnAFwGAzOAKj3Cc4AeHIsnAHg/aQRMALXQsAEwLUQ8udG4GlEwASACQATACYALAGoF11LAGosTACYAKgQsASgjgNLAJ7GDapvdawQMAFwrIbTnbnTEVgSAIud8K9/5zWrroyhob24tyvdfAy6U6Y+noVeudXtKkyoF5+V+vG0UUf84iWtDT2BPpkaeh6zVj21hWslzWI1AKPHADW61GozJZbnEzvq4KkTpekWPQGaOnyeG6iVhv6YOvQJ6m7Ppqpv3oDmv4txbSexDOQGtN9MC6VfAz0K+htaYoxv4Ihdmmpl8aY/QgqNK+OIfeU409+gBWypzc7gezGDrwa119TI0luC7dne3has6UmwVv8dhmVwWwjDxpzbH6qmnn3batTkrhpBkzzqi9m2lJ4B0OzOx2PpWwffH8ALYoDPJ6jrfQCPAc6TDOtdp9+X+1PX32r0nzFLbTZr3XdZPx26dHoEENs1DX9j3KpGT3E9xtUM9eTpEUBX/wF09tvQZhM7Xm/R8N6gtppa7N3Ll/VBwDmGcW5j/Wm1as+P6kIb8GPo4nrUvTNuh3jWcM1g3xlXaz+aMTbNtZs6dT63UvrooC8ZPACmWLvHB3WGT4UN169Tm5r1wudMDOyJzRieJRPEJeOQ3hX05Ti1rT5CTe8beiskwKaDtY7rD/1WGIdcP3rY5A2e8Ch68M3/cfnJ3mX1krjT94RuvxG4XQiYALhdyPq6RuAGEDABcFpQi00ArPAwAVCHhgmAGgsTALVpqQkAZW9NANTzxARAjYUJgBvYnPkUI3DMEDABcMwG1N25sxEwAWAC4DCCnQFQz2VnADSwwBtyEwAmAA6jwxkA9TxxBkCNhTMA7ux9oVtvBG4HAiYAbgeqvqYRuEEETACYADABEIIlAHWhQEsALAE4XBMsAWj8qGV5TBBjJgBMANzgNsynGYETgYAJgBMxzO7knYJARQBMsp3wi3/w3asmPwbN7P5Cq4hT808tNjX/G9Arl5FqxS9c3hG4mvWXx2OtBc1UQmqdqVdmjW9qG6lrH3S15Bc1uDm0jdTssl48a18fQN9Mz4I5dPpsP7WgGxu1dpOa/D7qH/Nt3S7qrV+4qBrc8/B6aN6rGrC7UTP83GnVbbapO8f9qGdmXHU66h3BDTaxYfpxU/fPmt7jhja56gurANC7YRv+B21ouRmXbejIp5hDrKdO7Tb7wnRixgH9FdbmAfTQvP+4oU8eI8Z70PzPoWXWCuIhDKHB5zj3od0e4PqUW3DO5fghlsJDgMfU+FIDTF17Cu+KAnGcN/TXvcb8q+KI8z8AS2KzQH12ej9wnKmVpscA44Safx5fy/+AY3MKc57acPZ/2PCTuIz1hN4MXBs5DoPTSta2ETcDjMVWv87UqMYmxQ/25Akt9+HDZ4z1iXNoD94Yo2usIdwD7O+rDr+p+6enxwBzhLp3ro1jxNGFx74ut6dXzUZfle3Pec5z5Psc98lc/WDoAbCADn9tfQNWf/rVP9X2wZsiwh6h05iTzEDawjN7zQ8F485xpbfDzkX1HdrE/L+n3Vq2/b9/42eW/+5e0v3RnbL3czuNwNONgAmApxtx388IXAUBEwBqNGcCoA4WEwA1FiYAaixMANQ/u00APP5j6PDPBMCTP2xNANTYmADwttQInDwETACcvDF3j48wAiYATAAchqczAOqJ6gyAGgtnAGiOgzMAGvOEzvxwp3cGQI2VCQATAEd4K+imGYHbjoAJgNsOsW9gBK4fARMAJgBMAFgCYAlAvWZaAlBjYQlAjYUlADUWlgBYAnD9u0x/0wg8joAJAEeCEThCCCwJgMVO+MXfefWqVZdRU3jO2tUolbcDze+aXhma2nZX9YfUUjY1utTvFtDzUV8c8HmrrbWht6AjbaE+POsvc6ioyaXGnzWEqTektptaybV68tRGQu/c1MWzXjmPE2BBbfPe7p50dxfH1HoPeqrRZy3r7hNaycOLrumTZ6qdXOSF3J/+Dm3U+abHQFHkcn67U489vRUYsylrhEMzHzAOM3o54PP+NTT3/YEazY1xPv0OrlUPnjXU1+qIQ8e6FhuN9nbhX7BAzO1By8w5uOZ7AW11hOvRl4P6Z6aVU+PfrDVfBQA9A+jPQA+ATXhlbELnnuEt94g+II2o28BaR43//pUrEqOMI3qKUPtNrwpiteYNgbii5p9xQNM/+rlw/aL3xBjzYtSIlTm8G6i9DpiDOptDSOHDsUFPAMy5TcRxjHFjHLXwnKO3DT1T+NziPGAlEY7d1tbWKhaYccRxp669u+aPomsn1wPOiTPw5Tl77qzEJds6g+8HNf9dXI8VZS7tqM/PmD4e8BDg+teMM45TgnX/DLwhCsyBtf0J1kbOoRIxfeqJ6/2Lv/+5JWa7lxdHaEfnphiBo4uACYCjOzZu2QlEwASA/qw1AVBPAhMAjQXBBMAKDBMAT276ZQJgLE9REwA1HCYAaixMAJzAzaa7fOIRMAFw4kPAABwlBEwAmAA4jEdnANQzs+sMgBUYzgBQoztnANTzxBkANRbOAKixcAbAUdrluS1G4GggYALgaIyDW2EElgiYADABYAIgBEsAalmOJQCaDm0JQP2wtASgxsISgAZhagmAd5RGwAhcAwETAA4RI3CEEKgIgPH8Uvjp97181aohtJjTRH8kZ/AAoGkWtdt8g0itZ1mUgkgzPXB3d1c+28NxDzrPNvS629D3bmzXusvqwqy/zrrW1CKef/RRaQ9rkm/gzfFGT7XeXWiEe5sbcj3qTqn9pp550dBmUr/LcblWDfDpcCRtaV57+UGuqlz2dRt9oQaWWBao9VyESO5/ZUf10kyhpW52kakWs9uoD80a4QF63whx00Mdbmpo6U3Bz9sY59OIwwj3n6AmOftKPTTryV947DHBbq2ePHSuG9iwN3Xw14objmMPMc+3wozptXEEFtS1s9Y964BTW0639Ytf15roXH47WEM6GKt2Q6tdnbtotHcCfXAMqcgc9dlH8ACYoLY89cnUam+j1n2COclx51jtoz0c6y7008Rm3cdD68NzHjTHvikHWK69qA1PvwF6lrQRsx1gEWPO0jtC8zhCiKBr5zF9Q/gsOn/pkoQSdfocC66HTZ0/50SHunQ8g+mjAVuNQJ08773ZVx+ewcZA+tKmXwwmzYi6evj6DOHvsrb2l+pZsLaezjSums+iDp/xaHsX+5cA7wdiA/uB0APWBfYc/Sfm8AM/8qdLVK7sZEdoR+emGIGji4AJgKM7Nm7ZCUTABID+aDQBUE8CEwA1FiYAGljgR6cJgBobEwDqj2ACoI4NEwA1FoUJgBO423SXTzoCJgBOegS4/0cKARMAJgAOA9IZAPXUdAZAjQUzR5wBEK/AcQaAMwAOg8EZAPWa4QyAI7XNc2OMwJFAwATAkRgGN8IIPI6ACQATACYAQrAE4NRqSbQEoMaiAsUSgPppaQlAjYUlAI24sATAW0ojYASugYAJAIeIEThCCFQEwGh6IfwP/+ZFq1bNoa0cQ6ObUnsJTR7dkKlfpgcA4bjU0FYeQH9HTXwLteGZjkxdaQfaR+o82ba1vqB+cTFXAoG1pwfQR1NbOYNunW9XqfmnvrpZx5u67mvJGS4D2wKaWNaiZnozdaosoUiN/hDYxamqcnN4AOxeUf+Hq/kfVDHUb2j+q+ONhjZ0AG1zDI0rf9iU9AhA2jvLWF25eFHCmG8DN6Ejp765hK8G7884pJ6ate2pLefY3HXXXdLepvabRe6YAdCF1prXplaabTuAbp5tobcE9dEcS+qhxwcH0jfGNecgteP70KYfQGCdNvrfglab996DTpxziOsZ/Q2o+R9graXOncccizX/BVyPmn+uzVxf1zwHoLduarvHGPc5vhsBywxzcIHPE8Qh5xTbvglfjhhzevfyZTmFHgWzhWq9M67dWD85VlwTmp4qXPf5HIljdcIYwa8lwdrJOTIH9pPpRPo66HXluPlcqT4gtqrgr1iyjp4/UG+bENTnZwqNfwks6ePRjJ0WsKA3TTnXrJQtxPhpPAvCREtXbuL6ZzGu7fOP9/7v/9PPLf+9fEX3AEdoe+emGIEjhYAJgCM1HG7MSUfABADoCRgImQCoZ4gJgBoLEwA1FiYAGnEB8sEEQE3GmABo63ajQUCYANAf0SYATvrO1P0/jgiYADiOo+o+3bEImAAwAXAYvM4AqKexMwBqLJwBoO87nQHQIAXxlv5qZpkmAEwAHEaOMwDu2C2jG24EbhgBEwA3DJ1PNAK3HgETACYATACEYAlAXQbMEoCpLLSWANRwWAJQY2EJQGOaWAJw6zdnvqIROGYImAA4ZgPq7tzZCCwJgMmF8OAv/4VVR3ahmWudOyed7KMeM7Wa1NVTJzqCxpba7maNc6bgRyjam01V73f69Glp6wBtnVJ3Ct04PQBYgzxHfeP1tHjVtVMvnaR6Rb5pplbysQsXpD/0AGhqMwfQmRMr6nsXHIf9fbkXMwKotTyF+unsK8edx/RnWOT6pvUSPAAe/bNHpX3j8UiOz505I8etdj0WTT+A6ktbiJMoqp3dq88jTGviTm01NffEamt7S6546uxZOaZPBvXHTInl/akv5ttW6urZ/+0Gdlmpet2AutgtrA9JotixbV+HPwI/X9MbQ4bTgXab92f69NnNTcGWc5geAAl8Oq5gXuxCrzxsHI+HQ7lXCb1wAv+ANt6Yt9DXZ91zj1zvLsQ05yzjjMdcAybw4SB2xJrE2NqcRqzwek2s154L9I7BtZh5MgWWE/pyYNw4Z6mrTzEWs5GuJxzbGZ41LcR9C+3vYWw5R5tlAbfxnOr3+roWo+9cr9rwwplhnFmtYgzdO8vypWj7HPcfYI4V8HPZ4LMIHid9zOkS2NFLY2dnZ4UHy9NG8GaYYxy3sZY/C8/85zSeE9VX08u6/nV21R9h+qePE4R/753/3/LfywekTO/sPaFbbwRuFwImAG4Xsr6uEbgBBEwAqHmRCYA6iEwA1FiYAKixMAFQk44mAPTHkgmAep6YAKixiEwA3MDuzKcYgeOFgAmA4zWe7s0djoAJABMAhyFMZ3kTACYAlgg4A0BWeWcA1HCw0ocJABMAFQLOALjDN4ZuvhG4DQiYALgNoPqSRuBGETABYALABEAIlgDU8glLANQDwBKAxg9+pM2bAGhkxlgCsALDBMCN7sh8nhE4vgiYADi+Y+ue3YEIVATAcHI+/ItfeMGq9VfQjw50qQlrqqMeM+u985hacRpL7V+pW8B0Y2pYE8iVe9Am0hNgDD1vAbE3Nfl8Cz5F/eUp6iv3uj1Brwud6wa04NQ+znKtNc1a2cSyWWeb3gr3YNyatd6rRrJ++gx94TE8rANrllNjy/Jwa7XtsWG+DM3/zp56EjT7WrWfbxv7HW3h2YZ3RX9T61Iz5lgffQFd6WOPPSbjSh3qGYwrtdQd1DDn/SbwphhO9EfoAnW7GTfEnp8zDil16TfmDduSY47NoXPnvXh8ZX9PsKPfAbXha9pvYJNB+02d/L3QzRfQhq/FIX7U7uH6rPK92yj1R6+GDq7VgZa6i8+J5b133SVYnT11So6pI6cnADX7XD8uwo+BcUivCH7eRn84B3m/rYYWnB4krC2/gM58ijhj3HAtP3/pkmC1v6dx18dzqgsdeoT1iH1p0b8B399uY4VE3PJZ0lwjmh4cVSfoCVAUOglb8MIZ4LkzxHOqqaGvrn/x0kXBagA/lxzPRcZ5F89Ztr8LX40+jtU1ZH3jNIYfzaOP1v4vl79+Xk7Ywtp690DX+mfBq+EMNjjxV7Wz0SU9jsfqIjLff1zz/8b/69PLfy+N7QFwB2593eRnAAETAM8A6L6lEXgyBEwAKDImAGo8TADUWJgAqLEwAVDXtjcBoD/LTQA0nicmAFZgmADwHtQIGAETAI4BI3CEEDABYALgEAFnANSx4AyAGgtnAOga4QyARmwgW8IEgAmACgFnAByhTZ6bYgSOCAImAI7IQLgZRqBCwASACQATACFYAlCXzrMEQN9qWwJQr5GWANRYsOyfJQA1NiYAvL80AkaACJgAcEwYgSOEwNIEcHoh/NT//MJVq/50pLWt59BORtALUgFXQJNHUzFqw881tNpVI5o1zKmbTKF9ZJ3rGPXc+WOG388LKkt1cJjiO5/rz4E56i2zHvNmXz0BYuhEWUOdOliGyj5qHDc9EdhX1nofwLuBunTWEGffOsCe+mNqZAeoBc32jNCXi41az1W/ZzONrHmm/ggRNLkc21On6grQa/rja2iZ6fXAtlLDugmPAfojkGDguJbQ+FLfzO93EUe9ntaqvlYFhwhzdNEY28v7dYp7dV/OX/pw8F4FtNEIm0Bt9yZ07lw/9uBNseYBwDiD3ngbx+zPmNpvxNVjly8L/F8/X2uQB9CRb9IfBdfOmRaON+jUqT/73nuv+rSYDHWtpgcAseb6yTk/4FqPwaPmf21eALumzj9FzK2Xk1StNX026FvB9e4yxolzKMP6wfuv9R2eBPSSGKCvp4Adx5reGEnDH4ZeNfRHoDdDq6V+A1x7DzCHr+zuShwNGz4W1Qcc15DqWLAM6gAeAFzb25gXLYx9B944KbBmXE8afjDlgcb8Bs69L25JXxefm8hx8lVdvbtjNQIuRoV8vxir/0JapsvP/+7vfmL576VJXRb0CG3t3BQjcOQQMAFw5IbEDTrJCJgAMAGwin+m84LcMAFQrxQmAGosTADUWJgA0JlhAqCODRMANRYmAE7yrtN9P6kImAA4qSPvfh9JBEwAmAAwAbD+BswZAPVy5QwAZwAcRoMzAOp54QyAGgtnABzJ7Z0bZQSOFAImAI7UcLgxJx0BEwAmAEwAmACwBKB+EswtAViBsSaZQpaQJQB13FgCUGNhCcBJ31m6/0ZgHQETAI4KI3CEEKgIgMnsYnj7//ayVatm0LHuo47uDnSsBzPVwI1Qv7kNDS6Pu9BONvWMMTS01KxSJ0qtIl2p6T/Aesvc8I5QT3kf2skpNLgj6JU3qUdu6NIrwJv116tj1kS/fEW1m2s11xtjQ00razPzXGpUafBF7GNoaA+ABbFu1rmu+tasCV4ds947NcKcJld2tIBzDB3pNrTkaafWyV5LU08/gyuX9K1vQN8Zs3fdrfXb6QGw5lURq8Y2hScB43gPfglt/EjtwgOAmlpejx4A04aO9gL0w5euKO58C0wviTTWOtrUXlOnHmP+Z9CdN9tWxQTj/BTWqy6wWYtjfJ7C06RJhlT3uwht+fkLF1ahyb5vbGgN8i5itA3vhjXtNYKemv0ScUiPEh5z3Kklvwf+K6fhp9D0Y6matre3Jy3sob9r61MDa2LBtZufs638Pts2mk6lbcSCWK/NCZx/L/rWAfY9epDgeIjnZIqxD01dPM5lHPEHdY628DE52t8XLMZj1cHn8LJZlyc8rnM//BvP9Rk/y9QLhz4+fM52OOdy1dnH9MbAc3ej4ZFS7mlf2le0reWfKakf/ZlOqnIPGv+hHmcz9ZqJI12rt7pbywv+t//vp5b/XoJXzRHa3rkpRuBIIWAC4EgNhxtz0hEwAVAbxVWxYAKgnhEmABqrgwmAFRgmAEwAHAaDCYB6jaApqQmAGhsTACd9p+n+G4EQTAA4CozAEULABIAJgMNwdAZAPTGdAVBj4QwAzQZxBkAdGyYATABUCDgD4Aht6twUI3BEETABcEQHxs06mQiYADABYAIgBEsA6jRYSwBUwmAJQP1stASgQX5YArACwwTAydw/utdG4KkgYALgqaDl7xqB24zA4wTApfA/ve/lqztl0MSOUBN4HxrdEY4fa2hkq4tSm1li40Qd/NmGljuCnwA9AHicwY+gBw3+AHrhNX0ytNkltNmsgU4daUEtI7SS1C9Tx876z/MMJoVX0YpvwF+AeuO1OtgYB9aSpr6Z+mN6ADA1vAusKa9gaPegkWV7+eNjAR1pG3FbNH7HrdW9R1xRa73z9brWe9XOIbXP0Nw/51nPku7QI4C694JtR98vwYOA3hAJ5mSMOXh2a1Pas3Z/zuGGJni8UA3sReiJ96/syLUZNyX0woxD+m6kqBk+Ql3vAGx68Ayg5j+wfjvGml4V9KLgejWBr8e8oRVnTN91l3pBUMvNfQzkpgAAIABJREFUvhIbzinq2ElUMS75fcbhmW0lPJ99770at/AsoE8I+8v1bx9eFc2Lz1FWdBPjTt+KLsY9gQFhBs2+VmsPoaQXDWJ+AFnPKWi/N/Z6gs1affgU2vGuzptiQ1s0SfT7i4YHwBRto38LnwtDYMlxmI3G0vYy03t3YRqQr/n2dOX8vNTzJ1PV4TPO+JyNMFbtuWIV9hWrxWX9PBk2dPhqbxCKS/rd/lTHrTVVj4BooQQfn+mtpHXVXVe0eLzU5d975DPLf+0BcJs3qb78sUHABMCxGUp35DggYAIAGw0TAKuwNgFQz3ATADUWJgBqszkTAGoOZwKgnicmAGosTAAch92i+2AEbg4BEwA3h5/PNgK3FAETACYADgPKGQD11HIGQI2FMwD0baozAOrYcAZAjUXmDIAVGM4AuKXbNF/MCBwLBEwAHIthdCeOCwImAEwAmAAIwRKAuqyXJQBaTs4SgMabXKSqmwAwAVAhYAnAcdkRuh9G4PYhYALg9mHrKxuBp4xARQDMsp3wv/7OX1+dO4Q+cLdRa7760gLazIvQI+7xeDiUduW4/iZqTzd/jM1x7hb0v/QAoE58c1O10HwzQT1w2ag3XDV6Dj1xGT2u/zv86/dVb7iAB0ELNdGpk6c2O4IuNoewtQiqX5wv5qu2UCc+m+kPmQH8EKi5j6i9RjTNoIWewO+AtZ+pby5w/RgeBAzeArrUfWjR6UDegQeAXA/34jhMUSf7yte/LqdP0fd2W3Wi7DtNsYgF624voLufTnTsRtBW0zui2+1Ie09D672GNfCYNjwJZvCdGCGOqAsv8XmKmGc9d9Z7L/CjsmjWRw8hTKDVZtp9n74emINDrCE8pm9IivsXGJuksR52MF9Pnz4t43D27rs1jhDTUxyztj3nzJR+DDheq+SBcd7CWkuZz5mNDZ2G0N2n9G9B/0kIPPa1r62uV2JcOlgP7sL6tIm46OPe8Ria+xHI3InWb8+gK8/Pq79Ke6hzOt/Tz/udvi4pLX0WFB3VyY9jzRxZ9GqSrbpQerbWpvfu1edI/6zeK9lQHXse672mC5ViTEYgsXbQll3FKl0oVr22egB0++2r7i2ipuHKcpOgX58f1M+p6pN4pP2ZXdbPk0w/T7Ia6zjTZ+B0R/0IOoW2Nc1xrQh9Rdwlbf18CizHB49j+fqP//HyX3sAPOVtp084oQiYADihA3+nd/vzn/98+MAHPhAeeeSR5X+f/exnQ/Uj4sd//MfDj/7oj651r9q4/eEf/mF4//vfH373d393+f3qB0xlgPVt3/Zt4fWvf33423/7b6/VnW9eqLrPT/7kT4YPfehDofphe99994XXvOY14YEHHgh3Y2N5o/iaANCNhwmAJ48kEwA1NiYAaixMANRYmADQH6ImAOrYMAFQY2EC4EZ3bD7PCNy5CJgAuHPH7kS3/C1veUv42Z/92TUMnowA+MIXvhBe8IIXLL9/5syZ8JKXvCRUm8MvfelL4WMf+9jy/1c/5n/t134t8O1g9dn73ve+8LrXvS5UTugvfelLwzd/8zeHj3/848vz77nnnvDwww+H5z//+Tc9JiYATAAcBpEzAOrp5AyAGgtnAODNsjMAVsHRdwbACgtnADS2I84AuOm9mS9gBI4bAiYAjtuInpD+vPOd7wxVFkD19v7FL35xePDBB8N73vOeJ80A+OIXvxje9KY3hX/8j/9x+M7v/M7QTPX+gz/4g/DqV786VGm9P/ZjPxb+2T/7Z4Lio48+uiQPqnTQd7zjHcvrVH9VxkGVOfDe9753SQp89KMfvWoGwfUMjQkAEwAmAEKwBKBOKbYEQFOGLQGonySWADTeYlsCsALDEoDr2W35O0bgZCNgAuBkj/+x6X31Q/zd7373kxIA1+roT/zETyxT+Z/3vOeFKlug+ffWt741vO1tbwv3339/+OAHPyifVfrV6kd7JQmo5AWvetWrrnWrq35eXWu62Anv/Z3XrL43RI3xMbSXj7HWMzR0E+hGL+5o3XDqr6npbWq/B9D8d6ALpXnbBHpfarNZm76Futf88RMl+DGA+5fQO8/gf9CGfwI1/9Qbs159gF6RNcubZbeu7F656lhvb6q+l9jyZNYcZ71k1iwfUF+Mt4M0iqJemDp3asWJHdtLLXnzfvR6KBCj5UyJoD3ELLEYbAzk9lWWT/OPWFSZPM0/arv3dnTsiA09AVgXfHt7S66/gM8Gs4xixHXW8JpYq1WfqCY2VQluKOgRgBrhrC7BuOP8Z9/iFvTHWI9mc007py6fmv/HHntMsCoxNgl8Ntj+qFETvYf1ib4UleSr+adRFgJjlj4ebPvB7q5cb0pvCGCzll2GuD+NOXsv4riAbr+NuKIuvwUPldne3qq91PS3Jzonsj19bby4rMflFTVESUYal52F+mAk0LUnc/1+UOl4SHL9vMxUZ99J9PoFPqevR6uvngLRQD0DskHd//QM2qbLS8hailVrQ6+dFfg80Tkz3BlJ3ERjbQuxa3N9mOpYxKWeP9xTn5/5UCO9VWp727FimQ8V60FPn1VlY84tsFbPEaMcl2wGv4NIn+k97F9yeKA0fXYqEA/7/rce/sgS04tTXX9uakPmk43AMUbABMAxHtyT1LWbJQB+8zd/cykBqDZo3OxXb/8rUuBd73pXeMMb3rAG6/d+7/cusw+qzIAqQ+Bm/kwA6MbEBEAdTSYAnhwLEwA1NiYAaixMAOiPdBMAdWyYAKixMAFwM7s2n2sE7kwETADcmePmVgOBmyUA/tW/+lfhh37oh8I3fdM3ha985Surq1dvVQ+dmj/1qU+FF77whWvY/9zP/Vz4wR/8waUM4I/+6I9uamxMAJgAeLIAMgFgAqBCgM7yzgCo31Y6A0DfBDsDoF4znAHQwMIZADe1T/PJRuA4IGAC4DiMovuw1OLfqASg0vb/xb/4F8OXv/zl8MM//MPhp3/6p1eIfvrTnw4vetGLlse7u7vLqgH8e+ihh8JrX/vaUJUau3jx4k2NhgkAEwAmAEKwBKCOAksAVONgCUDjza0lACswLAGo48ISgJvahvlkI3AiEDABcCKG+fh38mYIgMNzn/WsZ4XqLf/Zs2dXgH3kIx8JL3/5y5fHi8UiUCNe/f/KF+CVr3zlN5QPfCPkqx/5T/ZX6WG3z7bCz/z6f776StpoT/U/Z9DJX4DudIxN4e7Bgdyu8ito/lH/TH10U5e/CR35HBr/GPem/ndzc1PuzbrcJTSzc81gDQH650WjXnp14ccuXpDrT6F/HkBfePbUKfn+mv8B9McBWswdaIArkujwbzrV2s991IZnDFB6cgpYlUHBoFaa2klqYFmrnn1l/XXq9OkZwDfR1E+zP824Yn11VjwY7u0LPKoSDYG69XN3nZPvd/qo2424aSMOOAf2r6gHwO6lyzpc8J7g+TFq13NObaE+fQva9f5G7SGw2dO+NDXvVaPWUv4XqvfNJ1pznL4dG5jTG1hfAuaAVmMPgXG1ADYx5nRVfrX5Rx19Dt8OtjfGPEgaaw6XC8YsJQEdzLEMbT+AnplzgnM8FKqdnmENmOC4B6zPwgPgFOL0NI4HWG8H0EvPUG++uFy3rz2DJl7DJJRjRbPY15FPpzor+f1u6Mk45xM9f3ENHXsEP5fQNMYIISQBXhioL8/1LW2h1n2p8yTarImmWVd15POWHsfwD+hv6hzN59rXAm3vFF3BZjPV52KUKek13NVn+GykzxZiwWN6AMwn2vcF/R8wVlGkHgBNy5X+ho5ze0P9Dq7s6Vo6xnp0gL61g57fbSlWXGvb7dNLLL/n4Q8s/72AZ/7x3/26h0bgxhAwAXBjuPmsI4bAjRIAVdnAyvW/2ij+9m//9urH/mH3TACEYAKgEewmAFZgmACo48IEQI2FCYAaCxMANRYmAGosTADUWJgAOGKbaTfnxCBgAuDEDPXx7uiNEAD/8l/+y/AjP/IjoXpL/Ru/8Rvhr/21v7YG0jMhARjPLzkD4ImRcAZAHZLOAKixcAZAg3yg678zAFbgOANAX+s7A6BBzjgDYAWGMwCO9/7YvTMC3wgBEwCOi2OBwFMlAH7+538+/KN/9I+Wafu//uu/Hl796ld/QxyqdNVD3f+1TABf8pKXhI997GM3hWclDzABUENoAsAEQIWAJQB1HFgCgPJzlgCsgsMSgMY8YYlaSwBW4FgCcFPbNJ9sBI4FAiYAjsUwuhNPhQB4+9vfHv7hP/yHyx//v/Zrv7Ys/3e1v6e7DODB9EL4p+/+1lWTYuhCc+hA59A3jxZaI3gE3WlTp17d5Gqa/+rzppayZB1qAEe9Lj0TWFOcmtwYWuhd1PSlRwC13F9DTfG1muRt1RfeBX+F09Bmz6GpnUKffOmK1gFvasdTbkBxnFMvTGzbqtG9CzXBtzdUl3n2XO1d8Y3G9WCsbwNnOA6oSc63pzRfo259irgbDLR4dlMvff78eYmcIXwpygVqRUPrvI05cRrYbDRFqiEE6tbpV0D/hDF8M65cuiTtpW6dfgsdeABU/iHNP+rm6YVx9q57Vl9PocFnLfiAN/5Rob2lpj5CxsCfgw/GaejS+ymNOXVsRojj9kDj8vLOjvR9RH8HjG3KOIIWvBOp9jub19gy5X77jHp8zINq9Ev0dYa2RB1dL6grzzFnOOf5XOEcYdwU6Psp+DPchXrsyb5qxfMd7d/4vGrFo4O6SkA80nO3+7XvRNXujY7O38m+rh/ZSOOAHgDtVLErFto21q6PYx1X+oSw/nuESb1W2x5aco5dqc0L3VO11nzc0r4ueqqZpwcAvSCoue+UHQkFSgC6QXXuUa5jM5+rB0ECrLJcx4LYllOUgxzr9SYHGieLTNvTbuucLot6zqXtofQt2cL8DNq28QjPoaG2Zc0DINa2lKXGZfTEevC3PvK4B8DF2cQbYiNgBK4DARMA1wGSv3L0EbheAuAXf/EXwz/4B//gun/8Vz1/61vfGt72treF+++/f2n41/wbDofhOc95zrJCwPvf//7wqle96qbAqjIATADUEJoAqLEwAVBjYQKgscyYAFiBYQLABMBhMPCHpAmAes2YmQC4qX2aTzYCxwEBEwDHYRTdh+sqA/jLv/zL4fu///uXpnbX8+b/ENZHH300VFkA1RuJX/qlXwrf933ft/yoevvzhje8IbznPe8JL33pS8NHP/pReVt+I8NiAkDZfhMAJgAqBFJnAKwCwRkAzgA4DAZnANTrozMAaiycAXAjuy+fYwROFgImAE7WeB+b3n7iE58Ib37zm1f9+eIXvxguXboUqh/Qz372s1f//6GHHgr33Xdf+OQnPxle/OIXhyrl8lu+5VvCy172sifF4ld+5VfWPvvVX/3V8LrXvW75o78697nPfe5S7/+lL30p3HPPPeHhhx8Oz3/+828a38cJgIvhv3vvi1fX2sk0hY4p/wFp7ROkpVZSh+YfU/6ZxspSe3kjNT1CWzQxsKrfrul8THGNkBo9ZckwpI2HrpYYWiDdOMMPwz2kbq+VBespwXBme1uw2UJZMJZAmyFF9wrKw40aJc5i3Pwcrr0/1NJOObDtQA7xrLvvlrZ2UFaQZQFbkBDEUZ3++wSDJdeboKRjwdRsjN1ggPJ0+Jzl35pSlClKV+4gTRzZuSGg3GMX9+oiTnqbGpldlAWkBIDVHmOMxc7Fi4JVc5yrDxboT4dp9EjlLuaaUtxfK49ZSwBaSMGPEIOb0DYnmP8ZpB4Rjs+gskVnhvJqC3Vg4HoxOK1YT0pNJx5P9Hi2p31vZTrayVzjNB+qfCJa6MTqNcqExYme29nU1Ouyo+e2tvTe45mmJyeQV4Vcz48Wmqo9PtDzOQeTlmI7mWu6MiVTrVjlF/2WzrnFjmKTjvX7xQEWoWnd3mKk2QKRHoaA+V9m+oWNro47a89DbbEso9v8Y3m3COUic8ivKEni9fOxPieHO5qaPhjUc6pqx+aWxkq8UY9Nsa19vTBVyVKkj6WQlXrvyY6Oa7mr49DJNC67SHNnGcEy0vNz6B8Ypz2sh7OJPpeZARCVikUv1ThLU5XSHDSec2WqZT175wAOFvO18riJpvQnc50ji6GuFyHoM3uxeFwL8jf/4N8u/70wRT3Lm96V+QJG4HgiYALgeI7rse/V7//+74dXvOIV1+znl7/85eWP9ev9fnVB/mg9vMkjjzwSHnzwwfDhD3847O3tLYmFyj/ggQceWJIAt+LPBIBuBkwA1FFlAqDGwgRAjYUJgJrUMwFgAuBwZpgAqNcIEwC3YnfmaxiB44WACYDjNZ7uzR2OgAkAEwCHIewMgMZkdgbACgxnADgD4DAYnAFQrxHOAKixcAbAHb4RdPONwNOAgAmApwFk38IIXC8CJgBMAJgACPDvrgw3NCXXGQDOADhEwBKAOhYsAaixcAaAMwCud9/l7xmBk4iACYCTOOru85FFoCIAhvNL4YH/4ztWbfzilSvS3l3o7DNoJ6fQF59CybQJzj/A9yc0XGuUHbwLmv1N6Dr7aAs1+3O2FVruXZR/K/B5AbE2/Qxm0G5HqeoJz911TrDcQim9DvwSZixDCEkty3btN8sComTgAlpobVkILdy7gxJkd509I21vr+mTVYfahQ6dOvkIP6pnY+hWEQe9vmo7aSkQoL+eQ4s+b8RZAS+HSlLT/JsDuy7KXrVx3IPGvgcviRSfJ4irHGW0Lj/2qLRn//JlOe4ijjeA9QBj2cf9IvSf2u9+w7OAXgodjMsW7t0OGlnzoWrws12Nk2ik+t/ssmq1+7GOezFXMqbV1bTzeaNEWAVaEqGMIDT9SaEeA0mu7em31bejE6moOG3ol4nVLFPtc4A8Oeqohn+SK1YJsKTmv5hqLbrFSLHj8QbKqXFOlSkWGLY31fZST81SfNEMfgoN3T/L8pUo0xeCtoUx2m7pOOQoP1nCq4HSujTWcW/heu0erl9q3C1mqg1fjPQ4P9CxKTLo2uGdUSaj1Rzv3qMxl/fhL1Cqf0uEcYkzxb3cUyyLKzBcgMydXhJxqtcrYj1/cEqJ8+2zqpMfHqgfQgE/hzTSsQjwtqBHQNEorBp34S3TRQy3NWYXU50jLdC9KTxHyrH2td3WZ3j8xPryXzz0b5bj9/Wx9vXIbvbcMCPwDCNgAuAZHgDf3gg0ETABoBstEwB1dJgAqLEwAVBjYQKgUdsexIwJABMAhzPFBEC9ZpgA8L7TCBgBEwCOASNwhBAwAWAC4DAcnQFQT0xnANRYOAPAGQCH0eAMgHpeOAOgxsIZAEdoU+emGIEjioAJgCM6MG7WyUTABIAJABMAIVgCUKcrWwJgCcDhmsBUcxMAJgAqBCwBCMESgJO5Z3avbxwBEwA3jp3PNAK3HIGKABhlO+GnPvTdq2t/ATXIv4zjGfTEbeidO9CKt3A8hm7+UdQ0P93QHH8HatPfB08A6tpVVR7CATX/0H2en6s+cAI54QK69SH8CyBdDGlX3xbedffdMmbb21ty3O+rlnI6VD1hAg+CvR31ZygbngHT3V25dg992YROPYaWO4Gm/vT2prYVWKbQyLZwvy7qyY9GOjoXL2ite/or3HPXWbl/t6e1rFvQ1O6Pa01tdeKooevPoGNv+gNU380xriWOc/gpDBBHm/B2oL9CirjNZqr9DnPVjhdT/XwbGv/TPR2b8a72fY5a1htoX4Ei7E29NGuEp1PV6xbQyOZj1T7T76BQji1QN94pdM4k0JFHOkUDa5a3Ez1/QV8O6uphJkGt+FZfsU1K1RQXT9QBr+KG2mnWnl/TUqeqL0478CPAHOukGvP0K1jA3yAf6VhEU217O9HrzYLGXd7RwerdraYAeazXH+1r3LWhr+42TBBmQ71XinHJ4eGRwHeDOvSkras/iSvWqo8KxSLLELe4XoEFbQKfkPEV7ft2omt7kmv7JhM9Lhq6/mRbP+uc0XGKN7Xt8xz+A42YXC6aQ/1+GOri3E/Vn4D+DByLVkd9NQ5m6knQ3sQcbml/crSv1/D5qZqbxnr93Qv6LIsa62d7Q+9VYE7FLZWhRHiGFmPFYnagcVliE9BK9Tl0GKav+e33LaE+P9E4uOWbNF/QCBwTBEwAHJOBdDeOBwImAEwAHEayCYB6TpsAqLEwAWAC4DAaTADU88IEQI2FCYDjsR90L4zA7UTABMDtRNfXNgJPEQETACYATAA4A8AZAPXC6QyAGgtnANRYOAOgxsIZACE4A+Apbjb99ROPgAmAEx8CBuAoIWACwASACQATACYATABUCFgCUMeBJQA1FpYA1FhYAnCUdrBuy52EgAmAO2m03NZjj0BFAEzy3fALj/zXq75+5YrqzL94/rzgsA8tZAnt5mmUxvpP4BHwLTuqBR/+hOreN9p/YXW/7kB14q1vUq3gYlN/wOc91XVmLdW0xudQ3/i5OsRf1cuHL45Vi30FWvIh6iXH0KlvnTktN9g+pfWSA3SorN8+HY3l/PEV1UYWjc8H1PxD69yFF8MCdbRT6DYjfP6s06ekLVvQcZaok53heHigWsm9oR7Tz2FzoPrjLbSvl6DeO2qw70xq7EbwrSiu4SXRQQz3oCONJhpXraBa7hg69k6hxnIl6mJH0JnH0CsXM9WOn+rpWAyv6BxiTfSko+hmkbY/bfgp9CPVB5cHGljxWOfQeKwx2qJGN4YOPVUs+jhOYKzRzhXb6Z7OyXKu7VvA1yNtI05yXTPWaqojNuYz1QhvtGvfjhTjXubQF+Nc6pWjBFptHPY70GrPNQ7Kmd5vuqvYpLHql4sCCxw8ADbOQeOf6hyNetrAKbwsWqVeP57WsZJmOo70qRju4TkA34oSmvyoc3Vd/JofA+Y0PQMirOU5tOUdPMdasfZndkWx5xpQZur3EkUNbHWpC/NENf5xX+fcYFuvleM5Mj/QGO+VeoNsjDmA9SbGs4N+C7NS58R0gbgbKDYBz6YUXhcJ/CAWGZ7r8zouuwNdP9i2otCbcU5m8CzJsJZHWH/yXLFrPeHL8dd/9zeWz8MLjefMsd8wuoNG4CYQMAFwE+D5VCNwqxEwAWAC4BABEwB1LJgAqLEwAWAC4DAaTAA03oqbAFiBYQLgVu/MfD0jcPwQMAFw/MbUPbqDETABYALABEDA+6cQTACYADhEwBkAdSyYADABUCHgDIAQnAFwB2983fRnBAETAM8I7L6pEfjGCJgAMAFgAsAEgCUA9ToQWwKwAmNkCcAKC0sA6jliAsAEgPfURuCpImAC4Kki5u8bgduIQEUAjLOd8PO/9zdWd/kcNP87qIk+g651gLrb39JVjd7zH4X28/9WfePsP6qeMctqvePWFjT7/X1Bg2+k8kg1rIupagnb21pDOJxTHeniudDYPk8/v7SlesDRprb9z4ZaH3l/pLrWFvTI3ZZqZs9uai3pdq7tCWP1T+gsai33FnTqHWqXobVudfXeE9Qzpoa/Gyt2nUhrVaeRXq/UoQvThY77ZA7NbNATOrleb3pB+57t6thuon572Kq1oNNU79Xa0ms360xXARYtEHdjHYdiqMfxRL+f72kcspTeoKdxU0a4PjwLuASwxjg1tGt1vDHWAfrpVkOTW+xrW1ozjCvqaOeJ9nUCrNNtXQ/StsbNVndTupehXnxAbft8V/0LgoZVSJGazZrpi0LPT3rqj0Bt+ZpfQ16vCZwD1MBnWBuZKr2IocWGJ8BsrvKDQRdxM1W9c7JA/fVCvSIWerswm+mcCvEFDTVdjkJ0WtfDMtb75xONhbBXXy6ZaNuScE7uNRqhHnup49TpqB9B0dE4XQTtXAtra4z1hc+xVlfXt7KtfeMa0ULt+n6iz4ZiirWbYdtYD7MYfd3QORJ4CK+ZHH4tJeZE3HimVqDPJ/qFNrwbmqagy0HCWk5PkaitcdEZaINL6PIXpY5Vgeccx27e2IPkDT+AZdMSbdyi8UysPufaGDAsYa5tj3Os5ZmuX4vF4xf4ng//1vLfC1P1QLmN2zVf2gjc0QiYALijh8+NP24ImAAwAXAY0yYA6tltAqDGwgSA/mKITACsgsMEQD1PTADUWJgAOG47RffHCNw8AiYAbh5DX8EI3DIETACYADABEIIzAOosHWcA4C03KzaYADABEEJwBkCDMHUGwC3bk/lCRuC4ImAC4LiOrPt1RyJgAsAEgAkAEwCWADR+zEAeYQlAAxtLAFZgmAAwAVAhYAnAHbn1daOfAQRMADwDoPuWRuDJEFiaAM4vhXc89B2rr1yAbnWM4wR6w/sgLD39VdXQlZ9EEeA/gebuQL8fRRurtkRt1df1z6rOMg+qOaU+MI1Qn72l94q3VJc6HagONXmWnj94gWpwp6dVQztCveYRsGpqGatOthO9/1ZP+3eqr/eb76kONm7AE+2jRvfXobGf6ucF2tbuqda7k6iOczZWbCZT7fsAfggZtOEL1J7v9FVbSY3u7teuSNi2DnQs2N92ohre3rn6+tmWamzHkcYV9cDtJ2o9HzaAkoCNtI7R6jsslZfv6f0iYB9QGLvTV6yZkcA62tORjm020/sxNTuFB0APtbQXs1qTm13Sa6UzeHiMoFvXEA3hrMZZtoX5Dh+MBALj0UX1+YiHqOu9r3M+Huuc7vfvlrjpdLS9w7n6cvC41dd5kGCOLpo11CH/jYOK5jmOeVMUH0JINxXb3mmd/9OZjvN8qNrtZK7rB7XfOTwAylLHYg4PgHn2mGAXYSzTU9revNSx6MSI4536ftmezvei6Mu90lSPh8Md+TxuLnYhhM27tS/tATT8pcZNTFMSPT1wbc4hFu904XnCWva4Pu9HwqBo+nzAmoZlSZKWjnMGfwSunSn8CabwV2Ct+zTS6y/wTM+xB+hi/ciwtqcdrNUw1lwUOifjHp7LsR6nDazp68O1cErvm66u1fkUPhU4pKcI538oH1/w/sbv/ebyXxMA3l8bgetDwATA9eHkbxmBpwUBEwAmAA4DzQRAPeVMANRYmADAjyMTAKv/Ch04AAAgAElEQVTgMAFQz5PEBMAKDBMAT8v2zTcxAncUAiYA7qjhcmOPOwImAEwAmAAIwRkAzgA4nAfOAKifes4AqLFwBkCNhTMAnAFw3PfG7t+tR8AEwK3H1Fc0AjeMgAkAEwAmAEwAWAJQL6EmAEwAVAhYAlDHgSUAjS2WJQA3vN/0iScbARMAJ3v83fsjhkBFAMxnl8JD733FqmWds6rFLEstg9Wboz77f0Qt6a9qJ6ML8ATYQ+1q6FibZ3c2VXeZQMM/nUIji/rG9ADIMhX8JZtKABRt7WuOWtMJPAPKAerBb0NYCm0n6xuzTjjrM/fgCVBA1zq+3BAhKxShi/rFrAWd56iHHisW1KyynjKxZ11uHpddHfdZhlrU0PBPLmpcpfvavniqx+22gp236v6NEvVO6N2lWmtq5ENAXWt4AmSod56i/vpsV/0SpjvaF6YLix44hBDF0NFDg8u62qzbvcD3mZIbF9CC79djke8pNq32aZnQ1MS2W6rV7v6nen52Tu91MFHh/MHegVx/I9bzO1PVEy/gbTG7rJ93OqrDT1ONkzyHf0K8K/cvUsxp6JHLRSOOMecWC66dGvP9bfgnwFRvDgFyU/tcNXK+p3MmO4D3A+q/t5Iz2jeM+9aWtm+R4AJ9/Twa6Fj2BjpW4o9QeRyM6rFhXJWlegKw2HxR6BzKsgvSl+5ZPT/tahxwbSWWsI8JnENYakOB52AHa8JoqN4SXLvbLV2f0lbd3tFE1yd629ATIEZMZljLA8Y5LDBubR23yVDXp7LpT1B5nAAMWAaEea5xE2H9TNrwMEg0bqcLnUhlpHG3sVnr+FuR7j9g1RDyBZ7huT7zN9rwBJjr54uJzlHufw69Hb7n4YeX8XgBe5AjtsVzc4zAkUHABMCRGQo3xAiEYALABMDhPEhMADSWBBMAh2CYAACBaQJgNU9MANRLhgmAGgsTAN5dGgEjQARMADgmjMARQsAEgAkAEwAhOAPAGQCH88AZAI0HlDMAVmA4A6DxA18fm84AOEJ7OjfFCBxVBEwAHNWRcbtOJAImAEwAmAAwATC3BKD+oWcJQP0sNAFgAsASANkbWgJwIrfK7vQtQMAEwC0A0ZcwArcKgYoAmO1fDP/7W/7y6pL9U6jPjDrYnUK1jNEIeuIr1Kmqxq4XVH8YWJu6oeMvINSkFrFdwo8A9dFb0JW3UA897mp6L7WWrFectlVn2t7Q+7MeMrWPCcST1KlmC9VGst5z0sGrl0YgLIaqXWQt6ALayDVtYwYsIAdmfeQiUq1l1Nc46J5Wje4i0faNZ6oFj6BbFX+Dqp8qsQ2DRAvQs3b1LKo1xKNINbbJBvwDNjSmE9SCj6FhzeElcXBRdezJTLHMh/BbyPVzej/0ezoHOXaQ2IY01Tikh0Ar0rhNCz0O81oXO5nqOM7m2tZeV7HqdlS/G/05HdfxpgZSAQlvhPJpvVJ9P+Ih6rnvw0NkSI2/egDM5xp3LfiIhLCnyynal0GvHOU1PpzP06FiwTmS97EWwosi4N5trF9ra22DuKk6EcNPhWuAIhdCC/Xa81jjNE+0vZ2Bjn0RQ2891u+3o/r79CvYv4L1A7Xi+339vL2l956V8AgI2vY00RjnHOr2dH3KoRXPoA3PZnr9wx+Cq8wRnF/G8FdAHDaDjh4g9AAoE4wcHgP0N8jR9nwOLGOdY2seAND80wSw3dOx6MB/hZ4ArY4Gdh5Bd1/AGyOBl07jsNPRtpd6qUCvGnrZ8Px2jLZhHHm9Q/+V7/qtDy6H8PwEHki3anPm6xiBY4aACYBjNqDuzp2NgAkAEwCHEUyTQP7gNwFQz3UTADUWJgBqLEwAmAA4jAYTAPW8MAFwZ+8T3XojcCsQMAFwK1D0NYzALULABIAJABMAIbSdAbBaUZwBoIurMwBqPJwBUGPhDIBGXDgD4BbtyHwZI3B8ETABcHzH1j27AxEwAWACwASACQBLABqLtyUAKzAsAajjwhKAGgtLAEKwBOAO3PC6yc8oAiYAnlH4fXMjoAhUBMBi53L4re9+5eqDpK8/ivkGjDp31ranLvZgV8XbbdRPTqFPzua11nI8Uj1xgfrrg1h14KFAjV/o+eJE9Xq9LdWBdvvQhTbaUgEUQadK7WYMfTG/z75OUUOYWJYqtQzzDML8hjaU2sbxVLFj7WjqTIcXdZzyfYgr820JHra13VNs56gpnvZVkxt3NM6IzWhXdfuTy3p9fn/z9Ka0L2vVccQ6262e/sorU9XYds5pHMTb2vZZCV37VLFKFyrS7cP3YoF67sVUNbrUK3NOxSjZmLa0P2mh9y/h/0DsQqjnzRw1wxcL7VtZqBZ6sKla7OKs9iVDrfkcWPOHVT9Sj5ABsOsudFKUIx27SxcuSRzkuV6PcdvpwJsi03lTtvT63U4dG60EHiDAZlJozI4LvfbgnK5fXD9a8Dgp4YdAXf18H1pq+CvE8HOh50lA/fVWV+M+gjZ7OlPPg8lY+9f0MFhbf6BTT1oas8RiNtc42x/tyzhvDHTtj1LVkU+mOhbtlsZRjjifwE9mMVVs8xn8HDau7ilAnX5zDtILhl43RQKvBXgz0Itho6tYME4XY53D84n2bdDTuORzrkMPABzPZjpWHNtFhjjFWNG/od+vPVEmCx3HFrIPqNnvtnRcJtDsJzH8WrBnYFsOvSJe9evvX8bf+bE9ALyvNgLXg4AJgOtByd8xAk8TAiYATAAchpoJgHrSmQCosTABYALgMBpMANTzwgRAY700AfA07dh8GyNw5yJgAuDOHTu3/BgiYALABIAJgBCcAeAMgMN5MHYGwOpJ5wyABhHmDIAVGM4ACMEZAMdwQ+wu3VYETADcVnh9cSPw1BAwAWACwASACQBLAOp10wRAjYUJABMAFQKWADQyP56QCJgAeGp7TX/bCJgAcAwYgSOEQEUAZDt74UPf/cZVq/IcWvCe1snOe6p9bGqtq4sk0CdT88/6yqzj26xJnOGtSzxTXWeMeutRdErQbbX1B34K/fE0vyjfL4L2bTZWLeN2T3Xw7fZdOprwMygKvd54rNrxKFaNbRv15lto72Kh+uaDaa2DTXt6rdYGi4prU7NSdaDTS6jnvq860jQ9LReYQ5M7m+0q9i1oI9GcwRnoTHPVuabAhrr1At+n5nce1VgXrIOdwlwBZbbzDR236C7VJycbHDe9XqRTKMx3FdtuqXE53lPt9ORAsYuD6lS7PdW1r3kCwANgBq8J6mKbpl7c7FOfPF1oXzobWpe7fUaxmKeq910g7lirnj4frRLeEVNdAxgX4wP4hsD/gL4b21s6pwNCI0N9+SY+beiPiRXXxrylcdU5pdixFv0UcVMMUc8dfgiFLlchlFgvqXfGekedekAte2q7A+rFb26rD8dkUo8FPUcoJ0jgT1CU2tfRSD1BqJPvdXVO7A51PcoWut61O/AAgPYbYRqSXNcA6tjnmYLf9IqoFkbO4WZ9elYU2N9Xf4PetvaNfir0qcByETZ6upYnmc4pegJ04NPDOIjhhTNbaN9Tekfg+5s9jROOPbFtllTMMqzNLY3xQV+fK3PsIfTbIYymuljTI4TXi+LHr/Dyd71v+e9jQ43LI7S9c1OMwJFCwATAkRoON+akI2ACwATA4RwwAdB4y2MCYAWGCQD94WgCoPHUNAGwAsMEQB0XJgBO+s7S/TcC6wiYAHBUGIEjhIAJABMAJgBCCM4AWK1KzgBApowzAFaAOAOgjg1nANRYOAPgCG3q3BQjcEQRMAFwRAfGzTqZCJgAMAFgAsAEgCUAjfXfEoAaDEsAVlhYAtAIC0sALAE4mVtm9/omEDABcBPg+VQjcKsReJwA2A8ffu0PNN4AHshtFsl5OU7vhn4QGt8iQs1i1DinJg8l1UNT28l66OlctdAL1L3ud+67KkRlqbrQSQmtdVcVgqzPHiaqpQyoUV4G1XYvMrQ303TiHurRdzqKbbZQPXOeaXuzRa0/7G1dXV88jVW7HafaNm5wOweqT44i9TuYz1EXOweWscZR80dmNUhNXWd1zLrfi0Kv30rVRGCeq59CUOhCXNT968Tal2KkMTqdKzZBJaqh2NQUgc5pmEd29Xi+q5rY/AD641x/ZY52VUcaYYNNvXMLZbf4+Xyi2FCz2+koHp12fVwm2lfWb6d2O+pAVauXDlMI07k+sK/5BBpfDHOUXd0DoMy0/VGu359NdGw6fXgYANsIuvmmh8DBvsb4xrbqj1N4RZy6Tz1KaDh4/ryuteUEYwHPkxJeE8VMv18gRb8/0PbRzyFbXH3OLRY6GHPUe+ccb3oaTLE+0GshqMR+zXgun2tcdFOdc9SR97fq2vHV+jKd6Bwfz3VtRaJHKHPFkl4V7ZauR1yvNjexiGjzQzSv4/JgR+OIXhBrWKklQOidgSdIS9d2egzEM4CNObXR1uccPURKPOOTnl6vuZ5U2C+gw8/muh5y/WIWUtEkopCtRe+XVqLjwrgYTXStLSIdGD4Xuz34CD3xoPkvf/0Dy73G+RG8bm71Js3XMwLHBAETAMdkIN2N44GACQATAIeRbAKgMadNAKzAMAGgP6ZMANTzxARAjYUJgBoLEwDHY3/oXhiBW4mACYBbiaavZQRuEgETACYATACE4AwAZwAczgO+xXYGQONHrjMAVmA4A6COC2cA3ORGzKcbgROAgAmAEzDI7uKdg4AJABMAJgBMAFgCUK/ZJgBqLCi7sQSgESeWAKzAMAFw5+z53FIj8EwhYALgmULe9zUC3wCBigBYXN4Nv/md/83q02yhOvkw2JEzZxuqoY37miJLLWcJXep0qDrSNFLNXtpqiLmhw4wbusllo6CRpba7LFXzmsEDYAH/goBa9f2O6khbE/1Clp0VbBaZfn4wUk1tp6ufnz69Jee3UtWmz2eqDU0i1U5GDS3mLLss15oHxZk1x+OOjltaqIi+NYOWstC2TqHrTOEpUBRayzppq06UWvA5zCBY65qa/0Wp2FLr3UtqXWw/0nGMMtW4LhDzyYa29aDQcUi3rhKzlb8BYr6E50AbHgBzzAnqVumXsIivrqHt9VQT3Ep1bOczjY3ZvJ7T1N9y3HjM+b5AjBaI6RbmQKeNeuwLiKVR2z6f6udJhriC50inpRr/JNbvzwvFosRyluWK9Wxefz+Hp8c25nMy0HtNIiUc81j7Qp0717N8X7+fIa4K+h/Av4ByjkWhfTs40DlL74g+4irAY2A4VFOCZtxunMZajDjJA7TYCTxKSsWSunLWb2eczZG9wDT1Vqxzmh4AJcKS61eB9qdtnXPtVOO8W9Ta8tmQzxUdlzzsydpe9PQ5EXR5C2lP793vwpsCz6nFLvxc4MMxwrh2NtCXvurkuV7Rl4M6/eFQdfl5oWD3N+sOsixpO9a2cL42JTsViPS9SOCXkMKHh+vhoT/D3/m9R5ZjcnGKBco7TSNgBL4hAiYAHBhG4AghYAJANz4mABpv/0wArMAwAVDHhQkAEwCraDABsILCBEC9RpgAOEKbPDfFCBwRBEwAHJGBcDOMQIWACQATAIczwRkAjR+5zgBYgeEMAGcAHAaDMwDqNcIZADUWXWcAeENpBIzANRAwAeAQMQJHCAETACYATACEYAmAJQCH88ASgPoBZQlA4622JQArMCwBCMESgCO0kXVT7ggETADcEcPkRp4UBCoCYHpxJ7z327+rfuMXQ6faVQ+A6KzW1e6iJvpaXW/Ub05R1Jiaviyrd1rdrup300J1oNm+/oCnZjYb69u7ppaw6nC6qVrJsqVFhmdj1fdRF5/NVBdflKrljFGTuA/t5MaG9m8+uyChFzXrH1fa8kK1n0VeH0/HWuc6K9H3U9DBt3UcxxOti92JtG0bLdXNU9O6QA3xWabYUcMfQ3tZpijwrNLOsHlaa/PxetM97X8+quMoRv30TqreDYyzoqOa/3Gp2LS3FZumhr4awG6smtjZFW0b27PRU2wnE52DfAuPMAushR2CYrlWZ3uhcZRG9TyYF9AD59BmwzuCBmDU0MZd1XKPZ4olf2QWaNtkT7EgtgEc3nBHdehRoXEOqXZg+/Og2GQoEN9Elk7w1BPvT1RTPw7ad+rEceuQ7UMLPta2tUuNM+rYM4wd5wzjZjBQrXgSKXazkcYx13rGWVOH3+rr2kiPkifKq6/WvzSBtwPWvnymcdnp6JyM4SGQwgejF6tPxsGezvlooXG7yDTQZgW033r7kPa0/RybaFpj24ImP471uVLG2ra8CzZCl4+Q9PXeUaF96WQaN8lYn4M7FzTuilx9Mha57gno3xK1NG76PX329Lt63PTVqALgUGe/IuWKetZNhjqHOL8z7Dfa8BiZ47nEZ/48075yThzG/N/9d59YNu/SVL9/UvaO7qcReKoImAB4qoj5+0bgNiJgAsAEwGF4mQCoJ5oJgBoLbsZpHmkCoMbKBIASTyYA6tgwAVBjYQLgNm7qfGkjcEQRMAFwRAfGzTqZCJgAMAFgAiAEZwA4A+BwHjgDoEFoOANgBYYzAOq4cAZACM4AOJl7Zvf6xhEwAXDj2PlMI3DLETABYALABIAJAEsAGhkPlgCswLAEoPGj1xKAmgyxBMAEwC3fjfqCxx0BEwDHfYTdvzsKgSUBcOFy+F9efP+q3b2eamjbp1S7Oeuq9rG7Bb1zo6Z4ddF8Dr1xC/XlofVs92rxd4I61tFCtYXxWI/XtJSZah9Za5o6TuqVk0i1lNTFzw6AzUy1kyg5HkJL9YuzEjpSeBB0oV9k7es0rwkM1junf8Fkrlpq1opu91V0v6bvRY3xAOkj63Cz5jhLQ3Esog7GFlpzjg01vdSCh0Z38z3VzBaF+gm02zrOs/KyzOOso+Pa2VLBb4FyaEmAfhn12hdDBY8VGJh2n8Xwc9hSrXaBH61JW+OedbjXjhuZ25MRNPcDnd+bZxS7ItX5TU0t627TK2I+VyzGB1oTfDGByB+H+VDHln4K1PxTE9xcb6pBX2tvAT10XPe3lcLzA9rnPEbcASt6Rwx3de2lV0SaY+2EGUQ7RVxGqBcPX41ODz4fGxpXc3igZCMFv51cfc1o+oDkCbwk4AHCOGr6mywnY6LyAs6RNFEylx4lUa7rS9MjpLo81/J2R3XqeY41oKNrd/8u/f481s8psZo2/BTiqc7XQVvHgWvloq3jEG/r+dTkl1irS7WmCNPz8I/JTsv618ZYxRH8EGJdLzmWXKtbscbNCHOea8JiXt+v31HvBnqG8LjbPYc9GTxC8NzJMN/TrsbVYdy96ZHPLq97eYYF6Y7aAbqxRuDpQ8AEwNOHte9kBK6JgAkA3aSZAKhDxgRAjYUJgBoLEwAmAA6jwQRAPS9MANRYmAC45tbLXzACJw4BEwAnbsjd4aOMgAkAEwCrzbwzAFZT1RkA9arVdQaALOGFMwBWeJgAMAGwzJ5wBsBR3ua5bUbgSCBgAuBIDIMbYQQeR8AEgAkAEwAhWAJQr4iWAGg69MISgFVwWAJQz5OOJQA1YWoCwFtKI2AEroGACQCHiBE4QghUBMD80uXw0Hd816pVg03VWsY91U7OE+iXoZGbznUD3eqo3i+GMH5dK16n2M6m+gM9QvnjoHLh0EVdbGqxZzPoMrOr1+WmXrjfUp1nNlZd6GikDWKt+2SgGt5pDu0larBT99pv6/3LeT1W7Rx6XNQ/zzJta2sLemLUrZ4vVNs42te+FVPVF3dbqhXnuDLso0Tjalqo9pzl5ug1wf7QA6C1qPvXDdq2LFON7WRCXaj2NeqjlrzKUEOrhRgP0OQe6JxhbfumHrjCKYX3RB+a/zLVOVqWOhYDfJ/X59jMJnX7NjdV488MgP2RCoi7m9CdJ9qW0QxzDPXY1+Z/Bs+Qhs9Fhc3oso4N+9Zr6+Cw/Br11J321XXzvU0MdiNuGYMHM8WGcgliube3J9Pi4ILWe++U2rZBW8cmZBqXWa4L5AJa7byla0DQJSDQc2UBzX88g+dKfHU/l+bYEvcEvhuLtbVPV4wU3+f6UQadE1GA5n+i2AzPw+smuUtuGMWKfQq/hwATlLirYzcpNe753JyM6/UuxnqR5OohsraWYtymkT5Hmt4LVadaka5Ps4u6HiWTLel7HOv62IEXTRv3L9pX5Px5qtefTrR9c+jm2V8+p0PTYwV7gKaB6eNr5ylpSwl/ljzXOdfCM7mAbwafQ3nxeAP+/sc/v/zXHgBHaEPrphxpBEwAHOnhceNOGgImAEwAHMY867mbAKhXAxMANRYmAOofliYATAAczgwTAPUaYQLgpO0k3V8jcG0ETABcGyN/wwg8bQiYADABYAIgBGcAOAPgcB7wDaAzAOrHkTMAmo9mfcttAsAEwNO2cfONjMAdiIAJgDtw0Nzk44uACQATACYATABYAlCv8SYAaiwsAaixsASgxsISAEsAju+u2D27XQiYALhdyPq6RuAGEFgSAJcvh3/7nX91dXbSVf1ysVZIW2+UlaorZfm4rTPbckJRqMaXabR543qsb84NKeunB2hUWRM4jqDNztUTgBpdQsrrsZ46XbHpAZChLvgYHgSsSQ7leUgS1YY2a6BTk9/0B6j6QS1k/6z6CcQDvfYMmtwIeuMUOlXqOK9V751xFaMeMzW+SV/bx7iJCx3b2V49tpsptNNBYzLLVKPa7qr/wSRRf4KipTHcG0AnDv+FfKHCVepWc+iTOYdYbz6HGUZzznzDZYDeGfhSt6GbT9ta93o8V5IsSjUqkw7mFLTRBfwJ+j2NO/p0zIf6ZrUYKdYJ/BE456bwDSmAFedBnGr7W/h1czUvi8lc44Lzubup3hNJqjEcIU5aBcXdOlDDXR2LJ+TIqy+1e6pb753R+0cI0/FCrzcZY6yxnm60VBuOoV5bY6LGekuN/jzTtfda4xK38VzCWjqZ6lhkC30uJYViny40zudDBSdJ9JjtDzAdycrLMljJFuJqU8d2nNdY55lO0HwBH4xI23oKz9TRFL4YM6xnQePiwpcvSFvTqermi0K/3+8pFu22trfsqP9BUMuBMJpp+2aY451U7wc7h9BuzMm4VFwXU12r28kZHYcEjcF+ptW9uhHw/kR9PQ7Xvzf+u88s73NpquvVDWzDfIoROBEImAA4EcPsTt4pCJgAMAFwGKsmABpvuEwArMAwAaA/OJpruwkAfdLxR7wJgBqflgmAFRgmAO6UHaLbaQRuHQImAG4dlr6SEbhpBEwAmAAwARCCMwDqN3zOANA3tc4AqB8zzgBoPnL1zbMzABrYOAPgpvdmvoAROG4ImAA4biPq/tzRCJgAMAFgAsAEgCUAjTe1lgCswIgsAVhhYQlAI0PKEoBgCcAdvfV1458BBEwAPAOg+5ZG4MkQqAiA2aVL4X2vePnqKxm032Wk9ZU3Tm3I5WiaVRb6/SLW4/lMf3SveQI0PAAGG6o55du4tXrJmeo8p2PVQo4PVOPa7av2kHrgtKXaS/Z13qifvgQFWmv2rdXVt4usbc9a2WPUUO+3oZ9u6PCLsepGW6Xei21h7eh5qprZ7btVF8r66usaWmh6M4z7XLWSnZ6+JuJxXiqYxJ7actaO7sa1/rkDTWueq6Z1fx+17fuKxd5ca0cXXcW6v6HjEmLVyQ86iGPU/eacoS6engDr/gqKPXWxg4Hen7EgI6VTKEznOofyWLHJcEzXfI4LvRriTFPsewFa7IU2aLin9du3trSGeYCXxHCu36dnSZ5pf/odHctspp83sRtsKq5pX9cLaqHnmAOLsb5F7kaq2aePBz0AkpbO8d6mtn1wFu3bUCzH0I7nuc65CTwH4lzHih4oB1dUC95u1I8/mOhn9Dehz0V3Q7HY2VWNPaZQoEdAt6vnp7mOzXRX43q2q3Moz/U5R/+VVkuxmOQX5bmYAOuyq+thMzamhbYlBEWHMdnvwMwBD3jG7GJfY3i+p2txMte+ZBm8HiDKz/MrcscchACfawWeBbOx3r/b0udwG3HdnHNcK2dDHbcQdD3oYD53Onqv2UzXh7KlcbqA18OhB8D3f/xzSwwuz3QOe7dpBIzAN0bABIAj445E4POf/3z4wAc+EB555JHlf5/97GdDtVn68R//8fCjP/qj192nX/iFXwg/8AM/sPz+G9/4xvDOd77zSc+t7vOTP/mT4UMf+lDY29sL9913X3jNa14THnjggXD33Xdf9z2v9kUTACYADuPDBEA9U7omAFZgmAAwAXAYDCYA6jXCBECNhQmAW7Id80WMwLFGwATAsR7e49u5t7zlLeFnf/Zn1zr4VAiAL33pS+FFL3pRGI/HS7fkqxEA73vf+8LrXve6UDmdv/SlLw3f/M3fHD7+8Y+H6hr33HNPePjhh8Pzn//8mwbcBIAJABMAITgDoLGUOANA1lVnANRwmAAwAVAh4AyAEJwBcNPbT1/ghCFgAuCEDfhx6W71pr7KAvi2b/u28OIXvzg8+OCD4T3vec91ZwBUKWzf8R3fEf79v//34Xu+53vCu9/97iclAB599NHwghe8YEkUvOMd7whvetObljBWGQevf/3rw3vf+94lKfDRj340MDX4qeJtAsAEgAkAEwCWANQrpyUANRaWANRYWALQeONvCYAJgKe62fT3TzwCJgBOfAgcDwCqH+LVj/jrzQD4mZ/5mfDDP/zD4e1vf3u4cOFC+LEf+7EnJQDe+ta3hre97W3h/vvvDx/84AcFsOFwGKof7ZUk4P3vf3941atedVOAVteaXrgQfuXF/9nqOtOF6hFZy747UG3lmlY7Vn30midAoZ9TFxu1av1jmqpucxv1j6NctZJT6AGLKWqIB329WUDzWrZUp8m+Ul9MrTVrFG9tav151q5HcwI9Aqj1TmLUsi5qfDolyIxMtZCj0XmJlXGpfgjtszqunS0cQzsZxorV7ADeDlPVE3dber0B9MrU+M9Qzz1pa997fdXBzqErbdZYn49QW75QrXQLmtMo0rrV8wSa2YG2ZS1ueqj/nmgcZylc2qIAACAASURBVLmmlZPI44+NxUR1pouFtmcde437jQ34dpQ6dp1G/fgIGvoZ6rXniba9PVAvh6buuwq43d1dibt8oXFBL4l2ptfLEUdrdb/hJRF14ClwSuNkttA4nU60fjx19wVqsnfa9TzrM4ZTxZ1r6XCkemOSDdFC17PRvsZhiprm9AAIqZ6fRfBrwHECHTvbV8x1rJpzaklKwx8hQb36+bzGusjxXCixNsc6bkXA9+ElQy8H+h/w2UH/l+m+jjv9ZNowcGjF6rdQoj0c66ivY5H0dM1ozpsFfHdmuc5v9iXQXwXrG/1foim8G2bAvuElU40rPULotzArdQ61esAG60sSdP1rpzrHiW0P/g3N5yA9RfI5/RC0r60W/U90XOZzjYMs0+diEen6lXYe78sbP/GZ5b+X4OtxUxsyn2wEjjECJgCO8eCepK49FQLgMHPgL/2lvxR+7/d+b/nj/2oEQPX2/wtf+EJ417veFd7whjeswfq93/u9y+yDKjOgyhC4mT8TALrBNQFQR5MJgBoLEwCNt38mAFZgmABQgsEEQD1PTADUWJgAuJldms81AscDARMAx2McT3wvrpcAqNL2X/7yl4dPf/rT4VOf+lR43vOeF/75P//nT0oAHBwchENX6+r7L3zhC9ew/rmf+7nwgz/4g0sZwB/90R/d1FiYADABcBhAzgBobN6dAbACwxkA+rbUGQANMsgZACswnAFQx0XlcdT8MwFwU9s0n2wEjgUCJgCOxTC6E9dLAFQu/v/kn/yTUEkAKiPB6u9qBEBFFFRGgdVflTq7vb29BvZDDz0UXvva14Zz586Fixe19NBTHRkTACYATACEYAlAndZuCQDKmFoCsHqsWALQ+JFrCcAKDEsAnurOy983AicPARMAJ2/Mj2WPr4cA+MxnPhO+/du/PbzkJS8JH/7wh8NhDfurEQAf+chHlhkD1V+le1vT/oWw9AV45StfGSqtLfVw3wjs6kf+k/099thj4XSShH/zBOlQfY+af2ox+bBnrWu2aTpRT4H1H1vQ5DX0j9RCt6H3zQv9Ac/6wtR1nt08I1Acjsnqf8IBvejoj4EFap4zBbjXVu13mOr52VxTZokNa1mnbdVOptDYDtq1vrGEJp/aSNb4XqRayzk6De30turkU2jwx6gRHiba1/lQdaz0R8ihL+bY8i0SvSQYR52U9Z1rnWoaQ4OPN5edjsbFfK7YUOdeQOs9S1QTS31y863xMtag1aZunhpcxmkJb4tsonEVL3Qsk0gDO4L2u9Ov45Y1yUv0NQ96L/pWRInOZ65h07GuB0mmbVscqN9BOdO4ou8H5MWBMh4eJ5hT86nGaT5G2T8QAE2/hkM98OH6kWF94Fo6n0HbjflMLfTlKzuyXqXwkuj24INRatt3dvR89h23D1xv6U0RRxpXkOkHEgRNv4Yu5mcGH4vRWP0RqIvfOq2eJsQ+xw/yCbTd8wl8PDLtS78Drwh4miQlfD8C4hJzmvMiqEw+jGe11rzpe7N8BqfUsevJfI7M9nX9aReqse8l0MnrYzOM9tRrotPXtZT+LPRjORge6HO11PZvbeiLDD4L6GmQZfocba5/a88FZBss4DHS6agHQIDxTpJoW4fDfenLcKhzqNt9fI59/+c+t/z38kLXq2O54XWnjMAtQMAEwC0A0Zd45hG4FgFQmb297GUvC//hP/yH8MlPfjL8+T//51eNNgGgmxluMucmAFaxYgKgnusmABpYmACowVBuxwRA4/FoAqAGwwRAIzBMANScvwmAZ35D7RacCARMAJyIYT7+nbwWAVCZ/FU/9H/qp34qVK7+zb+jKAFwBsATI+QMgFWo9pwBsMLCGQD1CuYMgEaVkiccwQ/RcQaAZn84A6Dx5HcGwAoMZwAc/z2ye2gEiIAJAMfEsUDgWgTAt37rt4Y//uM/Dn/lr/yVtbTKr3zlK+FP/uRPwr333rvKDPj93//9JS77+/sr3f+1TAAracHHPvaxm8KzkgfMLl0O7/vL96+uU5aaijnJtUxO1NZNXh7p64RWR3c6XZRE45sYlsZrpnYv5ppelyH9mOnFG30tu8eU+fEVTXVcSydEGmlAKafWlqZWnrvnnODPslmzfU13no1RKi9TgzGm2E5nej770yz31I21Le22pn1GkaY2ToNeu9xCSutAUyOZclsg1XIx0rGKZyjrhbfW+UTjhunHZaTtoTyi29E0UcbCpFHejWWxWIqO5dgoY1n7YYdSc9NSsWyW1asChCmzzSyX6vMIJdBYYoyl6JhOzZJlca7YM+5aLY3jsvEWfTLT+R5QGrOMNGbX0pcpL2iUGKz6yhhm25K5snDjPS3LRTkFsS3bGjdjlPXqIW0+bZTSrNo3HelYspRos5zdWmnKDaTkB00751o3Qxo8s1z6A5XhcGxYTjJGmdAMZU6LBeYUxqrd17ignGP/QNeQbkv7u7+jz46mDGhygDRzlHjt4t5zYgd5Q9JFSVTIw2aQWyRI/e61NM29xFrMtPiATO8p1nKmzVP+ARVOaKbVs9wsy7+WGDfOobQ5gasg1rALGSRPa3KsgHKPkPFQbtVFmT7KaNbK1wL7tWdFrPKOgwOUqG3Xe4qigAQJJVw5x9ZkhG2N8cVC5V6UylGa1n6iFOffeeSR5bP/4kyf6Te1IfPJRuAYI2AC4BgP7knq2vUSANeLSfOH6NNdBtAEQD1K/OFlAqDGxgRAjUVsAmAFhgmAOi56JgDkkWcCoIbDBECNhQmA690Z+ntG4PggYALg+Izlie7JtQiAq4FzNQlAdV4lGXjb294W7r///qXhX/NvOByG5zznOcsKAe9///vDq171qpsaB2cA6BsxEwCNDaszAFZgOAOgQZI5A2AFhjMAnAFwGAzOAGj8wIcxHrMvTADc1LbNJxuBOxIBEwB35LC50UTgdhIAjz76aKiyAMbjcfilX/ql8H3f933L21epaW94wxvCe97znvDSl740fPSjHw000HuqI2UCwATAYcxYAlDPHksAGiuJJQCyrFoCUMNhCUCNhQkAEwBPdf/l7xuBk4SACYCTNNrHqK+f+MQnwpvf/OZVj774xS+GS5cuheoH9LOf/ezV/3/ooYfCfffdd9WeXysDoDr5V3/1V8PrXve65Y/+qprAc5/73KXe/0tf+lK45557wsMPPxye//zn3zTCVfvnl3bCv33Fd62ulZV7ct2kp1rLpKXHo4VqO6n5p1a700G5tqFq6Mqs/lFO/R71ffNChZnb21puKIG2umlKVXVyNNS2RyjlVLRU71x0lTAYnNISQ3EBEyzq4lF6CtLLEJV6/loJtIV+vrfX1G7quPR66sWQdhTnaYJybKdQKg5p7h1odFEFK8wwjp1IxzkaXh0b6tzjnurYu5uq+We9+kUGD4JGybIpvBhYbo0eAZOp6uCpgWWZP+qVu42yelWcMbOEOnVUzQrzOcrFJTo2/RTa8KG2N0actVPVvY6gsW2WTMsRlCx5uLGpMd/d0HEZT1W/G8Nle/u0zlGWg2RJQ85Zzpm0r2UAOIdZjo06e8ZdO1Ks2qUeNz0LmAFAOQRL2bEM3yxD+Tbo2Bl381y/T6JqPtE5cKhXPlzQO9Bur5UGjVCCEeTPYqH66yHiaP+iloNLFvXYpNCBt7A2Z+hb2tNxnRQa4/R2aHXhawGnez5L6KNBLHLo5vMRvC8waUnGr8UdymlK+Tl9rITmM3C5fuT6hXymnWPMco5Mp7rW55meTw+CEos7PQgYlz2UUORzerin3hBcfycT7DGe0Nmv4rZTj+1oBB+KrvblWiUMubayJCp9gei3cBg3/9VH/nDZvItTewDc9EbUFzgRCJgAOBHDfPw6WZn0veIVr7hmx7785S8vf6xf7e96CIDq/EceeSQ8+OCD4cMf/nDY29tbEguvec1rwgMPPLAkAW7FnwkAEwCHcZSYAFhNKRMA9epiAsAEwGE0mACo50VkAmAFhgmAW7Eb8zWMwPFGwATA8R5f9+4OQ8AEgAkAEwAhOAOgfrvqDABnAByuCaUzAFZPdGcA1JsbZwCE4AyAO2yz6+Y+4wiYAHjGh8ANMAI1AiYATACYADABYAlAvSZaAlBjYQKgxsIEgAmACgFLALyDNgI3hoAJgBvDzWcZgduCQEUALC7vhN/6zr+5un4RVGMXdVW7zfrLeaQaPL5B5NsC6v/ixZPXi6ceOMtUbxwnqgulJpc1zIPeKhSl6jqp3YZsNYxQU3wRqVa7larunvWWWXOcmv8AOWFSqDYyG2v/9/drAiPSYQoh1nFMNlE3e1M1ttNCdaKzUhvDmuDUvFJnPr2i12vP9M1qp4RHAP0TUHh7Guv1gkIRWKYwbmiM5xMdJ9Z254++MbTNdLFmbeg41cC6lua/1dc42T6juvjpQvvKutvMWJhNdKyKCeK6pWDliPumF8Y8V6yStvaNPhvUuc8zPZ+6+Da02v2u+hnMRtoX1hjnerKAbp0eJVuntcb4eKgeBeN9PY7gs5FPUSO9EaedNmI41klIn4oYtevpAcDvDwaKDXXs87FiveanMFfNfjHXuEg6ugZQ7pG19PzJRNfbgz0lULN9xWpxUJ8/gG9FB/Xbd0c78oxrDXSOcM7kid5rXigWcYn1LkVfC8WixPFwR3XrMdbiONPrd3taEYHPohReOttbm6v+Toc636cjPT64rN4KEdbKBDUG1565HcUy4Fkxg449Xyi2XP94nALbHrBY8yCY6/V7vXtl7NtteJaM6jjrw4smz/U5F7d0vaKHUdzWcSsj9Vfgc41YF0+sB3/9//ndZZsvTPBcui07NV/UCNz5CJgAuPPH0D04RgiYADABcBjOJgDqiW0CoMbCBIAJgMNoMAFQzwsTADUWJgCO0abQXTECtwkBEwC3CVhf1gjcCAImAEwAmAAIwRkA9Rs2ZwDo61FnANRPFhMAJgAqBJwBEIIzAG5kx+lzTjICJgBO8ui770cOARMAJgBMAJgAsASgXpotAaixsASg8YPfEoAVGCYATAAcuc2sG3TkETABcOSHyA08SQhUBMDs4sXw3m//9lW3qeEvU9XIbZzdEIiKCFpKaOrWdPax6pHTHHW8s/oNXD7Xe01Rm5lvpJIEmtcE+sCB6gNZq3lKPZ/KBUNTV16BwJrjaUv7wrepazWGg36f2u4w07eR+5e0P63oVD1u+Z6MyyxWLXWMvrPOdhYrdjNowdfiotS4GHSg5d7V+3dzHffWTHWpe3uaap22VVtZbuj9Wpt6fmdT9dhNrHtt1eeyrnYHMZmPFYsMcVdAL9zva9+zUs+nfplab+qdFyXqubdQ4zxTLLY31EMg6JQM1Ip32/AEaJywyPTerURjlDXCOWc6Ax0HegJQGx1BN5/EOumINdONWcebvh0Bccp67/SDmB1o3HJONmNhsVCs2LZWT2M0b2mMFy0dqPZAx5lzjnpk1nvvIo6n+zqHhkPVtScdeIxgDSja2r7ZHJ4DU3y+B/+IaX19ti3DtVp9jbM8hvSCXjTQck9m6k/AuKKunHEwaujMlwupTuFAYiiJtb3tROO+3dfjLo47vXqsc64vwHUx0jjrwtODc5aeJP0tXZ/oVXOwpx4Dkz3FspvqepHBW+LUqfo5VEHH5xyfm5OJxl2no+tzCi+d5vUW8EfJ8dyj5n/NywZ+LVwv2HauD0n++B7i1b/128t/z8MX4yTtH91XI/BUEDAB8FTQ8neNwG1GwASAbtBNANQBZwKg8SbUBMAKDBMA9S9DEwAmAA4nxv/f3nkASVKVcfxN2tl4xxFFEQUxICqKiSoxgjkgIuacMKKYUTCUGBHEhJgwgAkxFKKFWTCiomLCAGIAj7sj3HGbZidZ/157p79vdne2Zy9Mz/xeFXXMTnfPe78Xut+/v4AA0FovEQC284Mbl4dABgkgAGSw06hy/xJAAEAAiEc3FgCteY4FQIsFFgB2jcACIDFPsABYgIEAgADQv0+KtAwCqyeAALB6hlwBAtuMAAIAAgACQAi4ALTe5OICgAtAvCbgAtC61eICkLCIwgUAF4Bt9hTKhQaFAALAoPQ07cwEAQkAMxs3hk/c6Y4L9R0Zt/54NecMOdd0eb6LLmq2c0xtCxjkfCeDvVxIfm7UrO9io2F9+KsuX3HOxx8INrd0btzWdXSdvb7PCezzJeeb9vdzdXs9n4N465z1rfT+huPjLsaB89kdqluf4DnnCxoSvuA+93OjYM1zqyXnr+x8bksuV3TV+bF7H1kfP8H7I4827DjKTVpW1a22bW3xHFwMgPyoi9+wqxVvCi7Hejnhc1vM22ObFetD78fgUMHWbahgz/e56r2Pq5/83g/V+6mOrLWs/Gdvau5NbEddjnWfx9u7tgwVbftyiYHeyLuYHt6HvuL82F08BO8HP+d8vUcmnL+vy0Xv/d6D6yrvV19r2vo0XUySesPlpp9086BpfbkLPr+786ufnpxe6N62nOE5O8bb1sox+315Fxcvwa2t1Yat6+brN5uhlXMxQoaCG7fuc7NqYc7l7OI7W7cxAwqjLgiK+zizxR5fm7Ssx0NrffP3gZnpFkc1Kl+ybIZHrd+5j1dQHrHs/H1rZs76sddztm712vLj2MfJKOZcLAwXh6Pg4rnU3TwqDtnzQ2JgD7n1yfud+/gJyfkqdrWaDViQH7FrpW+rj1XjY0v49dHHIGi4tV15AZLF16fp5qg/3sdnKBT89VrzoOJiPdSadk74GCP5EXutwoiLNeFuXI2qXf/Kbg6Fufk5dMTXvxX9u8GN40w8+FFJCOwEAggAOwE6PwmBpQggACAAxGMDAaA1SxAAWiy82FBHAEAA+D8BBIDWPEEAaLFAAOCZEwIQ8AQQABgTEOghAggACAAIAMFYnYgHAgACQEzAv33FAqA1NhAAEADmCWAB0EOPdVQFAj1JAAGgJ7uFSg0qAQQABAAEAAQAXAASGzlcABZg4ALQGhe4ALRY4AKAC8CgPjPT7u4JIAB0z44zIbDNCUgAmL722nDqfvssXHtsbMz8zuiEy+9es0Gyci4/8/CY9d30frKNOetj53Osz0y1fDdLzv+u5vKzl8u7mboOD1u/0OrcjZaZdbkP+bL1lQz29OD9AYfy1sfW+2ZX6i6A2Kj1HZ9rWJ9bb3bvfdGr0y7/s/NHTvqKerPLYH86+JzjPl5B0dU16UMviHMu53mlYtu6ZmyNHTc56+td3WTb3qzYcTU1ZX2Caw3r2zm0q2XfHLb+zEUX0yA5DhvOj72csx3tXK9Dfcb61HofXZ9Hu+RiBHi/d5/L3ruVNsu2LWO72jlYHrL1rdVt/bx/dW3Wft82Nqy7dUgKANXK8rntiwXrQzs8Yuf77KT1C/f51nPO1ztXsJXxPv4+LkezYFlNTtvc9kOjdpz42BS1KZfg3cUgGW7a9tRnra/49NbWOG24eAM+LkazaOuaH7frTX7MrT/2p8PsrGVZnbV905xx16/Y65Xrdtx4X+/JGcvO+44Xx21fz1UdrIbtu2LVHl9sJhYhF3fDz5HyiO23kWG3frj1x6ejzA3ZujRLlk3OxaqZdfnkR0fteuTjZHjXl6aLAdCs29+rB3ufy5Vs38zOtu5zQyXb9nLOfs7X7LnNhguM4UM1DNk/+H4uujg8RRe/oJx391EXe6ZedzdSF6ijUvGBfdxaXfTxENyaMmwnQj6fPH+Luc/UC3Z++mw2pWHH0se1cIF+prdOmevn7G0uzE3O/+Ex3/lh9O/GGTtHt/lDGheEQJ8QQADok46kGf1BAAEAASAeyQgArTmNAJB48+ke1hEAEAAWRgcCwAIKBIDWmoEA0B/Ph7QCAtuSAALAtqTJtSCwSgIIAAgACAAhYAHQenuKBQAWAAtrAhYAC3dYLAASAikWAFgArPLZk9MHjwACwOD1OS3uYQIIAAgACAAIALgAtBZpXAAS1h8IAAgAIQSfBhAXAFwAevixlqr1KAEEgB7tGKo1mATmgwBuCB+96x0WALTlune5rX2ebu/nOrzGxQBwPr9tOYmHrf9ftdLy0XWp6EPe5b3OT9sN/FBpd9OR+bzzC3X5iCu1683x3p/Q53dva7vzLa/lrH+xz+fu4yUUStZXs82MdMblqp60fqVJX07vHzxXs36YI7tYn9rJivX/LY7ZoAFlF8uh2nB+586PtOTyZNdusr9f2Gr7amaLbbtnXRqzzpdDa60vZ2nC1rc2ZOuXzLuda9pxUJu2XAsNPwatr/XclPXzHB+xPrCFpm2LjwlQKtm6Vqq2bZW8czR1buzD43ZOjY/Z3/c+vT7mgPfDd8M2jAy1xkZlxtalLaWX8ccNYWJiwsyhWecTW3N+6/76Pp+7Dzzn83r7ORqchpdzc36k5HzJnT9zc6v1T57aYH2Aa3OW/Zo1yVgXdg7Vh+y4Cvanw1zBBxyw951Ofut+3M1tsderbHIxSGp23Hlf8ppbYBtFu77kh936OmJ9w/24K+VczJOpVv18nIrgBqEfo/54n46y4mLR1N3aXpywc3rIxRjwa7lzBW+L/zIz2fLZV69VpizrsREbt8PHSGm6eTPXaK0xPn5KoekGtRs2Pk6Pvwf7GCOTUy7WQ95e38fW8TEBfJyeXM2up8PD9r5bLtt4Cj5WTsO5jvi+DS6mQHL5zBXs/GwO2flbzdv7QMOhdEt1KBTs2t2Ys+dXZxz82fnfe8QF343+3TBtx8VgPknSagh0JoAA0JkRR0BghxFAAEAAWLAAQABYmHfeDB4BoLUk+Y0MAkCLDQIAAkA8GhAAWvMCAWCHPdLxQxDoWQIIAD3bNVRsEAkgACAAIACEgAUAFgDxPMACoHUnxAKgxQILgBYLLACwABjE52XavDoCCACr48fZENimBBAAEAAQABAAcAFoLasIAAgAIuBTwCIAIABEBHAB2KbPoFxscAggAAxOX9PSDBCQADC7aWP41CF3Waht5f95buM/VCrWrHPNGpfLetR+rpZcruox66NXy1s/WZ+nt95s+aEm89yrPhNN62eZ32p9Eeszay31vPVPzhWtc/WU8+9zKc5Do2Z9vyvTm8z1R8ad/5+tXvC+mD5XfXnU+tTOTrucws41vLLZ/iFfb/kvjjof1IbzsZ1ruPzsRevrOFuy1x5da9kFFwuilHf+xbbbw/Qm63favMn6Fzcq1k90zI0Tb05dG3a+nWV3Pee/XB5qsZ0o27bM3Gj7LeccRZuurS7deyg6H9rqjG180cVD8P7MhbL1O/UxAbwveH7IzjGfs9z7T1frrjNcDvSCq1+52GI1lMzdHkLw/rnex9b7tSfFhGiyVGw/1V38hXrOxWNwcTF8/nbvt+5ZDQ25fPJl64jvc9XXt7jfn0v6+IcwO2vXmJmZ1tgpFGzbhtfYOVQfsd+Xd7Pz3ecs9z74TTfwhks2HsFw3X6uXmf7vbbZzpn6nGXRbG4165lfn3z9qgm/dZ3o3O7DcNHWJ7mJHnJrb73m1p9Zuz7l3BwcHbHrRSPvxpXLB99w7Ko5y2bY5Zpv80O31QulYNe7Qt3GGGi4cV5x7Zmp2zUnX27N6bFRG9Oj7G4csy4GiY8d48dNNW/bum73daaf8yW7nvh4Bpu3bDbHJ9cHfeHnsI9dU865WBHFXcz1fAyAnFuPvPtEPt+qj4/t4Lol1F2shaZbq5sFO58bdTv/Z7faGAPucSVMlOf76vCvfDP6d8NUKy1oBh75qCIEdhoBBICdhp4fhkA7AQQAF6jOPtMhACSHDALAAg0EgNbAQABosUAAQABYEM4RAFrrJQIAj58QGHgCCAADPwQA0EsEEAAQAOLxiAVAa2ZiAZBg4SxJsADAAiAeHVgAtOYJFgAtFlgA9NJTHnWBQG8QQADojX6gFhCICCAAIAAgAISACwAuAPE8KOACsHB3xAWg9aCAC0CLBS4AuADwCA2BtAQQANIS43gIbEcCkQCwcWP49MEHL/xKvb6r+cWxMes/WK/bTXO9bv0F58ZuNOdX17pc9qPWzn5infW5TfqGVrdav8nqdfZz7VqX+z3c2vx2ce2+5nN+YjfzuVKy/sJbnR/pf2tbzPGzZft7N5uz/oL73fQX2/aiy9PdtD7CjWD9WJs1Gy/Bv0mZu8n6dlamW5/zdduWwpDtt+Eh5wNrvw7VtbYu1aKtS3CJsuuT9nq5aXt+ac76mTZcDIChgkt2b93iQ97FmsiNW9/Nmsu5XnP+yaXE9XOz1ie1VLHXarp86K4bQjMRl0IdXJtzcS4adow3q5adb2ulbsdBcY1l0ajbcTZatP7P3j+61rDH58Ys+6KLNTG+xsbKKNVac3Jygx3zzYbt1+lRFytiX3utdeP2c+M6F0fDxV9oiyWRs3WfdXE4cs6HN1dyfel8gF1K8VBs2vUnf5NjVbPrX61m+ybpr9xouDgXpRvM/G/aS4WqWz9G1liffB/rwbYshFmXi74waydNacr6qTc2Oz95FzOgWLZ9WRiy1/O+4t5P3sd78L7qyfzxs7OWe6Hg1nIXE6A07HzuXWyI0riLQeL82uvB3XfcOK5V7ZzJBzsO6nNubXZrRrl8S9PXczV7ftvqWb/J3skbiQC0tqqhPLyXPbZprz0zY+dormzvQ6U1Lm7PbvYeOzlrx22x7PvGjoP6nK3g9Gbr9+6zqAR72wvFRKwaNaxYtPfh2Vm7njbcWp7Ltdj5WDCFYVvXXMmNiyE7x6Yq7pkiEdNDdWtU7Zxozrq19f/D4qkX/Trqo02zLlDPdnxe49IQyDIBBIAs9x517zsCCAAIAPGgRgBoTW8EgBYLBAAEgHg0IAC05gUCQIsFAkDfPRrSIAhscwIIANscKReEQPcEEAAQABAAFOnevuVBAEAAiAlgAZAYCy4eBBYALTZYACSeQ7AA6P6hjDMh0KcEEAD6tGNpVjYJKGVWvVoN64zZnDU3zDmT3OBsatvSJ7n0TM2cM4b0Kdby3tA1uflw5zbsZ2eZHXLB2ZHnvF25bZs39VDHYAAAGUpJREFUa7dGnyHUnYm+s4IPeVeBottINj2rtmHi2teGypk3+wqaB3LP0X522IPv1ubyp7fX3G0GOqAK/nufVtD/gK+vs9D1lt1KSmYvkbiAH4KhrbHeYNdequ1b33Zf+bYTPFx3gJ8D7vre5L/jatPWl/YP+bbfa33v3/h7rH4+54ouLagbWE03Z4P/3KExyzuiBD+FO6JpO8DNqZwbaM22sZK8gh9z7mJuufGX8v3aNuZdZdtYuu9zDe/a4i+w5BSZ/2LppXhRrr7+bfeCBJ72KbP8nPN1ybUtvum72vScn2Pu+n7t9mtGzt1bOi0J7QtgYqy0LV3uvuW7se3GZy/QNq7cfG9rmx9HbiD6fvXjsK1vOnRt+83HrbceplnAPay2yps/eBY+PW7wv9X2efFxdkNlLuRzuVB1riWrG5WcDYH+JYAA0L99S8sySGBsbCxUq9UQ5xHfe++9M9iKnVvl9evXRxWAXfp+gF16ZvEZsOuOHdy646azYAe77gl0f2YvjruNGzeGUqkUpqZs/IXuW8mZEOhvAggA/d2/tC6jBOQKoHL11VdntAU7r9qw65497GDXPYHuzmTMdcdNZ8EOdt0T6P5Mxl337DgTAr1CAAGgV3qCekAgQYAbbPfDAXaw655A92cy7rpjB7fuuCEAdM8NdrBbHQHOhkD2CSAAZL8PaUEfEuChuPtOhR3suifQ/ZmMu+7Ywa07bmxiu+cGO9itjgBnQyD7BBAAst+HtKAPCfBQ3H2nwg523RPo/kzGXXfs4NYdNzax3XODHexWR4CzIZB9AggA2e9DWtCHBHgo7r5TYQe77gl0fybjrjt2cOuOG5vY7rnBDnarI8DZEMg+AQSA7PchLehDAjwUd9+psINd9wS6P5Nx1x07uHXHjU1s99xgB7vVEeBsCGSfAAJA9vuQFvQhAR6Ku+9U2MGuewLdn8m4644d3Lrjxia2e26wg93qCHA2BLJPAAEg+31ICyAAAQhAAAIQgAAEIAABCEAAAh0JIAB0RMQBEIAABCAAAQhAAAIQgAAEIACB7BNAAMh+H9ICCEAAAhCAAAQgAAEIQAACEIBARwIIAB0RcQAEIAABCEAAAhCAAAQgAAEIQCD7BBAAst+HtAACEIAABCAAAQhAAAIQgAAEINCRAAJAR0QcAAEIQAACEIAABCAAAQhAAAIQyD4BBIDs9yEtgAAEIAABCEAAAhCAAAQgAAEIdCSAANAREQdAYMcR+PKXvxw+/OEPh8suuyzMzc2FAw44IDz1qU8Nxx9/fCiVSjuuIj30S9VqNVx88cXhwgsvDD/60Y/C3//+9zA1NRV22223cK973Ssce+yx4ZGPfOSSNf7e974XTjvttPDLX/4yOu9Wt7pVOProo8MJJ5wQxsfHe6ilO64qr33ta8Mpp5wS/eDb3va2cOKJJy7647Cbx6K5eOaZZ4Zzzz03/PnPfw7T09Nh9913D3e+853Ds571rPDEJz6xjR/sQvj3v/8d3vOe94Tvfve70f83m82w9957h/vd737hla98ZTj44IMHctz99a9/Dd/5znfCpZdeGv13+eWXh3q9vuxcjEF1O66uuOKKcPLJJwedv2nTprDHHnuEI444IrzpTW8K+++//45bfFb5S2nZNRqN8Itf/CK6f/zgBz+IWN90001h7dq14W53u1s0f5/ylKeEXC63ZM3UR+9617ui+9CWLVuiMfyoRz0qnHTSSWHPPfdcZYt23Olp2S1VszPOOCO85CUvib5+7nOfGz7xiU/0Pbsd10v8EgR2DAEEgB3DmV+BQEcCr3jFK8L73//+UCwWw4Me9KBoc6oHls2bN4fDDjssemAcGRnpeJ1+O0APrA9+8IOjZt3sZjcLd7/73cPY2Fi0EfvjH/8Y/f0FL3hBtEHzD3Hve9/7oo2G/n7f+9437LXXXuHHP/5xuPbaa8Ptb3/78JOf/CTayA1S+dnPfhax0GZM/y0lAMBuflRcffXV4aEPfWg03jRWDj300Gj8/ec//wm/+93vwsMf/vBw3nnnmSEEuxAuueSSaN5u3bo13OIWt4jmbaFQiJhdddVV0Tr3+c9/PhxzzDEDxy5e6/26s5wYp2O7HVc//elPw0Me8pBIuDrooIPCne50p2jt/NOf/hSNZa2xGtdZKGnZSfi47W1vGzVt1113Dfe4xz3CunXrwj/+8Y/wq1/9Kvq7NvNf+cpXwtDQUBsCze0nP/nJoVarhXve855hv/32C7/+9a+j83U/0T1EQn0WSlp2i7VJ7b7LXe4SjSXdP5YTAPqJXRb6lzpCIA0BBIA0tDgWAtuJwNe//vVw1FFHRZv+iy66KBxyyCHRL1133XWRGPCHP/whvOpVrwrvfe97t1MNeveyEkH0xuHlL395tHFNli996UuRhYTenn3mM58Jz3jGMxa+/u1vfxttOvL5fPjGN74RbdRU9ODymMc8Jnz/+9+PLAH85q13Say+Zmr7Xe9614iBHmY17hbbdMBunvXMzEw0F//yl7+Et7zlLeENb3iDscQRx7/97W8R07jAbp6E3u7//ve/j8S5D33oQwvc9Eb2zW9+c/Q2epdddgnr168Pw8PD0TmDwk5vTPU2Vm+gNb7e8Y53hLPPPntZC4Bu2WiMagP83//+N7J60m/FReP5ne98Z7jlLW8Z1ScLAnNadldeeWU0Bl/zmtdEgpREqLjoXivrMVmGvfWtb42sIZJFzMRODD/60Y9G11HR/UaWA+ecc060jkrsWs6CYPUr97a5Qlp2/lc1dx/wgAdE81T3Tt1zlxIA+o3dtukBrgKB3iGAANA7fUFNBpiATNn1NkIPxW984xsNCb1h0Ma3XC6HDRs2RKaLlBaB5z3veeGTn/xkOPzww6M3WXF5whOeEORSoe8//vGPG2T/+te/IrNXPdDIJPQOd7jDQCCViPKBD3wgfPOb34zM2fUAt5gAALv54aANgfjowV8bgJUU2IVw/fXXL1jWbNy4MTI3TxZtoCYmJiKB5Te/+U20EVYZVHbaTC41F1e7nsXm2re73e2itU6CaFy0/h144IGRiCULKrlTZa2shN1ybdI9V6b8t7nNbYKsBZIldpWSq4TcWJJlcnIy7LPPPpFLgNwLZCWUtZKWXWyBIjdFzWuJJksJAP3OLmt9TX0h4AkgADAmILCTCVxzzTXRg4SKzOtkYujLvvvuG5kcy2RW5oiUFgE9jLz0pS8NesDVWywV+WzLzFNvbmRB8MAHPrANmfyQ5Q6gN2J6M9bvRfETZE3y9Kc/PdpsLPXwB7v5kaDYEze/+c0jKxzFnViJmS/s5tlpc6QNvkonAUCxAfQGepDZddqIrYaN3npLGJWYpQ2bL7HIJReBb3/725lbBjux69QgiaFyAZD5f6VSMYfr7b9EgbPOOis8+9nPbruULM5kuZFGIOxUnx35fRp2scWKXlb88Ic/jMbScgJAv7Pbkf3Eb0FgexBAANgeVLkmBFIQuOCCC8KjH/3oyD9Rb84WK4973OPC1772tciMUUG1KC0CsV/j/e9//yhIoIr8WxWgTUUBn+LNSJKbYgPojYZ8kPU2vJ+LNmTy29QbV/mySxxZ6uEPdvMjQWa98ouWCCCRTm44X/3qVyNTavGTVY7cSpJvVGHXmkWxwLacC4D4fetb3xr4OdtpI7aacaW4FbqvnH/++dF9xhf9/cgjj4ysNCTWZK10YtepPaeffnoUZFfBYf/5z38uHK7YFWvWrIk+y5Ulvp8krydrKllVyQ1AQWazVlbKThY797nPfaI1UCxkLSGXqKUEgEFgl7W+pr4Q8AQQABgTENjJBD74wQ+G4447LvIjlm/dYiU23X784x8fmbVT5gkomJ/M92WGqYexl73sZdHf5fMvP3/5GN94442L4orNGRUUKg4G1a9cX/jCF0Ym7BKRHvvYx0bNXOrhD3bzo0BuI9q86o2XLEgkvCnoVbLIdF1xFGShw7izs0dvDB/xiEdEVk0KAqh5Jv9rrXESVJQ5QbEB4k3WII+7ThuxbtkkN2IKvrhY1gX1RxxzRkKhggJmqXRit1xbZCGmgIgKSilB+NRTT104XJtdiaYqCsS7mOud1lOJ8xJZlFkha2Wl7JQBQVZyumdKcFdZTgAYBHZZ62vqCwFPAAGAMQGBnUxAJujy+5fCLn//xYq+13FZNdPcHogVlflhD3tYFMxPb2cUmTmO4ixXCQUH1MZDUdwXK/EGL+k6sD3qubOvqewR8k990pOeFL7whS8sVGephz/YzSOKH3qVflPuAEp7JaFOmSj0tk+f5TutDYT82HUc7Oxo1xtluZxoDCbLHe94xyio6XOe85yFPw8yu04bsW7ZyFpFa6DKUm4s+rvWQBUdrxR3WSqd2C3XlvhcWfnozbZSy8ZF2VJ0T1bR/FfWCl8UF0D35MXcB7LAcCXsZH2iYLoS8OQyF1s8LScADAK7LPQvdYTAcgQQABgfENjJBBAAuuuAOPifHtr0wBE/xOpq3T4wd1eT3j1LlhHaoMq3NU5jF9cWAWD5flN0dEVJV1HcDY2pZJHvulJJzs7Ohs9+9rPRRpdx1yKk1HN6O6qNk7KXKP6ENkr6u962auMpAUABPAd9znbaiHU7rhAAlp7jCu6p+AfKQKEYCfFmHwGgxUwi+73vfe/o3iELEq13cUEA6N37PjWDwEoIIACshBLHQGA7EsAFID3c2CVCvtiyAIijiMdX6tZkNn1NevsMBa769Kc/HZQuURHWkwUXgOX7TubpsUuJYksoxoQvcslR/nAFA1NgRcbdPCGZTEuQUwDFn//859EmIlnkFiCrnWSQzkFm10kA6JYNLgCLz/HTTjstskBRZh258MiSzJdBMGPvNO7k46+N/rvf/e6gqP7JggtAb9/7qR0EOhFAAOhEiO8hsJ0JxA93epOtB+bFShwE8NWvfnU45ZRTtnONevvyenDTA5z8+2WCKdPE5R7eOgUB7Oe4CmKkHNf+7ZZ4Kbe90kre+ta3jgJgybT9i1/8YhToKfZ9HWR2Ck6nHOEqcaR6P87iVFeKtC4zd9jNE/rc5z4Xnva0py2aWi1mKIsARROXlcXb3/72gWbXaSO2mnGl+8oNN9zQMQhgv/uxx+MuFtxljaKgnvEc93Nba1/s998pCGBW48h0GneKS3TZZZeFww47LIrfkSwKmKh0urpvxJYBcRDeQWDX209J1A4CnQkgAHRmxBEQ2K4E5KOuNFgqpAFcHnW84dKDmTb/ir68WFlN2qzt2tk7+OISAOQGsJISR8GG3TwtBZiUb7AC/yVz1SdZyoT9U5/6VDjqqKOizQTs5unE7hOyzBG7xYqY6e2rAlR+5CMfGWh2nTZiqxlXpAFsjb44Zaw2/7LcUfq/5Uq/p7LrNO5iAWAl9w8dkwyS2u/sVsqE4yDQqwQQAHq1Z6jXQBFQpHFFoj/55JOjgIDJosCASjkmc0W9sV0sGvEgwHr9618fmSJ22vzHLGTyrowJihWggH/JojcXSmWk9EaXX355lElg0MpyD3+wmx8NcSo7ZQBQCs5kUWAwjRuJdtrwanyqwC5EMRGe+cxnhpGRkbB+/fq2NUvsDjjggMiyImlePKjsOm3EVjOuzjjjjChgpVwytNYl01Y2Go1w4IEHRsEszzzzzHDsscdmbhlcCTs1Su170YteFMWhWMnmX+fEgvMRRxwRCc7JoowJEu7l7nLhhRdGgVazVlbKbrF2LecCMAjsstbX1BcCngACAGMCAj1AQG/C9EZsfHw8XHTRRQtpmZS/WSnIZAIq03cF0xrEcuKJJ0ZmwnqjLVPrpd78J9nozaNMM/XAe8EFFyz4ecrvWCkCFTvg6KOPDuedd94gIl0yDaBgwG5+SGiM6OFfsSbkEnDooYdGf1dwLAWykznxxMREFNBur732ir6DXYhSou23336R+8kxxxwTzjrrrGhtU9HbbLHT21hlTpAryv777z/Q7FayEet2XGm909tYBQSM3S3iBS/OLrPPPvtEIoAEm6yVlbCTACxxQ+NtpZt/cRAzsRPDj33sY+H5z39+hEfCseKrnH322dG96JJLLgm5XC5r6Ja9B3RqTCcBoN/ZdeLD9xDodQIIAL3eQ9RvYAjEge30kHL44YdH+Zi1AdEbBvlw6w1EFh/QVtuB559/fjjyyCOjy2hDf9BBBy16SfmweoFEeYu12dDDmYK47bnnnlEqI72VlN+irCt03iCWTg/OsJsfFbLKOemkk6Jo9rLUkc+rNmPygdV8lJWJ9yOGXQjnnHNOtEmSWLLHHntEGyWtbUrXec0110TCnEQAuQAkyyCw0/h58YtfvNDsK6+8Mor/oo14nLZPXyrPfDItX7dslHlB6erivPfKDKL0bvpP9xlFwY/FrV5fC9OyU/T6Qw45JDJPl8WOD0iZbK8Cpvqi+a0sINr061zFTJG1nix/JPrpHiJrliyUtOyWa1MnAUDn9hO7LPQvdYRAGgIIAGlocSwEtjOBc889N3oo1kOLzGRlpq5gWscff/xCjvvtXIWeu7weyrSR6FRiH3Z/nB5uTz311Ch3u95I7rvvvkGB/0444YTo7e2glk4CgLjAbn50yOrk9NNPj970KbK6RACJdK973euWdB+BXYgCiInbxRdfHG36tQnThlZBxY477rhIUFms9Ds7BUuTZVenctVVV0UbzmTpls0VV1wRlPpO58tCQ6KMrFuUCk/3mayUtOxWerzan/RhT/K49NJLg9L1SjxWTBWNYcUPkDAYW/5kgd9KWSw27nz7ViIA6Jx+YZeF/qWOEEhDAAEgDS2OhQAEIAABCEAAAhCAAAQgAAEIZJQAAkBGO45qQwACEIAABCAAAQhAAAIQgAAE0hBAAEhDi2MhAAEIQAACEIAABCAAAQhAAAIZJYAAkNGOo9oQgAAEIAABCEAAAhCAAAQgAIE0BBAA0tDiWAhAAAIQgAAEIAABCEAAAhCAQEYJIABktOOoNgQgAAEIQAACEIAABCAAAQhAIA0BBIA0tDgWAhCAAAQgAAEIQAACEIAABCCQUQIIABntOKoNAQhAAAIQgAAEIAABCEAAAhBIQwABIA0tjoUABCAAAQhAAAIQgAAEIAABCGSUAAJARjuOakMAAhCAAAQgAAEIQAACEIAABNIQQABIQ4tjIQABCEAAAhCAAAQgAAEIQAACGSWAAJDRjqPaEIAABCAAAQhAAAIQgAAEIACBNAQQANLQ4lgIQAACEIAABCAAAQhAAAIQgEBGCSAAZLTjqDYEIAABCEAAAhCAAAQgAAEIQCANAQSANLQ4FgIQgAAEIAABCEAAAhCAAAQgkFECCAAZ7TiqDQEIQAACEIAABCAAAQhAAAIQSEMAASANLY6FAAQgAAEIQAACEIAABCAAAQhklAACQEY7jmpDAAIQgAAEIAABCEAAAhCAAATSEEAASEOLYyEAAQhAAAIQgAAEIAABCEAAAhklgACQ0Y6j2hCAAAQgAAEIQAACEIAABCAAgTQEEADS0OJYCEAAAhCAAAQgAAEIQAACEIBARgkgAGS046g2BCAAAQhAAAIQgAAEIAABCEAgDQEEgDS0OBYCEIAABCAAAQhAAAIQgAAEIJBRAggAGe04qg0BCEAAAhCAAAQgAAEIQAACEEhDAAEgDS2OhQAEIAABCEAAAhCAAAQgAAEIZJQAAkBGO45qQwACEIAABCAAAQhAAAIQgAAE0hBAAEhDi2MhAAEIQAACEIAABCAAAQhAAAIZJYAAkNGOo9oQgAAEIAABCEAAAhCAAAQgAIE0BBAA0tDiWAhAAAIQgAAEIAABCEAAAhCAQEYJIABktOOoNgQgAAEIQAACEIAABCAAAQhAIA0BBIA0tDgWAhCAAAQgAAEIQAACEIAABCCQUQIIABntOKoNAQhAAAIQgAAEIAABCEAAAhBIQwABIA0tjoUABCAAAQhAAAIQgAAEIAABCGSUAAJARjuOakMAAhCAAAQgAAEIQAACEIAABNIQQABIQ4tjIQABCEAAAhCAAAQgAAEIQAACGSWAAJDRjqPaEIAABCAAAQhAAAIQgAAEIACBNAQQANLQ4lgIQAACEIAABCAAAQhAAAIQgEBGCSAAZLTjqDYEIAABCEAAAhCAAAQgAAEIQCANAQSANLQ4FgIQgAAEIAABCEAAAhCAAAQgkFECCAAZ7TiqDQEIQAACEIAABCAAAQhAAAIQSEMAASANLY6FAAQgAAEIQAACEIAABCAAAQhklAACQEY7jmpDAAIQgAAEIAABCEAAAhCAAATSEEAASEOLYyEAAQhAAAIQgAAEIAABCEAAAhklgACQ0Y6j2hCAAAQgAAEIQAACEIAABCAAgTQEEADS0OJYCEAAAhCAAAQgAAEIQAACEIBARgkgAGS046g2BCAAAQhAAAIQgAAEIAABCEAgDQEEgDS0OBYCEIAABCAAAQhAAAIQgAAEIJBRAggAGe04qg0BCEAAAhCAAAQgAAEIQAACEEhDAAEgDS2OhQAEIAABCEAAAhCAAAQgAAEIZJQAAkBGO45qQwACEIAABCAAAQhAAAIQgAAE0hBAAEhDi2MhAAEIQAACEIAABCAAAQhAAAIZJYAAkNGOo9oQgAAEIAABCEAAAhCAAAQgAIE0BBAA0tDiWAhAAAIQgAAEIAABCEAAAhCAQEYJ/A/uixGz3LcpBAAAAABJRU5ErkJggg==\" width=\"639.999990463257\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "volume = np.transpose(volume, (1, 0, 2))\n",
    "S = st3d.structure_tensor(volume, sigma, rho)\n",
    "val,vec = st3d.eig_special(S)\n",
    "coloring_z = lambda v : st3d.fan_coloring(v[[2, 0, 1]]) # rotating the coloring function\n",
    "st3d.show_vol_orientation(volume, vec, coloring = coloring_z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Investigating tensor-vector distance\n",
    "A tensor-vector distance can be computed for every voxel. Here I compute the distance from the z-direction. In the rotated volume, a 90 deg. bundle (the middle layer) is aligned with z-direction, and has the smallest distance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",