Mixture Models.ipynb

       "// 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",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\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(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\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(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\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",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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",
       "        }\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",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\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",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\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, 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",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "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 = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n",
       "        '<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 / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<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 () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('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",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\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",
       "\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",
       "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(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAPoCAYAAABNo9TkAAAgAElEQVR4nOzdeVhU9f4H8KOAgmCm3swd2QTNXNJcqhs3S7PUW13T6pZLZtlytazfNVu1zKUuoOCGK6apoCJqbigIuGaU+74bKosgIDvD+b5/f8CMDLMwAzPOGef9ep7zlMOZM+cc5Xw+7znnfI8EIiIiIiIiIrI5ydYrQEREREREREQM6ERERERERESKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6EREREREREQKwIBOREREREREpAAM6CY4duwYRo8eDW9vb7i6usLV1RW+vr547733kJycbOvVuyeuXLkCSZIQERFh61W5r02ePBmSdO9/Lbt27YqWLVuirKzM4DxPPPEEmjZtipKSklp/XkJCAiRJQkJCgtnvPXXqFCZPnowrV67o/GzkyJHw9PSs9frVhCRJ+Oijj2r8/q+++gpt2rSBk5MTGjVqZME1s1+//vor/vnPf6JFixZwcXGBh4cHunbtim+//RbXrl3TmjcwMBCSJMHLywtCCJ1lJSUlQZIkneNYRESE5nV9/x6FEPDx8YEkSQgMDLTwFhKZR/1vtbqpJsdWKhcYGFjj3/V58+bp7ZPYQxGRORjQqxEeHg5nZ2c88sgjCA0NRVxcHOLj4zF37lw8+eSTkCQJFy9etPVqWh2Ly72RkpKCgwcP3vPPnTNnDiRJwtatW/X+/Ny5c5AkCZ988olFPi83NxcHDx5Ebm6u2e9dt26dwQb04sWLOHz4sAXW0Hy1CegbN26EJEn46quvsG/fPof54s8QWZYxYsQISJKEF154AcuXL0diYiK2b9+O77//Hl5eXmjdurXWewIDA9GwYUNIkoS4uDidZY4cORIPPPCAwYDesGFDvPXWWzrvU3+Z1LBhQwZ0srmDBw9qTS+++CLc3Nx0Xq/JsZXKnTp1CqdOnarRex955BG9x4ni4mIcPHgQGRkZtVw7InIEDOhG7Nu3D3Xr1sXgwYMNnjVcu3Ytbty4cY/X7N6zt4AuhEBhYaGtV8Nu3L59G66urhgyZIjen3/++eeQJAnHjx+v1eeUlpZCpVLVahnGArot1Sag//DDD5AkCenp6RZbn4KCAost616bPn06JEnCjBkz9P5cpVJh7ty5Wq8FBgbikUceQe/evfHvf/9b62d37txBgwYN8O677xoM6GPGjIGbm5tOsHnrrbfQp08fg403kS2NHDkS7u7u1c5nz8cDe8LjBBFZAgO6ES+++CJcXFxw8+ZNk99j6NIofZfelpSUYOrUqfD390e9evXwt7/9DaNGjdL5hjU+Ph6BgYFo0qQJXF1d0aZNG/zrX//SKrjz589H586d4e7uDg8PD/j7++OLL77QWk5qairee+89tGrVCi4uLmjXrh2mTJmiE5hu3LiBoUOHwsPDAw888ACGDRuGgwcPmhTQCwoK8Nlnn6Fdu3aoX78+GjdujO7du2P16tVa823atAm9e/eGm5sbPDw88Nxzz+HAgQPV7jNA/2Xg6nC0YMECBAQEwMXFBQsWLAAAnDlzBq+//jqaNWuGevXqoU2bNhg+fDiKi4vN3jf6SJKEyZMn67zu6emJkSNHmrVv9G2bp6cnBg4ciO3bt6Nbt25wdXWFv78/li5dqvOZe/fuRe/evVG/fn20bNkSX3/9NRYvXgxJkvReEl7ZG2+8gXr16iEzM1Pr9bKyMrRs2RKPP/44AODChQsYNWoUfH194ebmhpYtW2LQoEE64V195nHFihX49NNP0bJlS9SpUwdnzpzRe4l7cnIyXnvtNXh6esLV1RWenp54/fXXcfXqVc08lS9Hrjyp/13q+zdTVFSESZMmoV27dnBxcUHLli3x4YcfIjs7u8b7WZ+qAV29jatXr8aXX36JFi1aoGHDhnj22Wdx9uxZrc+tuj2V/z1FRkaid+/eaNCgAdzd3dG/f3+dqwTUTfrx48fRr18/eHh4oHfv3gBMP86Ys/3Xr1/Hu+++i9atW8PFxQUtWrTAkCFDkJaWppknNzdX8+9dvd8//vhj5OfnG92PJSUlePDBB9GpU6fqd3ol6oC+aNEiuLq6av39Llq0CA0aNEB8fLzBgB4fHw83NzeEh4drfpaTkwM3NzcsXryYjTcpkr6Arv5dSEpKQp8+feDm5obXXnsNgOn1CqhdXYyMjES/fv3QvHlzuLq6IiAgAJ9//rnO7/+lS5fw2muvoUWLFqhXrx6aNWuGvn374siRI5p5TOmBsrKy8MEHH6Bly5ZwcXGBl5cXvvzyS606D5RfnRMWFoYuXbrA1dUVjRo1Qq9evbBp0yat/Vf1d33KlCno2bMnGjdujIYNG6Jbt25YsmSJ1u00+o7l6npk6CTH3r170bdvX3h4eMDNzQ19+vTBli1btOZRH6N2796N999/H02bNkWTJk3wyiuvOMQJIiJHxIBuQFlZmeZgaQ5TA7osyxgwYADc3d3x3XffYdeuXViyZAlatWqFjh07as7+XrlyBa6urujXrx82btyIxMRErFq1CsOHD9c0oGvWrIEkSRg3bhx27tyJuLg4hIeHY/z48ZrPS01NRZs2beDp6YmFCxciLi4OU6dORf369TFq1CjNfIWFhejQoQMaNWqEOXPmIDY2FuPHj0fbtm1NCuhjx45FgwYNEBISgoSEBGzZsgUzZ87EnDlzNPOsWrUKkiShf//+2LhxI6KiotC9e3fUq1cPe/fuNbjP1AwF9FatWqFz585YvXo1du/ejZMnT+Lo0aPw8PBAu3btEB4ejvj4ePzyyy8YNmwY7ty5Y9a+McTUhseUfWMooLdu3RodO3bEihUrEBsbi6FDh0KSJCQlJWnmO3bsGFxdXdG5c2dERkZi8+bNePHFF9GuXTuTAnpcXBwkScLs2bO1Xt+6dSskSdIEl6SkJHz22WdYv349kpKSEBMTg5dffhlubm5awVMdUFu1aoVXX30VmzdvxpYtW5CVlaU3oK9btw7ffvstYmJikJSUhMjISAQGBuKhhx7CrVu3AAAZGRmas6vz5s3TXM6pDptV/80IIfD888/D2dkZ33zzDXbu3ImgoCC4u7ujW7duWs2bqfvZEEMBvV27dnjzzTexdetWrFmzBm3btoWfn5/mfv/Dhw/jnXfegSRJ2LFjBw4ePIiUlBQAwLRp01CnTh2MHj0aW7ZswYYNG9CnTx+4u7trXYI5cuRITQM9Y8YMxMfHIzY21uTjjDnbf/36dbRo0QJ/+9vfEBISgri4OERFRWH06NE4c+YMgPIvo7p27ao1T2hoKBo1aoS+ffvqvUdcbf/+/ZAkSecLxuqoQ8mdO3fg7u6O+fPna37Wq1cvjBgxAsnJyQYDenJyMoYPH46ePXtqfrZgwQK4u7vjzp07DOikSIYCepMmTdCmTRvMmTMHCQkJmt9hU+tVbevi1KlTMWvWLGzduhWJiYkIDw+Hl5cXnnnmGa35/P394evri5UrVyIpKQnR0dH47LPPNLXBlB6oqKhIc4IiKCgIO3fuxDfffANnZ2e8+OKLWp83fPhw1KlTB2PGjMGmTZuwfft2TJs2DaGhoVr7r+rv+qhRo7B06VLs2rULu3btwtSpU+Hm5obvvvtOM8/hw4fh7e2Nbt26aWqT+stUfQE9MTERLi4u6N69O6KiorBx40b0798fderUQWRkpGY+9THK29sb48aNQ2xsLJYsWYLGjRvr7E8iuj8woBuQlpYGSZLw+uuv6/ysrKwMKpVKM1VuNk0N6OpQHR0drTWfuoFUN5fr16+HJEk4evSowXX9z3/+gwcffNDo9owdOxYeHh46AysFBQVBkiRNs79gwQJIkqT1bTIAvZeG6tOpUye8/PLLBn8uyzJatmyJRx99FLIsa17Py8tDs2bN8MQTT2heMzegN2rUCLdv39Z6vW/fvnjwwQeN3vdl6r4xxNSGp7p9AxgO6K6urlrrV1RUhCZNmmDs2LGa14YOHQp3d3dNmAXK93fHjh1NCuhCCHh5eaFz585arw8ZMgQNGjQweE9jWVkZSktL4efnhwkTJmheVwfUp59+Wuc9pgwSV1ZWhvz8fLi7u2s1T8Yuca/6b2bHjh2QJAk//fST1nxRUVGQJAmLFi3SvGbqfjbEUECv2iCuXbsWkiRpjTWg/nuv/Hf3119/wdnZGePGjdN6f15eHpo3b45hw4ZpbbckSVi2bJnWvKYeZ8zZ/tGjR8PFxQWnT582uC9mzJiBunXr6txLrz6ebdu2zeB7IyMjtb4QqqzycbfqWTx1QAfK90ePHj0AlN9PKkkSEhMTqw3o6r+zkydPAgAef/xxTRhhQCclMhTQ1VeFVGXOF8q1qYuVCSGgUqk0AzUeO3YMAJCZman3S+HKTOmBwsPDIUkS1q5dq/X6jz/+CEmSsHPnTgDAnj17NGN9GFPdIHGyLEOlUuH7779H06ZNtXpAQ8cJfQG9d+/eaNasGfLy8jSvlZWVoVOnTmjdurVmuepj1Icffqi1zJ9++gmSJCE1NdXo9hCR/WFAN8BYQO/SpYvWJUz/+9//ND8zNaC/+eabePDBBzX35FaeKjffFy9eRL169dCzZ08sX74cly5d0ln2ihUrNOu6ceNGrSZfrVWrVhg8eLDOZ6mbV3WjPmzYMDRs2FDn/erGtbqAPnr0aNSvXx+ff/45EhISdO4DP336tN7ABAAffPAB6tatq7lszdyA/sorr2i9VlBQACcnJ7z33ntG19nUfWOIqQ1PdfvG0LZ5enpqLleurHfv3hgwYIDmz82aNcPgwYN15psyZYpJAR0Avv/+e0iShD/++ANAeQNVr149DB8+XDOPSqXCtGnT0KFDB7i4uGj9LlReH/W/mcrhuurPKofsvLw8TJw4ET4+PnByctJa7vvvv6+Zz5yAPnHiREiSpPMFjRAC7u7umss+AdP3syGGAnrVoHn27FlIkqR1hkRfQFffmpCcnKzzb/O1115Ds2bNtLZbkiSdL1FMPc6Ys/0tWrRA//79je6LJ598Ep07d9b5zLy8PNSpUwcTJ040+F5DAT07O1vn8tHKXwBUDujqIHD8+HF8+umn8PHxgRCi2oCuHrH9008/xfHjxyFJEvbs2QOAAZ2UyVBAb9y4sd75Ta1Xta2Lly5dwhtvvIGHH34YderU0fq9VR/71L9vrVq1QnBwMA4fPqz1xT1gWg80bNgwuLu761yZk56eDkmS8PnnnwMAvvjiC0iSVO1ti/r6uPj4eDz77LOagSYrT5Vv7TE1oOfn56NOnTo6oRu4+8WC+ook9TFqx44dWvOpv4D+7bffjG4PEdkfBnQDjF3ifurUKSQnJ2Pz5s01DujPPfeczkG+8tS3b1/NvHv27MGgQYPg7u6uucyp6jfOy5YtQ58+feDk5IQ6deqgZ8+emm+NAcDZ2dno533//fcAgGeffRa+vr4663/mzBmTAnp+fj6+/fZb+Pv7Q5IkuLq64qWXXsL58+cBlN9vJUkSVq5cqfPeqVOnQpIkXL9+Xe8+UzMU0KsWuuvXr2ttmyGm7htDTG14qts3hrZNfW9wVVX/rTk5OWHMmDE686mvijAloKekpKBu3bqaoBkaGqo5+6g2btw41K1bF1988QV27NiBQ4cOITk5GV26dNFaH3VArXpWo/LPKofswYMHo0GDBpgxYwbi4uLw+++/Izk5GQ899JDWfjQnoL/zzjtwdnbWu60+Pj547rnnNH82dT8bYiigr1u3Tms+fWdS9AV09cBxhqa6detqbXeDBg101smc44yp2+/s7IzRo0cb3Re+vr5GP9fY+w8cOABJ0r3EvaysDMnJyUhOTtbsL0MBHQD8/Pzw0Ucf4aGHHsK0adMAoNqADpTv92bNmuHDDz9E+/btNfMxoJMSGQroHTt21Du/qfWqNnUxLy8PLVu2hLe3NxYvXoykpCQkJydjw4YNOr9/V69exejRo/Hwww9DkiQ0adIE48aN09yCBlTfAz377LPw8fHRuy7Ozs6aujhmzBg4OTkZvcUG0D3mHTp0CE5OTnj22WcRFRWF/fv3Izk5GV999ZVObTU1oKekpECSJEydOlVn3pUrV0KSJOzbtw+A7jFKrTaPKyUiZWNAN2LgwIFGB4lTH3ArB/Tnn39e71mogQMHagWH119/HU2bNtU0nFWnyvfyqpWVleG3337Dm2++CUmSsGbNGp158vPzsW3bNjz++OOoV6+eZoCt5s2bo3///gY/Tz3QSG3PoFeWlpaGiIgIPPzww/D39wdg3hn0sWPHonnz5jrzffTRR3oDetURtAsLC006g27qvjGkfv36mDRpks7rHh4eOoPuqOnbN0DtArqhM+jqZZoS0AFgwIABaNy4MYqLi9G1a1f4+vpqNTSNGzfWew9iq1at9Ab0qgG18s/UjUVOTg7q1KmDKVOmaM1XXFwMJyenGgf06s6gV75CRmkBXX3Z5vr16w3+26y83fpGcjbnOGPq9ptyBr1379549NFHDX6usX+LJSUlaNy4sdFB4vQ1rFUD+vTp01G3bl04OTlpvvQzJaBfv34ddevWRd26dbVGkWdAJyUyNkicPqbWq9rUxU2bNul8sQsAu3btMtpHnDt3DlOnToWTk5Pe24oM9UDDhg2Dh4eHwTPo6u2t6Rn0CRMmwNXVFUVFRVrz1Sag5+fno27dukbPoKuPzwzoRI6HAd0I9WPW/vnPf6K0tFTn5/oC+tixY9GkSROtwacyMzPRuHFjreDwyy+/1PjSpJycHEiShP/+978G51E/V1n9XOsxY8agZcuWOvdoV1Xbe9D1+eSTTyBJEgoKCiDLMlq1aoWuXbtqFdP8/Hw0a9YMTz75pOY19X2slS8fKykp0Zydq0xfQAfK70Fv3Lix3sv+1UzdN4b4+/vr3GesHi3aUEBXq7xvgNoF9Nreg66mDsDqcKs++6im757sLVu2QJKkGgf03NxcSJLuY7Xmzp2rsx/VV67ou4+5akCPjY2FJEkICQnRu42LFy/WvKa0gH7lyhU4Ozvjxx9/rPazDQV0c44zpm6/+h50fV8iqv3www9o0KABLl++XO3n6qMeCHDmzJl6f25KQL9x4wZeeuklrTBiSkAHyh8r+NJLL2k18gzopETmBnRT61Vt6qL6GF15nA0AePXVV03qI7p27ap5aog+VXughQsXQpIkbNiwQWu+//3vf5AkCbt27QJw9x70b775xujnVz3mffrpp/Dw8NDqAwsLCzWD51aurY899pjWQJNq+o77ffr0QfPmzbVud5NlGY8++qjee9AZ0IkcBwN6NRYsWABnZ2d06tQJYWFhiI+PR0JCAlavXo0hQ4ZAkiQsXLhQM/++ffsgSRJeffVVxMbGYvXq1ejatSs8PT21gkNZWRleeOEFNGnSBN999x22b9+OuLg4LF++HCNHjtQUmgULFmDo0KFYvnw5du/ejW3btmmKXGxsLIDyQjpu3DhERkYiKSkJUVFR6Nq1Kxo1aqQ5c3jz5k14enoiICAA8+fPR3x8PLZu3Yp58+Zh4MCBmlGjCwoK0L59ezRq1Ahz585FbGwsPv74Y5NHce/Zsye+//57bNy4EUlJSQgPD0fTpk21bhVQj+L+4osvYtOmTVi7dq3mjH/lUdwvX74MFxcX/OMf/8DWrVsRHR2NwMBAeHl5mRzQ1aO4e3t7Y9GiRdi9ezfWrFmDN954Q3MJnan7xpAffvgBderUwTfffIO4uDiEhYVp9mHlhseUfVObgH706FHNKO5RUVGaUdzVj36pOtiPISUlJfjb3/6GOnXqaJ19VBsxYgTq16+PWbNmIT4+Hj/99BMeeughtG7dusYBHQCefvppNGnSBIsXL8auXbvw9ddfo0WLFnjwwQe19uPly5chSRJefvll7N27F8nJyZpHwxkaxd3FxQVTpkzBrl27EBwcDA8PD72juCspoAPlQdXZ2Rljx45FTEwMEhMTERUVhc8++wzffvutZj5DAd3U44w5268exb1Zs2aYPXs24uPjER0djXfffVdzz2R+fj66deuG1q1bIzg4GLt27UJsbCwWL16MoUOHVvuFgSzLGDFihOY48fPPPyMpKQk7d+5EeHg4evToAScnJ62BqoyFEjVTA7o+DOikROYGdFPrVW3qovqkRJcuXbBhwwb8+uuveP311+Hn56f1+3fs2DH8/e9/R1hYGLZv3474+Hh89dVXqFu3Lr788ksApvVA6lHcGzZsiJCQEOzatQuTJ0+Gi4uLwVHc33vvPWzevBmxsbGYOXMmwsLCtPZf5d919RcYr776Knbu3Ik1a9age/fumu2pHNBHjhyJ+vXrIzIyEr///rvm8aPGRnHv1asX1q1bh02bNuH55583OIo7AzqR42BAN8HRo0fx9ttvw8vLC/Xr14erqyt8fX0xYsQIvaOk/vzzz+jQoQNcXV3RsWNHREVF6b2fWqVSISgoSPM8Tg8PDwQEBGDs2LG4cOECAODgwYN45ZVX4Onpifr166Np06YIDAzE5s2btT7vmWeewcMPP4x69eqhZcuWGDZsmM5zqW/duoXx48fDy8sLLi4uaNKkCbp3746vvvpK69mk169fx5AhQ+Dh4YGGDRtiyJAhmvtCqwvokyZNQo8ePdC4cWPUr18f3t7emDBhgs6ztTdu3IhevXrB1dUV7u7uePbZZ7F//36d5W3btg1du3aFm5sbvL29MXfuXKPPQdfn9OnTGDp0KJo2bYp69eqhbdu2GDVqlFY4M3Xf6FNSUoKJEyeiTZs2cHNzQ2BgII4ePapzT58p+6Y2AR0ov8e/V69eqF+/Ppo3b47//ve/msvlcnJyjG5HZRMmTNCEo6qys7PxzjvvoFmzZmjQoAGeeuop7N27V2d9zA3o6n936ufMDhgwACdPntTZjwAwe/ZseHl5aQaTq+456J9//jk8PT01z+z+4IMPDD4HvSpbBnSg/HflmWeewQMPPID69evD09MTr776KuLi4jTzGArogGnHGXO3PyUlBaNHj0bz5s01zzgfNmwY0tPTNfPk5+fj66+/1jx/vVGjRnj00UcxYcIEratijNm8eTMGDx6Mhx9+GM7OzmjYsCG6du2Kzz77TOcMPgM6OSJzA7qp9QqoXV08cOAA+vTpgwYNGuChhx7CmDFjcPjwYa3fv/T0dIwaNQoBAQFwd3eHh4cHOnfujFmzZmkeQ2lKDwSUPwf9/fffR4sWLeDs7AxPT0988cUXep+DPmvWLHTq1ElzXOrTpw9+/fVXrf1X9Xd92bJl8Pf319TuGTNmYOnSpToB/erVq+jfvz8aNmwISTL9Oeju7u5wc3ND7969tdYFYEAnckQM6ET3uX79+sHPz8/Wq0FERERERNVgQCe6j0yYMAErVqxAQkICoqOj8a9//QuSJGHp0qW2XjUiIiIiIqoGAzrRfWT8+PFo164dXF1d4ebmhu7du+t9pB0RERERESkPAzoRERERERGRAjCgExERWdH06dPRo0cPeHh44KGHHsJLL71k9DF1aomJiXjsscdQv359eHl5YcGCBTrzrF+/Hh06dEC9evXQoUMHnUdNERERVcW6pGwM6ERERFb0/PPPIyIiAidPnsTRo0cxcOBAtG3b1uhI2JcvX0aDBg3w8ccf4/Tp01i8eDFcXFywfv16zTwHDhyAk5MTpk+fjjNnzmgey2fKc++JiMhxsS4pGwM6ERHRPZSRkQFJkpYNzQ0AACAASURBVJCUlGRwnokTJyIgIEDrtbFjx6J3796aPw8bNgwDBgzQmuf555/H66+/btkVJiKi+xrrkrIwoDsYWZaRkpKCnJwc5ObmcuLEiZPFp5ycHKSkpECW5Vodr4qKimy+Lca2seprVZ+5bMiFCxcgSRJOnDhhcJ6///3vGD9+vNZrGzZsgLOzM0pLSwEAbdq0QUhIiNY8ISEhaNu2rZl72vZYmzhx4mTtibXJMNYlZWFAdzApKSmQJIkTJ06crD6lpKTU+FhVVFSE5s2cbL4NhiYPDw+d1yZPnlztdgkhMHjwYDz11FNG5/Pz88O0adO0Xtu/fz8kScLNmzcBAC4uLli1apXWPKtWrUK9evXM29kKwNrEiROnezWxNmljXVIeBnQHk5OTozk42fpbPk6cON2fkzps5eTk1PhYlZubC0mScO3Pdsg+762o6dqf7fQeR005S/Hhhx/C09Oz2gbRz88P06dP13pt3759kCQJqampAMobodWrV2vN88svv6B+/fpm7m3bY23ixImTtSfWJv1Yl5SHAd3BqA8subm5tl4VIrpPWeI4o15G9nlvyKl+ipqyz3vXaPv+85//oHXr1rh8+XK18zrapYSsTURkbaxNuliXlIkB3cGwCSIia2MTpE0IgY8++ggtW7bE+fPnTXrPxIkT0aFDB63X3n//fZ3BeF544QWteQYMGGCXg/GwNhGRtbE23cW6pGwM6A6GTRARWZslm6Cs815Qpfooaso672XW9n3wwQdo1KgREhMTkZqaqpkKCws180yaNAnDhw/X/Fn9OJsJEybg9OnTWLp0qc7jbPbv3w8nJyfMnDkTZ86cwcyZM+32cTasTURkbaxNd7EuKRsDuoNhE0RE1sYmSJuhwXwiIiI084wcORKBgYFa70tMTES3bt1Qr149tGvXDgsWLNBZ9rp16+Dv7w8XFxcEBAQgOjq6xvvcllibiMjaWJvuYl1SNgZ0B8MmiIisjU0QmYu1iYisjbWJ7AUDuoNhE0RE1mbJJijjnCeKb3opaso458njqIWxNhGRtbE2kb1gQHcwbIKIyNrYBJG5WJuIyNpYm8heMKA7GDZBRGRtbILIXKxNRGRtrE1kLxjQHQybICKyNks2QWnn2qLwZjtFTWnn2vI4amGsTURkbaxNZC8Y0B0MmyAisjY2QWQu1iYisjbWJrIXDOgOhk0QEVkbmyAyF2sTEVkbaxPZCwZ0B8MmiIiszZJN0M1zrZF/s62ippvnWvM4amGsTURkbaxNZC8Y0B0MmyAisjY2QWQu1iYisjbWJrIXDOgOhk0QEVkbmyAyF2sTEVkbaxPZCwZ0B8MmiIiszZJNUMrZVsi90UZRU8rZVjyOWhhrExFZG2sT2QsGdAfDJoiIrI1NEJmLtYmIrI21iewFA7qDYRNERNbGJojMxdpERNbG2kT2ggHdwbAJIiJrs2QTdO1sS2TfaK2o6drZljyOWhhrExFZG2sT2QsGdAfDJoiIrI1NEJmLtYmIrI21iewFA7qDYRNERNbGJojMxdpERNbG2kT2ggHdwbAJIiJrs2QTdOVsC2TeaKWo6crZFjyOWhhrExFZG2sT2QsGdAfDJoiIrI1NEJmLtYmIrI21iewFA7qDYRNERNbGJojMxdpERNbG2kT2ggHdwbAJIiJrs2QTdOlsc2TcaKmo6dLZ5jyOWhhrExFZG2sT2QsGdAfDJoiIrI1NEJmLtYmIrI21iewFA7qDYRNERNbGJojMxdpERNbG2kT2ggHdwbAJIiJrs2QTdP7Mw0i93kJR0/kzD/M4amGsTURkbaxNZC8Y0B0MmyAisjY2QWQu1iYisjbWJrIXDOgOhk0QEVkbmyAyF2sTEVkbaxPZCwZ0B8MmiMh0Qs6DyFsIOXMo5MzXIPIjIEShrVdL8SzZBJ098zBuXG+hqOksmyCLY20iMt2V7NuYnBCHQatX4O2N0dhx8TyEELZeLcVjbSJ7wYDuYNgEEZlGyHcg33oBcqo/5FS/iqk95FtDIESRrVdP0dgEkblYm4hMczw9DR3nzYZvWDC8QoPgU/HfmfuSbL1qisfaRPaCAd3BsAkiMo3Im1clnN8N6SJ/pa1XT9HYBJG5WJuITDNk7WpNKK86XbqdZevVUzTWJrIXDOgOhk0QkWnkW//UE84rzqJnjbD16imaJZugU2ea4a/rzRU1nTrTjMdRC2NtIqpeTlGR3mCuPpO+8I/fbb2KisbaRPaCAd3BsAkiMg0Des2xCSJzsTYRVY8BvXZYm8heMKA7GDZBRKbhJe41xyaIzMXaRGQaXuJec6xNZC8Y0B0MmyAi08jFByCn9dI9e85B4qplySbo+OlmuJLSXFHT8dNsgiyNtYmoeipZxsI/foffnBB4VzpzzkHiTMPaRPaCAd3BsAkiMk4IGXLOlxWB3L88lKf6QU57AnLeMj5mzQRsgshcrE1Ext0uLMSAX5bDKzRIM4K7V2gQBq5agVg+Zs0krE1kLxjQHQybICLjROEmA/ee+0EU7bD16tkFNkFkLtYmIuM+jd2mFcy9QoPgHRqE9nNCcKugwNarZxdYm8heMKA7GDZBRMbJWcMN3HvuDznrXQg5GyL/Z8i5MyAK1kPIbIyqsmQTdPR0M1xKaa6o6SibIItjbSIyrFilgt+cEL33nXuHBuHno4dx6XYWQn87gBn7kpB09QpknlHXwdpE9oIB3cGwCSIyTr41yOAZdDnjBchpXSoue+9Q/lr6ExCqK7ZebUVhE0TmYm0iMiy7qNDg6O2+YcEYEbNO8//qIP/mhrUoVqlsveqKwtpE9oIB3cGwCSIyTs79HnJqgP4z6KmP6jm7HgD51hBbr7aisAkic7E2ERkmhEDg8sWageFMmXzCgjHr4H5br7qisDaRvWBAdzBsgoiME6q/IKd1qxLSAyrOnBs4s57qB6G6autVVwxLNkGHTz+M8yktFDUdPv0wj6MWxtpEZNyWc2c1l7RXDuG9liyAb6j+x671WRpu69VWFNYmshcM6A6GTRBR9UTpOchZ71Rcyt4ecta7kPMWGw/opcdsvdqKwSaIzMXaRFS9bRfOod/KCHiFBqHjvNmYkhiPT3Zs0Rk8Tj09Mj/U1qusKKxNZC8Y0B0MmyAi0wlRAiFKy/9fde3uI9eqTmld+Pi1StgEkblYm4hMV6xSaQaBW3PimMF700fGrLfxmioLaxPZCwZ0B8MmiKjm5Jwv9IZ0kbfI1qumKJZsgv449TDO/tVCUdMfp9gEWRprE1HNFJaW4h/Ll2idRfepGCzu8M0btl49RWFtInvBgG4jnp6ekCRJZ/rwww/1zp+QkKB3/jNnzpj1uWyCiGpOCBVE3lzIaT0rRnAPhChYA8HH2WhhE2S/WJuI7E9GQT4+i92G9nNmwSs0CK+uXY1D11NsvVqKw9pE9oIB3UYyMjKQmpqqmXbt2gVJkpCQkKB3fnUTdO7cOa33lZWVmfW5bIKIak8IUXH5O4O5PmyC7BdrE5H9KpNllJr5u+dIWJvIXjCgK8THH38MHx8fgw2/ugnKzs6u1eewCSIia7NkE3ToVHOc+quloqZDp5o7zHGUtYmI7hesTWQvGNAVoKSkBE2bNsW0adMMzqNugtq1a4fmzZujb9++2L17t9mfxSaIyDxyyWHI2RMhZ42AnDsNQnXN1qukeGyC7g+sTUTKJAuBmDOn8N7mGIyIWYfFfyYjt7jY1quleKxNZC8Y0BUgKioKTk5OuHHD8GAeZ8+exaJFi/Dnn3/iwIED+OCDD1CnTh0kJSUZXXZxcTFyc3M1U0pKCn95iUwgyq5DvvVylQHh/CGndoIo+d3Wq6dobILuD6xNRMqz99pVdAufqzNq+z+WL0FWYYGtV0/RWJvIXjCgK0D//v0xaNAgs983aNAgDB482Og8kydP1juAD395iQwTcjbk9D4GnnneHnJGP95/boQlm6ADp1rg+F+tFDUdONXCIY6jrE1EynLoegp8DDzz3Cc0CN8lmX/1iiNhbSJ7wYBuY1evXkXdunWxceNGs9/7ww8/ICAgwOg8PEtBZD6Rt8jwM8/Vj1ZTXbT1aioWmyD7x9pEpDxvrI+Ct55wrp4eXzzf1quoaKxNZC8Y0G1s8uTJaN68OVQqldnvHTJkCJ555hmz3sP7/Ii0CSEgSg5DFO3Q3F8u337faDiXU/0g3/4QIm8hRNktG2+B8rAJsn+sTUS2VaxSIfHKZey6dAG5xUUAAP+5swyGc6/QIATMnY1JcbGIPn0SxTX43b3fsTaRvWBAtyFZltG2bVt8/vnnOj+bNGkShg8frvnzrFmzEBMTg/Pnz+PkyZOYNGkSJElCdHS0WZ/JJojoLqG6DDljgHbwzv4Ycvb/QU4NqCak+5dPaZ0hSv609aYoiiWboH0nW+LotdaKmvadbHlfH0dZm4hsa8fF8+iyYE6l4D0LSw7/gccXzzca0L1Cg+AXFgKv0CD0W7GM96RXwdpE9oIB3YZiY2M1z4+tauTIkQgMDNT8+ccff4SPjw9cXV3RuHFjPPXUU9i6davZn8kmiO5XQnUVomANROEGCDmn+vmFCnJ6oJ4g7g8564Pqz6BXnj/9aQhRVrFcAVFyCHLuNMi50yFKfne4+9XZBNk31iYiyxBC4ND1FKw4dgS7Ll0w6Rnl5zJvwScsWO+l7B9u3WTwHvSqk29YMCbFxWqWW6xSIebMKUxOiMOsg/txtZaPRrRHrE1kLxjQHQybILrfCCFDzvmuSmh+BKIwxvj7iuKMhO5HIOcGVTpTXn1QFyV/QogyyNmfVrwWcDf8Z0+EEPI92iO2xyaIzMXaRPebrMICvBz5i1Zo7rMkHGduZRh93+SEOPjqCeE+YcEYunY13lgfpflzdSE9YO5sCCGQUZCPZ39eWn6GfU4IfMOC4RMWjPWnT96jvaEMrE1kLxjQHQybILrfiILVBkdbF6XnDb8vP8LoQHBCdRVCdQEiLwzynSDIeUuMB/TiPRCF0YZ/Xrj5Hu4V27JkE5R0shX+vNZGUVPSyVY8jloYaxPdb977NUYnaPuGBeOJpQuhkg1/Yfv2xmiDgbvP0nDIQiDp6hX8uG8P5v7+Gybu2gG/OSEG31Mmyxi/fYve0O8bFoy0vLx7uFdsi7WJ7AUDuoNhE0T3G/nWiwaCdgDk3Gma+YQog5BzNWey5aJ4I4G7E4Qo1PocIeeUn1k3cMZdyDmQs4YbOOPuDzlr1D3dL7bEJojMxdpE95OM/Hyjo60nXrmsmbdYpcKd4mLNrVCTE+LgY+AxaiNi1ul8Vtzli/ofuxYWjKFr16BYpdIbztXzLDn8xz3bL7bG2kT2ggHdwbAJovuNnNbD8L3h2ePLg3ne3LvzpT0OOettyKmPGQ7oaV0hivfofJbIm6c5O1/5vyJvbvm63HrJ8DIzh9zrXWMzbILIXKxNdD85nZFu9NLzyJPHcaugABN2bNWc/X5uxTK8ER1lMEx7hQah/8oIXK/yO1Imyxi6do3WJe8+YcHwDQvGoespyC0uNnqf+qyD+220l+491iayFwzoDoZNEN1vjJ21FnkLIOdMNnopu6HL4+XUDjqXyAshIArWVYz8/gjkjAEQBes0Zz7k3JnQP/p7AOQ7/7PF7rEJSzZBu0+2we/XPBU17T7ZhsdRC2NtovtJXkkJAubONhiM/7x5A8+tWGY0jBsK1IERi3UGmysoLcVP+/fg8UXzETB3FoZvWIs/bl4HUF63+q2MMHhG/8Bf12yxi2yCtYnsBQO6g2ETRPcbUbxfTwD3h5zWHXLJWZMHedM7pT8BURRv+rqUpZafodcK6QGQ03pClKVZcS8oC5sgMhdrE91vftq/R+8l5f+OjkLMmdNmBfOq09B1a3A+M9PkdYm7dBHeFZfJV16XN6OjHOopI6xNZC8Y0B0MmyC6H4mi7ZDTn650OfmrEKVnIYp21zycVx7grSDS9HVRXYF8ezzk1I7l0+3xECrHOUMBsAki87E20f2mTJYRdGAvOs4L1QTiT3ZsQW5xMaYkxhsd2K26yTs0CB3nza52RPjKEq9cxsuRv8A7NAjdwudi5r4kFJaWWnEPKA9rE9kLBnQHwyaI7ldCyBCqKxBlqXdfKzlskYAupz0GIYrNXB/hUGcmKrNkExR/oi1+u9pOUVP8ibY8jloYaxPdrwpLS3ExKxM5RUWa12b/tt/sy9v1Xe4+9teNZq+Po9YlgLWJ7AcDuoNhE0SORAgZcsZzBu4LN/MseslhW2+O3WATROZibSJHci0n26TnmFc3dZg329abYldYm8heMKA7GDZB5GhE6RnIaT0rgnaHu/eFq+9Vr3isWrUBvfSU8c9RXYMoSYaQb9+jLVMuNkFkLtYmcjTrT5+Eb1iwZsR19Vlx9eXwXhWXsRsL6F3D5xj9DFkInEhPw+GbN1CsUt2jLVMu1iayFwzoDoZNEDkiIRdAFEZDvjMLojAGslwAUbwHIn8x5PwIGH6+eUWIz3i24pL1MoiCVZBvvQw5PRBy9v9BLjoAOfPflebvADl3KoRw3GbIkk3QzhOe2H/VS1HTzhOePI5aGGsTOaLUvDtY/GcyQg7uw76/riK/pAQbTp/Cwj9+x0/7dAeZq3qJ++SEOABAVmEBZu5Lwj+WL0Hfn5fif/v3YtelC3hq2SLN/N0WzsWG08a/aL7fsTaRvWBAdzBsgojuEnIe5KzR1TyGrTNEyZ8QQkDO/qRi3vZ3w3tqez0jxbd3qMeqVcUmiMzF2kR01/XcXDy+aL7RgP7cimW4XViI7KJCBEYs1rqnXf1INX2X0e/766qtN89mWJvIXjCgOxg2QeTohOoyRF4Y5NsfVX9pe1oPzaBzouRPM+9b7wwhiqpZm/sTmyAyF2sTOTIhBPb/dQ3T9yRg6Lo1Bp9Zrp7+HR2lGYF91sH9Jt/P7hsWjJEx6228tbbD2kT2ggHdwbAJInsk5HyI/JWQb/8Hcs4kiOL9NRqJVuRHGDjjbWDKeFHzXvnOLLMHm3O0x6upWbIJ2n7cC3uu+Chq2n7ci8dRC2NtInt0PTcXP+3fg7FbNmLangRcup1l9jJKy8owZnOMwTPe+qYZexM17x+0eoVZA8v1WRpuyV1gV1ibyF4woDsYNkFkb0RZZsVI7OpLyytCcu4M85ZTerYGo7e3h6y6VH7/ed4cMwN6Rwg530p7RdnYBJG5WJvI3hy6noKAubPhGxYM74qz035zQhB36aJZy1ly+I9qz5hXnZ79eSlyi8sf/flK1CqT3+cTFozX10daY3fYBdYmshcM6A6GTRDZGznnG4PBWJQc1ZpXiCKI0uMQqivlfy49Dzn7v5Az+kJOf9L0M+dVp/RAyHnhxoN81YHlcr6xwd5SBjZBZC7WJrInshB4atki+FQJwN6hQegSPkdnxPTMggIcTb2JjILyL23jLl/EWxvW4umIxeg0P7TGj1kbunYNftiTYFbA33HxvC12mSKwNpG9YEB3MGyCyN7IaV0NhOIAyLnTNfOJ/OWQ07pVujz9ecipHc2+LN3odPuDu5+tDuJpj0NO/0eV+f7jsPefA5ZtgrYe90biFT9FTVuPe/M4amGsTWRPjqWlGg3BiVcuAwAKS0vxfzu3ay5d9wkL1lySbonnoPuEBaPjvFAMrlimd6UB4vqvjMCj88M087afE4KFf/xu4z1nW6xNZC8Y0B0MmyCyN4YfgdYBcu5kAIAo3GC5EG70nvS+kIv2Qc7+DHLWaIi8+RByFoSQy5+BXrgVQnVZs+6i9ATk3JmQcydDFMVCVl2FKNoNUXrGRnvz3mATROZibSJ78vuNFKPBObbiLPX47VssEsSrG/jt6927sPbUCby7OQbv/RqD9adPoqSsDIWlpYi7fBHbL5xHdlEhAEAly4i9eB7f7N6F6XsTcSwtFcfT07D7yiWk5t2x5W61OtYmshcM6A6GTRDZG/n2WMOXuBeVPwNWznjm3gT0VD8I2bTfnfJB5dRn2/Wsf+YQzQjx9xs2QWQu1iayJ0WqUnReEKY3MLefE4LsokJcz821ajCvPA1cvcKk9S4sLcWwdWvgFRoEvzkh8AnV/vLAJywYk3btQGlZmZX3oG2wNpG9YEB3MGyCSElE6RmIoh1GzyiXD+7WuUrIbQ856y3Icgnk7C/uWTiXUztBiJLqt6vkDxOWFQD51sAajUavdJZsgjYf90H8lfaKmjYf9+Fx1MJYm0gpVLKMA39dw46L55GWl2dwvtUnjmldqq7+77zff0NGfj6eWb7knoRzn7BgjNpo2qPTTHkkm3doEGbsS7LU7lQU1iayFwzoDoZNECmBkLMgZ75R5YzyGxDy3UfUCNVFiOJ9EGWpEKoL5ZeVp/eBnPFc+aXlohgib6Flgnf605BzZ8D4IHL+kHO+Nmn75JzJBs/665yRLzlkrd1sM2yCyFysTaQEh2/eQO8l4Vrh97vEeMgVX6SWyTIO37yB/X9dQ35JCeIvX8Lr6yPRfdE8vBK1ClvOnQUAvLY+UmcAuZpMI2PWY/Sm6Grn237BtIHfnly20KTP7TgvVGegu/sBaxPZCwZ0B8MmiJRAzhyuJ8AGQL71GuT8nysGeKt0tjz7M72DrsnpT9U+nGe+BSHfBgCI0lPlz1pP7Ya7I7NXrGfmUAjZ8NkUrfXK/qyasF8poBestei+VQI2QWQu1iayteyiQnSaH6b3DPN3ifH4cd8edF84r1KInY2lh//QWc6l21kWOTMetH8vVLIMANh6/ixeifwFAXNnac5yq9dz+t5Ek6/E6hI+x+TPv3Hn/vtdZG0ie8GA7mDYBJGtCdXFGgRpf8g5X+gsS/fxZuZO7bUGddNaT/k2RMFqiLy55QPDlRwrH+Ct7Gb5z4WAkPMghO5ZBlEQafI6iJL7b1RdSzZBMcf8sPNygKKmmGN+PI5aGGsT2dryo3+a/Txyr9AgbD1/Vms5+/66WutL1v++bJHmrH1VF7MyEf7HISxIPoTTGRnY/9c1JF65jLyS8tuvymQZd4qL9Yb2D7dugq8Jg9bxDHr1y2BtImtiQHcwbILI1kRxQg3DdIDmTLeanPFC7UJ65gjIcqHx9VVdg3xrkPYZ/cx/Q854ruLPnSDnfKt1dl2IwoqrAIxd5h4A+dYg3oNezTLYBDkG1iayte+TdsNvTojZYfqlyF+0lpOad6dGQV89eYcGIeTAvmprQ9yli3hs4VzN+zrMnYWRMevRZUH5WfKei+dj2ZE/tZZz+lYGAubONhrSvUODMJP3oFe7DNYmsiYGdAfDJohsTaiu1ThQi9KT2ssq3Fz7S9xT/SEXbta/rkJV/mi1au8n9y+/BF7Id98rZ5Xfi57Wrfz9aU9U+XJgKEdxN2EZbIIcA2sT2dqq40drFKw7LwjTWdansdtq/Xi1Lgvm4FpOtt51vZCVCd+wYJPWN/S3A1rvPZGehrc3RqP9nBA8Mj9UK+T7hAXji7hYjuJuwjJYm8iaGNAdDJsgUoLyR6eZdo925RBceRA5NVHwC+S0HrW/1L0sXXfZRbvN+wKheJ/R7RZlNyCKkyBKz1lsXyqRJZug6GPtseNyB0VN0cfa8zhqYaxNZGt3iovx2MK5Jl0CfvdsczAG63nEWbFKhS/iYs0+I1916rMkXO+Z9CmJ8SavZ4d5szWXv+sjhMCpjHQkXrmM9HzTxlmxV6xNZC8Y0B0MmyBSAiHnQb79kRmXp/tDzv6v4eWJkvLB5WoT0nNn6i43P8KMLxICIPJ0z6Q4IjZBZC7WJlKCM7cy0H9lhFkheuPZ0waXl11UiPHbf63ViO4n0tN0ljtq43qzlvHnzRvW3G12g7WJ7AUDuoNhE0RKUn5G+TfIhZuMh9/MNyHnfA85dypE8R6tS8k1y5LzIKc+WvOAnvWh7jLNul++PUS+7pkUR8QmiMzF2kRKIYTA6Yx0/JbyF75L3G3wMvL2c0IwfvsWfLN7F/63fy/OZ2bqXd6ea1dqdRY99qLuI9S+S9pt1pn+S7d1rz5zRKxNZC8Y0B0MmyBSKlG4GXJ677uBN6Mv5DuLId/+v4rXOlRMfpBvj4UQpbrLKFitOZttdkDPW6S7PFFWMRicKcvrqPcSfEdkySZo3bEAbL38iKKmdccCeBy1MNYmUiKVLGPangT4V3q82atrVyPy5DG88MtyeIUGwW9OiCYsL9Hz2DUhBN7fsknzfnMD+uXs2zrLvHQ7C35zQqpdnq+eQewcGWsT2QsGdAfDJoiUTIhSiNLTEKpL5Y8xM3YPePZE/fekF++DfPs9yBn9y0dpN+MMuJzWC3LmKIiiWM1ZeqFKgXzrX1Xme/zupfep7SGndoAo2mH6dpalQuTNg5zzBUT+kvsu2LMJInOxNpGS5RYX40R6muYe7SmJ8QYHgVt57AhKqgyyppJlrDp+FP+KWoXnVizD0LWrTQ7o7eeE4ImlC/F/O7drXe6ecOUyHl88/+695nNnocO82Zpg7hUahN5LwnFFT8A35FhaKqYmJeCLuFhsPHtaZzvsHWsT2QsGdAfDJojsiXz742rOXgdAvvUy5MxXIWd/AVGqfS+gyFtkxj3kVb8A+FxrcB5RehaieC9EWTrkogTIqZ2158/5GkJU38yI4n2QUztVrFdAReB/TGeEenvGJojMxdpE9uTRBWFGQ3Wn+aF4JfIXDIlajZCD+3CroEDr/W+sj4J3aM1GeY85c7fOqWQZv99Iwf6/rqGgpAQz9yVpnVX3nzML0adNqy2zf9tffkVAWIhmcLtBq1cgt7jYovvOllibyF4woDsYNkFkT+Sst80I1QGQUwMgiuLvvv/OrJpd7l4xieL9OuskylIhpz4CfQPcifwlRrdHiBLIaT31vNcfcsbz980z0S3ZBEUe7YjNlx5V1BR5tCOPoxbG2kT2Qghh1iPUfMKC0XPxAly/c/ff9qDVK2p8T3rHebORr2dU9i3nzuqd3zs0CCf1DDRX2bG0VIPr/sOeBEvvQpthbSJ7wYDufxXyTwAAIABJREFUYNgEkT0ReeFmngFvDzm9D4RQAQDkotgah3M5tQPknMl61mm+4XVK/7vx7SlOMv6FQOlZa+zGe45NEJmLtYnsyWvrIs0K6b5hwfg0dpvm/Z/GbqtxQPcKDcIOPQPHDV27Wu86+YYF48v4nUa3Z2pSAvzC9D8S7rGF8yy+/2yFtYnsBQO6g2ETRPZEyNmQ0/9u9llwUXIUACBnGjkDn/F8NeE/AHLOlzrrJOd8A81gdXreY3R7irZXs96HrbIf7zU2QWQu1iayJ4eup8A3LNiskN5xXiiA8vvZDV0i335OiOY+cmPTlnO6X+Y+sTTc4Pxvb4w2uj3GntkeMHe2VfahLbA2kb1gQHcwbIJI6URxEuSskZDTnyp/vFrBesjZE80K6aLkMOTSy8bny/+l+uUUxequX/5KvZe3y6ntId8aaHzbytINfymQ1hVCFFprt95TlmyCVh/thI2XuihqWn20E4+jFsbaREqmkmX8fPQwXlz1M/osDccnO7Zi/akTeH19pMkBvcO88qC76I/fDc7TLXwuJifEGQ3+fnNCkFVYoLOO72zaoPfRa75hwZixL8no9m06e9rgmf/RmzZYZZ/aAmsT2QsGdAfDJoiUTBRE3r0nu9J/Rf5yCNUF00J6Wk/IhRuNnOWumAp3lT9b3dDPs0ZoLpXXWkf5DuT0XnrXRRT+Wu02ynd+vBvoK/1X5P9sjV1qE2yCtCUlJWHQoEFo0aIFJElCTEyM0flHjhwJSZJ0po4dO2rmiYiI0DtPUVFRjfe5LbE2kVIJIfDhVu3HpPmGBSNg7iwcTUvF6hPHTLrEfdy2X/H17l3VznsrPx+D1+jeo67+7PA/Duldz0PXU3Qeu+YTFowO82YjJTfH6DaWlJVh0OoVWl8M+IYFw3/uLByv5v51e8LapI21SbkY0B0MmyBSKiGKIKd1MxCY20NO7VJNOK8YET0v3LQz7TlfAwDkkt8g3x5fccl7p0rz9IB8Zw6EkCHK0iBKj0HI5U2OUF2AfGtIpS8FekAUrDJxOwVEwSrIGf0gpz4C+dYgk4K9PWETpG3btm346quvEB0dbVITlJOTg9TUVM2UkpKCJk2aYPLkyZp5IiIi8MADD2jNl5qaWuP9bWusTaRUv99I0RukvUOD8Mi8UM0z0o2F88cWzsX0vYkmnWnfe/UKSsvKEHXyOIbHrMOTSxeifcXl596hQfh7xGIkXr0MIQQuZmXiZHqa5nFoW8+fQ68lCzTLem7FMvxx87pJ25lbXIxpexLQfdE8dJg3G6M3bbivwjnA2lQVa5NyMaA7GDZBpFRy3gKTL2HXnTpDvv0xRMmR8rBt6vtu/wdy6qPVzFf55x0h53wPIUoBAEJ1DaL0FITQHVHXkVmyCVp55FFEX+yqqGnlkUdrvH2mNEFVxcTEoE6dOrh69armtYiICDRq1Mjsz1cq1iZSomKVCsNj1pl8GXvVqefiBZi2JwEpOTnoXM2j2Sqf9R69KVrnbHjVqfLyHls4D+srHqdWJss4cysDl25n3TdPBrEU1ibDWJuUhQHdwbAJIiWS78yuRTivuLy8IiTLGf1rvSzjU3vIuT/obIMQAqL4IETeIoiCaAg5717vRsVwlCYoJSUFubm5mqnYhOcF16QJGjRoEPr166f1WkREBJycnNC2bVu0atUKAwcOxOHD9jvIIGsTKU2xSoVX166ucTj3Cg3CsHVrAAA5RUW1Wo6p0+4rl3S2o0hVik1nT2NB8iHsvnIJZbJ8r3elYrA2GcbapCwM6A6GTRApiRAy5IJ1FgjNAXcfrZY11soBvfxMupDv3N0OORdy5rCKn1XcP5/WBaL4gK12rU05ShNUdap8mZ8h5jZBN2/ehJOTE6KiorReP3jwIFauXImjR49iz549GDJkCNzc3HD+vO7jl+wBaxMpSUFpKT7dsbXWgXlEzDoA5YPMdTRhdPbaTkOitG+1Opmehh6L5mkutfcKDUK/FcuQlueYXyCzNhnG2qQsDOgOhk0QKYUQZZBvj7NMYM766O5ySw7dg4DuBzlvCeSsd8vvXU//B3RHZ29fHtId8Ey6JZug5Ue6YO3FxxQ1LT/S5Z6dpZg+fTqaNm2KkhLjt1HIsowuXbpg3LhxJi9bSVibSCnS8/MQGLHYIoE58sQxzXJ/2r/H6gHdNzQIK48dwb+iVqHfimV4ZH6ozojwvmHBeGvDWhvuYdthbTKMtUlZGNAdDJsgUgpRGG25sHz7Y61llz+r/B6EdBNGlRcF62y0h23HUZoga9/nJ4SAr68vPvnkE5PmHzNmDAYMGGD2OikBaxMpxfjtW/Q+rqwm08YzpzXLLS0rwz+WWyb4VzdVd/+6V2gQbtxxvN811ibDWJuUhQHdwbAJIqWQs0bqOetc06mD1plqkTffpPB8LyaRt8Cs/SLKbkG+8xPkjBcg33oZIn8JhLCvx5OwCTLMnCYoISEBkiThxIkT1c4rhECPHj3w9ttvm71OSsDaREpQWlYGv4oR02s7+YQFY+jaNVrLH7p2zT0J6KZM5o7QfiI9DR9v34K+Py/FmxvWYvuF83Y3CB1rk2GsTcrCgO5g2ASRUsiZQywbhgtiIMtFkIsTIWe9Z/Ngfne9oqrfGRVEWTrk9CerfLnQHnLma3Y1Urwlm6Blh7sh8kIPRU3LDncza/vy8vJw5MgRHDlyBJIkISQkBEeOHMG1a9cAAJMmTcLw4cN13vfWW2+hV69eepc5ZcoU7NixA5cuXcKRI0fw9ttvw9nZGYcO6X9GstKxNpESFJaWWjQEd14Qhku3s3CroAAxZ07huRXLTDq7fS+mOyZc9qy25+oV+IYFa64sUF82P+vgfiv+bVgea5M21iblYkB3MGyCSCnkO7OMnEHvWsNA3N72gbzqlB9p+j7JnQpDZ/5F4QYr/m1YFpsgbeqzDVWnkSNHAgBGjhyJwMBArffk5OTAzc0NixYt0rvMTz75BG3btkW9evXw0EMPoX///jhwwH4HJWRtIqX455qV8DEQajvND7V5sDY0mRv8s4sKTdofQgj8Y/kSvcv3Dg3CzTt3ql+IQrA2aWNtUi4GdAfDJoiUQpRlQk5/okogDYCc3qf8THLmq7YP13qnTpBTO5o+f+5Mk/eJnP60geX4Q84eb8W/DctiE0TmYm0ipdj311X4hAVrDa7mExaMETHrcKe42GKXwFt66rl4vlnzX7qdZdL+uJqdbXQ5ayoNhKd0rE1kLxjQHQybIFISUXYTcvYXkNMeg5zWDXL25xBlNwAAcnpvBYTxKlNaN8hFCRAF61F+tt6E+9zvhJq8P8pHgzcU0E0bjEUJLNkELT7cHasu9FTUtPhwdx5HLYy1iZTk0PUUvLVhLTrMm43eS8Ix+7f9KFapcCEr0+ZBXN/Uf2UE/srJxsc7tmi+UKjuPX/cvG7SvkjJzTG6nKiTx638t2E5rE1kLxjQHQybILIX8q3Btg/keqcOEKUnIUqOQM7+L+TM1yCnPvr/7J13cBvXtf/95sXJm8y8P95fefm9eW8idkm25S5FtuOmuNtxi1tsy3ZsSy5xb7GdKIq7Q1AC2CSq99577703SlRvFgEQBAkSIOo9398fIEFCxC6w5AK7iz2fmTOkid3F3Xute873lnMlryf/qtTfuelHSdFPLUvSWNvqwkEQoxT2TYwR8AQCKYnfTFuOtRi3ja2CNxjEgmPVeGXBHDwybZLk9fmlJYqWuN83eXzC986zWVDn86W51tWDfRNjFFigmwwOghg9QYHNEO63IOoehWj8HBQ6HvtMeIbqQIwnsgIId/xyc/JNTXBdEYTzPhCFU68P0QDhvAfte+lbf7oHgSiiWr2nGw6CGKWwb2L0QigSwdRDB/Ds7Bl4dPpkDN++Be6WdjGbqaPSumKXz2a/vmheJ2GdYy3GPzesVVQney79hJ7lw2NJ4tp+jtu3R5U6zxTsmxijwALdZHAQxOgF8o5tF7Kxnz1BgWhWWAps0YEYlzDHbfHvQgTyToCw39RBxA8CRZzK60U0g7xjIOpfgKh/FdQyT5HI1wNqBkEj996Aicf76spGchCkOuybGD0QFgIvzZ8dE7Jty8VvGTsSTq8XAPDVxnWaC3GpWfQv1sav2PKFQvjr6hWxffO9yofj+80bEBZCcd2cbWjAVxvW4elZ0/H+8iXYcfGCKnWeSdg3MUaBBbrJ4CCI0QMUcUHU9kw8O+0cEBW8FIFw3gX1zkpXU6DfmvDYM6IQKHwGJNyJ35uCIP8KkHccKLAZRMqDJCPAQRCjFPZNjB5YcrwmofjNs1nwj/VrAACn3PWxGWS92ZtLFiR8r6ZAAKcb3GgJhRJ+7m5pwYzDBzF+/x7UuOrSVr9aw76JMQos0E0GB0GMHqCWebICmMKnoteFT0I4pRKnaWzuQSCi1N85VNN6xnmHpet1D4IijnRVs2ZwEMQohX0TowfeX75EUnz3HV0Zu25xzTH0LB+uuSBPZJMO7FP0zvOOHkFB6bC4VQMfrVyGSBdm2fUO+ybGKLBANxkcBDF6gFrmpiTQAURn0t1v6nMm3b8WFKoBkXyynehqgDvQOQFcEUT9S+mu7oyjZhBUufcmjD/+W11Z5d6buB9VGfZNjB54T06gj6qMu7YpEEDf0ZWaC/LL7ZrKUhx31eFkvQsiySDyyXqXZNK70Xt3p7OqNYF9E2MUWKCbDA6CGD0gAntkhG9viEA0MKDQUVBgPYR/lfZiXM7sfUDNpZJL1pPtp287Wi5b4CCIUQr7JkYPfL1xraTwvXP8aDi9XoQiEey4eAEbz53Bv7Zs1GVW9za7dWwVVp86Kfm+323eIDkgccf40Rms+czAvokxCizQTQYHQYzWiMDO9iXeCa0AorYXhPOB+L8579VeiCcxaq5M+M5Jl/QH92e4FdILB0GMUtg3MVpj2bpJVuzm2SzoN3oEbqyqiP2tZ9lw9NPhLHqb5VijSe72Xko8CPzBiqWSAr13hTXDLZB+2DcxRoEFusngIIjREiIBYe+XouCVE/E6NfsNiZPHhY7L3NcbJJo0aI30oWYQVLanL8bU3KIrK9vTl/tRlWHfxGjJKXe95mI6XZZns2Dw4sTJ40bv3R3bd97Rcm0WPD1reoZbIf2wb2KMAgt0k8FBEKMlFNyvvYhO9yx65GLCdxfu15FwH73nhwy3QvrhIIhRCvsmRkts27dqLqTTabeOrUr43o1+P26squg0i55jLcbGs2cy2wgZgH0TYxRYoJsMDoIYraDwOYi6RzUX0Om1niDhTfz+wgfR+CVEba/W2fY+EE3DQRTJcEukHw6CGKWwb2K0Yt2Z07h2RKnmIjpdlmw2/JS7Hs/OnhEn5peeqMlgC2QO9k2MUWCBbjI4CGIyDYVPQDR8gsTnnmeZ1T2RcIl7XH2IZlD4HIgCGWqBzKNmEGTb0w+jam7Vldn29ON+VGXYNzGZZt2Z03hy5lTNBXQm7NuN65PWR53PhwuexqSZ340M+ybGKLBANxkcBDGZhII7IWp7wxD7yR2/hWhZB+Gb2VrerpS5AKJ+YFbOiiuBgyBGKeybmExSsWu75qI5VXts+mScdbvxzrLFXbq/bY/5iN07tK52zWHfxBgFFugmg4MgJlMQEUTdg9Dl+eUJrQii4YPooIJ3NIT91i4/i/wrta5+TeEgiFEK+yYmU9ibm3V9NFoim3JwP9acPoV/bdmEXGvXyp5fWgJ3S4vW1a8p7JsYo8AC3WRwEMRkCopc0oHo1kjoN36evH6EF6KpBMJxG4T9Rgj3u6DwiQy0TPpRMwgatrs/Rhz7na5s2O7+3I+qDPsmJlNMP3yw24K5oLQkY+I8p8MseHdtcc2xpPVzusGN95cvwXUjy9Bv9Ah8t2k9PAF/Blom/bBvYowCC3STwUEQkykoUquO4HXcogPRrcQKIBr/Ll83FISoewLxqwuKIOzXgELGT87DQRCjFPZNTKaYoYJAv25EqeT54Xq25SePy9bNmQY3rqm0xb1brs2C+yaPhz8cylALpQ/2TYxRYIFuMjgIYjJFdIn7Q+jeEvciCOczEI67dCC8O9rVkN2j7t8sXzcti6Tf1/1WhloofXAQxCiFfROTKRzeZllxncpsdZ/KUjw9ezp6lQ/XXHR3tF5l0uXJtVngDconMf1o5TLJupl26ECGWih9sG9ijAILdJPBQRCTSSi4B6L2qqjwrM1vF+v1r4FCxyAaPpYXuoa0AgghZOtFNP61Q51cZvZrM9Q66UPNIKh4960oP3aHrqx4963cj6oM+yYmk1Tt2Yke1uKYGM1t/f27TetxvrERt42tSjpDnqsDQa7EHpw6IWm93DSqQlLcv710YQZaJr2wb2KMAgt0k8FBEJNpKHwKonEIRN1jEO43QIEN7Z9REKLph9YZaa2FtRpWCOF+P2mdCM8/ZAR633Q2R0bgIIhRCvsmJtNsPHcGgxfPxyPTJuHzNStxot4V++xSUxNeXzRPtb3ferA51YeT1slt46oS3ptns+CjlcvS2RwZgX0TYxRYoJsMDoIYPSIkl3wbyQohHP1BkZ+Svi8Fd0k/w/NNBmo8vXAQxCiFfROjRz5euSwrRPrAebMRiiQ//rNk22bJDPfrz5zOQI2nF/ZNjFFggW4yOAhi9ASJBlDLAoiGT3UgsLtpTWUgUZ/aexNBeL5tvbcIsaX/dQ+CRGOaaz39qBkE/bjrNpQevVNX9uOu27gfVRn2TYyeOOWux/TDB/HAlAmai+vu2HUjyzCn+nBK4hwAvMEg/jBtUmzWvG2Z/19XrwARpbnW0w/7JsYosEA3GRwEMVpB4ZOg4M6YACXfNIjaXtoLazXMfr3i4EUIAeH5EcJ+Q+vs+60QvpkcBF32DA6CzAH7JkYLwkJgf+0l7L30E0KRCEKRCD5YsVRzYa2G5dkseGfZIsV14m5pwasL5qKobBjybBb8Ydok7LuUfGWYEWDfxBgFFugmg4MgJtNQ+BxE3eMdBG0vCPcH2otq1awQoulH5fXSXNp6f0HcT2oemYZWyCwcBDFKYd/EZJo1p0+h76jKmKC9YWQ53l66MCuWtLfZ5vNnFdVJRAg8OXNq3DL3PJsF+aUl2JMFIp19E2MUWKCbDA6CmExCFIRw3IHECdGMnr29tfz1r4DIr6xeRAOkVw9cBRLNaWqRzKBmEPT9rtsx/OjdurLvd93O/ajKsG9iMkl1nRN5NktWifE2y2m1sp3bFdfLqlMnEj4z12bBs7NnpKElMgv7JsYosEA3GRwEMZmE/Mt0IKTTaPabIRq+BDVXgSIXU6+XwDrZ51JgSxpbJf1wEMQohX0Tk0k+W73CcMekKbF7Jo3DNxvXY/qhA2hOcvZ5R4ZuWIv80hJJ4W/0LVjsmxijwALdZHAQxKgNURgU2ALyLwdFauM+a0+Elg0mN+NfCFFbCPJNTa3OgjvlBXpwfzqaKmNwEMQohX0TozaeQAArT57A6tMn4QuF4j4bMHGs5iJa7Vlzqb/1GVGKA/ZaiVqKp3jrJsnz33uVD2eBDvZNTGZggW4yOAhi1ISCeyEct8QL1cahIIqAKALh+K0OhHVmRTyFTySvNwpDOPojlr29Y/05bgeRyEDrpQ81g6Bvd96Jkurf68q+3Xkn96Mqw76JUZMJ+/eiqGxYTFz2rrBi3tEjAIDTDe6sXNouZbk2C/qPGYmISO5Xalx1CZ+RZ7Pg8zUr091saYd9E2MUWKCbDA6CGLUg0QhhvzaByMyH8BRDNLynA8GcaSuCaPpXavUX3AlRe3Vr/bUetWa/BhTck+aWSz8cBDFKYd/EqMXGs2ckZ5lnHzmMeyeP01w0a2Fbz59Lqf4qdm2PifK22fTfTxwLd0tLmlsu/bBvYowCC3STwUEQoxbknQjpZd8FMp9ls/WEaPwi9TqM2EHNFRCNn4KaK0ERZxpbLHNwEMQohX0ToxavLJiTcJl2zmU/zWZLjh9LuQ4POez4asM6fLJqOWZXH0YgHE5ji2UO9k2MUWCBbjI4CGLUIrq/vGf3Ra1jgA6EtXpGvtlaN43mqBkEfbXzLvyr+h5d2Vc77+J+VGXYNzFqcdeEMaoI2vsmj9dcVKtlOdZiXGzif1vsmxijwALdZHAQxKgF+aarI2obh0K4P9JcWHffiiCcAxQfuZaNcBDEKIV9E6MWgxcvkEx0pmjGueYoBkxUR+xrLc4/W7Vc62bRBeybGKPAAt1kcBDEqAWJZghHXyQ+41yB2W9q/T3BXna9mmsghHcKRN0jrX/rCdHwQdYsUe8uHAQxSmHfxKjFrp8uqrKMvbBsWOxMca1Fdqr23cZ1KNm2GTeNqkAPazSD+7BtWxBOIUGcGWDfxBgFFugmg4MgfSOIDHWMCYWOQ9Q92E3Ba9C96k3DonUgvCBK/ZxZM6BmEDR0xwD8cOQ+XdnQHQO4H1UZ9k36xmgnSyyqOYrrR5ZpLpi1sG0XzkMQoSkQSClzu5lg38QYBRboJoODIH2y/cJ5PDlzKnKsxehdbsXf1q5Co1//S6VJeCCahkE47mjN6G5Qsd0Vs1+rSJiT8IC84yEaPoJo+iGl49iMCgdBjFLYN+kPIgL5pkA474j2eY7bQN6xhhDrJ+pd+GDFEtw0qgI9y4drLpozZTnWYry6cK6iujrT4MaPWzbi/eVLMHL3TtS3+NLUKtrDvokxCizQTQYHQfpjx8ULyLVZkNthz1yezYIHpkxAMBLRuniSkGiGqLsfhlqarraFUzu2hsJnW8+EL0B0S0ARRG0ByDcnza2kDRwEMUph36Q/qLk0cb/n+U7rosly2GFHz/LhquxDN6L1Gz0i5ZV4S0/UxI5Ty7NZkGO14NoRZThal53btdg3MUaBBbrJ4CBIfzw9a3qcOO9oi2qOal08Scg7FvLHrOlAQKfb7H1BgfVJ60rUD0Tivfo9QaI+A62VWdQMgv6+YwC+PXK/ruzvHASpDvsmfUGiCaK2t0TfV6TrfBsvzpslKc6NtJ+8O/bw1Im44GmUrafmYBC9EqwuyLNZ8Mi0SRlqrczCvokxCizQTQYHQfpDKpDILy3B39et1rp4koj6F2WE63USgjTbrCAqssNnJOuJhFv2fvJNy1yjZQgOghilsG/SFxTYJtv3kV+fvikihKQIz7VZ0HdUpebiOROWZ7PgrgljZPegL6o5KvuM843yAt+IsG9ijAILdJPBQZD+6DOiVNLB/mvLJq2LJ4mofwWSM+WOW3QgnjNlRbJLPilSK3NvIcg7NoOtlhk4CGKUwr5JX1DoiLxAD+7QuogJEUTILy2R9Kn9x4zUXDxn0jacPSNZVzMOH5S9t8ZVl7mGyxDsmxijwALdZHAQpD++2rBOcon7iXqX1sWThHyzZWaV++hAOGfQ3IOl64kIwnk3pAYzKKTfbQxdRc0g6Mvt9+Drww/qyr7cfg/3oyrDvklfRPute9B5JVRhNFkc6Tc/yttLF5l2/3lHy7EWY8L+vZL1dL6xUXK1wU2jKrLyaDb2TYxRYIFuMjgI0h9NgQD+MH0yelijy9qjiVqKMW7fHq2LJgtRqHUWvTVoaxOgzvu1F8wZtQIIz/fydeVf1Vo/hfH3NXyYodbKLBwEMUph36Q/KFQNYb8RbVt5RG1B9PSK4D6tiybLRY8HfUdVxga+28T6H2dO01w0Z9o2ysygA8CQdatjYr6HtThWZ3Orj2SmsTIM+ybGKLBANxkcBOmTsBBYcfI4/rlhLUq2bcYptzEShxGFQC3zIdxvQrgHgXwzIHzzkwjaXhCu53QgrNWyQlD4bPK6CmyBcD0PYe8D4bwL5B0NonAGWinzcBDEKIV9kz4h0QTyTYbwfAXyjgeJBq2LlBLulhaU79yOl+bPwXvLl2Dj2TP4ZOUy2Zn1m0dV4vcTx2ouqtWy/mNGQCTJ5i6IMGH/Xtw9cSx6V1jxxIypWH36ZIZaKfOwb2KMAgt0k8FBEJNuKFQjL2g930N4ZyNrMr032bSuct2hZhD01233Yeihh3Vlf912H/ejKsO+iUk3o/bsklzSfd2IMth2bIVlyybNhbVadtSp30z7WsG+iTEKLNBNBgdBTCaQPlYsv3WppA6EtRpm76toLyYRgVoWQ7iegnD0h6h/GRTYksaW0AYOghilsG9i0o27pQV9RpQmzPmSYy3Oqn3rby1ZqKhu/OEQynZux90Tx+C3Y0bg01XLcbbBGKsllMC+iTEKLNBNBgdBTHcR4VqIJitEsw0ilHgpHAlPdNl73Cx5lsyYdzT/OkV1R81lrfe27UUvgqgtALUoC6b0DgdBjFLYNzHdZc+ln/DdpvUYu3cP3C0tCa854nTgnknjNBfQ6bTCsmHwhYIp11tYCDw1a1rc6oI8mwXXVNoMs90uVdg3MUaBBbrJ4CCI6SpEBOF+t7NIdb8puZeaIrUQktnejWqtAw0NH4CS7O+LrwsXJFcVOPqCKKRWU2mOmkHQZ9vux5BDj+jKPtt2P/ejKsO+iekqjf4W3Dl+9GUz4hbJDOZEhOMuF/62dpXkCSpGsjZh3ZZgdnb1YUX1t+T4sYTPzbNZ8O7yxWo0kW5g38QYBRboJoODoO7jCQSw9EQNFtcckxylz0ZEk1VatDaXx11L4ZMg3xyQfzWEf40ORLUKVv88RN2DEK7nou+m8Jghalkk+3wKHVKzuTSFgyBGKeybug+Fz4NaFoIC60GU+gyq0blvsvSM+AF7bew6QYRtF85jxuGD2H3pIr7asFbyzHQj2QtzZ+GeSePwxuIF2HHxguL6+2TVcsnl/VdXZleOFfZNjFFggW4yOAjqHjMOH0RR2fCY8yooLcHovbu1LlbaIaJo9nFJgXkDqGUuRFNFNFN5x89ix/ToQGR32fpBeL6GaPoXKNS142fIvyKJQK9RudW0g4MgRinsm7oOURii8fP4ftbRFxTcqXXR0s5xl0tWvL6+aB7G7duD4i2bcMdls+y/GzdKc3HdXXtx7iwMWbcaI3bvgMPb3KU6/GJh2gc2AAAgAElEQVTtKkmBfkNVefIHGAj2TYxRYIFuMjgI6jp7L/0kmQF23ZnTWhcvrZDwpihkEwnxQmRHYrgixJaoNw3vWh3ar0lcP84BipbL6x01g6CPtz6ILw8+qiv7eOuD3I+qDPumrkPN5Qn63kIIex+QcGtdvLSy7MTxLovbPJsFvcqHI1cHQrs7ll9aglybBYVlw7Ahybnnidhy/pxk/fxj/Rr1G01D2DcxRoEFusngIKjrfLBiacJR5jybBS/Pn6N18dIKkYCoTSQuU7UCCPerEgLeoGa/CcL9jqIZdWpZHA2cY3vRiyBqrwYFd6Wx9TIPB0GMUtg3dQ0ignD0lex3yTtB6yKmlcMOe7cF7svzZmsustWyHGsxbhk7Et9v2gCnz5tSHRIR/rp6RSyeyWl9zl0TxqC+xZfmFsws7JsYo8ACXSOGDBmCK664Is5+9atfyd6zfv16XH/99fjFL36BHj16oLKyUvH3chDUdf44c5qkU7x7whiti5d2RFNxNwRtT4j6lyBqb9JeWKtuhaDA5pTrkULHIDxDIdyDIJp+BIWV7xnUOxwEGRf2TcaCKCjf73q+1bqIaYWI8PtuZmV/e+nCrDpirc1uGlWR8rJ3IsKa06fw3vIlGLRoPsbv34PmYPblMWDfxBgFFugaMWTIEPTu3Ru1tbUxczqdktefPn0av/zlL/Huu++iuroao0aNwpVXXonZs2cr+l4OgrrO3yT2aeXZLHhraXYdk5UIonCCLO5ZNCPeHXPckVVL1LuLmkHQh1sewucHHtOVfbjloaztR9k3GQ/hvEOybyLfLK2Ll3Yc3uZOWdxzrdknuLtiQ7NsiXp3Yd/EGAUW6BoxZMgQ9OnTJ+XrP/nkExQVFcX9bdCgQejXr5+i79VrEHTIYcff163Gm0sWonLXDl1mRz9R70JBaUncPvQcazFybRbsvfST1sXLGBT5CcI3LXp8mn+L9uJYJ0bhc1o3jW7gIMi4sG9qh0hEkzs2fAjR8D6oZYEuj0Mk37QEfVIRhKM/SGTXEmUpiAj77bUYu2831p05jR82b5TMGWMmu7GqQuum0RXsmxijwAJdI4YMGYJf/vKX+PWvf43f/OY3ePrpp3Hq1CnJ62+77Ta88847cX+bO3cufvaznyEUSj1g0GMQNPHAPvSwtu19itoNVeU45a7Xumid2HTuLG4dWxVzfn1HVWL5yeNaF0szRPNEzYWxXozC57VuDt3AQZBxYd8UhSgC4X6rXezWFkZ/dz0HooDWxYuDiEDNVfEnbdQ9DgpLt1u28/ycmZqLYz3YDSOzKwt7d2HfxBgFFugasXTpUsyePRsHDx7EqlWrcPvtt+NXv/oVXC5Xwuvz8/PxzTffxP1ty5YtuOKKK3Dp0iXJ7wkEAvB4PDG7cOGCrv7x2pubJZeNvzB3ptbFS4ggQrXTgUMOO8JCaF0czSCKQDh+Ky1amydC2KWSF2WZ2fvyEvcOqBkEvbflEXx64Ald2XtbHtFVP6om7JuiUMsCiX/vBSCvPnOOkPCBgvtB4TNaF0VTjrnqJAVrns2CudVHNBfOmbJPVy3Xujl0BfsmxiiwQNcJXq8Xv/rVr2CxWBJ+np+fj2+/jU/2snnzZlxxxRWora2VfG6ihD96+sc7Yf9e2WVojX6/1kVkJKCIU160en5AdhyvloL5N2rdHLqCg6Dsway+SbhfR2zW/HKr+4PWxWNkmFN9WFa0zjh0QHPhnAnLLy3R5XZBLWHfxBgFFug6YsCAARg8eHDCz7q6jFDvsxRVe3YiVyZ7qtOb2jEhTOYh8kM2SVz9a2g/TiyLrXms1k2hOzgIyi7M6JtE/YvS/+ad92pdPEaGpSdqZIWrdftWzcVzD2txWvfIF5YOQ42rTuum0B3smxijwAJdJwQCAfzP//wPhg4dmvDzTz75BD179oz72+DBgw2fiKfa6ZB0XL+fNI6XDesc2Rny+te0F8/pMvstEI2fmX4pqRRqBkHvbP4DPt7/pK7snc1/0FU/mk7M6pvIOxqJByCLIDzfa108RoZ9tZdkxevHK5dpLs7TZQ9MmYDh27bAE9BXngS9wL6JMQos0DXiww8/xPr163H69Gls374dDz30EP7zP/8TZ8+eBQB89tlneOGFF2LXtx1l8/7776O6uhpjxozJmqNsPlyxtJM4z7VZsOHsGa2LxshA4fMQdunjfYTrWYkANwuseZzW1a9rOAgyLuybopBognAOuKwPK4jmm4g4tC4eIwERYcPZ07Ii9u2lCzUX0umy2uYmrZtA17BvYowCC3SNePrpp/HrX/8aV155Jf7f//t/ePzxx3HkyJHY5wMHDsTtt98ed8/69etx3XXX4ec//zl+85vfoLKyUvH36i0IAoDJB/d3cjJ5NgvWnTkNTyCAC55GhCIRrYvJtEIUgGh4PwUhm6XivJYztieDgyDjwr4pCpGAqB/U+d+/vR8oUguK1EV/8iov3XCusQH3TR6vuUjWyq4fWcb/PyaBfRNjFFigmwy9BUGeQABFZcM6OZocazF6lg+P7dG6fmQZxuzdbTjnQ0Q4WufE1vPn0ODPjmQtonEoJJMnmcEaPta6CXSPmkHQ25sfw4f7n9KVvb35MV31o9mA3nwTBdZL9AGF8adTOB8ABbZpXVzFEIVAwT2g4G4QBbUuTreJCIE7J4xOeCqMWWzJ8WNaN4PuYd/EGAUW6CZDb0FQsmQul9u4fXu0LnLKnHLX44EpE2JlLygtwfebN0AYbJChIyR8ELW9tRfJmtgNEM1jQCRA1Pl4PYrUgporITxDQL5pIGHeBIccBDFK0ZtvEo1fIrVTKAoganuCQkeSP1QnkH85hKPDIIP9ZpB/mdbF6hYbzp7RXCBrZXdPGIuNrVsCE8UXBx12fLd5A4auX4M1p08hYuLjYdk3MUaBBbrJ0FsQtOS4MoF+Q1W5Ic4eD4TD6De6MuFofuWuHVoXr8tQ+FwXxa3RZ9xbs9E3vA9R92BrUHsjRJMFREFQYB1Eba/W92wN6h39QeGzWjeZJnAQxChFb75JNH6B1E+hKIJo+EDrIqcEhQ629lOXb0EqBIUOaF28LjPpwL4uiVujz7jn2SwoLBuGT1Yux41VFa2CfQzmHY0OGP24ZWPsuvzSEvSwFuP5uTMRCIc1bjFtYN/EGAUW6CZDb0FQo9+PwgRL3OXsUpP+k6DMO1otWf7rR5YbdhadqAWi9mpl4rbuCQjnPToQ2emwQoj6P0PYr00Q8BZBuJ7Vusk0Qc0g6I1Nj+O9fU/ryt7Y9Liu+tFsQG++ifxrlfUFzru1LnJKiIaPJAYejDPIkIit588pFrcfrVyKXuXDNRfZalvb1sB/rl8r8bkF5Tu3a91kmsC+iTEKLNBNht6CIACYsH9vbIS3h7VY9lz0/NIS+GTO1k0H7pYWlO3cjhfmzcJbSxZi9emTSffCW7Zujo1WJzJPwJ+h0quPaPoxgRiVs146ENIKzPWqqs+jSK3WTZZxOAhilKI330QkINxtSeIKLvuZYKDO9Vzmyxg+AeH5R/TM9sYhoFDyPcii7g/S/VXdwxkodXoQRLhv8nhFM+JXV1jTeha52vbpquWKri8oLUGuxGd3jh+tdZNpAvsmxiiwQDcZeguC2th8/iwGLZqP+yaPx1+WLkLv8uGdhHqezYKPVmZ2n9zFJg/6ja6MlaXN+f9j/RrZ+2YeOSTpNPuMKDX0HjARcUI479deSKfN+iu8Xn6wgkLHtW6yjMNBEKMUPfomojDINz16ZGTdI7KnV1DLosyWzb8W0e00bbPhRRC1hSD/Ctn7hPtdSM6gu9/JUOnTw8azZ3BNpU1zIZ0ue3rWdNWedUNVudbNpQnsmxijwALdZOgxCErEjosX0GdEKXpY22fUn5w5FZ5AIKPleG/5EskR+X21lyTv84VCuH5kWadBhhxrMYZt25LBN1AXomDrHmyj7ylPYva+6ryj/WYQZXbFhx5QMwgatPEJvLP3GV3ZoI1PGKIfNRJG8U3kHY32Pdytg3Oe7zN6wghRCMLRL8HgYAGE/UbZrOwU3CMxqFgACu7K2Duozcl6F3qVD5ecMc4Wk1thmKrl2Sz4y9LMDijpBfZNjFFggW4yjBIEAVGRO/9YNUbt2YUdFy90OwBqCYVwwF6L842NKV1PRJL74/NLS/DdpvWy9x9xOnDbuKo4cf7FmpWGSHInBbUs0l48Z8w6zk7JifWrINzvXRb0Rn8n3zStm0wTOAhilGIk30SRWpBvCsg7ARQ+p8Lz6kChAyBRn9r1wV2yfRcFNsvf3zIHwn5Nh4HEa0C+2d1+Dy35eOUywyd8S8UKWrfOXb6qL5EIf3zGFNw+blTcNXk2C4rKhuOYq07rJtME9k2MUWCBbjKMFASpBRGhYtd29K6wxpzUEzOm4lxjQ9L7pJxffmkJvtqwLul3CyLs/OkCVpw8bojkdskQnn8gtaOHjG5FEO63IBo+hnDeDeF6BsI7HsJxRwfxHs3YTv7l0aWwzRUQjv5Rce58IONLXvUEB0GMUkzpm0QzRMN7HQYAiyAaPgORfI4SCmxLItA3pPDdPlBgXdSET61X0oxbx1Z1W/waxb7btAHPz52J28ePwuDFCzB2724UlQ1DbodM7f1GV+JMgxtOnxefrlqOXuXDkWez4KX5s3HYYde6uTSDfRNjFFigmwwzBkETExy/kmezoP+YkUmPGnl14VxJkb75vPmO0BJNJUj96CEjWyFEw4ed3p8oAGqZC+H5CtRcmTABXCaXuuoVNYOg1zf8EW/veU5X9vqGP5quH003ZvRNwv06Oq/OKYRo+Fj2PiI/hP06ib7rGpDwZugN9MODUycaKuFbd2xO9eFO7+/0eTFy904MXb8G0w8fTJhMl30T+ybGOLBANxlmC4KICP1Gj5B0dG1nhUpR46pD7wprTKS3BQCvL5pvSmdH4ZNQlsHdwNbwRfQsZPdbIO9okEhtawTDQRCjHNP5pvAp2QFCisjPcpJvVuu1RXE/yTclQ2+gL9pOgzGDjdqzE39ZtgjvLFuMRTVHDb1tLtOwb2KMAgt0k2G2IMgbDEo6ufzSEvyweWPSZ5xpcOPzNStx+/hReHjaJEzYv9fUDpG8E1tFehFiy93rHoew35WF4r0IsWRQjv6g8IX4uhA+UGAbKLgXRBGNWkR/cBDEKMVsvon8K2T7HgpsS/6MwBaI+lchnHdC1L8CCiT3Z9lKWAgMXrwg6tttJbFB9Y9XLtNcUKfDcm2W2D70F+fNQjAS73/szc3YeO4MTtS7NGoRfcK+iTEKLNBNhtmCIEGEaypLEzq4HGsxJh3Yp1nZgpEIDthrUeOqM9xsPIXPgppLITzfgvyrIUQYwvONDgR1msW6+832OvBOgrD3af/ccSsosFXDVtEPagZBf97wFN7Y8ydd2Z83PGWqfjQTmM03UeiQvEAPa7eFikQDKLgfFJE+qUSPEBG2XziP7zatx7+2bMJhhx3BSAT3Tx6vuaBOt009dAAAEAiH8fHKZXHZ3p+cORW1zcbPgaMG7JsYo8AC3WSYLQgCAMvWzZ32puXaLLiqwgZPQD4ZTzpo9Psxft8eXDeyLFaeuyeMkT22LZNQxAXyrwUFd4Mo+UoBCh1pPXpNawGdCSsEURDkX5XwM1F7VadZdjPCQRCjFLP5JiKCqHsUnXN6FEHUD9SmPOFLEA1fIi4RaP2fU84un25O1Luw+tRJnExxVnh29WFcP7Jcc/GcbsuxFuOZ2dMBAH9fu6rTUWx5NgvumzzecBMB6YB9E2MUWKCbDLMFQQAQikTw/vIlcQ7rxqpy7PrpYkbLUV3nxNOzpid0sLk2C3pXWDUd5SYSEJ7v4wNG5x2g0EHpe0Q9hP16ZN/SdpmZLeGLZnVPePRaEURTcQZbTZ9wEMQoxYy+iSKXOg9uup4ARTK7LJlaFkeXySfs84qiZdJQ3LlbWvCnuTPjfOYLc2ehwd8iec+6M6c1F86ZtEenT4YnEIgdw5bItl04n8FW0yfsmxijwALdZJgxCGrjTIMbc6uPYO2ZUwhFMrtf+KcmD66utMme05prs2DYti0ZLVdHyDsm8ayw/XqQSPz/CzWPlBCq2WiFEK4/AgCE/WaJawog3G9lstl0iZpB0Mvrn8Kg3c/ryl5ez0GQ2pjVNxERKLgL1DI3uqw8w0I42V742MBkcHdGy9WR5+fO7OQ782wWDJwnfXb7M7Onmyare67NAtuOrTjmqpO9bsrB/RlsNX3CvokxCizQTYZZgyCt+X7zBllx3sMaXab25pKFmpSPiCAct0iKTvJNTnifaPgI2XfsWj8I1/PovCqgEMIfPV9YuJ6E9Az6j5lsOl3CQRCjFPZN2hCdwU++Aop80zUp38l6l6zfPN3gTnhfxy1k2WLPzJqG344ZERdL5FiLcUNVOeq8XngC/tg56InMjEfDXg77JsYosEA3GRwEacMzsxMvbe9oeTYLvtm4TpPyEYVkgrMiiLpHIJx3Q9Q9BGquAlF07370XPQsnUG39+/8N8ftoIgd5F+a4J4CiNqeoPA5TdpQT3AQxCiFfVPmIYqk3B9SYJMmZVxz+pSs33xixlTcOrYKz8yejiXHa2IrEB6aOlFzQZ0OK7BZcFWFtdPfX180HxEh8NnqFQn3oA+YOBaC96Czb2IMAwt0k8FBkDb8Zeki2Rn0nFYnesqtXTIe4bhNJkAriP/d9UxU1Ae2ay+kM2pFEA2fAgDIOxqitncHQX8zKLBes/bTE2oGQQPXPYPXdr2oKxu47hnuR1WGfVPmIaLWHCJJ+jzn3ZodI3nKXS8rWNvEaNty9uGt28T+sX6N5mI607aw5ihaQiG8tXRh3N8fmjoRF/nfFQD2TYxxYIFuMjgI0oZN587KOtarKmxYduK4pmUk73hlYtX9YbxANY1d3V5nwhPNeB/YCqKQhq2nLzgIYpTCvkkbRNMPkF0F5fw9KHxG0zK+NH920i1iHe2jFdl59rmc5dosGLx4fqzOzjU2YNWpEzjksHP29g6wb2KMAgt0k8FBkHaU7tiGnFZH2jbq/+K8WVhx4jhaQtqLOyJqXbLeq0OAlqXL17tlPTngSQIHQYxS2DdpA5Efov6lDv19dKuO8PwTFNyR0lGb6abR78crC+ZoLoL1bDnWYryyYI7WTaV72DcxRoEFusngIEhbzjc2YvTe3Ri5eyeOuzJ7lE6qkGgABTaDQgch7DfqQBDryYog3IO0biLdo2YQ9MK6Z/HnXQN1ZS+se5b7UZVh36Qd0Uzyu0HNlSDfVN2ce345ZxsasPHsmaQr0sxoOdZiTDywT+sm0j3smxijwALdZHAQxChB1L+sA1GsFyuCsF8DCh3Tull0DwdBjFLYNzGpQkS4utKmuSjWi+XaLLhv8nj4dLAST++wb2KMAgt0k8FBEKMEEdyrA2GsB7sGouFTUPiU1k1iCDgIYpTCvolRwj83mC8JXCK7eVQlSrZthicQ0LpJDAH7JsYosEA3GRwEMUoR9W8ilXNys9kouEPrZjAUagZBz619Di/tfElX9tza57gfVRn2TYwSmgIB3DSqIpa93Yx2VYWVZ80Vwr6JMQos0E0GB0Hq0Oj342S9SxfJ3dINUTCa6dfeJypYHb+FaBwKUXs1okmFsjGRXCFEbVH098ahnBROIRwExbNhwwY89NBD+PWvf40rrrgC8+bNk71+3bp1uOKKKzrZ0aNH466bPXs2evbsiZ///Ofo2bMn5s6d2+X61hr2TepAkVpQ+Kwukrulm4tNHgxaND+WdPXBqRPw2eoV6GGNHluabeI9x9p+JGuezYKlJ2q0bgLDwb4pHvZN+oUFusngIKh7NAUC+GD5ktiRL73KrbBs3YyIyP5giCgUTSDXGvhRxA5qLodo+BjC+UD2CPWGv0I0vAPR+Gk0WR6Lc8VwEBTP0qVL8cUXX2DOnDmKgqCamhrU1tbGLBJpP4t669at+Pd//3d8++23OHr0KL799lv87Gc/w/bt27tc51rCvql7UKgGwvVkez/m+B3Iv1zrYmUEfzgUt8T7kMOOf25Yi/eXL8HVlbaYgDeq5ViLUVg6DEPWrcHgxQvw9cZ1OFmvzySzeod9Uzzsm/QLC3STwUFQ93huzoyE57H+uGWj1kXTFBLNEO7XtBfX3TXvGK2rMitQMwh6Zs3zeHHHK7qyZ9Y83+X3UxIENTQ0SF7z1FNP4b777ov727333otnnnlGcZn0APumrkOivvXEjcsHSQtAgS1aF09TjrnqcPv40ZqL7O5Yr3Irdly8oHVVZgXsm6Rh36QvWKCbDA6Cus5Bh13SgfYsHw5vMJjyswQRtl84jznVh3HQYU9jqTMLhU91OFPXeEaR7GkLLeEgSBolQdBvfvMb/Pd//zfuuusurF27Nu6a//3f/0VJSUnc30pKSvB///d/isukB9g3dR1qHpFAnOdH/1b/orJnUQvIvxLUMh8UuZSmEmcWQYSdFy/gxpHlmovtrtid40drXYVZA/smadg36QsW6CaDg6CuM/3wQVknWu10pPScc40NGDBxbNy9T82ahgZ/S5rfQH2IBMg3GaLuQYjamyCcD2kusrtuvUHkj75XcB+E52uIxr+B/MtBFNa4po2FWYKgCxcuwOPxxCyQQiblVIKgY8eOoaqqCnv27MHWrVvxxhtv4N/+7d+wYcOG2DVXXnklpkyZEnfflClT8POf/7xrFa4x7Ju6jmh4R0Kg50PYb0j5OeRfC2G/Lm4GXni+MeQ2nwZ/C77btB79x4zEzVUV+N24UZoL7a5Yrs2CF+bOAgCEIhEsrjmGz9esxFcb1mG/vVbjWjYe7JukYd+kL1igmwwOgrrO+jOnJZ1ojrUYTq836TOICL+fOLbTMvk8mwWvLZTvGPWIaPxcB8JaDSuE8AwBEUF4vm/9WxFEbc/o765nQGS8ARStUDMIemrNC3h++591ZU+teSFhopwhQ4Ykfa9UgqBEPPTQQ3j44Ydj/33llVdi6tSpcddMnjwZv/jFLxQ/Ww+wb+o6wvMNYkkt46wAou6BlJ5B4Qut/V3nEzvINyX5A3REczCIuyeOSbgdzYi26tQJeINBPDZ9MnpYi5FvK0G+rQQ9rMUo3rpJ6+o2FOybpGHfpC9YoJsMDoK6TlgI9B8zMqG4fn3R/JSesePiBVmRX9vclOa3UA8K1ehAWKtk7tejSzsD2yQFPDXbtK5yw2CWIChdsxSJ+Prrr1FUVBT772xbRsi+qetQ+ERCYR0V11OTPwCAaBouLfKd96b5DdRl9N7dWZHBPc9mQdnOaGKtHzZvlHynPZd+0rjGjQP7JmnYN+kLFugmg4Og7nG0zonfjh4RE9Q9rMX4w/TJqG/xpXT/vKPVsg55r4EcLXnHSgaFhrCGj0G+maBQ+/Egon6Q9PXOOzWsbWNhliAoXfv8EvHEE0/gzjvb/x986qmncP/998ddc9999xk2EQ/7pu5BLfMganvH91mN/0j5uDXR8LGEQM+HqL06zaVXlxfnzdJcXHfHSndsw5zqw3Gr8q6qsCa8NtdqwZB1qzWsbWPBvkka9k36ggW6yeAgqPusPXMK908Zj6sqrBgwcSzmHT2S8h69I06HpFPOLy2Bu8U4y6jJN8XQAp2C++PfRzQneZ+bNKpp46FmEPTHNS/iue2v6sr+uOZFRe/X3NyMffv2Yd++fbjiiitQUlKCffv24dy5cwCAzz77DC+88ELs+mHDhmHevHk4fvw4Dh8+jM8++wxXXHEF5syZE7tmy5Yt+Pd//3d8//33OHr0KL7//ntDH2XDvql7EEUgmqsgHLdB2K+FqB8ICh1I/X7vKCTex14AUfd4GkuuPq8vmmfYo9WuHVGKQDg+50my7XUfrVymUU0bD/ZN8bBv0i8s0E0GB0HdY97RI9FR61bnn2ON/hy2LfWjbKSOaus/ZgSOuzJ3tikRgYI7QM0VIN9kkKhXdn/EITPjomcrgHC/2WlQRXiGyd9X/7Ka1Z/VcBAUT1vm28tt4MCBAICBAwfi9ttvj13/ww8/IDc3F//xH/+B//qv/8Ktt96KJUuWdHrurFmzUFhYiCuvvBJFRUVxQZLRYN/UPaIz4PkdBhmjOTQosC2l+6NHtV2fuE+vfxkkmtP8Bh3KQgFQyyJQczmoZQmIUj8hBQAWHJNfqaZHa1uRN/VQ50GVeyaNk7135uGDalV91sO+KR72TfqFBbrJ4CCo64QiEVwvcUxLrrUYTl/yJHEA4An4Ey7By7NZ0KeyFD81pb9tiFog6l/oEMgVQNT2AvmVjcSTb6oOBLcSuzo6IJEg4BOuJMfDeSeoVf1ZDwdBjFLYN3UdCh2WHox0PqLgOUeiM/CdnlMI4Xo6I9ncKXwCwnFLB9+UD+G4FRQ+nfIzIkLgjcULNBfdSuzWsVVYeqIm4fsUlQ2XvbfR71er+rMe9k2MUWCBbjI4COo6cueg97AW44fNG1N+1pdrVyWcRc+zWfDd5g3JH9BNhOdbdF7OWBCdcYkoO7qFQkcgGv8OYf+dDgR4spnzt6TrpPHv8vd7vk15P6fZUTMIemL1QDyz7TVd2ROrB3I/qjLsm7qO9DnordYhz4bsc4ggHHdIPocCqa8U69J7EEE470PnWfwiiLoHFQ0QCCKsOHkcby5egKsrbZoL8GQ25eB+yXfp15r3RmrmffWpk2pUvylg38QYBRboJoODoK5zzFUn62ALSktSPstcbsnaEzNSy7rbVYgoukcxYRBWCGquUv5M7xjEJyi6GsL9PkRtHx0I8w4Bpm+m9DuETyS/v7miO1VvGjgIYpTCvqnrJE3Y6XoqteeIepn+rwjUXJbe9wgdkO9/Q0cUPc8fDuHtpYvi/OuNVeX4fM0KzQX55SL7gqdR8j1G79kle3+uzYLdly52t/pNAfsmxiiwQDcZHAR1HSLCneNHyzrZSQf2pfSsZ2fPSJjEJtdmwWuL0nseOlFIJgjqCeH5Tv5+0QCKOLuLUD4AACAASURBVGOzGeRfmXi2Wnf703tDuN+FaFkuuadReJMs2bdfB6Lkx5WYHQ6CGKWwb+o6FLmYfHAxfDb5c8gf9QEJn1GQ9vPQyb9W/h0C0md+ExEc3mZ4Au3Lvb9cu6qTn82zWXBDVeKtalrZTVUV+GrDWuy4eCHhKoGIEBi8aL7k/Xk2C15dODctbZJtsG9ijAILdJPBQVD32HD2jKSTzC8tQcm2zSk9R+64tZUnT6T5LQDhfEByxoVaOif8AAAKn+ywbz0fwnkPhH8thOtZJF5eqTeB3tF6QThujZ5/HtgaXzfNFUkC3VNpbx+jo2YQ9Niql/HU1kG6ssdWvcz9qMqwb+oeouEj+X4ruFvBcy7vuwsganuDhDut70ARu4QvifoTitQlvG/FyeO4o3XwPMdajOfnzkR1nQMFpSWai2+l1rvCitvHjcLna1biTEN8fT89e7rkfTePqkxr22QL7JsYo8AC3WRwENQ9iEh2P1iqe8GICF+sWRkb/W7bj/7NxnWZScTjX55YUDvvTTi7HM3we7OE6O4tGxjq26LBIPlmJamb9utJNKS9fYwOB0GMUtg3dQ8Kn5UdkCQhvYQ67jnCDVH3cOt9PdGeQHRVmt8gimj8GzoPHhdANA5NeP3Gc2eQY23Pgt5xRZvWYrs7lmez4KoKG4652gclPl+zMmHumhxrMR6ZNikj7WN02DcxRoEFusngIKj7zDxyKKEzvW/yeESEsiRihx12WLdvRemObXGOOBNQy2II553tQtX9LiiS+Jg3aq6QmdmQMgOdkW6/DkTR/AFEQQhHvwTvWwThfjeTTWRYOAhilMK+qfsI9zuJ++kk25YuhygC8q+BaBoG8k6Q9AvpgCgE0VQCYb8u1jeLpuEgCie8/o8zpxn2zPNURPorC9qXrsslqp155FCmmsjQsG9ijAILdJNh9iCIiLD70kXMO3oE++21XZ6tnn7oAPqOqow50beXLoLL5+v0XcFIRI1ipw0iAkVcIOGTvU6431QouAtaA0XjiHQKtG9PoNBBCEff+IEG1x959jxF1AyC/rDyFTy5ZbCu7A8rXzF1P5oO2DcFQf61oJaFoMhPXXxGAMLzNUTtVR3ErRVEkcuui0gKXr1AFAJF6kAUkr0u2RFkiURvQekwzcV3qpZrs0B0iFOmHjqA/Nal+22rBIauX5ORlXfZAPsmxiiwQDcZZg6CLjU14YEpE+Kc3+MzpnQS1qkSEQI/NXnQFIhPGuYPh/DtpvWxo10GTByLxTXH1HgFzYgeQaZgT7n9+iTiXOlsfCYE+va4d44GzMujM0jBnRwAKYCDIEYpZvZNFNgMYb8xfoCzcWiXj3Uk8oMilzptV6LwOQj3W619eQFE/cugULUar6AZt4wZqUjwXj+yTPIzPS6Lzy8tiRPoAODy+TD98EFMPLCv0z51Rh72TYxRYIFuMswQBJ1pcGP64YNYVHMU3mA0QCEiPDJtUqf9W3k2C16YOyvJE1OHiDBw3uy4JXdtTn9utbIjYvREsuNvYua4E8I7TXOxrcwKIOw3SWZ2Z5TDQRCjlGz3TUQECu4C+aaDAptjs9oUcbTOeHce0CTvWPW+P+KCsPe9bHC0CMJ+DSh8WrXvyTRlO7enJHTfXroQQ9at1qUIl7Lo6ryFWldxVsG+iTEKLNBNRjYHQREh8Hlr4rU2611hxYqTx2X3bvWwFuNsgzpLl+cdPSL5Hf3HjOw0Em4kyDsxNcHrHgR9Z3DvaEUQtYUg/0qtqzerUDMIenjln/H4ljd0ZQ+v/HPW9qNakc2+iSJ1EHWPxfc9zgGg8DlQcyUkVxQ5bletDML9F+k+sPEL1b4n04QiEdkjyNpnzst1d7xaImsbQMi1WXDTqAqcb0wtuR+TGuybGKPAAt1kZHMQNHrv7oSZXPNLSzDl4H5Zp7j1/DnZZ19s8uCDFUvRq3w4isqG4+2lizotLXO3tKBnufx+uEtNTemsgrQjPMOSi966R3UgvGWsaRRE45cQ9X+CaPwbKHRU62rNOjgIYpSSzb5J1L+UYNCyCMJ5H0TD3yB99nhh0mdTcAeE67noM+w3QzT92CmnCAW2yPeJzrvT9eoZ46HLtq9dbno/ci3XasGc6kMYvHgBnp0zA8O3b0FdF7ffMdKwb2KMAgt0k5HNQdDvxo1K7PhsFvx93WrZEWt7c3PsOS2hEFafOollJ46jwd+COp8PN4+qjFsen2ez4NoRZfipqb0eR+3ZJe+AbRZ4LtuvbjSi56DL7S0vgGh4P0EwqhNz9O/yvk4mdTgIYpSSrb6Jwhfk+6TGryX61AII5/3xz4rYQf6loMDGaI6MwBZEZ987zsAXQriei+vnRP2L8mVwPZHpalGVYCSS8Pixjnb9yDLcPWGMbpe4f7BiqdbVaArYNzFGgQW6ycjWIAgACssSZ2bNs1nwyarleGXBnE5OPNdmwfvLl8SesbjmGK6qsMWNuj8/d2bCY1zybBZ8tWFd7N4PVixFrowDHrx4vga1oi7C9XSKYlirDO4FEHXPQ9Rek+Cz3hC+RSCRff/v6w01g6AHV7yKRze/qSt7cMWrWduPakW2+iYK7pbvs3yzojPfCZa5U8uC6DNIQHi+ib/G0RfCeW/C+0RtPiiwIVYGYb9Jtgzkm6ZV9ahCIBxOSQTna3wc2/NzZyYcILhtbBX2/HQRIZ2f+pINsG9ijAILdJORrUEQADwybVJCIZ1jLcbYfXvQFAjg7aUL4/Z4fbxyGfzh6DEu1XVOxeep3jt5fOz7f9yyUXIUP7+0BA5vs1TRDYOy89B7ayDQO9o1ELV9o2bvF1+uph8hRAso4ux0BBHTfTgIYpSSrb6JRD3kVhRR+AQoVANR93D73+3XgbwT2p/hHZ94MFKy7+sJ0fRj7P64Z19uznuyog9Uch56noYivYc1Opt//cgy9B1Vias7TAjcWFWBJcePwRMIwN3SonWVZiXsmxijwALdZGRrEAQAK04eTzjLfcPIcjT6/bHrnF4v9tVe6nS82t/Wrkq6TO5y4f/kzKmx+880uJFnsyQcIR+zd1fG6iGdkPBAOO9WINK1tiIIx+8kAuTWvzn6gbwT+Rg1FeEgiFFKNvum6DGVlwvqQgj3a3HXUfg0KHQARP74+x13KOz3CkHNFe3P9c2QuK4AIliTkTpIN3sv/YTCsmHItWo7S55q7HDb2Crkl5bILrl/cMoEbLtwXuuqzSrYNzFGgQW6ycjmIAgAZh05hBurKmIO7rEZU3Ci3pXSvS/Nn63Y0U47dCDuGUuO18QlisuxFuNva1cZOnv75ZCoh/D8UwfiW11T80gjs6NmEHT/8tfwyKa3dGX3L38tq/tRLchm30QUhPB8hfZVRYUQDR+BRGqrqqQHRAsSCP/o3yncnviUiFqXyHe89qrYEvpsodrpwFOzpmkuwJUIdbnPc63R1XcHHXatqzZrYN/EGAUW6CYjm4OgNkKRCGpcdbio8B2/3rgu4Qx6rrUY/UZXokers8xvzQY7ePEChEXnhGNNgQAWHKvG9EMHVDu+TY+Ixi8kgkODmv1GPgtdJTgIYpRiBt9EohkUOgYS7uQXdyC611yir41t3+mJ6KqgApB3UuLvD18A+WaCWhaChLFPFJEiLARuG1ul22RwSi3PZsGbS/gsdLVg38QYBRboJsMMQVBXOdPgji6Ru0yk51iLsfncWWy7cB5D16/BkHWrsfHcmayaFe8KRC0Q7sHKRLD7I5nZIO2Nwme1rtasgIMgRinsm6ShljkJ+qtCCPuNEBEHqGU+ROPfIJqKQeETWhdXc06563Hr2CpFQvjTVcs1F+NS1m/0CK2rNGtg38QYBRboJoODIHm2nj8X59ivH1mGeUePaF0sXSP8ayAc/VMQwIWgiB3CPkBzIZ7YChTPbDGJUTMIunfZ63ho49u6snuXvc79qMqwb5KGiEDe0RD2Pu39Vd0DoNBRrYumW4gIw7ZtRpHE6S4d7a4JYxBMMRN8pi3HWoyHpk7UujqzBvZNjFFggW4yzBoEXWpqwpzqw1hccwxNSc4iF0Q47LBjX+0lBA187Im7pQUzDh/EhP17cdyV2j78riJEEKLhr9LLMHVvRRDuN9NaR2aCgyBGKWb1TRQ6BPLNBgU2Jc2mTsIHCu4BhY4bOqklhU9GE3P6ZoJEfVq/q8Hfgt9PGqv4hBaly9DTKdKnXpbrhuk67JsYo8AC3WSYLQgiIvyweWOcc+5ZPhwLa7o38+APh3Ci3oX6Fl/yizVgbvURFJQOi43A97AW45NVyxFJsGe+OxD5o8mH7G3njmt9tNplS0BTEea1+RB1D4Ei6R3EMBMcBDFKMZ1vEk0Qrhfi+yPnHd1eok7CHT26jfR3TBeRgGj8MrZiKfqzJ8g3R/XvOtfYgFcXzo35v4LW3DF6MKn98R2PgG2LWT5dtdz02+nUhH0TYxRYoJsMswVBs6sPJ3SEuTYLalx1ip8niGDbsRW9K6yx57yxeIEmZ5bam5txxOmALxSK+/uJelfCAKDtPHg1Ee7XUxTCehHmrUFh86jorFVzBSiwLivOAdYTagZBv186CA9s+Iuu7PdLB5mqH80EZvNNouE9dD7+sQjCcTuIwoqfR6IRwv1Oe/9n7wPRZAWRuoOySctBBAqfap3lj+9XyTtJsl+m0DHVyuBuacFNoyriZrZzZISxHizPZkFR2XCsPnUSo/fuRuWuHah2OlSrEyYK+ybGKLBANxlmC4IenjYpoVPOs1kwdMNaxc8r3bEt4bMenT5Z8ZLDri5RdHq9cUfC9SofjmHbtsRG2b/dtF5yyd2dE8Z06TsTlj90RAdivIPVPQzRZJW/xnkvyL9GtTpgEsNBEKMUM/kmEm7ZgUQKrFP2PCII19MJBH8+RJNV8bO66psouLs143zrdztuA/lXxT4XzvuReBtUEYTnmy59ZyIqd+3QjRjPtRbjpfmz8dfVK2TLNGjx/C5NGjDKYN/EGAUW6CbDTEEQANxQVS65lGzw4vYzYIkIp9z1OGCvRSCcePYiEA7j6kqbpIPdfuF80vL4wyH8sHkjrh1RhhxrMR6eOhFrTp9K+X1qm5tw3YiyhN9ftnM7AOC95Usk99tdVWFL+buSQb6p2ovyjub5EcK/Qv4a72ieLc8AHAQxSjGTb6LQcdl+inxT26+lECh0GBSqkRTOFNwt/Tx7HxD5k5cpfB7C/S5EbS+I2p4Q7jdA4dR9k2hZISG+C0HBfdFr7DdIlLMQouHdlL8rGYMWz9dcmMd8brkVE/fvRemObbIC/QjPlmcE9k2MUWCBbjLMFAQBwJ/mzkwoVnNtFpRs2wwAOFrnxANTJsQ+u6ayFBP27+30rDMNbknnmmMtxrgky8eJCC/OmxVXnrbfl504nvRd6lt8kgMObeUORiIYtWdXwkAg12bBM7Ond60iE72Pf6n2ojyh9ZQIFNtmdW4FtSxI/oJMl1EzCBqwdBDu2/COrmwAB0GqYybfRMILUXuVtEAP7o5e17IIwtG3/TPngNhncc/zTZYX/OGT8uWJOFu/p+MMfBGE/XpQ5GLy9wnulOlzCyHcbwEARP1AJF45UAhqHtmFmkzMRyuXaS7Mu2KPTp/MQj3NsG9ijAILdJNhpiAIADadO9tJrObaLOhdYUVtcxMa/X5cO6Is4ZLwyxPJeQJ+2WytS0/UyJZlx8ULkuL+zgmjky4rHL59S9JlexebPGjwt+CGkeWdyppjLcamc+qd803k14EY77p1XHrJqAsHQYxSzOabRNOPCURtEYTryegy88CWBJ8XQtRe3Uk0k3+VTF9XCBINScoyTEI4F0F4vkr+Lq4n5ftb553Rcga2tb5TQfx32G9SNZv79EMHNBfbXbFcmwVXV9pgb25WrS6YeNg3MUaBBbrJMFsQBAALjlXj5lEVMSd47+Tx2G+vBQCM2btbMqHa/ZPHd3rW+8uXdBK+uTYLbqyqkFwa30bZzm2yAj9ZRvjHZkyRde4FpSWxhHGn3PV4etb02Ge3ja1KOoDQFYT9xsyJaoea56cXQNQ9pnp9MFE4CGKUYjbfRBSGaPoB7SdfFEC4B4OEGwAg6l9Gwj3ltUUQTf+67FlBCEf/BCK7CKLhvaRlie5fl+gr6x5I8h4tyftb1/Pt1/tXQjjv7PDZs93OXH85J+tdGRPVvSusyO9Chvhca+KkdTnW4tjqPkZ92DcxRoEFuskwWxDURlgIVNc5ccpdHzdT/dnqFZLOtaC0pNNzPIEAnp49Pe66m0ZV4JDDnrQME/bvlZwBz7NZOmVjv5w/zZkhO4P++ZqVne5x+rw439iYtmNaRFNxglketa0wmp3Y+fuu3y/xWSp7MxnlqBkE3bVkMO5Z/66u7K4lg03Zj6YTs/omEs2g0BFQxBn3d+G4RbpPc7/e+TmhI60ivaMwfgYkGpOWQdS/JtFPFkC4npUvPwUlBhI69LP+5ZfdI0DhC53eWS2ICA9MmYDcDAj0Cfv3qv7MARPHpqVeGPZNjHFggW4yzBoESVG6Y5tkQrXfjRuV8B4iwt5LP2HSgX1YefIEgpHUko45fd6EgwF5NgveXLIw6f0zDh+UdOj3TBqbVOCnAxK+DrMv8kFal61+EERgI0T96+o/2zM043VmBjgIYpTCvike4XpKQjQXSfZbRCGQfzXINwUU3JtyNna5fCLkm5m8rO53pPt/z9eK3lstalx1uGFkOXKsxZI+vjuWZ7Pgn+vXYsfF87iqQjp5bFdt9Sn5vAFM12DfxBgFFugmg4OgKDWuOny9cR0GLZ4vuey8V/lw/GP9GlXPOJ9/rBp5NgtybZaYWL9zwmg4vd6k94aFwKsL58WCg7ag48mZUxFKcZAgHRCFo8sWG/8J4fidyiK6T3xg2qVnyM3wX8Wz6GmAgyBGKeybWo84C6yHaPwcwvUn6X7LcSvIO1a1EymIKPqdsX62Z/T3hvdS+g6K1EI4bm/tawvbBxaahqtSvq7iCQQw8cA+fLxyGYrKhql69NpV5cNjv/csG6aqOM+1WfDCvFma1l22wr6JMQos0E1GNgRBa8+cwqPTJ6OgtAR9R1eidMe2lGexAWD64YPI6SByc6yJ94K1CeG7J45RdXb6gqcRth1b8Y/1azDv6JGke9c7EhECK04ex0crl+HDFUux7MRxRIRQrWzdhUQzRMNnl838RLMBqy+uU7HeEO73Za+hSK3W1ZZ1qBkE3bH4DQxY956u7I7Fbxi+H9UbRvdNRBGQd3SrUO0JUfcIyL9Mwf0CoqGtrypKYUCyAKLxCxXLT9Hj2jzfQ3i+BQW2KzoPnUQzyDsh+g6eoaDQQdXKpgY1rjo8MWNqnH/vWTZcdXGdqj0ybRJ+O2aE5Od3jB+tdZVlJeybGKPAAt1kGD0IWnL8WHSEuYMjy7EW480lqR2b5fR6E86Y59kssbPJL/8sx1qMSQf2pfnNsgfR8PFlwrr19yYbhH+NyjPscnYNRHAfyL9W+hr7tRANn0aTMzVXqJpJ2MxwEMQoxei+STR+mXBwkXwzUrqfWhbLDFLKHMkWPpPeF8sSmoNB3D5uVJz/z7VZUFBaglWnTuD7zRsyJs7vmjAa3mAQQ9evkYxHHp0+GW8vXYg3lyzEnOrDiiYhGGnYNzFGgQW6yTByECSIcNvYKkmnl0qitkkH9ile5pZjLcYbi+MHAIKRCKrrnDjXKH98jRyLao7isRlTcGNVBZ6dPQPrzpzu8rP0AoVPy4jhGyBEIMVl8F2ZOS+A8HwD0VQG0bIstjRThC9Gv1vyvraZqkII+82gsPHbQWs4CGKUYmTfROFzMv3ezSBKvgJLuAdDLqGlpED3TYsvi/BEk851cbCRyA9qrogm5XT8FqLho6TnqBsBqSSteTYLBi+eD5fPl9Je9YIu7mcfvXcXbDu2Ym/tpViZFtZUdypTx//OtVlikxFPzZqmaLUdkxj2TYxRYIFuMowcBF1qapJ0frk2C0bt2ZX0GaP27FKcMCbPZsFHK9uXKs44fBDXjyyLW6pW46pT9C5lO7fHyt3x5/TD+loWmAgKHYVo+DB6VI7rKVDL3NhSSPLNlg8oG/8JYe+fPPB0vdElgU7hC/FljTgkjh+SEev1r2hRrVmFmkHQ7xa9ibvWvq8r+92iNw3bj+oVI/sm8s2SF9GhY0mfIeoHdqHPywe1RBOMEgUhGodC1PZqH3BseB8kUj9Tmyjcuvf98nPKrwGF1D+mU21WnDyO5+bMwG3jqjBo0XzsvtR+Xvxfli2S9P3XVJbiy7WrUJTCcvc/zpyqKH7IsUaXq1++XWDj2TNxAjw2ACBxqkyOtRhj9+3JdJVmHeybGKPAAt1kGDkIavT7JWe/c6zFmHboQNJnHHE6JO+/bmTiJe49rMXYePYMAGDZieMJBweuG1mGBn9qyeTqW3ySR7v1GVGq61FyCu5sDQDbZp1bA7nGf0Q/96/oUpDZyZoq5WfKawviZ75r8yGafmwvZ/g0KLAVonEIpPdySs3SFygKapnOcBDEKMXIvon8y+RF9GUDhwmf0VwlMZBYFJ3JTtiPXR3rq0Tj3xL0aYWKBhyl++8iCPebXa6fTHD5oHdea36ZZSeOAwC+WLsKeTZp8Zuq4C7ZuinpNR3LkGuzxFbHCSLsr72EbRfOYcDEsYpX8z06fbKWVZwVsG9ijAILdJNh5CAIAF6aPzvhnq2C0mEpZ1t/d/niTsvIcqzFWHL8GP44c1rMsbY587+vWx0b/X546kRJ5zl67+6Uvn/5yc4iv6N1HPXXG6LuD5Kz0RQ+AaJA63LyBIGiEoEevgDhvEf6c++k1rPR74RwPQtqWRRNchRxyGc/TnVWSnR96wLDQRCjHCP7JhK+aD6LTv1eEYTryRSf4YFw3nWZEC+CsN8MEdga/RkbmIxa2/niJOplBiLzU579Fo1/RyyDeye7qsv1k26cvsS5ZXKsxeg7uhIRIbDn0k+KxHAi611uhdPnlRTWvcqHY/aRQ3hq1nTcNq4Kby5ZiP32aBLSHRcv4JaxI7v1/fdPmaBxTRsf9k2MUWCBbjKMHAQBwEWPB/3HRJ1cfmlJq5C2YMGx6pSfERYCo/bswp3jR+OqChv+NGcGtp4/F/tsyfEafLpqOf6+bjV2XLwQtzRNaua7h7UYT8+antL3rz1zStYJp7KXXguiQaCUqC0EeaPnxlNgC6JJjQo6BHsKjkirewhAoqRLreb6E4TovKeTiFoHEFL5LqnZ80KIukczWq/ZiJpB0K0L38Idaz7Qld268C1D96N6xOi+KZqMsmfrYGTPaB/j6AsKn0j9GREXhGcohL0vhP1GiIbPYrPvJBpB3nEQjZ9CNJWAwufa7wvulu/vvKnNvArP19L9p/16ZRWSQeYfq5b1qdVOBwDAtmNrbABezpdL2Y9bNiIYieCO8aMTfl65awdEgsz3PzV50LN8eKfl7FKWaAAg12aBZevmTFdt1sG+iTEKLNBNhtGDoFAkgoXHjuLtpYvw0vzZsGzdhLMNmZvtlNujdvu4USk9IxAOo09laScnnGstxm3jqhI6eD1AolFW8JJ3XPu1ERfIOwbC803r/szeqYlz+29BkVpQ6JDMda0BZN1joMDG9u8M7lI2U+565jKxHj3/l4I7NKjd7IKDIEYpRvdNJBohmsdA1L8K4f4LyDsBJJoy8t1CLjlnbT5E4z9Teg4F90j3uY1D0vsS3WBxzTFZwXvc5Ypde8xVB8vWzfhm4zpMP3wwZXE+cN5shIVAxa7tstfl2Sx4Y/GCuLikZNvmhDP8iSzXZsFt46rirs+zWXDL2JFw/X/2zjs4qivL/976zW7tbO3u1G7tVG2cGZSJtjHYOGLjOM55ZhzG4zD2OI3zOMexzRirBd0KKIEQAhGFECAQOQsECEQSICFEEKi71UGtzuGe7++P193qVr/3OqglddP3U3UL27rpPeF3zrnn3HOs1pF4vZcVXDZxkgVuoKcYyawEtet1/rqhPuP2ngXzoLEM3X3hDoMe+y92weRwAACuL5euW3pvFOFnG063+73/vprsOQWz0NQVelfR5HAgv2kP7l1Yifuq56Ng3x70efcjhpsx2N3xq9seiBA+LuZhCU3QFjSue0JkRnNfvtDf9E0EnvBsYV2vkU7WJRF4zb1zGl4DYw6QdSFYz4NgmhvBDG+AXEeH5L2lGlwJ4kRLMssmsq0OOIT0HvgZ/+KvJBH39cgNch0BuQ4L/8z65L99plkRzy140X0Hlt58H9o7RbPCk/uMEOmkvQdM9zTItlK2djqRE0TOmJ5ZDpPDgZyCWaHGrlI8QZuP8729ERvox9RCZNvUirKwfTNUClxTUgitxQIAeL1+lWxy2jSlwm+QV7YchMFmw/Rd23FLRRlumluKb3dshdZqift7S0W4bOIkC9xATzGSVQliRCE1TH2C8OkVSyOep8/hwHGtJqywO2s04uHFC/zrZBfMhKJxF77dvkUyJG3G7h2ycw6kw6DHtzu24pXVKzFj9w50ifxO+hwO3FVVESTc01UK3FVVAbMzWNEx2Gz4cGMDsr1e/nsXVsa9dBu5ToGpJ6L/Trlg8JJ5tnh/coIZ3ozCsz0a5G4HM76LyO6tZ/lD0smxR96YN7whlAyyrwdzHgezLATrmwlm/BSs9zOQfTOIWFzfV6oSTyXoxro3MHXTewnVbqx7Iym/o4lMssomcndKfKuyQJbyyOfxqL3l0eS9pGTf4q1M4V1Hcz2YbQOYRjpnBzn2Rr4PIpBjlxBKb3gDZJkPYqHyUohymoCQZJ29n4v0PQamfzbgW/wnkPtsxHuKhKXHj/oPu326QU7BTNFDb0Awzm+vnBOxgX7z3FJYnE5cOTs/Yk+4LyT9h107JO/IX19ejNfrV+GLrZvQ0n0J2892ouLQAUzfuR0fbFiHb3dsxXFviD5n8HDZxEkWuIGeYiSrErTnwnlZYXjB1Cs73s0Yvt+5zR+inqbMxZ/W1IlmXne43bhxbomoQM1tghU3ZAAAIABJREFU3ImJJQVBd8nSlbm4prRwSDz5Rfv3Il0pLthLDuzz93N6PLh7wbygPacpBe/8dm8G+nhBnm6wvjyhLJDxPVnlj/XNiNDQDmja28DMlYimFrrgmWGCJyfE8y4Y50RMSGJn+JOENz4TTP9SRDWLOfJwJYgTLckqm1hfrnS0j3Za2PHk0YLpXwwYNx6sTyl6WEiu4/7IoeDIoGww89xgD77vn/XPyXq1Y35u3VOS33ZyHe/fs/u08ExBfYXkd+SJrjxpOA6ru/HhxgY8XbMU32zfgk6jQbQfEYXIy3AtTZmLz7ZsxAt1NRGPe2KpUKP+XK8RWfl5onfLq44cAgB0Gg2YOi/UO+/TNSIpI8sJD5dNnGSBG+gpRiIrQfsuXsBr9atwz4J5eK1+FfZf7M9mHi4JzMFLF2Xnnr5zW4hwzFAp8MTS6hDlZfWpE5LrTCwpRIdejzfXrkZOwUzkFMzEn9etxvle+QOCWHlkyULJvTy6ZKG/n9QdvHRlLh4aodIsRG5vZuMojHNfs28G09wirfgGtfF+ZZY8XULIulg/zVQwwythDwzIUjUi7+tygitBnGhJVNlExEC2GjDdM2A99wt5NTz98oYZ/yLznRofdm7Wc5/oeDIXhfRnxo8k1soBM74LcuwE0z3hN4BZXy6I7PF/J8wq8w3NAZkLAvb8scSes8H6lHHfWyTEmtE9p2Am9l447y+fFs6D/sfVtf41t3WewcSSAtG+jy+pxtR5oRGCA1uHIfSaASc6uGziJAvcQE8xElUJWtF6PCQ8LU2Zi9oTQnb2dr1OUmhl5eeh1y6thJidTtnkboe6LwX1n7lnt6ygjLTeeTx4bEl12NN5APh622bZrLQjkXiOmCk247w7E2SrBXkuecPj5Yz0HLDeL4LXJQJz7B0Qih9pywLTPTbs7+pyI55K0PV1b+LmTe8nVLu+7s2E/I4mM4kom4gIzPh+v0Hp9/5OBLlPC30sUtE+2WC6J+Xnd+yQ/hapJ4bc12Y9j0r391a/GA6IbBLPLDx34OEC094uvWf9s8O250Dq2+STysk1rdWCPRfO46FFVX7PulTfhtNtQes6PR6UH9wvmiA23LoZKgVm7d09Iu/rcoLLJk6ywA30FCMRlSC724Xxs1WiQmnC7Hw43G4AwB9X1YacWqcpc/Ht9q2y87dqNbKCb/HRw/6+RIRX19TJCkm9bfgyqZYfPCCqAKQpczH3ULO/36y9uyVP9MfPVg3bfgMhYkLytVgM9IC6vUROELN6k8D5Er15y7f1PARioX+XpZXmCJr2nuF8TZclXAniREsiyibpyhA5YIZXhT7MBKaZInqQSI5t8vNbymQPEQM99cT6vFFFUt+tu4YklF0Kpv+D5OFpYGk5pntc+gDD8Naw7TcQuQN/uTa5rAge1n/1wOpywepy4q2GNRilzEWmKs9/uP/Flo2iv4/nV0YeIh/YMvPz8N2OrcP4li5PuGziJAvcQE8xElEJ2nnurKxg2u2tUW51ufDxpvV+T/GYQiV+3L0Tbiaf2KvHapUNRwu8o11yYJ/sXtKUuXihrmYoX0cQNpcLDy1egDTv2r728OIFsLn670qfNRola6d+s33LsO13IGSZH6WBnA2mf1F6Pvc5kLkQzPQ9yN4AIrdoP9b7oaTyKN9ywEzfDdXrSBm4EsSJlkSUTazvB5nvSE7/1Rp3pxAC7/uZ5haQrT7s/EL2d6lv0ZighHHC/IlzPYfc7d4opZz+b2d3JljfjOB+1sXS+w1zgDGUvFBXI+v9FvvZvJZm0bmICPsuXsD0XdsxY/cOtKi7Jde9prQwZu99vJO+piJcNnGSBW6gpxiJqATtOi9voDd6DXQffQ4HOo2GqEqJvV6/SjQD/M1zS/0n4i6PB1dL3BEb2K4rm428PbtgdQ19QjG724XKloN4umYpnq5ZisqWg6LPvuTYEaR778b5DjEeW1oNizP+ZW0ihYgC6o1H0rLA7INX2ljfjzEY6Nlg6skgz6XwC3BkiacSdN3KP+PGjR8kVLtu5Z8T7jua7CSibBKSXMoZ6MEeUvL0CIeIEVaDIHIId8VDDO9ssN7P+vu5jkX+/ex5EGSrGRZvupAwdIbwjTe8DrJvCX0n5AEzvhdgxPcb8sPp8R+I2enE2CJlxMbxVcX5/rJpg+HXC+ZJHgxI/fd0lQK/Xb54RK6qXW5w2cRJFriBnmIkohLkcLslS5dcVVzgD3EfDL12O55ctjho7pvnlqJdr/P36Tb3RXWana5S4NElC+HyDE2t21jo6jNh9v4mzNi9A1s7zySEQGd9M8N6foKa5o5BK27kPiO9puEVMPWkYK959wShBJv7XPjJOWHhShAnWhJRNpHzoHSkjeH1+KzhOhZcNq07E0z/YpD3nKzLo48G6ou89vlQQ0QgZwtY30yQWQVynRzpLQEA7q+eH7G8T1Pm4pttg49GW3ikRXKNP66q9R+u+3LyTC4tQm7jzqCIOU7scNnESRa4gZ5iDKUSRERQm80wORxRjWNEWH3qREiSuHSVAvVt8RPkRIQWdTeWHDuCHWc7g+6SAUI4ebZMMjmptuZUYigbiQq526NWLuNhKJOtDqx7TL9nqTtTKAtHbuFeu7sd5NHG4Qk5A+FKECdahlY2OUGeSyCKXDYRERjzgPV+0u/V9kfaXBvXOt5ELpBjK8i6DORqDf25Y1f0Bnp3DsijE1mN46PiULNsmLuYF32wMCJ8umVjkMc8Mz8P1d5cOCaHHW06HcwjGPl2OcNlEydZ4AZ6ijFUSlB92yncXFHqFzov1q1AV5/0GkSE6qOHcUuFUPfzuvLZ+GrbZrzTUI+HFy/Ae+vX4rDMPa54YLDZ8OPunZhWOQe3V85BbuNOvL9+bdjyKUFh8koFPtrYELc9JYLHO1qIGMh1CuQ6KRnaSZby0BBHueZois/emAFkXQqyzEsYr00qEE8l6Nrat3DDhr8kVLu29i2uBMWZoZBNRG6wvlkB5R4ngJmmh2RHDxrDrGCm78HUVwtjtA8JV2b0LwoJz/p+BHnUcduj6B5cp4Ts8Zpbhcztlmrhn6O8tkP2dfHbU4Rh+4mEzeXCUY0aF0ziZVCdHg+eX1njN5LDyf4MlSJue+sw6DGvpRmLjh5Gj3X4Es+mOlw2cZIFbqCnGEOhBG0+0yEqyG6aWyoZllW4b2/Inas0ZS6+2rY5bvuSo9dux63zykWzwkebxCUrPw9fb9uMvggiBy6YevHhxgZMKi3ElPLZ+HbHVhhsNqxtP4V7FszDKGUuri4pwI+7d/pD+7VWC9afbsOu82fDJsQbbsixE0x7a0B4+i2SiX/IdQLM8GpkyqV9e2z7ISfIsQfk2Alig78vyIkNrgRxomUoZBMzfYvQDOLZYMYPRPsTMTDdUwOux2SBdWeB7MMjm8h5CKx7rIgxPjbgoCHCpr4OZKmK6MoQOZuEzOzqSWDae4RKGMwOMhd4s9RnCpnibSv7x7jahGSdruND+Uqihogwe39T0B3zJ5YuwvneUEOdEWFLZwfurqqISN7HeohusNmwtfMM9l/sCone4wwfXDZxkgVuoKcYQ6EEPbR4geTJ8+JjR0L6m51OjC6cJXmvu9vcF7e9SaFqapTcc5oyFxnKXPx2+WI8t3I5/rZzG56rXSZbqzRdpcCt88rw+JJq3FxRitfXrgqJALjYZ8I1JYVByeoyVApcW1YUcliRrlLgxVUrMH3X9qD+15bNRlPXhSF/P1IQuUDmUjDtNMEbJZakqDtHVGEj8kReds0efb1Xsm/2JlzyKacTQNaF8XhsTpRwJYgTLfGWTcT08JdjFPlOkTv0OyodSp4Fpr03LvsKB9M9CemcHVlg6slg+t+D6V8DMxWAqW8QOYQY0HTPgPXcC6a9Q6iAMeBqD9k3o7+EZcCVIM0dA+b2/rO5TNhD0BpPjOiVIa3Fgs+3bMQ1pYUYI6JfZKgUuHFuiWhOmzadLrKIOZUi6vwoRARF4y7/3fJRylzcOLcEBy9dDD+YE3e4bOIkC9xATzGGwkCXqumZmZ+HT7dsDOm/7+IFWSG4tv2UyCrx5aHFCyISyOkqBdKUQj32qd5w/IjGeYV5YAm3L7duiqn+6cB5xxTOgtY6vN5hYhZvyaEx8oqgL4xdxENFrhORe376lNHtz93uVS5DFdWRLOWTqsRTCZq04m1MWf9hQrVJK97mSlCcibuB7tgr+40h+/qQMaxvlojnOmAMM8dlb5J7ZuYoPOReI157D1j3+PBGeuA4zY0gj0ZYkwhMe3sU4zO9Bx8DDxFywHRPDOn7EeOM0YCXV9dGLENXngy941/avC/iq20HLnVFtb+qw4dE9YpxRSrobTy0fbjhsomTLHADPcUYCgN9stcDLHbaPHNPqCf0pK5HVgDuPBe/5DtSPLakOqrkMGnKXNw+fw6qWg5GZVBPq5zjP3GfOi9yAz/coUHxgfjc0Y4EIg+Y7jfRKXA994fOE3GyuByw3k+j2iMzfSOhWGeD6Z+L05vgRApXgjjREncDPcz3hpyhNa3JMkfE8Ow3SuXursdlz2SL0lD2fuN6PwczvhvdGNN3wpqeS1GuJ9+GM9y9y2TClcX5EcvyzPw8zNi9I2SeuVEki6tvi86BICX305S5KGveH69XwYkQLps4yQI30FOMoTDQZ+7ZjTRl6OlzhkoheueLiHD3gnkh3uR0lQLXls0elnvW0QjkwHZcq0FOgXh4vlTzJajx3TEfbMvMz8MnmzcM+TvyIYQ/RqOk5YAZXg2dhwhMe6eMAuxrWSDrAhAzC/cgjW+B9X4Bch4Uagzb14Gc+/xJi4R7o09Kz6e5ZdjeFUeAK0GcaBmSO+g9j4kc3OWAae8UDVUmT7fEQZ94VNBQwPQvSuxBpqkng5wHohujuVV4ZqaPr4Fuj1/S1HBEG5WWpszFgiMtIfN0mUwR6wNnjAac7+3FjN078MbaVcht3IkuUy8OdV9CfdvJoNKtNpdLct7M/Dx8JhJhyBlauGziJAvcQE8xhkIJcno8eHn1Sr+RnaYUEqfViYSS+TjRo8XEkgKkeQVVmjIXY4uU2H8xuvCxWHG43Xhi6aKojeOmrgv4ZPOGqJQC3536ov17RQ8yfO9NTJmQUjLKDx4YlvcEQMhoLHmXU0JJc+wSnYuc+8C6x8kooDlCTWBXhzdrcZbXoBfpr50GZl0enKROzFOkf37Y3hVHIJ5K0DU17+C6ho8Sql1T8w5XguLMkGRxd5/35svI7P+GaG4Eudulx9hWeL852f3fvZ5fg5g+bvuS3/MZby6N6ELOiRiYZmoEB6A+A/12/5pM97TMN1kkyZ7ct9/VNizvCQBur5wTlXE+tlAJk8MuOtfs/U1+x4KUjH51TR12nOtEVn4eMlQKpCkVfp0nsO8LdTUo3Lc3KEndSMtxjgCXTZxkgRvoKcZQ1pptUXej5MA+VB89HNHdqj6HAwuOtODrbZsx5+ABNJ4/h5dWrcCYQiUmlRbi+53bIsqMHisOtxtLjh3B7ZVzJY3kwJahUsDidKLXbse9Cytlhbmv3Tqv3L+e3e3yHwpkqBT+sc+vXI6rigv8Qtt3aPHF1k2iSsKVs/NhtNuG7L0MhPUpo/ToZIFZ5gveb/3TYLqnQJYKEBP+TpD7HJhpOpj+OUExDEzspntKMM6N70awZmSKKDlCQxo5QwtXgjjRMlSyicgFsm8EmUuE6JsIwtTJfR5kLgQzfQuyrQGz1YH1PATWPR5MezfIuijqZGFR7dnTA9Y3U8ioLmokDzysvE8Y52wBU0+EL/O87BjTjwHPezrgUMB3IJoFZvwQoYnjbvR6+UXuoA/zdaKHFi+IKhJu/GwVNp05jek7t+HRJQvxYt0KNJxu8/8u9144j/fWr8XTNUvw6JKFyCmYiVFeh8OHGxvQa7NhUmlR2DXD/TxdpcD42SoYbMMnxzkCXDZxkgVuoKcYQ2mgD4ZjGjVyCmYGGbzpKgUeXFQFp8cz5OsfuNSFTzZvkC2x9qc1df7+Lo8H9W2n8MXWTX4hLtb2dp0PWsfp8WDlyVa83VCPP6xcjgcXVSEjwKvuE+yfb9nkLxUTmJF2WuUctHRfEs1EO1SQuyNKb46E0d7zkN9ID5qfPGC2VWA9j/i9QYNfLxNMfRXIumjY3hOnH64EcaIlUWUTWeYPMJK9f/bNGPq1yQWyrQYz/Fn+m2jrr3dOzCgcjhr+LPN9nABiwdVSiBlAljJhnP4PQsb3EE96Npi9QUgaanwreE+GP4J5ekA0fLKpMsqcMAPlrO9Q/pvtW0TntzidUO7djevnFGOUMhfjZDzi0bSbK0rR0n1p2N4Tpx8umzjJAjfQU4xEVYJerFsh6Y2WC5UfiM3lwtr2U1jeekz0/ns49l44L3r6fXVJASxOcc9L7YnjSBPxwD9dsxRP1yzFq/V12HC6Pcjjsuz40bAn7cc0agBCWbq9F85j57lOvNtQjyxvuZaHFy/AngvnRfcUb8hS0e8l8XtUrozaSCdLeejczhaIZwUejHE+GUTcOzFSxFMJmrj8XUxe93FCtYnL303I72gyk4iyicguU3s8O6qyYuTpBtlqQbY1MWWDFzLMi+xD/4LE3gnM+JcBhwveA1DDa2D6Z8B6PwO5WgeMkUs2lwWmuQ5Erv5ncuwBs23w1o/3ygjDn0GeoS8j5vJ48NKqFf6otHTvYfdVxflRG82tWk3I/MUHmuJikPudDkoFXl5VG3Mtdc7g4bKJkyxwAz3FSEQlCIBkXfTM/Dx8tCm0HI4Ym86cxvjZqqBT8s+3bIxaGG4/2+lP6JahUuC1+rqwtdn3XjiPl1fX4tZ55fjd8iW4qjjfb7D7/vzcmxDG5nJhXJFKVpBnqBRB2WbtbhduqywPiTBIVymw72LkddEv9pmw6/xZdBoNUb0TACDXKbC+GWC9n4NsdWCGN6I3nHWPhczL9C8h6qRIsi0bTPe7qJ+PEz+4EsSJlkSUTeQ8KPutIfva8HMQgfXlDTiAHA+y1YUdO3AespSDaa6DL0KI9f0oG7JPxEDWZUISTe0dYLo/DDhkzREOGuzrvM/bFNE3lhx7+9dwtYJ1jx3wfDlgmptALLJDciICuU6AHI1R3/VnRNjWeQZfbN2Er7dtxq5zZ4P0gEhahkqBWXuDK87YXC7ZO+QxGegqBQr37ZV4Es5wwGUTJ1ngBnqKkYhKEABMLBEPLc9U5UmGnwXSZTIhy5tsbuAcc2JMxGJy2GF3u6Ie93ZDvWQ0QPOli9h+tjOsIM/Mz8O3O7b651xy7IikwH9mxdKwe7K6XHhz7eqg9/PMiqXQWWOvwyokJIrSeO55NHQeSQ/VQM+PiCEueRDwJIgNb614Tj9cCeJESyLKJnKdDGOobgs/h22l5LeNXCej3xN5hDD2KEPJiVxgmini31T1NSByCLlBIkgIGpjXQwilFztgFY+YCtmX+wxYzwMB40aDmaaDKLarbed7e2PybA8sCXtY3S07Ri76Te5nuY07hzR/AUceLps4yQI30EeI77//HpMmTcI///M/4+c//zkeeughnDwpL6y3bt2KK664IqSdOHEi4nUTUQkCgE82b5BM0tai7g47ftbe3ZLjb6koG4YnELC7XMj0hqCLndJ/v3MbdpwLb6CPUgr14A02G6bv2i579y2nYFbYfb3dUB/yfjJUCjy+tDrmZ2W6x8MY0CKKnbk4dB7NLdIGuOZ2MPVkMO3tYLrfBiuPuifALAsklMNsMONbMT8bZ3DEUwm6evm7mLT244RqV1/GShCXTf0IpSGniRwGZnmv0YRPOMd0j0l8J3PATF8Pw1N49xGmXCY5doGZ/haBgT5BKIHpOgFmfFtGBmSBGV6T3RORA0xzk+g3nMxFMT2nyeEIm/BVrB31XinzcdZolO1/W2U5riouwIOLqnDvwv4SqukqBf6ysQGfbFovOXbZ8aMxPRtn8HDZxEkWuIE+Qtx9992oqKjAsWPH0NLSgvvuuw+/+MUvYLFIe/18StCpU6fQ3d3tb54okqglmhLU53CEeHbTlP3Z0fP2iJfrGsh769dKeq2zC2aKjjnXa0RN6zFs7GiPS9K1pq4LuLqkQNYr/s32LbC7XZgQJgTvhboaGO22kLB2sXZt2WzZfWktFlmF5cgAxSRSyFoTlXHONNeL3r0kc76kN5xcx4L7MqNQA919Rvh3d7vMmlkgT/jDHU784UpQ8sJlkwC5Tnkztw+M2skG6x4bcXUIpp4i/Y0y/Cl0XSKQsxlkqwE5D8TF20qWcomDzOBogEhqqZOl0ps3ZGyYOXPAej+W35dttfR49aSYvehvrl0dVSnU1+pXic7zyJKFIfOkK3MxqbQwJHnt+d5eNHVdgNYq/H8y91CzpHf99vlzY3ouzuDhsomTLHADPUHQarW44oorsH37dsk+PiXIaDTGvE6iKUF/WLlcVJDeVVURUZbTHqsVbzWskTRA05QK3F89HzaXC6tOnUDFoWbs67qADzasC+p3dUkBGs+fC5lfb7OisuUgZu3djS2dHfAwJrqPXrsdY4uUYU/ud50/CwCoO9kadBAR2O6cPxd9Dods3fTA03pFo/whRvOli7JzrIwiCV8gRATW+02A4jogy3GQsjUZzC1uLBM5hKzBvvBGr9IXUXikvSGM0rknpmfjDA6uBF0+pKJsItYrfLPEDg6Nb4I84WUTOVuEu9+S36dssL48kEctlG2zLgRzHgo9FOh5EOQJPUQldzvIXAwyF8mGypNjRwQHqBNAzOJNEvexzIHC+wDgTQgXPqknOffJvyOzCnIe+1hrzxvtNjy0eIFfRvoOyMXk32+WSZfM6zQaMKW82D8+TZmLsUVKNHWFz/vy6ZaNstF0nJGByyZOssAN9AShvb0dV1xxBY4elQ598ilBv/rVr/Cf//mfmDZtGrZsCX8/O5BEUoLadDpZw9N3Ei2Fw+3GHfPnhj0pVzU14kpvVlepu2FpSgVGF84KupO96cxp5BTM9BrSgqB9oHo+eu32kL3MP3wobO3Tl1evDFIEmi9dRLaEAP/T6pX+muly7amaJWHvyavNZtm9DbbcC7lPC1neTTMkPCrZYM5D8nMQCSGWfTNA5gK/hzzs2q7j8gqie3iy3HOCiacSdOXy9zBx7ScJ1a5c/l7CfEeHmlSUTWSZJ37Q2J0F1vNg+PGuNrDucTJGbDaYeoJQ69x/uCl1wJkDpvtN/9xEYH0/BhyMetfo/VrU0GSGV8J4ujNB1uqA+RmYuVy6v2VpBAZ/JsisCv+ebLXSc6ivHlTJNiLCrvNnUXJgH95uWCMq+yaXFsEZJnrO7nZheesxfL9zGypbDorKfzGKDzRJHtjfXFEa83NxBgeXTZxkgRvoCQAR4YEHHsBNN90k2+/kyZMoLS1Fc3MzGhsb8eqrr+Lv/u7vZD0bDocDJpPJ3y5cuJAw//OuOXVS1vgMd0pdd7JVdvzEkgLMO9SMCbNVEd1JS1MKpcvur56PF+pWiCady1Ap8P6GdSF7mbF7h+Rp+ShlLsqa98M9wPu+Ksz+f7NM2kBPU+Zi+fGjEWeof62+LuQgI0OlwAOLquKWsEYozyOmCOaAmb6Jyxqi6+qeEFk3B0z/4pCtyZGHK0GXB6kqm1jvJzKe3dHhxxv/Im8Ua3/tzZ8R3tD1N91TYD0Pe6teSBjFttWhe+m5X8YInghy7Awdo39ZZoz4nfFAw5q5Iss9QGTzJq4TuePfFz63SiR4GMM1EkloRylzsanjdFzWGYjWasHowlmiuse8luYhWZMTHi6bOMkCN9ATgNdeew2//OUvceFC5OWyfNx///144IEHJH/+5ZdfiibvSYT/eQ+GCb0OV8f8622bZY1iu9uN5a3HwhrmAw3fUUrhnplUn6z8vBCvtdxhwQ1zSvxG8CldD15eXYus/Lywnv9vtm2R2acCH25siPhd9zkceKGuJmiOR5YshNocfT1eKZj2bhnl8jfhJ4gR8mi8CesC13sWxGIPt+UMDq4EXR6kqmySy4vBtNPCjmfa22W+hU94Q8nfCevZDvG6i3rYA36ufzZ0L8YPpQ9Oez/rf2b7Bm94fY70s/vWCVNiM5Lyc/51XSeFEnCB8/d+NijveSBai0VSjmaoFCjYN3TXoJq6LmByWVHQetN3buNZ3EcQLps4yQI30EeYN954A//7v/+LM2ciC+kdyLfffoucnBzJnyeyl4KI8OuF80Q9u8/VLg87Pr9pj6Rn/MrZ+QCAwn17o0oWE2kbWJ7M4Xbj5rmlomstONICADhjNGBskTLi/bR0X8K1AcJ9YLu2LPostx0GPTacbsdxrSbqseFg+hckFLscMOM7cV9vIOQ6DrKvA7lODflaHHniqQRNWPY+rq7/NKHahGXvJ8x3dKhIadnkuQTWPUbUGCbLvLDjhbvnEpnbvd9CpvtddB70SFrPvaHP4mqFEA0QuJ8ssO4xIFeb0MdWF8b4D2xjQJ4umb7hk8OF7JGYkBjPvjHuiT0dbjdyCmZJytHlrcfCTzIIXB4Pdp0/i3XtbdDKJFrkDA9cNnGSBW6gjxBEhNdffx3//d//jba2tpjneeyxx3DbbbdF3D+R7vkBQv3yO6sqggTmo0sWRlSf+4KpV9TYTfeeUgOIqOZ4tO2muaWiJ+BdJhN+t3yJv9+E2Soo9+7GmlMnsbGjXTbT/MA2YbYKRIR3RMqj+drNcxPrHhvJlPEh5z4QM4P15QplddTXgBne8iuInMsLrgQlL1w2CZBjK5h6YrBR2/s1iMQThQaNtS6X/hY6hKSezPR9lB70cC0HrPdziWfZ6S0X54sCuB3MukzIou5oBFPfGPk6+peF/asnS+/D9GXcfg/x4Mutm0LkaLpKgSuL82F1udBh0OPthnpcVVyAKeXFmL5zG0yOyO6ac5ILLps4yQI30EeIV199FT/72c+wbdu2oLI0NpvN3+ejjz7Cs8/2h6zNnDkTtbW1aGtrw7Fjx/DRRx+4eghzAAAgAElEQVThiiuuQE1NTcTrJpoSBAgKYVPXBSw7fhQt3ZeiCv+qPXEcGSoF0pQKv/H7VM0S2FxCCDojwn3VlaKGcU7BzJgM9JowJ+6X+vrQ2qOFcm9jUAh+uCRygf02drTjrNGIOQcPiPZJVymQ2xh6d3CkIXPRAC/6aJBlPoicYD2PDvhZDph6Avd4X4ZwJSh54bKpHyI7yL4BZKsFebqiGMe899i93znfdy/gXjW5z4N1TxjwTcyCfMI4mbDz7gmyyTWJmFCW0nkMTP+n2A4B1BPB3JcEr7xkzpHw2duHG5vLhRfrVgTJ0EmlhTh46SLOGA0YP1sVpCOkqxS4Z8G8sAlYOckHl02cZIEb6COE2N27K664AhUVFf4+zz33HKZOner/9x9++AHp6en4x3/8R/zbv/0bbrrpJtTX10e1biIqQYNFYzFj7qFmzNq7G43nz4UY+F2mXjy1fInfQL66pADlBw/A5nLiqEaNTqMBt1SUiRrQaUrhzrnPY72i9bjsXhgRzvUasfjokYgN/nSlkNBuSnkxXl5di4bTbXjYWyJmlLK/FFuGSuH3AtxXXYk+h2MoX2vMkEcLstYISq23TA7ZVkl7WwxvjPCOOfEmnkrQuKUf4Mo1nyVUG7f0g8vuO+qDy6b4Qa7jQhk0c4mo8czsW8G0dwV4tu8BOXaDmB7kOgrmPCxhpGeDqa/q/3fd70Au6Sz7gPewwd3pTWAXvkSav2muB9NMBTN9B2ZdLkRABRzA9h8keI11iWzyiUCrVoNFRw9jw+l2fx1zuci2xUcPj/COOfGGyyZOssAN9BQj0ZUgp8eDHqs1JON5LBARCvftxZhCpV/g3l89H6f1obVVd5zrRGZA4jbfnyUHmnDB1Aud1SKpdHSZTPhh1w7ct3A+xhYpIzbMA9vWTkF5s7lcmFI+WzRJ3Z3zK/B6/SosPnYk6U72We9H0uGc6qtGenucOMOVIE60JLpsImYBMUNcjE9iZjDjWwHGdw6Y4S0wZgvpK5Riywz4fuaAdY8XQtPdF8A8fdLrOA+CGT8C09wOuXrj0m0ciJm8c7VIG/a6p8B6PwQ5diascS7FpFLxPC/pKgXeXBuaFZ+T3HDZxEkWuIGeYiSqEuRwu/Htjq0YUygkc5lYUoDiA00RlxETo7LlYIjQzVApcMOcEjhEap+e6NHiw40NuL96Pl6qW4E/rqr1J5e5prQQZc37Q5SPQ92XMKZwlmzW93BtUmkhVp8SytIsPX5Utu/2s50xv4+RhJm+lDbQNVP8/cjTLdRT77kfTHMzmO63IOsSECXXgUSqw5UgTrQkqmwiT5e3lrjXmNb+GuTYNqg5hVJpA7+H2WDGD0LXJwLZN4EZXhayrBvf9SaY8+6n5z7/vfagcZZ5sYWxB7aex0AuIWqMGd6S8byPB3nin3h0OLhpbqmorM1QKfDBxv6SqofV3Xi7oR63VZbjprmleHl1LXadPzuCO+fEApdNnGSBG+gpRqIqQa+vXYV0ZWiYWd6eUMUjEogI15XPljR0V55slR3/Yt0K0eRshfv2Bq1x94J5EdVYj6TNOXgA3+3YKptI7u6qirh6KIgIBy51oerwIWzqOA2XN+wv3pBzn4Rilw1mmu7t0yx4hsT66Z+PW9kdztATTyVo7JIPMGH1ZwnVxi7hSlC8SUTZRMwsHBQGGdNZYN3ZIGdTbHO6T8sYxdmyhi4xo7duuNh+Dvb386ijC2OX2Q/rHgtyHZYvo9mdCdY3I6b3IYXT48GG0+2oOnwo6tw00aBo3CUpw3d4D8TLmvdLyuSSA4l1354jD5dNnGSBG+gpRiIqQR0GvaTwG104C2anM+o5zU6n5JyZ+XmYsXuH5NjjWo3k2HFFSn94eafREBfD3NfGFCpRcqApbD+jPTQMMhZ67XY8vrQ6aO4p5cVo7dHGZf5AiMibtdgXoulVMHvuBzGTkFQpMMuwSCNbXdz3xRkauBLEiZZElE1kmQ/JO+D638c2p71B/jvn2Cs91lwqsZ8cMMPL/f2sCyX6xWik6//g9frLedula95HyxGNOqh++ChlLn63fMmQ5F2xOJ14aFGV32vuOyD/dPMGkDenjJw8TlcpoDab474vztDAZRMnWeAGeoqRiEpQ7YlWWQHYoo6+LiojwoTZ+aLzpSlzsdBbmzyQbnMfvtq2GVcXF8ju56SuBwDQrtfF1UAfpczFmlMn/EnppPZudUmHe+ttViw6ehjlBw+ErXX+ev0q0Rr0U8pnD4knnYhAziaw3s/AjO+BrMtBJChczHkkjJKYxZPJJRFcCeJESyLKJmb8ANK5M66MaU5yyX/ryH0udIzzEJjhVbDucdJj1ZP7+1vmxdFA9xrpti3yfXRPyj+3ux1kmQeyVstGCTjcbkwqLQzxameoFHh/wzrJcYPB4Xaj9sRxvNNQj483rceu82f9HntVU2NYuV3Nk8klDVw2cZIFbqCnGImoBO0IU6v8fG9vUP9Tuh68sXYVrizOx5TyYvxt13bRk/Xcxp0hmdnTVQqMKVRi8dHDaFF3+4Vwt7kPk8uKwtYpT1PmQmMRTss9jOGGOSWy5dPSlLmoO9kqa3QHtlsqSrH8+DHRn2WoFHh5da3ke6w90b9Omve6wJtrV4sa23qbVTY0f1PH6cH8SqOCbKvB1NdGYKC/Nmx74gyOeCpBYxb/BeNXfZ5QbczivyTcdzTZSUTZxEzTpQ10za0h/cm+CUz3hJBhvedekHVxSGg2EYH1PCwybw5Yz0Mg22qQ52J/f8dWwUCWrZmeBaa9p3+MuyPM9zQHTHMLmHlR5EZ676dghrelDxasC0XfoVBy7vP+ffpC8q0LRPvXt52UlEuZ+XnDVr3EzRim79oeVicYpczFApEDf05iwmUTJ1ngBnqKkYhKkJsxIXO5yIn5k8sWB/U9pevB2EJlSM3SB6rnhyR+c3k8eKehPljAq4IN5az8PIyfrcKt88rCJnrLUCnwh5XLAQA6qxXTd22XveeeXTATtSdasf50W8Qe9DRlLqbv2u5PcJfuLa2WpszF9XOK0SXye2NE+HH3Tsn5ivaHhkye0vUkhMJBjm0RK4hkjbymMmdk4UoQJ1oSUTaR65SEJzoLZC4O7mtd1u9t9hujmWB9P4TO67kE1nNfqNEc9O9jhRJn6omRfR8tld49t4IZ3wkuwxZyuHATyNUG1vtldJ52+05vwjzfc3r3rH9JNJEnsV4w3dPSe3YdCRlTfvCA7OHxuV5jnH678ny7Y6vs4XugjO3qS5y/sxx5uGziJAvcQE8xElEJAoQ7Z1eXFAQZ0VPnlYcIPrGwbF+rPSFeo/yM0YAVrcdxZ1XFoLKt3zl/LjQWMww2G26pKBM9ULinqgLvb1iLpceO+O+KlzbviyqR3PVzBMXvRI8W3+7YinfXr0Vly0FJz8HX2zbLznfjnJKQMTaXy58xX6w1X7ooslL8YbrfIqJkRrrfgij6XASckYErQZxoSVTZRNZF3m9UQK1vw+tBBimRE0w9WeL7lQ3yhF7TEq787AezVEEIXY8lJN07xvgeiDzCfN1jRIz98ULmd9P3IPsG/96Z/vdRrJUD1vs5iJjg1e/9BKz3Y5B9I4hCo7SInCKHEAPn+yJk3O7z5yTl0oTZKtEKLPHG5LAju2BmRPJ65p7dQ74fTvzgsomTLHADPcVIVCUIEIzGFa3HoWpqRMPpNtHQbKl75RkqBd5bv1Zy7nAe43DtrXVr4PHWZs/bI571NU2Zi7Lm/SFrb+xoj2qtSaWFEb+zS319YY3/nIKZomMVjbtCPAQZKgWeWFo9bLVsZb083dlC4jjzXBDZh2U/nPgQTyVo9KIPMa7ui4Rqoxd9mLDf0WQlkWUTebqF+9PmIpAzNLqIXMfkvdsyCS7JMjdG49xr5Fr6Q8VZzyOSB57kOhGyNjN9JWLMyxnUH0b+zmwrws9peDV0HBEeXFQlehBfsE86gV48OazulpWp2QUz8cjihVh/um1Y9sOJH1w2cZIFbqCnGImsBEXCtWXiIeWZqjx8tmWj5LjNZzoGZaCPUub6hfGvF1ZK9vnNgJB8QAjhn1pRFtFdtjRlLt6oXxXx+1hzSvq+nm++x5ZUi471MIa8PbswplCJUUohnP6NtavRax8+Y1go3SORlTjOZXs4wwdXgjjRksyySb50WibIvkFyLDN9C9Y9OkYDPQusexzIoxPCyWUOOweG5Av7bveuHeEBQRTXjFjvx2GM/2yQWfwwWm+z4k9r6vwHyOOKlFA1NYIN08Fxt7lPNryd1z9PXrhs4iQL3EBPMZJZCQKA6Tu3SXqMm7ouSI4LVyolXEtXKfBs7TIAwIPekixixvAzK5ZKrv9A9fyI1/vbru0RebG3dZ4JO9e2zjOyc9hcLrTpdDDY4lO+LRqEMkYSyptbft+cxIUrQZxoSWbZJCR+u1fEe50Fpr4aRNLfViGEPhbjvH8NsswVarbLGcOWcvH17VtkwvMHtgkgu/RBeCDM9J28ga6eBPL0yM6hs1rRptP5S5sOJy/WrRCtcnJLRdmwHRRw4g+XTZxkgRvoKUYyK0EAYHI4cF91pV9YZnjvq/91+5awBu0rq1fKhoOnKYU7blI/v2P+XABAWfN+ydP1F+pq8IeVy/HBxnXYf7EraH0iwsSSwoiN9NoTrWHfh9PjwTUlhf6s7UFRBfl5WHPqZOwvexgQMvx+OUB5GweyrRnprXEGQTyVoOzqjzBm5ZcJ1bKrP0rq72gikuyyiVzHvAndstGfQG10WIOWmBlMc10Yb7NcGw1mmg4AYPrnpOcxvA2mfwGsbwbIHXyYzVwno/DYjwZ5LkXwPo5Kz6O5GeRK7PBwndWKhxYvCJKpN84tQbteN9Jb4wwCLps4yQI30FOMZFeCAKFmaU3rMby7fi0+3bIRey+c9xvnbsZQ2rwPN1eUIqdgJh5dshBbOjtgc7mgsZjx5trVskbxuw31oqHoGSoF3mmoByB4nB9dstBv1KcF9An851HKXJQfPBC090+3bIwo1D1dpZAMTR9I4/lzGF04C+kqBTLz85CmzMWVxflh66AnEuQ+K5QkstWBWN9Ib4czSLgSxImWy0E2kacHZJ4NZnwXrC83qKY5MT2Y6Usw9TVg6ivBDH8Gc50GsT4wVyuY9n4Zb/O1YJppkqHoZBPKb5K7HUw9KcCTH2is5wT8OQHkPNS/N2JgmqmS80camh7yPsxFAWt6w/h7HgExS3xf/BBBRGjquoAFR1qwpbMDbm8eGk7ywmUTJ1ngBnqKkaxKkMPtRptOhx6rVbbf+xvWBXm3B3q6H19aLXu3bOaeXcgpmBXkafcZ4S+vrkXtiVY4PR443G4sPnoYL65agT+uqsVt88pFM8SnqxS41NdvcF7sM0VUb32UMhc3iGRfl0JrsaD4QBM+27IRlS0HYXLwpGqckYMrQZxoSVbZRMwIcrfLGp3EzGDaOwYYzNkBBvFoMN0z8oaxuVTUWGbqK4Xs6s59QmZ4jxasTwmmfx7M+DaErO4i47S/Doo6I/sWhK+37t2rSPZ1yWd3nQDrmwFm+gpkbwDR0Gdh53Ck4LKJkyxwAz3FSDYliIhQfKDJH3qepszFi3UroLWEKkNtOl1EnmnJnylz8UB1FR5fWo1JpcGh6Gnen49S5uKB6vlBJc/0Nqts2Hxly8GgfarNZny7Yytur5yDSaVFogcGGSoFXlm9EgDQYdDj8y0b8fDiBXitvo4nqOEkPPFUgrIWfoTRtV8mVMtayJWgeJN0somZwYzvBXirxwnh4yIGKFnmReCdDlNuUv97sJ4HwbqvFAk7947t/SbY6Latkp2T3J3B+3S2CJ597e3edSQ89tZFQn/HLjDD62C6x8BMX4fMx+EkGlw2cZIFbqCnGMmkBLk8HpQcaBI1Xu+qqvCXPfNR2XJQ1jseSfMZ8OkqBcYXSd9Hf652mV8R0ljMsvMNDHMP5GKfCWOLlCEe+3SVAs2XLqKp6wJyCmb6Pe6+P8XKuXE4iQJXgoLZvn077r//fvzXf/0XrrjiCtTW1sr2r6mpwR133IH/+I//wL/8y79gypQpaGhoCOpTUVGBK664IqTZh7EKQzxJJtlEZPfe9xZJCmf6PqQ/M7wSYfh4OAPeu57meul+lrn9+7TVyBvoMvfAyd4gMiYHTHMDiJlB5pKA8HXfn+NAzoOSc3I4Iw2XTcFw2ZS4cAM9xUgGJajb3Ic3164WDRkPbJvPdASNW956LCZjPNaW37QHTo8HvXYb7pw/V/Jw4HSYpDKH1d3+xHejlLm4uaIUm86cBhHhzqoKyZrrs/c3wex0DuWvgsOJCa4EBbN27Vp8+umnqKmpiUgJeuutt/DDDz9g3759aGtrw8cff4y///u/x8GD/cZPRUUF/vVf/xXd3d1BLVlJBtlEzn1guifCGNJjQSz4GZjx3QhCx33e8MEY8cIc5NwHYlYw9xkJz3yWkKiNPPLPa60JPgzQPQ1ynwN5uqU9/urJIPvmsHNzOCMBl03BcNmUuHADPcVIdCXI7HTi5rmlYe9oZ6gUKNi3N2hsr92OnIKZERnmd1VV4H5v2bPRBbNi8rynqxTI9O5zSnkx0lUK/759832xdVPEz97VZ0Kn0eAv4XK+tzfsHq4tm40zRkNcfwcczmCJpxKUueAj5Kz4KqFa5oLYwwgjUYLEGDNmDL7++mv/v1dUVOBnP/tZ1PMkKokum8h1GEKiszCh6N2ZINfh4LH2LZF7yfUvgmlu9P77+NiMdvXE/n/W3Bbggfd5urNA9vWRPTe5Qe4OkKc/6ahQGi7MvvTPgsghMzOHM/xw2SQNl02JBTfQU4xEV4LmHz4UsbG8vPVYyPjVp054y68pZD3ws/c34ZPNG/DrBfMwrbIc6SJlyqJpvj0/umQhbpxTgkeWLMSy40cjqmUuxVlj+NrtGSoFnly2aDCvnMOJO1wJkiYWJYgxhv/7v/9Dfn6+/79VVFTg//2//4df/OIX+J//+R/cd999QV6MZCPRZZMQph6ZF5w8wd4iIgLr/TzIQBYfmwNmqxPW0t4Hpp4SB4+6EHrOeh4F09wCZngF5JS+dhUJZK2O4OAgC2SePah1OJx4w2WTNFw2JRbcQE8xEl0JekeizNlAz/WVxfmwulyic5w1GpHbuBPvb1iLZ1cs9Y/xzfvb5YuRpcoL8XYPtqUpc3Hn/Lmie4oWN2PQW624rbI8ov11m3lpMk7ikCpK0IULF2AymfzN4QjvMYxFCZoxYwb+/d//HRpNvxdzz549qKqqQktLC3bs2IHHHnsMP/3pT9HWltj1paVIdNkklC+LwBjW/1F0PBGBnE1gpq/AjH8B094zwGDP8R4C+P5bvELevfN5a6UPFiKHUBYukr1p74zLmhxOvOCySRoumxILbqCnGImuBH29bXNYA31iSQGaL12MeM52vQ5/XrcGYwqVcTHEwzWbxMFBJHgYQ37THlxVnI9RylyMKRQSyIUz0tvD3HPncIaTeCpBGVUfI7vm64RqGVUfiybB+fLLL8M+V7RKUHV1Nf7pn/4JGzdulO3HGMOVV16JN998M+K5E4lEl01CZvMwBmnPoyCmj2g+IgZm3wGm+02EnvlBNt3jg3p+Ynow4/vw1zOP5MBCM2VQa3I48YbLJmm4bEosuIGeYiS6EnRUo5Y0Qv+4agXWtbfB4Y6ujuqBS11x85KHa6MLZ4Vkl4+Gb7dvFZ33prmlkmtOKi2Cy8MT8nASh1RRgobaS7F48WL89Kc/xZo1ayLq/9JLL+Gee+6JqG+ikeiySchaLuE1Nv3gr0Me3ZyFcTTC5TzaWWCGV2J/dnKB9dw34CDBu57mZmmvvfG9mNfkcIYCLpuk4bIpseAGeoqR6EoQAJQ17/eXGstU5WGUMhfPr6yJ2jD38ac1dWG98r4Q9SeWVgeFvWd4vdeKxp34ZvsWfLp5A2bt3S1p8L+7vj7m59bbrMjMzxOdN12lwGv1daLrLjl2JOY1OZyhIFWUoKG851ddXY1//Md/jFhhIiJMmjQJzz//fNR7SgQSXTYROQeEoAtJ18hcGuN8ruBkbmHDxe9AcIK6HDD1ZDDzHLDeL8BMX4L1fiU93tYQflNSexUtueY10jX3eKMLAo33bLDu8SB3e8xrcjhDAZdN0nDZlFhwAz3FSHQlyEen0YCCfXuR27gTjefPDSrZ2rTKORHfIT/Xa8TCIy349cJKTCwpxHO1y9HUdSFovq4+k6SB/sdV0WfA9LHz3FnZ/a1vb8OsvbtCMtU/tqQaGos55nU5nHgTTyUovepjZNV8nVAtPUolyGw249ChQzh06BCuuOIK5OXl4dChQzh37hwA4KOPPsKzzz7r719dXY2f/OQnKCwsDCpT09vb6+/z1VdfoaGhAR0dHTh06BCef/55/OQnP0FTU1PM73wkSQbZ5L9H3pcHMheB3J2xz+VRR2Gc3w7m6QXr+xFMMxVMcwNY7+cgT1fQnMwqU/fcsjjmvbK+Gf2h7WLNfRHM8OYAL34WWO8XIIrtYJ3DGQq4bAqGy6bEhRvoKUYyKEHx5rna5RF50O+YPxdGuy3sfGXN+yVrqKerFLC7Y7uD3qrVyO6v+dJFoT78gLUzVAo8uKhqUIcYHE484UpQMFu3bhW9F/jcc88BAJ577jlMnTrV33/q1Kmy/QHg7bffxi9+8Qv8wz/8A37+85/jrrvuQmNjY8zve6RJNdlE5IBQRi0CA93wAYjCX51i+ucgWfdc91Tse7WUScybCaaeAMZswqFByF36LLC+WTGvy+HEGy6bguGyKXHhBnqKkSpKkMPt9t8F39LZEfEd8pvnloY1dJV7G2UNfpPDHtOeiQi/XjAvZO4MlQK3VZZDYzbL3qU/1H0ppnU5nHjDlSBOtKSCbCIiENn9MoaZvpM2fAe23k/Czs90j0uP73ko9n17uiU86Nlgpr+CbKuk11VfDaLYE6dyOPGEyyZOssAN9BTjcleC9lw4j0eWLMQoZS6y8vPw3vq10FotmHPwALIk7ncPbKom+ZO+fRcvSIbI37Ng3qD232HQY0p5MUYpc/330SeVFuGkrgcHL12U3XftidZBrc3hxIt4KkFp8z9B5vJvEqqlzf/ksv6OjgSXs2wiIpClqj+hmnoyyFwAxixgxrciD3V3n5Vdh/XNkjD4s8H6ZgzuGWz1YN1j4C8J150JpvsdiFlA5nzZEPhIM9tzOEMNl02cZIEb6CnG5awE7b/YhQyVIigE3Od9trlcMNptqG87hcqWg7KG7o1zS2TXISK8tGoF0pT966R7191+thMA0Gu3Q9G4C3fOn4s758+FonEXeu2RedYdbjfqTrZi5p7dqD1x3B8yr7VaJEPrRylz0aLuHtT743DiBVeCONFyOcsmMheJh533fir83H0GZFsN1vtNGC/6V/LreHRgmhsHhJrngGmuB3k03rXawYwfgmmngekeB1mXRBQ+75ufLJUgcz7IsdsfCUC21TIe9Gv4PXROwsBlEydZ4AZ6ipGsSlCHQY/3N6zD9XOKcXdVBcqa98M5oLTYMyuWShqw+U2N+GLrJry5djWWHT8qa6DnFMwMu59Tuh7cXz3fX6P81nll2Ok1zk0OB6ZVzgnaS7pKgWmVc2IOf/fxdkO96B30R5Ys5HfQOQkDV4I40ZKssokc28H0vxcMY93TIHtwTWBiFpm75llglpVgxvcEo9k8N8xd9FfD7ofZ6sDUN/V7unXPgDwXhb04W8C6xwUY8N6kbsYPB/cOyClyMCDMT2bVoObmcOIJl02cZIEb6ClGMipBJ3q0GFukDLqbnabMxXO1y8ECjNLRhbMivmsud4f87qoKAIIXvPzgAby/YR1m7N6BTqMBANCm04nu59naZTiqUeOFuhWid8XTVQoU7ts7qHdhdbnw+tpVQfP/dvliaK2WQc3L4cSTuCpBlZ8gc9k3CdXSKrkSFG+SUTaRdUl/CHnAn2SZ29/HeTDyEPZAo1nsv3vD1Ml9RsjobvwLyDIPxEze/dSI7oeZS0GObWCaaZLzk+vo4N6Fu8NbKz3Ac2/6K4g84QdzOMMEl02cZIEb6ClGMipBL9atkDSot3ae8fe7tmx2xAa6XFty7AhO63W4pqQQaV5j3tdWtB7HUzVLZEPN5drDixfE5Z10mUzYfrYTp/W6uMzH4cQTrgRxoiXZZBORHUx9tYQxPRbE+oR+7o4oDXSplgNyn/WGk2d7vdU5gsGtmQLm2Aumvir2uePg6SYikOs4yLET5OGyiZN4cNnESRa4gZ5iRPNx8jCGLZ0dmL5zG/Kb9vg9yMONVHK3zPw8fLVts7+fonFX1IbzuCJV0HyKxl0gIjy+tDqi0mzRtDRlLp5YumhE3iGHM5xwJYgTLdH8nSFmEbzXpukg6wK/B3k4Iec+WaOX7Fv8fVnPwyLh33LtKgQle1NfA7JvATEjWPfYOBn8Aw30omF/hxzOcMNlEydZ4AZ6ihHpx8nqcuGJpYv8hmuG9651ZcvBYdppP2MkQtczVHn4fuc2fz+724WnapYE7Tmc0XxCq8W2zjNY234KPVYrAKDb3BdXwzzQQJ/X0gwPY2jt0aJNp+P3xjmXJXFVguZ9ioylf02oljbvU64ExZlI/86Qqw1Mc53XsBwteJDVE0HOlmHaqXcfzkPyBrpjZ39fd4e3TnjAnmUN5rEgpgfZG0CObSByCvNYlw+Bce7dr/s0iJlBrqMgD084yrk84bKJkyxwAz3FiPTjNH3XdlFvdJoyF+3DHFb9wYZ1ksb2wNrfjAg7znbib7u2I79pD95Yu0rWaH508QJ/lnQfHQb9kBjojy+txqqTJ3BdeX8o/m2V5WjquhD1O7lg6sWnWzbiprmluKuqAkX794Y8B4czUnAliBMtkfydISLvPeeBpcSywTQ3D+t9ZyKPNzHaQGM7C0w9yW9U9/e3CXfE+34AWRf0l1yTan2zQte0zI/AuI+meecy5YH1zURQMjv98+LYsNMAACAASURBVP7M71G9F+c+MMPLwvPpfguy1fODaE7CwGUTJ1ngBnqKEenHaWJJgYTXWoEZu3cM024FNBYzbppb6k+M5jPW/7pdCCF0ejxoUXfjRI82RBEw2KxhPek+L/zFPhMWHmnBgsOHMKm0MK6e89frV6F4X1NI8rh0pZA1/qzRGPH7OGs04qrigpAkdU8uWwSXhyfk4Yw8XAniREtEBrrrZBiv9eCScEYLOXZBqA3uC18X7oX7MrkTM4KcB/1Z1ANhcqXJArzwRARytgjGuaU8zp7zCWAmhZBFXiTsnfXcF3EJNgAg+1oE1Un3Jc0z58ftnXM4g4HLJk6ywA30FCPSj1OmzL3vT7dslB07FJgcDpQ178cfV9XinYZ6bD/bCSLC8tZjuDrgMOG2ynI0XwpWhsoO7JM1oMcWKaHc2yiaeX04WoZKgW93bI34Xby3fq3kocPqUyfi/OY5nOiJpxI0quJTpC/5a0K1URVcCYo3ERnoYe99rx/GHXv35D4LZpoOpn9ZyFrubgeRy1vTfHSAR/qFkMRpTPcbeQNa/yqY/oVgb/cwN3Jsj+w9kBtMc73EPDkgj3YoXj+HExVcNnGSBW6gpxiRfpx+s2yxZMK12hPHh2m38mzrPBOyt3SVAmMKZ+FiX//z1Z1sHRHDO5r2zIqlET/3VcXS0Q3vrV87FK+aw4kKrgRxoiUiA531QTpJWnbC3J1mpu9FDOocsJ5HgqK8mPFteQNZcwNCw/mHs2WDLOURPTO5WuUNfVvdUL1uDidiuGziJAvcQE8xIv047b1wHukqRZCRnqFS4K6qCjjc7mHarTy/kyh3lq5SIG/PLn+/jR2nZY3jMYWz4p6xPVoP+kebQj0/HQY93li7GuOKlLi6pABfbt0Evc2KyWVFUc0zVHSZTPhx9068Vr8KP+zagXO9kYfpcy5vuBLEiZaIk8SZVeJGYO83w7RTeYiZZQ4RMkHOff6+zPB6GAM5mszvQ+RBt9WHPqNjK5juSbDu8WDaaSDLXDDXKfl57MN3eEzOg2C9n4MZ/wyyVIKYedjW5iQ2XDZxkgVuoKcY0Xycdp8/h4cXL8AopXBP+sONDdDbrMOwy8i4pkT8nniaMhd/WtN/Wl91+JCsgTxhtipm4zoeLU2ZixZ1sOen02jA+NmqkHvmk8uK8MmmDZIHCtvPdg7Lu288fw45BTP92f0zVApk5ecN2/qcxCaeStCv5n6GtMXfJlT71dzPuBIUZyI20ImE+9i+JGuaKSBz8bAmiJODwhmq1v5Sm0z/8ogb4LKHA5opIHIEP5//7vwAz77uRTDNHaH/vTsTrHv8sBnJZC4KONzIEppmasJEV3BGFi6bOMkCN9BTjFg+Tk6PBywBs7A+tHgB0pShhmrgne4zRgNuqywfUQNcruUUzMTS40dDnu0vG6Uz119VXIBbKsqQ5jXafVEE761fOyzZcj2MYUp5cUj0QpoyF9eUFvJEdRyuBHGiJtq/M0QEImfCZQgXapVLh6X77nSTfRNY9wQZA3m0zM+GoWluBrmCr7MJmetvkh7T8yhY9zgEJ83LAtlqh+fdu9ulDxuM7wzLHjiJDZdNnGSBG+gpRjw+TsOB0+PBypOteH/DOny+ZaNoKbLaE+J3yzNUCpzW62BzuTClfDbSJYxjqTv2w9XeWLsKJodD5OmBKeXFsh73P6ysQcWhZrxQtwJvrl2N9afbhu0QpfnSRdnnajx/blj2wUlcuBLEiZZkkU3E9CBLGZjxfbC+PJA79HvHjO+LGOk5YNrbQOQBOVtkjfgRb+YKEIVeZSN3Z/ixfQVgfTPA9C+C9X4RYuQPJcL1B6lrAaMTJsqCM3Jw2cRJFriBnmIkgxJkdjrx0KIqv7GdqRIyyv91+5YgbwkRYeae3UGe5nFFKqxrbwMALD1+VNaQDKxHPtiWpszFW+vWRDXm7qoKbDnTgQ6DPqSG+bTKOWHXM9ptw/p78bH7/DnZvW3p7BiRfXESh7gqQXM+R9qi7xKq/WrO5wn/HU02kkE2kesEmPoa9JcSyxEMP/uG4H7MLBiogQai9k6Q+wwAgOn/HMZAvyG+Brf+tej6G14Bcx4Fuc8FlVkjjzr82J6Hh/V3Egjr+xFykQcDa9NzUg8umzjJAjfQU4xkUIJ+3L1T0ru998L5kP5aqwVrTp3Exo522FyCodtlMuG6MnkDfNae3XEz0McWKrElTDI6331t0fFFSszcs9vvBS/Ytzfsml0j9Du0ulwYW6gU3VNOwUyYHPYR2RcnceBKECdakkE2sZ4HRQzrLDD1VSAWmp+FXKdAtlUg5z6/oUuOHTJe3kywnofAesKUX4um9fwOzPBm7OM1U4PK1zHdb+X7a28btt/HQMjRKLGvbDDdUyO2L07iwGUTJ1ngBnqKMZJK0KW+Pny2ZSOuK5uN6+cU47sdW2GwhXqBb5gjHt6dmZ+HTzZvEJk5GDdjuHVeuej9dF+bWFKIw+ruuBjnWfl5OKpR44stG2X7hQupT1Pm+rPP290u3LdwvmTfKeXF8DAW5k0MHfNamoOeyfdnyYF94QdzLnu4EsSJlpGUTeRsBtP/EUx9LVjPvSBLVUg4NLnPyhqmZG8Iv477tKyHV7gr/QHIPDs+xrnmdqE0nfqWQcwjJFojx17vM3SAqaXuzueAGT8akt9RJBCR8HsMKnGXA9Y9BuQ8OGL74iQOXDZxkgVuoKcYI6UEaSxmXFs2OygcPV2lwLTKOegbcA/7yuJ8SQ/02w2hJV8GsimMJ3uUMheqpkYAwNsN9bIGczhje0zhLBy42AUA+PO61YM29scUzoLVGwXgZgwPVFeJ7qmm9RgA4ESPFstbj2H72U64h9lgbzjdhseWVOPqkgI8smQh1pw6OazrcxKXeCpBvyz/HKOqv0uo9styrgTFm5GSTYJHOzvAq+017owfBvcLW+d7Rdi1mOlree95dybIeRDETGCa28IYzVI/83r4tXeBmFD6kqmvHaSxnwOm/0P/c7jPgamvFjGEJ4DcHcI9e8dukLUG5DoW319YGIicIHMpmPZOMPVkMMPrw3oPnpPYcNnESRa4gZ5ijJQS9N2OraJZydOUuShr3h/U9421qyUzmItlPB9IafM+WW/16/V1fmPWwxjmtTRjWmU5xhUp8esF8/DE0uqojOoJs1WoPtKCb7Ztlu0Xaa31Ez1a/7M43G7M2L3Df2hxZ1UF1pw6CavLhZdWrQgad/2cYhzXauL7i+NwYoArQZxoGQnZRERg2nskDV5ynQzo6xQMPgmDmTxdYddj+t/LG+fWxf3rMT2YaTqYegqYeiKY7ndg3dOiM6y194LZdwt/xmTsBzT15OB35+kCM7wFISIgC0z/IsjVKkQJaAfsU/csiPXF7xfH4cQIl02cZIEb6CnGSBnod8yfK2mQPl2zNKhvm06HsUXKEG/7PQvmweEOzSw7kLXtpyTXyi6YGZKQLZDvd24bkuzuz6xYGnHf5a3HQrzhRBT03z7ZvCFkn+kqBSaVFkX0juRovnQRz6+swZXF+bh1XjmKDzTx0mmcqOBKECdaRsRA92hlPdFkKQ/ub10W7KX2Gbemv0a0Huv9TMKDngWme0Z6n0ReI1ve+x5TM/wpMiNdcz3IFXpATsT81wGIPGDaW0X2mQNmfDuK34z4OyBbjZAHQD0RTPcEyL5xUHNyUg8umzjJAjfQU4yRMtDvqxa/T52uUuClVaGhgad0PXitvg7ji1SYXFqE73ZsjTj5mNPjwfXlxaIe68eXVqPbLH6S7/R4JJOfxdqyVHn46/at0FotGFcUfm5fCPud8+dCYzHjmEaNOQcPYPGxI/6s7VaXC1n5eZJz1LfFHmq++/w5ZKgUQe8uTZmLP61ZmXD1hjmJS1yVoLLPMWrhdwnVflnGlaB4MyIGOuuV9SyTpSp0jH0jmO4x4R629i6QdUFQpnPZ9VzHvca9iEHc+y2IxCtzkHN//A3z7slgtrVg9i0R9veF/r8Hxpwg+xaQpRxkXw8i4dBbuC4gc+DB9DH/rljfrAEef+GQhKyLYp6Tk3pw2cRJFriBnmKMlIFe2rxP8k537YnWuK/XrtfhtsryEOM3TSkkmxMzYnVWa1yN8wyVAj/s2g5APjO91NjJZUX+Qwyf97++7SS6TCbJcekqRciVgWi4v3q+ZN345ksXY56Xk1pwJYgTLSMlm4SwczHPdDbIo477emRb472/HbyW4KW+wV+KLXhMXdwNdF/SNyEzfYRh7r6mvm7Avm8R7p5bF8uv6Yrt8Jg8OonfUSaYeiKIHOEn4XDAZRMneeAGeooxUkqQ3e3Ck8sW+Y1In4f2lTUrI8pG3mUy4bsdW/H40mq8uqYO2zpDlZiBEBGeWbFU1ODMzM/D7P1N2HPhPM4aDfhk8wbcMKck7uHtt1SUoVWrwQOLqgY9V5rXcO8w6DFhtkqy3/aznTH9jvocDtkDA+Xexpjm5aQeXAniRMuIJYlzd3iTqPk824IhKOY9Fx3vPCB4lXVPgvV+CXK3hx3DWJ8Qph1iGOeAaaeBrIsEg9exR6inrp4Sfw+64WUw94U4zZcDpr0bzNEs02csiJlj+x3Z18kb/s5DMc3LST24bOIkC9xATzFGspSN0+NB7YlWvLluNd5uqEfD6baIjPPjWg3GFan8Rr3vz5l7dov211osKNq/Fx9sWBeRwe3zrMfTMA+cO6dgJh6onh+XNTJUCszauxuqpkbRn929YJ6/lnq02N0uyfeVrlLwEmqciImnEvSL0i/wqwXfJ1T7RekXXAmKMyNaZo3pQeZiMMMbYKYvRe9ai46zLuo3UP1/jgE5xGUTuVrB+n4A078UhfEbpXc7mnm1dyC0rvsgmqNZOKgI8XZngZn+Fvvvx7FV3kB3xT8Kj3N5wmUTJ1ngBnqKMZJKUKw8uWyRZAb0s0ZjUN+9F85jdOGsIC/9YFumzH3vSI30u6sq4mb031JRhhWtx/FqfR2yC2b6//vva5dBY4nNQ+HjldUrJbPtXzD1Dmpuzv9n77zDo6q2/k/oluvFq+/r8/6uiukJvQiiglgIYBcVxKtg70jRq2JFpKqZkJl0QgqEEkLvnYQQegst1NACZGYy6clk2t7f3x8zmczJnDMtUzP78zz7ESb77LPnbMxa37P2Xst/YE4Qw158zTZRUg1S2l1A+D5jdi6d1iabiHhniGInJYyTv+y8sco/AqlbCVL2usnn3UGqZ4NSx5OXUqoCkfbneVkRDiIfxvKjMGyG2SaGr8AEup/ha05QVUODoFBtft5aSwgGpiY5ZZt6kDgan6xfgxtVVZixJ9di3zErluHxtGTLIl8Sg083rDHO29Y52NJvSEYqDt0sccrzvlldjccXJCNIzD2KkHb8qFPGZ/gHzAli2Iuv2Saq3GQlqnuhqa/mnHOj3zWJILpyENlwK4L5S5DSnpb7KN4FkQ218d52RvMV40F0zin9SRt2Q1/SrfEFRziItBfb3s6wC2abGL4CE+h+hq85QZUNSosCff6xpm3X+25cd1qUOlAcjZ93bQelFNmnTzlle/r4NSuw9HQhnspItdhvQGoifty5zeZxQyQiDEmfb1aazVGqVSpknDiGr7dswO95u3Ba5vxESYzWjdOdoKzZXtWYE+R8fM02UeUGKwK9ads1qfnLeVHq0lDQhu2gVAlS+Z0TBHW4vvxbXaZBAFvoW/YqSLmNZdmMY//svGeuvQ5S8zdI5WTQ2jiXJPFjtG6YbWL4Ckyg+xm+5gQBwKvZiwWjzpfLFcZ+2y5fdKpAL7h+DaL9BU4bL8RQp3xa3i7B7fdRi9KN5/LXnS/CQEMmd1vazuLLnloiBoMDc4IY9uJrtomScgFBGwYiG2KsDQ4ApGqadfFrcwsH0VWCKEbbH9G2NGbFJyBlLwiMGW6s9U6pFqQm2o7vEwlK+EubMhjuhtkmhq/ABLqf4WtOEAAcv30LEfHzjKK2Uaz/sWc3p19Zfb3Tzp33n5+Am9XVTk8eFywWYW7BHoRIRLxjZ585xflOZ+Uy28aViJB+4pg7l4XBEIQ5QQx78UXbROsWGESoaZK4cNCGndx+DZtbEOFu1iomgCpXOUmYN2s18wTmGAGqvcb5TqQ22eb525LZnsFwB8w2MXwFJtD9DF90ggBg15XLeG/NSjyzcAHeWbUc6y+c400M89e+fASKm85vOyqw312dgwXHjzpVnDfOZ8Lm9dhy6SK6J4o5AntOwR6z70QoxZPpKTZ9j5eWLsLnG9dh6+WLLGkOw6M40wl6KGUaui6a41XtoZRpPvl71JvxRdtEqQ6kLg2k7A39efDKyaCakzz9NCBlo8BNDmc4R22vSK9NAan4utlYTmp1y/VZ5k3HlvYBbdhu/p20V2yPziveAan6GVRz1h3LwmAIwmwTw1dgAt3P8DUnSFpbi9E5SzkC95ttm6HS8meEpZQi6+QJPJO5AKFxMYjKysD8o4cdEtKmGdKFBLEjIn1arj66Uq/RYOvli1hzrgiltcJbAHOvXkGIjVnpG3cX/LBjKxPpDI/BnCCGvfiabaKqgyCyISZCthdo3ULh/qQWpHo2iHQASGk3kPL3QaqmOyakpf0hfKa9N4i0j0Pj0oZd+rnqSkGV60AbtoFSpeB30p+tb3zZIDRu4wuICJDSMFDlBqevBYNhK8w2MXwFJtD9DF9ygiileGHJQl5h+umGtTaPE3/4oEORdKFrgsTRGLk4E1O2bnJo3G2XLqJWrbZLQBfJZfhu+xa8sGQhnspIRbAN9zlQcsORx85gtBjmBDHsxadsk+4WSGkP/uh3fY7N45CytxyMdgtF3cMMorm/A2OGg5A6i4Lc7DlQCtqwXV/XvexFENkTNrxc6A1K6h157AxGi2G2ieErMIHuZ/iSE3ToZolFAbrrSrFN43y2ca3Tt6qPXZmN9ONHHLq2W4J+a/sTaSlYevqkoFAnlGLnlcv4ZttmfL15A3LOnjbuHJDX12HfjeucbfKmLUQSY4zUMxjuxqlOUPI0dF04x6vaQ8nMCXI2vmSbSE2MhahxN1BSYds41kqgWWzd+EV29VyQiglWotoCAr0xKq8YDao+IjhvSupB65eAVE4EqZoKqtpntGNUWwxSt8SmSD2D4W6YbWL4Ckyg+xm+5ARlnz5pUeiOXJzJe520thZn5TLUazQAgF9270CIJMZhMf7qsiwBESzCgPmJLU4kx1djnFCKb7ZuMt6ncev6K8uyUKtWG/t1S4jlHTM0LgY/797hmoVhMKzAnCCGvfiSbSKVEy0L0FqJ2TWUUlBtMajmojHDu+31xwUEtXQAfzRd2l9AwNsj1iNBNafNvwcpB5FHmUTyDaK+elZTH3WhFYG+zXWLw2BYgNkmhq/ABLqf4Y1OkFqnw/4b15F//apRVAPAgZIbVsVtg7apv7yuDu+vXWkSqY7FvAP7UCgtdXoE3bQNSZ/fout7J8eZnanffvkSb99giQjzDuwz9puweYPg2fSdV1pedo2dY2c4AnOCGPbijbaJkgpQ1R5Q9TFQSoyf68uMWRC4itHccdRHQOTDm34uewq0YSeoHZnQ7W/dQUp7teD6CJCKr8yeCameBqHz71StryRCqdrw8oB/XpRUtXxtmG1iOACzTQxfgQl0P8PbnKCdxZfRLyXeKCq7J4qx5FQhAH0UuU9ynKCwDRZHQ6PTRyJ0hGB4VgavWE04fBBZJ084rQRb8xaVld6iCH2gOBoXFGWc5zJp60bB+T6ducDYr7iiHL2T4zh9g8TReH/tSmM9dUfXpTEJXp/kOMwt2MN5GcJgWMK5TtDv6Lpwrle1h5J/96rfo60Bb7JNlFJDyTGTWt+yoaBqvW2i2huWxW35e01jaa9Bf17ddMt5mP7vqiMglZNNPnOmQA/Tnw1vyRjSx8yejT46LyDoDbXSAYAqN4ATYTd8f1qX3oJ10YHWpjSddZcPA61f5fB4DP+D2SaGr8AEup/hTU7QBUWZYD3wPdeuAgBGZS8WFLWvLMsyjpV39YrFCLVap4O8rg7px4+2WEy7osnqajnP5vON6wS3zg9akMzpW1JdhV9378DTmQvw0tJFSD9xDGrDiwtH2HzpgkHoN4n+YIkI49esYFELhk0wJ4hhL95km2j9Yh4BGg4i7auPqlMlV7w3b7XzjWOR6lkCEecIkIoJ+vtpzoJU/epkgR6Klm1zDwWRjzB7NsLn5iNBqn7hPkf1YZCKz0Dkz4CUvwfasLtF62L+jMJaLPoZ/gWzTQxfgQl0P8ObnKDfcnfyRolDDGIQAHoIJEELFEfji43rjGMlHz1kMUJ+q6bp+/66e4fxTLenW4hEhHGrzbP+LjlVKNj/p13mNWmdBaUUT2cuEHw5cOhmicvuzWg9MCeIYS/eZJuI/FnBqDStywDVnLQsbOtXN41VPs6CAH7W2I9SHYj8OQEx74kWBlqXZv5sKr4QnCNt2OqyNaHaEgjuMpD2BaUNLrs3o/XAbBPDV2AC3c/wJido3JoVgsJ1cLo+AvF4WrKgUJ2+p+lt/LrzRYJjhcfPg9LkbLtSo8HH61dz+vRMkvAmXAuRiDA4fT5C45wbdW8cb2hGKuflgekcn1+ykPMiIUQiQt+UeNyoqsRJaSnWnDuLI7duOjWqraivt/gyIf7wQafdi9F6caoTlPQ7umbO9ar2UBJzgpyNt9gmSqmwECyNBKn+3bBtXVjcUlWucTxS+YOAoA0HUYzj3ltbbP5yQPakwH3C9bXUnS7MDXOt+BKUmh9ropoLINJezb5TOIjibRCi1J/ZV64D1V5z7roo11l+5ppTTr0fo3XCbBPDV2AC3c/wFicIsBxBf2/NSgBAzIECwWj3KZnUOFaDVoP+KQlmfYPE0Zi6g/+tflGZHNlnTmHnlcvQ6HS4VVONZxemGbd0B4qj8fiCZFxUKDA0I9Vp4vyLjevw97692HDhnNlW9BOlt/HphjUYkJqIqIVpGJGVgciEWITHz8PYldk4cfs23sxZyhlv5OJM3OQR+Y5Qr9EI7kQIEkdjYeFxp9yH0bphThDDXrzJNlmLoAMAKXuDR3iHg0gHgtKmShsWM5orzW0TpTpQVQFofQ6oulCf/V2VDyLt3XSP0lCQ8vEgmivOFefVM0BqYkHVRzkvfimloMq1IGWvg8gGgZSNApE9C1LaDUTaB6TqRxD1QfM66JX/5TyLlkAbdlsW6NqrTrkPo3XDbBPDV2AC3c/wJifookIheAY933AGvUGrwSs8Zc7eWbXc6EAQSkEoxSmZlDep3NDMVEhray3MBKhsUCL24D68vHQRnluYhk/Wr8G6800CelZ+bovLqTW2fsnxuFSuMJvD3uvXECIR8QrkxhcGfZPjzX4eIhHhpaWLnBZJ/3LTet45hMXFoKy+3in3YLRumBPEsBdvsk20fgl/xNpwBh0wRLulfc371TblCKFUq4/I12WDty55xURQqhWahuE+l0CqfgKRPw9S9qI+Iq/SC2hKqf5zZwl0xVugVGk2B33dd/0LCsGIu1kiPEP/GpFz1oSqQaQDeeYQAVI2yin3YLR+mG1i+ApMoPsZ3uQEAcDOK5fRPyXBKAK7J4qx9PRJ488rG5TomSjmFcexB/bhsw1rjaL2/bUrERE/jzci//H61YJzqFAqMTQzlRN9DxJH442cpcbyZ/L6OgxakOQUgR4sEeGJtGS8vWo5PtmwBpsvXYCOEERlZbRo3EJpqfE7lVRX4bRM6lDmdXldHZ5ZuMA41yCxPmP+uvNFdo/F8E+c6gQl/o6uGXO9qj2UyJwgZ+NNtkmfxT0WnCRr8qdBNU22iaoKhLeI1y8FKXtN/3dpb8O5bYHIb/1i4Xmoj0BfLo2bCZ3UzDOZxz6eSL6jLQxE8TqI4j8glVNBNadAdVIBYW5jk/Y11n2nVAeqOW+oBW//C2WqOoCmJHWGZyF9DFR7ye6xGP4Js00MX4EJdD/Dm5ygRjQ6HQ6W3MDe69c4ddABIOPEMcHIdbBBfJv+XUi8BomjUdnAjQzoCMHO4st4ZVmW4D2yzzSda5PX1+HnXds5Z9X7z0/AgPmJLRbtLxtKmrWkbbp4HtcqKzlb4HsmSZB67IjdztDqorOINPmekQmxnBcnDIYlmBPEsBdvtE2UVIKq8kHVJzh10AGAlH8kIIzDm/1XKPJs+LzsNZ771oLULTHUEue7NgxU25Swk2rOgCjeBSezvPw5CGdct1Gsl4aCyEe0WPhTUqPfoi57ymR+z4Kq9tm3HpSAVP7KfSayIZwXJwyGJZhtYvgKTKD7Gd7oBFnit9ydTkvQVlQmR/bpk/izIB/T8nYaz5tbEvWjc5bxitsKpRJnZTJMz9uN/inxCIuLQe+kODxqshvA3e20VIrH05J5t6fbI65Py6SC5/4Lbjg38Q+jdcKcIIa9+JptIvKnnRO1lg0F1V4HrUvTl2SrmgYi7Wf9uhqJ2ZwopaC6UhDVfpCKr0BKe4OUdgeRPgb9FnRnRNnt/X5PgKhPGl5YmL5sCAMp7WZX9JvWLeB/ISLtB0p8498Nw7Mw28TwFZhA9zN8zQlKO37UKWe/+yTHI5Jn+7st7cm0FMw7UIDiinLjvJQaDYZnZXikXFvz59G4vX9V0RnBawanz7c5iv79ji2CyfssHRVgMBpxqhOUMB1d0//0qvZQwnSf+j3qC/iabSLlH4L3XLldLQKk7BXHry97E6RusfFcPABQzXnoI+ctnZsjzfyetC4TpPIbCNaCr5pm0/OmlJonoTMR+5aOCjAYjTDbxPAVmED3M3zNCapQ1rcogt4oZsOcFIWfU7AHlFIsPX3S7cI8WCLCUxmpmLJ1k1FAB4mj8dWm9ahWqTBnb57FZ2XrefQxK5YJjvHsQvO6uAxGc5gTxLAXX7NNRLnZAQEb1kzMdneSMO4B2rBLP6+KrwTEsKua4TuVfwmieKvpc2kv0NoE64nsFKNtet6UaizMIRKkepYrl5vRSmC2ieErMIHuZ3jaho/MQwAAIABJREFUCdISgpSjhzE4fT7C4+fhtezF2HnlsmD/XVeK7Ray761ZiV5JEqOgnLpzm1OF8tZLF/DOquV2R/aDxY5H2yMTYjG3YA8qlPpz9OXKepwovQ1ZXVN2+sxC4fP6fZLjbY6g/7Rru2AE/bMNa1v2D4DhFzAnyDdQKBT48ssvERkZifvuuw/33nsvp7kTT9smqlMYtpf3ByntBVLxtcXt16R6BuxLnhZmcm49DKT8PRDFeN6os2MiuTuIrhT2bWUPM2kO3ls2GLR+aVMiOO11fXk4Utf0rMo/EXhpEAFSOcW29aEURDZE8HvQ+mUt+wfA8AuYbWL4Ckyg+xmedoK+3baZIyIbt4ivFcgQ/u22zXZvIx+2MA2VSqUxA3vC4YOCtb3tbUHiaPROMi/lZqkNyZiPnVcu42DJjRbdV2GlxFllgxLdE8W8teBjDhTYvEbnyuS85e+CxNE4dLPE+gAMv8eZTtCD8dPxcNqfXtUejG8dTtDIkSMRGhqKuXPnIiMjA5mZmZzmTjxpmyipNSRVi+CKR2kfwfra+pJfdorZyqkgRAtK9buZiOJt50azjbXSbWyKd0C110Cq5zr+YqDsJevPV5UnOAZVH7F9neoW8oxhqD1PLJdSZTAAZpsYvgMT6H6GJ52giwqFoAAdtCAZOtKUJVel1SL56CH0TJTYLWZDJCLMys81jrXMxu3olrLAO9K+3bYZVysrQAyRa0opXl++RHDO1iLyVysrmj9SMw7dLEG/lHjOdVO2boLGUM/dVnYUX8KjJtnpeyfHYc25s3aNwfBfmBPkG9x9990oLCz09DQAeFig12UKRJEjQCqncvvqboNU/+5w1Jmq9urHoQSk8uuWRa95I+I29GvYBaqTmXwnhQVx38fyWLIhNj7jBeBkmS/tBlq/1L51Mpa/MzkaIB8Bqjln1zgM/4XZJoavwAS6n+FJJ2jRyRM2CVAdIYYt5I5HvR9bkAS1ToevN2+wqX9kfCx+2rUd76zKcUpSukBxNP4qyIdofwH2Xr9mFOkanQ4TNm/gRLkfT0tG3rWr+Hj9asGxBqQmQkuIpcdrRKXVYmfxZaQeO4JVRWdws8axtdbodDhy6yYO3Swx7kZgMGyBOUG+waOPPooDBw54ehoAPGubSMXnwuLWRIBS3W0Q2WNw/Ix3BEjVT6C6W7aXL5M+qRelgiXX7G39QGrEoLWJnC38RHsLRP4St6/iHRDVIRDZUOHvU/lfm58zJeUg9etAapP1LwlIjUPrRUkVqGo/qOasQ/XUGf4Ls00MX4EJdD/Dk06QpSzjgeJoyOv0Z9a2Xr5oswgWEtN9U+Ix78A+q2L72YVpyL9+1TjHGpUKw7MyWizOg8T67fuNW+vfXrkcSpMa72qdDoWlt1FUJoeOEIxavsTiVn7TeuwAUK/RoLiiHDUqldlzrlap8Mn6NZy5fLZhLW9fBsMVONUJipuOhxf86VXtwbjW4QQdPnwYzz77LPLy8qBQKFBdXc1p7sSjAr3yW2HRLR/Z1K9qWgvEeZOgJWWvWx+n/H1Q3S3jvanmAlpW17zZPBrPvtfEcp4FJZWg6uOgupugupsg0r7gPycfBlLa0+ycPiXloNqrxm38nJ9pipq9mOgBWmt7fhQGo6Uw28TwFZhA9zM86QRVqxoQER/LWyZs7MpsY7+fdm23KXO7kJAOkYjw3+1b0M9CTfI/C/bgelUlr2PgzNrrjS1YIsKcgj28zyXv6hXB68LiYrDO5Hy+RqfD7L15iIiPRaA4GqFxMfhp13bUq9XGPh+uW2V25j5EIsIn69c4cTUZDGGYE+QbXLx4Ef3790fbtm05LSAgAG3btnXrXDy6xV3wjHQYaG2KsZ9wkjLT1g1ENlxA1IaC1KZYvr5hB6iujHeeROak2uvNGlXx5ygh1bOEXyTIhoJqmo49UZ3UkAzOEOWXDgCpXQRi2PlFSQ2I9FHe8ezd6s5gOAqzTQxfgQl0P8PTSeI2XTyPEENkufHc9YDURFwxOV/9e94uQYHcPVGMX3N3oofA2fQQiQi9k+NQXF5uUTB/sHaVcdt5c1YXnRUU2YMWJJu9YAiWiGw6v943OZ73fjEHChAqEX4hUG0S+f4td6fgroCRizORWXjc4hyuV1U6d0EZDB6YE+QbDBgwAI8//jiys7ORm5uLvLw8TnMnHhXolIJU/W4QjJEwnpUuHwdKm37/EvmzAiI3XJ/wrfwjYWFeGg6iGA3SsMuyYK5bLRhRFo70h4PInhQW01aj+t/y369slPB1Za+YPD8NiDxK4P5hIOUfg9SIILhFX/6McxeUwRCA2SaGr8AEup/haYEOANerKhFzoADf79iKhYXHOQIU0Cc6ExLf1s5p/7hzG25UVQEA+iTHWxSrwRIR3luzEkVyGef+Kq0Wzy1K40Shgwwt9+oVxBwoQLcEsXGMHolim6LoQeJoXscr9sA+ixF0tSHBW7mVmvC2nJ3fc+2qaxaVwTDBqU6Q5A88nPqXV7UHJX94/PeoM7jjjjtw/vx5T08DgOdtE6UUVH0YpPoPkKpfQBu2g1Ju7g1SEyMswCsm8AjQMH1/eZS+JjipB9WV2iCae4FUTQMlVdw5ai5AnyDNdA4R+ozy2kuGGuiNEezeFl4WNGvlH/A+E1L2hvDLhvL3m+bVsNX6S4DSSIsvECi1LccKg9ESmG1i+ApMoPsZnnaCbIFSil927zCK8kZxPDQzFePXrBCs0f3L7h0A9LXWt16+iAEmWciFWohEhG4JsbhcruDMoay+HpO3bjIK4hGLM7H7arHx50qNBqnHDiHEBlHcKORHLV9i9l0rlEoMTOWfZ7BEhO93bDH2FXpxYU8rrih30aoxGE0wJ8g3GDJkCHbs2OHpaQDwEdtEakDKGhOphTUJ4Iqv9aJaSHw2bDdcXw1av8T2yHbZS6BUzZ2DuhBEMdYkOv0JpxQc0ZWBlE+0I4IeDlobZ/5d1YctCnyq3Nh0z5oYcDO08zULCe5szATPYLQUZpsYvgIT6H6GLzhBgF6k775ajMlbN+GT9WuQdvwoalQqPJ25QFB8vr1qOSqUSjy/ZKHNEeXGfv/dvsVsDodvlWB0zjIEivVb63/ZvQM5Z07huYVpdgvjIHE08nmi1/GHDwomh+uXkoCqhgZj36uVFTbfr/mW+xCJCONWr3DlkjEYRpgT5Bvk5OSgW7duyMjIwNGjR3Hy5ElOcye+Y5uUoPXLQCq+AKmcpI8ea29ZFNq0NgVUfcKQcM2+TOxUuaHZ/an+/o3n0WVDQGrng9TEgUj72zW2sYa4TmH2PfU12gXmWv4RZzcYrV9s4/cyealh+h3r0l2+bgwGwGwTw3dgAt3P8BUnSIj3164UjKD/tGs7vt22mffn1lqvJAnnPkdu3USIRMQRz46WXwuWiDAiKwPT83ZxztoDwOicpYLXDc1INfv+Y1Zk2/T9nkxL4fx97MpslCvrXbo2DEYjznSCHhL/ga7z//Kq9pC4dThBAQEBZs0fk8S1FEpVFiPoRLkJRPaExYi0YKv4nHuv2kTrEWmbWy8QxRjQ2vmgpNrk+xCLLxxI9UzunEil4ftbmlOYoVxbb+5n1bPZ9naG22C2ieErMIHuZ/iyEwQA+deuCorgwtLbCHMw+3qQOBrVqqZotb4Oe8u2k/O9RAiPn4cDJTcAAOcVZYJnyoPE0XhlWZbZ9y+trcGIxZkWI+dhcTHGYwGNLxi+37EV+25ch87GWuoMRktgTpBvcO3aNYvNnfi6bSLVc3kEaoQ+wt2Q67iIlj1lvAcltXBeqbVmkXT5M8ZIOqlfZVmgNyvNBgBUtR9E2s/6fUojDM9JX6aN1CSBas65bZ0Y/g2zTQxfgQl0P8PXnSAAWHyqEN0SYo2itEeCGHP27sEpaWmLBHS/lHhknDgGSilCHYjC2/oi4KmMVFBK8fbK5Rb7/ilQlo1Qir3Xr2Hqzq3GKH+j0I+In2exnvrjackolJa6ecUY/gZzghj24uu2iVI1SOUPXJEuewqkfilIfU7LBHTZ66Cq/YZz4c4W56aR8d/15+xLe1juqz7B/wxIPUj9ehDFu01jGs+mW8kwr3gHlFTwjstgOAtmmxi+AhPofoavO0GN1KnVWFV0Bs82Ow9uKtwdbeKD+x2OxNvaXly60Gqf7oliXKmoECy5AwC3a2qQcPggpuXuxKKTJ6xG/YMNZehqmmXOZzCciVOdoNg/0DXlL69qD8W2Hifo5s2bWL58OeLi4iAWiznNnbQW20R1tw3nwR81EaDdWh7hLg0HqWuh0Lfawgxnz629MBgFQhos2iaqOQlS85e+lnqN2LYXBOUfuXGlGP4Is00MX4EJdD+j1ThBlGLk4kyz89jO2JYemRDr9O3t5pF02yP0kQmx+GnXdkhra6HSagWfydpzRTbeOxpLT7s3ARTDv2BOkG+Qnp6Ojh074u6770bXrl3xyCOPGFtgYKBb59JqbJPuJvSl0JxxRryZSC97xcUCvfFlgI19ZU+A1C4A0dWAUh3/86BUn1DPxjGp9rqbV4zhTzDbxPAVmED3M9ztBJ1XlCH36hXcrHHu/ZxRcsxX24frVuNcmRyLTxVi3OoVeHd1DiSH9ttc8i00LgZzBbbPMxjOgDlBvsGDDz6ImTNngnhBbgp32iZKtaDqI6CqAlBS69SxSc08WN3O7Q7x7PbWS19DXnsVpEakj8RXfAVSPceucahqv1PXg8Ewhdkmhq/ABLqf4S4n6HZNDUYtX8KJ2k7cshENWo3Va2tUKiw/cwqSQ/ux/fIlaHmcxxVnT3tcKHuqhUhExp0Djcng7B1jZdEZVyw7gwHAyU7QvBnomvy3V7WH5s1oFU7Qv/71L1y+fNnT0wDgPttEVfsMGdUbRWFP0Lo0267VloDWpYHWJoFqTvP2IZXfeLmQdmULh/7MeePuAXtfVISB6liOFIbrYLaJ4Sswge5nuMMJEtp+HiwRYerObRavPXyrBD2TJAYhqj8HHrUoHbI6bpTj2O1bLhO/rt7e7mlx/1hqEpQa6y9KGAxHYU6Qb/Ddd99hzpw5np4GADfZJgvbz2nDFsvX1qWhqY63QYBXfmu2tZvWSlwk0J29Zd7bWjhI5SSXrT2DATDbxPAdmED3M9zhBB0suSEoEEPjYlDZoOS9TqXVom9KvFkW8hCJCB+uW8XpSynFK8uyeM+gOyKwG7OgP5aa5FCiucHp81sknBvv7+qXAy8tXYTiinKXrT2DATAnyFfQ6XQYOXIkhg4digkTJmDKlCmc5k7cYZtIjUggqhsOonhT8DqqLhQUlrRuEbevrhT6UmjOEOmNEelQEMUYx8aQPdtCce+q7fqmLQykcgooqXfZ2jMYALNNDN+BCXQ/wx1OUPbpkxZFYpFcxnvd5ksXBK8JEkdDXl/H6S+vq8PYldmcPu+syrErmvxGzlIsPlWIuXv3IPv0SSg1GrywxHqGddPWI1GMfTeut1g8nyuTY87ePITHzXO6MP89bxcuKhQuW3MGwxSnOkExM9A16W+vag/FtA4n6I8//kBAQAAiIiIwdOhQPP3008b2zDPPuHUubhHolROFxar0UeHrqn4RFqplL5r1p+rDILKhJmP3AikfZ4dQDgOp/hO0Ngmk+i+QhjwQomsS67Y2xViQmtiWiWzFe6CqfJCKyS4Q5pEg9ctBdVKXrTmDYQqzTQxfgQl0P8ObI+iLTxVaFJmXyvkFZnFFOfZev4bS2hrMKdiDUIltJdJeXLIQ16sqMXtvnnFb/VMZqcY/29Oyz5zCgNREizXILbVgsQj1ajXGrsxGsJPFeaBYX7Ktnm1rZ7gJ5gT5Bl26dEFGRoanpwHAGyLobwhfV/GVsLiWDeK9hlICqi4EVR0AJXUgZS/YLlwrf9AnW6v4yjDfMBD5qw4K4NVWXgw0btsX+Ll8JCiphn5XgLMFOiutxnAvzDYxfAUm0P0MT59B/2HHVsHrTsukggKzV1KcxRJjJ0pvY+rObXh2YZpN28SfX5wJpVqND9auctuZc0vCO0gcjZ92bbd5rMh4+7fhH75V4orlZjDMYE6Qb/DAAw/g4sWLnp4GADfZJm0JhM+gbxa+rjZZQMRGgFR8IXwd1YEqN+kj99L+VsSqYU7V00FJOYhskGXh7M5WPdvGvuFWXgbwte6uWGoGgxdmmxi+AhPofoYns7h/vXmD1SzuH65bxRuFnn/sMG9/aW0t3lqxzCHBPDM/1y3C3LQ1njXnjXIniG0a4+P1qx2691mBowUMhrNxqhMkmoGuiX97VXtI1DqcoNmzZ+Prr7/29DQAeDKLew+rWdybBHNEMzEaCao5yXsNUR0DkT5hp1g1tKqZDgjdlrRwkNJuAj+LACl7yYaXBeEgZa/b/1LBwtECBsPZMNvkW1y6dAlbt26FUqnfeUsp9fCM3AcT6B4mISEBjzzyCDp16oR+/fohPz/fYv+8vDz069cPnTp1QmBgIJKSkuy6n7vroJ8rk+vroNt4P6VGg9/zdiHCECEekJqIzMJjvP9Tyupq8WhKgsNi2RVnvS21IHE0+qXEG7PT87WeiZZF+gdrV6F3cpxd9w2WiPDMwgV+9YuN4VmYE+QbvPbaa7jnnnsQGBiIl156CaNGjTK23r17t1rbpK+DfhhUtdfmOuhUew2k/KMm4Vz2KqjqAH9f1V4rAtua+O7rRnFuEOHSR4V/Xvay9THsrHduvG/1DGcuLYNhEWabfAOFQoHnnnsOAQEBaNu2LYqLiwEAH374Ib755hsPz849MIHuQbKzs9GhQwekpqaiqKgIkyZNwl133YXr16/z9r9y5QruvPNOTJo0CUVFRUhNTUWHDh2wcuVKm+/pboHuKCqtFor6euh4aqA3MmNPrtXt6T2sCF53t++2bxEU78OzMpB67Ajvz/ulxGPxqUKUVFXZ/VKgR6IEhaW33bh6DH+HOUG+wfvvv8/bhg4dioCAAGabeKCkDpRUCf+cUhD5CCtRY3cLcBua8bw7n4ieC1L+Hnij42Uvg6oKQOtX2n/PspcsPksGw9kw2+QbjBs3DiNGjEBJSQnuvvtuo0Dftm0bunXr5uHZuQcm0D3IwIED8fnnn3M+i4iIwNSpU3n7f//994iIiOB89tlnn2HQIP4kNXz4ihNkC09nLrAqUP/Ys9vjoty09Z+fgMfTks3O5weKo7H50gVQSpF+4hj6JMcjUByNyIRYzN27B2qdvtZug1aDiHj7Iv/7b1zz8Eox/A2nOkHRM9A14W+vag9Ftw4nSAhmmxxHX2bNijCVRxm2gwv18UDNc/kL0G9zNxXh4SDSvqC6W6CkHqRqKoxb4WVDQJVrm763qsC++0n7gpA6C0+SwXA+zDb5Bg888AAKCwsBgCPQr1y5grvuusuTU3MbTKB7CLVajXbt2mH16tWczydOnIinnnqK95ohQ4Zg4sSJnM9Wr16N9u3bQ2Njhu7W4gQBwPCsDIvCNCorA5VKpcW65uF2il1ntaczFxjP2g9Jn49154sA6JPdNW5hDxbrf/7MwgW4XVNj/N6/7d5hc7b4EIkIM/NzPbRCDH+FOUG+C7NNLYPqFFbEaRhI9VxQ9Qkr/Xq4X6SXhoHIn2v6u+JtUI3eNtG6LDQlgTOI+IqJoFSfvJVSneFa20u6UdUeTy4Vww9htsk3uPvuu40JTE0F+uHDh/Gvf/3Lk1NzG0yge4hbt26hTZs22LdvH+fzWbNmISwsjPea0NBQzJo1i/PZvn370KZNG9y+zb+FWaVSobq62thKSkpaxf+8ACA+uF9QqAZLRMi/fhUA8NvunRZF7NDMVON2cHdldA8UR2P75UuQ19WBGM6Gq3U63lJtIRIR3lmdY/zeSo0Gn6xfY7NA/+/2LZ5YHoYfw5wg36BPnz7o27cvp/Xo0QNt2rRBz549MX78eOzevRsAs032QBSjhaPgssdBdXJ9P9kQCwK2H4i0jwci6j1BtDdASaXx+1DNWUFBT+sWNPXTXgGRD7NdoCvXuX1tGP4Ns02+wQsvvIBffvkFgF6gX7lyBYQQjB49Gm+8IVwSszXBBLqHaBTo+/fv53w+c+ZMhIeH814TGhqK2bNncz4rKChAmzZtUFpaynvNtGnT0KZNG7Pmy//z1hsTyfFHv/ulxGPzxfPG/mNXZlsVsiMXZ+LTDWswPW8Xjt2+hfhDB1wq1oPF0fh2G7esz+aLFyxec6uGu2bnFWVYfuYUBi1ItnjdklOFblkXBqMRpzpBf89E1/hor2oP/T3T53+PAsDUqVPxz3/+E4MHD8Y333yDKVOm4LHHHkObNm0wZswYREVFoW3btli7di2zTTZAtVdAyj8WFqVlr4FoLhj7k9Je1iPaZf8BqZgEUiMG0d4EUfzH5SK9uXAmVT9CMDu7PIr7DCjRZ8qvTbISTQ8D1fLnNGAwXAWzTb7B2bNn8T//8z8YOXIkOnbsiDfffBORkZF44IEHcPnyZU9Pzy0wge4h3LWNsLVFKSileHd1Dm/k/PG0ZESaiPbXshejuKIcPWwsXxYsEWHnFf3/+GnHj7o8mv7Zxqbze9lnTlndbn9GJgUAEEo5GdlLa2vwanYWb/T8qYxU1Nu4xZTBcBbMCfINPv74Y/zxxx+cz9RqNQICAjBs2DAAwG+//Yb+/fsz22QFqisDkQ7kEaVhILKhJlHwcJDK70DU52wXzbInQHX6nQik/EOXR9Rp/VL9d6IakKpfLPeX9mt6BpSb1JWqDoJIB/C/eKj8zn2Lw2AYYLbJdygtLcVvv/2GF198Ec8//zx+/vlnwR1ZrREm0D3IwIED8cUXX3A+i4yMtJiIJzIykvPZ559/7leJeI7dvmWzAA6RiNDPjjJsQeJoPJGWAh0hOCOTulScB4mjkXHiGACg4MY1m/r/unsH3l21HEFi/dn5b7dthqyuqUTQhgvnjOfyg8XReGnpIiQdOYSy+npPLRfDT2FOkG9wzz334NKlS2af9+rVCx07dgQAnDt3DnfffTezTVagtRLhKLNZCweRj7RDNEeAVP0MACC1Ca6PoGv1L6pJzV/WXwZI++mzvDdmrpc9BlobB0r1L2YIISA1IhDZY4ZreuszwivXg1KVx9aL4Z8w28TwFZhA9yCNZdbS0tJQVFSEyZMn46677sK1a/qs21OnTsW4ceOM/RtL2UyZMgVFRUVIS0trtaVshFhw/KjNCdIcbZ9uWOPSe4RIRBiauQC1ajUA4MN1q3izutsyzpD0+ahRNTk5OkLwzdZNRlEfJI5GaFwMss+c8tSSMfwQZzpBD/81E4/ERXtVe/iv1uEE/e///i8WLlxo9vmXX36JNm3aIC0tDevXr0fnzp2ZbbICKf/AtcJZ2s9K5ndntDCQyu8BAJSqQKTWtuBbGodbq5ho5YZM8aFNLzJkj4FqznpiuRh+CrNNvkF6ejpycnLMPs/JyUFmZqYHZuR+mED3MAkJCejatSs6duyIfv36Yc+epqym7733HoYOHcrpn5eXh759+6Jjx4545JFHkJSUZNf9fN0JWl101qXi3NUtMj4WP+/ewYlqNyapa2kkHgAyC4/xbs0PEkfjXJncE0vG8EOYE+QbzJgxA3fccQcmTpyIrKwsLF68GBMnTsSdd96Jl19+GV27dkW7du3wj3/8g9kmK5DKb2FPBnOva9IhoHWpTVnZdbdbPCbVNu3O0J/Nb/58wkFkTxqj7QyGq2G2yTcICwszJig1JS8vTzBZaWuDCXQ/w5ucoMvlCoj2F+C33J1Yf+Gcsda3JWrVavRIFLs127oz2+QtG82+04frViHYYYEuwpeb1hvHGrYonffZhEhEmL7H/Jcdg+EKmBPkOyxevBiDBg3Cvffei3vvvReDBg3CkiVLjD9XKpVoaGhw+Ty8xTZRSvU1vatnglTPBlUf5eT8ELxOtd/zIrslYrpZYriWRdANY9Zn68fSSWFpqzxV5bpiKRkMM5ht8g06deqEq1evmn1+9epVdO7c2f0T8gBMoPsZ3uIELSw8jiCDcAyNi0GgWJ9JvbJBafXa/OtXEZkQa9y+HSjWZ27nE6+NP7fWXL1t3vQ+8ro6zvex5Qy6UAuRiDB15zbjWI011M3uK47G15s3OH0dGQw+nOoE/TkTj0iivao9/GfrcIK8CW+wTZRqQSq+MgjHSEMLBan6xTaRXitpigwbo8UDYH42PQJE+ihPRJmvuanEWtmLZt+HVM9umUBv0FcqES7T1ijkVzh9LRkMPpht8g0eeughrFtnXoZx7dq1+Pe//+2BGbkfJtD9DG9wgq5WVghGeX/atd3itTpCcOhmCVYVncG8/QV4eekiowhvngW9b0o80o4fxdOZC4yCvfGs958Fe7Dv+jVM2LwBLy5ZiIGpSW6Loh++VWL2vbon2pZpnq8dutk03rg1K3hfNgSJRUg5etjpa8lg8MGcIN/iyJEjWLRoEbKysnD06FGPzMEbbBOtX2ZBbG61fC2pA23YDVKfDVL1B4j8WZPre3DHk78MUpNsUuc83CDEu4Mot4PUrwApfx+k7EWTPq5u3c2+E7EirC2+VJD2BaVKw7OpByntKfxsNUUuWU8GoznMNvkG3333Hbp27Yrdu3dDp9NBp9Nh165d6Nq1K7799ltPT88tMIHuZ3iDEyQ5tF8wKVpkQqxgpOK0TIrB6fObCU/zMb7ctA47ii8h7tABY/S48WfdE8XIvVpsHFOl1SJqUbrbIuhBYvN65gAwcnGmQ9v2RfsLOOMcLLlhTA5n+uKjf0oCKpTWdycwGM6AOUG+QUlJCQYPHoyAgADjFveAgAA8+eSTuHHjhlvn4g22iShGC0Ssw0EqvhC8jtavgHlN87Bmfw4HqYkBUR3Ui2/j54Z+8igQXVMJIaq5aBD27oigh5nVMwcMpeMcun8PUNUezlikJpb/uZZ/5LwFZDCswGyTb6BWqzFmzBgEBASgQ4cO6NChA9q1a4cPPvgAakOC5dYOE+h+hjc4QbPycy1uPdeASli3AAAgAElEQVQSYnZNrVqNPsnxNgnp7oliXCgrE4zSf7J+DWpUKqQcPYxnF6a5LXIeIhHhg7WrIKurNXsJsejkCbvG6p0chyK5jPf57iy+bNw1ECiOxtsrl6O4otwla8lg8MGcIN8gKioKjz32GM6fP2/87Pz583jiiScQFWUu2FyJN9gmY6kwvlb+Du81VH3YdhFc/rHlKH39ElDtdZDqGQL1w13YaueDkkrzZ1LxGexKfqcYC6ozT0hKKQGtTQSR9jX07aY/OkDqzPoyGK6C2Sbvh1KKa9euob6+HhcvXkROTg42bNhgrCLiLzCB7md4gxO0o/gSr+gMlogwavkS3muyT5+0S8D+tnunRTH/3KI0tyea65UkMf75ybQUbL7Y5BSfkUnR0+TntrRqlXDiJkopbtfUoFzJaqAz3A9zgrjs2bMHL730Ev7v//4Pbdq0wZo1a6xek5eXh379+qFTp04IDAzkzYq+cuVKREZGomPHjoiMjMTq1avtesadO3fG8ePHzT4/duyY2xPxeINtItXTBcRoOGhtHP81FRPsELDdQBTvCESlw0Dkr0AfiXdzNnjpQBOBPYabfb0uC7bXdw8FKXvF4jOmVA2qu8mEOcMjMNvExRttEyEEHTp0wMWLF22+pjXCBLqf4Q1OkI4QjFq+hCOggyUiBEtE2HfjOgC9wDx0swSJRw5i8alCTM/bZXPCt0BxNMatzrFYW9xdW9qttdRjR1CnVqNfSrzdtdAXFpo71gyGN8CcIC6bN2/Gzz//jFWrVtnkBDXWFZ80aRKKioqQmppqVld8//79aNeuHWbPno1z585h9uzZaN++PQ4ePGjzMw4LC8OhQ4fMPj906BCCg4NtHscZeINtotoSfb1xjkCOAJE9AUr0u5AoVYMqN4HWJoI2bAGRv2ifGC57xcLPe9knhl3WIkE0F0DVRwReJlhqvUA1Jz22hgyGJZht4uKttqlbt244cOCAzf1bI34v0N977z1OfdfWjjc4QYB+y/rM/Fz0To5DsESE0TnLcKBEf+ZRqdHg3dU5CBTrt4WbZmu3tX2+ca2gMI9olkzOky1IHI2kI4daJPAZDG/DmU5Q1z9nevz/0+atawu2EdriBH3//ff45z//ybFNn332GQYNGmT8+5gxYzBy5EjOdSNGjMDYsWNtnsvatWsxcOBAHDlyxHjs5siRIxg0aJBNkRRn4i22iWovGzK5dwMp7QFS+S2o7lbTz2SDm4R7aSj0yc/sENWVkwX6uylbu61N9riF3QHW5toNVF3o0XVkMPhgtkkYW21TREQE5zNX2KaNGzdi8ODBOH36tM3XtDb8XqC//vrr6NSpE0JCQjBr1izcvHnT01NyKd7iBJnS/Dz2rPxcswh3ULP/WhO9cYcOYMLmDZxrGku6NU805+k2Knux3S8gGltkfCzq/CRhBsN3YE6QMLY4QUOGDEFwcDDHNqWmpqJ9+/bQaDQA9GVoYmJiONfFxMTg4Ycftjh2ly5djAnh7r33XnTs2BFt27ZFx44dOX++99577f5uLcHbbBOllGObKKUg8ud5BKudEW/VPhD50zCL0kuHWLnWAwJe9oyD14aBlL/vwdVjMPhhtkkYW23TxIkTOZ+tXr3aKbbJlC5duhjtUefOnTk2y922yVP4vUAHAIVCgdjYWPTp0wft27fHyJEjsWLFCuM/ttaEtzlBzaGUCp7FDpaI0Jen3nnzFhYXg9s1NdASgowTxzAiKwMDUhPxxcZ1OCWTQrS/QHCL+6jsxW7/hRq1KL1F1/+9L9/Ty8ZgcPAXJ6ikpATV1dXGplKprH4vW5yg0NBQzJo1i2Ob2rVrhzZt2mD+/PnQaDTo0KEDlizh5uxYsmQJOnbsaHHszMxMm5s78XrbpDlpRZR2t/LzcJCyl/XCX6cAqZ4FIntK36pn6T8rGyUs+OWWtsa7qJW9ZP8LCJNGNWc8vWwMBgdmm4SxxzaZsm/fPrRp0wa3b+urUDhqm0zxJtvkKZhAb8bx48cxYcIEdO7cGffffz8mT57cqhIVeLsTpNHpBH/xhMbF4OddOyxG0SMTYrHzymXesYsryrHp4gXsvX4NzyxcwBHpQeJovLIsCxEORrIdbUHiaHyzbRO6JcS2aJwtl1rPv1GG7+NUJ2juLATGiryqdZ07C23atDFr06ZNs/q9bHWCZs+ezfksPT0dbdq0QadOnXD//fejbdu2ZlGKxYsXo1OnTnY/a2vMmTMHlZXmGb6dibfbJtqw27Igrf7bSjR6GKjWvHQdpQRUfQS0YSuIcgv0pdUao+sGcVwx0f3ivDQUpFrcsuulfUBNSscxGJ6G2SZhHLVNBQUFaNOmDUpLSwHoBfrSpUs5fVxlm1ozTKCbcPv2bcydOxdhYWG46667MH78eERFRaF9+/ZmjpCv4u1OEAAMz8oQFOEbLpzDDzu28m6BH56Vwbvdu1atxsfrV3P6Ry1Kx8z8XLy8LAujli/BguNHMTyrZZFsR9uUrZtaLPJfXLLQAyvFYPDjL06Qq6IUzbcR3r59G++++y7atGmDO++8E+PHj0fnzp3NRLq92wht5R//+AeKi4udPq4p3m6bqE5qIZocAaK9xbN13dCqfgal5uVDqeYiiHwYt2/5JyBVP4GUvQhS/iGIcjP/mC5tYSClA0DKXmvhOOEgNSIPrBaDwQ+zTcJ40xb369evW2z+gN8LdI1Gg5UrV+LFF19Ehw4d0L9/fyQlJaGmpsbYZ9myZejSpYsHZ+k8vN0JAoDNly6YidAQiQjPLUqDWqeDSqvF9yYiPUgcjY/Xr0Flg5J3vMlbN5kJ+hCJCFGL0kEMZwzPyKRuF+ZB4mi8tWKZU8YKkTAniOE9+IsT5OpEPKa26f7770dgYKDRNo0ZMwZ9+vTh2KaRI0falYjHVu6++26/F+gAQKp+gflZ8DCQqt8BAFR7A0Qx2uRnPUBq5vGLc6oGkT3BI77DQaqbtpCS6rkeiJ53N3wPJ5x7L//IbevDYFiD2SZhbLVNkZGRnM8+//xzsyRxzz//PKePvbYpICAAbdu2FWz+gN8L9Pvuuw/33nsvvvzyS5w4cYK3T0VFBR555BE3z8w1+IITBADrzhdhSMZ8o/j8avN6yOu5dVPL6utx9PZN3KoR/i7lynqLJdW2GbaG/7p7h9uEebBYPx9nlnp7dH6iS9eDwbAH5gRxqa2txYkTJ3DixAm0adMGMTExOHHihDESMHXqVIwbN87Y/8qVK8bt7GPHjsW0adPMStns27cP7dq1w7333otz585h7ty5dpeysRUm0PVQqgGpEYFI+xi2cPc1CHAtt5/2Kqj6OCipFR6rYbMFYdsNhOifA5E+5ubIueElgbPGrPrJpWvCYNgDs01cHLFNd955J6ZMmYKioiKkpaUJ2qa5c+c6bJsKCws57ciRI5g/fz4iIiKwatUqm8fxZfxeoC9atAgNDQ2enobb8AUnqBFKKeR1dYJZyuV1dci/fhXnyuScbLsVSiX+2peP73dsRcbxY5bFskSEOQV78OmGNS6PlvdIFNuUhd6R9uvune5aFgbDKk51gubMQuA8kVe1rnPsc4Jyc3N5zwW+9957APTlPocOHcq55qeffkKfPn3QsWNHPPLII0hKSjIbd8WKFQgPD0eHDh1c6rgwgc6FUjWoTgZK+W0T1V4CVe0F1ZVyPifqcyBV00CqpoNUzeaJnps0aX99nfXSbh6IoDuvsXJrDG+C2SYujtimvLw89O3b1yO2aePGjWbzaa34vUD3N3zJCRJCo9Ph5907OBHol5dl4XpVJRIOH3RI4L63ZoXbIujObqFxMahVqXCrphrFFeXQEfPtlAyGO2FOUOuCCXTboLpSEMVb3Ih05XcgpB5EMd4BgRuuP4vuUhHtwhcAZS+DUh2otthYS57B8CTMNvk2Fy9exJ133unpabgFJtD9jNbgBM0t2GMWiQ6RiDAoNclhkfvo/AT0SBC7TEQPzUxt0fUhEhEGpiby/uzvffl4zaQ83GMLkrD2fJGnl4nhxzAnqHXBBLp1KKWGsmQ8Z8rlL1kQspbOeUeAlL/vWoFe/kHLx5AObPa9w/TCvzYFRDbYRLC/Dqo55+mlYvgxzDb5BqYJ7qqrq1FVVYVz587hrbfeQu/evT09PbfABLqf4etOkEqrRTcXCemT0lL0TOSvwd7S1j0hFuF2lnALNek/MDUJM/NzEb1vLx5PS0aQOBpRWRlYfLIQfVPiEcJznj336hVPLxfDT3GqEzR7FgJjRF7Vus5uHU6QrTz//PPGGreuwtdtE1UfclDgRlr+uWIMSN0yK0Le0RYOIn+9BddHgMhHgNSmglT+CCLtbXip8AFIXRbPnMNBpP1AdQpPLxfDT2G2yTfgSxIXEBCAhx9+GPv37/f09NwCE+h+hiecIJVWizXnzuK/27dgWu5OHL190+GxblZXOyySX122WPBnA1ITkXf1issi6IHiaATb2X/23jzOdcESEXolSVBkcuY+5ehhBInNxXmwRITROcuctYQMH4AQArVK4+lpAGBOkK9w7NgxnDp1yvj3tWvX4tVXX8WPP/4ItUDuD1fhCdtESTlo7Xz9NvSaWFCd47aJ1mc7LnJlzwgI8AiQyh9Aqme7SKA7Ei1/0iTqHtY0r7LXQEmt0TaR8nHgTzYXDlrLkpr6E1qNFjqtztPTAMBsk6+Ql5fHafn5+Th37hy0Wq31i1sJTKD7Ge52gqpVKry0dJFxm3aIRB8V/rMg36HxGrQaRCbEOl08zz92GNP37HZZEjdLLUhsntF92KJ03rmESER4Y/lS4/OYvHUTb/Q8UKxPSsdo/dRW1mHeZyl44c7/YFjAm/is739xcNMxj86JOUG+waOPPmrMvltcXIzOnTvj7bffRkhICCZNmuTWubjbNlHNGRBpP4OIjDC0SFBVrmPjqQ64JMJNNafNa6U7tQkJ/0f5Pxc8Sx8OWhtvfB5EKnB9aThI5UQLT5LRWig+eQ1TR8xAVNs3MbzdaPz22p8ouejanTjWYLaJ4Sswge5nuNsJmr03T7Cc2LHbjiWNmZWfy3sG/bEFSXYL7BCJCLPyc0EoNUas3d2m5e60+5rGknNzC/bwCvQgcTSeXZjmzKVkeCE6rQ6f9/sOw9uPwbCANzEs4E1EtRuNYW3fxKHNxwEAp/cWYd6nyZg5NgbrErZCWat0+byc6QQ9MmsWgkQir2qPzGodTtA999yDy5cvAwDmzp2L4cOHAwAKCgrw4IMPunUu7rRNlFIQ+Qs8Ed4w/RZsqnJgTAIifx68Z9DLRguIVUuR6v6gDZsBAET2nGcEuuJd+8aSjzQ+D31yO4FdASZ13hmtk1uXS/HyP97l2Kbh7cfg9fs/gOJ2BbQaLXYtycfsd2Lx5/tx2LfuMIgbEtwy2+Q7XL58GRMmTMBzzz2HYcOG4euvvzbaK3+ACXQ/w90CfcB8/sRmIZIY/J63y6Ex1Todvtu+hSPGh2dl4EplBXZfKUZ3G8+oB4mj8cXGdcZxT5Tedrs4D4+fJxgtt9Qaa78XV5QLRtAXFh53yhoyvJe9qw8anR/TFtVuNL7o/x0yf8vGsIA3MaLDGKNwHx/yFSqklS6dF3OCfIN//OMfuHjxIgBg2LBhiI2NBQBcv34dnTt3dutc3CrQtZcsCk3a4JhtorpbIGWjuOK34mtQqgSp/pPnhYCFVr/COC6p+smF4pxPRDe+VLCzHrr82aZnUb9MoF84qPZSi9eQ4d2Iv5iPER3GmNmm4e3HIHVqFqY89avx78MN/f4YI4JO59qt8Mw2+QZbt25Fx44dMXDgQEyZMgWTJ0/GwIED0alTJ2zfvt3T03MLTKD7Ge4W6D0S+cVyiESE73ZsadHYt2qqsbP4Mk5KSzl10CmlOHLrJpaeKrQqdActSOaM6aokceFx88yEdJA4Gr/ttj96/lTGfOP3VWm1SD9+1CwB3S+7d4CYPBNG6yT524UY0fEtXpEu1Ia3H4Poj1x7BpQ5Qb7BM888g/Hjx2PRokXo0KEDLl3SC6e8vDx07drVrXNxq0DXnLQs0JUbHB+bUlDNWdCGXaDaG81+1gDSsAukepYVsRsBUvWL8TqiveUigd64tZ9HiNfE2D+eSWSc6CpAKr5r1qcHqHIdGK2fDyInCtqgd4O+RFTb0bw/y1u+z6XzYrbJN+jTpw9++OEHs89/+OEH9O3b1wMzcj9MoPsZ7hbon21YKxjhXXPO+aXASmtrcLDkBorkMlQqlXhsgeXSayMXZ3KuX3PurEsEepA4Gh+uW2WMlIdIRPhg7UpcqShHmJ3Z3RccPwodIYg5UICI+Hmce4xdmY1zZXLj96GUsrrorZgls1ZxthCathEd38Lw9vxO0At3/ofzUsvZONUJmjkLQdEir2qPzGwdTtDJkyfRo0cP3HPPPfj999+Nn0+YMAFvv/22W+fi3i3uKhBpf+EIr07q5PtRUM0FENVBEO01EM1Z68K55i/OGEThhHJofK3sTX0mduNnvUGqZ+hfJNg5FtVJQUk5SMVX4Ebme4JU/ACiqzJ5JjpQymxTa2XykF/0u7Z4XhC/8s9x/C+P243BtFF/unRezDb5Bp06dTLu7jLlwoUL6NSpkwdm5H6YQPcz3C3Qi8rkiEyI5Yj0YIkILy1dBFULszE2aDXIPnMK327bjJ92bcO41SvMtoo/Y6X+eNrxo2bj/rx7h9PF+dOZCwAAGy+cR+/kOO5uAp4s7EItNC4G9RoN/izIF+zzzuocKOrr8MOOrYiI1yfUe2VZFvJY2bVWR+lVGYYLOEGf9v4WIzrwR9eHtxttPO+nUqqwJW0X5o6XQPxlKs7sO9/ieTEnyLdpaGiARuPeigBuTxJn3ILdGD02CMqalgsEqpOC1saDVH4LUjXNcDa92RZy6dOWxa6G65wSouYZxwkR9OoZ+jP51XNgXvLNjszxZaP15/DLXhG8jtYt0Ce9K3/P0CcSpOJzkGY7DRi+z5b03YIR9DH/72PBn00dMcM4huJ2BbL+WIE574qR8csylF6VtXhezDb5Bg8++CBycnLMPl++fDkeeughD8zI/TCB7md4opRNUZkcn29cix6JYgxITcScvXmoUdmfhMeUcmU9hi1KN0ajLYnaMEkMQgX6fLN1M15fvgTBEhH6psRjbsEeKDUaFMlleGvFMsEt+va2padPQl5fh8iE2BZlih+VvRiFpbcRbhI552uD01N4n8uo7MXILDyOo7dvujSCynAfW9J3Y3i70Rjefoxxu/tXA39AXs4+wS3u30dNBwBUK2rwUffJxs8bzwxm/NKyEn3MCfINbty4gZKSEuPfDx06hEmTJiElJcXtc/FImbWGrSBlr+sjvPKRoPXLWvx7kaqPgpT2Mgh/a2e4hTKdh4FU/wEie1r/Z/lw0PqVIEQHUr/ekOCuWwvFuV4gU+1l0IbtLRf71X+BKDda6dcTpLQ7/3OpmARSnwOqve6k1WV4EkII5o6XGHKgvGU8Z54wOR3xE9N4d35FtR2NFaL1AICz+8/jpbvf0Z9RN7SRncbi8NYTLZoXs02+wfTp09GlSxfMnTsX+fn52Lt3L+bMmYMuXbpgxowZ1gdoBTCB7md4wglyBI1OhyK5DMUV5bwO00+7tlsV5rY20/rkwRIR3l61HD/v2u60CHq/lHisKTqLpCOHBDPae6K9mr0Yivp6D6wuw9lIr8mxbM5qzP8+C/vXH4FOpwMhBN8Nm87ZZji8/Rg8f8fbOH9EnwlV8lWq4Bb5xj6O4FQnaMYsBP0t8qr2yIzW4QQNHjwYixYtAgCUlpbinnvuweOPP4777rsP06dPd+tcfMU2UVIDqjkNqjOP5lFKQGRDbRDmjojpUJCaeJCyF+yLbFsaU/48iPo0iOIdJ83ZljGs9QkDqZrGtr+3AiilKDp4EWk/LUHGr8tw6YR+F1/ZTQXe+N8PzTK8vxf2Neqq60EIwbjgr8x2h0W1HY3X7/8AGrXju3uYbfINKKWIiYnBv//9bwQEBCAgIAAPPvggYmNj/Sa4xAS6n+ELTtCac0V41CT7+/CsDBRKSzl9ujspsu3O1jNRIhjJ90QLkYjw/tqVHlplhjtQN6ixeOZKjAv+CqPuex8Tn/gJ0R8lIOfvdZCXKPBql/H859c7jEHytwsdvi9zgnyDLl264Px5/ZEGsViMJ554AgCwbds2BAYGunUu3m6bKNUatoF3bxKSFZ+DkoqmPupCJwvz5q2lUXOh1svF87a/0TrHf/8wvB/ZdTnmfZqMNx/4CKP/72N8N2w6EienY0v6bpwuOGcx0emRbYUO35fZJt9AqVSi3hBAqqmpwcmTJxETE4OtW7d6eGbugwl0P8PbnaD8a1fNhGSwRIQeiRJIa2uN/ZwVPedr3hTldqTZu4X+Zo13/ltgOAdCCLL+yOFme2+rL8UmdEZ9RIe3IP5ivsP3ZE6Qb3DXXXfh6tWrAICXX34Zc+fOBdD6y6w5Aqn5E+aR6wgQxWhjRIeqDnpc2Hp3a14j3kKTP+fhFWe4mmpFDaa9/peZ/RF6cdzY9q4+6Pg9mW3yCaKiopCUlAQAqKysxAMPPIAHH3wQnTt3RmKia6vQeAtMoPsZ3u4Evb1qOa9ADpaIEHuwqfzGuDUrXCbSW3JG3BtakB1J5wLF0Th2+5YHV5zhDDRqDTambMd3w37HlKd+Rfafa1FXrX/7nPRNptWya3yf56884PB8nOkEBf4xC8F/ibyqBf7ROpyggQMH4ocffkB+fj46d+6MwkJ9ZOrAgQP497//7da5eLNtoqQWTZFznmiv+rihXx28MRrtHc3ebfk9PbzqDGdQIa1Exi/LMPGJn/DjC7OQm10AQgi0Gi0+6fUNv11q+6ZgGbYRHd5CpbzK+o0FYLbJN7jvvvtw5swZAEBqaip69eoFQghycnIQERHh4dm5BybQ/QxvdoIAoF9KvKBo/mJjU/3UQmkpwuPNa4vbI2JDJCLBlwGeFtnuepEQGheDCqXSgyvOaClajRb/fe53Mwfng8hJuHHhljE5j5AjNKLDGO5ZwHajMfHJn6HT6hyeE3OCfIPc3Fx06dIFbdu2xQcffGD8/Mcff8SoUaPcOhdvtk1Uc96imKT1TUkVaV26g4I0FE3nsyN4ro8AkT3pBULbBiEufbyFY4SDlL3hwRVnOIPSqzK8+cBHxjwoUW31NuavD+KRm11g8cWx8dy58Vr9fxdOW96iOTHb5BvccccduH5dnzBy9OjRxjKgN27cwB133OHJqbkNJtD9DG92ggDgpaWLeIVniESEGXtyOX1Py6R4dVmWUVB3S4jF99u34LFUy7XPX1++BClHD+OiogzPLUozCtUQiQhB4mhknzmFlKOHvV6sh8fP4yS4c0Tg/7p7h2cWmuE0tmXm8js2bUdj5th5VqPnM9+eh2mv/4VXu4zH2Ac/RfrPS6Gsa4Dsuhx/vR+PV+4Zh5fveRd/vhcH6TW5TXNiTpDvoNPpUFFRwfns6tWrkMlaXtLIHrzZNlFSDkvJzahqD6c/Ua7jimnpYJDKX2F1i3fFRFDlOhDVPjRlgo80iN5HQdQnQco/FLi+hxeI88bWvFyb/Y02MNvk68x+J5a3FvqwgDfxxxiR4O6txrbgx8X4auAPeOWecfik9zfYmrEblFKc3HMW/332d7xwx9sY8/8+RuZv2VA3qG2aE7NNvkHPnj0hFotx48YN3HPPPdi/fz8A4OjRo3jggQc8PDv3wAS6n+HNThAArDh7mldIBktEuFSu4PRdXXTWLJIcJI7Gp+tXC0biH52fgFp10y9ylVaLBceO4OWlizA8KwMvLlmIHoliRMTH4q0Vy/DphjV4d3UOvti4DgsLj+OiQuFy4W36UiA0LgavLsty+j2CxNGYnrcLap3jUVKG5zl/5DLeDfpS0MF5/X8+sBqhyM0uMBu3QlqJMf/3MSf6Prz9GLz5wEdQ3K7gmQkXpzpB02cj+M8Yr2qB02d79e9Re9BqtdixYweSk5NRU1MDALh16xZqTXJ+uANvt02kcjKPwI4AkT0NSnXN+n4LbgTc8OfqORCMrJd/zh1DWwZS9RuI/EVDayyt1l8v0ss/BVGMB6maCqLcDFK/ys0ivL8TIuV8rRdo/Sp3Li3Dyei0OuxdfVBQnA8LeBNfPPq9RYEe1X40KqSVZmMf23ESUYayoqZR9h+G/2FTdm9mm3yDFStWoEOHDmjbti2ioqKMn8+ePRsjR4704MzcBxPofoa3O0GUUvxZkM8Rqd0SYrHxwnlOPx0heGyB5Ug5X+udJOGI0m2XLxqj5837hkhE6J4oRnFFOefeQ9JTXCrQg8TRCJWIMGHzBhSW3saj8xOcPv6s/Fx3LCfDRVBKkfyt5bPlwwLexMhOYzH2oU+FBfz97/OWrEn/eSmv8zS8/RgsmLrY6vyYE+QbXLt2DREREbjzzjvRrl07FBcXAwAmTZqEzz77zK1z8XrbRGpAFOO4YlL+LKiWW46Qai9ZEJ89wR+JDwMp/6ppDEpBqmc2vQQw6x8OUvYqKG162Ux05cLi32ktDEQ64P+z997hURzZ+r+JvrvetdfX17v3d/d+9y7KgA0GbIJzQAJHbCyBjcEEYzDGBGMw2NgEB+GgEWgkIYEQAgSIKJERUeQcBAIRDIg8M8rSaPJUvb8/JkgjdU/smZ7R1Od5zuNdqbu6qlv2OW+dqlMgNT+DaL1UsV57xGfflCE8qlo1vugxzaFvGv3UZPRuyf/72XEJnO1/1nUKr/A/u7fIYf+YbwocZDIZzpw5A0Lqj1w8fvw4Ll26JGKvfAcT6EGGvwdBFmTKWuQWX8TWq1dQp2u6dOlWdZXbAvXI7ZtIP3UCM/fuRkRyosNsds+MNLRPnYcn5ychKmWuw/bDpBKM3JjrVRHvroVJJeiRkYZSVZ0IX5UhFCfyzzq1f693i1i89dfBvL/74H9HcbZvL8D6rOsUh/1jQVBg0K9fPwwePBg6nVRkpqwAACAASURBVA5/+ctfrAJ93759CAsL82lfAsU3Uf0FUNV6UO2hJplzAKCqHPeEqeIlEN1JkFoJSNUEJ+95AdasujMV0uVdQSqGe1nEeyD+Kz4NmjOOmytpk5Y4XLreu4Wp2Ft0a54Me8tYzB2d3qRtdZ3GTnsDkPVdDkePbGG+iREoMIEeZARKEOSIcpVKdLHLl51eV1yE0ro6RCY7FvO+tKiUuZi6Kx/32LFqAc+cwUlOBUGOLKZVHBJHpeHKKdss4NfRszmzFNEt4zDp5RkO+ydoEDQrHqG/JPqVtZvVPIKgxx57zHoOekOBXlJS4vNCPM3FN1H1ZvfEqQD7tu2L8y4ghmsg6h1+IMYb960nqDLFZkUAIzB59z+HeuyXLKu7lsxchbK79Vsb9Tq97XGhjVZ35fyS57B/zDcxAgUm0IOM5hIEAd49as0T65GRhh/27/WogJurFiqV4Mv8rbxF7UKSErC08IzYn4whENPfihckCGpoecnbrO3zFZ7r3SIW2zP3OOwfC4ICg0cffRQXL14EYCvQDx48iL///e8+7Utz8U2UKEHkncUXvU0sCqTya5DSPr5/dk283d9TQ4nYn40hEHwC2i1rGYu3/zoYl45ftbb/84dzOSeno1vFQVbiuLAl802MQIEJ9CCjuQRBAHCnphrPLJwvuiDnsl6Z6T5/Zv/VKzB22ybOSYuI5ESUqVRifzKGQKz+bYPd/XvuZtMVt8sAmCp7/zBAYl2K2KeNKeia9f7vTh2/xoKgwGDAgAH49NNPAZgE+o0bN6BUKvHqq69i2LBhPu1Lc/JNVLMH9qq+i2ddxJkYqE0CkXfneCdRIGX9xf5cDAGZ/OosQf1SdKs4jOgwwbr1ofx+JT4OG2v2TQPQx1zIdEPKdqf6x3wTI1BgAj3IaE5BEACknzwuyHngQtsLWQt9+rxQqQTDNqxHaV0dXl1af3RcqNR03vumK8FRVKM5Una3HGmTlmBEhwn4/JmpWD9vCypklXjzoY8ED4TWz9tifS6lFCfyzyJpzELM+2wBTuSftSnWYg8hg6CQmfEIm5PoVxYys3kEQffu3UNERATat2+P1q1bo2fPnnjssccQGRnJjlnzEFL+kR8I8sb2lAjPjACtWwqqPQZTkbwGy/kVPZsU2WMEDsXHruLHARIMjRiHqX1+xNHNp1B0sFjw1V29W8TiZvEd63M1Ki22LdqNhBGpWPh1Nkou3Ha6z8w3MQIFJtCDjOYWBK0sOuc10euJ8P/l4H6fTxxYRLjWYMCGy8WYvX8vUk4cw1225zxgkd8sxft/H1G/pK9lLKJbxuLr6NmYOypd2Ax66wHImZMrSL9ZEBQ4qNVqZGZmYuzYsRgzZgwyMjKgVqt93o/m5ptI5Vh4p6p6BJwqCMdliudAyt73Ur/4M+jUaJrsoaQCtC4TpOZHUFUOKPHtUX4M4Ti84QSiW8VZM9gWH7X6tw2I/ccIwQX61dPXBek3802MQIEJ9CCjuQVBpXV1omfLuWzNxfPWTLY3s+bh5ir0X+3YBmJeAqYx6HHm/j1cLi9jFXEDmJvFd/DVqzN5i8G9/bCwGXQWBLEgSEyam28iqhUiZsrtmPYITJXfvSvKTRYJqq4/05way0F1p0CN90X8MgxPIITg7N4ivPefQzm3WQlRvLSxvf/4cM7jQN2B+SZGoMAEepDR3IKg+7W1ootxLltXfAF1Oh16LnJ9L/qcA/twXi7HlJ3b0T2De499RHIiJu/cjh/278WxO7dBKYWBEEzfs9PmKLjo7CwUKeRifyaGC9RV12Ha6z/ZX44u8P7z3i1jMWdwkmBjEDQImhGPsPhEv7KQGc0jCFq6dKld8yXNzTeRutVeFsHu7XGnRgWI7hzcyqJrT4Co80EqPjFVhee6Rv4sSNX3ILXzQA03Te/CqAAp/7DBMyNAKkeDkmqRvxLDFa6fu4nBIZ8LLsAd2c6l+wQbA/NNjECBCfQgo7kFQaUq72XQQ5IS3K7ELlPWAgCuV1ZYC8aFOzhzvV1SAp5ekNpkjCvOF3Iul49KmYuei9IwdVc+9pXcQJf0FM4se6c0KSrUrECcP6KqVWNlfC4+6zoFozp/haUzV+P7fr94JQvBK/ZbxeGzblPw04dzkTE1GzuX7kNddZ1H42JBUGDwt7/9zcYeeughtGjRAg8++CAeffRRn/alufkmqt7gRXH+vHv3KXpaV1VRzXZzJt3JJfOVX9qOj1KQyi94RHoXkNJoUGUyiGodz2RCFEj5EDE+DcMJ7l2TIWnMQozoMAETX/gOm+bn22638oG99ZeP8OVL3+OXj5Ox/Me1OLbllFNFSu3BfBMjUGACPchobkEQAPRetlj0jHlD675wvk3/tAYDNl+5hKRjR/DzgQK79z6XuaDJ+EZuyrV7nFxokv398iFJEiw8fcJXn4PhJOo6DUZ3mWxz3rjgmXE37c2HBuHwRvf/ZlgQFLhcvXoVr732GvLz83363ObmmyipcjvL7TWr+rpRHytA67JBlakglZ/bv7fmJ9t7qYY/i241x1l6qi/25WdhOMGN8zfx9sODrfvLo1vGieOLOPzhkNCxuH/d/VWBzDcxAgUm0IOM5hYEAUDG6ZOii/KGNnUn/3Efay4WOby/uNS2enJUyjyP+hMmlWDKLueOIGH4jtykreIFPk4ERn3bDkTZvQq3xiZoEPR9PMJ/TvQrC/m+eQdBJ0+eRGRkpE+f2Rx9Eyl7T3xRbiOGL/L3tWqig+x7D1Ban72kutPC9Em92RefguEC37zxs08z5a5YTJsBGP3UV27X12G+iREoMIEeZDTHIGj89i2ii/KGlnLiKG9fL5eXObw/75JtRqFzerJH/QmVSpB07Ii3PwPDRSa/Jux5sYIHQq3ikPNLnltjY0FQYHPmzBn89a9/9ekzm5tvolQPIn9GdFFuI4aNMv7+1i12fD+pn7Cj+ovC9El31hefg+EkRoPRZlWXv5q7BU2Zb2IECkygBxnNLQgCgG4LU0UX5RYLSUrA7H17rH0rravD/JPH8O2encg8cwpVGjWG5q2z28aJe3dsxvf93l0ItbPE3ZFFJs/F/dpaX38WhgO+jvnBfzPoLWLRp+1ApIzPdGtsLAgKDDZu3GhjGzZsQFpaGjp27Ii+ffv6tC/NzTdR/VXRBXkTMazZ26B/F0FqfwWpngmq2QZirACRd+W/X94JlOrq76cEpPRVeLSMv+wddtKIn2E0Gv02e97Qjm055db4mG9iBApMoAcZvgyCLpWVYmL+VryYlYH3Vq/AmotF1qPAhOSlrAzRhXnDbHXKiWMAgCO3byEqZZ71OLSQpAR0Tk/GGdk9vJC1kFPcv7Y0s0nAknn2lNv9iUqZiwM3SwR/5wzP2Zy+k3OPXe+WsXjrr8IfoeaO5WftdTwQDgQNgr6LR/hPiX5lId81jyCoRYsWNtayZUv84x//wIcffoj79317FJYvfRPV7AKpGAJS+oqpmrhO+Bod1HhPdEHeRKDrz5v6ppxv/lkUiKy9WSz3B9Gerf//NhYBUhNvOz5qMFVzd+rZHHvRS19lx635KTPf+82vRXp0yzgobpe5NTbmmxiBAhPoQYavgqBT9+8iMmWutbiZpYjZN7t3CP4s6fEjCE1yP8PcIdW9Pd5chdnCpBL8fvgA3lixlLOwW5hUgujsLNyqqkR7jr3lzy1egGqNxjq2i6UKBwXgTPbK0kX4fOsma6Y9IjkRY7dugkqvs/PmGGKi0+rx5Yvfo3dLcxEe8z9Hd5mMPSsOiBoAxbQegI/+PQZatdatsbEgiOEqvvJNVLnQLBIjG4jUCFD1VsGfRcrj4FSFdD5T9HbjvkiOZ0aBlEaDVM8GUbzCf1/NLyDqXO7fV06wmTymdYu4hXfDZ8rCQSo+AymLrf+5/GmQ2hSWOfdj7v5xH/3/a7hVpFv+mTI+E/M+WyDqEvjoVnH4dWiy22NjvokRKDCBHmT4Kgjqt2o577Ls4rJSwZ5TqqrD2K2bOJ/zVJpze7e/2rHNZXEenZ2FERvWW7PmIUkJiEyZi1eWLkKIE5MFP+7fyym8Q5ISMHVXPvIuFeOCQo6ZBbsRJuU+nq1zWjJGb96ApYVnUKczCfEqjRp/VJRDpdfDQAjyr13FzwcKkHLiGO6y/2D7HTqtHpvTd+LrmB8w+bVZyJNug7rONEGz4uf16NNmoChB0LQ+P0Jxy/1/T1kQFBh8+eWXnDZp0iR8++23WLx4MSoq3CsU6Cq+8E2UVPBkiMPNR5DphXuW7ixI2ds8z3rRObFdMcp1gV71PYjiZVuRrHgWRPaU48kCeQ+QisH8wluZAareDGqUmZe382TLS6NBqiaBavaAUmJ6H8b7oIbroNQISmpAVctBauJBVTmgRCnYe2cIQ/n9SmR9l4MvX/weM979FYc3nAClFBqVFt+/84sofqlv2w+QOmExdFr3/z1lvokRKDCBHmT4Igiq0Wp4hWmYVIJU8xJwT9EaDHh1aSZnpvq3wwcwbMM6h0K516J0rLt4wWWBHiqVoP+q5Vhw6jgWnDqBlUXnXFqK/vryJU5d13VBKm8GvRvHmekWqjUavLlyKdolmc5fD5VKECqVYF3xBUHePcM3VCqq8UnHiT4NgiY8/53H/RY0CJoej/AfE/3KQqY3jyDo5ZdfxsMPP4yHHnoIXbt2RZcuXfCXv/wFjzzyCHr06IG//e1vePTRR3HxIn/1b6HwiUBXb7UrUKm+SJjn6K+AyDrCdn92BIjsSZC6lSAKPnHb4Nqqr0GqpjgW1U3sCZCKL0CUS0CVC0A1+SAVY51s5wknnxHJP9Ehi2pynJvtuzln3useYW4jAkTeHVR/WZB3z/ANF45cRt8HP/Cpb9qY6vlpNMw3MQIFJtCDDF8EQUqdzq6wFepM7rxLF3mXfTf8J38WfDFuVFWiRqt16ygzS/sri84BAD5av9ppcR+7ZqXD/jkaQ7+cbACmVQTxB/fh1aWZ6JOdheTjRzFl53beJfZ3a9l/uAMFxe0yn2cp3C0M1xAWBAUGc+fORf/+/W3GUVNTg9jYWMybNw8qlQr9+vVDTEyM1/viE4Gu2eFAoAtzJjepmuyGsG6YBZ8IStWg2v1uthEFIutkFb38YrqRKV6Da0XfeDLttaYlyFR/wXR8W+krIOUfgKjyzKsHGj8jEqS0L1v2HkBsz9zjc990YvsZj/vNfBMjUGACPcjw1RL3wblrOAViu6QE3KyqEuQZMwt2IzyZe/m3fdErwevLl9gEA1uuXEaYeam6q+11Tk+GRq9HRxf2sk/e6fqy+sYWmTIXx+/expNp0iainm8coVIJ0k8dt467Uq1GmUolyPdgCM+1whLfBkEtY1Fy4bbH/WZBUGDwP//zP5zZ8QsXLuB//ud/AACnT5/GY4895vW++GaJuxJE1olbaJa+Yl2O7SmklG+ftxOCt2ZOfX8pBame4b5IrxwDarzr2vPLB7k/sWCxsjgQ1SqzgI+ob9vBfZZz2ikloEY5W/rux6z+bYNPfVPc/zcSRoPR434z38QIFJhADzJ8JdD/qChH5/Rk6z50i1hPPs5/RrirzD16mHcSwF72+sk0KS6WKpq0d04uQ6ibYnnC9s0uXe9qv/my664evxaenIhfDu1HcakCcWtyrD9/c8VSHL97h+MtM8Tk3nWZTwvyTH5tFgjxXKQIGQSFfhuPiB8S/cpCv20eQdBDDz2EgoKCJj8vKCjAX/7yFwDA9evXfXImus+KxKk3mMWiJcMdBSLrCKoVzjeR8vedEqRNhe07TUQppRSkdr7rbcnCYVruPsTFezp4LtDdNKo9AqreDKJ4yfyzSPMkg1ywb8MQhvXztvhUoOfMyRWk38w3MQIFJtCDDF8eZaOoUyLx6CEMzl2DL/O34sjtW4K2f7OqymWB+uuhA7xngh+6fdNj0RwItu7iBTyZJrV5d6FSCSKSEwUt4MfwDEIIBod87tsMeotYrJ+7xeO+syAoMBg0aBDatWuH3Nxc3LlzB3fv3kVubi5CQkIwePBgAEBOTg66devm9b749Jg1/QWQ6ukgFR+D1PwMaigRtn3VatfEqfwZUNUKUKrmbI/U/ganl6n7zNyYgLBrHU1L4Jv8PAqk9DVQ6t6JEgzhuVl8x+cFTKNbxuH6uZse9535JkagwAR6kOHLIMgXrCu+gDBzATR7WemQpAT0X72Csw1CKS4o5JAeOyK6eOYyd4+BM427/p2ESSV4d9VyzDm4n3d/+sR84Y8aYrgOIQRfR//gc3Heu0Us3n98OE7vOgej0f3lhCwICgyUSiVGjhyJtm3bomXLlmjZsiXatm2LTz/9FHV1dQCAs2fP4uzZs17vS3PyTZQSkKpp9QLTuueaS9RGgCq5C34SogXRHASpGA/X9oYHoNXOAyl7i1f4U3Wej78ig4uq0mq899gwn/ulmFZxmPLaLI9FOvNNjECBCfQgozkFQRbkSiUyz5zCvGOHcfBWCd5YsYQzs95zURqulpdb76OUYvGZU5znkfuTDc9b1+RnzqwcGLA2B2+tXGYV+TMLdqNWq8UgO8XsXlqSIeKXZFjYv/aIKOK8oX3Ubozb+9FZEBRYKJVKnDt3DoWFhVAqxdn32xx9E9VfAFWmgioXgGgPgcg7cwvtiuGgpK7+PlJnruAudJZaYCsf6t7EQdW3IIpepv+teAG0bikIMdq5pz1IzY8ifkmGBcmnaaL7pm9e/wlqJfdqE0cw38QIFJhADzLEDoLqdDrkFJ3DjILdSDt5HIo64YPBGq0GfTmOMQuTStBrUTp05sxgxumTdgWuOwXovGEhSQl4fvECm6y3PZFtsTFbNgIA9EajTUG8iflbODPooVIJ4tbkWK8rV6lw5v49yJTcWwIAwEAIlhaewds52XhpSQa+3bMTJVWVgn/TYGNm/9/Qu6W4QVBM6wH44P+NhkFvcLn/LAhiuIrYvoka74Mq54PUzAZVreNdbu4JRFcM7iJ1kdajySilpqX3dkWuBxXihTR5F9PZ6Q2FdLnjPe9UtQqUUlCqs/omSimI/GmeeyJBlfPrv5XhFqiu0G4ROWosN20NKI0BKXsDVJnCis55CKUUb/zpQ9EFekzrAfh9BP8xs/ZgvokRKDCBHmSIGQSVVFWiR0aaVfyGSiWITJmLgpIbgj5HrdcjKmUur3Dd/sdVaA0GdEpLtitwP1ybgwg3RXq4AEXguMW6BL0y01GqqsOrSzN5rwuVSjCjYDfn+zly+xbvfXmXLkJrMGDarnyriA9JSsCozXmo1mhs2qGUYvSWDTZV48OkEnScn4TL5WWCftNgQ4y953x2ZNNJl/vPgiCGq4jpm6gm3yQuG57vrXgZ1Hhf2OdoD9kV3ZRUgerOOBbGFZ96IKy7eEGsmzP9FaNBjJWOBbqG2zeR2t/RNCNvKuhHjfdBDXdAygc0+N0TILXzmhzPRo3l5kJzDScyIk1F+Lww8RIsqJRq0f2Rxfq0GYi66jrHnW4E802MQIEJ9CBDzCBowNqcJpnbkKQEPDFfCpVeL9hz7tRU2xWuGadP4mp5uUMx/O6q5W4L6fSTxzGMY2m6UNZ1QSq+37vL7jVFCv7Kt/NPHrMKa8ty+dn79oBSiqm78pssoQ+TSjBo/WqbNviK6oVJJRi5SZiKq8HI+QPFogc/FotuGYu85G0uj0HQIOibeETMTvQrC/2GBUFCI5ZvoqTaJPSaLCePAqkYKeyzVDn2hav+Mogy07EgLh8M97LokSCaQyDybl4Q6WYrfQukYhy/kFf0BKU67vdDtSAVI+v7KosAkXUE1WwHpTqQ0pc5x03rFtm0Yyqqx7X0PgK0LlvQbxpMZH2XI7pPamh3rtxzeQzMNzECBSbQgwyxgqB7tTV2xeTWq5cFe5bWYLCbQd94uRjvrV7hUAT3zebey24V+zwTAOknj1tn9Cfmb/GaSA9JSsDbOdnokp7cpA/Lzjku6nS3pgZZZ08j4/RJXKsw7c0vV6nsjrm4wfF0Px0o4N0GECaVNMlqMJwj8dM09GkzQPTgx2KFBRdcHgMLghiuIppAV621mxmmpEq4Z+lO2HlWexDtYefEc9nbdvvM+XN5NxDtcQAAIToQ+YveE+mycJCKT5qKafnToLpC+++IUlDdWdC6DFBVDigxbZmimm38z5J3B6X1RS1JaQz/u6kYIdj3DDY++N9Rovsji731l4+gUble2Z/5JkagwAR6kCFWEHSlvMyu2FxVdE6wZ2kNBrv7xweuXeXUOeSfbdngsmhee7HIpi+UUmSeOYWei9LRLikBndKS8WzmAnRZkCKYUN9z4zrOy2VIP3UcSwvP2N0z7ohT9+/afdbGy8XWa+cc2o8wKfd7jkieywS6m/z0QaJPzz7ns+iWsRjTbYpb35EFQQxXEU2g1y3mF7WycFCj61k6Poj2rB2R2cu0p9uZwnDlH7komDuAGGzHQUkNSM1MENmTpmsUz4EonoVwS+A7ghgqQDS7QJTpoOoNHi0vp0op7B01R0lF/Xsue5NfoFeOdrsPwc47Dw8R3S9ZbPH0lW6NgfkmRqDABHqQIVYQpDMa0dWOKL1eWeG4ESfJOnvaY9HrToG4UKkEA9bmcPaJUgqtwWAjdp7LXOB5P6WJ+G7vLsHe3f3aWut+ci47df+u9dpC2X3e7PmEfM/P0g5WNqbmi14grneLWIzr9S0qFdVujUHIIChsWjwiZyX6lYVNY0GQ0Igm0PVF/CJT8SIoJYI9i5THeS58eQup2bNIUGUa9/gpsVlyTg03BRLo4aCanYK9O6pab+eddAal9dvkqDIVfNXlqXq9YH0KNr7v94tfTB6nTVri9jGgzDcxAgUm0IMMMfegryw6h3ZJCTYCMCQpAZN2uLbHlVKKAzdLMKNgN2YW7Mah2zdthO/AtTmCZaddtW4Lna8smnz8qMP2GhZg4xPos/ftsWlXazDgbk0N1G7u6x+5Ka/JCoMwqQR9ly9pkk2dtW+P9feWSYoeGWm4W8ucgztQSiErkSP27yNEDYC+e+cXj8bBgiCGq4jpm0jl540y1xFmMbfRpXYoVYOq1oBUTweplYAarjf4HTVlsu2KWm9VZ48CqZ7q/Pso6+dEmx14RXC9QN9r+35ILajxHih1/WQISurMkxMcReRqf2t0rdI8hogGFg5SMcJGyDOcx6A34OSOQtEnj49uPe3ROJhvYgQKTKAHGWIfZbPxcjFisrMQkpSA7hnzkXLiGAzE+QyFgRCM2bLRKk7DzUusJ+RvAaEUxaUKu4LWGUHs7r2hUgneX+38sqvVF8471e6SwjN4emEq7++P370DADASAsmRQ+g4PwntkhIQlTIXMwt2Q2NwLSCp0qjxwbpVNs/os3wJ7nL8zVBKsfvGNYzduglD8tYi5cRRVKhVLj2PYeJg7jEMjRgnenYiulUc1HUaxx22AwuCGK4iahV3qgOpnQei6GESc2Vvg2p2uNaGUQ5S+opZNLY3i+0IUNVa0+9Vy50QvN4Q55YMuvOTx6TyM8dtyl8EqfkV3MvOI0DkXaxL2qmxHKTyi3pxregFquJebWb3HeuLQBTP2z6rahJn0TnTZMly0174ytGg6lwmzt3AaDRi2ew16Pe3j0X3TZ88MdHj8TDfxAgUmEAPMsQW6Bbc3Z+8yo6ozbtUjHHbNtstctYnOwujNuc1ucYTYd7Qtl694vRYEo8ecmop/cFbN6GoU+K5xQus/bT0f/qendZ3+dP+gibjCJVKMHbbJrfe9cVSBTZcLsap+3fZfnIvQinFmt83iB78WGze5ws9HpPgQdDMRL8yFgQJT6D7JlI5jicDHgliuAMi725f8NbMMU8QcLXhxL50O+KcyJ4ANfKf6tFkLGXvOdFuBCipMx8d16FBv6NMEwLqreb3aTDvCeeovm6evHAFSg2g2kOg6s2ghpsu389wHp1Gh+/emSO6T7LYxaOeFxNmvokRKDCBHmT4SxDkLgPXruIU06FSCT7OW4tn7ezrjkhORKVajUq1ukkV95eWZDhVOM6exa1Z6TC4K5Tdx+jNG9BjURpeyFroVLsLTp0AYNofLj12BEM3rMPYrZuw6/of1udVadR2xX5JVaXXvw3DdSpklRjTbYrogU9DG/R/n6Gq1L295xZYEMRwlUD2TZRq7Cz3jgCpTbQvdhXRpiXwutPmQm2W3z0BIn/Gw+x5BEhtkoP+U1D1JpDyWHOxuOftjKeBwNYXm/tdCFIzG6RiGEj1DFD9pfq2NbvsjPslNvnrp5zbfxHvPjpUdH/U0GbH/u7x3wvzTYxAgQn0ICOQgyAAeH3FUl4R2n/1Cry5cpldsbv2YhHeMl8TJpVYj0obvXkDQpI8E+jtkhKa7AdvyMFbNxEmlVgnApzN2qedPI4huWus///9NStxVnbfpu0T9+7YbePrXflYWniGc5k6QzwmvzoLMX50pFrvFrGIaT0Amd+u8GhcLAhiuEog+ybTWep8QjYKpDbBQRa8I4jmIIi8a4MsdDiIrAtIWX8PM+hmMx+xxkX9BILlOY7FOZGFg6jWgJRG1/e5ahKosbxR2/Ngr/o6Uc43LT8nSm9/JoaT1FYq8fZfByPaD4qVNrbCfa4f+9kQ5psYgQIT6EFGIAdBABB/cB9npjskKQHjt23Gt7t32BWq9kQx17nmrlqYVIJarRZqvR4ri87hi22bMGXXduy/eQPR5r33rrQX0UDQW/splSAqZS6ulpsCIUIpfjt8wGFbloJz844dFvkrMgDg7h/3RQ92+GzgPz/1KFMhaBA0NR6RMxL9ysKmsiBIaALZN1FKQUpf5xfSykXm39sTvFwiNhJE5mkG3Wylr5v6apSZRHPlFyA18SDaY3YEuZ2JAXkv7smI0r7WPeGUVIOUD3LQN/Mz5J1BtQfF/IwMM5vm5yO6pfjV2rksftA8j8bGfBMjUGACPcgI5CAIAGTKWnRbkOrxcnRvWubpk4jOXmwV097oa0hSAkZtygMA/Lh/T7oEygAAIABJREFUr8v3775xTeQvySgsuCB6sGPPlsxY5fbYWBDEcJVA901Us9csNp3MPothqu0g8k7mPkbAUsjO9bYc3FOXYyq8V/aWC+8jAkT2BChh27HEJvPbFejTdqDoPojLolvG4ezeIrfHxnwTI1BgAj3ICPQgCABuVVdhYv5WdEidh1AHWfHmbj0Xpbt138B17osvhjBUyqsQ09q/lrc3tD5tBrq9F50FQQxXaQ6+iWoPgZR/wJMNDyaL4MmwO2HKRWJ/xqBnb84h0f0Pr0BvFYex3Z0/MrAxzDcxAgUm0IOM5hAEWShSyEUXyIFqoVIJO6vcD5CMnI/oVv65lLB3i1gc3nDCrXEJGQSFfx2PqO8T/crCv2ZBkNA0J99ElekuZI6Z2ZjieVDq/NGrDOHRafUYHPK5X08ga9Vat8bGfBMjUGACPchoTkHQliuXRRe6/m58qwtCkhIQf3Cf2J8w6KmrVWN0l8miBzt8dnr3ebfGxYIghqs0J99Eqr8B93FpzExmf4k81R4S+xMGPcXHruD9x4eL7oO4rE/bgTDoDW6Ni/kmRqDABHqQ0ZyCIG9n0O0tnffnPfCWvneaL7V7Tf/VnlXqZnjOb8NS/COD3qhab3SrOMT+4xMWBLEgyGc0J98kbgZdgIrvXrVIB8vfI0GVKWJ/wqBGo9KaMuh+dsJI7xamU0biP3K/UBzzTYxAgQn0IKNZBUGU4v3VK+2K5aiUuW6L3Mjkudxnricl4HpFBU7eu4tID9r3ttmrSh8mlWDU5jyxP2FQo7hV2kQYi2XRreIQ3SoOMW0GIKb1ALzxpw/dzp4DAgdBU+IR9V2iX1n4FBYECU2z8k3GsgbF2HiEqLyz8CJc8TKIsQykbrkfCHF3JxEiQFVs8lhMti/eK7pPamh9zH6pd8tYDAkdi/L77hcSZL6JESgwgR5kNKcgCADKVCp8sG6VjfgctTkPd6qrca2iHHMO7nP6+LSG56J/mb/V7rWris4h7eRxdJyf5BOxHeaFNndd/0PszxfUHMo7Lnrg09Cyf1yLX4cmY9nsNSi9U+54AHZgQRDDVZqbb6K6UyCKFxsIz46gylQQw11Qw02QsrddyzrLIkBkHUCqv7N/ra4IpPp7ByJY4Iy4oMKdVXIXm6QxC/2mivvop75C2qQl+HVYMrYu3AV1ncajsTHfxAgUmEAPMppbEGThj4pyFJTcwK3qKpuf/3JoP0KTHC9HfyFrIb7asQ2z9+3BObkMt6qr7F7/8pJFPs2GN5w8sGeOKtqHmlcbzDm036Nzrhmec+HwZdGDH4u98edBIES4wkwsCGK4SnP0TZQaQXWnQbUHQIntiQik7E3nBGvFYJCqyaDKZFCjDFS10sE9XXycDe/gogC397uOoJo9In0thoVls9b4RYG46Fax+L7fL4KOjfkmRqDABHqQ0RyDIHucuHfHKQGcf+2qzX23q+wLdH8zizB/Ms3+vvPZ+/bijwrPsqMMYaCUYljkOES3FH8P+ufPuH9sDRdCBkERk+PRfnqiX1nEZBYECU2w+SZSO8+JLPeToEZZo/uSBBLLvjJzhl3e0854nwStywYlFSJ9DUZD7t+Q+4VA790iFktnrRF0bMw3MQIFJtCDjEAIgkqqKjFpxzZ0XZCCXovSMefQftRo64/UUNQpcej2TVyvdOzMKaUYt22zXWGbeOQQfj98ENP37kJu8UVoDQaM3JQruuh2xWLXrETG6ZO4VFbKm0XvkZEGg4BZUoZnXD7xB34fkYo3HxokehDUu0Usig5dEmxsLAhiuEog+CaqPQhSPhhE3hWk7A1QVY7NkWBUfxVUexjU6HgSlJJqEMXzdoRtZ5C6pSA1P4DU/AiqPQpCiOnZootuF6xqPKhmG4hqDc81USBVX3vzszFcwGgw4sD6Y5jW90e/mDx+529D3D5SjQvmmxiBAhPoQYa/B0ElVZXonJZsU/gtVCpB3+VLUK3RYPLO7dZl2u2SEjBg7Soo6pR221x7sYh/ybdZpIdJJdZ226fOQ/vUeaKLbmctTCrBnAZHps05tN8mqx4qlSAkKQGbrggnwBjuQylF6sTF6N0iFn3aDLRmKvo++IFoQVBMqzjMHZUu2BhZEMRwFX/3TVS9xTYjbMkG1/wIargNUtbfVnRWzwKl9k9BIJVf2BG33evbsjxL/qz4gttFsxyZRqkOpOw92O5ZjwKRdwU13PTFJ2Q4oK5Ghc+fmWryTW0HWk8YETubfmDdUcHGyHwTI1BgAj3I8PcgaMrO7bxV2QeuW2Ujzi3i9NnMBcgtvoBqDXfxkJQTx/z+WDRPLFQqwYJTJ6zjpZRi7cUivLVyGbouSMVHuWtw8BYLgPyF49vOiJ6V4LIfBkgEG6OgQdBX8Wj/baJfWcRXLAgSGn/2TZQaQRTP8YjQCBDFS2h67nkESMUIUM1eUKrnbJeUfyC6gPa6QNcX179HojQt7Ve8DKLoBVI1FdRwy1efkeGA+ROzRBfjXLY1Y7dgY2S+iREoMIEeZPhzEAQAz2TMt5vptidUI1PmYu3FIhgIwb6SG1h94TxO3LuL3w4dEF1ENx6LkO2FSSWQKWs9fvfFZaWYtW8PRm/ZgHnHDkOutL8ygeEePw+a65dBUG7SVsHGyIIghqv4s2+ihmueCVXFc6D6YlBSC6reDKrOBdGdA6kYDvHOS+eYaBC6vdI3PC5GSikF1ewFqZpsWi6vWg1KPavkzeCm398+Ft0PcdnN4juCjZH5JkagwAR6kOHPQRAAvJC1kDdL7Kxg5RP53GI58DProVIJdl7z7Mi03OKL1qX+IeY2n0yT4pzsPu7UVKNSrRboCzO+ef0n0QOexvbmQ4NQV6MSbIwsCGK4ij/7Jmq866G4jTTvHX/CD4S4D03eE9Rw2/33TilI1dfm9qJgncwoexvEWAZquAVKhPvvVrDjjxPH43p+I+gYmW9iBApMoAcZ/hwEAUDi0UO8YlzozLMz1nNROl5fvgRPzrdfHd1dC09OFKSdMKkEozZvwLriC9AZjS698xqtBlEpc+22H5KUgGEb1uFurX/+3QQSOXNyrXv7/MVO7jgr6BgFDYImxaP9N4l+ZRGTWBAkNP7um5run7aYGJXTI0BKY01Lxb0i+oXK6keAyLuDVE8D1R5z+Z1TzV4nnvEESM1PoFTnha8eXEx6eYZfifQ3/jwIqlphJ2CYb2IECkygBxn+HgQpdTq8k5NtFZ2WvePTdu/AVzu2uZRJF8JeXpKBiOREnz83pNE/Xbknbk0OtAb7xYkaknep2OlJgOcWL4Baz72fkuEcNRW1+OB/R4ke/DS0pM8zPF6KajNGFgQxXMTffRPVXzJnwSPNZs7oqvJAFC+i6R50L1v5x/Ui2G8FusXM76Z2nkvvnFRNcfK9RoJUTfHSlw8ezh8o9qvJ45g2A7A356CgY2S+iREoMIEeZPhrEHS5vAzS40eQePQQTt67i/XFFzAhfwum7srHgZsloJRCpddjzJaNPhXKrojkiORE9MpMd/p6e/vqw6WJ+GRjLl5dmulWfxedOeXwnVNKsePaVfTJznKp/TUXi3zwF9G8UdwuQ++W4gdADW1Y1HiU3nF8PJQzsCCI4Sr+6JsoJaDa/SC1EtC6DBB9MagyDaRqAkjNHFCDaWsRNVwHKe3rW4HukvUCkXXiEd5uCPyqKSDyp9zqC9VfceK9a0DrskDkz7jQdgSo8a63/ySaPbnSraL7osY2Z3ASDHrnkw72YL6JESgwgR5k+FsQRCnFL+ZjwRpmzCfv3A7Ck9G7WVWF1BPHfC7UnRXdlrHYvU4qQXhyIj5av5r32uN372Ds1k1u9eOdnGyH715y5JBLExDtkkxL8mcUCFdRNZj5pONE0QOfhhbdKg5f9JgmyNiEDIIiv4xHh2mJfmWRX7IgSGj8zjeROpDygWbx1x6WrDlVr+e+nlJQXSFI5QQ/EOQ8WWanxHkUiPxFEPnT3O3InwIhdSDybm70IcphFp1SLUj5ALcmDqiG+SZPqS6r8asseu8WsYhuGYtls9YIMj7mmxiBAhPoQYa/BUF7S667nanNv3YVz2Yu8ExQi3T8WmTKXMws2I3rlRXosiDFKtItYrnrghQsOHUcTy9Mdav9vsuX2H13t6qrXBLmDd9XygnhziQNZgpWHxI98OGy6+c8P5KPBUEMV/E330RqfuIRtZGgBv6q0pQS01Fi8k4eCuquPM/3ssmfAVFvBNVsM4tkyxJzs2AufR2kbo2b7bcHqf3N7nunqlVu953qzwn9ZxCUTH5tluh+qLH1/6/hgmzDYr6JESgwgR5k+FsQ9PnWTZwZ5JCkBLy/emWT6w2EYOvVy/gyfysm7diGrVev4IJCjs7pyW4JznZJCRiwNkcUkd4uKQEz9u6CTFmLnw4UoH3qvCa/d+f89pCkBHy3d5fd976k8LRb7ytMKsE9VihOEPKz9ooe9HDZsa2nPR4bC4IYruJPvolSCiLvzCMEI0GVqU3vITWgdZkgVeNBamaB6E6AqLe4L5QVvUAUvX0v0GWRILIIUM0O04qAilHCThRo7PsmUvEp3Fp2X/q6oHU0gpnJr/qfQO/dIhZGg2sFcLlgvokRKDCBHmT4UxAEAB+uX80rBl9ZssjmWp3RiI/z1lqFokW8frIxFzuv/YHw5ES3BG1jcdtQjHq7cnxIUgJuV1cj6+xpt9vgOyru7ZXLUFxWyvnelxaecUugv75iqS/+LIKCxFFpogc8TaxlLOQ3uf9mXEHQIGhiPDpMTfQri5zIgiCh8SffRKnRfha45mfb6w13QBTPmoWlpYBcuGkfdc0v5vs8LSLXULR6O7MeAVL6mmmiomKoB+1wjTkSpHI8KOH+zqYJATcEeu3vvvjTCApi//GJ+L6okQ2N+EKQsTHfxAgUmEAPMvwpCAKAWfv2cC4zD5NKMHVXvs212efO8grH1RfO41pFOWbv34sRG9bjo9w16J6R5rJYtgh/y7Fig9av9voy+DUXi/D2ymVu3TtwbQ7mHNyPZxY2Pfs9VCpB5/RklKuaHlNyt6aGU6CHSiXouiCFV7yHJCXAQIiv/jyaNfM+W+B3heJ++iBRkLGxIIjhKv7kmyil5qJv3EKRarbZXE8qR/OI0QgQ/W1Q7SGQqskgFZ+AlH8AInvSRQEa2aAo25MgVTPgkzPVDTfdv7cmHqTqS5iK03GMp3wI97tXreV/B7Ku/M+rGOyLP42g4MP/N1p0X9TYdiwpEGRszDcxAgUm0IMMfwmCFHVKDM5dw50RlkrQPnUerldW2NwTtyaHUziGJEkwOLdpARFL5feXsjJcEukrzhdaRejmK5e8Ks7bJSVg69UrLlVrD5dK8PziBUg+ftR6nFrcmhzOiYRQqQRpJ49zfoOkY0eskyGWf7ZPnYevd23nXYkQJpXAyAS6IOxY4l9L3IdHjYdWrRVkbCwIYriKv/gmqjsBUvoaf0a47E1QWn/UJKVqOxnfSNC6RU2fQY0g+quui159iXUZN6maBu9m0iNAjHIX7+kIUvYeqHqLaZyk1vQznuup/iLHu9GBlA+q74NFnJf2ASl9h7+vFcO99BcRfEyN+UF0f9TQEj6ZL9jYmG9iBApMoAcZ/hAEEUoRk53FKwIHrV+NIoW8yX1v2cky91+9AoBJlCvqlKjRaqz32cu8cwn0mQV7rPcaCUHf5Uu8Js7bp8yFSq/H9D07ne7f+O1bmrybJ9OkvJMdE/KbXm+hoOQGRm3OQ7+cbMws2I2SqkoUlyp4xfnYrZs8+fSMBqz6JU/0wMeSwR8WOQ7VZcL9N0HQIGhCPDp8nehXFjmBBUFC4w++iRpuwZSZ5hK+7UGqpoGSStt7SK0dwRoFqkwxXUd1oEYZKK2fBCOVn8Glpe+a+jOhqbEUXs2ilw819VHxktP3UJVthXuqL7J/PW9FfB2oajlIxUcg5QNAlQtBSS1o3SLwrmpQCVPlmwFMeP470X1TTGtTJflfhkhBBEwKMN/ECBSYQA8y/CEI2n+zhFeAPjE/yZoVbkzCkYO8WWLp8SPYee0PvLxkkVXIDt+wHndqqkEpReLRQ4hITrS5x54Ifio9Gb2XLUbayeN4NjPdawI9TCqBrLYWNVqtTf/sGdcxZ9HZWZyrC8KkEsw5tN/lb9Tw6DvL++qekYY7NdUut8XgZunM1YhuJW4QNCxyPHYsKYBOoxN0bCwIYriKP/gmUhPPI5gjQSo+5b+vrB+PqA8H0Z4GVaaAyLuYf/YkSM1PoFRrEveVn7qWoZZ3Ny2Tr8v2njiXhYMoXjEt9dfscV6gNyoAR40KXkFNZOGg2sMufR9K1SDlsbBmzS1tVwwFpcL+NyyYGdtjmugC/Zs3fsaZPecFL/zHfBMjUGACPcjwhyAo4/RJuwKZTwSWqVTotSjdJvMeJpXg+cULse3qFYQkNS3y1mtROpQ6k+Ou0qixr+QGTt+/hyWFZ5zOWLtbHd5Z+2RTLgAg7cQxp/a7F8ruN3k3y88XcvY9TCppslXAGSilOHCzBBPyt2DohnVIOXEUFeqme9kZ7nNyR6HoQVB0qzgsmrYcaqVa0LGxIIjhKv7gm0jFMDuC9SXe+6j2iFnYNxT3ESCV40BqfuUW/JXj6+833ATVFoAaroNUOlMkzUfHr6m3mJacV4x04vonOEUy9yqBKHMROtczo5RqQVWrTcXkKseAqnNtthwwPOf34Smi+6Z+j36MbYt2M4HOfFPQwgR6kOEPQdDWq1d4xWdEciLqdPwz4XKlEjMKduOZjPnonpGGWfv2oFRVx7sHOyQpAcvOnW3SDqUUMwp2e1V4O2sd5ydhBYfA5rI3eaqoE0oxe98em8mEDqnzsPXqZcG+G0NYtmfuET0I6t0iFjGtB2Bcr28EOcLGgpBBUNT4eHSckuhXFjWeBUFC4w++iVRP5xCTZkFc/pHde6nurElcy58BKY0xHblmrIDdPdiGkqbtkDqQ0rd9I8AdWfkQkMoxTkwYhIPUSrjfC6kEKR9ge23pK6CG60J8MoYXmPHur6L7JYstmbFK0LEx38QIFJhAF4GSkhKMGDEC//73v/Ef//EfCAkJwYwZM6CzI0wBYOjQoXjggQdsrEePHi492x+CIK3BgO4ZaU32oIdKJZi+Z6dbbUalzOUUtGFSCabs2s55z4Fb/EvtG/fLmwI9KmUunkpPdnhdmFSCCxx78xtyp6Yaay4WYfOVS9aVA1yo9HpWjV1kFn6djT5tB4oeAFnswPpjgo2NBUGBSbD7JtOeab7K7Ttcb0932q6operNnPeZjmbz9Fg2AazMmYmCCBDFCzZ765u8B0pBdWdBVatBtQdBKfdkIKUElCjdyqwzhOOTJ74U3R9ZrG/bgX5bH4X5JoY3YQJdBLZv345hw4Zhx44duH79OjZu3Ii///3v+Oqrr+zeN3ToUPTt2xcymcxqFRWuLV/2hyAIAIrLSvHc4gU2AnTkpjyo9e4tVXsucwGvqP310AHOe5Q6HdqnznMojMOliRiSuxad0mxF9Fsrl2HQ+tV4emGqRwK97/Ish9e8snQRDtwq8eCNm8i/dhXR2VnWiYFv9+y0KajH8B2b0nb4zTFrfdoMhHRshmBjY0FQYMJ8E0DVubA9Bq09qDLNvbYMt+wLdO1R7vu0h5wX0RWNj3iLAikfDFL2Poiss3PZb962R8LhcvqKoaDGu568clBqAFWmmlYfyMJBFL1A6zKZUBeJGe/+ipjWA0T3SxY7vPGEYGNjvokRKDCB7if89ttvaNeund1rhg4din79+nn0HH8JggBThfQDt0qQW3wRV8rLPGor5cQxniPYEuzuwc46e9opEf3Skvqj2vrlZNtUmZ+1bw/CnSzwxtW/7X9ctXtN9rmzguzDyr921frMhhMY/XKy2dFpInDvugzRfiPQByBjarZgYxM0CBoXj46TE/3KosYFTxAUjL6JEiWoZjuoejOosdyjtkznnnPtwX7ZbibZ2X3fRN7d/L8jQSrGgxir6p9d+or74lz+DEhdln2Bb7jp0bux9rN6JvdzahMFaZ/hGqt+9YMTRhrYmT3nBRsb802MQIEJdD9h+vTp6Natm91rhg4dikceeQSPP/44wsPDMXLkSCgUCpee409BkJDojUZ8vnWjdUl6SFICwpMTsa74gsN7h21Y51BENxa1ndOToahTAjAVvXOnkFyH1HnYf/MGAOCdnOwmS/5DkhLQKU0KjUGYAjh8ld7bJSVg941rgjyD4RxGgxFDw8eKHvg0tGuFJYKNjwVBzQfmmzyDGu+BlEbXC3NLhlhvvz4IpToQ+dMuCutIkPJB9WelVwx1T5yX9gE13gU1loPI2nNcEwVSOVqg9yOzk6XvCEqa19+Dv3P3j/vo08Z/tl7F/fcn/lsfhfkmhhdhAt0PuHbtGh5++GFkZNhfYrpq1Sps2bIFRUVF2LRpEzp37oyOHTtCq+Xf+6XValFTU2O1O3fuNOt/ec8r5Fhw6gSyz51Fmcq5quNTdm3nPZPdIva5fp549BAAYM+Na24J9MiUudh57Q8AwJXyMnRdkGKT4Q6TSrDjj6uCvBeVXs+/hD85Eb8d5t4GwPAOOf5wBnoDW/7TOkHHx4Kg5gHzTcJAqQFUswdUuQBUvcXufu2GEEVPO0Kaf4861Z0CpUaQmjluCvTe1gkEqt5gFtANjjVT9AAxeLas3fpuNDvs9oVqhauNwbAPpRRfvTJTdH9ksb4PfoCze4sEHSPzTYxAgQl0AZk5c2aTQjmN7eTJkzb33Lt3D2FhYfjkk09cft79+/fRpk0brF+/3uU+sX9569lwuZhTuIbxiHOLDd+wHiuLzrm1tL2hZZ45BSMhGLFxfZPfdVuYiosuZqIAoFAuw6x9ezBpxzbkFJ3D0Tu3EMrz/FCpBBmnTzpulOERlFIUFlzAjwMT/WfvedsBSByVjkp5leMBuICQQVD7L+LxxFeJfmXtvwisIIj5psCEVH1tV4hzW4RpaXrlOPeXt8siQGRPgOoKTWeZy59rek3ZB6BE6dJ4TBMV+SDV00wV8zUFILVS+wLdwUoDhufoNDrsXLYP43p+I7pPslj/x4dh3dzN0GmEPd+e+SZGoMAEuoCUlZXh0qVLdk2jqS/Ide/ePURERGDIkCEgbu4BDgsLwy+//ML7+2DKUrgKMS8D1BmN6JeTbVOtPUwqQSRPZXiLTdi+xeE1zlhUyjysvVjE+/swaSJO3Lvj9LhSTxyz3tdwZQDfZEOYVAK50jbQqtKokXLiGD5cvxojN+Vh85VL1vfFcB1CCH4ZIhU96Gls0a3iEN0qDm8+NAiF+xxvB3EWFgRxk5qain//+9948MEH0bVrVxw4wL9yhasy+gMPPIAOHTpYr8nKyuK8pqGfAZhvCiQopdbiaNRQAiLv2kikRzpe+s559jqfELe3XH4wSNU3/NcpXgAlzhUDNJ2nbllyH2VnWXuDFQJlbzWpv0INf4DUzAQpHwRSNRVUVyj4NwgmKhXVGN5+gui+qLHFtDEVqRsWOU7QCWTmm5oill9i2IcJdJG4e/cuwsPD8cEHH8BodG9/TXl5OR588EEsXcp9NjYXgbjP71Z1FRacOoHk40dRKLvvUVuUUiw+exrPmqu+P794IZYWnkGtVovfDx9Er8x0dE5PxhfbNmH6np0ITeI/Yu23wwcciu+YZYsR7sQxbe+tWm739yFJCXhrxVJsvXrF7viulJe5NDkQmpSATVcuWe83EoK8SxfRKU1qFfSWiYtJ+VsFKVYXjOxZcUD0gMeRUI/9xycw6A2CjJcFQU1ZtWoV2rRpg4yMDBQXF2PChAl46KGHcOvWLc7rq6urbaqi37lzB//5n/+JmTNnWq/JysrCww8/bHOdTCZz+50DzDc5i+nosJOgymRTxXGjh76J1IDUzAKRmyuvl8eBao+AGm6AVE02iXLFc6Yj2ErfsS+sHWbeO4CUvuGkiOc/x90qpCvHgOqL7Y+vbomDCYHG4v9ZUMMfDd5PnXnJfkQDcR8FIosAVfOv1GDY59ehyX5Vsb2JUG89AHMGJwk2XuabbAkUvxSMMIEuApalg6+++iru3r3L+wccGRmJ3NxcAIBSqcRXX32FI0eOoKSkBAUFBejVqxf++c9/ora21uln+1MQVKfTYc6h/ei2MBWRKXMxOHcNTt233de28PQJhJhFoiUbPH77FpfO8L5XW4Mf9u9FTHYWei5K5xSq3+/difMKOcZv34LXlmXi47y1mLp7B7+wlUqwvviCx9lzi7lSBX75ef6MQeLRQ7z76bls1/X6AKhKo8bbK5fZvf7gLWGq9gYb0/r+iOhWcaIHO47s1E5hslGCBkFj4/HEpES/svZjXRfo3bt3x2effWbzs6ioKEybNs2p+/Py8tCiRQvcvFn/72BWVhYeeeQRp/vgCOabTFDDDZDKCSCyTiDyp0CqvgE11p/cQakOpHJUo2xwJKgqx7Xn6M6YlqKX9gGRdeEWsOpdoOqtIOVDTNdVfQ1SNpBf7Jb1B6me6kCgu7LU3ZnrokBkT9gV6aTsXRee2wGUqhu8p0IQeTc713dyebk9AzDoDejb1n8KwvFZn7YDodMKUyyX+SZbAsEvBStMoIsA3/KPBx6w/RwPPPAAsrKyAABqtRoxMTF4/PHH0aZNG/zrX//C0KFDcfv2bZee7S9BkJEQvL9mpc2y8lCpBOHJ9cu5z9y/xysUlxSeduo5N6uq0GVBilOiNcS83Lth1jiU477QpAR8vWs7KtQqt49X88Q6pSVDa+DOdP50oMClPp28Vz8hMmnHNrvvKTw5EdP37vL84wchX4i8ty/2vz9B7D9GOLxu/9ojgow3WIKgO3fu2CzT5iuKptPp0KpVK6uotTB+/Hi8+OKLTr2Pt956C9HR0TY/y8rKQqtWrfCvf/0L//znP/Hmm2/izJkz7r1wMN8EANRwh2NZeRSI4kVQYlpqS5XJPOI1AlTvXGFPqtlmbsNZId0wa2x4t0xEAAAgAElEQVSnQJx6i2mft8fi3FUzZdL5IKUxLrT1RP17onoQxbMOJwuoZodnHz4I0ai0ovqlmNYDMOjfY/DmQ4McXltX41zRX0cw31RPoPilYIUJ9CDDX4Kgndf+4M1MD1hrykJ8u2cnp2AMSUpAn+wsp54zfvsWtyqsN+yPpVicRazHZC9GlcY0u59x+iTaNRD2vrJCOfdyoYKSG0630WVBCnTmJaxqvd6hsA+XSvDNbhYEucPi6StFXUYY09qUvc+VbsEbf+YOhmJaD0DZPef2kzoiWIKgxtZwmV9D7t27hwceeACHDx+2+fnPP/+MiIgIh+/i/v37aNWqFVavXm3z86NHjyI7OxuFhYU4cOAA3n//ffzpT3/C1avCnP7gS/zFN5GamTwCOBJUmWa6RvECv0it/c3hMyjVNzi/3B2LtD3/3CJeq6ab97AbQSqGWycNfCbS5U/Zea8/OzkZEQVSOb7+XWn3OfVsqtnu+ccPQj7rOkXU1V3RreLwziNDsCltB/fvW8bh006TBBsv8031ML/k3zCBHmT4SxA0e/9eXkEYkpQAQik+27KRV1w/vXC+U88Roogbl2hfdOaU9RkFJTcwfMN6dEid5zOBfqm0FBcUclyrKMfhWzcxMX8LBq1fjV8O7sc7OdlOtTF0wzpUm4t2lKrqnLpn93V2Xro7VMgqEfuPT6yFb8Q0aza/USX5tElLBBuvoEHQ5/F44stEv7L2n7uWQbcEQkeO2K5Q+OmnnxAZGenwXcTHx+Oxxx6DTme/ojEhBJ07d8a4ceOcf9F+gr/4JlLam18IVgw1XSN7kl9cVjteGkp1Z70kkLuB6ky+iVIdaF02SHms7wS6ohcoqQHVnwcx3AVVrQOp+BSkYgRIbQqIvIsT7USA1CbWF8pT5zlxT0dQUu21v4nmzMkdhYhuFYcYkbdgvfnnQfg4/AubfsS0ikN0yzgc2+rciklnYL6pHuaX/Bsm0IMMfwmCJEf490p3SJ0HSinSTh5HCEeRtjCpBJ9t2eDUczzJnjuyxpXVv96V7/VMeqhUgl6Z6eianmL78wbvxpmidJZr+y5fAq3BAEIpemVy78+32LAN62B0s6IzA5CVKBD/0Ty88edBeONPH2LGu7+KEwy1jEXs30dgqDkY+ujfY5CbtNXtat1cBEsQ5Oz4PFlKSClFWFgYJk6c6NSzRo4cib59+zp1rT/hL77JtFeaK+scCVI51nRN+WDwVSF3Zh860RzwkkiOBJF3BSW2y4FNS8S9LdAjQcreA5F14BbdZiHtdHs1PwEAqOG6w2tp3WLh/xCCiDN7zmPiC9+hT5sB6P9fwzH+2W9FE+ojn/gS/f9rOGJaD8C4Z78VrC6KBeab6mF+yb9hAj3I8Jcg6Gp5Oa9otOxzrlSr8UzGfBvRa9mnfo5niTdgqmT+2ZYNaO/FjHaYVIKvdmyzee5+F5aXO7JRm/Ow9mIRIpJNR6WZltlL0DE1SfCxrC82Ha+1hueot47zk7Dk7GnrcniGZ9y+fBf7Vh/G+QPF6PvgB6IEQdGt4rDm941eGyMLgprSvXt3jBlju0e3ffv2DovxFBQU4IEHHkBRUZHDZ1BK8fTTT2P48OFO98tf8BffROuW8gj0cFBNvuka7THYLC2XhcO0T/1lUFLH37Zml1nEtveqWKZq23+3SU0875hcNmWyuT3zmC3L1uU9BR5HhLUyPqkcD84JkdLeoNp93vtjCCIIISg6WIx9qw/jYN4xUbPp1895rxgt8022ML/kvzCBHmT4SxAEAAtPnbBmfy0ivE92Fqo0auiMRuy5cR0Zp09g0PrV1kx4v5xsHLvDX3zoyO1biEhO9Grm3GJv5yzDkNw1iEqZa3cy4MWsDJfa7bYwFTVaLbQGA+Yc2o+n0lMQmTIXfZcvwevLl3AWrvNkomHyzvq9e+uKL+D5xQvRLikBkSlzMW33DtTyLNtluIZGpcXM/r/ZBCLvPDJEtCBoaswPXhurkEFQh8/j8eSXiX5lHdwQ6JbjbDIzM1FcXIyJEyfioYcesla/nTZtGoYMGdLkvsGDB6NHjx6cbc6aNQv5+fm4fv06zp49i+HDh6N169Y4fvy4ey9dRPzFN1GqAykf3kCAmsV09bem/d2kElS9GaT2d5DSvvXZ48ovQI38E8ekdp5XRblNJrtyHEjp6zBlrDvxXNcBRP6Ma21XjDK9A6MMpPJzmJb6dzLvdxd+0oGqN9V/k9pfzUfQhYMoepqOtmPHfgrCnSv3MCxqvI1/eP1PH4o2ebxWsslrY2W+yRbml/wXJtCDDH8JggpKbliFYLukBDyZJsVvhw9AazDg5L276LYw1UZIjt++GeUq+1U8N1+55HVRbjF7Vd4b26yC3S61XVyqAKEUQ/LW2izx98by+TBpImYW7LZ5j5RSVGnUvJXiGe6ROCrNJ4XinCn4E9MqDjPf+9VrY2VBEDepqan4v//7P7Rt2xZdu3bF/v37rb8bOnQoXnrpJZvrq6ur8ac//QkLFy7kbG/ixIn417/+hbZt2+Lxxx9HTExMk/2EgYI/+CZKKahyfr0QlIWbCsKpt5l+V7ekkRDtCKLMBKUau22Squ99JM5dsSdByj91/npFTxBiBDXKQRS9YFvwjXu5v8cCXbOn0bvUmyZIKFvNJRRGgxEftRvjdd8U02aAU8+IbhmHTWneK0bLfFNTmF/yT5hADzL8IQgqUsitldEtQjEkKQERyYnYee0PhEmbFo8LSUqA5Mgh3jbLVCpEuHC82LursnGruhoz97kmni19CW3Uf0fXO9u29JjpP2L7PFguH5KUYM3oN6w+z2dn7t/z1acPWupqVD45b3Zn9j6Mf266KSByEAztW33YccfdhAVBDFfxB99E6xZzCMUokNJoEOUCfiGpO8HfpqtHntX8DKK/ClI+CK4vS3dFKLtybQSIzrSU1flq7DztyDrC9sg4y88bXSfvBkrZ6i1vc2zLKZ9MGp/bfxHvPz4cvVva90192gxEpbzKa+NlvokRKDCBHmT4QxD0Zf5WzmxwqFmk8wnJzunJIDxL2pYWnrErhEOlEry+fAl+2L8XRQq5zb2Lzpxy6ezwV5YsEjyTbRHTw/LWQWsw4Mf9rp1nXp8RlyAiOREHb93EqgvnMWpzHsZs2YjVF4qs1d3DpYkIN0+CJBw56ItPHvTcuXLP60FQ7xax2JqxC0aDEYfyjiNlXCYWTlmGz5+Zag58BqCPuYr8zx/OFbQoXGMEDYLGxOPJiYl+ZR3GsCBIaMT2TZQaQRQ93BCdUSCVE3jbJZWjHAvtiuEgtVIQY3mD/uhAKr9wrS9lA93OVjs0ZZppNYBL55k3mhAofRlEfxVUKQWpGAlS/Q2IKhdE/jTqz4SPBJF1ANXu532nDOHIS96G6Jber+BOKUVddR02puYj6fMMLPw6G/0fH47olnGIaW32TS1jsW3Rbsed9gDmmxiBAhPoQYbYQRAAxGRnuS1i63Q6EEqx6sJ5vLtqOZ5fvBAT8rdgRsFuh0vAD97iLzxyuawMcw7ud6oP5+Qyt8Szs/b0wlQMXJvj9PURyYnovWwxXl6yCF/mb0VxWSkO3b6JsVs34f3VKzF7/17crKqC3mjE5iuX8O2enfhxfwHvWeoM4dGotHiT5/xxIe3kjrNNnm00GLFvzRH8OjQZCSNScWzraa/v3WRBEMNVxPZNlFS4L17L+pvbqDHtNS+NMWXda38HKXvfwf2dQImSt19EvRukYrTjPsi7gWgOe0+gy8JByuNc3Lfezfwu+oLUJoAY5aCq1SAVw0DKB4HWZYASJSipMq1eqP4GVJlidy8/Q1hO7z7v/cnjlrGcPqe2Uom1kk34edBcpH2ZhRtFt7w+XuabGIECE+hBhthBEAAM37Derf3UvTLTQSnFtN07rBlnS9bYUXuz9+3hdBB6oxHf7tnpdOG1yJS5iF62GK8szfRJITpHFsKRBU8/ddz6Xiz/bJ86D2dl9331iRkcLJyyDNEtvRcERbeKw8WjV8QeJgAWBDFcR2zfRKkO/AXV7FkESPV0UKI0F41ruHTcdOwZ/3LyCFAN935bapSBlLuQEZc/DVLWz3b/vNimPdXg/epNwtzyziz/LO3DzjAXEUIIPu00yavnoH/4r9GokFWKPVQAzDcxAgcm0IMMsYMgwFQgzp7g5PvdsnNnee8NSTIVmuO6/7s9u3j7En9wn1tC25U96N62N1YstY7nfm0t52RDqFSCt1Yu88XnZTTAaDRCVasGpRTXzt1EH2/uQ29psuRxmdCoxN27KWQQ1PGzeHSakOhX1vEzFgQJjT/4JtP+6sZiuvFxao0tEkR/GaR6Ns91ETBVO+fYZ63Zy9kPSglI2Ztwb6+3QMepeWxRILWS+jGp8/jfX22irz4xw4xOq4dWbfIT6+dt8XoW/Y0/D8LO7P2iV95nvokRKDCBHmT4QxAEAAtOnbBZJh4mTcRrSzN5RejwDevxw749bmWYO6VJUapqejatWq/36Kx0T447a58yr0mlenft7Zxs65iWny+0O3EgU9b68jMHLVq1FulfLcXbfx2M3i1i8VG7MRjbfapPqrj3bhGL4e3Ho6ZcvG/NgiCGq/iDb6JUYz4+rGFmuguI/Dl+IVq3CKT8Awdi9WluYVr+Iadgodqj4glrxasQ5si0KJDaedYxmd4rz0qC0mhffuag5v51OWa8+6s1Yz7huel455GPfeKXereIxW/DUkQV6cw3MQIFJtCDDH8IgiyUqVTIu3QRM83HkDVepm4Rmp9sXI+lhWecFuRcQjrlxNEmz79VXSWIQA51457w5ETErVnp8ZnmIUkJSD9Vf7bksnNn7Qr0e7Xif/dgYPpb8bZLBr24tJ3LolvFIfmLRaKNnwVBDFfxJ99E9VdAVWtBKkbwZKXN/1+5GKTyMzjOdPNntan+XNPnq1YKI5DdOf6stHeD8909M6q/aB2T6T3xvIfS13z5eYOW6rIaxP33JzYTxc4cy+nWai47vz+8kf/UA2/DfBMjUGACPcjwpyAIALQGA55KT+EUkxHJidh/8wYopYjOXmxXeNrbgx4qlWDcts0AACMh1tlblV6PqJS5Hgv0OBcKuglhIQ3s7ZxlUOn11vd5p6aa8z2FJCUgJjtL9OVlwcCVU9d8Ksb57N1Hh4r2DgQNgkbHo9P4RL+yjqNZECQ0/uabqK6QX2yXxoAabprOBPdwSTlVrTWdsd7gbG+qPeS5QJY/A6J4yY173R2P5T7zZEXNz7bvU7WGfyKh9ldff96gZGV8rncEuQsW03oA4j+a57izXoL5JkagwAR6kOFvQdCxO7ftitEDN0sAAE/MT7J7XQcHS9WfXpiKp9KT0S4pAd0WpiL5+FEYCMHs/XsRmmQr7sOkEjyZJnU6Mz5swzpcKS/Dtj+u4JmM+V4T5u+uWo7sc2fxcd5aDM5dg6WFZ6BuIM4tSI4csk5MWMYTkZyIo3du+/jrBid5Ut8cW+PIXv/Th6K9AxYEMVzF33wTqU0Ef2Y8ApQaQPXnnRCuXe3/XvECTHvUw0HK3gTV5Jv2oJfGcDw/EkTWxXnRrFwMqjsOotrgueC3ZzU/marXV3wEUjkWVNO0KCulOpDyAY0mACJBFC+DNjhejuE9pr8V//+z9+bRTVzZ2jeddNL93l799nf73u9b6bvWvenYxjYJEKaQmYxA5hHISCDz0JnTIeNtEgIkIZZBsrExZjYz2GaeZzCYebYZDBhsY0seNFmyprOf74+SZMmqKqlk2ZKs81vrrGC56tSpUrf3fmrvs3fU7dLga4Zh7LPReyHDbRMnXuACPcGINScoVIH+/BLpdPCXC5dg+FJlUewkdQb+uWk9bE4nPt+4zi/q3GdaNsZsXo9euZqQ5xtZtAxDC+YEPa67wpT2AdOnYtjShVhz7kzIz5SIsKHiHEYWL8Pggln456b1KK/XddA3yGnL1gW7gjsp1w739iR/9q+jOiRK8f2TP0ftGXAniKOUWLNNIQl0ZoDsfm2jCsrSzAXxStbVIGcVWP1TbcT8Q2D6bxTM1xus8W35PfThDu0gIW3dEXrnCKIWUPNMsPrnwOqfBDNNAbHGDvwWOb78OjoLQ64Tr4My+FqhH/nga4YLx1wzDI/+8aXIi/RrhmFF9vqoPQNumzjxAhfoCUasOUFyKe69cjXeCPGWixWSQvu5xQsweN6ssKLSl/RC64+DNVXo22YdyeqMoJF7JWP8zm14YO4MRef0ytXgYlMjph4oxY87t6G4/DRsTme7n7uuuRkHa6p50bgOwGq24sn/OzIgij7kuhH45rEJWD1tE8aNUGHS69nYu+qAt5BcJMX5Y//2Ms4fvRi1ZxBxJ+ijzJga3AmKPLFmm6RT3NPBmt7xHscM4yCeFn4zWNMn4Ylf3f0gErZjMfMcH5HvuU5fiWuGOSxrFZ6TBtb0jvCMTJPAjL+AbKUR2UJFzgqQ/bBsb3hOeBzbfkpSNM8fvxxz/rUYPzz/G3I/n4ONc7Z3yIvjN27+BFazNWrPgNsmTrzABXqCEWtOEACsOXsGSWr/vt1J6gwUlZ32O2552SnRyuftaXe2vOwUAODVoqURE+JiI1mdgZ2Vl/DLnp1hFYZLUmd4q97fP2cG6szhOS8WhwOfbFjjXUOSOgPvr1kJoy26bbm6Goc2HcPjf3oZg68Z7m2tNjrtI9TX+EeLDm48FpFI+ez/XYSX/uddPPPXUfhxWAYuHK+M0p0LcCeIo5RYtE3M8F2rIPWI87p+IOd57zFEDjDjT4IgF42Ie4Yy0UyuOhBrhjf9vaNG3UAwZ527rVs4oj8N3iyCpo/99tIrgZwXweqf8Zm3F8gc3YrfXZF5Pyz12g5PFtf4FzPhcvl/b9O+mIuh17WvLWjBT8sxaXQ2nv2P0Rjxt7eQ+/kcGBujGxTgtokTL3CBnmDEkhPUaLVgQ8U57Ky8hIPVVfh0wxo8vnAePlq3GoeuVoue02CxBOwZbyuElQjfTRXn0Wi1dKg494xbp2WhxmREbwWp82IjRaPCe2tWgBHBxZiiZ/7RutUBLwhSNCq8sbIwEl8pxwdjgwnFWesw45sF2LF0L5yOwMyHw1tOhOzsBBT3uWYYht/wJq5erIvC3cnDnSCOUmLJNpGzAtSyHsx+DMyyCqxxtCAejRNBrhrRc4Lv81bS0zwNxMwg6+qOFeeedTW9D2bbHaZAb/NiwbJISP9XIKyJrGDau0SfETXPi9TXynFzubwa839ajtn/uwin954R/a6mjykIqS3o4GuH49H/E5gKP2bwj3DYA2vkRBtumzjxAhfoCUYsOEFEBHXpXr8+6H3zsrH9UvCU3ILjR2XF60frV2PQ7HzcOSM3qNDtMy0bNqcTVUZDpwj0m9QZyDqwL2JzJbszDUYVLw9pj3mNySibbXChie8F7Gwul1UpKyjXpn2NJoqt1OSIpBPU852JuPXDzJgaPd/hTlCkiQnbxMxgTe/4i8T6J0DOqqDnsoaXZYRrKljTp2Dae8Dq7gpBMP9DmNOc1wkC3b0+468Iqy1bwOgNTwScGcaCWPDvk6yF0vNp7+FR9Ciw+Nfi8CLn1wzD4GuGR7WVmhzcNnHiBS7QE4xYcIKKyk4HiMMktdBW7YrBIHvuFxvXyYrW0uoruGzQY8mpE0Gj0CVXLgMQWq+1tx95qOOFZYtlW8KFM1I0KtySo/bup5diz5VK2Xk2VZyXPZ8Teb5+ZHy72t4MvmY46ipjrwAgd4I4SokF28T0n4uI1HQw3SMgks9WEiLAMgKYMZDjOJjhX/ICt+5ukEsrzNmyrZMEevcQXhyEM9LA6p8GkXzdFGaaBLlie0TR27OciFibW9pVG2XwNcMxKu2jmHyxwm0TJ17gAj3BiAUn6ImF80QjuSkaFSaV7JI999c9u2RF5psri0IStWnZk9HibE2/umPGtE4R6K+vXN4hLwNSNCp8t22z7LO7pG+SnaNMp43I98sJDbO+OSAiHs5YN2NLtG8lAO4EcZQSbdtErFE2gky2UtnzhbZoUuJ3AJhuaGiitmFk65zM3DniXHsvFLVvUzioZYP8s7csgGR6fd1tQV+OcCLLruX72m2XHv7dMGgv85fH3DZxwoUL9AQj2k4QANyamyUqEJM1Kny0brXsuQdrqiUFZu9cjSLxe7imGnmHDnSKOE9SZ+CT9Wsw/8SxDrvGg3NnBn32I4uWBUTwUzQqPLdkQaS+Xk6INNY2RcQJ2lywM9q3EkBEnaC3J+LWf2TG1Oj5NneCIk20bRM5TsuLTMsy2fOZaYq0yKztjdD3oPcEY81g+jFoTRfvqOFp61Yk7ENXtE8+1NEDzDhB/tkzI1hdXwS+IEkFmbMi+TVzQmDTvB0RsU1Ndfpo30oA3DZx4gUu0BOMaDtBAPDckgWiQjpZo8KU0hLZc4kIH65bHSB+07ImKxa0D82d2eHC/Ca1sL8+c98eOFwuWBwOPDB3RsTT3JPUGXh28Xyc1NahxiT93TZYLBi+zL9n/FOLCsKuCs8JHyLC6PSPle1BbzMe/eNLMDXF3nfHnSCOUqJtm4L1NCf7kSDnN4HpHmgjMlPBtHcoFLQD0OGV2z1DNxRkXSOs33EarPYWEZHc3pEOZvwV5Dgpux+d7EfbbBNIBTN8GzQ9nhN5tJd17bJLQ34/Ap/e+320b0MUbps48QIX6AlGtJ0gANhQcU5UnN88dUpIfbmdjGHusSN4fOE83D0zD59tWIvi8sB97XKjf15gu7ZIjxSNCpX6poB9WPUWC0avKIz49VJ9iu69XLgEV03Sz/KUtg6rzpbjeF1tTO4TSxRK1xzC4GuGh1Qt9+HfDcMQ9371odeNwOBrhmPjnO3RvgVRuBPEUUos2CZhf3jbKHg6WP1zIf2dJNYo7KfWPQSmexjMpHIXX5MW/gGjQ/aCtxnaB8BYYGtNchwXftdh174ZzDAORHbx50dOkG0PyLoW5BLv5MLpHHI+my3YnRC3YQ29bgQevkawUc/+dRQunrwc7VsQhdsmTrzABXqCEQtOECBUY+/l025s0Ox8ydZqYlTq9ZiwaztGr1iO77Ztxp7Ll0Luh56kzsBdM8NLa1fac/17kX3hzXY7euao29W//Sa10FIuRZMp+rsUjQoPzp0Jp8I2bJzO59j2U/jy4R/x5J9fxYi/vSXpAD32f17CzG8XYOyzvyLrwxmoOHYp2kuXJJJOUK+3JqLPB5kxNXq9xZ2gSBMLtonIDmb4xj+K3DgK5GoIfQ77fiE9vfFNkDkLrHm+AgHbr33iV0H0m1o2Bq7dti9yUXPvWtq+8EgFM/wQya+N0wEQEVblbsQbN3+KJ//8Kobf8Jb3BXHbaPmHd3wN9fvTMfbZX1EwbllMprZ74LaJEy9wgZ5gxIIT5KHF6cDBmmqc1NaBKYjillZdQXr2ZG+aeIpGhWT3PupQ9qDfPFWNPtPE98FHeiRrVAHp4yvOlIU9V4q7tdqkkl34rWQ3Ju7eIdtXnVdmjy+cDide+fv7ARH1wdcOR+5nswEAzYZmrJy6AeoP8rFk0oqYdIa4E8RRSizZJnLVg+z7QU5lUUAy5/gI1O5ukToArG4gQtrfXfdgO4VxqH3MU8HqHw9YPzN8Fdo6RQV5qrCP3DwTzPgzmOEHmeN7gFjs/d3iSHPx5GVvlLytSD+wXtj+cfVCHeb9sBSaf+Rj07wdsLeIZ0pEE26bOPECF+gJRiw5QeHAiHDv7OlIFhXeU/D2qmLJtO9ojS0XKlBlNGBKaQm+27YZH69fHdY8/fOmYlLJLlQ0tkZzdM3NksenaFTIPrAvit8WJxyqz1/FW70+axXn1wzHpNHZcNgduHTqCp7/f1/H4GuGY+j1L2DwtcPx+L+9jKPbTkZ72X5wJ4ijlHi3TeS8LCGQ08EaXgDTPdpGSItFu9MURcHDE+c+g9lA9kNgxglgxnFg9cPCu3b986DmmSDW2uqTrMWy55DjeBS/LU447Cnej2f/Y7TXNj3+p1ewKkeo0L9p3g4MuVbYrjX0+hfw8O+GYVTqR2islW//2tlw28SJF7hATzDi3Qkq02llRezGinO4YjBgx6WLON/YgE/XrxEV88nuiHQ4QvmumXneiPZNIcyTvX8fUtzR7+7teGEwtGB2wPOwOZ3oMXWK5DmFZac6/0vitBsiwpmDFdi3+hC0V+q9n73b5wvR6Ppz//k6HHZHkFk7j4g6QW9ORJ/3M2Nq9HqTO0GRJt5tEzXny4trl1kolGbbCebSuaPqSoRwCMJdey8CitRJHt8bTD/WJwKuYJ9822HKCHwetlLZlwnkqovCt8RpL3abA4e3nMCB9UdgNQv96RuuNgnRdZH0959ezIzyiv3htokTL3CBnmDEuxN0vK5WVsTmHTrgd/xjC+ZKHjt43iw8v2SB9+f7Zuej4PjRoEJ55pFDKC4vw9OLCjAwPxdvrSrCoNn5ou3LBs3ODymKH8p+9D7TsjAwPxfvrVmB43W13nv8cee2gJcEyRoV+kzLhsURO6ItkSAinCo5g9zP5yD745k4sOEomEg9AGOjCcd2nELl6StB57xcXi1bpKd07eGOuJWw4E4QRynxbpuE9HYZEe2saT2WGWTEaw+wpg/dYtsTgX8RzKgKHiV3nAAzZQtF6rSDwAxfS6wpDazxHVkB7f9iIMjLAe3dYNr7wIzjQS6h9zURA9MNRmDKfDpY03vR+poSHofdge2L90D9QT5mfLNA0vZcvViHY9tPoeFq8Ah4kXotBovsT/eI9BZLYEHCaMFtEyde4AI9wYh3J8jhcqH/dOkK7APzc+BwubzHf7B2pWhLsxSNCh+6e667GPPugbc5nbJ7uh+aNxMVTY0YVbzc+1nPHDX6Tsv2E8eCoM7GJ+vXyIruXjnCte6fMwNFZacxYdf2oELdE4nfVyUY1hanA++tWdHmOeTimI+I53QeRAT1B9PdlW1fwNDrhHS/75/8GU6H0DKIMYbpY+bhkT+86OFWn+oAACAASURBVHVk3u8/BtXnr0rOW77/nKxA37ZoT2fdYlC4E8RRSrzbpmB91Jn+y9ZjyeXu+y2R/u3uuU7k8FaPJ/vhIPOPA9lKwHRDWz+rux3+LdvcYrn+CbD6F6SFd13/1mMbR7qruw8OIZqeDqYdBGKNwpqdlW6R7nNMw0t8/3mUMOub8W6fLwTbdP0LGOKOehdOXuM9xlBvxNeP/OSXofXLSA1sVmmRPf+n5d65xIaxIXh3ns6C2yZOvMAFeoIR704QACw4IR/l3nKxwntsadUVyeMO1FQBAPQtVsw+ehjjd23HklMnkHtwv0wUOxt3zpgWtI95v7xs2d97RpXBAJuztc/r5H0lIZ2XrM7Akwvn+T2Xsw31WF52CtsuXfB7ScHpXEpWHhB1UgZfMwzFmnUAgAUTCgOK7Qz5/Qi8fON7sNvEsx5aLDY8+X9flZh7OLSXdZ15m7JE0gnq/cZE9H0vM6ZG7ze4ExRpuoJtYg2vykbGibUWDGWmTJGIeBpY3QAQawYAkPMCyKwBM/0K1rITrGG0dBRd9xS8xdoko+KpYLXSLwZaI+KDQOQCkfC3iIjA6p8JQaC778HUmtZMxEC2vSBLIchxnLf1jCJZH86QbOlZWVYFIsIn93wfcMyQa4U6KFIc33la0uaNTv84pr5zbps48QIX6AlGV3CCzjTUy4rXhSf9i88sPHncb592j6lTsNh9zP7qKtzibnnm2R9+e34uXi5cEpJQbu94Z1UxrO40dJvTiZ45akXn61usnf78OfL8ODxD3Am6ZhjeHzAGLqcLz/51lGS0Yfti6Uj48szVgb1prxmGrA9ndOIdBoc7QRyldAXbxMwzZARyd5CzNZ2YyAGm/8r/eO0gkEMo+CjsafdEvd37wxteAau7M0Sh3J6RCjLnta7VflDZ+fVPdvqz58hDRHjyz+IveIf8fgRmf78IZw9VSNqlIb8fgSatQXLur4aM80tzH3ztcDx8zTCUrDggek604LaJEy9wgZ5gxIoTpG02Y86xw8g+sA/7q6sUvWG1OBy4WaYw2rHawDRhk82GjRXnsKniPMx2ofWH3Z0u37aIXIpGJTt/JEeSOgPfbd0EALikb1J8rudeokmL04HCslP4dc8uLDx5HCZb7Ow3iwZfDRkn6eSMTP4H9DqD5O+HXvcC5v24VHb+jXO2Y3T6xxh8zTC8+N/vYGnGKtH97dGEO0EcpcSKbSLHaZA5F9Q8Q3mbNbk+4nX9QRT495qcVSDrWpBtH4hc7jWclI5Od7g493mh4O6VThYlvdy7gzU83/4vIgKQSwtqnglmygC1bPU+30SEiCT3iQ+9/gVkfzwTWxfskt1GdXrfWcn5bVYbZnw9H8/+x2gMvnY4Prjtq5iqi+KB2yZOvMAFeoIRC05QYdkpbz9vT6r4qOLlfqnewcjctyegsFqKRoUXly8OWexvu3ShU0R4sJGalQmzzQajzRY0dd73XkcVLw/3K4gYF5oacXt+Lm5St2Yg3DotK6H3vy+cWCTqCA29bgSmvJcHp8Mpmar+8O+GYdO8HSFdJ5bSBtsSUSfo9Yno+25mTI3er3MnKNJE2zYRMTDDtz5COM0dSc5VMAeB1T8HsV7ivhHpYDDjBNE5OnekgjW8LNxXyxZl0ffmOYqff6ShlnUQMg/S4M1AqH8axMSjwInAZ4P+F0MkRPquwlKc3ntG0i4NvmY46msaQ7oOt03cNnHaDxfoCUa0naBKvV60LVmyRoWMvbtDnocRYfK+EtziTglP0ajw6YY1MPpEb21OJ841NKDeYhGdo7i8LOri3DP6501F/uGD+Hzj2pDav/XPm4qL+uj2FyUiPLFwXsBLhWSNCnfOnAZXjEV1Owtjgwkv/ve7fmnuQ34/Ak/9ZSRqKoQXFzO+WYDB1/g7SkN+PwLD/r83YqribbhwJ4ijlGjbJrIskY4k20NP0yXWBNb0UWu0u66vEJH3ES3E9CDnee9e87Yw/RgZgd65UXRW/zRYy1ahUnso1254GUTR/RtGLh1Y7c0i60sH038T1bVFkxO7yjD0uhEBtukfA7+Cy+kSWnn2/WdAy7Qhvx+BH4cHttKLR7ht4sQLXKAnGNF2gjL37ZGMEvefPlXxfPUWCyaXluDLzeuRfWAfrppMICLkHCxFL3c19iR1Bt5aVQSdxd8ZumzQS7Y3u0XhXvBIjR93bMUrRUtlj3l7VTEareIvHTqTcw0NsussuaIsPbQroatqwK+jsvD4v72MR65/AWOfm4TKsirv750OJ357Y6qfSH816QNcOF4ZxVVHDu4EcZQSbdskRL7F9o+ng+nHKJ/PcRrMOA5M/z3IsgTELCBmBtN/7iN0e4GZfgORf/YYWRZLi3Pdo50fSa9NBbMs8Gn9JjHM00XT+Dsbap4j8V12B6u9OSbWGC1O7CrD5/f/C0N+PwJP/z+vIfez2Wg2tvoTuqoGvD9gjJ9A//rR8Wg2iL9Mije4beLEC1ygJxjRdoL+d9tmbyq0WNq2Ei7qmzDQJ706WaNCalYmxmzeIDr3I/PnBER1v9q8wU+ke/497dB+3Dt7eqcL9O5ZmWiwWHC8rtbbyi1ZnYEUjfDMPly3OmYi0wdqqmTvZe25M9FeYsyjvazDrsJSnNhVFnP7yNtDRJ2g0RPR953MmBq9R3MnKNJE2zYx7X3SwrPxDUVzUct6dwTcJ71aOwisQay1WSqY8Rf/88kKpnu4TRTdPZd1YycLdPca658FkRPMuh5M96D7c08KeSrIsiiSX0e7YKYprc9dZBCLnbZfsQgR4eyhCuxavs/vxXJXgNsmTrzABXqCEW0naNnpk6JiLlmdgWcWz1c014hliwKi8VIRcc/Yfumi3xxOxpC1fx/65wm91e+dNR0LTwqtYJZKrDWckRTC2sTWWFavQ+a+PZhUsgsHa6pjam+X0WZDevZkyfutNnEDkahwJ4ijlGjbJqb/FOJp5WkgsybkeYgZwGp7ikRw5dLDb/FrwQYA5Kp3V3l3p2o3vAiyHxTW2vRxCKI68qnwnkg/kQtk2w5mmgQy5/hVp48FyLZT+kWDbkhM2VFO58JtEyde4AI9wYi2E9TidOC+OTP8hLVHvLYVz3JcNZkUi+QUjQo5B0tF5yMi2EV6h+cfPig756DZ+X7CO1mjEobIscXlp7H3ymXMOCI/567KS+E+3k4nc98eUXH+9ZaN0V4aJ4pwJ4ijlGjbJnKUucWwr7BNB6u7DeTShT6PZXl44tdxSnw+Yt5+5K2fWd090aXmSwer7e1zL1Lp3mlgdX3A7EfBbCVgTV/KCv54EbZEDKxhWJvvUngG1LI+2svjRBFumzjxAhfoCUa0nSBAaLH2wdpVXpH+0NyZ2FRxXtEc5xvl9z9LjaKy04quEyyN21ecp2Vl4ustG3H4ag1GLFvk/Xxgfg4Ky1qdLyLy68vedkw/fFDRGqMJEWHmkUMYmJ+Dm9QZ6DMtG1NKS+DsQunaHOVE0gm6ddRE9Hs7M6bGraO4ExRpYsE2kf2gey+6J7V9NMhZoWwO2f3P0ink5NIquo6Qxh3i/HUDwJpnCenxuvtbP69/2u/FAHOcDfISIX62LREzgRn+BSGboTuYbiioZUO0l8WJMtw2ceIFLtATjFhwgjxYHQ40Wa1hvZV3uHuYhyrMkzUq3DotCxaHI/jkPteYsGu7ogj9nTOneSPxdWYzLjQ1iopVqSJ0yeoMfLx+jeLnEW2ICM12O1icRFg4HQt3gjhKiSXbRMwQkHIe8rmO0wrFeTpY07vKruGqB2t4UcE10ryF7ogYyHkJ5KpWvHayFIb1TKIJkRPEol9UlRMbcNvEiRe4QE8wYskJai+LTx4PWTz3z5uKI1drQp6biPDemhUh7xv3HaEUR3tw7kxJkT9u57b2PBYOJ+pwJ4ijlK5km4Q2ayFG0RueB7HQ+ksDALFGd0E7pXvM04Jeh1y18gLdtqO9j4bDiSrcNnHiBS7QE4yu5AQBwJqzZzBAIpKerFHh8QVzsaHiHGxOZ/DJfNhXdSWsFPoUTSay9u8TnXN/dRVeX1GIgfm5uGtmnmTKfHl96PsdOxqjrQU1JmPMVI7nxAcRdYJem4h+b2XG1Lj1Ne4ERZquZJuI7CBzFqR7mXcH038Osh9UnEHGTBlhiHO3wLYfE1krgSxLweqfBdPeBVY3UGT+NDDt3QHt4KIFEYFcOpCrIdpL4cQZ3DZx4gUu0BOMruQEeXh9RaGkYL5rZp7keUabDXOPHcH32zZj2qH9fn3Sf96zU7IdXLCx6mx5wLU2VJxDkjtC3nbverJG5f3dopPHO+QZKUXbbMY7q4u967xjxjS/ffQcjhzcCeIopSvaJmmB3gPM8C/J88h5GcykBjOOBVmLQGRrnbP+sbDEOatNExW0zPAjPPvgvWLcV5jXdgerGyhZxK6zIfsBsPonfTIQhoEcJ6K9LE6cwG0TJ17gAj3B6IpO0JjNGwLarXlEsFTrtvJ6HfrlZSNJ3dpDvcfUKdh75TIAIGPvbtE5g+1BH5ifg3KdFvNPHMPyslPQt1jBiHDXzDzJdPmMkt0oOH4UuuZmvzU6XC5srDiH/MMHseViRacVXrO7XHhg7gzR+xd7+cDhtIU7QRyldEXbxLR3Se8JN4m3biNroVsYp8Pby1s32FtJntU/E5Y4Z42fguwHQM0FoJbNIHKAnBelz9HeDWbOA1lXg6jFf43MALIsAzXP7lThTo6zYLW3BL5EqOsdc63eOLEJt02ceIEL9ASjKzpBR67WSIrmnjlqHK296nc8EeH+OTMCBHOSWoX+eVNhd7lwWqdVHDkX6wmempWJMZs2yJ5XcPxowD1daGrE3bPy/KLt983OR5XR0OHPc9XZcsn0+4fmzuzw63Pin0g6QX1GTkD/N1UxNfqMnNDl/o5Gm65om8icLb0Xvf6pgD3hzFktkb6eDtb0iTBnc770nJKjp4gAvwus8S3580REL7WsD5yv6R8gsnf48xT6wotlJaSDGSd0+PU58Q+3TZx4gQv0BKOrOUEmmw3jd23HzRJty5LUQusvT/V2RoR3V6+QFcw73P3Yf9mzMyAdvSNGikaFMZvXw2gTohREhMHzZon2Uh9cMLvDn+nE3Ttk0/uV7ufnJB7cCeIopavZJnKeB2t8X0Jwe0T3e63HuxrAtHfKCOZ0ELW4e6APDzPNXenoDzJPBxFzr1HqBUJ3MOMvHf5Mme4R6bU2vNDh1+fEP9w2ceIFLtATjHh2gi4b9Cir13nbmDlcLjy1qADJIaSiF5cL/c9Dqfy+2p3GvaL8tKTw7wiR/vSiAjAiHK29KnvsnsuVHfqc8w8flHymvXI1YbXF4yQW3AniKCVebRORE+Q4K7Quc/9tJOclsLo+EtFe39Ha/zyUyu/EDCByufeNK42it2OYpgj3JZcRUJve4baBNb4m8YIgHazpow69NqdrwG0TJ17gAj3BiEcn6ExDPZ5aVOAVif3ypmLxqRNYLZGKLSZ+cw6WAgCeXbJANiKerFHhqsmEY7VXOzxyLjZ2Vl7Cporzssd80sF90nXNzUjNmhxw/8kaFX7ezdvscIITUSfo1Qno/4YqpkafV7kTFGni0TaRdY3/PvP6x0GO42D6r0MQ527R7TgFYiaZSLt76IYK1cvN0zpPmHtHTxAzgxm+lz/OVtqxz7tlnfRztO3p0GtzugbcNnHiBS7QE4x4c4L0LVb0zcsWLVj2WvHykCutb3enrQ+anS973A87tgIAPtuwVnGRuEhE0dWle1FtNMoe90rR0g5/7psvnEeP7CleYX6TOgOjVyxHi9PR4dfmxD/cCeIoJd5sE9lKRKLJaWB1t4LVSRWHaztuATETyFUTXMi3bAERgWlvj4JA7w6yHwUz58of0zy3Y585EZhpkvt6qd5B5pwOvS6n68BtEyde4AI9wYh1J8jJGKyOVhE448gh0Uh2srtiejARnaJRYej8Od4+3l9sXCd7zv7qKgDAM4vnSx4Tbvu1YCNJ3Vowrl+eeG/3JHUGvt26qVO+C6OtBUtOnUD+4YM4crWGp7ZzQoY7QRylxLptIrL5FUJjjaMlouRp7l7iwURvKpjxZ/fcLvn953X9QUwPYpYgc97acQLdWQnm0gZ5ibChc74LZyWoeQ6oeR7IVdMp1+R0Dbht4sQLXKAnGLHiBBltLZh55BA+27AWE3fvwOGr1RizeT1Ss4RK6I8umIttly7gy83rJQV1ahChnKTOwJsri/zal51tqJc8L0mdgeeXLAQgLeRTNCp8uG41Xi5cEnaUvH/e1IACcElqoQp8k9UKAFh2+qTkGk9o66LynXE4oRJJJ6jvKxMw4HVVTI2+r3AnKNLEim0i5yUw029g+i+Eium2vWCNI1tFddO7wjHaO6TFqu5RyO8R7wVmmgSi1oKbZFksK+bJPNUdQZe5bvMiYe6whXgfBKbap4M1jPCukzV9IP6yQXtHp1Ry53DaA7dNnHiBC/QEIxacoEv6JtyWn4Mkt2BN9opPlY8QVSFJLey3lhLo98+ZgewD+7zC15OKffesPOytugKdpVn0+mM2r5cV0VaHAye0daKF0pLUGTh0tRojli0KWZR75knWqDC0YDY2nD+Lp90R+hSNyivOt1ys8K6RiPDrnl1+2QMpGhV+3bOz3ZFsi8OBqQdK8cj8OXhw7kxM2LU9oAc7h9MeuBPEUUos2CahhZinB7lvdDzNX7DWDQSrf1JChKeDGX5wFzRz/+w5rvEtMFs5iIn/vWXa+6XFc8MwYY3N+SK/TxNS3506CH3CQxHjqT731ROs8XUw6xawutvcn3l6sD8Acla1PiNmAmt4xX+uun5gLVva//ydV8AMY8F0D4HVPwNqngsivq2KEzm4beLEC1ygJxix4AS9UrgkpP3dyeoMPLpgDrpnZYqmuc8+ehgAMP/EUe98HjF83+x81JjE7zH7QKlklfJkjcrbRmztubPom5ft/d2t07Kw4kwZAASN3vuu5bH5c70C27POf23bjB2XLkJduhcFx496I+eAkF1QbTTCyRgOX63BHTOm+c371KKCsAW1zenE04vn+91/ikaFO2bkQttsDmtODqct3AniKCXatomYGay2d5DIt48gbnxP8nfkOCOkres/DxTDTR9Iik7W8KK0mG58VVgnMfc+7B4+EfuhQiV5+4EQxXm6sFe+9s7Wnz0vJqwrQdYikDkL1LLeb63k0oJcdWCMgTXPgX8/9FQww3cgcoX3/J0XBKHvfTHi3mPe+La3zRuH0164beLEC1ygJxjRdoIarRbFaeEbK86jZ47GL4r9r22bwYhgdTjQO1cTIOBTNCqMLF4muoYLTY2S6efvrVnhd6zd5UJR2Sm8VLgEt+So0WdaFr7fthl9p2WLzpGsUaFfXjZ652owYtkifLt1k2Q1+K0XL/hdq95iwftrVnrF84DpU3HXzGmiLzPSsycj9+B+OFzKnCGpNnMpGhXG7dym7MvkcCSIqBP08gQMGK2KqdH3Ze4ERZpo2yayrlaWDt7wKpgpo010vRfIukqYT1Isp4KaZ4mvwTJf8npkWeR/LGsEM08Fq39ciJpr7wczTpRfc91tYHUDwPRfuF8GtN1DnwqhYrv/d0D2Y2D1z/i8EHjU/YJA5GWG9j5Qi/I6KazpQ5H1uO/dxruHcCIDt02ceIEL9AQj2k5QjUm+Qnnb4em7bXE4sPbcWSw7fRJXDAbvfGvOnpE9XyrSPPVAqV+KeZI6A3fMyEWV0eB3XKVej965Gj+RnKJRoXeuRjIKX16v857/2IK5koL4o/Wrvce5GMMj8+coqhyfpM7AO6tXyKa8N1gsyDt0AF9uXg916V6MKl4m+cLg3lnTw/1aORw/uBPEUUq0bRNZlioQ6OlgTR8L57lqhYizdQ2ItWYhMcM3EoIzFUz3qPgayO6TGp/WKv4bXw/Y303WNT7HtUk3D7huGpj2Lu+ed2JN4uLa+zJgeet1nJUQ9rWn+d9DkGdEloXyz9t5XsgEMHzj3n8vlZrfA8w4NpyvlMMJgNsmTrzABXqCEXUniAiDZueH1GM8OYSo7pxjR2TnON/YIHnuoavV+GbLRry3ZiWmHz4AQ0tLwDHfbNkoKZrvnTUdN6mFqu6eY2YcOeR3/j3uY8TG6BWF3uO2XKhQnFngGQdqqtouGwBwUlvnzi5QeffoJ7tfSIjNc/+cGbLPmsMJFe4EcZQSddvkvByS8Aw1qssa35I+X3un9DrIKUTz9Z+C6T8FWVf7FZMTjmFg2kEykfL+7ntxR7nrbgXZD7ee76qWubdUUPPs1vsw/igZ2ZaP1vcFUaBNBQCyLHKvz3evv9SzTwczjg/hG+RwgsNtEyde4AI9wYi2EwQAGyvOeaPWcsLziYXz0GyXrgpbbTQG7M/2Hf3ysmFXmALuCxHh9hm5kvO/ubIQmy+cx087tyNz3x5UiLwM+GrzBlGBn6RWIffgfrQ4HZh++ABuy88JS5ynaFSYvK9EdO0Pz5sVEOWXeubJGhVUe/eE/aw4HF8i6QT1e2kCbhuliqnR7yXuBEWaWLBNzPBjaOLTNEk2c4latsmI2tboe9jrdFyQFdjMnA+yLAQzjhfakbEm//WRC0x7r/TLB8dpkOsqmPEnmch2CC8xfF4KeK/tqkFgpXj5qDzZD7TreXE4Hrht4sQLXKAnGLHgBAHAniuVeG7JAknhOTA/x9u7XIoXli2WTQmfe+yI5Ln1FguWnj6JxadO4KrJFPD7o7VXMaRgtqww/nj9mqD3eVHfhJ45gSnyd86cBp3FrKgavJSwnnZof8B1y+t1IZ3reVEypGA2jDZb0PvhcEKBO0EcpcSCbSJioOYCsLq7pMWv/jP5OZgBQkq4lOC8GeQ4LX2+4yzIstCdMm8J/L1lsbCPXDa9vFBk5jbzWFeKCONUsKYPhWrqdQMlhLQCgS5yn9Q8I8i8nvW4jzF81+7OJRyOB26bOPECF+gJRiw4Qb5k7tvjFYse8ZqsUWH7pYuy51Ub5fey/7hjq+S5s48e9hPMyRoV1KV7W+c2GXHz1CmSe8w9w7ctmhxnG+rxzupipGZlosfUKfhi4zrUmk1YcaYsJBH94NyZkr9PUmfgskEPAHAyBp2lGXaXC4ev1sjOO3b7Vry9qhijipdjzrHDspkKHI5SuBPEUUos2SYiO1jDiDbiNV3Yx+2qlT/Xslg2Gsxs+6Sv2fSx/7F1fUG2Xa3HWNeGIIxvATGD6DUCrtmyCaz+KXj7mJs1wjr0X4YmzrUPSfwuDUz3kFdYE7WAXA3CCxCzBrIp8yY1WONo4UVByyYuzjkRhdsmTrzABXqCEUtOECCkYq89dxYvLV+C++bk48N1q3CsTt4BAoAT2jpZAVpYdkr0vP3VVZLnbKw4BwCYVLIraLG2b7e233H4ZMOaoGn+zywuQLPdjtO6OgyYLvSOT9aokKIR2rzNOHIIjAjZB0rRZ1oWblJn4JYcNcbt3IaeOWpJ0c9bqnE6kog6QS9OwG2vqWJq9HuRO0GRJvZsUwvIPF3od64bAmb8GeTSBj/PnCsrQMmlEz2PmSaLCHt3VXWXsH1Kuve659g0kHW16PxKEPawBxHnxkwQEZhlGVr3krsL29X1BtmPgJgeTP9PeFvCaQeBmVTS669/ot1r53Dk4LaJEy9wgZ5gxJoTFC4WhwM3TxUXoDepM3ChqVH0vE/WrxEV38k+bdneWFkoOe8tOWqUVl2JyFv9zzeuQ3IQge7puw4ARpsNs48exsfr12Ds9i04oa0DAPy6Z5doZP3pRQXef/v+9+c9O9u9dg5HDu4EcZTSVWwT2fbJRJzvFe3pTUQyaeupoOaZACAj/FPB6p8GOSsjcg+s7rbg6es++9rJeVloOaf/VIjCu+qEfe71T4uvWdf2RYMg7H2zBTicjoDbJk68wAV6gtFVnCAAyHa3SmsrTD9aJx1BGL5Ues/3g3MFJ+i7bZu9Eeq2In7YUvnWMUrYVHE+aIq7WIV2q8OBFWfKkHOwFKvPliMte7Jk+vuso4fx+IK5SM+ejAfnzsT8E8d4yiCnw+FOEEcpXcU2ERFYw0uiKeJSe8OJ7DJiuAeYcSIAyFRuTwOZp0bsHphxrEykvrsQISdH4H24tKDmAlBzPljzXOnzdQ+AmTRg2nvAanuCNb4KspVGbP0cjhTcNnHiBS7QE4xYcoLK63WYd/woVpwpgznIHuhjtVcxcfcO/LBjK7ZdugBGBCLC7KOHMdBdAb1njga/7NkpW7n9x53bRCPoKRoVPt2wFoDQnkwq9XylT0S7vTAivL9mpeh1UjQqPDxvFrZcqMC3Wzfh+22bsavyEo7X1aJfXrb3mGACf83ZMxFbL4cTKpF0gvq/MAEDR6piavR/gTtBkSZWbBORC2TbBWqeJ/yXpO0JkQPUsgHM+AOY6TeQQ/h7S8wMZhgriE+3ICVrsex1me5hSVFM1iJh3uZ8idT2m4PujVf0DFz1si8DmOFHoUq84Ruhor3zvLt1Wro31b51bVIReP7/HU7nw20TJ17gAj3BiAUnyO5y4R9rVwWkjm+9eCHgWCLC+J3b3YI0E92zhMj2qOLlsDmF3rCMCIaWFjiDVH0HgEv6JqRn+xeAS1ILvcxPuVPGAWB52Smk+0SmPW3IgkWfLQ4HppSW4P45M3B7fi7GbF6PS/omyeNdjGHBiaO4NTfL73ncP2cGXi5cipvca/Pcd7pEtFxq7Ku6EvSZcDiRhjtBHKXEgm0iV7Ww39xXXOoGg5yBmUzEzGD1z7dGud2p3GTOaz2GHCBmDClriazFIkI2HUx7n7efOJELzPBdm2h2X1DLtuDzOy+D6b8B094FpnsIzKQGsWbp45nB/ZKhh//1Gt8AqxvUur5weqTX9hSNwHM4HQ23TZx4gQv0BCMWnKDMfXsCItRJ6gykZk0OKF62q/KSZPr29MPh9UY9dLXar4XaA3NnYFflpYDjjLYWrDxThuVlp1BrDmzFhtM99QAAIABJREFU1ha7y4VnlyzwE/8pGhV652pwUUakA8KLiMNXa7D41AnsuVKJguNHgxaQkxvJGhXumTU9aKs6Dqcj4E4QRymxYJtY/XMigjMdrP6ZAJHNjD+LprGzWvH2YqFAloXu9mYeMfwayFUdeJyzEmRZDmrZACJr8HmdlWB1/drcWxpY/fMgks9eI7KDWraALMtAjrNgTe+HKcp9I/Dfh/V8OJz2wm0TJ17gAj3BiAUnyJOiLSYq2/b0/nzjOslU7gHTp4bcu5uIYHM6fdq+EK4YDLikb4rYnuzicvG2aSkaFT5zp8+HyrClC8MS6N3de+cHTJ+KMl3wisMcTkcQUSdoxAQMfFUVU6P/CO4ERZpo2yZynJEVlm1Ft2whtca3RIvBiV6XyE8kEzlAzoqQKsaHilBJXVxUk3VFyPMQs0i+lJAfqa3XbxgBYryLCCc6cNvEiRe4QE8wou0EuRiTFpdZmfhxp3+q3juri2WF6uB5s4KK9GWnT2LQ7HzcpM7ArdOykLF3t+w+9XCoMRnx5soiyarsfaZlA4B373wwHpk/R7E4X1Fehqz9+1BcfhotTp4+yIke3AniKCXatolsO+UFum273/Gs9hZ5UWr4Vv561AJmmgRW17c1lT4CLdL8r8FAzvNgtVJt09LB9F94jw06H2sKQ5wPBFkWgcw5IFsJL1LKiSrcNnHiBS7QE4xoO0EAMHjeLEnRvez0Sb9j8w8flBXoyRoVsg9IV3+de+yISHq8SrbSuxKqTUa8VLgkqHi+NTcLjy+Yi5vUGeidm4Wfd++QFdETd+8IqQicZ6RlT47I/XA4kYA7QRylRNs2kasWcj3GyXXV73jWOCpoNJkcx8WvRQTW+Hab84Vrk2V5ZO7HtgdM92DwdPP6Z4V96bXdwXQPCansEiKaiMB0j8o8J7FsgpERuR8OJxJw28SJF7hATzCi7QQBwMozgangKRoV7p6VFyBajTYb7p01XVacPrmoQPQ6dpcLfaaJp9PfpM7Ah+tWQ9csXSQnGHaXC/fNzg8qpD1R9bYvGgbPm4UWh7hIrzWb0D9vqt/cyRLXSVJn4MtN68K+Dw4n0kTaCbr9FVVMDe4ERZ5YsE1MP0ZEdKeB6f8ZcCzZj0qmjXuj06Ypotch+zF50WzKbVcRNXKchVDcTYGQ9ov+S+8RJ9t2+Fdqlx9kXRP2fXA4kYbbJk68wAV6ghELThAALD55HAOm53hF5siipagyGkSP1Tabva3UxMZTEgL9bEO9rHBOUmfgnlnTYWhpCese1p47E1J0OzUrsKe6Zzy2YK63Gn1brhgM+GLjOvTK0aBXrgZjNm/A+6tX+In9JHUG7piRi6umwCJ2ZrsdVokXABxOR8KdII5SYsE2EdnBDON80tdvEVqKkfg2KmY7EJ5Ab54VXDw3fRz2fTDDt8FfHgQT16ZM6edk2wvW8ApYbU8w7b1gpgwwrUibuMa3QORv34gYiBl4FXdOVOC2iRMvcIGeYMSCE+TByRguNDVCZwkexZ577IhkqvvIomWi59SaTUHFc7JGhZyD0inycmTu2+NtfyY2hi1ZiC82rgu6hvknjoV8TUaE1WfL8cbKIoxYtgjq0r1otFr8jjlQU4WnF8/3Cvg3VxahUq8P6x45nHDgThBHKbFkm4iZQc4LIRUzE1LVJQRv80Lx+a2FoUWfHSdFzw+6pvpnZObtC9YwEqzpH8Gv76wM+ZrETEKf9sZXwBrfEKrM+4hwIhKq1Gvvds/fG8w4PqQq9BxOpOC2iRMvcIGeYMSSE6SEFqcD97kLvYmNkiuXRc97qXBJ0BT0lwuXhLWmhSePS740UFKB/ZUwry/GSW0dUrMyA1q9DZiegyYrd4Q4nUNEnaDh43H7yxkxNfoPHx+Xf0djmXi1TeS8AFZ7s7jIrbtVVOQTM4HV9goSRU8DNeeHtSZBfIu9NEiV+FxspIKaZ7T38bTec/Mc0XtkjW9H7BocTjC4beLEC1ygJxix4gQRES7pm1DR2AAWYlVXT1RYbP/6pxvE97lVGQ24R2YPe7JGhbdWFStef7XRiBPaOvTK1YjuDVci0F9YtjjoteYdP4qC40dRY5L/3j5Yu0r0hUSyRoXcg/tlz+VwIgV3gjhKiR3bZAc5zgUUhZM8nplkhTZZi8TPa9kG+UrwqSDLfIVrdwovDKxrQhThciMNZJ4mcy0C2Y+AmueArCtBTDoTjsgOVjdAJlPglKL75HDChdsmTrzABXqCEQtO0OGrNRhcMNsrHu+elYfNF84HPW+QTAT91aKlkufZnE58tmGt5Lmrz5aHvPaT2jo8sXCe99zbpuegV64mZDEuJuTzDx+UvN7kfSVIch/nGdkH9vkd0+J04GBNNU5q63DbdOm9+u+sVv4igsMJB+4EcZQSC7aJLIv8+5s3vAByXpI/x1UTJAouHYUmVz2YbqiEwE8HuXShr91aCKa9s/V87YMQCsX5Rs+V9TAnxxnxazGLu4p999a11/UB2Ura3F8DyH4AzLZb/joKX0RwOOHCbRMnXuACPcGIthN0xWBAj6lT/KLOSe4I7+GrNbLnfrZhrWR0OHPfHtlz7S4XXite5o24e+b5ZMOakCP4tWYTeuZoAtaepM5A7sFSzDxyCC8tXyxZbV1sDCmYDbPdLnq9zRfOS56349JFAMCCE8fQ2+cFgVRBuhSNCl9v2RjSfXI47SWSTtCAYeNxx0sZMTUGDONOUKSJtm0i62pRkcy0dwWJDjv9hXFb8Wk/JH9d5xX3vmxP+nm6O3ouXltFdI6WjeJrr7sdzLIEzJwrFHNTEkE3/Evyesz4g4jYTwWr6w1iRnexve9CfiFA1rUh3yuH0x64beLEC1ygJxjRdoKk+nunaFR4b80K2XPPNNQjLXtywP7qPtOyQ2qX5mIMGyvO4avNG/Dt1k3YVXlJst8rAOiam7HyTBk2VpyD1eGAau8eUfGdolFhaMEcRX3Lb1Jn4OlFBTDaxKsDA8DrKwolr/fu6hWiAl4utf5gTXXQZ8ThRALuBHGUEm3bxHSPSaaqk2WR7LlkWSQaPWcNr8raGO/5zAxqngem/xLM9CvIKZ9RRo5ykHUFyFYKIuYuCieRZi9bME5iGMfJ9EK3g9X2lDg3VXgWhnEi6xFbXxpYXT8QhddJhcNRCrdNnHiBC/QEI9pO0KtFSyUF5D2zpgc9//DVGjy3ZIFXjL5WvAwVjQ0RXSMRIWPvbj9x3DNHg6cWFYSdyi42Dl2VF8yPLpgjK+6HL10ku/89RaNCskaFJHVG2JXqOZxw4E4QRynRtE1EJC1wa3uAGX8IPodlKZh2kPucnmCGsbKR97DWycxgjaP916cbDOnCb8pS2oUouLxgJqaXOb8HmPE3SBbN8z2uNlUoomfjtonTeXDbxIkXuEBPMKIt0Mds3iCZph6sWJovJpsNFoU9vl2MYfflSmTt34c5xw5D2yzeQqew7JTkfvHkdghy39T6KaUlotf25estGyWzDf61fQv65mVLrFOFlwuXQrN/L6Yd2s9brHE6nYg6Qc+Pxx0vZsTUGPA8d4IiTbRtE9PeJSly5Yql+UJEIKYHkfi2Jclrs2YwywqQOVsouCYhkJn+MxHR7UmLVxgl94tq93DP2xNkk98uRsTk0+VFq7X7p84z0xSQZRGImRQ9Jw6nvXDbxIkXuEBPMKLtBB2tvSopYNeeEy9I014cLhd+K9mF7m3EbopGhWWnA/vMPrFwnmiquJK95b5jYH4Otl28gJ92bsdvJbtRVh9a4Z9zDQ0BKf3JGhXSs6fgQlMjnlpUgCS1uID/ec/OSD9GDidkuBPEUUq0bROZcyTSsm8Bueo65pouHVjju4EiVns7yFHmfyxrVBgRl2vh5h5NX4IsS4SU9uYZIFd9aOu2LBaZLx2s/jEwV4PsC4NgLwA4nI6E2yZOvMAFeoIRbScIABadPO5XzMxT5C2UvXrh8NXmDZLiOUmdgQtNjX7Hy0Wmn1xU4Lf2JHUGnnen3MsNk8xecymarFZ8u3UTeuW0FoF7fOFcbzG9FWfKRO+ne1YmLuqbIvLsOJxw4E4QRynRtk1ETjD9GH9BWdcXZNvRQdezgukekk5N1z0AItZ6vKNcXmzXj2jzWW8w3cNBznkmrLUzx3mwxld9UtlTwZo+ALmE7WZM/6V4pF832O+eOJzOhtsmTrzABXqCEW0nyIO+xYri8tNYdvokas0dl+ZWbTTKFk5L0aiQsXe33zlDfFrAtY2gTyktQZPVisKyU1h08jiqjAZom83okT1F8ho9c9RwMWVOyWWDHrfl53ij555Ud9+95ESErP370N3nhUGfadnYcrEiIs+OwwmXSDpBtz07HneOyIipcduz3AmKNLFim8h5AWRZCmpZDyJrx13HsjRohJvsB7zHB41M24+AnBVC6rh1lVB4rmWbzPzpYE0fKF93ywa3+PasxZ0a77NWYs1gTe+1eRnwOMh5OSLPjsMJF26bOPECF+gJRqw4QZ3FmrNngu4L/8an/Vj2gVLJSPstOWrUmcX3rR+sqRZNgU9Wq/DzbuURmLdWFYnuP09SZ+BSm+h4o9WCDRXnsOPSRdicTsXX4nAiDXeCOEpJNNvEDN8GTVmnlvUA3NH9hlelo+0NwyQz0JgxI2Lp5kQtYHX9Qor4A+6XHS3rQfajHZYhx+EogdsmTrzABXqCkWhO0J4rlUHTzxefOgEAqLdYJFulpWhUOBSkTdn+6ircOi3L77z31qxULJpbnA7JqL/Qc31/2M9DKUZbC9Sle/Hogrl4dMFcaPbvlW0Nx+EA3AniKCfRbBMzTQoi0FNBzioAALWskz5Oey+INcpfy5zfJvqeDmqeqXjN8hH57iDH6bCeRTiQ84LwkkM3FKzhJZC1iKfPc4LCbRMnXuACPcFINCfIxRjunDlNUvDeO2s6rO5q8CtF9nT7jtM6bdDr2ZxObKg4h8Unj+NMQ2gFd9rSbLfLruPd1fL94iOFyWbD4HmzAorUDSmYHdaeek7iEFEn6JnxuHN4RkyN257hTlCkSTTbRI5zkC3kpv/SeywzfCWd3l7XP7TruRoEEWst8u4VV7zmlg3yafnWNWHNq3gdjhNgtb18non7ORq+65Trc+IXbps48QIX6AlGV3eCiAg7Ky/hn5vW4x9rV2HBiWOike2b1EIPdd/972vPyafDnw1TcBMRWpwORSl+g+fNklzHgOk5YJ2QLjj1QCmSRarEJ2tUmHao86L4nPiDO0EcpXR929QiVEzXfwym/xJk2w7WXOAvMD3p4saf/Vq1CenwUgL99nasiYEo9JetQiV5uZcKX4e9FiWwhpcksw86M4rPiT+4beLEC1ygJxhd2QkiIny/bbM3Jd3Ts3xIwWxUG41YdPI4Ju3ZhYLjR9FotQScb7TZkC5S7C1ZnYH758wIWWDXmk3I2Lsbo4qX47klC9B/+lTcpM5Av7ypyNq/D84QCsZ57kNqdGRhPQ/PLJ4vef3nlizo8Otz4hfuBHGU0qVtEzOB1T/hU1TNLbYN34A5roDM08GMKjDrBjAWKJjJtlO60JtxXOjrcBwHM3wH1jgKrP4ZsNqewjy6x0AtG4NPAIBpH5QW6LqHQ15LuBCzyETx00Hm7A5fAyd+4baJEy9wgZ5gdGUnqOTKZcnq6+N3bQ9pjmWnTyLJp2p6ikaF9OzJ2F9dFdL5ZToteuVqJHumJ6kz8O3WTUHnWXzqhKQ4TtaoOiXF/PklCyXvYfjSRR1+fU78EkknaODT43HXsIyYGgOf5k5QpOnKtomZfpOO+Np2Bj2fiMD0X/gIfHfUXfdQ0P3n3jksS9zRb7FIvBAV9xSlk72Xpo8l7iUVrGF4SGtpD0RWmSh+Osic0+Fr4MQv3DZx4gUu0BOMruwEfbt1k1/LMd9x2/TQjfbxulp8vWUjXilaip92bkelXh/yuc8uWSApzn0FbnWQ52+0taBH9pSAvfMpGhU+WLsy5PW0h5lHDonu3U9SZ2D20cOdsgZOfMKdII5SurJtYtpB0hFwQ2hp4URM2APe9A+wxtdBzTNALLRMKmJNaO1ZLl2UTuhTLp8pRrbt0kXiLItDWk97YY2vS6b8k/N8p6yBE59w28SJF7hATzC6shP0z03rJauw987N6vDr65qbZYW571hz9kzQ+bZcqEBq1mQkqVXeFw8Pz5sFnaW5w+8FAKwOhzfNPck9POntLU5Hp6yBE59wJ4ijlK5sm1jd7RKiNg1M/1mHX5+sRUHEuY/AZfLPn4jcFejdLxg8Qln/BYhcHX4vAEDO82B1/X0i+e41mDI65fqc+IXbJk68wAV6gtHVnCAiQmnVFXy3bTOGL1skKoZTNCp8siH86rI6SzOyD+zDR+tW4+fdO3ChSTylsMZkDFmg775cGfK1Zxw5hJ/37MTac2fgcHWOA+ShxelAwfGjGFm0DCOLlqHg+FHea50TlIg6QU/9hLue/y2mxsCnfupSf0djga5nm+wgazGY/ksw3WDpFHdrYfjXcJSBGceD6T91R9QN4sdZloYo0Hv4FaeTv3Y5mEkNZsqMSp9zctWCmTLAGl4Ga/oQZNvOe61zgsJtEyde4AI9wehKThAR4aed27wRXilx3itXIymqg3FSW+fdU56sUSHFPdaeOyu6nofmzpRci2f/+O35uSEViuNw4hXuBIkzdepU/P3vf8cf/vAH9OvXD7t27ZI8dvv27ejWrVvAKC8v9ztu+fLl6NGjB66//nr06NEDRUVFYT3vaNOlbBMzg9U/57e/W7Rae/2zIQvigGtYFvnsKU8T/q29A+QMfPlLrhqZfds+6fb6Me29dQ4npuG2KRBul2ITLtATjK7kBO2vrpIUwt2zMnFbfg7+uWk9LuqbwpqfiPDI/DkBe8qT1Bm4JUeNZnugY7Wr8pJXxLc9J0mdgV65Ghy5WtPeW+dwYhruBAWyePFiXHfddcjPz0dZWRk++eQT/OlPf8Lly5dFj/c4QmfPnkVtba13uHyyaPbu3Ytrr70WEydORHl5OSZOnIjf//73KC0tDfu5R4uuZJuYKVNGEPcC0z0AZpoCYuaw5ieXViIinw7WOFpiTao2Rea6+/9c/wSIhWcrOZx4gdsmf7hdil24QE8wupIT9N22zbLR6vXnz7Vr/ov6Jtk0dbEouslmw87KS3h/zUrcPTMPzyyej682b8DEXdsx7/hRGG0t7VoThxMPRNIJuv3Jn3D3c7/F1Lj9SeUCfeDAgXjvvff8PktPT8fXX4sXCfM4QnqZIpUjRozAI4884vfZ0KFD8eKLL4a8rlihK9km6aJwQhQ91MrrUlBzgWxEvO0+ciICczWAWZaCNbworK/xDTDjD2CmSaCWjSDiW5c4XR9um/zhdil24QI9wehKTtAXG9fJCuiP14e/7xwQWqbJzf9q0VLsuVIJIkKV0YA3VhZ6Xxg8PG8Wtl68EKE75XDiC+4E+WO323HttdcGpPl9/PHHGDRokOg5Hkfo73//O2644QY8+OCD2LZtm98x//3f/43MzEy/zzIzM/E///M/Cp50bNCVbBOr7S9fiM0S/r5zAKDmfMk97ay2O5jhJ5DzonCsbQ9Y/eOtKfaNr4umwXM4iQC3Ta1wuxTbcIEeJW688caAPRxfffWV7DlEhLFjx+Jvf/sb/vjHP+K+++7DqVOnFF23KzlBRWWnZQX0+2va147M4XKh//SpkvOnqIU09o/WrsIdM6b5pbV7Utr3XhFPE+JwujKJ4gRVVVXBaDR6h81mE72XmpoadOvWDSUlJX6fT5gwAampqaLnnDlzBtOnT8fhw4exd+9evP/++/jd736HnTtb+2Zfd911WLBggd95CxYswPXXXx/2c+e2qf2wxneDCPRF7ZqfHKeD7Cd370k3Zrb+2zcNXnsHiIXePpTD6Spw29RKPNmlRIQL9Chx4403Yty4cX57OMxm+f1ov/zyC/785z+jsLAQJ0+exAsvvIC//e1vMJlC64UKdC0nyOZ0on+etIBecupEu68R7CVAsHH3zDzoW6wRuFsOJ36IqBP0xE+4+9nfYmrc/sRPooVyxo4dK3ovHkdo7969fp+PHz8eaWlpIT+TJ554Ak8++aT35+uuuw4LFy70O2b+/Pn4wx/+EPqDbgO3Te2HOc7LpKCnglzV7b9G0xchVmaXiLQ3vQ8iXqyUk1hw29RKPNmlRIQL9Chx4403YvLkySEfT0S44YYb8Msvv3g/s9ls+Mtf/oJp06aFPE9XcoIA4HxDA26eOiWgINvTi+dHpB3YFYMhoEic0vHwvFmiBeU4nK5KojhBoUbQw0klFGP8+PFIT0/3/twRqYTcNkUGZlkoLoxNkyI0f6it02SG4buIrIXDiRe4bWolnuxSIsIFepS48cYbccMNN+Cvf/0rbr31VowfPx52GRF34cIFdOvWDUeOHPH7/KmnnsJrr70W8nW7mhMEALVmE37cuQ2DZudj8LxZyD6wDxaHo93zMiJMKtkVUJFd6UhSZ2D20cOKrk1E2FV5Cf/avgVjt2/B7suVinq8XjbokXfoALL278Ox2qtKb53DaReJ4gQpLRL3/vvv+33Wo0cPyWI8Yjz//PN44IEHvD+PGDECjz76qN8xjzzySLuK8XDbFDnIfhSs6QOhKFvDCyDrqoj06iZygNU/E0LrtOCDnOcVXtsq9FU3fAdmygA5KxScSyD7QZA5C9Q8E+TitonTuXDb5E+82KVEhAv0KJGZmYkdO3bg+PHjyM/Px3/+53/izTfflDy+pKQE3bp1Q02Nf4uut99+G0OGDJE8z2az+b1Fq6qq6nJOkBLK63X4ec9OfLt1E4rLT4tG2Q0tLfh26yakZ09plzD3Feivrwi9KJCLMXywdqW3XVz3rExv0TtXCP3Tpx8+gCR1hrdvu+dc3nud01lE0gm64/GfcM8zv8XUuOPx8NuszZw5E2VlZfj000/xpz/9CZWVQsGur7/+GiNHjvQeP3nyZBQXF+PcuXM4deoUvv76a3Tr1g2Fha1/S0pKSnDttdfil19+QXl5OX755Zd2t7PhtqnzIWIg23Yw41gw4ziQrVRUyJOjDKxxdESEuTfdvnlu6Ot0acF0D7rP7SHsZ69NBVmWhHCPdrCmd1r3wdemgdWmtXs/PoejBG6b/IkXu5SIcIEeQcaOHSu698N3HDx4UPTc5cuXo1u3bmhoaBD9vccJunrV/43zW2+9haFDhypeUyI6QTOOHAoQzwPzc6FrbvYe42QMjy+c2+6oue9I1qjwwdrQC9YtOXVCcq7i8tOy5x65WiP5kmDOMWVRfA4nXLgTJM7UqVNx44034vrrr0e/fv38CuuMGjUK9913n/fnX3/9FcnJyfjjH/+If//3f8c999yDtWvXBsy5bNkypKWl4brrrkN6erqfo+SB26bYhcjhI1x9RsPrfnvEyXkJrK63W9xGQpx7CtYtDnmtrOljieungVy18vdpzpZ4sZCqOIrP4YQLt02BRMsuceThAj2C1NfXo7y8XHa0tIj3wa6urka3bt0k3zCFm0bIoxQCF5oaJUXvoNn53mjF+vPnQhbeqQpEvFjPdCleXL5YtL97skaF14qXyZ777dZNoi8XktQZGFowuz2PkMMJGe4ExRbcNsUuQk9zqT3iY73HMcP/KhDnt4Z4XA+QS/zFS8A6ySZz/TRQ8yzZ85n2Holz0yO2L5/DCQa3TZx4gQv0GGH16tXo1q0bLl8Wb8vlKcTz66+/ej+z2+0JX4gnVCbvK5EV0AeqqwAAP+3c7k0plxoD83NQWHYK2Qf2yUfO3f/9eP0aMAX7Dh9fOE9yzmeXLJA99701K0XF/U3qDAyYntOuZ8jhhEpEnaDHxuGepyfF1LjjsXEJ83eU26aOhemelhHQ6SBqcR83OLjgrn8azH4SrP65IMemhZya7oGYUX6d5iz5+6ztJS3QDaHvd+Vw2gO3TZx4gQv0KLB3715kZmbi6NGjuHjxIpYsWYL/+q//wlNPPeV3XFpaml91xV9++QV/+ctfUFRUhJMnT+Kll16KaiubkiuXMXrFctw1Mw8vLl+MDRXn2j1nR/HD9q2yYnrSnl0AgKz9+ySrtveYOgXnGurhZAw2pxO9c7OCprZrSvcqEucA8PPuHaJR8GSNChl7d8uem3twP5LUgeemaFR4b82KsJ8fh6ME7gTFJ13BNhG5QJaFQhE17SAw/WcgR3m75uxImPZu+RR0+37huIYREiniaWANo0FO4SUz2Y8GF/J1fcBs8rakLUQEVv+4xBq6g+wH5O+z4RVItXzj+9A5nQW3TZx4gQv0KHD48GHcfvvt+Mtf/oI//vGPSEtLw9ixY2GxWPyO69atG2bPnu39mYgwduxY3HDDDfjDH/6AQYMG4eTJk4quHSknqLj8tFf4ecTjTeoMTDu0v13zdhQbgqSuTyktASDdVi1Zo8LY7Vu881UZDUHT2pPUGeibl6243Vud2Yz+eVP9RHqSOgM3T52CY3XyVW+brFbclp/jd26yRoXuWZk4Xie/R5DDiRTcCYpPuoJtYvox3r3NrQXJbgHZY7MGB2t6L4hAF7YOkExbNWrZ6p2PLItCSG1PB2v6SPFaybbd/VzbCG3dI2Au+ZcxZCv1Ru791qG9H8QssudyOJGC2yZOvMAFeoIRiT9OdpcL/fKyxfdlZ2WiyWqN4Iojg4sx9J0mvuab1Bk421DvPXbJqRNI1qi8wvYmdQaeWTwfJp8+krUmU8iF5HZcuqh4vVcMBowsWhbwkiA1KxO7Ki/Jnlup1+PNlUXeVPenFxWgtOqK4jVwOOESSSfozkfH4d6nJsXUuPNR7gRFmkj8b4YcJ6RTuhuGR3C1kYM5L0oLae2dIHIBEDIDmP6fPi8d3PvBjRP9Kr4za1EIAt2TPh/YGzkYZCsB097vM0+qMLT3BS8UZ9vpjsK7v5OmD4Oew+FEEm6bOPECF+gJRiT+OB2tvSorSNedD70gWmdypl6Hm6cgkpkQAAAgAElEQVSqA9ar2rsn4NhqoxE5B0vx856d2HKhwtvejIiQuW8P0rMnhyTOb1IrKxDnwcUY7pqZ593H7htJHzA9Bw6XK+gcVocDRptyB4zDaS/cCeIoJSIC3ZwNuUJqxMwRXHHkYM3z20SWU8Fqe4DapKELfcSPgJlUYKYpIEdrVw9iBnc0PvQWbOE8D3JWSEfl9Z+HNgczevfWczidCbdNnHiBC/QEIxJ/nE5p62QF6ZYLFRFccWTYe+UyPlm/Bu+uXoF3V6/AqOJl+HzjOuy5UqloHrFWbXIjRaPya+MWKlLt0jxjw/lzWHmmDMXlZWiw8PRATmzBnSCOUiIj0PMk9zmz2lQQxVZ2F5ELzLIYrOkDsKZ/gDW9C9bwJphxAsipLPNK6I8eapX3VLD6J8NbszlL5jo9wBznQZZCUMsWENnDugaH01Fw28SJF7hATzAi8ceJEeGeWdMD9monqTPQM0cDq8MRwRW3D6vDgacXzw8QuPfNyYfOokw4MyLclp+jSKD/6i4+p5S9Vy4HEf6tlea7Z2Vi+mH5Aj0cTmcSUSfokXG498lJMTXufIQ7QZEmIgLdeUk6utv4VgRX236Y4zxYXf/Ateo/9et/HgrkOBdy1Nz7ssIWmDkW0rr///buPTqq+t77eI4YUGmP53i0tnqUayAoSkXFOxeJgNVVW9un1vpYqtKj9lFBsRW1iliw1JNgEwioiKgUxBbwhgiC3BREVMBb8MY1QhJIyP2e/fs8fxACQ2Yie7J39t6z36+1fovlMJn9nSmdz/ebfSv73/2D+JFsJ//8povcAX5ANiEoGNBDxqkL8azduUM9pzzRdB5298Zzthd++YVDlTrj5lcXxBxy733rTVuvVVZTY2s4PzP776o/gkPRo6morY16OH5La0Uc57oDbqAJgl2OXcW9PPuQ87Qbz3XO7ydTv82ZQh1gTJWs/L6xDz2vet3e61W/aW9AL4p9f/rv3FbNWhvb6ikrv4+MVRz39gAnkU0ICgb0kHHyNmvbi4s1YfUK3fTKfD20fKk2793jQIXO+bastMWBtsfkSbZugWYZoz5PtnxrtcNXUVX8h5/P3PhR08Xh9h+hEPnn4YfS3/zq/Li3BTiJJgh2OZlNpvb9/VdzLxohU54t01DoQIXOMZXzvmOA/r2916v71N6Avvcn8ddujKyiEYed6x7rtILGvfUVL8S9PcBJZBOCggE9ZJxsgvxu5bat3zlAH8nF1g416b13m66O/l3rrGlZqrfsHap4uEVff6mfvzRbfaZN1k9fnKWBzz0Tc3tDZs1s1bYApzjZBF089FH1v/pxX62Lh9IEOS1M2WSVTmh5gC683tbr7b9H+bVHeA56qqx9f2hV/cbUypRPk7Xncln558kq+p8WttdLVtnfWrU9wClkE4KCAT1kwtQEfVm4t8UB+qrZ9n+rX9fQoPuWLo4Y0rs2rsPPx//fNe989wva9ODypVFv79Y9K0OjFr/h+PaAeNAEwa4wZZOpeLblIbos2/5rNuTJ2vvzI9qDbmrWOft+jJFVMKCFQ/ZfdnR7QLzIJgQFA3rIhKkJkqRrX5odc0Bfvys37tf9trRUC7/8Qmt27tAn+Xm67NmnI4bzP771pu2980fiq8JC9Zg8qdkvCLpnZejTgnzHtwfEgyYIdoUpm4xVJCuvd4wLq/WN+5xtY4xM3ccyVQtl6jbLVM6XlX/2Ia9/lkzliw6/m8ZtV74YfW99Qf+47rcOuIFsQlAwoIdMmJogScorL9OwfzwXMZj3npqppQ7fCs4yRutyd2rR11/qW5c/2zU7d2jAc9Ob3s+lzz6t5du2uLpNwA5Hm6Arxqn/T/7mq3XxFeNC9T3aFsKWTaZmbfMLxRVcIat+l7PbsSpkqt/ef9szF+8Db4yRqXhGVv45EYfqm/qdrm0TsItsQlAwoIdM2JogaX/j8P63uXrps0/0/re5MjYuDOdXxhh9XVSoLwv32rrQHdAWaIJgVzizqUam+i2Zynm+usp8axhTLVP3uUzDt16XAjRDNiEoGNBDJoxNkN9V1dXpo9279EXh3oT45QFAEwS7yCb/MQ17ZWo/lGnI87oUwBFkE4KCAT1kaIL85dmNH6n31IP3Ox8ya6Y+31PgdVlAqzjaBKWNU/8r/+ardXEaTZDTyCb/MKZaVvEfD7l9Wg9Z+26XsfjfBsFGNiEoGNBDhiaodYwx2rKvSF8XFbb60PJXvshpduG6blkZ6vPkZO2rqnKoYqDt0QTBLrKpdYyp2X9huIbdrX6tyOH8kAu+FQ1vfaGAh8gmBAUDesjQBMXvvdydGvT8wfuQX9bKi7MN+8dzUe+p3jUzXc9s+NDByoG2RRMEu8im+Oy/ONtzkRecK7xepn5HfK/XsCfKcH7ILdPqvnT4HQBth2xCUDCghwxNUHy27CtSzylPRL292Sdx3t6sx+RJUW//ljJ5ksYsW+LwOwDajpNN0CVp4zRg2N98tS6hCXIc2RQfU/nPFm5vVm3/9WrXt3wP9epFLrwLoG2QTQgKBvSQoQmKz8Mrlql7VkazYbp7VoZGvrkwrtc89FZphx/mPmX9ew6/A6Dt0ATBLrLJPmOMrD2DYg/TVQvsv2bDty0P6HUfu/BOgLZBNiEoGNBDhiYoPr94aU7UYbpLZrrSXng2rtd8ftOGKIe3Zyh1yhPKKy9z+B0AbYcmCHaRTfYZU9PCMN1LVunEuF7XKhqxfy/84Xvl9/6MO40g0MgmBAUDesjQBMVn5JsLo+5B75aVod+9Mi+u17SM0fjVK9TtkNft+9QUvbNju8PVA23L0SZo8CMaMHSir9Ylgx/he9RhZJN9xhhZ+efFGNB7yFQ8H9/rWsWyCm+IfL2913C7NQQe2YSgYEAPGZqg+Lz/bW7MPehvb43/QnGSlF9eroVffqEV27aqtqEh6nMsY/T+t7l67cvN+qqwsFXbA9xGEwS7yKb4WGV/338btMOGcyvvLBlrX6te29R9LlP1ukztpph7zo2pkql+W6Z6kUwD2QR/I5sQFAzoIUMTFL/nN22IuLBb96wMTfvgfde3u7V4n9JeeDbilwI3vzpfFbW1rm8biAdNEOwim+JjTJ2s4nsiB/T8c2Vq3L+OialeIiv/nIjD6k35ZA6Dh2+RTQgKBvSQoQlqnX1VVXp5c44W5HyuPZUVrm+vwbI0YOb0ZofXd8vK0OglXE0X/uRkE3Tp5Y9o4JCJvlqXXk4T5DSyqXVM/Tcylf+SqV4iY2raZHv7z1M/fO99ikzVa65vH4gH2YSgYEAPGZqgYFm1fVvMQ+u7Z2WouLrK6xKBZmiCYBfZFCxW6WNRLiTXeHh94S+8Lg+IimxCUDCghwxNkHPqLUvfFBVqd5l7V1yf9fHGmAN6l8x0fVm417VtA/GiCYJdZJNzjFUhU/+1jFXi2jasottiX0E+/wLXtgu0BtmEoGBADxmaIGe8vDlHF0yf1jQoX/vSbH1d5OwFcj4pyNcFz0yLOZz3nPKEyjkPHT7kaBM06BENvGKir9alg2iCnEY2tZ4xdbJKJ8rK633w1mjFf5Kxyp3dTuU/ZeWdEWNA7ymr8P86uj3AKWQTgoIBPWRoglq2KT9PE99dpQmrV+jdndujXuzm7a1boh5ufu5T2SqprnakjpLqavV5cnLELdgi75eerr+sWuHItgCn0QTBLrIpNmPq91+QrXSCrLK/y9RHv3OIVfqXKOeE95RVNMK5WmrWtHDv9cZz0GtWOrY9wElkE4KCAT1kaIKiM8boL6uWNw3bKVn7r9b+P6+/orrDbn127Uuzow7OXTPT9cyGDx2p5/lNG9S1hUPbH16xrFldgF/QBMEusik6Y5XL2vuLpqukH7gw2+H3ODdWcePfxxia675ypB6r6Pcxzj1PkZV3pkzlPEe2A7iBbEJQMKCHDE1QdMu3Nd8rfmA9v2lDxHPPyP57zIu23fvWm47UM27VcqUccku3w5fFbWzgY042QZcNHKtBaX/11bps4Fi+Rx1GNkVnlY7fvxc8ysXYTP03Tc8ztRtb3qvt0JXVrT2DY2+n8AZHtgG4hWxCUDCghwxNUHR3Lnq92a3MDuwVv3rOCxHPHfjcMzEH9P9d844j9bS0B/3iGU85sg3ALTRBsItsis7K7xtjIE6VVfZE0/NMw66WB/Ta952pJ+Ye9FRZJQ85sg3ALWQTgoIBPWRogqL77cvzYu6tvmzm0xHPnbHhw2bDc9fGAX17cbEj9bR0DvrMjR85sg3ALTRBsItsas4YE2PveePh7qXjIp5vFd0cZXhOlbXnChljOVNT1HPQe8jK6ylTt9mRbQBuIZsQFAzoIUMTFN2U9euiDsPdszJ039LFEc9tsCw98PZbEc/rlf13vfHVl47W9ElBvvrPnN60jZTJk/T4mtVRL1wH+ImjTVD/sRp0+V99tS7rTxPkNLIpOqvw+phDuql6I+K5pmGvrL0/i3zenoExLyoXL1P5T1n5Pz7ktmrny1S/5eg2ADeQTQgKBvSQoQmKbl9VlS58ZlrEYe7dszJ05tRMbdlXFPVnthbv05xPP9YrX+SorKbGlbosY7Rh9y6t3LZV+6qqXNkG4DSaINhFNkVnat9vHNAPHdJ7ytr7UxlT1/z5xsjUrpepnC1Ts1LGuHMxUWOqZGrelalZJ2O43SeCgWxCUDCghwxNUGzflpVq5OKF6jH5CXXLytDNry7Q5r17vC7LETX19dpZUsJ909EmaIJgF9kUm6lZJ6vwuv2HkuefLav0ERkrMT4nY5XJ1O+M+ssGwGlkE4KCAT1kaIK+mzEmYa6SbhmjzHVrdda0rKbD5O9bulgVDOpwkZNNUP/LHtblgx7z1ep/2cN8jzqMbPpuxlgJc4qTsfbJKh518MiA/PNlKmYmzPuDP5FNCAoG9JChCQqXjLXvNjuvvltWhn73CveqhXtogmAX2RQexliy9v486tXgD7+/O+AksglBwYAeMjRB4VFRW6teMe7Z3iUzXZ/vKfC6RCQomiDYRTaFh6l5N/Yt4QoukDH1XpeIBEU2ISgY0EOGJig8PivIjzmcd8lM10uffeJ1iUhQjjZBlz6sywc+5qvV/1KaIKeRTeFhyp9u4fZxKTINeV6XiARFNiEoGNBDhiYoPPLLy5vdr/3QtWLbVq9LRIKiCYJdZFN4mKoFsfeg5/WSsSq9LhEJimxCUDCghwxNkH9tK96nTfl5qqpz7mq2N786P+LWcQfOQb/omSdVb1mObQc4FE0Q7CKb/MmYBpm6z2XqvpAxzmSGsSpk5feNshe9p6zi+xzZBhAN2YSgYEAPGZog/9myr0jXvDiraYDuPTVT0z/6wJGr2e6prNBPZj/fNJh3yUzXeU9P5fxzuMrRJuiSh3T5gAm+Wv0veYjvUYeRTf5jqpfIKrj44AC9Z5BMzVpnXrt2feOQnnJwUC/8tYxV5sjrA9GQTQgKBvSQoQnyl8q6OvWbPq3ZXu4umema69A54pYxemfHdj2z4UO98dWXqqnnAjxwF00Q7CKb/MXUbmwcnHscsoe7h6y8M2TqtzizDVMlU/W6TMWzMrXrucUaXEc2ISgY0EOGJshf5n72ScxzxPvPnO51eUBcaIJgF9nkL9a+O6PeBs3KS5VVOs7r8oC4kE0ICgb0kKEJ8pdHVy1XyuRJMYd0zhNHEDnZBA24+CEN7j/BV2vAxTRBTiOb/MXakxb7Qm6Fv/G6PCAuZBOCggE9ZILeBFXW1Wl+zmeasv49LdvyTeAH2BkbPox5pfXznp7qdXlAXGiCYFfQs8k05MlUPC9T/pRM3Wdel9NqVtFNMW6FlsqF3BBYZBOCggE9ZILcBG3K260fPzlFXTLTm87ZTnvhWeWXl7dpHV8W7tVj76zU6CWL9PymDSqrqYn7tYqqKnVG9t+bLuB2YHXNTNeU9escrBpoOzRBsCvI2WQq/3HI+dqNQ23x3TKm7a73YYyRqVklq+TPskoekKleKmMa4n+96uUx9qD3kKnd5GDlQNshmxAUDOghE9QmqLahQedPn9pskO2elaEbX/5Xm9Xx4qcfq2vjdrtnZahrZroumvGkvo3xeZbX1mrZlm+0bOs3qqitjfqcdbk7de5T2RHD+ZhlSwJ/dADCy9Em6KI/a/Bl4321Blz050B+j/pZULPJ1H0e81BwU/Fs29RgGmQVjzq4h/vAueNFI2RM9NwxDbtkqhfL1L4f8/ZppuIZWXm9DnlPvWUq2y5vAaeRTQgKBvSQCWoTtGzrNzHP0+6Sma68cvdvzZJfXh71auvdszI04rUFzZ4/99OPdUb235ued2Z2pv75+adRX7u2oUHLt23Ry5tztLOkxO23AriKJgh2BTWbrNJHY1xMLUXWniFtUoOpei32Lwkq/xH5XFMnq+T+yKuz7xkoU/d59Ne29slULZSpflPGatuj1QCnkU0ICgb0kAlqE/RSC1c775KZrpw2uK/3zI0fxTxfvGtmusoP2UO+LndnzOd9sOtb12s9EmU1NXpmw4e6+dUFuvPN17Vsyzfc5gaOoAmCXUHNJqt4ZIxztVNk5Z/bNjUU3RKjhh6yCn8Z+dyyJw67dVrjXvf8fjJWZZvU+11M/Q5ZpRNlFY2QVTpWpu4Lr0tCgiCbEBQM6CET1CZo8949MYfzM6dmqqquzvUasteva3aI/aGrsPJgc/OHN16Nubf9zkWvu17rd9lbWakBM6c3/cLhQK0Pvv0WQzpazckmaOAFf1baJeN9tQZeQBPktKBm0/7DwA8feFP2D8xFt7RJDVbh9bGvuL73JwdrNfWy8s9pYW/7/DaptyWmZp2svDMPOSohVVZeT5mqhV6XhgRANiEoGNBDJqhNkCT9/rWXow7Ik99/r022vylvd8y94le88GzEYHvl7OdiDvI/fXFWm9Tbkj8vXxr1FwhdMtO1Lnen1+Uh4GiCYFdQs8lYJbIKLjrsMPf9F4sztR+2TQ3l2bGvuF7618haYw3yeb1klf29TeqNxRhL1p6BUX7h0UNW/o99s4cfwUU2ISgY0EMmqE2QJFXX1+mRlW8rdcr+87r7PjVFT3+0vs32+BpjdNvCVyMOc+/WeKG4t7duiXjuyDcXxtyDfu9bb7ZJvS3p8+TkqMN5StYkjV2xzOvyEHA0QbAryNlk6nc0Hmbeo2mvtalZ3Xbbt/bJKuh/2C8JUmUVXCDTkHfweaZBVn6/2HvQq7w9uqulC+5ZeSky1WQTWodsQlAwoIdMkJugA2rq67WnosKTq5zXNTRo6gfrdOmzT+uM7Ez9Zv5Lei/KHudN+XlRb53WLStDnxbkt3ndhztzambMAf2Bt9/yujwEnKNNUL8HlXbxX3y1BvZ7MPDfo36TCNlkrHIZq8iT04RMQ4Gskodk5Z8nK7+vrOL7ZOpzmz+v/Knoe9oLLo15xfe2Ymo3fceA7v0vtxFsZBOCggE9ZBKhCQqKN7/+Suc+ffD2aec9PVVvffO112VJku5Y9FrMQ9yXfPOV1+Uh4GiCYBfZ1DaMsWSVpTee533gPPWfydRv87o0GVMrK//8mIfgG2uf1yUi4MgmBAUDesjQBLWtuoYGfbR7lzbs3uWr+5pv2Veks6dlRQzpXTPTdcP8l9TgozoRTDRBsItsalvGKpGpXS9T749fGh9gql455OJwKU3n1pvyp7wuDQmAbEJQMKCHDE0QDtheXKz7ly3Rpc8+paGzZuqpD9erpr7e67KQABxtgs5/UGkX/cVXa+D5NEFOI5twgKlZu/+c/oLLZBXeIFO92OuSkCDIJgQFA3rI0AQBcBtNEOwimwC4jWxCUDCghwxNEAC30QTBLrIJgNvIJgQFA3rI0AQBcJuTTdCg8x7QFRc+6qs16LwH+B51GNkEwG1kE4KCAT1kaIIAuI0mCHaRTQDcRjYhKBjQQ4YmCIDbaIJgF9kEwG1kE4KCAT1kaIKaK62p0cR3V+miZ55U36em6J4li7S1mPutAvFytAk6935dccE4X61B597P96jDyKbmTP3Xsorv3n9v8IL+ssomyVgVXpcFBBbZhKBgQA8ZmqBI1fV1unL28+p2yP3Au2dl6OxpWdrGkA7EhSYIdpFNkUzdV7Lyzz7kfuCN9wQv/KWMqfW6PCCQyCYEBQN6yNAERZr72SdNg/mhq3tWhv741ptelwcEEk0Q7CKbIln77jxsOD+4TNXrXpcHBBLZhKBgQA8ZmqBIdy56PWLv+aHrvKenel0eEEiONkF979cV54/z1RrUlybIaWRTJCv/x1GHcysvVVbJGK/LAwKJbEJQMKCHDE1QpHvfelPdYwzol8182tFt7Swp0cyNH2nGhg85xx0JjSYIdpFNkaz8C2IP6KVjHduOMUam9kOZiukylf+UsUoce23Ab8gmBAUDesjQBEVauW1r1OG8W1aGMta+69h2MtetVdfMdHVtfO0umema+O4qGWMc2wbgFzRBsItsimSVTth/znm0Q9xr1zuyDWOqZBX97uD57XkpsvJ6y1Qvc+T1Ab8hmxAUDOghQxMUyRij+5ctaTrv/MDw/NMXZ6m81pkL8cT6JUCXzHQt+vpLR7YB+ImTTdDl54zRkPMe8dW6/JwxfI86jGyKZKwSWXuvOmR4bjwfvXS8Y7/Yjf5LgB6y8s6QadjryDYAPyGbEBQM6CFDE9ScMUard2zTfUsXa+TihZqf85lq6usde/3bFr4S9TD6blkZuvHlfzm2HcAvaIJgF9nUnDHVMpX/lFV8j6ySB2Vq3nNsODfGkpXfJ8Zh9D1kKp51ZDuAn5BNCAoG9JChCWp71740O+Ye9CGzZnpdHuA4miDYRTa1LWOqYwznKbLyeskqe9zrEgHHkU0ICgb0kAlDE1RTX6/3cndqXe5OR/eEx+vRVcuj7kHvnpWh+5Yu9ro8wHGONkE/HqMh54711br8xzRBTgtDNhmrSKbmXZm6zz2//ogxRtaeKxoPaY9ynnv1Ik/rA9xANiEoGNBDJtGboFe/yFGfJyc3DcHnPDVFb3z1hac17Sgp1pnZmRG3c+uWlaHUKU/o66JCT2sD3EATBLsSOZuMaWg83/uQ+5rv+YlM/Tfe1lX1evSrxO8ZKmPqPK0NcAPZhKBgQA+ZRG6CPtq9S11jXJH94/w8T2v7pCBfPz/kUPefvjhLH+7+1tOaALfQBMGuRM4mU54dfRAuuFjG1HhbW9UCWQWXHbwY3b47uEAcEhbZhKBgQA+ZRG6C7lj0esxDyUcvif9wvdqGBr28OUejFr+hPy59U8u3bYn78MTCykrtrayMuxYgCBxtgvrcpyF9H/bVurzPfQn7PeqVRM0mYxpk5Z8X83xvU/Va/K9tFcmUPy2reKSs0gkydfHdFcQYS6YhT8Yqj7sWIAjIJgQFA3rIJGoTJEnD/vFczIuxXfPirLhes6quTr/855ymQf/ALwBGLX5DFvcwB6KiCYJdiZpNxir+jouxZcb3uvVfy8rv13gO+YHbsPWQqZzv8DsAEgfZhKBgQA+ZRG2CJOkPb7wWcw/6qMVvxPWa2evXRT1svktmuhZ/85XD7wBIDDRBsCtRs8mYeln5fVvYg/5yXK9rFV4feU77IUO/sYocfhdAYiCbEBQM6CHjxyaouLpKf1m1Quc/PVV9npysUYvf0NbifbZfZ/2u3KjDdNfMdG3M2x1XbVfMejbqcN4tK0N3LIr/0EQgkTnaBJ11n4b8+GFfrcvPoglymh+zydRtlrXv/+0fsAsukVWWIWNV2H4dqywzytXSU2UVXChjqu3X1bC3hb3yKTKV/7T9mkAYkE0ICgb0kPFbE1RZV6crXng2Ys9396wM9Zk2WduLi22/3vycz9R7albTa509LUuvfJETd32XPvt01AG9a2a6bnltQdyvCyQymiDY5bdsMnWfy8rrfdhe6p6yCn9p+wrnxtTLKhnbeCj6gau4XxH/OeP1uS0M6D1kKl6I63WBREc2ISgY0EPGb03QCx9vjLrXuzX3CK+qq9Pq7du0esc2Vde37lYxDy1fGvWw+a6Z6Xpu00etem0gUdEEwS6/ZZO179YYh5CnyFTFd8qUaSiQqV4uU7upVfdBN8aStWdQ7HuYe3z7NsCvyCYEBQN6yPitCbp14Ssxz/G+8JknvS5P35aV6pynpkQM6d2yMpT2wrOqqK31ujzAl5xsggb3/pOG9nnIV2tw7z/56ns0Efgtm6y8s2LsoU6VVfJnr8uTqX6rcUBPbdpzbuWlyCp50OvSAN8imxAUDOgh47cm6O7Fb0TdQ90lM12Dnn/G6/IkSTtLSnTf0sU69+lsXfjMNE1YvULF1VVelwX4Fk0Q7PJbNsW+NVqqrNIJXpcnSTI178kq+q2s/HNl7RkmUzFLxlhelwX4FtmEoGBADxm/NUFvb90S8yJsk99/z+vyAMSBJgh2+S2brNK/xD7EvXaT1+UBiAPZhKBgQA8ZvzVBxhiNWbak2X3Gf/HPOaqqa9354wC84WgTdOYfNfTsP/tqDT7zj776Hk0Evssmq0TW3qsO7jU/MKyXpXtdGoA4kU0ICgb0kPFbEyTtH9Lf2bFdD7z9lkYvWaTXvtysuoYGr8sCECeaoOiys7PVuXNndejQQX379tXq1atjPnf+/PlKS0vTiSeeqO9///u68MILtXhx5IUzZ86cqaSkpGarutr+rbu85s9sqpGpnCer+F5ZpWNlaj/0uiQArUA2NUcu+RMDesj4sQkCkFhogpqbO3eukpOTNX36dOXk5GjkyJHq2LGjduzYEfX5I0eO1N/+9jetX79eX331le6//34lJydrw4YNTc+ZOXOm/v3f/115eXkRK4jIJgBuI5sikUv+xYAeMjRBANzmaBN0xr0aetaDvlqDz7jX9vvr16+fbrvttojHUlNTNWbMmCN+jTPOOEPjxo1r+u+ZM2fq+OOPP+Kf9zOyCYDbyKZI5JJ/MaCHDE0QALfRBEWqra1Vu3bttGDBgojH77rrLvXv3/+IXsOyLJ122ufi8xYAABznSURBVGmaPHly02MzZ85Uu3btdPrpp+vUU0/VVVddFbEnI0jIJgBuI5sOIpf8jQE9ZGiCALgtLE1Qbm6uSktLm1ZNTU3U97Jr1y4lJSVpzZo1EY9PmDBBPXr0OKLP4/HHH9cJJ5yggoKCpsfee+89zZo1S5s2bdLq1av1i1/8Qscee6y++uqruD93r5BNANxGNh1ELvkbA3rI0AQBcJujTVCv0Rra+wFfrcG9Rke9CM7YsWOjvpcDjdDatWsjHh8/frx69uz5nZ/FnDlzdNxxx2np0qUtPs+yLPXp00d33nnnEX/OfkE2AXAb2XQQueRvDOghQxMEwG1haYKOdA96aw4lnDt3ro499lgtXLjwiD63ESNGaNiwYUf2IfsI2QTAbWTTQeSSvzGghwxNEAC3haUJsnuRuNtvvz3isV69erV4MZ45c+bomGOO0csvv3xE2zDG6LzzztNNN910xHX5BdkEwG1kUyRyyb8Y0EOGJgiA2xxtgnqO1tAzHvDVGtzT/oB+4HY2M2bMUE5OjkaNGqWOHTtq+/btkqQxY8boxhtvbHr+nDlzdPTRRys7OzviVjUlJSVNz3nkkUe0ePFibdmyRRs3btRNN92ko48+Wu+//37cn7tXyCYAbiObIpFL/sWAHjI0QQDcRhMUXXZ2tjp16qT27durb9++WrVqVdPfDR8+XAMGDGj67wEDBkQ9l3D48OFNzxk1apROP/10tW/fXieddJKGDBnS7HzCoCCbALiNbGqOXPInBvSQoQkC4DaaINhFNgFwG9mEoGBADxmaIABuc7IJSutxj4b1ut9XK63HPXyPOoxsAuA2sglBwYAeMjRBANxGEwS7yCYAbiObEBQM6CFDEwTAbTRBsItsAuA2sglBwYDugRUrVkS9yEJSUpLWr18f8+eGDx/e7PkXXHCBrW3TBAFwm6NNUMrdGpY6xlcrLeXuhPweJZsAJDKyCUHBgO6B2traiNsT5OXlacSIEercubOMMTF/bvjw4Ro2bFjEzxUVFdnaNk0QALfRBAUT2QQgkZFNCAoGdB+oq6vTD37wAz366KMtPm/48OG65pprWrUtmiAAbqMJSgxkE4BEQjYhKBjQfWDevHk66qijtHPnzhafN3z4cB1//PE66aSTlJKSohEjRqigoMDWtmiCALjN0Sao2ygN63Gfr1Zat1Gh+B4lmwAkErIJQcGA7gNXXnmlrrzyyu983ty5c7Vw4UJ9+umneu2119SnTx+deeaZqqmpifkzNTU1Ki0tbVq5ubn8nxeAq2iCEgPZBCCRkE0ICgZ0B40dOzbmBXYOrA8++CDiZ3Jzc3XUUUdp3rx5tre3e/duJScna/78+bZr4v+8ANxCE+QvZBMAkE0IDgZ0B+3du1ebN29ucVVXV0f8zKOPPqqTTjpJdXV1cW2ze/fumjhxYsy/Zy8FgLbmaBPUdaSGpfzJVyut68hAfY+STQBANiE4GNA9ZIxRly5dNHr06Lh+vrCwUB06dNDzzz9/xD/DeX4A3EYTFGxkE4BERDYhKBjQPbRs2TIlJSUpJycn6t/37NlTCxYskCSVl5dr9OjRWrt2rbZt26YVK1booosu0qmnnqqysrIj3iZNEAC30QQFG9kEIBGRTQgKBnQPXX/99br44otj/n1SUpJmzpwpSaqqqtKQIUN00kknKTk5WaeffrqGDx/+nVfXPRxNEAC3OdsE3aVh3f/oq5XW9a6E/h4lmwAkIrIJQcGAHjI0QQDcRhMEu8gmAG4jmxAUDOgh49cmqKK2VpPee1f9Z07X+dOnavSSRdqyr8jrsgDEgSYIdvk1m0z9dlnF98kquEhWwUBZZU/IWOVelwUgDmQTgoIBPWT82ATVNjToZ3P/oW5ZGeqSma4umenqnpWhs6ZlMaQDAeRoE9TlTg3rdq+vVlqXO333PRp0fswmU79dVn5fWXmpsvJSGldPWXt/LmNqvS4PgE1kE4KCAT1k/NgEvbw5p2kwP3R1z8rQyMULvS4PgE00QbDLj9lkFf/psOH84DJVC7wuD4BNZBOCggE9ZPzYBI1eskjdD9l7fujq8+Rkr8sDYBNNEOzyYzZZ+f2iDudWXqqs4nu8Lg+ATWQTgoIBPWT82AQ98PZb6p41KeqAfv70qV6X16I3v/5KV81+Xt2zMnTBM9M0Zf061TU0eF0W4ClHm6BOd2hYl9G+Wmmd7vDd92jQ+TGbrILLYg/oJfd7XV5MxtTJlE+VVXDJ/lr3/lSmeonXZQGeI5sQFAzoIePHJujdndtjHuI+YfUKr8uLaV7OZ+qSma6uh9TcNTNdoxa/4XVpgKdogmCXH7PJKnt8/znn0Q5xr3nH6/JisorvlpXX45B6ezQelv+y16UBniKbEBQM6CHjxybIGKMHly9tGsq7NQ67Q2fNVEl1tdflRVVvWeo3fWrUXyx0yUzXl4V7vS4R8AxNEOzyZTZZZbL2Xn3w4nAHzkcveUDGGK/Li8rUfRljr3+KrIKLZQxHeCG8yCYEBQN6yPixCZL2D+mrt2/TvW+9qTsWvaY5n36sqro6r8uKaWvxvpjDeZfMdL3w8UavSwQ842gTdPofNKzz3b5aaaf/wZffo0Hm32yqlql8SVbxXbKK/yRTs8q3w7kkmYpZh+09P2zPf/12r0sEPEM2ISgY0EPGr01Q0BRUlLc4oL+8OcfrEgHP0ATBLrLJGabq5dh70PNSZBo4ugvhRTYhKBjQQ4YmyDnXz3up2dXnu2am64zsv6uspsbr8gDP0ATBLrLJGcYqk5V3VpS96Kmyim70ujzAU2QTgoIBPWRogpyzvbhYFz4zTV0y05UyeZK6ZWUoZfIkLfnmK69LAzzlaBN02u0a1mmUr1baabfzPeowssk5pnqJrLxejefN92o8//wSmfodXpcGeIpsQlAwoIcMTZCzKmprNfuTTXpw+VJlvb9W35bxuQI0QbCLbHKWadglUz5FVsnDMpUvylgVXpcEeI5sQlAwoIcMTVDbWfT1l/rFS3N03tNT9at/zdWyLd94XRLQJmiCYBfZ1DaMqZUpf1LWniGyCi6SVXyPTB1HfSEcyCYEBQN6yNAEtY2nP1qvLpnp6tZ4jvqBP2dxdXeEgKNN0Km3adhpI3210k69je9Rh5FN7jPGklX0u8POT0+VlXeWTN3nXpcHuI5sQlAwoIcMTZD7Smuq1XPKE1Gv7t57aqavbx8HOIEmCHaRTe4z1ctjXN09VVbRCK/LA1xHNiEoGNBDhibIfW9v3dLiLdjey93pdYmAq2iCYBfZ5D6r9C8HLxoXZUj38/3dASeQTQgKBvSQoQly3zs7trc4oG/YvcvrEgFXOdoEnXKrhv33Xb5aaafcyveow8gm91lljzce0h5tQD/b6/IA15FNCAoG9JChCXJfbUOD+j41RV0PG8y7ZmboohlPqsGyvC4RcBVNEOwim9xn6j6JfYh78RivywNcRzYhKBjQQ4YmqG28vXWLUiZPUvesDHXNTFf3rAz1nPKE1uzkPrRIfDRBsItsahv796IfuDhcj/1rzyCZhj1elwa4jmxCUDCghwxNUNvZWrxPj72zUrcufEUT312lnSUlXpcEtAlHm6Af3aphp97pq5X2I5ogp5FNbcMYI1PznqySMbL23SFT8byMVe51WUCbIJsQFAzoIUMTBMBtNEGwi2wC4DayCUHBgB4yNEEA3EYTBLvIJgBuI5sQFAzoIUMTBMBtjjZBP/wfDTvlDl+ttB/+D9+jDiObALiNbEJQMKCHDE0QALfRBMEusgmA28gmBAUDesjQBAFwG00Q7CKbALiNbEJQMKCHDE0QALc52gT9YISG/fAPvlppPxjB96jDyCYAbiObEBQM6CFDEwTAbTRBsItsAuA2sglBwYAeMjRBANxGEwS7yCYAbiObEBQM6CFDEwTAbY42QSfdomEn3+6rlXbSLXyPOoxsAuA2sglBwYAeMjRBANxGEwS7yCYAbiObEBQM6CFDEwTAbTRBsItsAuA2sglBwYAeMjRBANzmaBN04s0a9oPbfLXSTryZ71GHkU0A3EY2ISgY0EOGJgiA22iCYBfZBMBtZBOCggE9ZGiCALiNJgh2kU0A3EY2ISgY0EOGJgiA2xxtgk64ScNOvNVXK+2Em/gedRjZBMBtZBOCggE9ZGiCALiNJgh2kU0A3EY2ISgY0EOGJgiA22iCYBfZBMBtZBOCggE9ZGiCpA27d+muNxfq6jkv6K43F2rD7l1elwQkFCeboMH/OVxD/+v3vlqD/3N46L9HnRb2bDLGkql6VVbRcFl7fyar9K8yDbu9LgtIKGQTgoIBPWTC3gS98kWOumamq3tWhro0/tk1M12vfpHjdWlAwqAJgl1hziZjjKziMbLyUmTl9Wz8M1VW/nky9Vu8Lg9IGGQTgoIBPWTC3ATV1Nfr7GmT1SUzvdnqM22yaurrvS4RSAg0QbArzNlkaj9qHMoPX6my9t3udXlAwiCbEBQM6CET5ibo3Z3bow7nB9aanTu8LhFICI42Qf/xWw39zxG+WoP/47eh/R51S5izySp7fP8wHmNIN8byukQgIZBNCAoG9JAJcxPEgA60DZog2BXmbGJAB9oG2YSgYEAPmTA3QRziDrQNmiDYFeZs4hB3oG2QTQgKBvSQCXMTJHGROKAtONoEHX+jhv7HLb5ag4+/MdTfo24Iczbtv0jc/VwkDnAZ2YSgYEAPmTA3QQdwmzXAXTRBsCvs2bT/NmuvHXKbtYncZg1wGNmEoGBAD5mwN0EA3EcTBLvIJgBuI5sQFAzoIUMTBMBtjjZB379BQ//9Jl+twd+/ge9Rh5FNANxGNiEoGNBDhiYIgNtogmAX2QTAbWQTgoIBPWRoggC4jSYIdpFNANxGNiEoGNBDhiYIgNscbYK+9xsN/f7vfLUGf+83fI86jGwC4DayCUHBgB4yNEEA3EYTBLvIJgBuI5sQFAzoIUMTBMBtNEGwi2wC4DayCUHBgB4yNEEA3OZkE3T5cb/WkI6/9dW6/Lhf8z3qMLIJgNvIJgQFA3rI0AQBcBtNEOwimwC4jWxCUDCghwxNEAC30QTBLrIJgNvIJgQFA3rI0AQBcJujTdCx12nIcTf6al1+7HV8jzqMbALgNrIJQcGAHjI0QQDcRhMEu8gmAG4jmxAUDOghQxMEwG00QbCLbALgNrIJQcGAHjI0QQDc5mgT1OFXGnLM//XVurzDr/gedRjZBMBtZBOCggE9ZGiCALiNJgh2kU0A3EY2ISgY0EOGJgiA22iCYBfZBMBtZBOCggE9ZGiCALjN0Sao/f/RkA6/8dW6vP3/4XvUYWQTALeRTQgKBvSQoQkC4DaaINhFNgFwG9mEoGBADxmaIABuowmCXWQTALeRTQgKBvSQoQkC4DYnm6BBR/9SVyRf76s16Ohf8j3qMLIJgNvIJgQFA3rI0AQBcBtNEOwimwC4jWxCUDCghwxNEAC30QTBLrIJgNvIJgQFA3rI0AQBcJujTVC7a3XF0df5ag1qdy3fow4jmwC4jWxCUDCghwxNEAC30QTBLrIJgNvIJgQFA3rI0AQBcBtNEOwimwC4jWxCUDCghwxNEAC3OdkEDfy3nyvtqF/5ag38t5/zPeowsgmA28gmBAUDesjQBAFwG00Q7CKbALiNbEJQMKCHDE0QALfRBEWXnZ2tzp07q0OHDurbt69Wr17d4vNXrlypvn37qkOHDurSpYumTZvW7Dnz5s1Tr1691L59e/Xq1UsLFiywVZNfkE0A3EY2NUcu+RMDesjQBAFwm6NNUNI1Svu3X/pqDUy6xvb7mzt3rpKTkzV9+nTl5ORo5MiR6tixo3bs2BH1+Vu3btVxxx2nkSNHKicnR9OnT1dycrLmzZvX9Jy1a9eqXbt2euyxx7R582Y99thjOvroo7Vu3bq4P3evkE0A3EY2RSKX/IsBPWRoggC4jSaouX79+um2226LeCw1NVVjxoyJ+vw//elPSk1NjXjs1ltv1YUXXtj037/61a80bNiwiOcMHTpUv/71r4+4Lr8gmwC4jWyKRC75FwN6yJSUlCgpKUm5ubkqLS1lsVgsx1dubq6SkpJUUlIS93dVaen+JujSpJ9oYNI1vlqXJv0k6vdoTU1N1PdSW1urdu3aNTvM76677lL//v2j/sxll12mu+66K+KxBQsW6Oijj1ZdXZ0k6bTTTtOkSZMinjNp0iSdfvrp8X7sniGbWCyW24tsOohc8jcG9JA58OXEYrFYbq/c3Ny4v6uqq6v1wx/+0PP3EGt973vfa/bY2LFjo76XXbt2KSkpSWvWrIl4fMKECerRo0fUn0lJSdGECRMiHluzZo2SkpK0e/duSVJycrJmz54d8ZzZs2erffv2cX7q3iGbWCxWWy2yiVzyOwb0kLEsS7m5uSopKWn2G0X2XLTuN7J8fnx+fH77V0lJiXJzc2VZVqu+r6qrqz1/Ly29x8Mfi7UH/UAjtHbt2ojHx48fr549e0b9mZSUFD322GMRj7377rtKSkpSXl6epP2N0Jw5cyKe849//EMdOnSI9yP3DNnk/OLz4/Pj84tcZNNB5JK/MaBDpaWc+9cafH6tw+fXOnx+/sehhPHh33br8Pm1Dp9f6/D5+Ru55G8M6OBLtJX4/FqHz691+PyCoV+/frr99tsjHuvVq1eLF+Pp1atXxGO33XZbs4vxXHnllRHPGTZsWMJcjId/263D59c6fH6tw+fnf+SSfzGggy/RVuLzax0+v9bh8wuGA7ezmTFjhnJycjRq1Ch17NhR27dvlySNGTNGN954Y9PzD9zO5u6771ZOTo5mzJjR7HY2a9asUbt27TRx4kRt3rxZEydOTKjb2fBvu3X4/FqHz691+Pz8j1zyLwZ0qKamRmPHjo15/iRaxufXOnx+rcPnFxzZ2dnq1KmT2rdvr759+2rVqlVNfzd8+HANGDAg4vkrV67UOeeco/bt26tz586aNm1as9f817/+pZ49eyo5OVmpqamaP3++22+jzfBvu3X4/FqHz691+PyCgVzyJwZ0AAAAAAB8gAEdAAAAAAAfYEAHAAAAAMAHGNABAAAAAPABBnQAAAAAAHyAAT3kxo8fr4suukjHHnusjj/++KjP2bFjh66++modd9xx+q//+i/deeedqq2tbeNKg6FTp05KSkqKWPfdd5/XZfladna2OnfurA4dOqhv375avXq11yUFwtixY5v9Wzv55JO9LgtwBNnkLLLJHnIpfmQT0HoM6CH38MMPa9KkSbrnnnuiNkENDQ3q3bu3Bg0apA0bNmjp0qU65ZRTdMcdd3hQrf916tRJjz76qPLy8ppWeXm512X51oF7cE6fPl05OTkaOXKkOnbsqB07dnhdmu+NHTtWZ555ZsS/tT179nhdFuAIsslZZNORI5dah2wCWo8BHZKkmTNnRm2CFi1apKOOOkq7du1qeuzFF19Uhw4dVFpa2pYlBkKnTp30xBNPeF1GYPTr10+33XZbxGOpqakaM2aMRxUFx9ixY9WnTx+vywBcRTY5g2w6cuRS65BNQOsxoENS7CbooYce0tlnnx3x2L59+5SUlKTly5e3VXmB0alTJ/3whz/UCSecoD59+mj8+PEcchlDbW2t2rVrpwULFkQ8ftddd6l///4eVRUcY8eO1XHHHacf/ehH6ty5s6677jpt2bLF67IAR5FNziCbjgy51HpkE9B6DOiQFLsJ+v3vf68rrrii2ePt27fXnDlz2qK0QJk0aZJWrlypjz/+WNOnT9eJJ56oW265xeuyfGnXrl1KSkrSmjVrIh6fMGGCevTo4VFVwbFo0SLNmzdPn3zyiZYuXaoBAwbo5JNPVmFhodelAY4hm5xBNh0Zcqn1yCag9RjQE1C0C3Qcvj744IOIn2mpCRoyZEizx5OTk/Xiiy+69h78JJ7P84B58+YpKSmJYIriQCO0du3aiMfHjx+vnj17elRVcFVUVOjkk09WRkaG16UAUZFNziKbnEcuOY9sAuxjQE9Ae/fu1ebNm1tc1dXVET/DYYSxxfN5HvDtt98qKSlJ69ata+Oq/Y9DCZ2XlpbW7NxJwC/IJmeRTc4jl9xBNgH2MKBD0ndfiGf37t1Nj82dO5cL8Ryh119/XUlJSVz9NYZ+/frp9ttvj3isV69eXIwnDjU1NTr11FM1btw4r0sBHEM2uYNsio1cchbZBNjHgB5yO3bs0MaNGzVu3Dh973vf08aNG7Vx48am268cuJXN4MGDtWHDBi1btkz//d//za1soli7dq0mTZqkjRs3auvWrXrppZd0yimn6Kc//anXpfnWgdvZzJgxQzk5ORo1apQ6duyo7du3e12a740ePVorV67U1q1btW7dOl199dX6/ve/z2eHhEA2OYdssodcah2yCWg9BvSQGz58eNTz1lasWNH0nB07duiqq67SscceqxNOOEF33HGHampqvCvapz766CNdcMEFOv7443XMMceoZ8+eGjt2rCorK70uzdeys7PVqVMntW/fXn379tWqVau8LikQrrvuOv3oRz9ScnKyTjnlFF177bX6/PPPvS4LcATZ5ByyyT5yKX5kE9B6DOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADaGbPnj06+eSTNWHChKbH1q1bp+TkZC1ZssTDygAAYUU2AQgDBnQAUb3xxhtKTk7WBx98oPLycnXv3l0jR470uiwAQIiRTQASHQM6gJj+8Ic/qEePHrrhhhvUu3dvVVdXe10SACDkyCYAiYwBHUBMVVVV6tq1q5KTk/Xxxx97XQ4AAGQTgITGgA4gps8++0zHHHOM2rVrp9dee83rcgAAIJsAJDQGdABR1dbWqk+fPho+fLj++te/6qSTTlJ+fr7XZQEAQoxsApDoGNABRHXvvfeqc+fOKi0tlWVZ6t+/v6666iqvywIAhBjZBCDRMaADaGbFihU6+uij9c477zQ9tmPHDh1//PGaOnWqh5UBAMKKbAIQBgzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPsCADgAAAACADzCgAwAAAADgAwzoAAAAAAD4AAM6AAAAAAA+wIAOAAAAAIAPMKADAAAAAOADDOgAAAAAAPgAAzoAAAAAAD7AgA4AAAAAgA8woAMAAAAA4AMM6AAAAAAA+AADOgAAAAAAPvD/AdztQT2dtrf0AAAAAElFTkSuQmCC\" width=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 10), ncols=2)\n",
    "data.plot.scatter(x=\"x\", y=\"y\", c=\"guess_bgmm\", colormap='viridis', ax=ax[0])\n",
    "data.plot.scatter(x=\"x\", y=\"y\", c=\"source\", colormap='viridis', ax=ax[1])\n",
    "ax[0].set(xlabel=\"x\", ylabel=r\"y\", title=\"Guessed source using Variation Inference GMM\")\n",
    "ax[1].set(xlabel=\"x\", ylabel=r\"y\", title=\"True association\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72508ead",
   "metadata": {},
   "source": [
    "## Other heuristic approaches\n",
    "\n",
    "Many other heuristic approaches for clustering have been developed. Some of them rely on a strong foundation in statistics, others take a more practical approach and make assumptions on how the data samples are expected to be distributed in the $xy$ scatter plot. The following methods deserve a look if you are not familiar with them already:\n",
    "\n",
    "  * DBSCAN (see https://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html ). Uses the euclidean distances between the samples to define if a sample belongs in a cluster or another. The assumption is related to GMMs. While the GMM requires fixing the number of clusters, DBSCAN relies on the maximum distance parameter do define which samples belong to a cluster.\n",
    "  * Agglomerative clustering (see https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html#sklearn.cluster.AgglomerativeClustering). It uses the nearest neighbour to each sample to define which samples belong together in the same cluster. Since the cluster association is topological, it does not assume the samples make a \"blob\" of some sort, as in the case of GMM. One could for example have samples close to one another making a circle in the $xy$-scatter plane and those samples would belong to the same cluster (depending on the definition of closeness and other parameters of the algorithm).\n",
    "  * Spectral clustering (see https://scikit-learn.org/stable/modules/clustering.html#spectral-clustering). Uses K-means on another representation of the data. This representation of the data transforms the data points from the $xy$ space shown before into a space where connectedness of nearest neighbours is the criteria for similarity. For the mathematical foundation, this document may be useful: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.165.9323&rep=rep1&type=pdf\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "488df5eb",
   "metadata": {},
   "source": [
    "### Contact us at the EuXFEL Data Analysis group at any time if you need help analysing your data!\n",
    "\n",
    "#### Data Analysis group: da@xfel.eu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "941c7cb8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}