diff --git a/ReleaseNotes.txt b/ReleaseNotes.txt
index 545d91783..c602aca33 100644
--- a/ReleaseNotes.txt
+++ b/ReleaseNotes.txt
@@ -30,6 +30,9 @@
     - `AtomicMultichannelPulseTemplate`:
         - Add duration keyword argument & example (see MultiChannelTemplates notebook)
         - Make duration equality check approximate (numeric tolerance)
+    - `MappingPulseTemplate`:
+        - Added `namespace_mapping` argument to enable mapping of namespaces for parameters not explicitly mapped.
+        - DEPRECATED: `allow_partial_parameter_mapping` argument. MappingPulseTemplate now always allows partial mapping.
     - Plotting:
         - Add `time_slice` keyword argument to render() and plot()
     - Add `AbstractPulseTemplate` class
@@ -40,6 +43,16 @@
 - Expressions:
     - Make ExpressionScalar hashable
     - Fix bug that prevented evaluation of expressions containing some special functions (`erfc`, `factorial`, etc.)
+    - ExpressionScalar equality operator now also returns true in case of numerical almost-equality
+    - Expressions now accept nested parameter dictionary representing namespaces in evaluate methods
+
+- Utils/sympy:
+    - Add class `SymbolNamespace`, `NamespacedSymbol` to allow specifying parameter namespaces in expressions
+        - either by explicit python `SymbolNamespace(foo).bar` (returns symbol `bar` (as `NamespaceSymbol` in a namespace `foo`)
+        - or in an expression string ``"NS(foo).bar"` (same result after sympify)
+    - Add subs_namespaces method to substitute namespaces in sympy.Expr objects
+    - recursive_substitution now can handle numpy arrays of expressions as well
+    - (temporarily) removed incompatible substitute_with_eval and evaluate_compiled
 
 - Parameters:
     - `ConstantParameter` now accepts a `Expression` without free variables as value (given as `Expression` or string)
diff --git a/doc/source/examples/14ParameterNamespaces.ipynb b/doc/source/examples/14ParameterNamespaces.ipynb
new file mode 100644
index 000000000..4bd809527
--- /dev/null
+++ b/doc/source/examples/14ParameterNamespaces.ipynb
@@ -0,0 +1,2575 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Parameter Namespaces\n",
+    "\n",
+    "We can defined namespaces using `NS(<namespace_name>)` notation in parameter declarations and expressions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\prediger\\AppData\\Local\\Continuum\\miniconda3\\envs\\qupulse-devel\\lib\\site-packages\\qupulse\\utils\\sympy.py:19: UserWarning: scipy is not installed. This reduces the set of available functions to those present in numpy + manually vectorized functions in math.\n",
+      "  warnings.warn('scipy is not installed. This reduces the set of available functions to those present in numpy + '\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'NS(simple_pulse).ty', 'NS(all_pulses).t_end', 'NS(simple_pulse).x', 'NS(simple_pulse).tx', 'NS(simple_pulse).y'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qupulse.pulses import TablePT\n",
+    "entry_list = [(0, 0),\n",
+    "              ('NS(simple_pulse).tx', 'NS(simple_pulse).x', 'hold'),\n",
+    "              ('NS(simple_pulse).ty', 'NS(simple_pulse).y', 'linear'),\n",
+    "              ('NS(all_pulses).t_end', 0, 'jump')]\n",
+    "entries = {0: entry_list}\n",
+    "\n",
+    "simple_pulse_pt = TablePT(entries)\n",
+    "print(simple_pulse_pt.parameter_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For instantiating, we pass a nested dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "parameters = {'simple_pulse': {'tx': 2, 'ty': 4, 'x': 2, 'y': 3}, 'all_pulses': {'t_end': 6}}\n",
+    "\n",
+    "%matplotlib notebook\n",
+    "from qupulse.pulses.plotting import plot\n",
+    "\n",
+    "_ = plot(simple_pulse_pt, parameters=parameters, sample_rate=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is also possible to pass a flat dictionary with fully namespaces parameter names as keys:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "parameters = {'NS(simple_pulse).tx': 2, 'NS(simple_pulse).ty': 6, 'NS(simple_pulse).x': -2, 'NS(simple_pulse).y': -3, 'NS(all_pulses).t_end': 8}\n",
+    "\n",
+    "_ = plot(simple_pulse_pt, parameters=parameters, sample_rate=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "(__developer internal info__) In fact the nested version will be transformed into the flat version by `PulseTemplate.create_program` using `utils.sympy.flatten_parameter_dict` before the parameter dictionary is passed on to `PulseTemplate._internal_create_program`. All functionality currently essentially operates on the flat dictionary."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mapping\n",
+    "\n",
+    "`MappingPT` can deal with namespaces. It allows explicit mapping of any namespaced parameter to anything else and it allows wholesale mapping of namespaces. Explicit parameter mapping takes precedence over namespace mapping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'k', 't_end', 'NS(experiment).NS(qubit1).NS(simple_pulse).ty', 'NS(generics).NS(times).t_begin', 'NS(experiment).NS(qubit1).NS(simple_pulse).y', 't'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qupulse.pulses import MappingPT\n",
+    "from qupulse.utils.sympy import NS\n",
+    "\n",
+    "parameter_mapping = {'NS(simple_pulse).tx': 'NS(generics).NS(times).t_begin', \n",
+    "                     'NS(simple_pulse).x': 't*k',\n",
+    "                     'NS(all_pulses).t_end': 't_end'}\n",
+    "namespace_mapping = {'NS(simple_pulse)': 'NS(experiment).NS(qubit1).NS(simple_pulse)'}\n",
+    "mapped_pt = MappingPT(simple_pulse_pt, parameter_mapping=parameter_mapping, namespace_mapping=namespace_mapping)\n",
+    "print(mapped_pt.parameter_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4Xu2dB5gUVbbHDyJITgoiMAQRlOQCCggIgoKiPokuCkoSUDGCARUBCYsklaCrGFZRFhARCT7BsEoGw7rCIiMooEhyl5WwKEnC+87d17MTeqar+vZMV/jd7+N7+5x7qm/97r/6/PveqlP5Tp8+fVpoEIAABCAAAQhAAAKhIZAPAxiaueZEIQABCEAAAhCAgCGAAUQIEIAABCAAAQhAIGQEMIAhm3BOFwIQgAAEIAABCGAA0QAEIAABCEAAAhAIGQEMYMgmnNOFAAQgAAEIQAACGEA0AAEIQAACEIAABEJGAAMYsgnndCEAAQhAAAIQgAAGEA1AAAIQgAAEIACBkBHAAIZswjldCEAAAhCAAAQggAFEAxCAAAQgAAEIQCBkBDCAIZtwThcCEIAABCAAAQhgANEABCAAAQhAAAIQCBkBDGDIJpzThQAEIAABCEAAAhhANAABCEAAAhCAAARCRgADGLIJ53QhAAEIQAACEIAABhANQAACEIAABCAAgZARwACGbMI5XQhAAAIQgAAEIIABRAMQgAAEIAABCEAgZAQwgCGbcE4XAhCAAAQgAAEIYADRAAQgAAEIQAACEAgZAQxgyCac04UABCAAAQhAAAIYQDQAAQhAAAIQgAAEQkYAAxiyCed0IQABCEAAAhCAAAYQDUAAAhCAAAQgAIGQEcAAhmzCOV0IQAACEIAABCCAAUQDEIAABCAAAQhAIGQEMIAhm3BOFwIQgAAEIAABCGAA0QAEIAABCEAAAhAIGQEMYMgmnNOFAAQgAAEIQAACGEA0AAEIQAACEIAABEJGAAMYsgnndCEAAQhAAAIQgAAGEA1AAAIQgAAEIACBkBHAAIZswjldCEAAAhCAAAQggAFEAxCAAAQgAAEIQCBkBDCAIZtwThcCEIAABCAAAQhgANEABCAAAQhAAAIQCBkBDGDIJpzThQAEIAABCEAAAhhANAABCEAAAhCAAARCRgADGLIJ53QhAAEIQAACEIAABhANQAACEIAABCAAgZARwACGbMI5XQhAAAIQgAAEIIABRAMQgAAEIAABCEAgZAQwgCGbcE4XAhCAAAQgAAEIYADRAAQgAAEIQAACEAgZAQxgyCac04UABCAAAQhAAAIYQDQAAQhAAAIQgAAEQkYAAxiyCed0IQABCEAAAhCAAAYQDUAAAhCAAAQgAIGQEcAAhmzCOV0IQAACEIAABCCAAUQDEIAABCAAAQhAIGQEMIAhm3BOFwIQgAAEIAABCGAA0QAEIAABCEAAAhAIGQEMYMgmnNOFAAQgAAEIQAACGEA0AAEIQAACEIAABEJGAAMYsgnndCEAAQhAAAIQgAAGEA1AAAIQgAAEIACBkBHAAFpM+KlTp2T37t1SvHhxyZcvn8WRCIUABCAAAQhAIK8InD59Wg4dOiQVKlSQM844I68+1lOfgwG0mI6dO3dKSkqKxREIhQAEIAABCEAgWQR27NghlSpVStbHJ/VzMYAW+A8ePCilSpUSFVCJEiUsjkQoBCAAAQhAAAJ5ReDf//63WcA5cOCAlCxZMq8+1lOfgwG0mA4VkApHjSAG0AIkoRCAAAQgAIE8JED+FsEAWggOAVnAIxQCEIAABCCQJALkbwyglfQQkBU+giEAAQhAAAJJIUD+xgBaCQ8BWeEjGAIQgAAEIJAUAuRvDKCV8BCQFT6CIQABCHiKgJYGOXHihJw8edJT42Iw7gnkz59fzjzzzGxLtJG/MYDuVZUuAgFZ4SMYAhCAgGcIHD9+XPbs2SOHDx/2zJgYiB2BIkWKyHnnnScFCxbMciDyNwbQSl0IyAofwRCAAAQ8QUCL+n/33Xeiq0Zly5Y1hoHi/p6YmrgGoSu5auj37t1rVnNr1KiRpdgz+RsDGJe4IkEIyAofwRCAAAQ8QeDo0aPy/fffS5UqVURXjWjBIKCrudu3b5dq1apJoUKFMpwU+RsDaKVyBGSFj2AIQAACniAQMYDRjIInBsgg4iKQ07ySvzGAcYmKFUArbARDAAIQ8BQBDKCnpiNhg8EA5oySQtAWUuMXhAU8QiEAAQh4hEBQDeAPP/xgtj+/+uorqV+/vkdoZz+MVq1amXFOnjw5IWPFAGIAEyKkaAfBAOYaWg4MAQhAIM8IYADzDHWOH+TEAC5fvlweeOAB2bhxo1SoUEEGDx4sd955Z9TjYgAxgLmmbAxgrqHlwBCAAATyjAAGMM9QWxlAfVCnbt260r9/f7njjjtk9erVctddd8ns2bOlS5cuWY6NAcQA5pqyMYC5hpYDQwACEMgzAn42gFrCZuLEifLyyy/Ljh075NxzzzXm6PHHH5fIFvC8efPk2Weflc8++8yURJk2bZo0bdrU8P3555/lnnvukZUrV8q+ffukevXqMmTIEOnWrVsaf12Zu/jii82TtK+88oopk6OrbiNGjEjro2VzdAzvvfeefPDBB1KxYkV5+umnpX379ml9UlNT5aGHHpIVK1ZI0aJF5eqrr5ZJkybJOeecY/rEWgF85JFHZNGiRfLNN9+kHVPHsX79elm7di0G0OUVwz2ALoGl744BtIBHKAQgAAGPEIhmALWW3JHf8v6NIIUL5HdVg1BNkRovNVKXX365KWa9adMm6devX5oBvOiii+Spp54y5k+N4RdffCFbtmwxb8rYtWuXWUFr06aNlChRwhi4QYMGmdW1Jk2apBkzvY9Qt167d+9uzFbv3r2N0Wvbtq3powawUqVKMmHCBGnUqJExnK+++qopw1KmTBkzLjWRunrXs2dPOXLkiOjY9c0rn3zyiSMD2LJlS2nQoIFMmTIlTTnz58+Xrl27mgLeBQoUyKAoVgBZAcy1rxgMYK6h5cAQgAAE8oxANKNw+PgJqT38gzwbQ+SDUkddI0UKnunocw8dOmQKVz/33HPG8GVukRVAXbXr27ev+bOuwtWpU8esoqkxjNauv/56qVWrljGN2nRlTgsq6yphpDVu3FiuvPJKGTduXJoBHDp0qIwePdr8/7/++qsUL15cFi9eLO3atZPhw4ebFUg1jZG2c+dOSUlJkc2bN0vNmjVjrgBqHzWeukIZaWvWrJHmzZvL7t27zVs/0jcMIAbQ0YUUTycMYDzUiIEABCDgLQJ+NYCff/65WaXbtm2bedo3OwOo/XRVTtv+/fvNipw+TKEramrs1MTNmTPHrAYeO3bM/OvUqZO89dZbaQZQTeMf//jHtI/o0KGDnH322WaVT5uuAGr/3//+92l9SpYsaVYCdcVPTeVHH32U5bVsahTVJF577bWODGCfPn3kscceS/sMXamMrHyWL18eA+ji0mIL2AWszF0xgBbwCIUABCDgEQJ+3QLesGGD2VaNZQDTl4E5cOCAlC5dWpYuXWoMl27Z6j8tvVKvXj1zb97AgQPN9vCCBQvSDGDm8iwdO3aUUqVKyfTp09MMoG7H6n+PNP27HldX7dTg6VtWxo8fn2XWdeVOPzfWPYBsASf2gsEAWvDEAFrAIxQCEICARwj49SEQHbeu5k2dOjXHLeCcDOANN9wg5cqVkz/96U9mNvShEt3+1X+JNIB676E+jPL1118bcxmtxTKAes/gu+++a7axI23AgAGybt06HgKJ41rCAMYBLRKCAbSARygEIAABjxDwqwFUfCNHjjQPRehKm94Lt3fvXlMjT+/5i1YIOvMKoD7wocbszTffNCuDzzzzjNnKbd26dUINoN6jp6uIV1xxhTz88MPmyV99EEU/Vx9iyZ8/f8wVwEgZGH3KWR8m0YdR9ClgysDEdyFhAOPjZqIwgBbwCIUABCDgEQJ+NoC6Yjd27FhjoiIPQqgp0vvknBhALf1y2223yccff2y2aG+//Xb58ccf5eDBgwk1gDrV3333nXnyV7ef9T7DKlWqmAdE1HTqPYSxVgD1GHrvoprWSCFoPR6FoOO7kDCA8XHDAFpwIxQCEICAlwj42QB6iaPXxsJTwDnPCAbQQrGsAFrAIxQCEICARwhgAD0yEQkeBgYQA5hgSf33cBjAXEPLgSEAAQjkGQEMYJ6hztMPwgCGwAC+8MILov/0fgdtWq9Ii07qY+fZNb3pddiwYbJ161bz6psxY8aYukduGgbQDS36QgACEPAmAQygN+fFdlQYwBAYQH0sXJ8guuCCC8zZvv766+bdiProu5rBzE2fHGrRooWpWK6mT2sXqWFctWpV2qtvnAgPA+iEEn0gAAEIeJsABtDb8xPv6DCAITCA0U5RayOpCYy8/iZ9n5tuusk8wbtkyZK0/6xPIukj8Po4udOGAXRKin4QcEYg8v5Vt+9DdXZ0ekEgOgEMYDCVgQEMmQHU19rMnTtXevXqZVYAa9eunYVA5cqVzWPk+i/S9EXaWkdJX1ydXYu8IifydzWA+h5DfVxeX6JNgwAE4ieg5u/GaWvly+375dIqpWXunU1NaQgaBHKbQMQoVK1aVQoXLpzbH8fx84jAkSNH0krhFCpUKMOnsoAjEpingPWVOE2bNhW9kIsVKyazZs2S6667LqrMChYsaF5f071797S/a399x6CavOzaiBEjTNHNzA0DmEdXMx8TaAKHj5+Q2sP/+6L41FHXSJGC0d8YEGgQnFyeE9CFg2+//da8EUPfb0sLBoGff/5Z/vnPf0rNmjXNbWLpGwYwQAbw+PHjpnilVjnXBzxeeeUVUzAy2gqgGkC9T7Bbt25pepg5c6bZLlYDmV1jBTAYXwqchTcJYAC9OS9hGdWePXtM/lATqAWRWX3278zrbsLhw4eN+dP3Eeu7hjM3DGCADGDmyW3Tpo15uvfFF1/MMvHxbgEjIP9+ITBy7xPAAHp/joI8QjUNP/30kzGBtGAQUPNXvnz5qGYeAxhgA3jVVVeZ+/N0qzdz04dADh06JIsXL077k5aMUbHwEEgwLnzOwn8EMhvAjSOvkaJnsQXsv5n094h1O/i3337z90kweilQoECWbd/0WDCAATGAQ4YMMTX/1PCpsdOXS48bN07ef/99adu2rfTs2VMqVqxo3peobc2aNdKyZUtT+69Dhw6ycOFCGTp0KGVg+NKAQBIJZDaAtc8rIe/ddzlbcUmcEz4aAkElgAEMiAHUe/f0RdZ6D0fJkiXl4osvNi+cVvOnTV8wrU93pV8NfPvtt43p27ZtW1oh6M6dO7vSOgJyhYvOEMiRQGYDqJ15EATRQAACuUGA/B0QA5gb4nByTATkhBJ9IOCMAAbQGSd6QQAC9gTI3xhAKxUhICt8BEMgA4FoBvCvQ9vI2UULsg2MViAAgYQSIH9jAK0EhYCs8BEMgZgGUDtQFBqhQAACiSZA/sYAWmkKAVnhIxgC2RpAfQAkdc+/0/7OvYCIBQIQSCQB8jcG0EpPCMgKH8EQyNYAagmYI7+dlEv/8BfTBwOIWCAAgUQSIH9jAK30hICs8BEMgWwNoBo+bZFXw1ETELFAAAKJJED+xgBa6QkBWeEjGAKODSA1ARELBCCQSALkbwyglZ4QkBU+giGQowEsXCC/XD91Vdq9gGwDIxgIQCBRBMjfGEArLSEgK3wEQyBHA1ik4Jny67ETUueJD0w/DCCCgQAEEkWA/I0BtNISArLCRzAEYhrA9LUBqQmIYCAAgUQRIH9jAK20hICs8BEMAVcGUDtTExDRQAACiSBA/sYAWukIAVnhIxgCMQ3g6dOn5ffT1spft+9P68tWMMKBAARsCZC/MYBWGkJAVvgIhkBMA6gd1AT+/OtxagKiFwhAIGEEyN8YQCsxISArfARDwJEB1E7p7wWkJiDCgQAEbAmQvzGAVhpCQFb4CIZAXAaQmoAIBwIQsCVA/sYAWmkIAVnhIxgCjg2gbgNTExDBQAACiSJA/sYAWmkJAVnhIxgCjg2gdqQmIIKBAAQSRYD8jQG00hICssJHMARcGUDuA0QwEIBAogiQvzGAVlpCQFb4CIZA3AaQ+wARDwQgYEOA/I0BtNGPICArfARDwJUB5D5ABAMBCCSKAPkbA2ilJQRkhY9gCLgygNqZ+wARDQQgkAgC5G8MoJWOEJAVPoIh4NoA8m5gRAMBCCSCAPkbA2ilIwRkhY9gCFgZQA3m3cCICAIQiIcA+RsDGI9u0mIQkBU+giHg2gDybmBEAwEIJIIA+RsDaKUjBGSFj2AIuDaAGsC7gREOBCBgS4D8jQG00hACssJHMATiMoAaRE1AxAMBCNgQIH9jAG30QxkYK3oEQyAjgfSmLnXUNVKk4JnZIkrfl5qAKAkCEHBLAAOIAXSrmQz9EZAVPoIhEPcKIDUBEQ8EIGBDgPyNAbTRDyuAVvQIhkD8K4AaSU1AFAQBCMRLAAOIAYxXOyYOAVnhIxgCca8AaiA1AREQBCAQLwHyNwYwXu1gAK3IEQyBrATc3AOY2QDq/09NQFQFAQg4JYABxAA61UrUfgjICh/BELBaAaQmIAKCAATiJUD+xgDGqx1WAK3IEQwB+xVAPQI1AVESBCAQDwEMIAYwHt2kxSAgK3wEQ8BqBTASTE1AhAQBCLglQP7GALrVTIb+CMgKH8EQSLgBpCYgooIABJwQIH9jAJ3oJNs+CMgKH8EQSIgBpCYgQoIABNwSIH9jAN1qhhVAK2IEQyB7Am6fAk5/JGoCoiwIQMANAQwgBtCNXrL0RUBW+AiGQEJWAPUgNuaRaYAABMJHgPyNAbRSPQKywkcwBHLFAP51aBs5u2hByZcvH4QhAAEIRCVA/sYAWl0aCMgKH8EQyBUDqAelKDTiggAEciJA/sYAWl0hCMgKH8EQSJgBpCg0YoIABNwQIH8HxACOHTtW3nnnHdm0aZMULlxYmjVrJuPHj5cLL7wwWz1Mnz5d+vTpk+XvR44ckUKFCjnSEQJyhIlOEHBEwPY+PopCO8JMJwhAQETI3wExgO3atZObb75ZGjVqJCdOnJDHH39cNmzYIKmpqVK0aNGoYlcDeP/998vmzZsz/L18+fKOLw4E5BgVHSEQk4CtAdQPoCh0TMx0gAAEMIBGA/lO68/mgLW9e/dKuXLlZPny5dKyZctsDeDAgQPlwIEDcZ89BjBudARCIAuBRBtAikIjMghAIDsC5O+AGsAtW7ZIjRo1zCpg3bp1szWA/fr1k4oVK8rJkyelfv36Mnr0aGnQoIHjKwYBOUZFRwjEJJAIA0hR6JiY6QABCLACGMwVQE0AHTp0kP3798vKlSuzFfqnn34qahTr1atn7gWYMmWKLF68WNavX2/MY7R27Ngx0X+RpnEpKSly8OBBKVGiBBcVBCBgQSARBlA/nqLQFpNAKARCQoAFnACuAN59993y3nvvyapVq6RSpUqOpXzq1Clp2LCh2TKeOnVq1LgRI0bIyJEjs/wNA+gYMx0hkC2BRBlA7gNEZBCAQCwCGMCAGcB7771XFixYICtWrJBq1arFmv8sf+/fv7/s3LlTlixZwgqga3oEQMCOQG4YQO4DtJsToiEQVAIYwIAYQN32VfM3f/58WbZsWbZbuDkJWY/RuHFjsyX86quvOtI8AnKEiU4QcEQgUQaQ+wAd4aYTBEJNgPwdEAN41113yaxZs2ThwoUZav+VLFnS1AXU1rNnT/PAh9YM1KZbuZdddpkxiyoE3fadMWOGrF692hhBJw0BOaFEHwg4I5AoA6ifxn2AzpjTCwJhJUD+DogBzO6dn6+99pr07t3b6LtVq1ZStWpV0fp/2gYNGmSKR//000+iRlGf/tV7/Jo2ber4ekBAjlHREQIxCSTSAKY/Fu8GjomeDhAIHQHyd0AMYLKUi4CSRZ7PDSKB3DKAyop3AwdRMZwTBOInQP7GAMavHuoIWbEjGAKZCSTSAPJuYPQFAQjkRAADiAG0ukIQkBU+giGQgUAiDaAemHcDIzAIQCA7AuRvDKDV1YGArPARDIFcNYB6cGoCIjIIQCAaAfI3BtDqykBAVvgIhkCeGkBqAiI4CEAgQoD8jQG0uhoQkBU+giGQ6waQmoCIDAIQYAUwugbyndZvSFpcBDCAcWEjCAJRCST6HsDIh1ATEMFBAAKZCZC/WQG0uioQkBU+giGQ6yuA+gHUBERoEIAABjCrBlgBtLguMIAW8AiFQCYCubUCmP64+pHUBER6EIAA+ZsVQKurAAFZ4SMYAnmyAkhNQIQGAQiwAsgKYEKvAgxgQnFysJATyK0VQMVKTcCQi4vTh0AmAuRvVgCtLgoEZIWPYAjkyQpg5EOoCYjgIACBCAHyNwbQ6mpAQFb4CIZA0gwgNQERHwTCTYD8jQG0ugIQkBU+giGQpwaQmoAIDgIQYAXwvxrgKWCL6wEDaAGPUAhkIpCb9wBGPoqagMgOAhBQAuRvVgCtrgQEZIWPYAjk6Qqgfhj3ASI6CEAAA/gfDbACaHEtYAAt4BEKgSSsAKY3gNwHiAQhEF4C5G8MoJX6EZAVPoIhkOcrgNwHiOggAAFWAFkBtL4KMIDWCDkABNII5MU9gPph3AeI6CAAAfI3K4BWVwECssJHMATyfAVQP5B3AyM8CECA/I0BtLoKEJAVPoIhkHQDqAPg3cAIEQLhI0D+xgBaqR4BWeEjGAJJMYC8GxjhQQAC5G8MoNVVgICs8BEMgaQYQP1Q3g2M+CAQbgLkbwyg1RWAgKzwEQyBpBlA/eC8euiEaYYABLxHgPyNAbRSJQKywkcwBDxjADeOvEaKnnUmMwIBCISEAPkbA2gldQRkhY9gCHjGAFIUGjFCIFwEyN8YQCvFIyArfARDIKkGkKLQCBAC4SVA/sYAWqkfAVnhIxgCSTWA+uEUhUaEEAgnAfI3BtBK+QjICh/BEEi6AaQoNCKEQDgJkL8xgFbKR0BW+AiGgKcMoA6GotCIEgLhIED+xgBaKR0BWeEjGAJJN4AUhUaEEAgnAfI3BtBK+QjICh/BEEi6AdQBUBQaIUIgfATI3xhAK9UjICt8BEPAEwZQB5H+XkBqAiJMCASfAPkbA2ilcgRkhY9gCHjSAFITEGFCIPgEyN8YQCuVIyArfARDwDMGkJqAiBEC4SJA/sYAWikeAVnhIxgCnjGAOhBqAiJICISHAPkbA2ildgRkhY9gCHjKAFITEEFCIDwEyN8YQCu1IyArfARDwLMGUAdGTUAECoHgEiB/YwCt1I2ArPARDAFPGUBqAiJICISHAPkbA2ildgRkhY9gCHjKAOpgqAmIKCEQDgLkbwygldIRkBU+giHgOQOoA6ImIMKEQPAJkL8xgFYqR0BW+AiGgOcNIDUBESkEgkmA/B0QAzh27Fh55513ZNOmTVK4cGFp1qyZjB8/Xi688MIclTtv3jwZNmyYbN26VapXry5jxoyRTp06OVY7AnKMio4QiEkg/cpb6qhrpEjBM2PG5EYHagLmBlWOCQFvESB/B8QAtmvXTm6++WZp1KiRnDhxQh5//HHZsGGDpKamStGiRaOqbu3atdKiRQsZPXq0MX3z58+X4cOHy6pVq6RJkyaOlIqAHGGiEwQcEfCKAdTBUhPQ0ZTRCQK+JUD+DogBzKzAvXv3Srly5WT58uXSsmXLqAK96aabRAWwZMmStL+rkSxdurTMnj3bkagRkCNMdIKAIwJeMoDcB+hoyugEAd8SIH8H1ABu2bJFatSoYVYB69atG1WglStXlkGDBpl/kTZp0iSZPHmybN++PWrMsWPHRP9FmgooJSVFDh48KCVKlPDthcDAIeAFAl41gNwH6AV1MAYIJJYABjCABlDv3+nQoYPs379fVq5cma1iChYsKNOnT5fu3bun9Zk1a5b06dMng8lLf4ARI0bIyJEjsxwTA5jYC5OjhZOAlwwg9wGGU4OcdXgIYAADaADvvvtuee+998y9fJUqVcrRAL7++uvSrVu3tD4zZ86Uvn37ytGjR1kBDM/3AGfqEQJeMoCKhPsAPSIMhgGBXCCAAQyYAbz33ntlwYIFsmLFCqlWrVqOkolnCzjzARFQLlyVHDK0BLxmAHk3cGilyImHgAD5OyAGULdr1Pzpk7zLli0z9//FavoQyKFDh2Tx4sVpXa+99lopVaoUD4HEgsffIZALBLxsAPV0eTdwLkw6h4RAkghgAANiAO+66y7R+/cWLlyYofZfyZIlTV1AbT179pSKFSuK1gzUtmbNGvOEsNb+03sGNXbo0KGUgUnSxcjHQsBrBpB3A6NJCASXAAYwIAYwX758UVX62muvSe/evc3fWrVqJVWrVjUPfkTa22+/bUzftm3b0gpBd+7c2bHiEZBjVHSEQEwCXjOAOmDeDRxz2ugAAV8SIH8n2QDu3LnTPKn7ww8/yOHDh6Vs2bLSoEEDU4hZn9L1ekNAXp8hxucnAl40gMqPmoB+UhFjhYAzAuTvJBnAt956S6ZOnWq2Yc8++2ypUKGC2ardt2+fMYPFihWTW2+9VR5++GFTZ8+rDQF5dWYYlx8J+MEAUhPQj8pizBDISoD8nQQDGHldW69evaR9+/Zy/vnnZ5iZI0eOyOrVq+XNN980T/S++OKL0qVLF0/qFwF5cloYlE8JeNUAUhPQp4Ji2BDIgQD5OwkGUB+20IcunLR//OMfZkXQ6bt5nRwzkX0QUCJpcqywE/CqAdR5oSZg2NXJ+QeNAPk7CQYwSCJCQEGaTc4l2QS8bACpCZhsdfD5EEgsAfI3BtBKUQjICh/BEMhAwC8GUAdNTUDECwF/EyB/e9QAtmvXzpRm+fbbbz2tMATk6elhcD4j4GUDSE1An4mJ4UIgBgHyt0cNoD4hvHfvXhk9erSnRYyAPD09DM5nBLxsABUlNQF9JiiGC4EcCJC/PWoA/aJaBOSXmWKcfiDgdQOoDKkJ6AclMUYIxCZA/sYAxlYJvyCsGBEMAacE/GYAqQnodGbpBwHvEcAAJtkAtm3bVrJ7jZvK5cMPP/SeatKNCAF5enoYnM8I+MEAUhPQZ6JiuBDIhgD5O8kG8N57780wNb/99pusW7dONm3aZN4E8txzz3lavAjI09PD4HxGwA8GUJFSE9BnwmK4EIhCgMrDTIwAACAASURBVPydZAOYnSqHDRsmx48fl/Hjx3tauAjI09PD4HxGwC8G0C/j9Nn0M1wI5CkB8rdHDeCWLVvM2z9+/vnnPBWE2w9DQG6J0R8C2RPwi7GiKDQqhoD/CZC/PWoAZ82aJQ8++KDs2bPH0ypDQJ6eHgbnMwJ+NICKmKLQPhMaw4WAiJC/k2wAu3btmkGIeoO1mr5PP/1UhgwZIqNGjfK0UBGQp6eHwfmMgF8MIEWhfSYshguBKATI30k2gD169MgwLWeccYaULVtWrrzySrnuuus8L1oE5PkpYoA+IuAXA6hIKQrtI2ExVAhgAKNqIN9p/SajxUUAAxgXNoIgEJWAnwygngBFoREyBPxLgPyd5BVA/0rnPyNHQH6fQcbvJQJ+NoAUhfaSkhgLBGITIH971AD27dtXduzYQSHo2BqmBwQCQ8BvBpCi0IGRHicSQgIYQI8awEceeUR2794tM2bM8LQsEZCnp4fB+YyA3wyg4qUotM9ExnAh8P8EyN8eNYB+USgC8stMMU4/EPCjAeQ+QD8oizFCICsB8jcG0Oq6QEBW+AiGQAYCfjeA3AeIoCHgHwLkbw8YQN3q/d///V/58ccfzevf0rcJEyZ4Wk0IyNPTw+B8RsCPBpD7AH0mMoYLAbaA0zSQ1DIwS5culRtuuEEqVaokW7dulVq1asn27dslX758cvHFF8uKFSs8LVYMoKenh8H5jIAfDaAi5j5AnwmN4UKAKh5GA0k1gPq+3zZt2siYMWOkePHisn79ejnnnHPklltuMcbw9ttv97RQMYCenh4G5zMCfjWAvBvYZ0JjuBDAACbfAKrp++qrr+SCCy6Q0qVLy6pVq6ROnTqybt066dSpk3z//feeFioG0NPTw+B8RiAIBlCR825gnwmP4YaSAPk7ySuA5cuXF90G1q3f2rVry7hx46R9+/by97//XZo1aya//PKLp4WJgDw9PQzOZwT8agB5N7DPhMZwIcAKYPJXADt06GC2evv16ycPPfSQvPvuu3LbbbfJvHnzpFixYvLJJ594WqgYQE9PD4PzGQG/GkDFzLuBfSY2hht6AuTvJK8AbtmyRQ4dOiQNGjSQX3/9VQYNGmS2gXVLeMqUKVKtWjVPixQBeXp6GJzPCPjZACpqagL6THAMN9QEyN9JNoB+Vx8C8vsMMn4vEQiSAaQmoJeUxVggkJUA+RsDaHVdICArfARDIAMBvxtAagIiaAj4hwD5OwkGsF69ejJs2DDzlG+BAgWyVcu2bdtk0qRJpkagvhvYiw0BeXFWGJNfCfjdACp3agL6VX2MO2wEyN9JMIAffvihMXQ7duyQa665Ri699FKpUKGCFCpUSPbv3y+pqanmPkCtCThgwAAZOnSolCpVypPaRECenBYG5VMCQTCA1AT0qfgYdugIkL+TYAAjKtO3fMyZM8e87eOHH36Qo0ePytlnn20eCFFj2LNnTylTpoynRYmAPD09DM5nBIJmABU/NQF9JkKGGxoC5O8kGsAgqAwBBWEWOQevEAiCAaQmoFfUxDggkDMB8jcG0OoaQUBW+AiGQAYCQTCAekLUBETYEPA+AfI3BtBKpQjICh/BEAikAdSToiYg4oaAtwmQvzGAVgpFQFb4CIZAKAwgNQEROgS8R4D8jQG0UiUCssJHMAQCawCpCYi4IeBtAuRvDKCVQhGQFT6CIRBYA6gnRk1ABA4B7xIgf3vAAGoJmOnTp8vWrVvl6aeflnLlyonWCkxJSZFatWo5Vo+Wk5k4caJ8+eWXsmfPHpk/f7507Ngx2/hly5ZJ69ats/z9m2++kYsuusjR5yIgR5joBAFHBILyEEjkZLkP0NG00wkCSSFA/k6yAVy5cqW0a9dOGjduLGvWrBE1X+eff76MGzfOGLm5c+c6FsaSJUtk9erV0rBhQ+nSpYtjA7h582YpUaJE2ueULVtW8ufP7+hzEZAjTHSCgCMCQTaA3AfoSAJ0gkCeESB/J9kANmvWzLwS7uGHH5bixYubt3+oAfz888+NidO3hcTT8uXL59gA6ttH4n3TCAKKZ3aIgUB0AkEzgNwHiNIh4F0C5O8kG8BixYrJhg0bpFq1ahkMoG4L6zasvh0knubGAFatWtV8Tu3atc1r56JtC0fGcOzYMdF/kaYC0q3qgwcPZlhFjGfMxEAg7ASCZgB1PrkPMOyq5vy9SgADmGQDWKlSJbPN27Rp0wwGcMGCBfLggw+a+wLjaU4MoG796n2Dl1xyiTF1M2bMkGnTponeG9iyZcuoHztixAgZOXJklr9hAOOZJWIgkJFAEA0g7wZG5RDwJgEMYJIN4EMPPSRffPGFvP3221K9enVZt26d7N27V2655RbzL5rZciIlJwYw2nFuuOEG0dhFixZF/RhWAJ3Qpw8E4iMQdAOoVHg3cHzaIAoCiSaAAUyyATx+/Lj06NFD5s2bJ6dOnZKCBQvKb7/9Jl27djUrcmeeeWZccx6vARwzZoz8+c9/Ng+jOGkIyAkl+kDAGYEgGkDeDexs7ukFgbwmQP5OsgGMTPi3334rf/vb34wJ1Kd4nZZhyU4w8RrAG2+8Ufbt2yeffPKJIy0iIEeY6AQBRwSCaAD1xHk3sKPppxME8pQA+dsjBjARs/7LL7/Ili1bzKEaNGggzzzzjHmgo0yZMlK5cmV57LHHZNeuXfLGG2+YPpMnTxZ9AKROnTqiK5G68qflZ3Q1snPnzo6GhIAcYaITBBwRCKoB1JMP8rk5mlw6QcBjBMjfSTaAgwcPjioJXcErVKiQXHDBBaL35Tkp05JdYedevXqZQtO9e/cWfbpY+2mbMGGCvPTSS8YUFi5c2BhBNYnXXXedY5kiIMeo6AiBmASCbJIoCh1z+ukAgTwlQP5OsgFs0aKFKQOj9/2p2dOtEn3yt0CBAub//+6778z/1qd1tUyL1xoC8tqMMB4/EwiLAaQotJ9VytiDQoD8nWQD+Oyzz8rHH39sVugiq3xamLlv375y5ZVXSp8+faRbt25mi/b999/3nO4QkOemhAH5mECQDSBFoX0sTIYeSALk7yQbQK0D+MEHH5jt1/Tt66+/Nq+I27lzp3klnP5vLQ/jtYaAvDYjjMfPBIJsAHVeKArtZ3Uy9qARIH8n2QDqm0AWL16cpfDy8uXL5frrrxd9sGPbtm1Sv3590cnyWkNAXpsRxuNnAkE3gBSF9rM6GXvQCJC/k2wAdXtXC0FPmjRJGjVqZIow63uAH3jgAWncuLHMnDlT5syZYx7Y0JVArzUE5LUZYTx+JhAmA6jzRFFoP6uVsfudAPk7yQbw0KFDct999xmjd/LkSaOn/Pnzy6233ipTp04VXSHU+oB6/4y+ss1rDQF5bUYYj58JBN0AUhTaz+pk7EEjQP5OsgGMCErfpatP/+oXpD79W7JkSV9oDQH5YpoYpE8IBN0A6jRQFNonYmSYgSdA/vaIAfSr0hCQX2eOcXuRQBgMoHKnJqAX1ceYwkaA/O0BA/jVV1/J3Llz5ccffzTlXtK3t956y9OaRECenh4G5zMCYTSA1AT0mUgZbmAIkL+TbADV+N1yyy2m5t/SpUvN/9Xiz//617+kffv2aa9t86riEJBXZ4Zx+ZFAWAwgNQH9qE7GHDQC5O8kG8Df/e530q9fP7n33nulePHisn79evN+3v79+0uVKlVk+PDhntYcAvL09DA4nxEIiwHUaaEmoM/EyXADR4D8nWQDWLRoUdGiz9WqVZOzzz7bvKe3Xr16kpqaKm3atJHdu3d7WnQIyNPTw+B8RiBMBpCagD4TJ8MNHAHyd5INoL4JZMmSJcb06WrgkCFD5KabbpJPP/1Urr76ak8Wf05/FSCgwH0ncEJJJBBWA6jIqQmYROHx0aEkQP5OsgHUQtBNmjSRgQMHyh/+8Ad57rnnpFOnTub1cBdffLEsWLDA08JEQJ6eHgbnMwJhMoDUBPSZOBlu4AiQv5NsAPVhjyNHjkhKSoopBD1+/HhZtWqVqQX4xBNPmG1hLzcE5OXZYWx+IxAmA6hzQ01AvymU8QaJAPk7yQbQ72JCQH6fQcbvJQJhM4DKnpqAXlIgYwkTAfJ3kg1gwYIFZdeuXVK2bNkMutu3b5+UL18+S11Ar4kTAXltRhiPnwmE3QBSE9DP6mXsfiNA/k6yATzjjDPkp59+knLlymXQjj79e/7558vRo0c9rSkE5OnpYXA+IxBGA0hNQJ+JlOEGhgD5O0kG8Pnnnzci0vp/Y8eOlWLFiqWJSu8FXL58uSkIrXUBvdwQkJdnh7H5jUAYDaDOETUB/aZUxhsEAuTvJBlAfehDm27/nnfeeaIrgZGm28JaDHr06NHSrFkzT+sMAXl6ehiczwiE1QByH6DPhMpwA0GA/J0kAxhRT4sWLWTRokVSunRpXwoKAfly2hi0RwlgAEW4D9Cj4mRYgSNA/k6yAfS7ohCQ32eQ8XuJQFgNIPcBekmFjCUsBMjfSTCAgwcPdqyvCRMmOO6bjI4IKBnU+cygEgirAdT55D7AoKqa8/IqAfJ3Egygbvs6afny5ZMVK1Y46Zq0Pggoaej54AASCLMB5N3AARQ0p+RpAuTvJBhATyvC5eAQkEtgdIdADgQwgB+k0eHdwFwqEMhdAuRvDxlArQeoq37nnntu7s56Ao+OgBIIk0OFnkCYDSDvBg69/AGQxwTI30k2gPqlp3UAn3rqKTl48KCZ/lKlSslDDz0kjz76qDGEXm4IyMuzw9j8RiDMBlDnincD+02xjNfPBMjfSTaAQ4cOlWnTpskTTzwhzZs3N1+Aq1evllGjRsmAAQNMLUAvNwTk5dlhbH4jEHYDqPNFTUC/qZbx+pUA+TvJBrBixYryxz/+UTp27JhBQ/Pnz5d77rnHFIr2ckNAXp4dxuY3AhjAjAaQmoB+UzDj9RMB8neSDWChQoXk73//u9SsWTODbjZv3iz169eXI0eOeFpPCMjT08PgfEYAA/ifbeDrp66S1D3/NrOXOuoaKVLwTJ/NJMOFgPcJkL+TbAAbNWokl19+uUyaNCmDWgYOHChr1qyRzz//3NMqQkCenh4G5zMCGMD/TBg1AX0mXIbrSwLk7yQbwKVLl8r1118v1atXN+/91Yc+9B7Abdu2yeLFi+WKK67wtLAQkKenh8H5jAAG8D8TRk1AnwmX4fqSAPk7yQZQVbNz50557rnn5JtvvjHbH7Vr1zb3/1WqVMnzokJAnp8iBugjAhjArAZQ/ws1AX0kYobqGwLk7yQZwHXr1pl7/PzeEJDfZ5Dxe4kABvA/s0FNQC+pkrEElQD5O0kG8IwzzpAGDRpIv379pHv37lKyZElfagwB+XLaGLRHCWAA/zsx1AT0qEgZVmAIkL+TZADXrl0rr776qrz11lvy22+/SefOnaVv377SunVrX4kLAflquhisxwlgADNOEDw8LliG52sC5O8kGcCIarTMi5rA1157TVauXClVq1aV2267TXr16sU9gL6+tBg8BNwTwPBkbwA3jrxGip5FORj3qiICAtEJYACTbADTT8vWrVuNEXzjjTdkz5490rZtW/MksJcbAvLy7DA2vxHAAGZvACkK7Tc1M16vEyB/e8gAqlh++eUXmTlzpgwZMkQOHDggJ0+e9LSGEJCnp4fB+YwABjDjhFEU2mcCZri+IkD+9ogBXL58ubkncN68eZI/f37p2rWruSfwsssu87SgEJCnp4fB+YwABjDrhFEU2mciZri+IUD+TqIB3LFjh0yfPt38+/77700haDV9av6KFi3qCxEhIF9ME4P0CQEMYNaJSs+E+wB9ImSG6QsC5O8kGUC9v0/fAlK2bFnp2bOnefDjwgsvtBLNihUrZOLEifLll1+aewjnz58vHTt2zPGYuvL4wAMPyMaNG6VChQoyePBgufPOOx2PAwE5RkVHCMQkgAHM2QByH2BMCdEBAo4JkL+TZADbt29vVvv+53/+x2z5JqItWbLEvEauYcOG0qVLl5gGUFcd69atK/3795c77rjDxN51110ye/ZsE++kISAnlOgDAWcEMIBZOXEfoDPt0AsCbgmQv5NkAN1OlNv++k7hWCuAjzzyiCxatMi8gi7SdPVv/fr1onUKnTQE5IQSfSDgjAAGMDon7gN0ph96QcANAfJ3iA1gy5YtzdtIpkyZkqYZNY16D+Lhw4elQIECMbWEgGIiogMEHBPAAEZHBRfHEqIjBBwTIH+H2ADWrFlTevfubUrORNqaNWukefPmsnv3bjnvvPOyCOnYsWOi/yJNBZSSkiIHDx6UEiVKOBYeHSEAgawEMDoYQK4LCOQVAQxgyA1gnz595LHHHkvTm94HePnll5uHSMqXL59FhyNGjJCRI0dm+e8YwLy6ZPmcIBPAAGIAg6xvzs1bBDCAITaA8WwBswLorQuY0QSLAAYQAxgsRXM2XiaAAQyxAdSHQN59911JTU1N0+iAAQNk3bp1PATi5auWsQWWAAYQAxhYcXNiniOAAQyQAdTXyG3ZssWITB/ueOaZZ6R169ZSpkwZqVy5stnq3bVrl3nXsLZIGRgtAaOlYPTJX30KmDIwnrtOGVBICGAAMYAhkTqn6QECGMAAGcBly5YZw5e59erVy7xtRB/4+OGHH0T7RZoWgh40aFBaIWhdFaQQtAeuTIYQSgIYQAxgKIXPSSeFAAYwQAYwGQpCQMmgzmcGlQAGEAMYVG1zXt4jQP7GAFqpEgFZ4SMYAhkIYAAxgFwSEMgrAuRvDKCV1hCQFT6CIYABdKABjLEDSHSBgEsC5G8MoEvJZOyOgKzwEQwBDKADDWAAHUCiCwRcEiB/YwBdSgYDaAWMYAjkQACjwxYwFwgE8ooABhADaKU1BGSFj2AIsALoQAMYYweQ6AIBlwTI3xhAl5JhBdAKGMEQYAXQtQYwgK6REQCBmAQwgBjAmCLJqQMCssJHMARYAXSgAQygA0h0gYBLAuRvDKBLybACaAWMYAiwAuhaAxhA18gIgEBMAhhADGBMkbACaIWIYAg4JoDRiY4KLo4lREcIOCaAAcQAOhZLtI4IyAofwRDIQACjgwHkkoBAXhEgf2MArbSGgKzwEQwBDKADDWCMHUCiCwRcEiB/YwBdSiZjdwRkhY9gCGAAHWgAA+gAEl0g4JIA+RsD6FIyGEArYARDIAcCGB22gLlAIJBXBDCAGEArrSEgK3wEQ4AVQAcawBg7gEQXCLgkQP7GALqUDCuAVsAIhgArgK41gAF0jYwACMQkgAHEAMYUSU4dEJAVPoIhwAqgAw1gAB1AogsEXBIgf2MAXUqGFUArYARDgBVA1xrAALpGRgAEYhLAAGIAY4qEFUArRARDwDEBjE50VHBxLCE6QsAxAQwgBtCxWKJ1REBW+AiGQAYCGB0MIJcEBPKKAPkbA2ilNQRkhY9gCGAAHWgAY+wAEl0g4JIA+RsD6FIyGbsjICt8BEMAA+hAAxhAB5DoAgGXBMjfGECXksEAWgEjGAI5EMDosAXMBQKBvCKAAcQAWmkNAVnhIxgCrAA60ADG2AEkukDAJQHyNwbQpWRYAbQCRjAEWAF0rQEMoGtkBEAgJgEMIAYwpkhy6oCArPARDAFWAB1oAAPoABJdIOCSAPkbA+hSMqwAWgEjGAKsALrWAAbQNTICIBCTAAYQAxhTJKwAWiEiGAKOCWB0oqOCi2MJ0RECjglgADGAjsUSrSMCssJHMAQyEMDoYAC5JCCQVwTI3xhAK60hICt8BEMAA+hAAxhjB5DoAgGXBMjfGECXksnYHQFZ4SMYAhhABxrAADqARBcIuCRA/sYAupQMBtAKGMEQyIEARoctYC4QCOQVAQwgBtBKawjICh/BEGAF0IEGMMYOINEFAi4JkL8xgC4lwwqgFTCCIcAKoGsNYABdIyMAAjEJYAAxgDFFklMHBGSFj2AIsALoQAMYQAeQ6AIBlwTI3xhAl5JhBdAKGMEQYAXQtQYwgK6REQCBmAQwgBjAmCJhBdAKEcEQcEwAoxMdFVwcS4iOEHBMAAOIAXQslmgdEZAVPoIhkIEARgcDyCUBgbwiQP7GAFppDQFZ4SMYAhhABxrAGDuARBcIuCRA/sYAupRMxu4IyAofwRDAADrQAAbQASS6QMAlAfI3BtClZDCAVsAIhkAOBDA6bAFzgUAgrwhgADGAVlpDQFb4CIYAK4AONIAxdgCJLhBwSYD8HTAD+Pzzz8vEiRNlz549UqdOHZk8ebK0aNEiqiymT58uffr0yfK3I0eOSKFChRxJCQE5wkQnCDgigNFhBdCRUOgEgQQQIH8HyADOmTNHevToIWoCmzdvLi+++KK88sorkpqaKpUrV84iFzWA999/v2zevDnD38qXL+9YWgjIMSo6QiAmAQwgBjCmSOgAgQQRIH8HyAA2adJEGjZsKC+88EKaPGrVqiUdO3aUsWPHRjWAAwcOlAMHDsQtJwQUNzoCIZCFAAYQA8hlAYG8IkD+DogBPH78uBQpUkTmzp0rnTp1StOPrvCtW7dOli9fHtUA9uvXTypWrCgnT56U+vXry+jRo6VBgwbZ6u/YsWOi/yJNBZSSkiIHDx6UEiVK5JVu+RwIBJIABhADGEhhc1KeJIABDIgB3L17tzFyq1evlmbNmqWJ7cknn5TXX389yzavdvj0009ly5YtUq9ePVEhTJkyRRYvXizr16+XGjVqRBXsiBEjZOTIkVn+hgH05PXNoHxGAAOIAfSZZBmujwlgAANmANesWSNNmzZNk+SYMWNkxowZsmnTppgyPXXqlNlCbtmypUydOjVqf1YAY2KkAwTiJoABxADGLR4CIeCSAAYwIAYwni3gaFrp37+/7Ny5U5YsWeJISgjIESY6QcARAQwgBtCRUOgEgQQQIH8HxACqFvQhkEsuucQ8BRxptWvXlg4dOkR9CCSzfk6fPi2NGzc2W8KvvvqqI3khIEeY6AQBRwQwgBhAR0KhEwQSQID8HSADGCkDM23aNLMN/NJLL8nLL78sGzdulCpVqkjPnj3NfYKRJ4L1Xr7LLrvM3O+nQtBtX90u1vsI1Qg6aQjICSX6QMAZAQwgBtCZUugFAXsC5O8AGUCVg67+TZgwwRSCrlu3rkyaNMnc06etVatWUrVqVdH6f9oGDRok77zzjvz0009SsmRJ8/SvPuSR/h7CWBJDQLEI8XcIOCeAAcQAOlcLPSFgR4D8HTADaCcH99EIyD0zIiCQHQEMIAaQqwMCeUWA/I0BtNIaArLCRzAEMhDAAGIAuSQgkFcEyN8YQCutISArfARDAAPoQAMYYweQ6AIBlwTI3xhAl5LJ2B0BWeEjGAIYQAcawAA6gEQXCLgkQP7GALqUDAbQChjBEMiBAEaHLWAuEAjkFQEMIAbQSmsIyAofwRBgBdCBBjDGDiDRBQIuCZC/MYAuJcMKoBUwgiHACqBrDWAAXSMjAAIxCWAAMYAxRZJTBwRkhY9gCLAC6EADGEAHkOgCAZcEyN8YQJeSYQXQChjBEGAF0LUGMICukREAgZgEMIAYwJgiYQXQChHBEHBMAKMTHRVcHEuIjhBwTAADiAF0LJZoHRGQFT6CIZCBAEYHA8glAYG8IkD+xgBaaQ0BWeEjGAIYQAcawBg7gEQXCLgkQP7GALqUTMbuCMgKH8EQwAA60AAG0AEkukDAJQHyNwbQpWQwgFbACIZADgQwOmwBc4FAIK8IYAAxgFZaQ0BW+AiGACuADjSAMXYAiS4QcEmA/I0BdCkZVgCtgBEMAVYAXWsAA+gaGQEQiEkAA4gBjCmSnDogICt8BEOAFUAHGsAAOoBEFwi4JED+xgC6lAwrgFbACIYAK4CuNYABdI2MAAjEJIABxADGFAkrgFaICIaAYwIYneio4OJYQnSEgGMCGEAMoGOxROuIgKzwEQyBDAQwOhhALgkI5BUB8jcG0EprCMgKH8EQwAA60ADG2AEkukDAJQHyNwbQpWQydkdAVvgIhgAG0IEGMIAOINEFAi4JkL8xgC4lgwG0AkYwBHIggNFhC5gLBAJ5RQADiAG00hoCssJHMARYAXSgAYyxA0h0gYBLAuRvDKBLybACaAWMYAiwAuhaAxhA18gIgEBMAhhADGBMkeTUAQFZ4SMYAqwAOtAABtABJLpAwCUB8jcG0KVkWAG0AkYwBFgBdK0BDKBrZARAICYBDCAGMKZIWAG0QkQwBBwTwOhERwUXxxKiIwQcE8AAYgAdiyVaRwRkhY9gCGQggNHBAHJJQCCvCJC/MYBWWkNAVvgIhgAG0IEGMMYOINEFAi4JkL8xgC4lk7E7ArLCRzAEMIAONIABdACJLhBwSYD8jQF0KRkMoBUwgiGQAwGMDlvAXCAQyCsCGEAMoJXWEJAVPoIhwAqgAw1gjB1AogsEXBIgf2MAXUqGFUArYARDgBVA1xrAALpGRgAEYhLAAGIAY4okpw4IyAofwRBgBdCBBjCADiDRBQIuCZC/MYAuJcMKoBUwgiHACqBrDWAAXSMjAAIxCWAAMYAxRcIKoBUigiHgmABGJzoquDiWEB0h4JgABhAD6Fgs0ToiICt8BEMgAwGMDgaQSwICeUWA/I0BtNIaArLCRzAEMIAONIAxdgCJLhBwSYD8jQF0KZmM3RGQFT6CIYABdKABDKADSHSBgEsC5G8MoEvJYACtgBEMgRwIYHTYAuYCgUBeEcAABswAPv/88zJx4kTZs2eP1KlTRyZPniwtWrTIVk/z5s2TYcOGydatW6V69eoyZswY6dSpk2P9ISDHqOgIgZgEMIAYwJgioQMEEkSA/B0gAzhnzhzp0aOHqAls3ry5vPjii/LKK69IamqqVK5cOYtk1q5da8zh6NGjjembP3++DB8+XFatWiVNmjRxJDEE5AgTnSDgiAAGEAPoSCh0gkACCJC/A2QA1bQ1bNhQXnjhhTRp1KpVSzp27Chjx47NIpebbrpJVABLlixJ+1u7du2kdOnSMnv2bEfyQkDRMZ0+fVqO/HbSvbe9CAAAFMVJREFUEUM6QSBC4PDxk3LpH/5i/t/UUddIkYJnAkdE0hvjvw5tI0UK5ocLBFwRKFwgv+TLl89VTNA7k78DYgCPHz8uRYoUkblz52bYwr3//vtl3bp1snz58ixa1lXBQYMGmX+RNmnSJLNtvH379qjaP3bsmOi/SFMBpaSkyMGDB6VEiRJBv14cn1/6hOU4iI4QSEcAA/hfGFxPXBq2BLieshLEAAbEAO7evVsqVqwoq1evlmbNmqXN9JNPPimvv/66bN68OcvsFyxYUKZPny7du3dP+9usWbOkT58+GUxe+sARI0bIyJEjsxwLA5gRCQnL9us63PGXViktc+9syorF/8tAV9R/P22t/HX7/nALg7OPmwAGEAMYTTz5Tuu3i89bxACuWbNGmjZtmnY2+lDHjBkzZNOmTVENoJrDbt26pf1t5syZ0rdvXzl69CgrgBaaYAvYAh6hwnZVVhFwTXFh2BDgmsIABtYA5tUWcGaALCHbfCURCwEIQAACEEgOAfJ3QLaAVT76EMgll1xingKOtNq1a0uHDh2yfQjk0KFDsnjx4rT+1157rZQqVYqHQJJzPfKpEIAABCAAgTwhgAEMkAGMlIGZNm2a2QZ+6aWX5OWXX5aNGzdKlSpVpGfPnuY+wcgTwbpd3LJlS1P7T03iwoULZejQoZSByZNLjw+BAAQgAAEIJI8ABjBABlBlpKt/EyZMMIWg69atK/pUr5o8ba1atZKqVauaBz8i7e233zamb9u2bWmFoDt37uxYkQjIMSo6QgACEIAABDxDgPwdMAOY18pCQHlNnM+DAAQgAAEI2BMgf2MArVSEgKzwEQwBCEAAAhBICgHyNwbQSngIyAofwRCAAAQgAIGkECB/YwCthIeArPARDAEIQAACEEgKAfI3BtBKeAjICh/BEIAABCAAgaQQIH9jAK2Eh4Cs8BEMAQhAAAIQSAoB8jcG0Ep4CMgKH8EQgAAEIACBpBAgf2MArYSHgKzwEQwBCEAAAhBICgHyNwbQSngIyAofwRCAAAQgAIGkECB/YwCthIeArPARDAEIQAACEEgKAfI3BtBKeAjICh/BEIAABCAAgaQQIH9jAK2Eh4Cs8BEMAQhAAAIQSAoB8jcG0Ep4CMgKH8EQgAAEIACBpBAgf2MArYSHgKzwEQwBCEAAAhBICgHyNwbQSngIyAofwRCAAAQgAIGkECB/YwCthIeArPARDAEIQAACEEgKAfI3BtBKeAjICh/BEIAABCAAgaQQIH9jAK2Eh4Cs8BEMAQhAAAIQSAoB8jcG0Ep4CMgKH8EQgAAEIACBpBAgf2MArYSHgKzwEQwBCEAAAhBICgHyNwbQSngIyAofwRCAAAQgAIGkECB/YwCthIeArPARDAEIQAACEEgKAfI3BtBKeAjICh/BEIAABCAAgaQQIH9jAK2Eh4Cs8BEMAQhAAAIQSAoB8jcG0Ep4Bw8elFKlSsmOHTukRIkSVsciGAIQgAAEIACBvCGgBjAlJUUOHDggJUuWzJsP9din5Dt9+vRpj43JN8PZtm2bVK9e3TfjZaAQgAAEIAABCPyXwNatW+X8888PJRIMoMW06y+H0qVLy48//hjaXxDZ4Yv8umJ1NCsh2GR/0cEmOhu4oJl4UhW6yZ6a7uBVrlxZ9u/fb3bywtgwgBazzj0EOX8p67K6XmRsj2fkhG7QjduvHTSDZtxqRvujG3STk24wgPFcVf8fw8XFxRWPfNANunGrGzSDZtxqBgOYMzGuKR4CieeaSotBQHwpxyMgdINu3OoGzaAZt5rBAGIAY2mGFcBYhHL4+7Fjx2Ts2LHy2GOPyVlnnWVxpOCFwib7OYUNbNxe8WgGzbjVjPZHN+gmJ91gAOO5qoiBAAQgAAEIQAACPiaAAfTx5DF0CEAAAhCAAAQgEA8BDGA81IiBAAQgAAEIQAACPiaAAfTx5DF0CEAAAhCAAAQgEA8BDGA81IiBAAQgAAEIQAACPiaAAXQ5eVo1/L777pNFixaZyPbt28uzzz6bYyXxVq1ayfLlyzN80k033SRvvvmmy0/3Vvfnn39eJk6cKHv27JE6derI5MmTpUWLFtkOct68eTJs2DDRV+/oK/TGjBkjnTp18tZJJWg0bthMnz5d+vTpk+WTjxw5IoUKFUrQiJJ/mBUrVhi9fPnll0Yz8+fPl44dO+Y4ML1uHnjgAdm4caNUqFBBBg8eLHfeeWfyTybBI3DLZtmyZdK6desso/jmm2/koosuSvDoknc4rbLwzjvvyKZNm6Rw4cLSrFkzGT9+vFx44YU5DioM3zXxsAnLd80LL7wg+u+HH34wOtH8NHz4cLn22mvJT+kIYABdfrepgHbu3CkvvfSSibz99tulatWq8u6772Z7JDWANWvWlFGjRqX10S8zP7+Aes6cOdKjRw9Ro9O8eXN58cUX5ZVXXpHU1FTzep3Mbe3atcYcjh492pg+Tf56Qa5atUqaNGnicha83d0tG/1Svv/++2Xz5s0ZTqx8+fLePlGXo1uyZImsXr1aGjZsKF26dIlpAL///nupW7eu9O/fX+644w4Te9ddd8ns2bNNfJCaWzYRA6iaSf+mnbJly0r+/PkDg6Zdu3Zy8803S6NGjeTEiRPy+OOPy4YNG8z3TNGiRaOeZ1i+a+JhE5bvGs3Heh1ccMEFRiOvv/66+fH51VdfGTMY5vyU/twxgC6+KvXXde3ateXTTz9NMy36v5s2bWp+oWb3q1QNYP369c0KWVCamjZN5PorK9Jq1aplVnT0l2nmpiueWsxWE12k6ReYvktZE3qQmls2+qU8cOBA0XdLh6Xly5cvpgF85JFHzEq7XneRpqt/69evF03yQW1O2EQMYNjeY7p3714pV66c2VFp2bJlVAmE6bsmPQAnbML4XRNhVKZMGWMC+/btG+r8hAGMM3O8+uqrZjsqc6LWF0lPmjQp6jaefpQaQN3COn36tJx77rlmGfqJJ56Q4sWLxzmS5IYdP35cihQpInPnzs2whaurWOvWrcuy3a2j1VXBQYMGmX+RpszUFG/fvj25J5TAT4+HjX4p9+vXTypWrCgnT540PxZ0pbRBgwYJHJm3DuXE5GiCVwZTpkxJG7yuHHft2lUOHz4sBQoU8NZJJWg0TthEDKDuPhw9etT8MB06dGjUbeEEDcsTh9myZYvUqFHDrALq6nC0Fpbvmszn7oRNGL9r9DtVc1WvXr3MCqBeK5lbWDXDCqCLr7Unn3xS9AL69ttvM0Tp9q7ew6VvBInWXn75ZalWrZrolt7XX39t+unS9EcffeTi073Tdffu3cas6Jac3pMTacpHl9ozb2Xq3wsWLGjYde/ePa3/rFmzDDetVh+UFg8bXUXWL+969eqZVVI1PIsXLzYrXZrsgticmBy9rnr37i1DhgxJQ7BmzRpzy4FyPu+884KIRpyw0WtM7xu85JJLzPUzY8YMmTZtmqgxzG5lzO+w9Ad0hw4dRFc9V65cme3phOW7Jj0Ap2zC9F2jPxJ0d05/IBUrVkw031x33XVRdRNGzSgIDKCIjBgxQkaOHJnj9+MXX3whH374YVSDo0lal5UfffRRR9+xehP8pZdeam6G121Uv7WIydFkrBdYpOlDHZqIdDs8c9MLTM1ht27d0v40c+ZMw00v0KC0eNhkPvdTp04ZXWginzp1alDQZDgPJyYn2g8r/dFx+eWXm4dIgnaPZASQEzbRRHHDDTcY8xh5QC1owrn77rvlvffeM/cNV6pUKUcDGIbvmvQAnLIJ03eN7sb8+OOPZsdOHwrSe9T11oFoK4BhyU+Z5x8DKCL/+te/zL+cmm616C+IeLaAMx9Xf63pu4PVLOn9Kn5r8WxzhmWJPR420eZfH3zQh43S3zPpN53kNF4nJoct4JyfkM7MV3+A/fnPf85wz2RQNHPvvffKggULzKqn7qbk1MLyXRNh4IZNGL9rIufcpk0bU31CH1jM3MKmmbQfm6fVjdAcEYg8BPLZZ59J48aNTYz+78suuyzHh0AyH1y3gXW7L6cbmR0NKImd9EEH3X7Sp4AjTX9Z6RZNdg+BHDp0yGxtRpreC6n3TwbxIRA3bKL9QFB9qUb0vtMgNicGUB8C0af59InPSBswYIC5zzTsD4FE08SNN94o+/btk08++SQwktH0pAZH7/3U7W0nt0Toj+owfNfEwyaM3zWRc77qqqskJSXF3IqUuYVFM5nPmxVAl1+Valp0my/yK0LLwFSpUiWtDMyuXbtEhfbGG28Yk6g173SrU+89OOecc0wye/DBB01NK91W9mvJhkipE73vSLeBtSyO3uuoD7soj549e5r7BCNmULeLdUVHVynUJC5cuNDctB7kMjBO2ejtB/ojQpOb3gOo2766OqzbnZEfGi5l6snuv/zyi7nXUZs+3PHMM8+Yhxb06Tz9Ba73xur1o9eOtkgZGC0Boyuiavr0KeAgloFxy0YfntJdCS1poavOuvI3btw4s9XVuXNnT85/PIPSsj+686LfF+mrLGgJLf0O1RbW75p42ITlu0bvG9ZcrYZPfwxozV29Pt5//31p27ZtaDWDAYznWyhdjP7CzlwI+rnnnksrBK2FJ3WLYunSpebp3x07dsitt95qHv7QL3kV5PXXX2+eAtbE5+emq38TJkww92PpE3n6VG/kBnQ9d01Q6X9tvf3228b0bdu2La0QdJCSVfq5dMNGn4zWYrc//fSTqQ2p5kjvS01/f6WfdRIZe3bFi/XpPNWJPvCh14/2izRdJVc+kULQuioYxELQbtnodac/utQwqxFSI6gGOrub3P2qH10pjtZee+01oxdtYf2uiYdNWL5r9N7yjz/+2OQm/U69+OKLRb871PyFWTMYQL9+EzJuCEAAAhCAAAQgkCACbAEnCCSHgQAEIAABCEAAAn4hgAH0y0wxTghAAAIQgAAEIJAgAhjABIHkMBCAAAQgAAEIQMAvBDCAfpkpxgkBCEAAAhCAAAQSRAADmCCQHAYCEIAABCAAAQj4hQAG0C8zxTghAAEIQAACEIBAgghgABMEksNAAAIQgAAEIAABvxDAAPplphgnBCAAAQhAAAIQSBABDGCCQHIYCEAg7wlE3rzz1VdfSf369fN8AJs3b5YrrrhCvvvuOylevLj15+tbhT788ENZtGiR9bE4AAQgAIGcCGAA0QcEIOBJAtm96ioyWH2F3J/+9CfZu3evec/2mWeemefnceONN8rvfvc7GTZsWEI++9ixY+YVinPnzpXLL788IcfkIBCAAASiEcAAogsIQMCTBPTdyJE2Z84cGT58uOiKW6TpO3D1PZ/Jajt37pTzzz/fvNu6UqVKCRvGgw8+KHpsPWcaBCAAgdwigAHMLbIcFwIQSBiB6dOny8CBA+XAgQMZjpl5C3jZsmXSunVref/99+XRRx+VTZs2SdOmTeXNN9+UL7/8Uh544AHZtWuXXH/99Wb1sEiRIuZ4p0+flokTJ8q0adPMC+Rr1qxpVvV0hS+79swzz8js2bPliy++SOsSGaeaNx3vjh07zErea6+9Juedd57pp2McPHiwbNy4UQoUKCB16tSRWbNmSZUqVczfly9fLldffbU5VzW5NAhAAAK5QQADmBtUOSYEIJBQAm4N4GWXXSZPPfWUMXhdu3aVihUryllnnSXjxo2TX375RTp16iQPP/ywPPLII2acjz/+uLzzzjsyefJkqVGjhqxYsULuvPNO+eCDD8w9ftFax44djal74YUXMhjA22+/3cSMHTtWzjjjDLn11lulQYMGMnPmTDlx4oTZru7fv785/vHjx+Xzzz83prVy5crmOL/++qu5n3Dp0qXZfnZC4XIwCEAglAQwgKGcdk4aAv4i4NYA/uUvf5GrrrrKnKSavscee0y2bt1qtmy1qfnS1UNdKVTDpabsk08+MauFkdavXz85fPiwWZ2L1vShky5dumS4/0/H2adPH9myZYtUr17dhD3//PMyatQo0S3tffv2ydlnn21WAbMzlhpTpkwZmTRpkuh9jjQIQAACuUEAA5gbVDkmBCCQUAJuDeA///lPKVu2rBmDbr/ec889xuhF2hNPPCHvvvuu/O1vfzNbuI0bN5aiRYtmGLOuzunK3WeffRb1XC688EJRk6griZGm47z77rszfNb8+fONUTx16pTppgZRt47btm0rbdq0MSuUke3hyHF0xXLo0KEyYMCAhHLkYBCAAAQiBDCAaAECEPA8AbcGcP/+/VKqVClzXtFiR4wYIQsWLJB169YZg6dbxroqp8YrfdNt45SUlKh8mjdvblbxnnzyyQwGMPO9ivo5uuWs9xlGmpat0dVHNaEbNmyQjz76yIwh0vTevxkzZuR4D6LnJ40BQgACniaAAfT09DA4CEAgOxOn/z27h0DcGMBDhw6Z1cKXX35ZevTo4Ri4rirq07pq8CItmtmMZgDTf4huOzdq1EimTp1q/rNuVV9wwQUZtpEdD4qOEIAABBwSwAA6BEU3CEAgeQRycwVQz0q3W/UJ4Keffto8tfvvf/9b1qxZI8WKFcv2PjxdvdMt4N27d0v+/PkNnFgG8Pvvv5eXXnpJ2rdvLxUqVDBlbbp16yZ/+MMf0rZ79RijR482RpAGAQhAILcIYABziyzHhQAEEkYgtw2gbs8+++yz5oENreun28cNGzaUIUOGSMuWLaOex8mTJ03pFi0nc8011zgygP/4xz/MAyi67fzzzz+be//0QQ+9J1GfGNamx9KngrWMDQ0CEIBAbhHAAOYWWY4LAQgEnoAaxoULF5pyMYloX3/9tXl6+dtvv01qketEnAvHgAAEvE0AA+jt+WF0EICAhwloXb/x48fLfffdl5B3Aet7gHU1MrKi6OFTZ2gQgIDPCWAAfT6BDB8CEIAABCAAAQi4JYABdEuM/hCAAAQgAAEIQMDnBDCAPp9Ahg8BCEAAAhCAAATcEsAAuiVGfwhAAAIQgAAEIOBzAhhAn08gw4cABCAAAQhAAAJuCWAA3RKjPwQgAAEIQAACEPA5AQygzyeQ4UMAAhCAAAQgAAG3BDCAbonRHwIQgAAEIAABCPicAAbQ5xPI8CEAAQhAAAIQgIBbAhhAt8ToDwEIQAACEIAABHxO4P8Aul/D5cjYf6UAAAAASUVORK5CYII=\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "parameters = {'experiment': {'qubit1': {'simple_pulse': {'ty': 1.5, 'y': 1}}}, \n",
+    "              'generics': {'times': {'t_begin': 1}},\n",
+    "              't': 2,\n",
+    "              'k': 1.5,\n",
+    "              't_end': 2.5}\n",
+    "\n",
+    "_ = plot(mapped_pt, parameters=parameters, sample_rate=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Explicit mapping requires full namespace notation in the parameter dictionary and currently does not allow for nested dicts, i.e. in the above it is not possible to defined the `parameter_mapping` as `{'simple_pulse': {'tx': 'NS(generic).NS(times).t_begin'....` and so forth.\n",
+    "Namespace mapping also crucially requires the `NS(<namespace name>)` notation on both sides of each mapping. It is obviously required that namespaces are always mapped to namespaces, not to parameters, i.e., the `namespace_mapping` cannot have statements of the form\n",
+    "\n",
+    "- `'NS(foo)': 'k'`\n",
+    "- `'NS(foo)': 'NS(bar).param'`\n",
+    "\n",
+    "are not allowed.\n",
+    "It is currently also required that all mapping entries are strings."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A nested namespace `NS(foo).NS(bar)` will not be mapped by a mapping for `NS(bar)` but will be affected for mappings of `NS(foo).NS(bar)` and `NS(foo)`:\n",
+    "\n",
+    "- mapping `NS(foo).NS(bar)` with mapping `NS(foo).NS(bar): NS(other)` results in `NS(other)`\n",
+    "- mapping `NS(foo).NS(bar)` with mapping `NS(foo): NS(other)` results in `NS(other).NS(bar)`\n",
+    "- mapping `NS(foo).NS(bar)` with mapping `NS(bar): NS(other)` results in `NS(foo).NS(bar)` (no change)\n",
+    "\n",
+    "Providing mapping for both outer and nested namespace (i.e., `NS(foo).NS(bar): NS(other1)` _and_ `NS(foo): NS(other2)`) currently results in undefined behavior (and may produce either `NS(other1)` _or_ `NS(other2).NS(bar)` depending on the order in which the mappings are processed, which is currently not specified."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/doc/source/examples/examples.rst b/doc/source/examples/examples.rst
index 55a5d65dc..c72d3d2cb 100644
--- a/doc/source/examples/examples.rst
+++ b/doc/source/examples/examples.rst
@@ -20,6 +20,9 @@ All examples are provided as static text in this documentation and, additionally
     10FreeInductionDecayExample
     11GateConfigurationExample
     12AbstractPulseTemplate
+    13RetrospectiveConstantChannelAddition
+    14ParameterNamespaces
+
 
 The `/doc/source/examples` directory also contains some outdated examples for features and functionality that has been changed. These examples start with the number nine and are currently left only for reference purposes.
 If you are just learning how to get around in qupulse please ignore them.
\ No newline at end of file
diff --git a/qupulse/expressions.py b/qupulse/expressions.py
index d85cffa79..bc1822fd5 100644
--- a/qupulse/expressions.py
+++ b/qupulse/expressions.py
@@ -14,7 +14,8 @@
 
 from qupulse.serialization import AnonymousSerializable
 from qupulse.utils.sympy import sympify, to_numpy, recursive_substitution, evaluate_lambdified,\
-    get_most_simple_representation, get_variables
+    get_most_simple_representation, get_variables, almost_equal, subs_namespaces, SymbolNamespace, \
+    flatten_parameter_dict
 
 __all__ = ["Expression", "ExpressionVariableMissingException", "ExpressionScalar", "ExpressionVector"]
 
@@ -69,7 +70,8 @@ def _parse_evaluate_numeric_result(self,
             raise NonNumericEvaluation(self, result, call_arguments)
 
     def evaluate_numeric(self, **kwargs) -> Union[Number, numpy.ndarray]:
-        parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)
+        flat_kwargs = flatten_parameter_dict(kwargs)
+        parsed_kwargs = self._parse_evaluate_numeric_arguments(flat_kwargs)
 
         result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,
                                                               parsed_kwargs, lambdified=self._expression_lambda)
@@ -84,6 +86,7 @@ def __float__(self):
             return float(e)
     
     def evaluate_symbolic(self, substitutions: Dict[Any, Any]) -> 'Expression':
+        substitutions = flatten_parameter_dict(substitutions)
         return Expression.make(recursive_substitution(sympify(self.underlying_expression), substitutions))
 
     @property
@@ -122,6 +125,9 @@ def make(cls: Type[_ExpressionType],
     def underlying_expression(self) -> Union[sympy.Expr, numpy.ndarray]:
         raise NotImplementedError()
 
+    def subs_namespaces(self):
+        raise NotImplementedError()
+
 
 class ExpressionVector(Expression):
     """N-dimensional expression.
@@ -161,7 +167,8 @@ def variables(self) -> Sequence[str]:
         return self._variables
 
     def evaluate_numeric(self, **kwargs) -> Union[numpy.ndarray, Number]:
-        parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)
+        flat_kwargs = flatten_parameter_dict(kwargs)
+        parsed_kwargs = self._parse_evaluate_numeric_arguments(flat_kwargs)
 
         result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,
                                                               parsed_kwargs, lambdified=self._expression_lambda)
@@ -266,7 +273,10 @@ def __le__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[
 
     def __eq__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> bool:
         """Enable comparisons with Numbers"""
-        return self._sympified_expression == self._sympify(other)
+        sympified_other = self._sympify(other)
+        if self._sympified_expression == sympified_other:
+            return True
+        return almost_equal(self._sympified_expression, sympified_other)
 
     def __hash__(self) -> int:
         return hash(self._sympified_expression)
@@ -316,6 +326,9 @@ def get_serialization_data(self) -> Union[str, float, int]:
     def is_nan(self) -> bool:
         return sympy.sympify('nan') == self._sympified_expression
 
+    def subs_namespaces(self, mapping: Dict[Union[str, SymbolNamespace], SymbolNamespace]):
+        return ExpressionScalar(subs_namespaces(self._sympified_expression, mapping))
+
 
 class ExpressionVariableMissingException(Exception):
     """An exception indicating that a variable value was not provided during expression evaluation.
diff --git a/qupulse/pulses/mapping_pulse_template.py b/qupulse/pulses/mapping_pulse_template.py
index 8d01a4321..835df16cb 100644
--- a/qupulse/pulses/mapping_pulse_template.py
+++ b/qupulse/pulses/mapping_pulse_template.py
@@ -2,6 +2,7 @@
 from typing import Optional, Set, Dict, Union, List, Any, Tuple
 import itertools
 import numbers
+import warnings
 import collections
 
 from qupulse.utils.types import ChannelID
@@ -15,9 +16,10 @@
 from qupulse.pulses.conditions import Condition
 from qupulse.serialization import Serializer, PulseRegistryType
 
+from qupulse.utils.sympy import sympify, flatten_parameter_dict
+
 __all__ = [
     "MappingPulseTemplate",
-    "MissingMappingException",
     "UnnecessaryMappingException",
 ]
 
@@ -36,46 +38,54 @@ def __init__(self, template: PulseTemplate, *,
                  measurement_mapping: Optional[Dict[str, str]] = None,
                  channel_mapping: Optional[Dict[ChannelID, ChannelID]] = None,
                  parameter_constraints: Optional[List[str]]=None,
-                 allow_partial_parameter_mapping: bool = None,
+                 namespace_mapping: Optional[Dict[str, str]] = None,
+                 allow_partial_parameter_mapping: Optional[bool ]= None, # deprecated; todo: remove
                  registry: PulseRegistryType=None) -> None:
         """Standard constructor for the MappingPulseTemplate.
 
-        Mappings that are not specified are defaulted to identity mappings. Channels and measurement names of the
-        encapsulated template can be mapped partially by default. F.i. if channel_mapping only contains one of two
-        channels the other channel name is mapped to itself.
-        However, if a parameter mapping is specified and one or more parameters are not mapped a MissingMappingException
-        is raised. To allow partial mappings and enable the same behaviour as for the channel and measurement name
-        mapping allow_partial_parameter_mapping must be set to True.
-        Furthermore parameter constrains can be specified.
+        Mappings that are not specified are defaulted to identity mappings. F.i. if channel_mapping only contains one of
+        two channels the other channel name is mapped to itself.
+        All parameters that are not explicitly mapped in the parameter_mapping dictionary are mapped to themselves i.e.,
+        no change occurs.
+
+        The namespace_mapping argument can be used to provide a mapping of namespaces which is applied to all parameters
+        not already explicitly mapped by parameter_mapping. Is is allowed to mapped nested namespaces, i.e.,
+        namespace mappings of the forms `'NS(foo).NS(bar)': 'NS(new)'`, `'NS(foo)': 'NS(new).NS(bar)'`,
+        `'NS(foo).NS(bar)': 'NS(new).NS(new_inner)'` are allowed. Note also that a nested namespace will only be mapped
+        if fully specified, i.e. a namespace `NS(foo).NS(bar)` will not be affected by a mapping of only `NS(bar)`.
+
+        Finally, if both an outer and an inner namespace are mapped at the same time, e.g.,
+        `{'NS(foo).NS(bar)': 'NS(foo).NS(rab)', 'NS(foo)': 'NS(new)'}` this results in undefined mapping behavior as the
+        order in which mappings are applied is not explicitly specified.
         
         :param template: The encapsulated pulse template whose parameters, measurement names and channels are mapped
         :param parameter_mapping: if not none, mappings for all parameters must be specified
         :param measurement_mapping: mappings for other measurement names are inserted
         :param channel_mapping: mappings for other channels are auto inserted
         :param parameter_constraints:
-        :param allow_partial_parameter_mapping: If None the value of the class variable ALLOW_PARTIAL_PARAMETER_MAPPING
+        :param namespace_mapping: mapping of namespaces
+        :param allow_partial_parameter_mapping: deprecated
         """
+        if allow_partial_parameter_mapping:
+            warnings.warn("The allow_partial_parameter_mapping argument is deprecated and will be ignored. Partial parameter mappings are always possible.", category=DeprecationWarning)
         PulseTemplate.__init__(self, identifier=identifier)
         ParameterConstrainer.__init__(self, parameter_constraints=parameter_constraints)
 
-        if allow_partial_parameter_mapping is None:
-            allow_partial_parameter_mapping = self.ALLOW_PARTIAL_PARAMETER_MAPPING
+        parameter_mapping = dict() if parameter_mapping is None else parameter_mapping
+        mapped_internal_parameters = set(parameter_mapping.keys())
+        internal_parameters = template.parameter_names
+        missing_parameter_mappings = internal_parameters - mapped_internal_parameters
+        if mapped_internal_parameters - internal_parameters:
+            raise UnnecessaryMappingException(template, mapped_internal_parameters - internal_parameters)
 
-        if parameter_mapping is None:
-            parameter_mapping = dict((par, par) for par in template.parameter_names)
-        else:
-            mapped_internal_parameters = set(parameter_mapping.keys())
-            internal_parameters = template.parameter_names
-            missing_parameter_mappings = internal_parameters - mapped_internal_parameters
-            if mapped_internal_parameters - internal_parameters:
-                raise UnnecessaryMappingException(template, mapped_internal_parameters - internal_parameters)
-            elif missing_parameter_mappings:
-                if allow_partial_parameter_mapping:
-                    parameter_mapping.update({p: p for p in missing_parameter_mappings})
-                else:
-                    raise MissingMappingException(template, internal_parameters - mapped_internal_parameters)
         parameter_mapping = dict((k, Expression(v)) for k, v in parameter_mapping.items())
 
+        if namespace_mapping is not None:
+            namespace_mapping = {sympify(k): sympify(v) for k, v in namespace_mapping.items()}
+            parameter_mapping.update({k: Expression(k).subs_namespaces(namespace_mapping) for k in missing_parameter_mappings})
+        else:
+            parameter_mapping.update(**{k:Expression(k) for k in missing_parameter_mappings})
+
         measurement_mapping = dict() if measurement_mapping is None else measurement_mapping
         internal_names = template.measurement_names
         mapped_internal_names = set(measurement_mapping.keys())
@@ -99,6 +109,7 @@ def __init__(self, template: PulseTemplate, *,
             raise ValueError('Cannot map multiple channels to the same target(s) %r' % overlapping_targets,
                              channel_mapping)
 
+
         if isinstance(template, MappingPulseTemplate) and template.identifier is None:
             # avoid nested mappings
             parameter_mapping = {p: Expression(expr.evaluate_symbolic(parameter_mapping))
@@ -249,19 +260,24 @@ def map_parameters(self,
             A new dictionary which maps parameter names to parameter values which have been
             mapped according to the mappings defined for template.
         """
+        parameters = flatten_parameter_dict(parameters)
         missing = set(self.__external_parameters) - set(parameters.keys())
         if missing:
             raise ParameterNotProvidedException(missing.pop())
 
         self.validate_parameter_constraints(parameters=parameters)
+        mapped_params = dict()
         if all(isinstance(parameter, Parameter) for parameter in parameters.values()):
-            return {parameter: MappedParameter(mapping_function, {name: parameters[name]
+            mapped_params = {parameter: MappedParameter(mapping_function, {name: parameters[name]
                                                                   for name in mapping_function.variables})
                     for (parameter, mapping_function) in self.__parameter_mapping.items()}
-        if all(isinstance(parameter, numbers.Real) for parameter in parameters.values()):
-            return {parameter: mapping_function.evaluate_numeric(**parameters)
-                    for parameter, mapping_function in self.__parameter_mapping.items()}
-        raise TypeError('Values of parameter dict are neither all Parameter nor Real')
+        elif all(isinstance(parameter, numbers.Real) for parameter in parameters.values()):
+            mapped_params =  {parameter: mapping_function.evaluate_numeric(**parameters)
+                              for parameter, mapping_function in self.__parameter_mapping.items()}
+        else:
+            raise TypeError('Values of parameter dict are neither all Parameter nor Real')
+        #mapped_params = {k: str(subs_namespaces(sympify(k), self.__namespace_mapping)) for v in }
+        return mapped_params
 
     def get_updated_measurement_mapping(self, measurement_mapping: Dict[str, str]) -> Dict[str, str]:
         return {k: measurement_mapping[v] for k, v in self.__measurement_mapping.items()}
@@ -347,20 +363,6 @@ def integral(self) -> Dict[ChannelID, ExpressionScalar]:
         return expressions
 
 
-class MissingMappingException(Exception):
-    """Indicates that no mapping was specified for some parameter declaration of a
-    SequencePulseTemplate's subtemplate."""
-
-    def __init__(self, template: PulseTemplate, key: Union[str,Set[str]]) -> None:
-        super().__init__()
-        self.key = key
-        self.template = template
-
-    def __str__(self) -> str:
-        return "The template {} needs a mapping function for parameter(s) {}".\
-            format(self.template, self.key)
-
-
 class UnnecessaryMappingException(Exception):
     """Indicates that a mapping was provided that does not correspond to any of a
     SequencePulseTemplate's subtemplate's parameter declarations and is thus obsolete."""
diff --git a/qupulse/pulses/pulse_template.py b/qupulse/pulses/pulse_template.py
index 7296da625..092b6d936 100644
--- a/qupulse/pulses/pulse_template.py
+++ b/qupulse/pulses/pulse_template.py
@@ -25,6 +25,8 @@
 from qupulse._program.waveforms import Waveform, TransformingWaveform
 from qupulse.pulses.measurement import MeasurementDefiner, MeasurementDeclaration
 
+from qupulse.utils.sympy import flatten_parameter_dict
+
 __all__ = ["PulseTemplate", "AtomicPulseTemplate", "DoubleParameterNameException", "MappingTuple"]
 
 
@@ -138,7 +140,8 @@ def create_program(self, *,
         if non_unique_targets:
             raise ValueError('The following channels are mapped to twice', non_unique_targets)
 
-        # make sure all values in the parameters dict are of type Parameter
+        # make sure all values in the parameters dict are of type Parameter and the dict is not nested
+        parameters = flatten_parameter_dict(parameters)
         parameters = {key: value if isinstance(value, Parameter) else ConstantParameter(value)
                       for key, value in parameters.items()}
 
diff --git a/qupulse/utils/sympy.py b/qupulse/utils/sympy.py
index 86e2ff1b9..8b92c29e9 100644
--- a/qupulse/utils/sympy.py
+++ b/qupulse/utils/sympy.py
@@ -1,4 +1,4 @@
-from typing import Union, Dict, Tuple, Any, Sequence, Optional
+from typing import Union, Dict, Tuple, Any, Sequence, Optional, Set
 from numbers import Number
 from types import CodeType
 import warnings
@@ -8,6 +8,7 @@
 
 import sympy
 import numpy
+import re
 
 try:
     import scipy.special as _special_functions
@@ -25,26 +26,296 @@
 
 Sympifyable = Union[str, Number, sympy.Expr, numpy.str_]
 
+namespace_separator = '.'
+namespace_pythoncode_separator = '____'
+namespace_identifiers = {'SymbolNamespace', 'NS'}
 
-class IndexedBasedFinder:
-    """Acts as a symbol lookup and determines which symbols in an expression a subscripted."""
 
-    def __init__(self):
-        self.symbols = set()
-        self.indexed_base = set()
-        self.indices = set()
+class NamespacedSymbol(sympy.Symbol):
+
+    def __new__(cls, inner_name: Union[str, sympy.Symbol], namespace: "SymbolNamespace"=None):
+        name = inner_name
+        if isinstance(name, sympy.Symbol):
+            name = str(name)
+        if namespace_separator in name:
+            raise ValueError("namespace name may not contain a namespace separator \".\"!")
+        prefix = ""
+        if namespace:
+            prefix = namespace.name + namespace_separator
+        name = prefix + name
+        return super().__new__(cls, name)
+
+    def __init__(self, inner_name: str, namespace: "SymbolNamespace"=None) -> None:
+        self._namespace = namespace
+        self._inner_name = inner_name
+
+    @classmethod
+    def instantiate(cls, name: str, namespace: "SymbolNamespace"=None):
+        return cls(name, namespace=namespace)
+
+    def _subs_namespace(self, old, new):
+        if self._namespace:
+            new_namespace = self._namespace._subs_namespace(old, new)
+            return new_namespace._members[self._inner_name]
+        return self
+
+    def change_namespace(self, namespace: "SymbolNamespace"=None) -> "NamespacedSymbol":
+        return self.instantiate(name=self._inner_name, namespace=namespace)
+
+    def _subs(self, old, new, **hints):
+        if old.name == self.name:
+            return new
+        return self
+
+    def to_sympy_symbol(self) -> sympy.Symbol:
+        return sympy.Symbol(self.name)
+
+    def __hash__(self) -> int:
+        return hash(sympy.Symbol(self.name))
+
+    def __eq__(self, other) -> bool:
+        return sympy.Symbol(self.name) == other
+
+    def _pythoncode(self, settings=None) -> str:
+        prefix = ""
+        if self._namespace:
+            prefix = self._namespace._pythoncode(settings) + namespace_pythoncode_separator
+        return prefix + self._inner_name
+
+    def _numpycode(self, settings=None) -> str:
+        return self._pythoncode(settings)
+
+    def _lambdacode(self, settings=None) -> str:
+        return self._pythoncode(settings)
+
+    @property
+    def _root_namespace(self) -> "SymbolNamespace":
+        if self._namespace:
+            return self._namespace._root_namespace
+        return None
+
+
+class NamespaceIndexedBase(NamespacedSymbol):
+
+    def __getitem__(self, item):
+        return sympy.IndexedBase(self.name)[item]
+
+    def to_sympy_symbol(self) -> sympy.IndexedBase:
+        return sympy.IndexedBase(self.name)
+
+    @property
+    def free_symbols(self):
+        return {NamespacedSymbol(self._inner_name, namespace=self._namespace)}
+
+
+class SymbolNamespace:
+    """A namespace of symbols.
+
+    Grants attribute access members of that namespace. Members can be set during construction. Any member symbol
+    that is requested from the namespace and wasn't given during construction is simply instantiated as
+    NamespacedSymbol.
+    """
+
+    def __init__(self, name: Union[str, sympy.Symbol, "SymbolNamespace"], members: Optional[NamespacedSymbol]=None, parent: "SymbolNamespace"=None):
+        self._inner_name = name
+        if isinstance(self._inner_name, (SymbolNamespace, NamespacedSymbol)):
+            self._inner_name = self._inner_name._inner_name
+        elif isinstance(self._inner_name, sympy.Symbol):
+            self._inner_name = str(self._inner_name)
+        if namespace_separator in self._inner_name:
+            raise ValueError("namespace name may not contain a namespace separator \".\"!")
+        self._parent = parent
+
+        self._members = dict()
+        if members is not None:
+            self._add_members(members)
+
+    def change_namespace(self, namespace: "SymbolNamespace") -> "SymbolNamespace":
+        return SymbolNamespace(self._inner_name, members=self._members.values(), parent=namespace)
+
+    def _add_members(self, new_members: Sequence[NamespacedSymbol]) -> None:
+        for m in new_members:
+            k = m._inner_name
+            if k not in self._members:
+                self._members[k] = m.change_namespace(self)
+
+
+    @property
+    def name(self) -> str:
+        prefix = ""
+        if self._parent:
+            prefix = self._parent.name + namespace_separator
+        return prefix + "NS(" + self._inner_name + ")"
+
+    def __getattr__(self, k: str) -> sympy.Expr:
+        if k in namespace_identifiers:
+            return SymbolNamespaceFactory(instances=self._members, parent=self)
+        if k not in self._members:
+            self._members[k] = NamespacedSymbol(k, namespace=self)
+        return self._members[k]
+
+    def _subs_namespace(self, old, new):
+        if old.name == self.name:
+            new._add_members(self._members.values())
+            return new
+        if self._parent is not None:
+            new_namespace = self._parent._subs_namespace(old, new)
+            return new_namespace._members[self._inner_name]
+        return self
+
+    def members(self) -> Dict[Union[str, sympy.Symbol], Union[NamespacedSymbol, "SymbolNamespace"]]:
+        return self._members
+
+    def _pythoncode(self, settings=None) -> str:
+        prefix = ""
+        if self._parent:
+            prefix = self._parent._pythoncode(settings) + namespace_pythoncode_separator
+        return prefix + self._name
+
+    def _numpycode(self, settings=None) -> str:
+        return self._pythoncode(settings)
+
+    def _lambdacode(self, settings=None) -> str:
+        return self._pythoncode(settings)
+
+    def _sympy_(self):
+        return self
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @property
+    def _root_namespace(self) -> "SymbolNamespace":
+        if self._parent is not None:
+            return self._parent._root_namespace
+        return self
+
+NS = SymbolNamespace
 
-        class SubscriptionChecker(sympy.Symbol):
-            """A symbol stand-in which detects whether the symbol is subscripted."""
+
+class SymbolNamespaceFactory:
+
+    def __init__(self, parent: SymbolNamespace=None, instances: Dict[Union[str, sympy.Symbol], SymbolNamespace]=None):
+        self._parent = parent
+        self._instances = instances
+        if self._instances is None:
+            self._instances = dict()
+
+    def __call__(self, name: Union[str, sympy.Symbol]):
+        if str(name) not in self._instances:
+            self._instances[str(name)] = SymbolNamespace(name=name, parent=self._parent)
+        return self._instances[str(name)]
+
+    def get_instances(self):
+        return self._instances
+
+
+def subs_namespaces(expr: sympy.Expr, mapping: Dict[Union[str, SymbolNamespace], SymbolNamespace]) -> sympy.Expr:
+    """Substitutes namespaces
+
+    Counterpart to Expr.subs() which can only substitute namespaced symbols but not namespaces itself, i.e.,
+    `(NS(a).b * c).subs({NS(a).b: x} == x*c` but `(NS(a).b * c).subs({NS(a).b: NS(x)}) == NS(a).b * c` (no change).
+
+    subs_namespaces adds functionality to substitute namespaces and thus move all affected symbols in the expression
+    into the replacement namespace, i.e., `subs_namespaces(NS(a).b * c, {NS(a): NS(x)}) == NS(x).b * c` and
+    `subs_namespaces(NS(a).NS(b).d * c, {NS(a).NS(b): NS(x).NS(y)}) == NS(x).NS(y)d * c`
+    """
+    subs = dict()
+    for a in expr.atoms(NamespacedSymbol):
+        for old, new in mapping.items():
+            ret = a._subs_namespace(old, new)
+            if ret is not a:
+                subs[a] = ret
+    return expr.subs(subs)
+
+
+##############################################################################
+### Utilities to automatically detect usage of indexed/subscripted symbols ###
+##############################################################################
+
+class CustomSyntaxInterpreter:
+    """Acts as a symbol lookup for sympify and determines which symbols in an expression are subscripted/indexed (within
+     a namespace)."""
+
+    def __init__(self):
+        self.symbols = dict()
+        # self.bases = dict()
+
+        class CheckingNamespaceFactory:
+            """A stand-in class for SymbolNamespaceFactory which helps tracking subscripted symbols."""
+
+            def __init__(self, parent: "CheckingNamespace"=None):
+                self._parent = parent
+                self._instances = dict()
+
+            def __call__(self, name: Union[str, sympy.Symbol]):
+                if str(name) not in self._instances:
+                    self._instances[str(name)] = CheckingNamespace(name=name, parent=self._parent)
+                return self._instances[str(name)]
+
+            def get_instances(self):
+                return self._instances
+
+        class CheckingNamespace(SymbolNamespace):
+            """A stand-in class for SymbolNamespace which helps tracking subscripted symbols."""
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self._fac = CheckingNamespaceFactory(parent=self)
+
+            def __getattr__(self, k: str):
+                if k in namespace_identifiers:
+                    return self._fac
+                if k not in self._members:
+                    self._members[k] = CheckingSymbol(k)
+                return self._members[k]
+
+            def get_symbol(self) -> SymbolNamespace:
+                members = dict()
+                # convert all symbols
+                for k, s in self._members.items():
+                    assert(isinstance(s, CheckingSymbol))
+                    members[k] = s.get_symbol()
+
+                # convert all nested namespaces
+                members.update(**{
+                    k:s.get_symbol() for k,s in self._fac.get_instances().items()
+                })
+                return SymbolNamespace(self._inner_name, members=members.values())
+
+        class CheckingSymbol(sympy.Symbol):
+            """A symbol stand-in which detects whether a symbol (in a namespace) is subscripted.
+
+            Overloads __getitem__ to detect item accesses to determine whether this CheckingSymbol represents an indexed
+            symbol. Returns sympy.Indexed.
+
+            The method get_symbol() is used to return the proper class representation for use after detection.
+            It returns:
+                - sympy.NamespaceIndexedBase if __getitem__ was called
+                - sympy.NamespaceSymbol otherwise
+            """
+
+            def __init__(s, *args, **kwargs) -> None:
+                sympy.Symbol.__init__(*args, **kwargs)
+                s._is_index_base = False
 
             def __getitem__(s, k):
-                self.indexed_base.add(str(s))
-                self.indices.add(k)
-                if isinstance(k, SubscriptionChecker):
+                s._is_index_base = True
+                if isinstance(k, CheckingSymbol):
                     k = sympy.Symbol(str(k))
                 return sympy.IndexedBase(str(s))[k]
 
-        self.SubscriptionChecker = SubscriptionChecker
+            def get_symbol(s):
+                if s._is_index_base:
+                    return NamespaceIndexedBase(str(s))
+                else:
+                    return NamespacedSymbol(str(s))
+
+        self.CheckingSymbol = CheckingSymbol
+        self.namespace_fac = CheckingNamespaceFactory()
 
     def __getitem__(self, k) -> sympy.Expr:
         """Return an instance of the internal SubscriptionChecker class for each symbol to determine which symbols are
@@ -54,16 +325,51 @@ def __getitem__(self, k) -> sympy.Expr:
         'Integer', 'Float', etc. We have to take care of returning correct types for symbols (-> SubscriptionChecker)
         and the base types (-> Integer, Float, etc).
         """
+        if k in sympify_namespace:
+            return sympify_namespace[k]
+        if k in namespace_identifiers:
+            return self.namespace_fac
         if hasattr(sympy, k): # if k is a sympy base type identifier, return the base type
             return getattr(sympy, k)
 
         # otherwise track the symbol name and return a SubscriptionChecker instance
-        self.symbols.add(k)
-        return self.SubscriptionChecker(k)
+        if k not in self.symbols:
+            self.symbols[k] = self.CheckingSymbol(k)
+        return self.symbols[k]
 
     def __contains__(self, k) -> bool:
         return True
 
+    def get_symbols(self) -> Dict[str, Union[sympy.Symbol, SymbolNamespace]]:
+
+        symbols = dict()
+        # convert all immediate symbols (not in namespaces)
+        for k, s in self.symbols.items():
+            assert (isinstance(s, self.CheckingSymbol))
+            symbols[k] = s.get_symbol().to_sympy_symbol()
+
+        # convert all namespaces -> create a NamespaceFactory object that holds all known namespaces and simply
+        # replicates them when called as NS(<name>)
+        nested = {k: s.get_symbol() for k, s in self.namespace_fac.get_instances().items()}
+        rootFac = SymbolNamespaceFactory(instances=nested)
+        symbols.update(**{
+            k: rootFac for k in namespace_identifiers
+        })
+
+        return symbols
+
+
+def get_symbols_for_custom_syntax(expression: str) -> Dict[str, sympy.Symbol]:
+    # track all symbols that are subscipted in here
+    syntax_interpreter = CustomSyntaxInterpreter()
+    sympy.sympify(expression, locals=syntax_interpreter)
+
+    return syntax_interpreter.get_symbols()
+
+#############################################################
+### "Built-in" length function for expressions in qupulse ###
+#############################################################
+
 
 class Broadcast(sympy.Function):
     """Broadcast x to the specified shape using numpy.broadcast_to
@@ -93,13 +399,17 @@ def eval(cls, arg) -> Optional[sympy.Integer]:
             return sympy.Integer(len(arg))
 
     is_Integer = True
-Len.__name__ = 'len'
 
 
+Len.__name__ = 'len'
+
 sympify_namespace = {'len': Len,
                      'Len': Len,
                      'Broadcast': Broadcast}
 
+#########################################
+### Functions for numpy compatability ###
+#########################################
 
 def numpy_compatible_mul(*args) -> Union[sympy.Mul, sympy.Array]:
     if any(isinstance(a, sympy.NDimArray) for a in args):
@@ -126,14 +436,9 @@ def to_numpy(sympy_array: sympy.NDimArray) -> numpy.ndarray:
             return numpy.asarray(sympy_array)
     return numpy.array(sympy_array.tolist())
 
-
-def get_subscripted_symbols(expression: str) -> set:
-    # track all symbols that are subscipted in here
-    indexed_base_finder = IndexedBasedFinder()
-    sympy.sympify(expression, locals=indexed_base_finder)
-
-    return indexed_base_finder.indexed_base
-
+#######################################################################################################
+### Custom sympify method (which introduces all utility methods defined above into the sympy world) ###
+#######################################################################################################
 
 def sympify(expr: Union[str, Number, sympy.Expr, numpy.str_], **kwargs) -> sympy.Expr:
     if isinstance(expr, numpy.str_):
@@ -141,18 +446,18 @@ def sympify(expr: Union[str, Number, sympy.Expr, numpy.str_], **kwargs) -> sympy
         # It seems to ignore the locals argument
         expr = str(expr)
     try:
-        return sympy.sympify(expr, **kwargs, locals=sympify_namespace)
-    except TypeError as err:
-        if True:#err.args[0] == "'Symbol' object is not subscriptable":
-
-            indexed_base = get_subscripted_symbols(expr)
-            return sympy.sympify(expr, **kwargs, locals={**{k: sympy.IndexedBase(k)
-                                                            for k in indexed_base},
-                                                         **sympify_namespace})
+        # first try to use vanilla sympify for parsing -> faster for standard sympy syntax and namespaces without subscripted symbols
+        return sympy.sympify(expr, **kwargs, locals={**sympify_namespace, **{k: SymbolNamespace for k in namespace_identifiers}})
+    except (TypeError, AttributeError):
+        # expression contains custom syntax: subscripted or namcespace symbols, do custom symbol parsing
+        namespace_symbols = get_symbols_for_custom_syntax(expr)
+        locals = {**namespace_symbols, **sympify_namespace}
+        return sympy.sympify(expr, **kwargs, locals=locals) # todo [2018-11]: until here we invoke 3 times sympy, can we do this better?
 
-        else:
-            raise
 
+###############################################################################
+### Utility functions for expression manipulation/simplification/evaluation ###
+###############################################################################
 
 def get_most_simple_representation(expression: sympy.Expr) -> Union[str, int, float]:
     if expression.free_symbols:
@@ -165,37 +470,46 @@ def get_most_simple_representation(expression: sympy.Expr) -> Union[str, int, fl
         return str(expression)
 
 
-def get_free_symbols(expression: sympy.Expr) -> Sequence[sympy.Symbol]:
-    return tuple(symbol
-                 for symbol in expression.free_symbols
-                 if not isinstance(symbol, sympy.Indexed))
+def get_free_symbols(expression: sympy.Expr) -> Set[sympy.Symbol]:
+    return set(symbol
+               for symbol in expression.free_symbols
+               if not isinstance(symbol, sympy.Indexed))
+
+def get_variables(expression: sympy.Expr) -> Set[str]:
+    return set(map(str, get_free_symbols(expression)))
 
+def get_root_level_namespaces(expression: sympy.Expr) -> Set[SymbolNamespace]:
+    return set(symbol._root_namespace
+               for symbol in expression.free_symbols
+               if isinstance(symbol, NamespacedSymbol))
 
-def get_variables(expression: sympy.Expr) -> Sequence[str]:
-    return tuple(map(str, get_free_symbols(expression)))
+def get_root_level_namespace_ids(expression: sympy.Expr) -> Set[str]:
+    return set(n._inner_name for n in get_root_level_namespaces(expression))
 
 
 def substitute_with_eval(expression: sympy.Expr,
                          substitutions: Dict[str, Union[sympy.Expr, numpy.ndarray, str]]) -> sympy.Expr:
-    """Substitutes only sympy.Symbols. Workaround for numpy like array behaviour. ~Factor 3 slower compared to subs"""
-    substitutions = {k: v if isinstance(v, sympy.Expr) else sympify(v)
-                     for k, v in substitutions.items()}
-
-    for symbol in get_free_symbols(expression):
-        symbol_name = str(symbol)
-        if symbol_name not in substitutions:
-            substitutions[symbol_name] = symbol
-
-    string_representation = sympy.srepr(expression)
-    return eval(string_representation, sympy.__dict__, {'Symbol': substitutions.__getitem__,
-                                                        'Mul': numpy_compatible_mul})
+    raise NotImplementedError()
+    # """Substitutes only sympy.Symbols. Workaround for numpy like array behaviour. ~Factor 3 slower compared to subs"""
+    # substitutions = {k: v if isinstance(v, sympy.Expr) else sympify(v)
+    #                  for k, v in substitutions.items()}
+    #
+    # for symbol in get_free_symbols(expression):
+    #     symbol_name = str(symbol)
+    #     if symbol_name not in substitutions:
+    #         substitutions[symbol_name] = symbol
+    #
+    # string_representation = sympy.srepr(expression)
+    # return eval(string_representation, sympy.__dict__, {'Symbol': substitutions.__getitem__,
+    #                                                     'Mul': numpy_compatible_mul,
+    #                                                     **sympify_namespace})
 
 
 def _recursive_substitution(expression: sympy.Expr,
                            substitutions: Dict[sympy.Symbol, sympy.Expr]) -> sympy.Expr:
     if not expression.free_symbols:
         return expression
-    elif expression.func is sympy.Symbol:
+    elif isinstance(expression, sympy.Symbol):
         return substitutions.get(expression, expression)
 
     elif expression.func is sympy.Mul:
@@ -206,12 +520,16 @@ def _recursive_substitution(expression: sympy.Expr,
     return func(*(_recursive_substitution(arg, substitutions) for arg in expression.args))
 
 
-def recursive_substitution(expression: sympy.Expr,
+def recursive_substitution(expression: Union[sympy.Expr, numpy.ndarray],
                            substitutions: Dict[str, Union[sympy.Expr, numpy.ndarray, str]]) -> sympy.Expr:
-    substitutions = {sympy.Symbol(k): sympify(v) for k, v in substitutions.items()}
+    if isinstance(expression, numpy.ndarray):
+        vecfun = numpy.vectorize(recursive_substitution, excluded=('substitutions'))
+        return vecfun(expression, substitutions)
+        #return numpy.array(recursive_substitution(elem) for elem in expression)
+    substitutions = {sympify(k): sympify(v) for k, v in substitutions.items()}
     for s in get_free_symbols(expression):
         substitutions.setdefault(s, s)
-    return _recursive_substitution(expression, substitutions)
+    return _recursive_substitution(expression, substitutions).doit()
 
 
 _base_environment = {'builtins': builtins, '__builtins__':  builtins}
@@ -225,24 +543,60 @@ def recursive_substitution(expression: sympy.Expr,
 def evaluate_compiled(expression: sympy.Expr,
              parameters: Dict[str, Union[numpy.ndarray, Number]],
              compiled: CodeType=None, mode=None) -> Tuple[any, CodeType]:
-    if compiled is None:
-        compiled = compile(sympy.printing.lambdarepr.lambdarepr(expression),
-                           '<string>', 'eval')
-
-    if mode == 'numeric' or mode is None:
-        result = eval(compiled, parameters.copy(), _numpy_environment)
-    elif mode == 'exact':
-        result = eval(compiled, parameters.copy(), _sympy_environment)
-    else:
-        raise ValueError("Unknown mode: '{}'".format(mode))
+    raise NotImplementedError()
+    # if compiled is None:
+    #     compiled = compile(sympy.printing.lambdarepr.lambdarepr(expression),
+    #                        '<string>', 'eval')
+    #
+    # if mode == 'numeric' or mode is None:
+    #     result = eval(compiled, parameters.copy(), _numpy_environment)
+    # elif mode == 'exact':
+    #     result = eval(compiled, parameters.copy(), _sympy_environment)
+    # else:
+    #     raise ValueError("Unknown mode: '{}'".format(mode))
+    #
+    # return result, compiled
+
+
+def flatten_parameter_dict(parameters: Dict[str, Union[numpy.ndarray, Number, Dict]]) -> Dict[str, Union[numpy.ndarray, Number]]:
+    """ Transforms a nested parameter dictionary into a flat dictionary with namespace-qualified keys.
+
+    e.g. `{'foo': {'a': 3}, 'c': 7}` turns into `{'NS(foo).a': 3, 'c': 7}`
+    """
+    result = dict()
+    for k, v in parameters.items():
+        if isinstance(v, dict):
+            flat_v = flatten_parameter_dict(v)
+            result.update(**{'NS({}){}{}'.format(k, namespace_separator, ik):iv for ik, iv in flat_v.items()})
+        else:
+            result[k] = v
+    return result
+
 
-    return result, compiled
+lambdified_namespace_separator = '____'
+parameter_namespace_filter_regex = re.compile(r'(NS|SymbolNamespace)\(["\']?(\w+)["\']?\)\.')
 
 
 def evaluate_lambdified(expression: Union[sympy.Expr, numpy.ndarray],
                         variables: Sequence[str],
-                        parameters: Dict[str, Union[numpy.ndarray, Number]],
+                        parameters: Dict[str, Union[numpy.ndarray, Number, Dict]],
                         lambdified) -> Tuple[Any, Any]:
+    # mapping namespaced parameter names to something that doesn't provoke syntax errors when used as argument for lambda
+    # NS(foo).bar -> foo____bar
+    name_map = {v:parameter_namespace_filter_regex.sub(r'\2' + lambdified_namespace_separator, v) for v in variables}
+    variables = name_map.values()
+    parameters = {name_map[k]: v for k, v in parameters.items()}
+    substitutions = {sympy.Symbol(k):sympy.Symbol(v) for k, v in name_map.items()}
+
+    # while I've tried overloading the corresponding printing functions (_pythoncode, _lambdacode, _numpycode) of
+    # NamespacedSymbol (and thus NamespacedIndexedBase) and SymbolNamespace to produce the above renamed identifier,
+    # these are not reliable called by the code printers when nested in numpy arrays, sums, etc..
+    # -> perform symbol substitution up front
+    if isinstance(expression, numpy.ndarray):
+        expression = recursive_substitution(expression, substitutions)
+    else:
+        expression = expression.subs(substitutions)
+
     lambdified = lambdified or sympy.lambdify(variables, expression, _lambdify_modules)
 
     return lambdified(**parameters), lambdified
diff --git a/tests/expression_tests.py b/tests/expression_tests.py
index c6097a1dd..098a0c30a 100644
--- a/tests/expression_tests.py
+++ b/tests/expression_tests.py
@@ -49,6 +49,21 @@ def test_evaluate_numeric_2d(self) -> None:
             params['a'] = sympify('h')
             e.evaluate_numeric(**params)
 
+    def test_evaluate_numeric_namespaces(self) -> None:
+        e = ExpressionVector(['NS(foo).bar * NS(foo).NS(special).bar', 'NS(foo).b + c'])
+        params = {
+            'foo': {
+                'bar': 0.5,
+                'b': -1,
+                'special': {
+                    'bar': 0.5
+                }
+            },
+            'c': 2
+        }
+        np.testing.assert_equal(np.array([0.5*0.5,-1+2]),
+                                e.evaluate_numeric(**params))
+
     def test_partial_evaluation(self):
         e = ExpressionVector(['a * b + c', 'a + d'])
 
@@ -125,6 +140,34 @@ def test_evaluate_numpy(self):
         }
         np.testing.assert_equal((2 * 1.5 - 7) * np.ones(4), e.evaluate_numeric(**params))
 
+    def test_evaluate_numeric_namespaces(self) -> None:
+        e = ExpressionScalar('NS(foo).bar * NS(foo).NS(special).bar + NS(foo).b + c')
+        params = {
+            'foo': {
+                'bar': 0.5,
+                'b': -1,
+                'special': {
+                    'bar': 0.5
+                }
+            },
+            'c': 2
+        }
+        self.assertEqual(0.5*0.5-1+2, e.evaluate_numeric(**params))
+
+    def test_evaluate_numeric_namespaces_numpy(self) -> None:
+        e = ExpressionScalar('NS(foo).bar * NS(foo).NS(special).bar + NS(foo).b + c')
+        params = {
+            'foo': {
+                'bar': 0.5*np.ones(4),
+                'b': -1*np.ones(4),
+                'special': {
+                    'bar': 0.5*np.ones(4)
+                }
+            },
+            'c': 2*np.ones(4)
+        }
+        np.testing.assert_equal((0.5*0.5-1+2) * np.ones(4), e.evaluate_numeric(**params))
+
     def test_indexing(self):
         e = ExpressionScalar('a[i] * c')
 
@@ -147,6 +190,13 @@ def test_partial_evaluation(self) -> None:
         expected = ExpressionScalar('a * 5.5')
         self.assertEqual(expected.underlying_expression, evaluated.underlying_expression)
 
+    def test_partial_evaluation_namespaces(self) -> None:
+        e = ExpressionScalar('NS(foo).a * NS(foo).c')
+        params = {'foo': {'c': 5.5}}
+        evaluated = e.evaluate_symbolic(params)
+        expected = ExpressionScalar('NS(foo).a * 5.5')
+        self.assertEqual(expected.underlying_expression, evaluated.underlying_expression)
+
     def test_partial_evaluation_vectorized(self) -> None:
         e = ExpressionScalar('a[i] * c')
 
@@ -201,6 +251,21 @@ def test_evaluate_symbolic(self):
         expected = ExpressionScalar('d*b-7')
         self.assertEqual(result, expected)
 
+    def test_evaluate_symbolic_namespaces(self):
+        e = ExpressionScalar('NS(foo).bar * NS(foo).NS(special).bar + NS(foo).b + c')
+        params = {
+            'foo': {
+                'bar': -7,
+                'special': {
+                    'bar': 'NS(foo).x'
+                },
+            },
+            'c': 'NS(foo).x'
+        }
+        result = e.evaluate_symbolic(params)
+        expected = ExpressionScalar('-7*NS(foo).x + NS(foo).b + NS(foo).x')
+        self.assertEqual(result, expected)
+
     def test_variables(self) -> None:
         e = ExpressionScalar('4 ** pi + x * foo')
         expected = sorted(['foo', 'x'])
diff --git a/tests/pulses/mapping_pulse_template_tests.py b/tests/pulses/mapping_pulse_template_tests.py
index 1917aaa2a..83fd3f03e 100644
--- a/tests/pulses/mapping_pulse_template_tests.py
+++ b/tests/pulses/mapping_pulse_template_tests.py
@@ -2,8 +2,7 @@
 from unittest import mock
 import itertools
 
-from qupulse.pulses.mapping_pulse_template import MissingMappingException,\
-    UnnecessaryMappingException, MappingPulseTemplate,\
+from qupulse.pulses.mapping_pulse_template import UnnecessaryMappingException, MappingPulseTemplate,\
     AmbiguousMappingException, MappingCollisionException
 from qupulse.pulses.parameters import ConstantParameter, ParameterConstraintViolation, ParameterConstraint, ParameterNotProvidedException
 from qupulse.expressions import Expression
@@ -24,10 +23,6 @@ def test_init_exceptions(self):
         template = DummyPulseTemplate(parameter_names={'foo', 'bar'}, defined_channels={'A'}, measurement_names={'B'})
         parameter_mapping = {'foo': 't*k', 'bar': 't*l'}
 
-        with self.assertRaises(MissingMappingException):
-            MappingPulseTemplate(template, parameter_mapping={}, allow_partial_parameter_mapping=False)
-        with self.assertRaises(MissingMappingException):
-            MappingPulseTemplate(template, parameter_mapping={'bar': 'kneipe'}, allow_partial_parameter_mapping=False)
         with self.assertRaises(UnnecessaryMappingException):
             MappingPulseTemplate(template, parameter_mapping=dict(**parameter_mapping, foobar='asd'))
 
@@ -175,6 +170,20 @@ def test_map_parameters(self):
         for k, v in st.map_parameters(parameters).items():
             self.assertEqual(v, values[k])
 
+    def test_map_namespaces(self):
+        template = DummyPulseTemplate(parameter_names={'NS(foo).a', 'NS(foo).b', 'NS(bar).a', 'NS(foo).NS(bar).a'})
+        st = MappingPulseTemplate(template, parameter_mapping={'NS(foo).b': 't*k', 'NS(bar).a': 't*l'},
+                                  namespace_mapping={'NS(foo)': 'NS(bar)', 'NS(bar)': 'NS(scope)'})
+
+        parameters = {'t': ConstantParameter(3), 'k': ConstantParameter(2), 'l': ConstantParameter(7),
+                      'bar': {'a': ConstantParameter(1), 'bar': {'a': ConstantParameter(2)}}}
+        values = {'NS(foo).b': 6, 'NS(bar).a': 21, 'NS(foo).a': 1, 'NS(foo).NS(bar).a': 2}
+        for k, v in st.map_parameters(parameters).items():
+            self.assertEqual(v.get_value(), values[k])
+        parameters.popitem()
+        with self.assertRaises(ParameterNotProvidedException):
+             st.map_parameters(parameters)
+
     def test_partial_parameter_mapping(self):
         template = DummyPulseTemplate(parameter_names={'foo', 'bar'})
         st = MappingPulseTemplate(template, parameter_mapping={'foo': 't*k'}, allow_partial_parameter_mapping=True)
@@ -239,6 +248,13 @@ def test_integral(self) -> None:
 
         self.assertEqual({'default': Expression('2*f'), 'other': Expression('-3.2*f+2.3')}, pulse.integral)
 
+    def test_namespace_mapping(self) -> None:
+        template = DummyPulseTemplate(parameter_names={'foo', 'NS(outer).NS(inner).bar', 'NS(inner).bar', 'NS(outer).bar', 'NS(outer).NS(inner).foo'})
+        st = MappingPulseTemplate(template,
+                                  namespace_mapping={'NS(outer).NS(inner)': 'NS(combined)', 'NS(inner)': 'NS(bla)'},
+                                  parameter_mapping={'NS(outer).NS(inner).bar': 'NS(bla).a *c'})
+        self.assertEqual({'foo', 'NS(outer).bar', 'NS(bla).bar', 'NS(combined).foo', 'NS(bla).a', 'c'}, st.parameter_names)
+
 
 class MappingPulseTemplateSequencingTest(MeasurementWindowTestCase):
 
@@ -403,6 +419,46 @@ def test_create_program_subtemplate_none(self) -> None:
         program_old = MultiChannelProgram(block, channels={'A'}).programs[frozenset({'A'})]
         self.assertEqual(program_old, program)
 
+    def test_create_program_namespaces(self) -> None:
+        measurement_mapping = {'meas1': 'meas2'}
+        parameter_mapping = {'NS(foo).t': 'k'}
+        namespace_mapping = {'foo': 'bar'}
+        channel_mapping = {'B': 'default'}
+        global_transformation = TransformationStub()
+        to_single_waveform = {'tom', 'jerry'}
+
+        template = DummyPulseTemplate(measurements=[('meas1', 0, 1)], measurement_names={'meas1'}, defined_channels={'B'},
+                                      waveform=DummyWaveform(duration=2.0),
+                                      duration=2,
+                                      parameter_names={'NS(foo).t', 'NS(foo).a'})
+        st = MappingPulseTemplate(template, parameter_mapping=parameter_mapping,
+                                  measurement_mapping=measurement_mapping, channel_mapping=channel_mapping,
+                                  namespace_mapping=namespace_mapping)
+
+        pre_parameters = {'k': ConstantParameter(5), 'NS(foo).a': ConstantParameter(3)}
+        pre_measurement_mapping = {'meas2': 'meas3'}
+        pre_channel_mapping = {'default': 'A'}
+
+        program = Loop()
+        expected_inner_args = dict(parameters=st.map_parameters(pre_parameters),
+                                   measurement_mapping=st.get_updated_measurement_mapping(pre_measurement_mapping),
+                                   channel_mapping=st.get_updated_channel_mapping(pre_channel_mapping),
+                                   to_single_waveform=to_single_waveform,
+                                   global_transformation=global_transformation,
+                                   parent_loop=program)
+
+        with mock.patch.object(template, '_create_program') as inner_create_program:
+            st._internal_create_program(parameters=pre_parameters,
+                                        measurement_mapping=pre_measurement_mapping,
+                                        channel_mapping=pre_channel_mapping,
+                                        to_single_waveform=to_single_waveform,
+                                        global_transformation=global_transformation,
+                                        parent_loop=program)
+            inner_create_program.assert_called_once_with(**expected_inner_args)
+
+        # as we mock the inner function there shouldnt be any changes
+        self.assertEqual(program, Loop())
+
     def test_same_channel_error(self):
 
         dpt = DummyPulseTemplate(defined_channels={'A', 'B'})
@@ -446,11 +502,6 @@ def test_requires_stop(self):
 
 class PulseTemplateParameterMappingExceptionsTests(unittest.TestCase):
 
-    def test_missing_mapping_exception_str(self) -> None:
-        dummy = DummyPulseTemplate()
-        exception = MissingMappingException(dummy, 'foo')
-        self.assertIsInstance(str(exception), str)
-
     def test_unnecessary_mapping_exception_str(self) -> None:
         dummy = DummyPulseTemplate()
         exception = UnnecessaryMappingException(dummy, 'foo')
diff --git a/tests/pulses/pulse_template_tests.py b/tests/pulses/pulse_template_tests.py
index 304f13a79..870af8163 100644
--- a/tests/pulses/pulse_template_tests.py
+++ b/tests/pulses/pulse_template_tests.py
@@ -297,21 +297,21 @@ def test_create_program_defaults(self) -> None:
             _internal_create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=program)
         self.assertEqual(expected_program, program)
 
-    def test_create_program_channel_mapping(self):
-        template = PulseTemplateStub(defined_channels={'A', 'B'})
 
-        expected_internal_kwargs = dict(parameters=dict(),
+    def test_create_program_namespaced_params(self):
+        template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'NS(foo).bar', 'k'})
+
+        expected_internal_kwargs = dict(parameters={'NS(foo).bar': ConstantParameter(7), 'k': ConstantParameter(2)},
                                         measurement_mapping=dict(),
-                                        channel_mapping={'A': 'C', 'B': 'B'},
+                                        channel_mapping={'A': 'A'},
                                         global_transformation=None,
                                         to_single_waveform=set())
 
         with mock.patch.object(template, '_internal_create_program') as _internal_create_program:
-            template.create_program(channel_mapping={'A': 'C'})
+            template.create_program(parameters={'foo': {'bar': ConstantParameter(7)}, 'k': ConstantParameter(2)})
 
             _internal_create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=Loop())
 
-
     def test_create_program_none(self) -> None:
         template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'})
         parameters = {'foo': ConstantParameter(2.126), 'bar': -26.2, 'hugo': 'exp(sin(pi/2))'}
diff --git a/tests/pulses/table_pulse_template_tests.py b/tests/pulses/table_pulse_template_tests.py
index 23acfa189..e4a9f8b24 100644
--- a/tests/pulses/table_pulse_template_tests.py
+++ b/tests/pulses/table_pulse_template_tests.py
@@ -651,6 +651,26 @@ def test_requires_stop(self) -> None:
         for expected_result, parameter_set, condition_set in test_sets:
             self.assertEqual(expected_result, table.requires_stop(parameter_set, condition_set))
 
+    def test_build_waveform_namespaces(self) -> None:
+        entry_list = [(0, 0),
+                      ('NS(simple_pulse).tx', 'NS(simple_pulse).x', 'hold'),
+                      ('NS(simple_pulse).ty', 'NS(simple_pulse).y', 'linear'),
+                      ('NS(all_pulses).t_end', 0, 'jump')]
+        entries = {0: entry_list}
+
+        template = TablePulseTemplate(entries)
+        #parameters = {'simple_pulse': {'tx': 2, 'ty': 4, 'x': 2, 'y': 3}, 'all_pulses': {'t_end': 6}}
+        parameters = {'NS(simple_pulse).tx': 2, 'NS(simple_pulse).ty': 4, 'NS(simple_pulse).x': 2, 'NS(simple_pulse).y': 3, 'NS(all_pulses).t_end': 6}
+
+        waveform = template.build_waveform(parameters=parameters, channel_mapping={0: 0})
+
+        self.assertIsInstance(waveform, TableWaveform)
+        self.assertEqual(waveform._table,
+                         ((0, 0, HoldInterpolationStrategy()),
+                          (2, 2, HoldInterpolationStrategy()),
+                          (4, 3, LinearInterpolationStrategy()),
+                          (6, 0, JumpInterpolationStrategy())))
+        self.assertEqual(waveform._channel_id, 0)
 
 
 class TablePulseConcatenationTests(unittest.TestCase):
diff --git a/tests/utils/sympy_tests.py b/tests/utils/sympy_tests.py
index 8811c07fc..e3763d4d7 100644
--- a/tests/utils/sympy_tests.py
+++ b/tests/utils/sympy_tests.py
@@ -8,15 +8,18 @@
 import sympy
 import numpy as np
 
-from sympy.abc import a, b, c, d, e, f, k, l, m, n, i, j
+from sympy.abc import a, b, c, d, e, f, k, l, m, n, i, j, x, y, z
 from sympy import sin, Sum, IndexedBase
 
-a_ = IndexedBase(a)
-b_ = IndexedBase(b)
-
 from qupulse.utils.sympy import sympify as qc_sympify, substitute_with_eval, recursive_substitution, Len,\
     evaluate_lambdified, evaluate_compiled, get_most_simple_representation, get_variables, get_free_symbols,\
-    almost_equal, Broadcast
+    almost_equal, SymbolNamespace, NamespacedSymbol, NamespaceIndexedBase, subs_namespaces, Broadcast
+
+a_ = IndexedBase(a)
+b_ = IndexedBase(b)
+foo_bar = NamespacedSymbol('bar', namespace=SymbolNamespace('foo'))
+foo_bar_ = NamespaceIndexedBase('bar', namespace=SymbolNamespace('foo'))
+scope_n = NamespacedSymbol('n', namespace=SymbolNamespace('scope'))
 
 
 ################################################### SUBSTITUTION #######################################################
@@ -24,29 +27,43 @@
     (a*b, {'a': c}, b*c),
     (a*b, {'a': b, 'b': a}, a*b),
     (a*b, {'a': 1, 'b': 2}, 2),
+    (foo_bar*b, {'NS(foo).bar': c}, b*c),
+    (foo_bar*b, {'b': scope_n}, scope_n*foo_bar),
+    (foo_bar*b, {'b': foo_bar, 'NS(foo).bar': b}, foo_bar*b),
+    (foo_bar*scope_n, {'NS(foo).bar': scope_n, 'NS(scope).n': foo_bar}, foo_bar*scope_n),
+    (foo_bar*b, {'NS(foo).bar': 5, 'b': 0.2}, 0.2*5)
 ]
 
 elem_func_substitution_cases = [
     (a*b + sin(c), {'a': b, 'c': sympy.pi/2}, b**2 + 1),
+    (a*scope_n + sin(foo_bar), {'a': scope_n, 'NS(foo).bar': sympy.pi/2}, scope_n**2 + 1)
 ]
 
 sum_substitution_cases = [
     (a*b + Sum(c * k, (k, 0, n)), {'a': b, 'b': 2, 'k': 1, 'n': 2}, b*2 + c*(1 + 2)),
+    (a*foo_bar + Sum(c * k, (k, 0, scope_n)), {'a': foo_bar, 'NS(foo).bar': 2, 'k': 1, 'NS(scope).n': 2}, foo_bar*2 + c*(1 + 2)),
 ]
 
 indexed_substitution_cases = [
-    (a_[i]*b, {'b': 3}, a_[i]*3),
-    (a_[i]*b, {'a': sympy.Array([1, 2, 3])}, sympy.Array([1, 2, 3])[i]*b),
-    (sympy.Array([1, 2, 3])[i]*b, {'i': 1}, 2*b)
+    (a_[i] * b, {'b': 3}, a_[i] * 3),
+    (a_[i] * b, {'a': sympy.Array([1, 2, 3])}, sympy.Array([1, 2, 3])[i] * b),
+    (sympy.Array([1, 2, 3])[i] * b, {'i': 1}, 2 * b),
+    (foo_bar_[i]*scope_n, {'NS(scope).n': 3}, foo_bar_[i]*3),
+    (foo_bar_[i]*scope_n, {'NS(foo).bar': sympy.Array([1, 2, 3])}, sympy.Array([1, 2, 3])[i]*scope_n),
+    (sympy.Array([1, 2, 3])[foo_bar]*b, {'NS(foo).bar': 1}, 2*b),
 ]
 
 vector_valued_cases = [
     (a*b, {'a': sympy.Array([1, 2, 3])}, sympy.Array([1, 2, 3])*b),
     (a*b, {'a': sympy.Array([1, 2, 3]), 'b': sympy.Array([4, 5, 6])}, sympy.Array([4, 10, 18])),
+    (foo_bar*b, {'NS(foo).bar': sympy.Array([1, 2, 3])}, sympy.Array([1, 2, 3])*b),
+    (foo_bar*b, {'NS(foo).bar': sympy.Array([1, 2, 3]), 'b': sympy.Array([4, 5, 6])}, sympy.Array([4, 10, 18])),
+    (foo_bar*scope_n, {'NS(foo).bar': sympy.Array([1, 2, 3]), 'NS(scope).n': sympy.Array([4, 5, 6])}, sympy.Array([4, 10, 18])),
 ]
 
 full_featured_cases = [
     (Sum(a_[i], (i, 0, Len(a) - 1)), {'a': sympy.Array([1, 2, 3])}, 6),
+    (Sum(foo_bar_[i], (i, 0, Len(foo_bar) - 1)), {'NS(foo).bar': sympy.Array([1, 2, 3])}, 6),
 ]
 
 
@@ -54,11 +71,14 @@
 simple_sympify = [
     ('a*b', a*b),
     ('a*6', a*6),
-    ('sin(a)', sin(a))
+    ('sin(a)', sin(a)),
+    ('SymbolNamespace(\'foo\').bar*6', foo_bar*6),
+    ('sin(SymbolNamespace(\'foo\').bar)', sin(foo_bar))
 ]
 
 complex_sympify = [
     ('Sum(a, (i, 0, n))', Sum(a, (i, 0, n))),
+    ('Sum(NS(foo).bar, (i, 0, m))', Sum(foo_bar, (i, 0, m)))
 ]
 
 len_sympify = [
@@ -67,7 +87,8 @@
 ]
 
 index_sympify = [
-    ('a[i]', a_[i])
+    ('a[i]', a_[i]),
+    ('SymbolNamespace(foo).bar[i]', foo_bar_[i])
 ]
 
 
@@ -75,29 +96,39 @@
 eval_simple = [
     (a*b, {'a': 2, 'b': 3}, 6),
     (a*b, {'a': 2, 'b': np.float32(3.5)}, 2*np.float32(3.5)),
-    (a+b, {'a': 3.4, 'b': 76.7}, 3.4+76.7)
+    (a+b, {'a': 3.4, 'b': 76.7}, 3.4+76.7),
+    (foo_bar+scope_n, {'NS(foo).bar': 1.2, 'NS(scope).n': 3.3}, 1.2+3.3),
+    (foo_bar*scope_n, {'NS(foo).bar': 1.2, 'NS(scope).n': np.float32(3.3)}, 1.2*np.float32(3.3)),
+    (foo_bar*scope_n, {'NS(foo).bar': 1.2, 'NS(scope).n': 3.3}, 1.2*3.3)
 ]
 
 eval_many_arguments = [
-    (sum(sympy.symbols(list('a_' + str(i) for i in range(300)))), {'a_' + str(i): 1 for i in range(300)}, 300)
+    (sum(sympy.symbols(list('a_' + str(i) for i in range(300)))), {'a_' + str(i): 1 for i in range(300)}, 300),
+    (sum(list(NamespacedSymbol('a_' + str(i), namespace=SymbolNamespace('scope')) for i in range(300))), {'NS(scope).a_' + str(i): 1 for i in range(300)}, 300)
 ]
 
 eval_simple_functions = [
-    (a*sin(b), {'a': 3.5, 'b': 1.2}, 3.5*math.sin(1.2))
+    (a*sin(b), {'a': 3.5, 'b': 1.2}, 3.5*math.sin(1.2)),
+    (a*sin(foo_bar), {'a': 3.5, 'NS(foo).bar': 1.2}, 3.5*math.sin(1.2)),
 ]
 
 eval_array_values = [
-    (a*b, {'a': 2, 'b': np.array([3])}, np.array([6])),
-    (a*b, {'a': 2, 'b': np.array([3, 4, 5])}, np.array([6, 8, 10])),
-    (a*b, {'a': np.array([2, 3]), 'b': np.array([100, 200])}, np.array([200, 600]))
+    (a * b, {'a': 2, 'b': np.array([3])}, np.array([6])),
+    (a * b, {'a': 2, 'b': np.array([3, 4, 5])}, np.array([6, 8, 10])),
+    (a * b, {'a': np.array([2, 3]), 'b': np.array([100, 200])}, np.array([200, 600])),
+    (a * foo_bar, {'a': 2, 'NS(foo).bar': np.array([3])}, np.array([6])),
+    (a * foo_bar, {'a': 2, 'NS(foo).bar': np.array([3, 4, 5])}, np.array([6, 8, 10])),
+    (a * foo_bar, {'a': np.array([2, 3]), 'NS(foo).bar': np.array([100, 200])}, np.array([200, 600])),
 ]
 
 eval_sum = [
     (Sum(a_[i], (i, 0, Len(a) - 1)), {'a': np.array([1, 2, 3])}, 6),
+    (Sum(foo_bar_[i], (i, 0, Len(foo_bar) - 1)), {'NS(foo).bar': np.array([1, 2, 3])}, 6),
 ]
 
 eval_array_expression = [
-    (np.array([a*c, b*c]), {'a': 2, 'b': 3, 'c': 4}, np.array([8, 12]))
+    (np.array([a*c, b*c]), {'a': 2, 'b': 3, 'c': 4}, np.array([8, 12])),
+    (np.array([a*foo_bar, scope_n*foo_bar]), {'a': 2, 'NS(scope).n': 3, 'NS(foo).bar': 4}, np.array([8, 12]))
 ]
 
 
@@ -110,69 +141,59 @@ def assertRaises(self, expected_exception, *args, **kwargs):
 
 
 class SympifyTests(TestCase):
-    def sympify(self, expression):
-        return sympy.sympify(expression)
+
+    def sympify(self, expression) -> sympy.Expr:
+        waa = qc_sympify(expression)
+        return waa
 
     def assertEqual1(self, first, second, msg=None):
         if sympy.Eq(first, second):
             return
         raise self.failureException(msg=msg)
 
-    def test_simple_sympify(self):
+    def test_simple_sympify(self) -> None:
         for s, expected in simple_sympify:
             result = self.sympify(s)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
-    def test_complex_sympify(self):
+    def test_complex_sympify(self) -> None:
         for s, expected in complex_sympify:
             result = self.sympify(s)
-            self.assertEqual(result, expected)
-
-    def test_len_sympify(self, expected_exception=AssertionError, msg="sympy.sympify does not know len"):
-        with self.assertRaises(expected_exception=expected_exception, msg=msg):
-            for s, expected in len_sympify:
-                result = self.sympify(s)
-                self.assertEqual(result, expected)
-
-    def test_index_sympify(self, expected_exception=TypeError):
-        with self.assertRaises(expected_exception=expected_exception):
-            for s, expected in index_sympify:
-                result = self.sympify(s)
-                self.assertEqual(result, expected)
-
+            self.assertEqual(expected, result)
 
-class SympifyWrapperTests(SympifyTests):
-    def sympify(self, expression):
-        return qc_sympify(expression)
-
-    def test_len_sympify(self):
-        super().test_len_sympify(None)
+    def test_len_sympify(self) -> None:
+        for s, expected in len_sympify:
+            result = self.sympify(s)
+            self.assertEqual(expected, result)
 
-    def test_index_sympify(self):
-        super().test_index_sympify(None)
+    def test_index_sympify(self) -> None:
+        for s, expected in index_sympify:
+            result = self.sympify(s)
+            self.assertEqual(expected, result)
 
 
 class SubstitutionTests(TestCase):
     def substitute(self, expression: sympy.Expr, substitutions: dict):
         for key, value in substitutions.items():
             if not isinstance(value, sympy.Expr):
-                substitutions[key] = sympy.sympify(value)
+                substitutions[key] = qc_sympify(value)
+                #substitutions[key] = sympy.sympify(value)
         return expression.subs(substitutions, simultaneous=True).doit()
 
     def test_simple_substitution_cases(self):
         for expr, subs, expected in simple_substitution_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result, msg=str((expr, subs, expected)))
 
     def test_elem_func_substitution_cases(self):
         for expr, subs, expected in elem_func_substitution_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_sum_substitution_cases(self):
         for expr, subs, expected in sum_substitution_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_indexed_substitution_cases(self):
         if type(self) is SubstitutionTests:
@@ -180,7 +201,7 @@ def test_indexed_substitution_cases(self):
 
         for expr, subs, expected in indexed_substitution_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_vector_valued_cases(self):
         if type(self) is SubstitutionTests:
@@ -188,7 +209,7 @@ def test_vector_valued_cases(self):
 
         for expr, subs, expected in vector_valued_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result, msg="test: {}".format((expr, subs, expected)))
 
     def test_full_featured_cases(self):
         if type(self) is SubstitutionTests:
@@ -196,9 +217,9 @@ def test_full_featured_cases(self):
 
         for expr, subs, expected in full_featured_cases:
             result = self.substitute(expr, subs)
-            self.assertEqual(result, expected)
-
+            self.assertEqual(expected, result)
 
+@unittest.SkipTest # substitute_with_eval currently not implemented"
 class SubstituteWithEvalTests(SubstitutionTests):
     def substitute(self, expression: sympy.Expr, substitutions: dict):
         return substitute_with_eval(expression, substitutions)
@@ -214,7 +235,27 @@ def test_full_featured_cases(self):
 
 class RecursiveSubstitutionTests(SubstitutionTests):
     def substitute(self, expression: sympy.Expr, substitutions: dict):
-        return recursive_substitution(expression, substitutions).doit()
+        return recursive_substitution(expression, substitutions)#.doit()
+
+    def test_array_argument(self) -> None:
+        expr = np.array([a * c, b * c])
+        substitutions = {'a': x, 'b': a, 'c': y}
+        expected = np.array([x*y, a*y])
+        result = self.substitute(expr, substitutions)
+        np.testing.assert_equal(expected, result)
+
+        expr = np.array([a * foo_bar, scope_n * foo_bar])
+        substitutions = {'a': x, 'NS(scope).n': a, 'NS(foo).bar': scope_n}
+        expected = np.array([x * scope_n, a * scope_n])
+        result = self.substitute(expr, substitutions)
+        np.testing.assert_equal(expected, result)
+
+    def test_nested_array_argument(self) -> None:
+        expr = np.array([[a * c, b * c], [a * foo_bar, scope_n * foo_bar]])
+        substitutions = {'a': x, 'b': a, 'c': y, 'NS(scope).n': a, 'NS(foo).bar': scope_n}
+        expected = np.array([[x * y, a * y], [x * scope_n, a * scope_n]])
+        result = self.substitute(expr, substitutions)
+        np.testing.assert_equal(expected, result)
 
 
 class GetFreeSymbolsTests(TestCase):
@@ -244,7 +285,7 @@ class EvaluationTestsBase:
     def test_eval_simple(self):
         for expr, parameters, expected in eval_simple:
             result = self.evaluate(expr, parameters)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_eval_many_arguments(self):
         for expr, parameters, expected in eval_many_arguments:
@@ -254,29 +295,49 @@ def test_eval_many_arguments(self):
     def test_eval_simple_functions(self):
         for expr, parameters, expected in eval_simple_functions:
             result = self.evaluate(expr, parameters)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_eval_array_values(self):
         for expr, parameters, expected in eval_array_values:
             result = self.evaluate(expr, parameters)
-            np.testing.assert_equal(result, expected)
+            np.testing.assert_equal(expected, result)
 
     def test_eval_sum(self):
         for expr, parameters, expected in eval_sum:
             result = self.evaluate(expr, parameters)
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_eval_array_expression(self):
         for expr, parameters, expected in eval_array_expression:
             result = self.evaluate(expr, parameters)
-            np.testing.assert_equal(result, expected)
+            np.testing.assert_equal(expected, result)
+
+
+class EvaluationTests(EvaluationTestsBase, unittest.TestCase):
+
+    def evaluate(self, expression: Union[sympy.Expr, np.ndarray], parameters):
+        if isinstance(expression, np.ndarray):
+            return np.array(expr.evalf(subs=parameters) for expr in expression.flat)
+        return expression.evalf(subs=parameters)
+
+    @unittest.expectedFailure
+    def test_eval_array_expression(self):
+        super().test_eval_array_expression()
+
+    @unittest.expectedFailure
+    def test_eval_array_values(self):
+        super().test_eval_array_values()
+
+    @unittest.expectedFailure
+    def test_eval_sum(self):
+        super().test_eval_sum()
 
 
 class LamdifiedEvaluationTest(EvaluationTestsBase, unittest.TestCase):
 
     def evaluate(self, expression: Union[sympy.Expr, np.ndarray], parameters):
         if isinstance(expression, np.ndarray):
-            variables = set.union(*map(set, map(get_variables, expression.flat)))
+            variables = set.union(*map(get_variables, expression.flat))
         else:
             variables = get_variables(expression)
         return evaluate_lambdified(expression, variables=list(variables), parameters=parameters, lambdified=None)[0]
@@ -285,7 +346,7 @@ def evaluate(self, expression: Union[sympy.Expr, np.ndarray], parameters):
     def test_eval_many_arguments(self):
         super().test_eval_many_arguments()
 
-
+@unittest.SkipTest
 class CompiledEvaluationTest(EvaluationTestsBase, unittest.TestCase):
 
     def evaluate(self, expression: Union[sympy.Expr, np.ndarray], parameters):
@@ -321,6 +382,10 @@ def test_get_most_simple_representation(self):
         self.assertIsInstance(st, str)
         self.assertEqual(st, 'a + b')
 
+        sym = get_most_simple_representation(qc_sympify('b + NS(foo).NS(bar).test'))
+        self.assertIsInstance(sym, str)
+        self.assertEqual('NS(foo).NS(bar).test + b', sym)
+
 
 class AlmostEqualTests(unittest.TestCase):
     def test_almost_equal(self):
@@ -331,6 +396,142 @@ def test_almost_equal(self):
         self.assertTrue(almost_equal(sympy.sin(a), sympy.sin(a) + 1e-14, epsilon=1e-13))
 
 
+class TestSubsNamespaces(unittest.TestCase):
+
+    def test_subs_namespaces(self) -> None:
+        expr = SymbolNamespace('foo').bar * a
+        result = subs_namespaces(expr, {SymbolNamespace('foo'): SymbolNamespace('oof')})
+        self.assertEqual(SymbolNamespace('oof').bar * a, result)
+        self.assertEqual(SymbolNamespace('foo').bar * a, expr) # ensure original wasnt changed
+
+    def test_subs_namespaces_nested(self) -> None:
+        expr = SymbolNamespace('foo').SymbolNamespace('bar').x * a + SymbolNamespace('bar').x
+
+        # change only NS(foo)
+        result = subs_namespaces(expr, {SymbolNamespace('foo'): SymbolNamespace('oof')})
+        self.assertEqual(SymbolNamespace('oof').SymbolNamespace('bar').x * a + SymbolNamespace('bar').x, result)
+        self.assertEqual(SymbolNamespace('foo').SymbolNamespace('bar').x * a + SymbolNamespace('bar').x, expr)
+
+        # change unnested NS(bar)
+        result = subs_namespaces(expr, {SymbolNamespace('bar'): SymbolNamespace('rab')})
+        self.assertEqual(SymbolNamespace('foo').SymbolNamespace('bar').x * a + SymbolNamespace('rab').x, result)
+        self.assertEqual(SymbolNamespace('foo').SymbolNamespace('bar').x * a + SymbolNamespace('bar').x, expr)  # ensure original wasnt changed
+
+        # change nested NS(foo).NS(bar)
+        result = subs_namespaces(expr, {SymbolNamespace('foo').SymbolNamespace('bar'): SymbolNamespace('bar')})
+        self.assertEqual(SymbolNamespace('bar').x * a + SymbolNamespace('bar').x, result)
+        self.assertEqual(SymbolNamespace('foo').SymbolNamespace('bar').x * a + SymbolNamespace('bar').x, expr)  # ensure original wasnt changed
+
+
+class NamespaceSymbolTests(unittest.TestCase):
+
+    def test_stringify_and_back(self) -> None:
+        sym = NamespacedSymbol('bar', namespace=SymbolNamespace('foo', parent=SymbolNamespace('oof')))
+        sym_str = str(sym)
+        self.assertEqual("NS(oof).NS(foo).bar", sym_str)
+        sym_sympified = qc_sympify(sym_str)
+        self.assertEqual(sym, sym_sympified)
+
+    def test_atoms(self) -> None:
+        expr = SymbolNamespace('foo').bar * 3 + SymbolNamespace('foo').c
+        self.assertEqual({SymbolNamespace('foo').bar, SymbolNamespace('foo').c}, expr.atoms(NamespacedSymbol))
+
+    def test_subs(self) -> None:
+        expr = SymbolNamespace('foo').bar * a
+        result = expr.subs({'NS(foo).bar': a})
+        self.assertEqual(a*a, result)
+
+        result = expr.subs({SymbolNamespace('foo').bar: a})
+        self.assertEqual(a * a, result)
+
+        result = expr.subs({NamespacedSymbol('bar', namespace=SymbolNamespace('foo')): a})
+        self.assertEqual(a * a, result)
+
+    def test_subs_nested(self) -> None:
+        expr = SymbolNamespace('foo').SymbolNamespace('off').bar * a
+        result = expr.subs({'NS(foo).NS(off).bar': a})
+        self.assertEqual(a * a, result)
+
+    @unittest.expectedFailure
+    def test_subs_do_not_change_namespaces(self) -> None:
+        expr = SymbolNamespace('foo').bar * a
+        result = expr.subs({'NS(foo)': 'NS(oof)'})
+        self.assertEqual(SymbolNamespace('oof').bar * a, result)
+
+
+class NamespaceTests(unittest.TestCase):
+
+    def test_illegal_name(self) -> None:
+        with self.assertRaises(AttributeError):
+            qc_sympify("qubit._forbidden")
+
+    def test_sympify_dot_namespace_notations(self) -> None:
+        expr = qc_sympify("NS('qubit').a + NS('qubit').NS('spec2').a * 1.3")
+        expected = sympy.Add(NamespacedSymbol('a', namespace=SymbolNamespace(sympy.Symbol('qubit'))),
+                             sympy.Mul(NamespacedSymbol('a',
+                                                        namespace=SymbolNamespace(sympy.Symbol('spec2'),
+                                                                                     parent=SymbolNamespace(sympy.Symbol('qubit'))))
+                                       , sympy.RealNumber(1.3)))
+        self.assertEqual(expected, expr)
+
+    def test_sympify_indexed_dot_namespace_notation(self) -> None:
+        expr = qc_sympify("NS(qubit).a[i]*1.3")
+        expected = sympy.Mul(NamespaceIndexedBase('a', namespace=SymbolNamespace('qubit'))[sympy.Symbol('i')], sympy.RealNumber(1.3))
+        self.assertEqual(expected, expr)
+
+    def test_sympify_dot_namespace_notation_as_index(self) -> None:
+        expr = qc_sympify("NS(qubit).a[NS(index_ns).i]*1.3")
+        expected = sympy.Mul(NamespaceIndexedBase('a', namespace=SymbolNamespace('qubit'))[NamespacedSymbol('i', namespace=SymbolNamespace('index_ns'))], sympy.RealNumber(1.3))
+        self.assertEqual(expected, expr)
+
+    def test_vanilla_sympify_compatability(self) -> None:
+        # taken from sympy test suite: sympy/parsing/tests/test_sympy_parser.py::test_sympy_parser()
+        x = sympy.Symbol("x")
+        inputs = {
+            '2*x': 2 * x,
+            '3.00': sympy.Float(3),
+            '22/7': sympy.Rational(22, 7),
+            '2+3j': 2 + 3 * sympy.I,
+            'exp(x)': sympy.exp(x),
+            'x!': sympy.factorial(x),
+            'x!!': sympy.factorial2(x),
+            '(x + 1)! - 1': sympy.factorial(x + 1) - 1,
+            '3.[3]': sympy.Rational(10, 3),
+            '.0[3]': sympy.Rational(1, 30),
+            '3.2[3]': sympy.Rational(97, 30),
+            '1.3[12]': sympy.Rational(433, 330),
+            '1 + 3.[3]': sympy.Rational(13, 3),
+            '1 + .0[3]': sympy.Rational(31, 30),
+            '1 + 3.2[3]': sympy.Rational(127, 30),
+            '.[0011]': sympy.Rational(1, 909),
+            '0.1[00102] + 1': sympy.Rational(366697, 333330),
+            '1.[0191]': sympy.Rational(10190, 9999),
+            '10!': 3628800,
+            '-(2)': -sympy.Integer(2),
+            '[-1, -2, 3]': [sympy.Integer(-1), sympy.Integer(-2), sympy.Integer(3)],
+            'Symbol("x").free_symbols': x.free_symbols,
+            "S('S(3).n(n=3)')": 3.00,
+            'factorint(12, visual=True)': sympy.Mul(sympy.Pow(2, 2, evaluate=False), sympy.Pow(3, 1, evaluate=False), evaluate=False),
+            'Limit(sin(x), x, 0, dir="-")': sympy.Limit(sin(x), x, 0, dir='-')
+        }
+        for text, result in inputs.items():
+            self.assertEqual(qc_sympify(text), result, msg="failed for {}".format(text))
+
+    def test_evaluate_lambdified_dot_namespace_notation(self) -> None:
+        res, _ = evaluate_lambdified(
+            qc_sympify("NS(qubit).a + NS(qubit).NS(spec2).a * 1.3"),
+            ["NS(qubit).a", "NS(qubit).NS(spec2).a"],
+            {"NS(qubit).a": 2.1, "NS(qubit).NS(spec2).a": .1},
+            lambdified=None
+        )
+        self.assertEqual(2.23, res)
+
+    @unittest.expectedFailure
+    def test_evaluate_compiled_dot_namespace_notation(self) -> None:
+        res = evaluate_compiled("NS(qubit).a + NS('qubit.spec2').a * 1.3", {"qubit.a": 2.1, "qubit.spec2.a": .1})
+        self.assertEqual(2.23, res)
+
+
 class BroadcastTests(unittest.TestCase):
     def test_symbolic_shape(self):
         symbolic = Broadcast(a, (b,))