Apps in the notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example demonstrates that Flexx apps can be run interactively in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script id='flexx-core.js'>\n",
       "/* Bundle contents:\n",
       "- asset flexx-loader.js\n",
       "- asset bsdf.js\n",
       "- asset bb64.js\n",
       "- asset pscript-std.js\n",
       "- asset flexx.event.js\n",
       "- module flexx.app._clientcore\n",
       "- module flexx.app._component2\n",
       "*/\n",
       "\n",
       "\n",
       "/* ========================== flexx-loader.js ===========================*/\n",
       "\n",
       "/*Flexx module loader. Licensed by BSD-2-clause.*/\n",
       "\n",
       "(function(){\n",
       "\n",
       "if (typeof window === 'undefined' && typeof module == 'object') {\n",
       "    throw Error('flexx.app does not run on NodeJS!');\n",
       "}\n",
       "if (typeof flexx == 'undefined') {\n",
       "    window.flexx = {};\n",
       "}\n",
       "\n",
       "var modules = {};\n",
       "function define (name, deps, factory) {\n",
       "    if (arguments.length == 1) {\n",
       "        factory = name;\n",
       "        deps = [];\n",
       "        name = null;\n",
       "    }\n",
       "    if (arguments.length == 2) {\n",
       "        factory = deps;\n",
       "        deps = name;\n",
       "        name = null;\n",
       "    }\n",
       "    // Get dependencies - in current implementation, these must be loaded\n",
       "    var dep_vals = [];\n",
       "    for (var i=0; i<deps.length; i++) {\n",
       "        if (modules[deps[i]] === undefined) {\n",
       "            throw Error('Unknown dependency: ' + deps[i]);\n",
       "        }\n",
       "        dep_vals.push(modules[deps[i]]);\n",
       "    }\n",
       "    // Load the module and store it if is not anonymous\n",
       "    var mod = factory.apply(null, dep_vals);\n",
       "    if (name) {\n",
       "        modules[name] = mod;\n",
       "    }\n",
       "}\n",
       "define.amd = true;\n",
       "define.flexx = true;\n",
       "\n",
       "function require (name) {\n",
       "    if (name.startsWith('phosphor/')) {\n",
       "        if (window.jupyter && window.jupyter.lab && window.jupyter.lab.loader) {\n",
       "            var path = 'phosphor@*/' + name.slice(9);\n",
       "            if (!path.endsWith('.js')) { path = path + '.js'; }\n",
       "            return window.jupyter.lab.loader.require(path);\n",
       "        } else {\n",
       "            return window.require_phosphor(name);  // provided by our Phosphor-all\n",
       "        }\n",
       "    }\n",
       "    if (modules[name] === undefined) {\n",
       "        throw Error('Unknown module: ' + name);\n",
       "    }\n",
       "    return modules[name];\n",
       "}\n",
       "\n",
       "// Expose this\n",
       "window.flexx.define = define;\n",
       "window.flexx.require = require;\n",
       "window.flexx._modules = modules;\n",
       "\n",
       "})();\n",
       "\n",
       "\n",
       "/* ============================== bsdf.js ===============================*/\n",
       "\n",
       "flexx.define(\"bsdf\", [], (function () {\n",
       "\"use strict\";\n",
       "\n",
       "var VERSION;\n",
       "VERSION = [2, 1, 0];\n",
       "\n",
       "// http://github.com/msgpack/msgpack-javascript/blob/master/msgpack.js#L181-L192\n",
       "function utf8encode(mix) {\n",
       "    // Mix is assumed to be a string. returns an Array of ints.\n",
       "    var iz = mix.length;\n",
       "    var rv = [];\n",
       "    for (var i = 0; i < iz; ++i) {\n",
       "        var c = mix.charCodeAt(i);\n",
       "        if (c < 0x80) { // ASCII(0x00 ~ 0x7f)\n",
       "            rv.push(c & 0x7f);\n",
       "        } else if (c < 0x0800) {\n",
       "            rv.push(((c >>>  6) & 0x1f) | 0xc0, (c & 0x3f) | 0x80);\n",
       "        } else if (c < 0x10000) {\n",
       "            rv.push(((c >>> 12) & 0x0f) | 0xe0,\n",
       "                    ((c >>>  6) & 0x3f) | 0x80, (c & 0x3f) | 0x80);\n",
       "        }\n",
       "    }\n",
       "    return rv;\n",
       "}\n",
       "\n",
       "// http://github.com/msgpack/msgpack-javascript/blob/master/msgpack.js#L365-L375\n",
       "function utf8decode(buf) {\n",
       "    // The buf is assumed to be an Array or Uint8Array. Returns a string.\n",
       "    var iz = buf.length - 1;\n",
       "    var ary = [];\n",
       "    for (var i = -1; i < iz; ) {\n",
       "        var c = buf[++i]; // lead byte\n",
       "        ary.push(c < 0x80 ? c : // ASCII(0x00 ~ 0x7f)\n",
       "                 c < 0xe0 ? ((c & 0x1f) <<  6 | (buf[++i] & 0x3f)) :\n",
       "                            ((c & 0x0f) << 12 | (buf[++i] & 0x3f) << 6\n",
       "                                              | (buf[++i] & 0x3f)));\n",
       "    }\n",
       "    return String.fromCharCode.apply(null, ary);\n",
       "}\n",
       "\n",
       "\n",
       "// ================== API\n",
       "\n",
       "function bsdf_encode(d, extensions) {\n",
       "    var s = new BsdfSerializer(extensions);\n",
       "    return s.encode(d);\n",
       "}\n",
       "\n",
       "function bsdf_decode(buf, extensions) {\n",
       "    var s = new BsdfSerializer(extensions);\n",
       "    return s.decode(buf);\n",
       "}\n",
       "\n",
       "function BsdfSerializer(extensions) {\n",
       "    /* A placeholder for a BSDF serializer with associated extensions.\n",
       "     * Other formats also use it to associate options, but we don't have any.\n",
       "     */\n",
       "    this.extensions = [];\n",
       "    if (extensions === undefined) { extensions = standard_extensions; }\n",
       "    if (!Array.isArray(extensions)) { throw \"Extensions must be an array.\"; }\n",
       "    for (var i=0; i<extensions.length; i++) {\n",
       "        this.add_extension(extensions[i]);\n",
       "    }\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.add_extension = function (e) {\n",
       "    // We use an array also as a dict for quick lookup\n",
       "    if (this.extensions[e.name] !== undefined) {\n",
       "        // Overwrite existing\n",
       "        for (var i=0; i<this.extensions.length; i++) {\n",
       "            if (this.extensions[i].name == e.name) { this.extensions[i] = e; break; }\n",
       "        }\n",
       "    } else {\n",
       "        // Append\n",
       "        this.extensions.push(e);\n",
       "        this.extensions[e.name] = e;\n",
       "    }\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.remove_extension = function (e) {\n",
       "    delete this.extensions[e.name];\n",
       "    for (var i=0; i<this.extensions.length; i++) {\n",
       "        if (this.extensions[i].name == name) { this.extensions.splice(i, 1); break; }\n",
       "    }\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.encode = function (d) {\n",
       "    // Write head and version\n",
       "    var f = ByteBuilder();\n",
       "    f.push_char('B'); f.push_char('S'); f.push_char('D'); f.push_char('F');\n",
       "    f.push_uint8(VERSION[0]); f.push_uint8(VERSION[1]);\n",
       "    // Encode and return result\n",
       "    this.encode_object(f, d);\n",
       "    return f.get_result();\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.decode = function (buf, extensions) {\n",
       "    // Read and check head\n",
       "    var f = BytesReader(buf);\n",
       "    var head = f.get_char() + f.get_char() + f.get_char() + f.get_char();\n",
       "    if (head != 'BSDF') {\n",
       "        throw \"This does not look like BSDF encoded data: \" + head;\n",
       "    }\n",
       "    // Read and check version\n",
       "    var major_version = f.get_uint8();\n",
       "    var minor_version = f.get_uint8();\n",
       "    if (major_version != VERSION[0]) {\n",
       "        throw ('Reading file with different major version ' + major_version + ' from the implementation ' + VERSION[0]);\n",
       "    } else if (minor_version > VERSION[1]){\n",
       "        console.warn('BSDF warning: reading file with higher minor version ' + minor_version + ' than the implementation ' + VERSION[1]);\n",
       "    }\n",
       "    // Decode\n",
       "    return this.decode_object(f);\n",
       "};\n",
       "\n",
       "\n",
       "//---- encoder\n",
       "\n",
       "function ByteBuilder() {\n",
       "    // We use an arraybuffer for efficiency, but we don't know its final size.\n",
       "    // Therefore we create a new one with increasing size when needed.\n",
       "    var buffers = [];\n",
       "    var min_buf_size = 1024;\n",
       "\n",
       "    var buf8 = new Uint8Array(min_buf_size);\n",
       "    var bufdv = new DataView(buf8.buffer);\n",
       "\n",
       "    var pos = 0;\n",
       "    var pos_offset = 0;\n",
       "    var pos_max = buf8.byteLength;  // max valid value of pos\n",
       "\n",
       "    // Create text encoder / decoder\n",
       "    var text_encode, text_decode;\n",
       "    if (typeof TextEncoder !== 'undefined') {\n",
       "        var x = new TextEncoder('utf-8');\n",
       "        text_encode = x.encode.bind(x);\n",
       "    } else {\n",
       "        // test this\n",
       "        text_encode = utf8encode;\n",
       "    }\n",
       "\n",
       "    function get_result() {\n",
       "        // Combine all sub buffers into one contiguous buffer\n",
       "        var total = new Uint8Array(pos_offset + pos);\n",
       "        var i = 0, j;\n",
       "        for (var index=0; index<buffers.length; index+=2) {\n",
       "            var sub = buffers[index];\n",
       "            var n = buffers[index + 1];\n",
       "            var offset = i;\n",
       "            for(j=0; j<n; j++, i++){ total[i] = sub[j]; }\n",
       "        }\n",
       "        for(j=0; j<pos; j++, i++){ total[i] = buf8[j]; }  // also current buffer\n",
       "        return total.buffer; // total is an exact fit on its buffer\n",
       "    }\n",
       "    function new_buffer(n) {\n",
       "        // Establish size\n",
       "        var new_size = Math.max(n + 64 , min_buf_size);\n",
       "        // Store current buffer\n",
       "        buffers.push(buf8);\n",
       "        buffers.push(pos);\n",
       "        // Create new\n",
       "        buf8 = new Uint8Array(new_size);\n",
       "        bufdv = new DataView(buf8.buffer);\n",
       "        // Set positions\n",
       "        pos_offset += pos;\n",
       "        pos_max = buf8.byteLength;\n",
       "        pos = 0;\n",
       "    }\n",
       "    function tell() {\n",
       "        return pos_offset + pos;\n",
       "    }\n",
       "    function push_bytes(s) {  // we use Uint8Array internally for this\n",
       "        var n = s.byteLength;\n",
       "        if (pos + n > pos_max) { new_buffer(n); }\n",
       "        for (var i=0; i<n; i++) { buf8[pos+i] = s[i]; }\n",
       "        pos += n;\n",
       "    }\n",
       "    function push_char(s) {\n",
       "        if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "        buf8[pos] = s.charCodeAt();\n",
       "        pos += 1;\n",
       "    }\n",
       "    function push_str(s) {\n",
       "        var bb = text_encode(s);\n",
       "        push_size(bb.length);\n",
       "        if (pos + bb.length > pos_max) { new_buffer(bb.length); }\n",
       "        for (var i=0; i<bb.length; i++) { buf8[pos + i] = bb[i]; }\n",
       "        pos += bb.length;\n",
       "    }\n",
       "    function push_size(s, big) {\n",
       "        if (s <= 250 && typeof big == 'undefined') {\n",
       "            if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "            buf8[pos] = s;\n",
       "            pos += 1;\n",
       "        } else {\n",
       "            if (pos + 9 > pos_max) { new_buffer(9); }\n",
       "            buf8[pos] = 253;\n",
       "            bufdv.setUint32(pos+1, (s % 4294967296), true); // uint64\n",
       "            bufdv.setUint32(pos+5, (s / 4294967296) & 4294967295, true);\n",
       "            pos += 9;\n",
       "        }\n",
       "    }\n",
       "    function push_uint8(s) {\n",
       "        if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "        buf8[pos] = s;\n",
       "        pos += 1;\n",
       "    }\n",
       "    function push_int16(s) {\n",
       "        if (pos + 2 > pos_max) { new_buffer(2); }\n",
       "        bufdv.setInt16(pos, s, true);\n",
       "        pos += 2;\n",
       "    }\n",
       "    function push_int64(s) {\n",
       "        if (pos + 8 > pos_max) { new_buffer(8); }\n",
       "        var j, a;\n",
       "        if (s < 0) { // perform two's complement encoding\n",
       "            for (j=0, a=s+1; j<8; j++, a/=256) { buf8[pos+j] = ((-(a % 256 )) & 255) ^ 255; }\n",
       "        } else {\n",
       "            for (j=0, a=s; j<8; j++, a/=256) { buf8[pos+j] = ((a % 256 ) & 255); }\n",
       "        }\n",
       "        pos += 8;\n",
       "    }\n",
       "    function push_float64(s) {\n",
       "        // todo: we could push 32bit floats via \"f\"\n",
       "        if (pos + 8 > pos_max) { new_buffer(8); }\n",
       "        bufdv.setFloat64(pos, s, true);\n",
       "        pos += 8;\n",
       "    }\n",
       "    return {get_result: get_result, tell: tell, push_bytes: push_bytes,\n",
       "            push_char: push_char, push_str: push_str, push_size: push_size,\n",
       "            push_uint8: push_uint8, push_int16: push_int16, push_int64: push_int64,\n",
       "            push_float64: push_float64};\n",
       "}\n",
       "\n",
       "function encode_type_id(f, c, extension_id) {\n",
       "    if (typeof extension_id == 'undefined') {\n",
       "        f.push_char(c);\n",
       "    } else {\n",
       "        f.push_char(c.toUpperCase());\n",
       "        f.push_str(extension_id);\n",
       "    }\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.encode_object = function (f, value, extension_id) {\n",
       "    var iext, ext;\n",
       "\n",
       "    if (value === null) { encode_type_id(f, 'v', extension_id); }\n",
       "    //else if (typeof value == 'undefined') { encode_type_id(f, 'v', extension_id); }\n",
       "    else if (value === false) { encode_type_id(f, 'n', extension_id); }\n",
       "    else if (value === true) { encode_type_id(f, 'y', extension_id); }\n",
       "    else if (typeof value == 'number') {\n",
       "        if (Number.isInteger(value)) {\n",
       "            if (value >= -32768 && value <= 32767) {\n",
       "                encode_type_id(f, 'h', extension_id);\n",
       "                f.push_int16(value);\n",
       "            } else {\n",
       "                encode_type_id(f, 'i', extension_id);\n",
       "                f.push_int64(value);\n",
       "            }\n",
       "        } else {\n",
       "            encode_type_id(f, 'd', extension_id);\n",
       "            f.push_float64(value);\n",
       "        }\n",
       "    } else if (typeof value == 'string') {\n",
       "        encode_type_id(f, 's', extension_id);\n",
       "        f.push_str(value);\n",
       "    } else if (typeof value == 'object') {\n",
       "        if (Array.isArray(value)) {  // heterogeneous list\n",
       "            encode_type_id(f, 'l', extension_id);\n",
       "            var n = value.length;\n",
       "            f.push_size(n);\n",
       "            for (var i=0; i<n; i++) {\n",
       "                this.encode_object(f, value[i]);\n",
       "            }\n",
       "        } else if (value.constructor === Object) {  // mapping / dict\n",
       "            encode_type_id(f, 'm', extension_id);\n",
       "            var nm = Object.keys(value).length;\n",
       "            f.push_size(nm);\n",
       "            for (var key in value) {\n",
       "                f.push_str(key);\n",
       "                this.encode_object(f, value[key]);\n",
       "            }\n",
       "        } else if (value instanceof ArrayBuffer || value instanceof DataView) {  // bytes\n",
       "            if (value instanceof ArrayBuffer) { value = new DataView(value); }\n",
       "            encode_type_id(f, 'b', extension_id);\n",
       "            var compression = 0;\n",
       "            var compressed = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);  // map to uint8\n",
       "            var data_size = value.byteLength;\n",
       "            var used_size = data_size;\n",
       "            var extra_size = 0;\n",
       "            var allocated_size = used_size + extra_size;\n",
       "            // Write sizes - write at least in a size that allows resizing\n",
       "            if (allocated_size > 250) {  // && compression == 0\n",
       "                f.push_size(allocated_size, true);\n",
       "                f.push_size(used_size, true);\n",
       "                f.push_size(data_size, true);\n",
       "            } else {\n",
       "                f.push_size(allocated_size);\n",
       "                f.push_size(used_size);\n",
       "                f.push_size(data_size);\n",
       "            }\n",
       "            // Compression and checksum\n",
       "            f.push_uint8(0);\n",
       "            f.push_uint8(0);  // no checksum\n",
       "            // Byte alignment\n",
       "            if (compression == 0) {\n",
       "                var alignment = 8 - (f.tell() + 1) % 8;  // +1 for the byte to write\n",
       "                f.push_uint8(alignment);\n",
       "                for (var j=0; j<alignment; j++) { f.push_uint8(0); }\n",
       "            } else {\n",
       "                f.push_uint8(0);  // zero alignment\n",
       "            }\n",
       "            // The actual data and extra space\n",
       "            f.push_bytes(compressed);\n",
       "            f.push_bytes(new Uint8Array(allocated_size - used_size));\n",
       "        } else {\n",
       "            // Try extensions (for objects)\n",
       "            for (iext=0; iext<this.extensions.length; iext++) {\n",
       "                ext = this.extensions[iext];\n",
       "                if (ext.match(this, value)) {\n",
       "                    this.encode_object(f, ext.encode(this, value), ext.name);\n",
       "                    return;\n",
       "                }\n",
       "            }\n",
       "            var cls = Object.getPrototypeOf(value);\n",
       "            var cname = cls.__name__ || cls.constructor.name;  // __name__ is a PyScript thing\n",
       "            throw \"cannot encode object of type \" + cname;\n",
       "        }\n",
       "    } else {\n",
       "        if (typeof extension_id != 'undefined') {\n",
       "            throw ('Extension ' + extension_id + ' wronfully encodes object to another ' +\n",
       "                   'extension object (though it may encode to a list/dict ' +\n",
       "                   'that contains other extension objects).');\n",
       "        }\n",
       "        // Try extensions (for other types)\n",
       "        for (iext=0; iext<this.extensions.length; iext++) {\n",
       "            ext = this.extensions[iext];\n",
       "            if (ext.match(this, value)) {\n",
       "                this.encode_object(f, ext.encode(this, value), ext.name);\n",
       "                return;\n",
       "            }\n",
       "        }\n",
       "        throw \"cannot encode type \" + typeof(value);\n",
       "    }\n",
       "};\n",
       "\n",
       "//---- decoder\n",
       "\n",
       "function BytesReader(buf) {\n",
       "\n",
       "    // Buffer can be ArrayBuffer, DataView or Uint8Array, or Nodejs Buffer, we map to DataView\n",
       "    var bufdv;\n",
       "\n",
       "    if (typeof buf.byteLength == 'undefined') {\n",
       "        throw \"BSDF decorer needs something that looks like bytes\";\n",
       "    }\n",
       "    if (typeof buf.byteOffset == 'undefined') {\n",
       "        bufdv = new DataView(buf);  // buf was probably an ArrayBuffer\n",
       "    } else {\n",
       "        bufdv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);  // remap to something we know\n",
       "    }\n",
       "\n",
       "    var startpos = bufdv.byteOffset;\n",
       "    var pos = 0;\n",
       "    var buf8 = new Uint8Array(bufdv.buffer, bufdv.byteOffset, bufdv.byteLength);\n",
       "\n",
       "    // Create text encoder / decoder\n",
       "    var text_encode, text_decode;\n",
       "    if (typeof TextDecoder !== 'undefined') {\n",
       "        var x = new TextDecoder('utf-8');\n",
       "        text_decode = x.decode.bind(x);\n",
       "    } else {\n",
       "        // test this\n",
       "        text_decode = utf8decode;\n",
       "    }\n",
       "\n",
       "    function tell() {\n",
       "        return pos;\n",
       "    }\n",
       "    function get_char() {\n",
       "        return String.fromCharCode(buf8[pos++]);\n",
       "    }\n",
       "    function get_size() {\n",
       "        var s = buf8[pos++];\n",
       "        if (s >= 253) {\n",
       "            if (s == 253) {\n",
       "                s = bufdv.getUint32(pos, true) + bufdv.getUint32(pos+4, true) * 4294967296;\n",
       "            } else if (s == 254) { // closed stream\n",
       "                s = bufdv.getUint32(pos, true) + bufdv.getUint32(pos+4, true) * 4294967296;\n",
       "            } else if (s == 255) {  // unclosed stream\n",
       "                s = -1;\n",
       "            } else {\n",
       "                throw \"Invalid size\";\n",
       "            }\n",
       "            pos += 8;\n",
       "        }\n",
       "        return s;\n",
       "    }\n",
       "    function get_bytes(n) {  // we use Uint8Array internally for this\n",
       "        var s = new Uint8Array(buf8.buffer, buf8.byteOffset + pos, n);\n",
       "        pos += n;\n",
       "        return s;\n",
       "    }\n",
       "    function get_str() {\n",
       "        var n = get_size();\n",
       "        var bb = new Uint8Array(buf8.buffer, buf8.byteOffset + pos, n);\n",
       "        pos += n;\n",
       "        return text_decode(bb);\n",
       "    }\n",
       "    function get_uint8() {\n",
       "        return buf8[pos++];\n",
       "    }\n",
       "    function get_int16() {\n",
       "        var s = bufdv.getInt16(pos, true);\n",
       "        pos += 2;\n",
       "        return s;\n",
       "    }\n",
       "    function get_int64() {\n",
       "        var isneg = (buf8[pos+7] & 0x80) > 0;\n",
       "        var s, j, m;\n",
       "        if (isneg) {\n",
       "            s = -1;\n",
       "            for (j=0, m=1; j<8; j++, m*=256) { s -= (buf8[pos+j] ^ 0xff) * m; }\n",
       "        } else {\n",
       "            s = 0;\n",
       "            for (j=0, m=1; j<8; j++, m*=256) { s += buf8[pos+j] * m; }\n",
       "        }\n",
       "        pos += 8;\n",
       "        return s;\n",
       "    }\n",
       "    function get_float32() {\n",
       "        var s = bufdv.getFloat32(pos, true);\n",
       "        pos += 4;\n",
       "        return s;\n",
       "    } function get_float64() {\n",
       "        var s = bufdv.getFloat64(pos, true);\n",
       "        pos += 8;\n",
       "        return s;\n",
       "    }\n",
       "\n",
       "    return {tell: tell, get_size:get_size, get_bytes: get_bytes,\n",
       "            get_uint8: get_uint8, get_int16: get_int16, get_int64: get_int64,\n",
       "            get_float32: get_float32, get_float64: get_float64, get_char: get_char, get_str: get_str};\n",
       "\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.decode_object = function (f) {\n",
       "\n",
       "    var char = f.get_char();\n",
       "    var c = char.toLowerCase();\n",
       "    var value;\n",
       "    var extension_id = null;\n",
       "\n",
       "    if (char == '\\x00') {  // because String.fromCharCode(undefined) produces ASCII 0.\n",
       "        throw new EOFError('End of BSDF data reached.');\n",
       "    }\n",
       "\n",
       "    // Conversion (uppercase value identifiers signify converted values)\n",
       "    if (char != c) {\n",
       "        extension_id = f.get_str();\n",
       "    }\n",
       "\n",
       "    if (c == 'v') {\n",
       "        value = null;\n",
       "    } else if (c == 'n') {\n",
       "        value = false;\n",
       "    } else if (c == 'y') {\n",
       "        value = true;\n",
       "    } else if (c == 'h') {\n",
       "        value = f.get_int16();\n",
       "    } else if (c == 'i') {\n",
       "        value = f.get_int64();\n",
       "    } else if (c == 'f') {\n",
       "        value = f.get_float32();\n",
       "    } else if (c == 'd') {\n",
       "        value = f.get_float64();\n",
       "    } else if (c == 's') {\n",
       "        value = f.get_str();\n",
       "    } else if (c == 'l') {\n",
       "        var n = f.get_size();\n",
       "        if (n < 0) {\n",
       "            // Streaming\n",
       "            value = [];\n",
       "            try {\n",
       "                while (true) { value.push(this.decode_object(f)); }\n",
       "            } catch(err) {\n",
       "                if (err instanceof EOFError) { /* ok */ } else { throw err; }\n",
       "            }\n",
       "        } else {\n",
       "            // Normal\n",
       "            value = new Array(n);\n",
       "            for (var i=0; i<n; i++) {\n",
       "                value[i] = this.decode_object(f);\n",
       "            }\n",
       "        }\n",
       "    } else if (c == 'm') {\n",
       "        var nm = f.get_size();\n",
       "        value = {};\n",
       "        for (var j=0; j<nm; j++) {\n",
       "            var key = f.get_str();\n",
       "            value[key] = this.decode_object(f);\n",
       "        }\n",
       "    } else if (c == 'b') {\n",
       "        // Get sizes\n",
       "        var allocated_size = f.get_size();\n",
       "        var used_size = f.get_size();\n",
       "        var data_size = f.get_size();\n",
       "        // Compression and checksum\n",
       "        var compression = f.get_uint8();\n",
       "        var has_checksum = f.get_uint8();\n",
       "        if (has_checksum) {\n",
       "            var checksum = f.get_bytes(16);\n",
       "        }\n",
       "        // Skip alignment\n",
       "        var alignment = f.get_uint8();\n",
       "        f.get_bytes(alignment);\n",
       "        // Get data (as ArrayBuffer)\n",
       "        var compressed = f.get_bytes(used_size);  // uint8\n",
       "        f.get_bytes(allocated_size - used_size);  // skip extra space\n",
       "        if (compression == 0) {\n",
       "            value = new DataView(compressed.buffer, compressed.byteOffset, compressed.byteLength);\n",
       "        } else {\n",
       "            throw \"JS implementation of BSDF does not support compression (\" + compression + ')';\n",
       "        }\n",
       "    } else {\n",
       "        throw \"Invalid value specifier at pos \" + f.tell() + \": \" + JSON.stringify(char);\n",
       "    }\n",
       "\n",
       "    // Convert using an extension?\n",
       "    if (extension_id !== null) {\n",
       "        var ext = this.extensions[extension_id];\n",
       "        if (ext) {\n",
       "            value = ext.decode(this, value);\n",
       "        } else {\n",
       "            console.warn('BSDF warning: no known extension for \"' + extension_id + '\", value passes in raw form.');\n",
       "        }\n",
       "    }\n",
       "    return value;\n",
       "};\n",
       "\n",
       "\n",
       "// To be able to support complex numbers\n",
       "function Complex(real, imag) {\n",
       "    this.real = real;\n",
       "    this.imag = imag;\n",
       "}\n",
       "\n",
       "function EOFError(msg) {\n",
       "    this.msg = msg;\n",
       "}\n",
       "\n",
       "\n",
       "// ================== Standard extensions\n",
       "\n",
       "var rootns;\n",
       "if (typeof window == 'undefined') { rootns = global; } else { rootns = window; }\n",
       "\n",
       "var complex_extension = {\n",
       "    name: 'c',\n",
       "    match: function(s, v) { return v instanceof Complex; },\n",
       "    encode: function(s, v) { return [v.real, v.imag]; },\n",
       "    decode: function(s, v) { return new Complex(v[0], v[1]); }\n",
       "};\n",
       "\n",
       "var ndarray_extension = {\n",
       "    name: 'ndarray',\n",
       "    match: function(s, v) {\n",
       "        return v.BYTES_PER_ELEMENT !== undefined && v.constructor.name.endsWith('Array');\n",
       "    },\n",
       "    encode: function(s, v) {\n",
       "        return {shape: v.shape || [v.length],\n",
       "                dtype: v.constructor.name.slice(0, -5).toLowerCase(),\n",
       "                data: new DataView(v.buffer, v.byteOffset, v.byteLength)};\n",
       "    },\n",
       "    decode: function(s, v) {\n",
       "        var cls = rootns[v.dtype[0].toUpperCase() + v.dtype.slice(1) + 'Array'];\n",
       "        var value = new cls(v.data.buffer, v.data.byteOffset, v.data.byteLength / cls.BYTES_PER_ELEMENT);\n",
       "        value.shape = v.shape;\n",
       "        return value;\n",
       "    }\n",
       "};\n",
       "\n",
       "var standard_extensions = [complex_extension, ndarray_extension];\n",
       "\n",
       "// ================== the UMD module suffix\n",
       "return {encode: bsdf_encode, decode: bsdf_decode, BsdfSerializer: BsdfSerializer, standard_extensions: standard_extensions};\n",
       "}));\n",
       "\n",
       "\n",
       "/* ============================== bb64.js ===============================*/\n",
       "\n",
       "flexx.define(\"bb64\", [], (function () {\n",
       "\"use strict\";\n",
       "\n",
       "function base64encode(b, last_two) {\n",
       "    \"use strict\";\n",
       "    console.assert(b.BYTES_PER_ELEMENT == 1);\n",
       "    // Most Base64 encoders use +/ for the last two characters, but not all\n",
       "    if (last_two === undefined) last_two = '+/';\n",
       "    // Init charcodes array\n",
       "    var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\" + last_two;\n",
       "    var charcodes = new Uint8Array(64);\n",
       "    for (var k=0; k<64; k++) charcodes[k] = chars.charCodeAt(k);\n",
       "    // Init result string, as a typed array of ASCII values\n",
       "    var s = new Uint8Array(Math.ceil(b.length / 3) * 4);\n",
       "    // Init\n",
       "    var b1, b2, b3;\n",
       "    var i = 0;  // The byte index\n",
       "    var j = 0;  // The string index\n",
       "    // Iterate over bytes\n",
       "    while (i < b.length) {\n",
       "        // Sample bytes, out of bounds are mapped to zero\n",
       "        b1 = b[i+0] || 0; b2 = b[i+1] || 0; b3 = b[i+2] || 0;\n",
       "        i += 3;\n",
       "        // Encode and assign\n",
       "        s[j+0] = charcodes[( b1 >> 2 ) & 0x3F];\n",
       "        s[j+1] = charcodes[( ( b1 & 0x3 ) << 4 ) | ( ( b2 >> 4 ) & 0xF )];\n",
       "        s[j+2] = charcodes[( ( b2 & 0xF ) << 2 ) | ( ( b3 >> 6 ) & 0x3 )];\n",
       "        s[j+3] = charcodes[b3 & 0x3F];\n",
       "        j += 4;\n",
       "    }\n",
       "    // Replace stub bytes with the padding char\n",
       "    for (var k=0; k<(i-b.length); k++) s[s.length-k-1] = '61';\n",
       "    // Convert to string\n",
       "    return String.fromCharCode.apply(null, s);\n",
       "}\n",
       "\n",
       "function base64decode(s, last_two) {\n",
       "    \"use strict\";\n",
       "    // Most Base64 encoders use +/ for the last two characters, but not all\n",
       "    if (last_two === undefined) last_two = '+/';\n",
       "    var charcode62 = last_two.charCodeAt(0), charcode63 = last_two.charCodeAt(1);\n",
       "    // Allocate byte array, with a length as large as it can possibly become\n",
       "    var b = new Uint8Array(Math.floor((s.length / 4) * 3));\n",
       "    // Init\n",
       "    var i = 0; // The number of bytes (and byte index)\n",
       "    var j = 0; // The index into the string\n",
       "    var c, cc = new Array(4);  // to store character codes (ints)\n",
       "    // Iterate while there are chars left\n",
       "    while (j < s.length) {\n",
       "        // Collect 4 (or less) characters\n",
       "        var charcount = 0;\n",
       "        while (charcount < 4 && j < s.length) {\n",
       "            c = s.charCodeAt(j++);\n",
       "            if (c >= 65 && c <=90) c -= 65;  // A-Z: 0-25\n",
       "            else if (c >=97 && c<=122) c -= 71;  // a-z: 26-51\n",
       "            else if (c >=48 && c<=57) c += 4;  // 0-9: 52-61\n",
       "            else if (c == charcode62) c = 62;\n",
       "            else if (c == charcode63) c = 63;\n",
       "            else continue;  // skip other chars, like newline, padding, or other\n",
       "            cc[charcount] = c;\n",
       "            charcount += 1;\n",
       "        }\n",
       "        // At the end, we may not have enough chars, zero these values\n",
       "        if (charcount != 4) for (var k=charcount; k<4; k++) cc[k] = 0;\n",
       "        // Calculate the 3 byte values\n",
       "        b[i+0] = (cc[0] << 2) | (cc[1] >> 4);\n",
       "        b[i+1] = ((cc[1] & 15) << 4) | (cc[2] >> 2);\n",
       "        b[i+2] = ((cc[2] & 3) << 6) | cc[3];\n",
       "        // Next i (4 chars -> 3 bytes, 3 chars -> 2 bytes, 2 chars -> 1 byte)\n",
       "        i += charcount - 1;\n",
       "    }\n",
       "    // Return view that has the correct length, but on same data buffer.\n",
       "    // The unused memory should be marginal, so making a copy not worth it.\n",
       "    return new Uint8Array(b.buffer, 0, i);\n",
       "}\n",
       "\n",
       "return {encode: base64encode, decode: base64decode};\n",
       "}));\n",
       "\n",
       "\n",
       "/* =========================== pscript-std.js ===========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "flexx.define(\"pscript-std.js\", [], function () {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_abs = Math.abs;\n",
       "var _pyfunc_all = function (x) { // nargs: 1\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        if (!_pyfunc_truthy(x[i])){return false;}\n",
       "    } return true;\n",
       "};\n",
       "var _pyfunc_any = function (x) { // nargs: 1\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        if (_pyfunc_truthy(x[i])){return true;}\n",
       "    } return false;\n",
       "};\n",
       "var _pyfunc_bool = function (x) { // nargs: 1\n",
       "    return Boolean(_pyfunc_truthy(x));\n",
       "};\n",
       "var _pyfunc_delattr = function (ob, name) {  // nargs: 2\n",
       "    delete ob[name];\n",
       "};\n",
       "var _pyfunc_dict = function (x) {\n",
       "    var t, i, keys, r={};\n",
       "    if (Array.isArray(x)) {\n",
       "        for (i=0; i<x.length; i++) {\n",
       "            t=x[i]; r[t[0]] = t[1];\n",
       "        }\n",
       "    } else {\n",
       "        keys = Object.keys(x);\n",
       "        for (i=0; i<keys.length; i++) {\n",
       "            t=keys[i]; r[t] = x[t];\n",
       "        }\n",
       "    }\n",
       "    return r;\n",
       "};\n",
       "var _pyfunc_divmod = function (x, y) { // nargs: 2\n",
       "    var m = x % y; return [(x-m)/y, m];\n",
       "};\n",
       "var _pyfunc_enumerate = function (iter) { // nargs: 1\n",
       "    var i, res=[];\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    for (i=0; i<iter.length; i++) {res.push([i, iter[i]]);}\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_filter = function (func, iter) { // nargs: 2\n",
       "    if (typeof func === \"undefined\" || func === null) {func = function(x) {return x;}}\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.filter(func);\n",
       "};\n",
       "var _pyfunc_float = Number;\n",
       "var _pyfunc_getattr = function (ob, name, deflt) { // nargs: 2 3\n",
       "    var has_attr = ob !== undefined && ob !== null && ob[name] !== undefined;\n",
       "    if (has_attr) {return ob[name];}\n",
       "    else if (arguments.length == 3) {return deflt;}\n",
       "    else {var e = Error(name); e.name='AttributeError'; throw e;}\n",
       "};\n",
       "var _pyfunc_hasattr = function (ob, name) { // nargs: 2\n",
       "    return (ob !== undefined) && (ob !== null) && (ob[name] !== undefined);\n",
       "};\n",
       "var _pyfunc_int = function (x) { // nargs: 1\n",
       "    return x<0 ? Math.ceil(x): Math.floor(x);\n",
       "};\n",
       "var _pyfunc_list = function (x) {\n",
       "    var r=[];\n",
       "    if (typeof x===\"object\" && !Array.isArray(x)) {x = Object.keys(x)}\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        r.push(x[i]);\n",
       "    }\n",
       "    return r;\n",
       "};\n",
       "var _pyfunc_map = function (func, iter) { // nargs: 2\n",
       "    if (typeof func === \"undefined\" || func === null) {func = function(x) {return x;}}\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.map(func);\n",
       "};\n",
       "var _pyfunc_merge_dicts = function () {\n",
       "    var res = {};\n",
       "    for (var i=0; i<arguments.length; i++) {\n",
       "        var d = arguments[i];\n",
       "        var key, keys = Object.keys(d);\n",
       "        for (var j=0; j<keys.length; j++) { key = keys[j]; res[key] = d[key]; }\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_op_add = function (a, b) { // nargs: 2\n",
       "    if (Array.isArray(a) && Array.isArray(b)) {\n",
       "        return a.concat(b);\n",
       "    } return a + b;\n",
       "};\n",
       "var _pyfunc_op_contains = function op_contains (a, b) { // nargs: 2\n",
       "    if (b == null) {\n",
       "    } else if (Array.isArray(b)) {\n",
       "        for (var i=0; i<b.length; i++) {if (_pyfunc_op_equals(a, b[i]))\n",
       "                                           return true;}\n",
       "        return false;\n",
       "    } else if (b.constructor === Object) {\n",
       "        for (var k in b) {if (a == k) return true;}\n",
       "        return false;\n",
       "    } else if (b.constructor == String) {\n",
       "        return b.indexOf(a) >= 0;\n",
       "    } var e = Error('Not a container: ' + b); e.name='TypeError'; throw e;\n",
       "};\n",
       "var _pyfunc_op_equals = function op_equals (a, b) { // nargs: 2\n",
       "    if (a == null || b == null) {\n",
       "    } else if (Array.isArray(a) && Array.isArray(b)) {\n",
       "        var i = 0, iseq = a.length == b.length;\n",
       "        while (iseq && i < a.length) {iseq = op_equals(a[i], b[i]); i+=1;}\n",
       "        return iseq;\n",
       "    } else if (a.constructor === Object && b.constructor === Object) {\n",
       "        var akeys = Object.keys(a), bkeys = Object.keys(b);\n",
       "        akeys.sort(); bkeys.sort();\n",
       "        var i=0, k, iseq = op_equals(akeys, bkeys);\n",
       "        while (iseq && i < akeys.length)\n",
       "            {k=akeys[i]; iseq = op_equals(a[k], b[k]); i+=1;}\n",
       "        return iseq;\n",
       "    } return a == b;\n",
       "};\n",
       "var _pyfunc_op_error = function (etype, msg) { // nargs: 2\n",
       "    var e = new Error(etype + ': ' + msg);\n",
       "    e.name = etype\n",
       "    return e;\n",
       "};\n",
       "var _pyfunc_op_instantiate = function (ob, args) { // nargs: 2\n",
       "    if ((typeof ob === \"undefined\") ||\n",
       "            (typeof window !== \"undefined\" && window === ob) ||\n",
       "            (typeof global !== \"undefined\" && global === ob))\n",
       "            {throw \"Class constructor is called as a function.\";}\n",
       "    for (var name in ob) {\n",
       "        if (Object[name] === undefined &&\n",
       "            typeof ob[name] === 'function' && !ob[name].nobind) {\n",
       "            ob[name] = ob[name].bind(ob);\n",
       "            ob[name].__name__ = name;\n",
       "        }\n",
       "    }\n",
       "    if (ob.__init__) {\n",
       "        ob.__init__.apply(ob, args);\n",
       "    }\n",
       "};\n",
       "var _pyfunc_op_mult = function (a, b) { // nargs: 2\n",
       "    if ((typeof a === 'number') + (typeof b === 'number') === 1) {\n",
       "        if (a.constructor === String) return _pymeth_repeat.call(a, b);\n",
       "        if (b.constructor === String) return _pymeth_repeat.call(b, a);\n",
       "        if (Array.isArray(b)) {var t=a; a=b; b=t;}\n",
       "        if (Array.isArray(a)) {\n",
       "            var res = []; for (var i=0; i<b; i++) res = res.concat(a);\n",
       "            return res;\n",
       "        }\n",
       "    } return a * b;\n",
       "};\n",
       "var _pyfunc_op_parse_kwargs = function (arg_names, arg_values, kwargs, strict) { // nargs: 3\n",
       "    for (var i=0; i<arg_values.length; i++) {\n",
       "        var name = arg_names[i];\n",
       "        if (kwargs[name] !== undefined) {\n",
       "            arg_values[i] = kwargs[name];\n",
       "            delete kwargs[name];\n",
       "        }\n",
       "    }\n",
       "    if (strict && Object.keys(kwargs).length > 0) {\n",
       "        throw _pyfunc_op_error('TypeError',\n",
       "            'Function ' + strict + ' does not accept **kwargs.');\n",
       "    }\n",
       "    return kwargs;\n",
       "};\n",
       "var _pyfunc_perf_counter = function() { // nargs: 0\n",
       "    if (typeof(process) === \"undefined\"){return performance.now()*1e-3;}\n",
       "    else {var t = process.hrtime(); return t[0] + t[1]*1e-9;}\n",
       "};\n",
       "var _pyfunc_pow = Math.pow;\n",
       "var _pyfunc_range = function (start, end, step) {\n",
       "var i, res = [];\n",
       "    var val = start;\n",
       "    var n = (end - start) / step;\n",
       "    for (i=0; i<n; i++) {\n",
       "        res.push(val);\n",
       "        val += step;\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_repr = function (x) { // nargs: 1\n",
       "    var res; try { res = JSON.stringify(x); } catch (e) { res = undefined; }\n",
       "    if (typeof res === 'undefined') { res = x._IS_COMPONENT ? x.id : String(x); }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_reversed = function (iter) { // nargs: 1\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.slice().reverse();\n",
       "};\n",
       "var _pyfunc_round = Math.round;\n",
       "var _pyfunc_setattr = function (ob, name, value) {  // nargs: 3\n",
       "    ob[name] = value;\n",
       "};\n",
       "var _pyfunc_sorted = function (iter, key, reverse) { // nargs: 1 2 3\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    var comp = function (a, b) {a = key(a); b = key(b);\n",
       "        if (a<b) {return -1;} if (a>b) {return 1;} return 0;};\n",
       "    comp = Boolean(key) ? comp : undefined; \n",
       "    iter = iter.slice().sort(comp);\n",
       "    if (reverse) iter.reverse();\n",
       "    return iter;\n",
       "};\n",
       "var _pyfunc_str = String;\n",
       "var _pyfunc_sum = function (x) {  // nargs: 1\n",
       "    return x.reduce(function(a, b) {return a + b;});\n",
       "};\n",
       "var _pyfunc_time = function () {return Date.now() / 1000;};\n",
       "var _pyfunc_truthy = function (v) {\n",
       "    if (v === null || typeof v !== \"object\") {return v;}\n",
       "    else if (v.length !== undefined) {return v.length ? v : false;}\n",
       "    else if (v.byteLength !== undefined) {return v.byteLength ? v : false;}\n",
       "    else if (v.constructor !== Object) {return true;}\n",
       "    else {return Object.getOwnPropertyNames(v).length ? v : false;}\n",
       "};\n",
       "var _pyfunc_zip = function () { // nargs: 2 3 4 5 6 7 8 9\n",
       "    var i, j, tup, arg, args = [], res = [], len = 1e20;\n",
       "    for (i=0; i<arguments.length; i++) {\n",
       "        arg = arguments[i];\n",
       "        if ((typeof arg===\"object\") && (!Array.isArray(arg))) {arg = Object.keys(arg);}\n",
       "        args.push(arg);\n",
       "        len = Math.min(len, arg.length);\n",
       "    }\n",
       "    for (j=0; j<len; j++) {\n",
       "        tup = []\n",
       "        for (i=0; i<args.length; i++) {tup.push(args[i][j]);}\n",
       "        res.push(tup);\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_append = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.append.apply(this, arguments);\n",
       "    this.push(x);\n",
       "};\n",
       "var _pymeth_capitalize = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.capitalize.apply(this, arguments);\n",
       "    return this.slice(0, 1).toUpperCase() + this.slice(1).toLowerCase();\n",
       "};\n",
       "var _pymeth_casefold = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.casefold.apply(this, arguments);\n",
       "    return this.toLowerCase();\n",
       "};\n",
       "var _pymeth_center = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.center.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    var left = Math.ceil(tofill / 2);\n",
       "    var right = tofill - left;\n",
       "    return _pymeth_repeat.call(fill, left) + this + _pymeth_repeat.call(fill, right);\n",
       "};\n",
       "var _pymeth_clear = function () { // nargs: 0\n",
       "    if (Array.isArray(this)) {\n",
       "        this.splice(0, this.length);\n",
       "    } else if (this.constructor === Object) {\n",
       "        var keys = Object.keys(this);\n",
       "        for (var i=0; i<keys.length; i++) delete this[keys[i]];\n",
       "    } else return this.clear.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_copy = function () { // nargs: 0\n",
       "    if (Array.isArray(this)) {\n",
       "        return this.slice(0);\n",
       "    } else if (this.constructor === Object) {\n",
       "        var key, keys = Object.keys(this), res = {};\n",
       "        for (var i=0; i<keys.length; i++) {key = keys[i]; res[key] = this[key];}\n",
       "        return res;\n",
       "    } else return this.copy.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_count = function (x, start, stop) { // nargs: 1 2 3\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    if (Array.isArray(this)) {\n",
       "        var count = 0;\n",
       "        for (var i=0; i<this.length; i++) { \n",
       "            if (_pyfunc_op_equals(this[i], x)) {count+=1;}\n",
       "        } return count;\n",
       "    } else if (this.constructor == String) {\n",
       "        var count = 0, i = start;\n",
       "        while (i >= 0 && i < stop) {\n",
       "            i = this.indexOf(x, i);\n",
       "            if (i < 0) break; \n",
       "            count += 1;\n",
       "            i += Math.max(1, x.length);\n",
       "        } return count;\n",
       "    } else return this.count.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_endswith = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.endswith.apply(this, arguments);\n",
       "    return this.lastIndexOf(x) == this.length - x.length;\n",
       "};\n",
       "var _pymeth_expandtabs = function (tabsize) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.expandtabs.apply(this, arguments);\n",
       "    tabsize = (tabsize === undefined) ? 8 : tabsize;\n",
       "    return this.replace(/\\t/g, _pymeth_repeat.call(' ', tabsize));\n",
       "};\n",
       "var _pymeth_extend = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.extend.apply(this, arguments);\n",
       "    this.push.apply(this, x);   \n",
       "};\n",
       "var _pymeth_find = function (x, start, stop) { // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.find.apply(this, arguments);\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    var i = this.slice(start, stop).indexOf(x);\n",
       "    if (i >= 0) return i + start;\n",
       "    return -1;\n",
       "};\n",
       "var _pymeth_get = function (key, d) { // nargs: 1 2\n",
       "    if (this.constructor !== Object) return this.get.apply(this, arguments);\n",
       "    if (this[key] !== undefined) {return this[key];}\n",
       "    else if (d !== undefined) {return d;}\n",
       "    else {return null;}\n",
       "};\n",
       "var _pymeth_index = function (x, start, stop) { // nargs: 1 2 3\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    if (Array.isArray(this)) {\n",
       "        for (var i=start; i<stop; i++) {\n",
       "            if (_pyfunc_op_equals(this[i], x)) {return i;} // indexOf cant\n",
       "        }\n",
       "    } else if (this.constructor === String) {\n",
       "        var i = this.slice(start, stop).indexOf(x);\n",
       "        if (i >= 0) return i + start;\n",
       "    } else return this.index.apply(this, arguments);\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_insert = function (i, x) { // nargs: 2\n",
       "    if (!Array.isArray(this)) return this.insert.apply(this, arguments);\n",
       "    i = (i < 0) ? this.length + i : i;\n",
       "    this.splice(i, 0, x);\n",
       "};\n",
       "var _pymeth_isalnum = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isalnum.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z0-9]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isalpha = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isalpha.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isidentifier = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isidentifier.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z_][A-Za-z0-9_]*$/.test(this));\n",
       "};\n",
       "var _pymeth_islower = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.islower.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), high = this.toUpperCase();\n",
       "    return low != high && low == this;\n",
       "};\n",
       "var _pymeth_isnumeric = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isnumeric.apply(this, arguments);\n",
       "    return Boolean(/^[0-9]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isspace = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isspace.apply(this, arguments);\n",
       "    return Boolean(/^\\s+$/.test(this));\n",
       "};\n",
       "var _pymeth_istitle = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.istitle.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), title = _pymeth_title.call(this);\n",
       "    return low != title && title == this;\n",
       "};\n",
       "var _pymeth_isupper = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isupper.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), high = this.toUpperCase();\n",
       "    return low != high && high == this;\n",
       "};\n",
       "var _pymeth_items = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.items.apply(this, arguments);\n",
       "    var key, keys = Object.keys(this), res = []\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; res.push([key, this[key]]);}\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_join = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.join.apply(this, arguments);\n",
       "    return x.join(this);  // call join on the list instead of the string.   \n",
       "};\n",
       "var _pymeth_keys = function () { // nargs: 0\n",
       "    if (typeof this['keys'] === 'function') return this.keys.apply(this, arguments);\n",
       "    return Object.keys(this);\n",
       "};\n",
       "var _pymeth_ljust = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.ljust.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    return this + _pymeth_repeat.call(fill, tofill);\n",
       "};\n",
       "var _pymeth_lower = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.lower.apply(this, arguments);\n",
       "    return this.toLowerCase();\n",
       "};\n",
       "var _pymeth_lstrip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.lstrip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        if (chars.indexOf(this[i]) < 0) return this.slice(i);\n",
       "    } return '';\n",
       "};\n",
       "var _pymeth_partition = function (sep) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.partition.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    var i1 = this.indexOf(sep);\n",
       "    if (i1 < 0) return [this.slice(0), '', '']\n",
       "    var i2 = i1 + sep.length;\n",
       "    return [this.slice(0, i1), this.slice(i1, i2), this.slice(i2)]; \n",
       "};\n",
       "var _pymeth_pop = function (i, d) { // nargs: 1 2\n",
       "    if (Array.isArray(this)) {\n",
       "        i = (i === undefined) ? -1 : i;\n",
       "        i = (i < 0) ? (this.length + i) : i;\n",
       "        var popped = this.splice(i, 1);\n",
       "        if (popped.length)  return popped[0];\n",
       "        var e = Error(i); e.name='IndexError'; throw e;\n",
       "    } else if (this.constructor === Object) {\n",
       "        var res = this[i]\n",
       "        if (res !== undefined) {delete this[i]; return res;}\n",
       "        else if (d !== undefined) return d;\n",
       "        var e = Error(i); e.name='KeyError'; throw e;\n",
       "    } else return this.pop.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_popitem = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.popitem.apply(this, arguments);\n",
       "    var keys, key, val;\n",
       "    keys = Object.keys(this);\n",
       "    if (keys.length == 0) {var e = Error(); e.name='KeyError'; throw e;}\n",
       "    key = keys[0]; val = this[key]; delete this[key];\n",
       "    return [key, val];\n",
       "};\n",
       "var _pymeth_remove = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.remove.apply(this, arguments);\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        if (_pyfunc_op_equals(this[i], x)) {this.splice(i, 1); return;}\n",
       "    }\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_repeat = function(count) { // nargs: 0\n",
       "    if (this.repeat) return this.repeat(count);\n",
       "    if (count < 1) return '';\n",
       "    var result = '', pattern = this.valueOf();\n",
       "    while (count > 1) {\n",
       "        if (count & 1) result += pattern;\n",
       "        count >>= 1, pattern += pattern;\n",
       "    }\n",
       "    return result + pattern;\n",
       "};\n",
       "var _pymeth_replace = function (s1, s2, count) {  // nargs: 2 3\n",
       "    if (this.constructor !== String) return this.replace.apply(this, arguments);\n",
       "    var i = 0, i2, parts = [];\n",
       "    count = (count === undefined) ? 1e20 : count;\n",
       "    while (count > 0) {\n",
       "        i2 = this.indexOf(s1, i);\n",
       "        if (i2 >= 0) {\n",
       "            parts.push(this.slice(i, i2));\n",
       "            parts.push(s2);\n",
       "            i = i2 + s1.length;\n",
       "            count -= 1;\n",
       "        } else break;\n",
       "    }\n",
       "    parts.push(this.slice(i));\n",
       "    return parts.join('');\n",
       "};\n",
       "var _pymeth_reverse = function () { // nargs: 0\n",
       "    this.reverse();\n",
       "};\n",
       "var _pymeth_rfind = function (x, start, stop) { // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.rfind.apply(this, arguments);\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    var i = this.slice(start, stop).lastIndexOf(x);\n",
       "    if (i >= 0) return i + start;\n",
       "    return -1;\n",
       "};\n",
       "var _pymeth_rindex = function (x, start, stop) {  // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.rindex.apply(this, arguments);\n",
       "    var i = _pymeth_rfind.call(this, x, start, stop);\n",
       "    if (i >= 0) return i;\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_rjust = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.rjust.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    return _pymeth_repeat.call(fill, tofill) + this;\n",
       "};\n",
       "var _pymeth_rpartition = function (sep) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.rpartition.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    var i1 = this.lastIndexOf(sep);\n",
       "    if (i1 < 0) return ['', '', this.slice(0)]\n",
       "    var i2 = i1 + sep.length;\n",
       "    return [this.slice(0, i1), this.slice(i1, i2), this.slice(i2)]; \n",
       "};\n",
       "var _pymeth_rsplit = function (sep, count) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.rsplit.apply(this, arguments);\n",
       "    sep = (sep === undefined) ? /\\s/ : sep;\n",
       "    count = Math.max(0, (count === undefined) ? 1e20 : count);\n",
       "    var parts = this.split(sep);\n",
       "    var limit = Math.max(0, parts.length-count);\n",
       "    var res = parts.slice(limit);\n",
       "    if (count < parts.length) res.splice(0, 0, parts.slice(0, limit).join(sep));\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_rstrip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.rstrip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    for (var i=this.length-1; i>=0; i--) {\n",
       "        if (chars.indexOf(this[i]) < 0) return this.slice(0, i+1);\n",
       "    } return '';\n",
       "};\n",
       "var _pymeth_setdefault = function (key, d) { // nargs: 1 2\n",
       "    if (this.constructor !== Object) return this.setdefault.apply(this, arguments);\n",
       "    if (this[key] !== undefined) {return this[key];}\n",
       "    else if (d !== undefined) { this[key] = d; return d;}\n",
       "    else {return null;}\n",
       "};\n",
       "var _pymeth_sort = function (key, reverse) { // nargs: 0 1 2\n",
       "    if (!Array.isArray(this)) return this.sort.apply(this, arguments);\n",
       "    var comp = function (a, b) {a = key(a); b = key(b);\n",
       "        if (a<b) {return -1;} if (a>b) {return 1;} return 0;};\n",
       "    comp = Boolean(key) ? comp : undefined; \n",
       "    this.sort(comp);\n",
       "    if (reverse) this.reverse();\n",
       "};\n",
       "var _pymeth_split = function (sep, count) { // nargs: 0, 1 2\n",
       "    if (this.constructor !== String) return this.split.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    sep = (sep === undefined) ? /\\s/ : sep;\n",
       "    if (count === undefined) { return this.split(sep); }\n",
       "    var res = [], i = 0, index1 = 0, index2 = 0;\n",
       "    while (i < count && index1 < this.length) {\n",
       "        index2 = this.indexOf(sep, index1);\n",
       "        if (index2 < 0) { break; }\n",
       "        res.push(this.slice(index1, index2));\n",
       "        index1 = index2 + sep.length || 1;\n",
       "        i += 1;\n",
       "    }\n",
       "    res.push(this.slice(index1));\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_splitlines = function (keepends) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.splitlines.apply(this, arguments);\n",
       "    keepends = keepends ? 1 : 0\n",
       "    var finder = /\\r\\n|\\r|\\n/g;\n",
       "    var i = 0, i2, isrn, parts = [];\n",
       "    while (finder.exec(this) !== null) {\n",
       "        i2 = finder.lastIndex -1;\n",
       "        isrn = i2 > 0 && this[i2-1] == '\\r' && this[i2] == '\\n';\n",
       "        if (keepends) parts.push(this.slice(i, finder.lastIndex));\n",
       "        else parts.push(this.slice(i, i2 - isrn));\n",
       "        i = finder.lastIndex;\n",
       "    }\n",
       "    if (i < this.length) parts.push(this.slice(i));\n",
       "    else if (!parts.length) parts.push('');\n",
       "    return parts;\n",
       "};\n",
       "var _pymeth_startswith = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.startswith.apply(this, arguments);\n",
       "    return this.indexOf(x) == 0;\n",
       "};\n",
       "var _pymeth_strip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.strip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    var i, s1 = this, s2 = '', s3 = '';\n",
       "    for (i=0; i<s1.length; i++) {\n",
       "        if (chars.indexOf(s1[i]) < 0) {s2 = s1.slice(i); break;}\n",
       "    } for (i=s2.length-1; i>=0; i--) {\n",
       "        if (chars.indexOf(s2[i]) < 0) {s3 = s2.slice(0, i+1); break;}\n",
       "    } return s3;\n",
       "};\n",
       "var _pymeth_swapcase = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.swapcase.apply(this, arguments);\n",
       "    var c, res = [];\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        c = this[i];\n",
       "        if (c.toUpperCase() == c) res.push(c.toLowerCase());\n",
       "        else res.push(c.toUpperCase());\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_title = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.title.apply(this, arguments);\n",
       "    var i0, res = [], tester = /^[^A-Za-z]?[A-Za-z]$/;\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        i0 = Math.max(0, i-1);\n",
       "        if (tester.test(this.slice(i0, i+1))) res.push(this[i].toUpperCase());\n",
       "        else res.push(this[i].toLowerCase());\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_translate = function (table) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.translate.apply(this, arguments);\n",
       "    var c, res = [];\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        c = table[this[i]];\n",
       "        if (c === undefined) res.push(this[i]);\n",
       "        else if (c !== null) res.push(c);\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_update = function (other) { // nargs: 1\n",
       "    if (this.constructor !== Object) return this.update.apply(this, arguments);\n",
       "    var key, keys = Object.keys(other);\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; this[key] = other[key];}\n",
       "    return null;\n",
       "};\n",
       "var _pymeth_upper = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.upper.apply(this, arguments);\n",
       "    return this.toUpperCase();\n",
       "};\n",
       "var _pymeth_values = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.values.apply(this, arguments);\n",
       "    var key, keys = Object.keys(this), res = [];\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; res.push(this[key]);}\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_zfill = function (width) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.zfill.apply(this, arguments);\n",
       "    return _pymeth_rjust.call(this, width, '0');\n",
       "};\n",
       "\n",
       "return {_pyfunc_perf_counter: _pyfunc_perf_counter, _pyfunc_time: _pyfunc_time, _pyfunc_op_instantiate: _pyfunc_op_instantiate, _pyfunc_merge_dicts: _pyfunc_merge_dicts, _pyfunc_op_parse_kwargs: _pyfunc_op_parse_kwargs, _pyfunc_op_error: _pyfunc_op_error, _pyfunc_hasattr: _pyfunc_hasattr, _pyfunc_getattr: _pyfunc_getattr, _pyfunc_setattr: _pyfunc_setattr, _pyfunc_delattr: _pyfunc_delattr, _pyfunc_dict: _pyfunc_dict, _pyfunc_list: _pyfunc_list, _pyfunc_range: _pyfunc_range, _pyfunc_pow: _pyfunc_pow, _pyfunc_sum: _pyfunc_sum, _pyfunc_round: _pyfunc_round, _pyfunc_int: _pyfunc_int, _pyfunc_float: _pyfunc_float, _pyfunc_str: _pyfunc_str, _pyfunc_repr: _pyfunc_repr, _pyfunc_bool: _pyfunc_bool, _pyfunc_abs: _pyfunc_abs, _pyfunc_divmod: _pyfunc_divmod, _pyfunc_all: _pyfunc_all, _pyfunc_any: _pyfunc_any, _pyfunc_enumerate: _pyfunc_enumerate, _pyfunc_zip: _pyfunc_zip, _pyfunc_reversed: _pyfunc_reversed, _pyfunc_sorted: _pyfunc_sorted, _pyfunc_filter: _pyfunc_filter, _pyfunc_map: _pyfunc_map, _pyfunc_truthy: _pyfunc_truthy, _pyfunc_op_equals: _pyfunc_op_equals, _pyfunc_op_contains: _pyfunc_op_contains, _pyfunc_op_add: _pyfunc_op_add, _pyfunc_op_mult: _pyfunc_op_mult, _pymeth_append: _pymeth_append, _pymeth_extend: _pymeth_extend, _pymeth_insert: _pymeth_insert, _pymeth_remove: _pymeth_remove, _pymeth_reverse: _pymeth_reverse, _pymeth_sort: _pymeth_sort, _pymeth_clear: _pymeth_clear, _pymeth_copy: _pymeth_copy, _pymeth_pop: _pymeth_pop, _pymeth_count: _pymeth_count, _pymeth_index: _pymeth_index, _pymeth_get: _pymeth_get, _pymeth_items: _pymeth_items, _pymeth_keys: _pymeth_keys, _pymeth_popitem: _pymeth_popitem, _pymeth_setdefault: _pymeth_setdefault, _pymeth_update: _pymeth_update, _pymeth_values: _pymeth_values, _pymeth_repeat: _pymeth_repeat, _pymeth_capitalize: _pymeth_capitalize, _pymeth_casefold: _pymeth_casefold, _pymeth_center: _pymeth_center, _pymeth_endswith: _pymeth_endswith, _pymeth_expandtabs: _pymeth_expandtabs, _pymeth_find: _pymeth_find, _pymeth_isalnum: _pymeth_isalnum, _pymeth_isalpha: _pymeth_isalpha, _pymeth_isidentifier: _pymeth_isidentifier, _pymeth_islower: _pymeth_islower, _pymeth_isnumeric: _pymeth_isnumeric, _pymeth_isspace: _pymeth_isspace, _pymeth_istitle: _pymeth_istitle, _pymeth_isupper: _pymeth_isupper, _pymeth_join: _pymeth_join, _pymeth_ljust: _pymeth_ljust, _pymeth_lower: _pymeth_lower, _pymeth_lstrip: _pymeth_lstrip, _pymeth_partition: _pymeth_partition, _pymeth_replace: _pymeth_replace, _pymeth_rfind: _pymeth_rfind, _pymeth_rindex: _pymeth_rindex, _pymeth_rjust: _pymeth_rjust, _pymeth_rpartition: _pymeth_rpartition, _pymeth_rsplit: _pymeth_rsplit, _pymeth_rstrip: _pymeth_rstrip, _pymeth_split: _pymeth_split, _pymeth_splitlines: _pymeth_splitlines, _pymeth_startswith: _pymeth_startswith, _pymeth_strip: _pymeth_strip, _pymeth_swapcase: _pymeth_swapcase, _pymeth_title: _pymeth_title, _pymeth_translate: _pymeth_translate, _pymeth_upper: _pymeth_upper, _pymeth_zfill: _pymeth_zfill};\n",
       "});\n",
       "\n",
       "\n",
       "/* =========================== flexx.event.js ===========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "flexx.define(\"flexx.event.js\", [\"pscript-std.js\"], function (_py) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_truthy = _py._pyfunc_truthy, _pyfunc_str = _py._pyfunc_str, _pyfunc_dict = _py._pyfunc_dict, _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_all = _py._pyfunc_all, _pyfunc_op_mult = _py._pyfunc_op_mult, _pyfunc_op_parse_kwargs = _py._pyfunc_op_parse_kwargs, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_hasattr = _py._pyfunc_hasattr, _pyfunc_repr = _py._pyfunc_repr, _pyfunc_setattr = _py._pyfunc_setattr, _pyfunc_int = _py._pyfunc_int, _pyfunc_float = _py._pyfunc_float, _pyfunc_range = _py._pyfunc_range, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_list = _py._pyfunc_list, _pyfunc_bool = _py._pyfunc_bool, _pyfunc_getattr = _py._pyfunc_getattr;\n",
       "var _pymeth_clear = _py._pymeth_clear, _pymeth_partition = _py._pymeth_partition, _pymeth_sort = _py._pymeth_sort, _pymeth_insert = _py._pymeth_insert, _pymeth_lower = _py._pymeth_lower, _pymeth_repeat = _py._pymeth_repeat, _pymeth_replace = _py._pymeth_replace, _pymeth_split = _py._pymeth_split, _pymeth_pop = _py._pymeth_pop, _pymeth_copy = _py._pymeth_copy, _pymeth_append = _py._pymeth_append, _pymeth_rstrip = _py._pymeth_rstrip, _pymeth_endswith = _py._pymeth_endswith, _pymeth_lstrip = _py._pymeth_lstrip, _pymeth_strip = _py._pymeth_strip, _pymeth_upper = _py._pymeth_upper, _pymeth_join = _py._pymeth_join, _pymeth_startswith = _py._pymeth_startswith, _pymeth_get = _py._pymeth_get;\n",
       "var _mutate_array_js;\n",
       "_mutate_array_js = function flx__mutate_array_js (array, ev) {\n",
       "\tvar err_3, index, is_nd, mutation, objects;\n",
       "\tis_nd = _pyfunc_hasattr(array, \"shape\") && _pyfunc_hasattr(array, \"dtype\");\n",
       "\tmutation = ev.mutation;\n",
       "\tindex = ev.index;\n",
       "\tobjects = ev.objects;\n",
       "\tif ((is_nd === true)) {\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot set nd array in-place\");\n",
       "\t\t} else if (_pyfunc_op_contains(mutation, [\"extend\", \"insert\", \"remove\"])) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot resize nd arrays\");\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"replace\")) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot replace items in nd array\");\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\t\tif (!(Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'number')) { throw _pyfunc_op_error('AssertionError', \"Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'number'\");}\n",
       "\t\t} else if ((!Array.isArray(objects))) {\n",
       "\t\t\tthrow _pyfunc_op_error('TypeError', \"Inplace list/array mutating requires a list of objects.\");\n",
       "\t\t}\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([0, array.length], objects));\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"insert\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([index, 0], objects));\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\t\tarray.splice(index, objects);\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"replace\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([index, objects.length], objects));\n",
       "\t\t} else {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', mutation);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var mutate_array = _mutate_array_js;\n",
       "var mutate_dict;\n",
       "mutate_dict = function flx_mutate_dict (d, ev) {\n",
       "\tvar err_2, key, mutation, objects, stub1_seq, stub2_seq, stub3_itr, val;\n",
       "\tmutation = ev[\"mutation\"];\n",
       "\tobjects = ev[\"objects\"];\n",
       "\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t_pymeth_clear.call(d);\n",
       "\t} else if (_pyfunc_op_contains(mutation, [\"set\", \"insert\", \"replace\"])) {\n",
       "\t\tif (!(Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'object')) { throw _pyfunc_op_error('AssertionError', \"Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'object'\");}\n",
       "\t\tstub1_seq = objects;\n",
       "\t\tfor (key in stub1_seq) {\n",
       "\t\t\tif (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "\t\t\tval = stub1_seq[key];\n",
       "\t\t\td[key] = val;\n",
       "\t\t}\n",
       "\t} else if (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\tif (!(Array.isArray(objects))) { throw _pyfunc_op_error('AssertionError', \"Array.isArray(objects)\");}\n",
       "\t\tstub2_seq = objects;\n",
       "\t\tif ((typeof stub2_seq === \"object\") && (!Array.isArray(stub2_seq))) { stub2_seq = Object.keys(stub2_seq);}\n",
       "\t\tfor (stub3_itr = 0; stub3_itr < stub2_seq.length; stub3_itr += 1) {\n",
       "\t\t\tkey = stub2_seq[stub3_itr];\n",
       "\t\t\t_pymeth_pop.call(d, key);\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('NotImplementedError', mutation);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var Logger = function () {\n",
       "\tthis.level = 25;\n",
       "}\n",
       "var $Logger = Logger.prototype;\n",
       "$Logger.debug = function (msg) {\n",
       "\tif (this.level <= 10) { console.info(msg); }\n",
       "};\n",
       "$Logger.info = function (msg) {\n",
       "\tif (this.level <= 20) { console.info(msg); }\n",
       "};\n",
       "$Logger.warn = function (msg) {\n",
       "\tif (this.level <= 30) { console.warn(msg); }\n",
       "};\n",
       "$Logger.exception = function (msg) {\n",
       "\tconsole.error(msg);\n",
       "};\n",
       "$Logger.error = function (msg) {\n",
       "\tconsole.error(msg);\n",
       "};\n",
       "var logger = new Logger();\n",
       "var Loop;\n",
       "Loop = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "var $Loop = Loop.prototype;\n",
       "$Loop.__init__ = function () {\n",
       "\tthis._active_components = [];\n",
       "\tthis.reset();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._call_soon_func = function (func) {\n",
       "\tsetTimeout(func, 0);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._iter_callback = function () {\n",
       "\tthis._scheduled_call_to_iter = false;\n",
       "\treturn this.iter();\n",
       "};\n",
       "\n",
       "\n",
       "$Loop.__enter__ = function () {\n",
       "\treturn this;\n",
       "};\n",
       "\n",
       "$Loop.__exit__ = function (type, value, traceback) {\n",
       "\tthis.iter();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._activate_component = function (component) {\n",
       "\t_pymeth_append.call(this._active_components, component);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._deactivate_component = function (component) {\n",
       "\tvar err_2, top;\n",
       "\ttop = _pymeth_pop.call(this._active_components, (-1));\n",
       "\tif ((top !== component)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', (\"loop._deactivate_component: \" + component.id + \" is not \" + (_pyfunc_truthy(top) && _pyfunc_truthy(top.id)) + \"\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_actions = function (n) {\n",
       "\tvar action, args, err, i, pending_actions, stub1_err, stub2_;\n",
       "\tn = (n === undefined) ? null: n;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tif ((n === null)) {\n",
       "\t\t\tpending_actions = this._pending_actions;\n",
       "\t\t\tthis._pending_actions = [];\n",
       "\t\t} else {\n",
       "\t\t\tpending_actions = this._pending_actions.slice(0,n);\n",
       "\t\t\tthis._pending_actions = this._pending_actions.slice(n);\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < pending_actions.length; i += 1) {\n",
       "\t\tstub2_ = pending_actions[i];\n",
       "\t\taction = stub2_[0];args = stub2_[1];\n",
       "\t\tthis._processing_action = action;\n",
       "\t\ttry {\n",
       "\t\t\taction.apply(null, args);\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t} finally {\n",
       "\t\t\tthis._processing_action = null;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_calls = function () {\n",
       "\tvar args, err, func, i, pending_calls, stub1_err, stub2_;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tpending_calls = this._pending_calls;\n",
       "\t\tthis._pending_calls = [];\n",
       "\t}\n",
       "\tfor (i = 0; i < pending_calls.length; i += 1) {\n",
       "\t\tstub2_ = pending_calls[i];\n",
       "\t\tfunc = stub2_[0];args = stub2_[1];\n",
       "\t\ttry {\n",
       "\t\t\tfunc.apply(null, args);\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_reactions = function () {\n",
       "\tvar _, component, component_names, connections, err, events, ir, name, pending_reactions, reaction, stub1_err, stub2_, stub3_seq, stub4_seq;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tpending_reactions = this._pending_reactions;\n",
       "\t\tthis._pending_reactions = [];\n",
       "\t\tthis._pending_reaction_ids = ({});\n",
       "\t}\n",
       "\tfor (ir = 0; ir < pending_reactions.length; ir += 1) {\n",
       "\t\tstub2_ = pending_reactions[ir];\n",
       "\t\treaction = stub2_[0];_ = stub2_[1];events = stub2_[2];\n",
       "\t\tif (((events.length > 0) || (_pyfunc_op_equals(reaction.get_mode(), \"auto\")))) {\n",
       "\t\t\tthis._prop_access = ({});\n",
       "\t\t\tthis._processing_reaction = reaction;\n",
       "\t\t\ttry {\n",
       "\t\t\t\treaction.apply(null, events);\n",
       "\t\t\t} catch(err_4) {\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\terr = err_4;\n",
       "\t\t\t\t\tlogger.exception(err);\n",
       "\t\t\t\t}\n",
       "\t\t\t} finally {\n",
       "\t\t\t\tthis._processing_reaction = null;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\ttry {\n",
       "\t\t\tif ((_pyfunc_op_equals(reaction.get_mode(), \"auto\"))) {\n",
       "\t\t\t\tconnections = [];\n",
       "\t\t\t\tstub4_seq = this._prop_access;\n",
       "\t\t\t\tfor (component_names in stub4_seq) {\n",
       "\t\t\t\t\tif (!stub4_seq.hasOwnProperty(component_names)){ continue; }\n",
       "\t\t\t\t\tcomponent_names = stub4_seq[component_names];\n",
       "\t\t\t\t\tcomponent = component_names[0];\n",
       "\t\t\t\t\tstub3_seq = component_names[1];\n",
       "\t\t\t\t\tfor (name in stub3_seq) {\n",
       "\t\t\t\t\t\tif (!stub3_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\t\t\t\t\t_pymeth_append.call(connections, [component, name]);\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t}\n",
       "\t\t\t\treaction._update_implicit_connections(connections);\n",
       "\t\t\t}\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t} finally {\n",
       "\t\t\tthis._prop_access = ({});\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._schedule_iter = function () {\n",
       "\tif ((this._scheduled_call_to_iter === false)) {\n",
       "\t\tthis._scheduled_call_to_iter = true;\n",
       "\t\tthis._call_soon_func(this._iter_callback);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.add_action_invokation = function (action, args) {\n",
       "\tvar stub1_err;\n",
       "\t{/* with lock */\n",
       "\t\t_pymeth_append.call(this._pending_actions, [action, args]);\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.add_reaction_event = function (reaction, ev) {\n",
       "\tvar ev2, i, mode, new_item, pending_reactions, stub1_err;\n",
       "\tpending_reactions = this._pending_reactions;\n",
       "\tmode = reaction.get_mode();\n",
       "\t{/* with lock */\n",
       "\t\t\t\tif (_pyfunc_op_equals(mode, \"normal\")) {\n",
       "\t\t\ti = pending_reactions.length;\n",
       "\t\t\twhile (i > 0) {\n",
       "\t\t\t\ti -= 1;\n",
       "\t\t\t\tev2 = pending_reactions[i][1];\n",
       "\t\t\t\tif (((pending_reactions[i][0]) === reaction)) {\n",
       "\t\t\t\t\t_pymeth_append.call((pending_reactions[i][2]), ev);\n",
       "\t\t\t\t\tif ((!((ev2[\"source\"] === ev[\"source\"]) && _pyfunc_op_equals(ev2[\"type\"], ev[\"type\"])))) {\n",
       "\t\t\t\t\t\tpending_reactions[i][1] = ({source: null});\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t\treturn null;\n",
       "\t\t\t\t}\n",
       "\t\t\t\tif ((!((ev2 === null) || ((ev2[\"source\"] === ev[\"source\"]) && _pyfunc_op_equals(ev2.type, ev.type))))) {\n",
       "\t\t\t\t\tbreak;\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t} else if (_pyfunc_op_contains(reaction._id, this._pending_reaction_ids)) {\n",
       "\t\t\tif ((reaction._connections.length > 0)) {\n",
       "\t\t\t\t_pymeth_append.call((this._pending_reaction_ids[reaction._id][2]), ev);\n",
       "\t\t\t}\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((reaction._connections.length > 0)) {\n",
       "\t\t\tnew_item = [reaction, ev, [ev]];\n",
       "\t\t} else {\n",
       "\t\t\tnew_item = [reaction, null, []];\n",
       "\t\t}\n",
       "\t\t_pymeth_append.call(pending_reactions, new_item);\n",
       "\t\tthis._pending_reaction_ids[reaction._id] = new_item;\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.call_soon = function (func) {\n",
       "\tvar args, stub1_err;\n",
       "\targs = Array.prototype.slice.call(arguments, 1);\n",
       "\t{/* with lock */\n",
       "\t\t_pymeth_append.call(this._pending_calls, [func, args]);\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.can_mutate = function (component) {\n",
       "\tvar active;\n",
       "\tcomponent = (component === undefined) ? null: component;\n",
       "\tactive = this.get_active_component();\n",
       "\tif ((active !== null)) {\n",
       "\t\treturn active === component;\n",
       "\t} else {\n",
       "\t\treturn this._processing_action !== null;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.get_active_component = function () {\n",
       "\tif ((this._active_components.length > 0)) {\n",
       "\t\treturn this._active_components[this._active_components.length -1];\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.get_active_components = function () {\n",
       "\treturn _pyfunc_list(this._active_components);\n",
       "};\n",
       "\n",
       "$Loop.has_pending = function () {\n",
       "\treturn (this._pending_reactions.length > 0) || (this._pending_actions.length > 0) || (this._pending_calls.length > 0);\n",
       "};\n",
       "\n",
       "$Loop.iter = function () {\n",
       "\tvar err_2, stub1_err;\n",
       "\t{/* with lock */\n",
       "\t\t\t}\n",
       "\tif ((this._in_iter === true)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"Cannot call flexx.event.loop.iter() while it is processing.\");\n",
       "\t}\n",
       "\tthis._in_iter = true;\n",
       "\ttry {\n",
       "\t\tthis._process_calls();\n",
       "\t\tthis._process_actions();\n",
       "\t\tthis._process_reactions();\n",
       "\t} finally {\n",
       "\t\tthis._in_iter = false;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.register_prop_access = function (component, prop_name) {\n",
       "\tvar d;\n",
       "\tif ((this._processing_reaction !== null)) {\n",
       "\t\tif ((_pyfunc_op_equals(this._processing_reaction.get_mode(), \"auto\"))) {\n",
       "\t\t\t {\n",
       "\t\t\t\tif ((!_pyfunc_op_contains(component._id, this._prop_access))) {\n",
       "\t\t\t\t\td = ({});\n",
       "\t\t\t\t\tthis._prop_access[component._id] = [component, d];\n",
       "\t\t\t\t} else {\n",
       "\t\t\t\t\td = this._prop_access[component._id][1];\n",
       "\t\t\t\t}\n",
       "\t\t\t\td[prop_name] = true;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.reset = function () {\n",
       "\tthis._in_iter = false;\n",
       "\tthis._scheduled_call_to_iter = false;\n",
       "\tthis._processing_action = null;\n",
       "\tthis._processing_reaction = null;\n",
       "\tthis._prop_access = ({});\n",
       "\tthis._pending_calls = [];\n",
       "\tthis._pending_actions = [];\n",
       "\tthis._pending_reactions = [];\n",
       "\tthis._pending_reaction_ids = ({});\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var loop = new Loop();\n",
       "var Component;\n",
       "Component = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "var $Component = Component.prototype;\n",
       "$Component._base_class = Object;\n",
       "$Component.__name__ = \"Component\";\n",
       "\n",
       "$Component._IS_COMPONENT = true;\n",
       "$Component._COUNT = 0;\n",
       "$Component._REACTION_COUNT = 0;\n",
       "$Component.__init__ = function () {\n",
       "\tvar i, init_args, name, property_values, stub1_err;\n",
       "\tproperty_values = {};\n",
       "\tif (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "\t\tproperty_values = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "\t\tinit_args = arguments[0].flx_args;\n",
       "\t} else {init_args = Array.prototype.slice.call(arguments);}\n",
       "\t$Component._COUNT += 1;\n",
       "\tthis._id = this.__name__ + $Component._COUNT;\n",
       "\tthis._disposed = false;\n",
       "\tthis._Component__handlers = ({});\n",
       "\tthis._Component__pending_events = [];\n",
       "\tthis._Component__anonymous_reactions = [];\n",
       "\tthis._Component__initial_mutation = false;\n",
       "\tfor (i = 0; i < this.__actions__.length; i += 1) {\n",
       "\t\tname = this.__actions__[i];\n",
       "\t\tthis._Component__create_action(this[name], name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__emitters__.length; i += 1) {\n",
       "\t\tname = this.__emitters__[i];\n",
       "\t\tthis._Component__handlers[name] = [];\n",
       "\t\tthis._Component__create_emitter(this[name], name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__properties__.length; i += 1) {\n",
       "\t\tname = this.__properties__[i];\n",
       "\t\tthis._Component__handlers[name] = [];\n",
       "\t\tthis._Component__create_property(name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__attributes__.length; i += 1) {\n",
       "\t\tname = this.__attributes__[i];\n",
       "\t\tthis._Component__create_attribute(name);\n",
       "\t}\n",
       "\tthis.__enter__();\n",
       "\ttry {\n",
       "\t\tthis._comp_init_property_values(property_values);\n",
       "\t\tthis.init.apply(this, init_args);\n",
       "\t} catch(err_1)  { stub1_err=err_1; }\n",
       "\tif (stub1_err) { if (!this.__exit__(stub1_err.name || \"error\", stub1_err, null)) { throw stub1_err; }\n",
       "\t} else { this.__exit__(null, null, null); }\n",
       "\tthis._comp_init_reactions();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_init_property_values = function (property_values) {\n",
       "\tvar err_4, i, name, stub2_seq, value, values;\n",
       "\tvalues = [];\n",
       "\tfor (i = 0; i < this.__properties__.length; i += 1) {\n",
       "\t\tname = this.__properties__[i];\n",
       "\t\tif ((!_pyfunc_op_contains(name, property_values))) {\n",
       "\t\t\t_pymeth_append.call(values, ([name, this[(\"_\" + name) + \"_value\"]]));\n",
       "\t\t}\n",
       "\t}\n",
       "\tstub2_seq = property_values;\n",
       "\tfor (name in stub2_seq) {\n",
       "\t\tif (!stub2_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\tvalue = stub2_seq[name];\n",
       "\t\tif ((!_pyfunc_op_contains(name, this.__properties__))) {\n",
       "\t\t\tif (_pyfunc_op_contains(name, this.__attributes__)) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + this._id + \".\" + name + \" is an attribute, not a property\"));\n",
       "\t\t\t} else {\n",
       "\t\t\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + this._id + \" does not have property \" + name + \".\"));\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tif ((typeof value === \"function\")) {\n",
       "\t\t\tthis._comp_make_implicit_setter(name, value);\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\t_pymeth_append.call(values, [name, value]);\n",
       "\t}\n",
       "\tthis._comp_apply_property_values(values);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_make_implicit_setter = function (prop_name, func) {\n",
       "\tvar err_2, reaction, setter_func, setter_reaction, t;\n",
       "\tsetter_func = _pyfunc_getattr(this, (\"set_\" + prop_name), null);\n",
       "\tif ((setter_func === null)) {\n",
       "\t\tt = \"%s does not have a set_%s() action for property %s.\";\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (t % [this._id, prop_name, prop_name]));\n",
       "\t}\n",
       "\tsetter_reaction = (function () {return setter_func(func());}).bind(this);\n",
       "\treaction = this._Component__create_reaction(setter_reaction, \"auto-\" + prop_name, \"auto\", []);\n",
       "\t_pymeth_append.call(this._Component__anonymous_reactions, reaction);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_init_reactions = function () {\n",
       "\tvar ev, func, i, name, r;\n",
       "\tif ((this._Component__pending_events !== null)) {\n",
       "\t\t_pymeth_append.call(this._Component__pending_events, null);\n",
       "\t\tloop.call_soon(this._comp_stop_capturing_events);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__reactions__.length; i += 1) {\n",
       "\t\tname = this.__reactions__[i];\n",
       "\t\tfunc = this[name];\n",
       "\t\tr = this._Component__create_reaction(func, name, func._mode, _pyfunc_truthy(func._connection_strings) || []);\n",
       "\t\tif ((_pyfunc_op_equals(r.get_mode(), \"auto\"))) {\n",
       "\t\t\tev = {source:this, type:\"\", label:\"\"};\n",
       "\t\t\tloop.add_reaction_event(r, ev);\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < this._Component__anonymous_reactions.length; i += 1) {\n",
       "\t\tr = this._Component__anonymous_reactions[i];\n",
       "\t\tif ((_pyfunc_op_equals(r.get_mode(), \"auto\"))) {\n",
       "\t\t\tev = {source:this, type:\"\", label:\"\"};\n",
       "\t\t\tloop.add_reaction_event(r, ev);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.reaction = function () {\n",
       "\tvar connection_strings, err_2, err_3, func, i, mode, name, nameparts, s;\n",
       "\tconnection_strings = Array.prototype.slice.call(arguments);\n",
       "\tif ((connection_strings.length < 2)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"Component.reaction() (js) needs a function and one or more connection strings.\");\n",
       "\t}\n",
       "\tif ((typeof connection_strings[0] === \"function\")) {\n",
       "\t\tfunc = connection_strings[0];\n",
       "\t\tconnection_strings = connection_strings.slice(1);\n",
       "\t} else if ((typeof connection_strings[connection_strings.length -1] === \"function\")) {\n",
       "\t\tfunc = connection_strings[connection_strings.length -1];\n",
       "\t\tconnection_strings = connection_strings.slice(0,-1);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"Component.reaction() requires a callable.\");\n",
       "\t}\n",
       "\tfor (i = 0; i < connection_strings.length; i += 1) {\n",
       "\t\ts = connection_strings[i];\n",
       "\t\tif ((!(((Object.prototype.toString.call(s).slice(8,-1).toLowerCase() === 'string')) && s.length))) {\n",
       "\t\t\tthrow _pyfunc_op_error('ValueError', \"Connection string must be nonempty strings.\");\n",
       "\t\t}\n",
       "\t}\n",
       "\tname = func.__name__ || func.name || 'anonymous';\n",
       "\tnameparts = name.split(' ');\n",
       "\tnameparts = nameparts[nameparts.length-1].split('flx_');\n",
       "\tname = nameparts[nameparts.length -1];\n",
       "\tmode = \"normal\";\n",
       "\treturn this._Component__create_reaction_ob(func, name, mode, connection_strings);\n",
       "};\n",
       "\n",
       "$Component._Component__create_action = function (action_func, name) {\n",
       "\tvar action, getter, opts, setter;\n",
       "\taction = (function flx_action () {\n",
       "\t\tvar res;\n",
       "\t\tif ((loop.can_mutate(this) === true)) {\n",
       "\t\t\tres = action_func.apply(this, arguments);\n",
       "\t\t\tif ((res !== null)) {\n",
       "\t\t\t\tlogger.warn(\"Action (\" + name + \") is not supposed to return a value\");\n",
       "\t\t\t}\n",
       "\t\t} else {\n",
       "\t\t\tloop.add_action_invokation(action, arguments);\n",
       "\t\t}\n",
       "\t\treturn this;\n",
       "\t}).bind(this);\n",
       "\n",
       "\taction.is_autogenerated = _pyfunc_op_equals(action_func.name, \"flx_setter\");\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn action;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Action \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_attribute = function (name) {\n",
       "\tvar getter, opts, setter;\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn this[\"_\" + name];\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Cannot set attribute \" + _pyfunc_repr(name) + \"\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: false, configurable: false, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_property = function (name) {\n",
       "\tvar getter, opts, private_name, setter;\n",
       "\tprivate_name = (\"_\" + name) + \"_value\";\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\tloop.register_prop_access(this, name);\n",
       "\t\treturn this[private_name];\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Cannot set property \" + _pyfunc_repr(name) + \"; properties can only be mutated by actions.\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_emitter = function (emitter_func, name) {\n",
       "\tvar func, getter, opts, setter;\n",
       "\tfunc = (function flx_func () {\n",
       "\t\tvar ev;\n",
       "\t\tev = emitter_func.apply(this, arguments);\n",
       "\t\tif ((ev !== null)) {\n",
       "\t\t\tthis.emit(name, ev);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn func;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Emitter \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_reaction = function (reaction_func, name, mode, c_strings) {\n",
       "\tvar getter, opts, reaction, setter;\n",
       "\treaction = this._Component__create_reaction_ob(reaction_func, name, mode, c_strings);\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn reaction;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Reaction \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn reaction;\n",
       "};\n",
       "\n",
       "$Component._Component__create_reaction_ob = function (reaction_func, name, mode, connection_strings) {\n",
       "\tvar reaction, that;\n",
       "\treaction = (function flx_reaction () {\n",
       "\t\treturn reaction_func.apply(this, arguments);\n",
       "\t}).bind(this);\n",
       "\n",
       "\t\n",
       "\treaction._clear_component_refs = function (ob) {\n",
       "\t\tvar connection, i, ic;\n",
       "\t\tfor (i = this._implicit_connections.length - 1; i > -1; i += -1) {\n",
       "\t\t\tif (((this._implicit_connections[i][0]) === ob)) {\n",
       "\t\t\t\t_pymeth_pop.call(this._implicit_connections, i);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tconnection = this._connections[ic];\n",
       "\t\t\tfor (i = connection.objects.length - 1; i > -1; i += -1) {\n",
       "\t\t\t\tif (((connection.objects[i][0]) === ob)) {\n",
       "\t\t\t\t\t_pymeth_pop.call(connection.objects, i);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._connect_and_disconnect = function (old_objects, new_objects, force) {\n",
       "\t\tvar i, i1, i2, i3, ob, stub1_, stub2_, stub3_, type;\n",
       "\t\tforce = (force === undefined) ? false: force;\n",
       "\t\ti1 = 0;\n",
       "\t\twhile ((i1 < new_objects.length) && (i1 < old_objects.length) && (((new_objects[i1][0]) === (old_objects[i1][0]))) && ((_pyfunc_op_equals((new_objects[i1][1]), (old_objects[i1][1]))))) {\n",
       "\t\t\ti1 = _pyfunc_op_add(i1, 1);\n",
       "\t\t}\n",
       "\t\tstub1_ = [new_objects.length - 1, old_objects.length - 1];\n",
       "\t\ti2 = stub1_[0];i3 = stub1_[1];\n",
       "\t\twhile ((i2 >= i1) && (i3 >= i1) && (((new_objects[i2][0]) === (old_objects[i3][0]))) && ((_pyfunc_op_equals((new_objects[i2][1]), (old_objects[i3][1]))))) {\n",
       "\t\t\ti2 -= 1;\n",
       "\t\t\ti3 -= 1;\n",
       "\t\t}\n",
       "\t\tfor (i = i1; i < i3 + 1; i += 1) {\n",
       "\t\t\tstub2_ = old_objects[i];\n",
       "\t\t\tob = stub2_[0];type = stub2_[1];\n",
       "\t\t\tob.disconnect(type, this);\n",
       "\t\t}\n",
       "\t\tfor (i = i1; i < i2 + 1; i += 1) {\n",
       "\t\t\tstub3_ = new_objects[i];\n",
       "\t\t\tob = stub3_[0];type = stub3_[1];\n",
       "\t\t\tob._register_reaction(type, this, force);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._init = function (connection_strings) {\n",
       "\t\tvar _, d, err_5, force, fullname, i, ic, ichars, ipart, is_identifier, label, part, parts, s, s0, stub1_;\n",
       "\t\tichars = \"0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n",
       "\t\tthis._connections = [];\n",
       "\t\tthis._implicit_connections = [];\n",
       "\t\tfor (ic = 0; ic < connection_strings.length; ic += 1) {\n",
       "\t\t\tfullname = connection_strings[ic];\n",
       "\t\t\tforce = _pymeth_startswith.call(fullname, \"!\");\n",
       "\t\t\tstub1_ = _pymeth_partition.call(_pymeth_lstrip.call(fullname, \"!\"), \":\");\n",
       "\t\t\ts = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\t\t\ts0 = s;\n",
       "\t\t\tif ((_pyfunc_op_contains(\".*.\", (s + \".\")))) {\n",
       "\t\t\t\ts = _pymeth_replace.call(s, \".*\", \"*\");\n",
       "\t\t\t\tconsole.warn(\"Connection string syntax \\\"foo.*.bar\\\" is deprecated, use \\\"\" + s + \"\\\" instead of \\\"\" + s0 + \"\\\":.\");\n",
       "\t\t\t}\n",
       "\t\t\tif (_pyfunc_op_contains(\"!\", s)) {\n",
       "\t\t\t\ts = _pymeth_replace.call(s, \"!\", \"\");\n",
       "\t\t\t\tforce = true;\n",
       "\t\t\t\tconsole.warn(\"Exclamation marks in connection strings must come at the very start, use \\\"!\" + s + \"\\\" instead of \\\"\" + s0 + \"\\\".\");\n",
       "\t\t\t}\n",
       "\t\t\tparts = _pymeth_split.call(s, \".\");\n",
       "\t\t\tfor (ipart = 0; ipart < parts.length; ipart += 1) {\n",
       "\t\t\t\tpart = _pymeth_rstrip.call(parts[ipart], \"*\");\n",
       "\t\t\t\tis_identifier = part.length > 0;\n",
       "\t\t\t\tfor (i = 0; i < part.length; i += 1) {\n",
       "\t\t\t\t\tis_identifier = _pyfunc_truthy(is_identifier) && _pyfunc_op_contains(part[i], ichars);\n",
       "\t\t\t\t}\n",
       "\t\t\t\tif ((is_identifier === false)) {\n",
       "\t\t\t\t\tthrow _pyfunc_op_error('ValueError', (\"Connection string \" + _pyfunc_repr(s) + \" contains non-identifier part \" + _pyfunc_repr(part) + \"\"));\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\td = {};\n",
       "\t\t\t_pymeth_append.call(this._connections, d);\n",
       "\t\t\td.fullname = fullname;\n",
       "\t\t\td.parts = parts;\n",
       "\t\t\td.type = _pyfunc_op_add((_pymeth_rstrip.call(parts[parts.length -1], \"*\") + \":\"), (_pyfunc_truthy(label) || this._name));\n",
       "\t\t\td.force = force;\n",
       "\t\t\td.objects = [];\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tthis.reconnect(ic);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._seek_event_object = function (index, path, ob) {\n",
       "\t\tvar connection, err_3, isub, name_label, new_ob, obname, obname_full, selector, stub1_, t;\n",
       "\t\tconnection = this._connections[index];\n",
       "\t\tif (((ob === null) || (path.length == 0))) {\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((path.length == 1)) {\n",
       "\t\t\tif (_pyfunc_hasattr(ob, \"_IS_COMPONENT\")) {\n",
       "\t\t\t\t_pymeth_append.call(connection.objects, [ob, connection.type]);\n",
       "\t\t\t}\n",
       "\t\t\tif ((!_pyfunc_truthy(_pymeth_endswith.call(path[0], \"**\")))) {\n",
       "\t\t\t\treturn null;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tstub1_ = [path[0], path.slice(1)];\n",
       "\t\tobname_full = stub1_[0];path = stub1_[1];\n",
       "\t\tobname = _pymeth_rstrip.call(obname_full, \"*\");\n",
       "\t\tselector = obname_full.slice(obname.length);\n",
       "\t\tif (_pyfunc_op_equals(selector, \"***\")) {\n",
       "\t\t\tthis._seek_event_object(index, path, ob);\n",
       "\t\t}\n",
       "\t\tif ((_pyfunc_hasattr(ob, \"_IS_COMPONENT\") && _pyfunc_op_contains(obname, ob.__properties__))) {\n",
       "\t\t\tname_label = _pyfunc_op_add((obname + \":reconnect_\"), _pyfunc_str(index));\n",
       "\t\t\t_pymeth_append.call(connection.objects, [ob, name_label]);\n",
       "\t\t\tnew_ob = _pyfunc_getattr(ob, obname, null);\n",
       "\t\t} else {\n",
       "\t\t\tnew_ob = _pyfunc_getattr(ob, obname, null);\n",
       "\t\t}\n",
       "\t\tif (_pyfunc_truthy(selector.length && _pyfunc_op_contains(selector, \"***\") && Array.isArray(new_ob))) {\n",
       "\t\t\tif ((selector.length > 1)) {\n",
       "\t\t\t\tpath = _pyfunc_op_add([obname + \"***\"], path);\n",
       "\t\t\t}\n",
       "\t\t\tfor (isub = 0; isub < new_ob.length; isub += 1) {\n",
       "\t\t\t\tthis._seek_event_object(index, path, new_ob[isub]);\n",
       "\t\t\t}\n",
       "\t\t\treturn null;\n",
       "\t\t} else if (_pyfunc_op_equals(selector, \"*\")) {\n",
       "\t\t\tt = \"Invalid connection {name_full} because {name} is not a tuple/list.\";\n",
       "\t\t\tthrow _pyfunc_op_error('RuntimeError', (_pymeth_replace.call(_pymeth_replace.call(t, \"{name_full}\", obname_full), \"{name}\", obname)));\n",
       "\t\t} else {\n",
       "\t\t\treturn this._seek_event_object(index, path, new_ob);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._update_implicit_connections = function (connections) {\n",
       "\t\tvar new_conns, old_conns;\n",
       "\t\told_conns = this._implicit_connections;\n",
       "\t\tnew_conns = connections;\n",
       "\t\tthis._implicit_connections = new_conns;\n",
       "\t\tthis._connect_and_disconnect(old_conns, new_conns);\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._use_once = function (func) {\n",
       "\t\tthis._func_once = func;\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction.dispose = function () {\n",
       "\t\tvar connection, ic, ob, stub1_, stub2_, type;\n",
       "\t\tif (((this._connections.length == 0) && (this._implicit_connections.length == 0))) {\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((!\"this_is_js()\")) {\n",
       "\t\t}\n",
       "\t\twhile (this._implicit_connections.length) {\n",
       "\t\t\tstub1_ = _pymeth_pop.call(this._implicit_connections, 0);\n",
       "\t\t\tob = stub1_[0];type = stub1_[1];\n",
       "\t\t\tob.disconnect(type, this);\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tconnection = this._connections[ic];\n",
       "\t\t\twhile (connection.objects.length > 0) {\n",
       "\t\t\t\tstub2_ = _pymeth_pop.call(connection.objects, 0);\n",
       "\t\t\t\tob = stub2_[0];type = stub2_[1];\n",
       "\t\t\t\tob.disconnect(type, this);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tthis._connections = [];\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction.get_connection_info = function () {\n",
       "\t\treturn (function list_comprehension (iter0) {var res = [];var c, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {c = iter0[i0];{res.push([c.fullname, (function list_comprehension (iter0) {var res = [];var u, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {u = iter0[i0];{res.push(u[1]);}}return res;}).call(this, c.objects)]);}}return res;}).call(this, this._connections);\n",
       "\t};\n",
       "\n",
       "\treaction.get_mode = function () {\n",
       "\t\treturn this._mode;\n",
       "\t};\n",
       "\n",
       "\treaction.get_name = function () {\n",
       "\t\treturn this._name;\n",
       "\t};\n",
       "\n",
       "\treaction.reconnect = function (index) {\n",
       "\t\tvar connection, err_3, new_objects, ob, old_objects;\n",
       "\t\tconnection = this._connections[index];\n",
       "\t\told_objects = connection.objects;\n",
       "\t\tconnection.objects = [];\n",
       "\t\tob = this._ob1();\n",
       "\t\tif ((ob !== null)) {\n",
       "\t\t\tthis._seek_event_object(index, connection.parts, ob);\n",
       "\t\t}\n",
       "\t\tnew_objects = connection.objects;\n",
       "\t\tif ((new_objects.length == 0)) {\n",
       "\t\t\tthrow _pyfunc_op_error('RuntimeError', (\"Could not connect to \" + _pyfunc_repr(connection.fullname) + \"\"));\n",
       "\t\t}\n",
       "\t\tthis._connect_and_disconnect(old_objects, new_objects, connection.force);\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       ";\n",
       "\tthat = this;\n",
       "\t$Component._REACTION_COUNT += 1;\n",
       "\treaction._id = 'r' + $Component._REACTION_COUNT;\n",
       "\treaction._name = name;\n",
       "\treaction._mode = mode;\n",
       "\treaction._ob1 = (function () {return that;}).bind(this);\n",
       "\treaction._init(connection_strings, this);\n",
       "\treturn reaction;\n",
       "};\n",
       "\n",
       "\n",
       "$Component._Component__check_not_active = function () {\n",
       "\tvar active_components, err_2;\n",
       "\tactive_components = loop.get_active_components();\n",
       "\tif (_pyfunc_op_contains(this, active_components)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"It seems that the event loop is processing events while a Component is active. This has a high risk on race conditions.\");\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.__actions__ = []\n",
       "$Component.__attributes__ = [\"id\"]\n",
       "$Component.__emitters__ = []\n",
       "$Component.__enter__ = function () {\n",
       "\tloop._activate_component(this);\n",
       "\tloop.call_soon(this._Component__check_not_active);\n",
       "\treturn this;\n",
       "};\n",
       "\n",
       "$Component.__exit__ = function (type, value, traceback) {\n",
       "\tloop._deactivate_component(this);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.__properties__ = []\n",
       "$Component.__reactions__ = []\n",
       "$Component._comp_apply_property_values = function (values) {\n",
       "\tvar name, setter, setter_name, stub1_seq, stub2_itr, stub3_tgt, stub4_seq, stub5_itr, stub6_tgt, value;\n",
       "\tthis._Component__initial_mutation = true;\n",
       "\tstub1_seq = values;\n",
       "\tif ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "\tfor (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "\t\tstub3_tgt = stub1_seq[stub2_itr];\n",
       "\t\tname = stub3_tgt[0]; value = stub3_tgt[1];\n",
       "\t\tthis._mutate(name, value);\n",
       "\t}\n",
       "\tstub4_seq = values;\n",
       "\tif ((typeof stub4_seq === \"object\") && (!Array.isArray(stub4_seq))) { stub4_seq = Object.keys(stub4_seq);}\n",
       "\tfor (stub5_itr = 0; stub5_itr < stub4_seq.length; stub5_itr += 1) {\n",
       "\t\tstub6_tgt = stub4_seq[stub5_itr];\n",
       "\t\tname = stub6_tgt[0]; value = stub6_tgt[1];\n",
       "\t\tsetter_name = _pyfunc_op_add(((_pymeth_startswith.call(name, \"_\"))? (\"_set\") : (\"set_\")), name);\n",
       "\t\tsetter = _pyfunc_getattr(this, setter_name, null);\n",
       "\t\tif ((setter !== null)) {\n",
       "\t\t\tif ((_pyfunc_getattr(setter, \"is_autogenerated\", null) === false)) {\n",
       "\t\t\t\tsetter(value);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\tthis._Component__initial_mutation = false;\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_stop_capturing_events = function () {\n",
       "\tvar allow_reconnect, ev, events, stub1_seq, stub2_itr;\n",
       "\tevents = this._Component__pending_events;\n",
       "\tthis._Component__pending_events = null;\n",
       "\tallow_reconnect = false;\n",
       "\tstub1_seq = events;\n",
       "\tif ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "\tfor (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "\t\tev = stub1_seq[stub2_itr];\n",
       "\t\tif ((ev === null)) {\n",
       "\t\t\tallow_reconnect = true;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\tev.allow_reconnect = allow_reconnect;\n",
       "\t\tthis.emit(ev.type, ev);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._dispose = function () {\n",
       "\tvar i, name, reactions, stub1_seq;\n",
       "\tthis._disposed = true;\n",
       "\tif ((!\"this_is_js()\")) {\n",
       "\t}\n",
       "\tstub1_seq = this._Component__handlers;\n",
       "\tfor (name in stub1_seq) {\n",
       "\t\tif (!stub1_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\treactions = stub1_seq[name];\n",
       "\t\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\t\t((reactions[i][1])._clear_component_refs)(this);\n",
       "\t\t}\n",
       "\t\twhile (reactions.length) {\n",
       "\t\t\treactions.pop();\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__reactions__.length; i += 1) {\n",
       "\t\t(_pyfunc_getattr(this, this.__reactions__[i]).dispose)();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._mutate = function (prop_name, value, mutation, index) {\n",
       "\tvar cname, err_2, err_4, ev, is_equal, old, private_name, validator_name, value2;\n",
       "\tmutation = (mutation === undefined) ? \"set\": mutation;\n",
       "\tindex = (index === undefined) ? -1: index;\n",
       "\tif ((!(Object.prototype.toString.call(prop_name).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"_mutate's first arg must be str, not \" + Object.getPrototypeOf(prop_name) + \"\"));\n",
       "\t}\n",
       "\tif ((!_pyfunc_op_contains(prop_name, this.__properties__))) {\n",
       "\t\tcname = Object.getPrototypeOf(this).__name__;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + cname + \" object has no property \" + _pyfunc_repr(prop_name) + \"\"));\n",
       "\t}\n",
       "\tif ((loop.can_mutate(this) === false)) {\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Trying to mutate property \" + prop_name + \" outside of an action or context.\"));\n",
       "\t}\n",
       "\tprivate_name = (\"_\" + prop_name) + \"_value\";\n",
       "\tvalidator_name = (\"_\" + prop_name) + \"_validate\";\n",
       "\told = _pyfunc_getattr(this, private_name);\n",
       "\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\tvalue2 = _pyfunc_getattr(this, validator_name)(value);\n",
       "\t\t_pyfunc_setattr(this, private_name, value2);\n",
       "\t\t{ /* if this_is_js() */\n",
       "\t\tis_equal = _pyfunc_op_equals(old, value2);\n",
       "\t\t}\n",
       "\t\tif ((this._Component__initial_mutation === true)) {\n",
       "\t\t\told = value2;\n",
       "\t\t\tis_equal = false;\n",
       "\t\t}\n",
       "\t\tif ((!_pyfunc_truthy(is_equal))) {\n",
       "\t\t\tthis.emit(prop_name, {new_value:value2, old_value:old, mutation:mutation});\n",
       "\t\t\treturn true;\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tev = {};\n",
       "\t\tev.objects = value;\n",
       "\t\tev.mutation = mutation;\n",
       "\t\tev.index = index;\n",
       "\t\tif ((Object.prototype.toString.call(old).slice(8,-1).toLowerCase() === 'object')) {\n",
       "\t\t\tif ((!_pyfunc_op_equals(index, (-1)))) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('IndexError', \"For in-place dict mutations, the index is not used, and must be -1.\");\n",
       "\t\t\t}\n",
       "\t\t\tmutate_dict(old, ev);\n",
       "\t\t} else {\n",
       "\t\t\tif ((index < 0)) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('IndexError', \"For insert, remove, and replace mutations, the index must be >= 0.\");\n",
       "\t\t\t}\n",
       "\t\t\tmutate_array(old, ev);\n",
       "\t\t}\n",
       "\t\tthis.emit(prop_name, ev);\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._register_reaction = function (event_type, reaction, force) {\n",
       "\tvar _, comp1, comp2, i, label, msg, reactions, stub1_, stub2_els, type;\n",
       "\tforce = (force === undefined) ? false: force;\n",
       "\tstub1_ = _pymeth_partition.call(event_type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tlabel = _pyfunc_truthy(label) || reaction._name;\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, null);\n",
       "\tif ((reactions === null)) {\n",
       "\t\treactions = [];\n",
       "\t\tthis._Component__handlers[type] = reactions;\n",
       "\t\tif ((!_pyfunc_truthy(force))) {\n",
       "\t\t\tmsg = (\"Event type \\\"{type}\\\" does not exist on component {id}. \") + (\"Use \\\"!{type}\\\" or \\\"!xx.yy.{type}\\\" to suppress this warning.\");\n",
       "\t\t\tmsg = _pymeth_replace.call(_pymeth_replace.call(msg, \"{type}\", type), \"{id}\", this._id);\n",
       "\t\t\tlogger.warn(msg);\n",
       "\t\t}\n",
       "\t}\n",
       "\tcomp1 = _pyfunc_op_add((label + \"-\"), reaction._id);\n",
       "\tstub2_els = true;\n",
       "\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\tcomp2 = _pyfunc_op_add(((reactions[i][0]) + \"-\"), ((reactions[i][1])._id));\n",
       "\t\tif ((comp1 < comp2)) {\n",
       "\t\t\t_pymeth_insert.call(reactions, i, [label, reaction]);\n",
       "\t\t\tstub2_els = false; break;\n",
       "\t\t} else if (_pyfunc_op_equals(comp1, comp2)) {\n",
       "\t\t\tstub2_els = false; break;\n",
       "\t\t}\n",
       "\t} if (stub2_els) {\n",
       "\t\t_pymeth_append.call(reactions, [label, reaction]);\n",
       "\t}\n",
       "\tthis._registered_reactions_hook();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._registered_reactions_hook = function () {\n",
       "\tvar key, reactions, stub1_seq, used_event_types;\n",
       "\tused_event_types = [];\n",
       "\tstub1_seq = this._Component__handlers;\n",
       "\tfor (key in stub1_seq) {\n",
       "\t\tif (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "\t\treactions = stub1_seq[key];\n",
       "\t\tif ((reactions.length > 0)) {\n",
       "\t\t\t_pymeth_append.call(used_event_types, key);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn used_event_types;\n",
       "};\n",
       "\n",
       "$Component.disconnect = function (type, reaction) {\n",
       "\tvar _, entry, i, label, reactions, stub1_;\n",
       "\treaction = (reaction === undefined) ? null: reaction;\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, []);\n",
       "\tfor (i = reactions.length - 1; i > -1; i += -1) {\n",
       "\t\tentry = reactions[i];\n",
       "\t\tif ((!(((_pyfunc_truthy(label) && ((!_pyfunc_op_equals(label, entry[0]))))) || (_pyfunc_truthy(reaction) && (reaction !== entry[1]))))) {\n",
       "\t\t\t_pymeth_pop.call(reactions, i);\n",
       "\t\t}\n",
       "\t}\n",
       "\tthis._registered_reactions_hook();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.dispose = function () {\n",
       "\tthis._dispose();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.emit = function (type, info) {\n",
       "\tvar _, err_2, ev, i, index, label, reaction, reactions, stub1_, stub2_;\n",
       "\tinfo = (info === undefined) ? null: info;\n",
       "\tinfo = ((info === null))? (({})) : (info);\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tif (label.length) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', \"The type given to emit() should not include a label.\");\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(info).slice(8,-1).toLowerCase() === 'object'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Info object (for \" + _pyfunc_repr(type) + \") must be a dict, not \" + _pyfunc_repr(info) + \"\"));\n",
       "\t}\n",
       "\tev = _pyfunc_dict(info);\n",
       "\tev.type = type;\n",
       "\tev.source = this;\n",
       "\tif ((this._Component__pending_events !== null)) {\n",
       "\t\t_pymeth_append.call(this._Component__pending_events, ev);\n",
       "\t} else {\n",
       "\t\treactions = _pymeth_get.call(this._Component__handlers, ev.type, []);\n",
       "\t\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\t\tstub2_ = reactions[i];\n",
       "\t\t\tlabel = stub2_[0];reaction = stub2_[1];\n",
       "\t\t\tif (_pymeth_startswith.call(label, \"reconnect_\")) {\n",
       "\t\t\t\tif ((_pyfunc_getattr(ev, \"allow_reconnect\", true) === true)) {\n",
       "\t\t\t\t\tindex = _pyfunc_int((_pymeth_split.call(label, \"_\")[_pymeth_split.call(label, \"_\").length -1]));\n",
       "\t\t\t\t\treaction.reconnect(index);\n",
       "\t\t\t\t}\n",
       "\t\t\t} else {\n",
       "\t\t\t\tloop.add_reaction_event(reaction, ev);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn ev;\n",
       "};\n",
       "\n",
       "$Component.get_event_handlers = function (type) {\n",
       "\tvar _, err_2, label, reactions, stub1_;\n",
       "\tif ((!_pyfunc_truthy(type))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"get_event_handlers() missing \\\"type\\\" argument.\"));\n",
       "\t}\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tif (label.length) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', \"The type given to get_event_handlers() should not include a label.\");\n",
       "\t}\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, []);\n",
       "\treturn (function list_comprehension (iter0) {var res = [];var h, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {h = iter0[i0];{res.push(h[1]);}}return res;}).call(this, reactions);\n",
       "};\n",
       "\n",
       "$Component.get_event_types = function () {\n",
       "\tvar types;\n",
       "\ttypes = _pyfunc_list(this._Component__handlers);\n",
       "\t_pymeth_sort.call(types, undefined, false);\n",
       "\treturn types;\n",
       "};\n",
       "\n",
       "$Component.init = function () {\n",
       "\treturn null;\n",
       "};\n",
       "var Property = function () {};\n",
       "Property.prototype._validate = function(value, name, data) {return value;};\n",
       "var AnyProp;\n",
       "AnyProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "AnyProp.prototype = Object.create(Property.prototype);\n",
       "AnyProp.prototype._base_class = Property.prototype;\n",
       "AnyProp.prototype.__name__ = \"AnyProp\";\n",
       "\n",
       "\n",
       "var BoolProp;\n",
       "BoolProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "BoolProp.prototype = Object.create(Property.prototype);\n",
       "BoolProp.prototype._base_class = Property.prototype;\n",
       "BoolProp.prototype.__name__ = \"BoolProp\";\n",
       "\n",
       "BoolProp.prototype._default = false;\n",
       "BoolProp.prototype._validate = function (value, name, data) {\n",
       "\treturn _pyfunc_bool(value);\n",
       "};\n",
       "\n",
       "\n",
       "var ColorProp;\n",
       "ColorProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ColorProp.prototype = Object.create(Property.prototype);\n",
       "ColorProp.prototype._base_class = Property.prototype;\n",
       "ColorProp.prototype.__name__ = \"ColorProp\";\n",
       "\n",
       "ColorProp.prototype._default = \"#000\";\n",
       "ColorProp.prototype._validate = function (value, name, data) {\n",
       "\tvar M, Mi, blackfactor, common_colors, d, err_2, err_3, hex, i, stub10_, stub10_c, stub10_i0, stub10_iter0, stub1_, stub2_, stub3_, stub4_, stub5_, stub5_i, stub5_i0, stub5_iter0, stub6_, stub6_i, stub6_i0, stub6_iter0, stub7_, stub7_i0, stub7_iter0, stub7_x, stub8_, stub8_i0, stub8_iter0, stub8_v, stub9_, stub9_i0, stub9_iter0, stub9_v, val, whitefactor;\n",
       "\tval = value;\n",
       "\tcommon_colors = ({k: \"#000000\", black: \"#000000\", w: \"#ffffff\", white: \"#ffffff\", r: \"#ff0000\", red: \"#ff0000\", g: \"#00ff00\", green: \"#00ff00\", lime: \"#00ff00\", b: \"#0000ff\", blue: \"#0000ff\", y: \"#ffff00\", yellow: \"#ffff00\", m: \"#ff00ff\", magenta: \"#ff00ff\", fuchsia: \"#ff00ff\", c: \"#00ffff\", cyan: \"#00ffff\", aqua: \"#00ffff\", gray: \"#808080\", grey: \"#808080\"});\n",
       "\tcommon_colors[\"\"] = \"#0000\";\n",
       "\tM = ({0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15});\n",
       "\tMi = \"0123456789abcdef\";\n",
       "\tif ((Object.prototype.toString.call(val).slice(8,-1).toLowerCase() === 'string')) {\n",
       "\t\tval = _pymeth_lower.call(val);\n",
       "\t\twhitefactor = 0.0;\n",
       "\t\tblackfactor = 0.0;\n",
       "\t\tif (_pymeth_startswith.call(val, \"darker\")) {\n",
       "\t\t\tstub1_ = [0.66, val.slice(6)];\n",
       "\t\t\tblackfactor = stub1_[0];val = stub1_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"dark\")) {\n",
       "\t\t\tstub2_ = [0.33, val.slice(4)];\n",
       "\t\t\tblackfactor = stub2_[0];val = stub2_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"lighter\")) {\n",
       "\t\t\tstub3_ = [0.66, val.slice(7)];\n",
       "\t\t\twhitefactor = stub3_[0];val = stub3_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"light\")) {\n",
       "\t\t\tstub4_ = [0.33, val.slice(5)];\n",
       "\t\t\twhitefactor = stub4_[0];val = stub4_[1];\n",
       "\t\t}\n",
       "\t\tval = _pymeth_get.call(common_colors, val, val);\n",
       "\t\tif ((((_pymeth_startswith.call(val, \"#\") && (val.length == 4))) || (val.length == 5))) {\n",
       "\t\t\tstub5_ = [];stub5_iter0 = _pyfunc_range(1, val.length, 1);if ((typeof stub5_iter0 === \"object\") && (!Array.isArray(stub5_iter0))) {stub5_iter0 = Object.keys(stub5_iter0);}for (stub5_i0=0; stub5_i0<stub5_iter0.length; stub5_i0++) {stub5_i = stub5_iter0[stub5_i0];{stub5_.push(_pyfunc_op_mult(_pymeth_get.call(M, val[stub5_i], 0), 17));}}\n",
       "\t\t\tval = stub5_;\n",
       "\t\t} else if ((((_pymeth_startswith.call(val, \"#\") && (val.length == 7))) || (val.length == 9))) {\n",
       "\t\t\tstub6_ = [];stub6_iter0 = _pyfunc_range(1, val.length, 2);if ((typeof stub6_iter0 === \"object\") && (!Array.isArray(stub6_iter0))) {stub6_iter0 = Object.keys(stub6_iter0);}for (stub6_i0=0; stub6_i0<stub6_iter0.length; stub6_i0++) {stub6_i = stub6_iter0[stub6_i0];{stub6_.push(_pyfunc_op_add((_pyfunc_op_mult(_pymeth_get.call(M, val[stub6_i], 0), 16)), _pymeth_get.call(M, val[stub6_i + 1], 0)));}}\n",
       "\t\t\tval = stub6_;\n",
       "\t\t} else if (_pyfunc_truthy(_pymeth_startswith.call(val, \"rgb(\") || _pymeth_startswith.call(val, \"rgba(\"))) {\n",
       "\t\t\tstub7_ = [];stub7_iter0 = _pymeth_split.call(val.slice(4,-1), \",\");if ((typeof stub7_iter0 === \"object\") && (!Array.isArray(stub7_iter0))) {stub7_iter0 = Object.keys(stub7_iter0);}for (stub7_i0=0; stub7_i0<stub7_iter0.length; stub7_i0++) {stub7_x = stub7_iter0[stub7_i0];{stub7_.push(_pyfunc_float((_pymeth_strip.call(stub7_x, \" ,();\"))));}}\n",
       "\t\t\tval = stub7_;\n",
       "\t\t\tif ((val.length == 4)) {\n",
       "\t\t\t\tval[val.length -1] = _pyfunc_op_mult(val[val.length -1], 255);\n",
       "\t\t\t}\n",
       "\t\t} else {\n",
       "\t\t\tthrow _pyfunc_op_error('ValueError', (\"ColorProp \" + _pyfunc_repr(name) + \" got invalid color: \" + _pyfunc_repr(value) + \"\"));\n",
       "\t\t}\n",
       "\t\tstub8_ = [];stub8_iter0 = val;if ((typeof stub8_iter0 === \"object\") && (!Array.isArray(stub8_iter0))) {stub8_iter0 = Object.keys(stub8_iter0);}for (stub8_i0=0; stub8_i0<stub8_iter0.length; stub8_i0++) {stub8_v = stub8_iter0[stub8_i0];{stub8_.push(stub8_v / 255);}}\n",
       "\t\tval = stub8_;\n",
       "\t\tfor (i = 0; i < 3; i += 1) {\n",
       "\t\t\tval[i] = _pyfunc_op_add((_pyfunc_op_mult((1.0 - whitefactor), val[i])), whitefactor);\n",
       "\t\t\tval[i] = (_pyfunc_op_mult((1.0 - blackfactor), val[i])) + 0;\n",
       "\t\t}\n",
       "\t}\n",
       "\tif ((val === null)) {\n",
       "\t\tval = [0, 0, 0, 0];\n",
       "\t} else if ((((Object.prototype.toString.call(val).slice(8,-1).toLowerCase() === 'object')) && _pyfunc_op_contains(\"t\", val))) {\n",
       "\t\tval = val[\"t\"];\n",
       "\t}\n",
       "\tif ((!Array.isArray(val))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"ColorProp \" + _pyfunc_repr(name) + \" value must be str or tuple.\"));\n",
       "\t}\n",
       "\tstub9_ = [];stub9_iter0 = val;if ((typeof stub9_iter0 === \"object\") && (!Array.isArray(stub9_iter0))) {stub9_iter0 = Object.keys(stub9_iter0);}for (stub9_i0=0; stub9_i0<stub9_iter0.length; stub9_i0++) {stub9_v = stub9_iter0[stub9_i0];{stub9_.push(Math.max((Math.min(_pyfunc_float(stub9_v), 1.0)), 0.0));}}\n",
       "\tval = stub9_;\n",
       "\tif ((val.length == 3)) {\n",
       "\t\tval = _pyfunc_op_add(val, [1.0]);\n",
       "\t} else if (_pyfunc_truthy(val.length != 4)) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', (\"ColorProp \" + _pyfunc_repr(name) + \" value must have 3 or 4 elements, not \" + val.length + \"\"));\n",
       "\t}\n",
       "\tval = _pyfunc_list(val);\n",
       "\t{ /* if this_is_js() */\n",
       "\tval.push = undefined;\n",
       "\tval.splice = undefined;\n",
       "\tval.push = undefined;\n",
       "\tval.reverse = undefined;\n",
       "\tval.sort = undefined;\n",
       "\t}\n",
       "\t{ /* if this_is_js() */\n",
       "\td = ({});\n",
       "\t}\n",
       "\td.t = val;\n",
       "\td.alpha = val[3];\n",
       "\tstub10_ = [];stub10_iter0 = val.slice(0,3);if ((typeof stub10_iter0 === \"object\") && (!Array.isArray(stub10_iter0))) {stub10_iter0 = Object.keys(stub10_iter0);}for (stub10_i0=0; stub10_i0<stub10_iter0.length; stub10_i0++) {stub10_c = stub10_iter0[stub10_i0];{stub10_.push(_pyfunc_int(_pyfunc_op_mult(stub10_c, 255)));}}\n",
       "\thex = stub10_;\n",
       "\td.hex = \"#\" + (_pymeth_join.call(\"\", ((function list_comprehension (iter0) {var res = [];var c, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {c = iter0[i0];{res.push(_pyfunc_op_add(Mi[_pyfunc_int((c / 16))], Mi[c % 16]));}}return res;}).call(this, hex))));\n",
       "\td.css = \"rgba(\" + _pyfunc_op_mult(val[0], 255) + \",\" + _pyfunc_op_mult(val[1], 255) + \",\" + _pyfunc_op_mult(val[2], 255) + \",\" + val[3] + \")\";\n",
       "\treturn d;\n",
       "};\n",
       "\n",
       "\n",
       "var ComponentProp;\n",
       "ComponentProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ComponentProp.prototype = Object.create(Property.prototype);\n",
       "ComponentProp.prototype._base_class = Property.prototype;\n",
       "ComponentProp.prototype.__name__ = \"ComponentProp\";\n",
       "\n",
       "ComponentProp.prototype._default = null;\n",
       "ComponentProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!((value === null) || _pyfunc_hasattr(value, \"_IS_COMPONENT\")))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Component property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var DictProp;\n",
       "DictProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "DictProp.prototype = Object.create(Property.prototype);\n",
       "DictProp.prototype._base_class = Property.prototype;\n",
       "DictProp.prototype.__name__ = \"DictProp\";\n",
       "\n",
       "DictProp.prototype._default = ({});\n",
       "DictProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'object'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Dict property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn _pymeth_copy.call(value);\n",
       "};\n",
       "\n",
       "\n",
       "var EnumProp;\n",
       "EnumProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "EnumProp.prototype = Object.create(Property.prototype);\n",
       "EnumProp.prototype._base_class = Property.prototype;\n",
       "EnumProp.prototype.__name__ = \"EnumProp\";\n",
       "\n",
       "EnumProp.prototype._default = \"\";\n",
       "EnumProp.prototype._consume_args = function (options) {\n",
       "\tvar args, err_2;\n",
       "\targs = Array.prototype.slice.call(arguments, 1);\n",
       "\tif ((!Array.isArray(options))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"EnumProp needs list of options\");\n",
       "\t}\n",
       "\tif ((!(_pyfunc_all(((function list_comprehension (iter0) {var res = [];var i, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {i = iter0[i0];{res.push(Object.prototype.toString.call(i).slice(8,-1).toLowerCase() === 'string');}}return res;}).call(this, options)))))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"EnumProp options must be str\");\n",
       "\t}\n",
       "\tif ((!_pyfunc_truthy(args))) {\n",
       "\t\targs = [options[0]];\n",
       "\t}\n",
       "\tthis._set_data((function list_comprehension (iter0) {var res = [];var option, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {option = iter0[i0];{res.push(_pymeth_upper.call(option));}}return res;}).call(this, options));\n",
       "\tEnumProp.prototype._base_class._consume_args.apply(this, args);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "EnumProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"EnumProp \" + _pyfunc_repr(name) + \" value must be str.\"));\n",
       "\t}\n",
       "\tvalue = _pymeth_upper.call(value);\n",
       "\tif ((!_pyfunc_op_contains(_pymeth_upper.call(value), data))) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', (\"Invalid value for enum \" + _pyfunc_repr(name) + \": \" + value + \"\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var FloatPairProp;\n",
       "FloatPairProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "FloatPairProp.prototype = Object.create(Property.prototype);\n",
       "FloatPairProp.prototype._base_class = Property.prototype;\n",
       "FloatPairProp.prototype.__name__ = \"FloatPairProp\";\n",
       "\n",
       "FloatPairProp.prototype._default = [0.0, 0.0];\n",
       "FloatPairProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tvalue = [value, value];\n",
       "\t}\n",
       "\tif (_pyfunc_truthy(value.length != 2)) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair property \" + _pyfunc_repr(name) + \" needs a scalar or two values, not \" + value.length + \"\"));\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(value[0]).slice(8,-1).toLowerCase() === 'number'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair \" + _pyfunc_repr(name) + \" 1st value cannot be \" + _pyfunc_repr(value[0]) + \".\"));\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(value[1]).slice(8,-1).toLowerCase() === 'number'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair \" + _pyfunc_repr(name) + \" 2nd value cannot be \" + _pyfunc_repr(value[1]) + \".\"));\n",
       "\t}\n",
       "\tvalue = [_pyfunc_float(value[0]), _pyfunc_float(value[1])];\n",
       "\t{ /* if this_is_js() */\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.splice = undefined;\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.reverse = undefined;\n",
       "\tvalue.sort = undefined;\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var FloatProp;\n",
       "FloatProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "FloatProp.prototype = Object.create(Property.prototype);\n",
       "FloatProp.prototype._base_class = Property.prototype;\n",
       "FloatProp.prototype.__name__ = \"FloatProp\";\n",
       "\n",
       "FloatProp.prototype._default = 0.0;\n",
       "FloatProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'number')) || (Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\treturn _pyfunc_float(value);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Float property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "\n",
       "var IntProp;\n",
       "IntProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "IntProp.prototype = Object.create(Property.prototype);\n",
       "IntProp.prototype._base_class = Property.prototype;\n",
       "IntProp.prototype.__name__ = \"IntProp\";\n",
       "\n",
       "IntProp.prototype._default = 0;\n",
       "IntProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'number')) || ((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'boolean')) || (Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\treturn _pyfunc_int(value);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Int property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "\n",
       "var ListProp;\n",
       "ListProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ListProp.prototype = Object.create(Property.prototype);\n",
       "ListProp.prototype._base_class = Property.prototype;\n",
       "ListProp.prototype.__name__ = \"ListProp\";\n",
       "\n",
       "ListProp.prototype._default = [];\n",
       "ListProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"List property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn _pyfunc_list(value);\n",
       "};\n",
       "\n",
       "\n",
       "var StringProp;\n",
       "StringProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "StringProp.prototype = Object.create(Property.prototype);\n",
       "StringProp.prototype._base_class = Property.prototype;\n",
       "StringProp.prototype.__name__ = \"StringProp\";\n",
       "\n",
       "StringProp.prototype._default = \"\";\n",
       "StringProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"String property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var TriStateProp;\n",
       "TriStateProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "TriStateProp.prototype = Object.create(Property.prototype);\n",
       "TriStateProp.prototype._base_class = Property.prototype;\n",
       "TriStateProp.prototype.__name__ = \"TriStateProp\";\n",
       "\n",
       "TriStateProp.prototype._default = null;\n",
       "TriStateProp.prototype._validate = function (value, name, data) {\n",
       "\tif ((value === null)) {\n",
       "\t\treturn null;\n",
       "\t}\n",
       "\treturn _pyfunc_bool(value);\n",
       "};\n",
       "\n",
       "\n",
       "var TupleProp;\n",
       "TupleProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "TupleProp.prototype = Object.create(Property.prototype);\n",
       "TupleProp.prototype._base_class = Property.prototype;\n",
       "TupleProp.prototype.__name__ = \"TupleProp\";\n",
       "\n",
       "TupleProp.prototype._default = [];\n",
       "TupleProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Tuple property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\tvalue = _pyfunc_list(value);\n",
       "\t{ /* if this_is_js() */\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.splice = undefined;\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.reverse = undefined;\n",
       "\tvalue.sort = undefined;\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var event = {}; // convenience \"module emulator\"\n",
       "event.Property = Property;\n",
       "event.AnyProp = AnyProp;\n",
       "event.BoolProp = BoolProp;\n",
       "event.ColorProp = ColorProp;\n",
       "event.ComponentProp = ComponentProp;\n",
       "event.DictProp = DictProp;\n",
       "event.EnumProp = EnumProp;\n",
       "event.FloatPairProp = FloatPairProp;\n",
       "event.FloatProp = FloatProp;\n",
       "event.IntProp = IntProp;\n",
       "event.ListProp = ListProp;\n",
       "event.StringProp = StringProp;\n",
       "event.TriStateProp = TriStateProp;\n",
       "event.TupleProp = TupleProp;\n",
       "\n",
       "return {Component: Component, loop: loop, logger: logger, Property: Property, AnyProp: AnyProp, BoolProp: BoolProp, TriStateProp: TriStateProp, IntProp: IntProp, FloatProp: FloatProp, StringProp: StringProp, TupleProp: TupleProp, ListProp: ListProp, DictProp: DictProp, ComponentProp: ComponentProp, FloatPairProp: FloatPairProp, EnumProp: EnumProp, ColorProp: ColorProp};\n",
       "});\n",
       "\n",
       "\n",
       "/* ======================= flexx.app._clientcore ========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "\n",
       "\n",
       "flexx.define(\"flexx.app._clientcore\", [\"pscript-std.js\"], function (_py) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_range = _py._pyfunc_range, _pyfunc_reversed = _py._pyfunc_reversed, _pyfunc_str = _py._pyfunc_str, _pyfunc_time = _py._pyfunc_time, _pyfunc_truthy = _py._pyfunc_truthy;\n",
       "\n",
       "var _pymeth_count = _py._pymeth_count, _pymeth_get = _py._pymeth_get, _pymeth_join = _py._pymeth_join, _pymeth_pop = _py._pymeth_pop, _pymeth_replace = _py._pymeth_replace, _pymeth_split = _py._pymeth_split, _pymeth_splitlines = _py._pymeth_splitlines;\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "var Flexx, JsSession, __pscript__, bsdf, serializer;\n",
       "\"\\nThe client's core Flexx engine, implemented in PScript.\\n\";\n",
       "__pscript__ = true;\n",
       "Flexx = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "Flexx.prototype._base_class = Object;\n",
       "Flexx.prototype.__name__ = \"Flexx\";\n",
       "\n",
       "Flexx.prototype.__init__ = function () {\n",
       "    var err_2, key, stub1_seq;\n",
       "    if (_pyfunc_truthy(window.flexx.init)) {\n",
       "        throw _pyfunc_op_error('RuntimeError', \"Should not create global Flexx object more than once.\");\n",
       "    }\n",
       "    this.is_notebook = false;\n",
       "    this.is_exported = false;\n",
       "    stub1_seq = window.flexx;\n",
       "    for (key in stub1_seq) {\n",
       "        if (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "        this[key] = window.flexx[key];\n",
       "    }\n",
       "    this.need_main_widget = true;\n",
       "    this._session_count = 0;\n",
       "    this.sessions = ({});\n",
       "    window.addEventListener(\"load\", this.init, false);\n",
       "    window.addEventListener(\"unload\", this.exit, false);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.init = function () {\n",
       "    this.asset_node = window.document.createElement(\"div\");\n",
       "    this.asset_node.id = \"Flexx asset container\";\n",
       "    window.document.body.appendChild(this.asset_node);\n",
       "    if (_pyfunc_truthy(this.is_exported)) {\n",
       "        if (_pyfunc_truthy(this.is_notebook)) {\n",
       "            console.log(\"Flexx: I am in an exported notebook!\");\n",
       "        } else {\n",
       "            console.log(\"Flexx: I am in an exported app!\");\n",
       "            this.run_exported_app();\n",
       "        }\n",
       "    } else {\n",
       "        console.log(\"Flexx: Initializing\");\n",
       "        if ((!_pyfunc_truthy(this.is_notebook))) {\n",
       "            this._remove_querystring();\n",
       "        }\n",
       "        this.init_logging();\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype._remove_querystring = function () {\n",
       "    try {\n",
       "        window.history.replaceState(window.history.state, \"\", window.location.pathname);\n",
       "    } catch(err_2) {\n",
       "        {\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.exit = function () {\n",
       "    var session, stub2_seq;\n",
       "    stub2_seq = this.sessions;\n",
       "    for (session in stub2_seq) {\n",
       "        if (!stub2_seq.hasOwnProperty(session)){ continue; }\n",
       "        session = stub2_seq[session];\n",
       "        session.exit();\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.spin = function (n) {\n",
       "    n = (n === undefined) ? 1: n;\n",
       "    if (!window.document.body) {return;}\n",
       "    var el = window.document.body.children[0];\n",
       "    if (el && el.classList.contains(\"flx-spinner\")) {\n",
       "        if (n === null) {\n",
       "            el.style.display = 'none';  // Stop the spinner\n",
       "        } else {\n",
       "            el.children[0].innerHTML += '&#9632'.repeat(n);\n",
       "        }\n",
       "    };\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.init_logging = function () {\n",
       "    var error, info, log, on_error, warn;\n",
       "    if (_pyfunc_truthy(window.console.ori_log)) {\n",
       "        return null;\n",
       "    }\n",
       "    window.console.ori_log = window.console.log;\n",
       "    window.console.ori_info = _pyfunc_truthy(window.console.info) || window.console.log;\n",
       "    window.console.ori_warn = _pyfunc_truthy(window.console.warn) || window.console.log;\n",
       "    window.console.ori_error = _pyfunc_truthy(window.console.error) || window.console.log;\n",
       "    log = (function flx_log (msg) {\n",
       "        var session, stub3_seq;\n",
       "        window.console.ori_log(msg);\n",
       "        stub3_seq = this.sessions;\n",
       "        for (session in stub3_seq) {\n",
       "            if (!stub3_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub3_seq[session];\n",
       "            session.send_command(\"PRINT\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    info = (function flx_info (msg) {\n",
       "        var session, stub4_seq;\n",
       "        window.console.ori_info(msg);\n",
       "        stub4_seq = this.sessions;\n",
       "        for (session in stub4_seq) {\n",
       "            if (!stub4_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub4_seq[session];\n",
       "            session.send_command(\"INFO\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    warn = (function flx_warn (msg) {\n",
       "        var session, stub5_seq;\n",
       "        window.console.ori_warn(msg);\n",
       "        stub5_seq = this.sessions;\n",
       "        for (session in stub5_seq) {\n",
       "            if (!stub5_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub5_seq[session];\n",
       "            session.send_command(\"WARN\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    error = (function flx_error (msg) {\n",
       "        var evt;\n",
       "        evt = {message:_pyfunc_str(msg), error:msg, preventDefault:((function () {return null;}).bind(this))};\n",
       "        on_error(evt);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_error = (function flx_on_error (evt) {\n",
       "        this._handle_error(evt);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_error = on_error.bind(this);\n",
       "    window.console.log = log;\n",
       "    window.console.info = info;\n",
       "    window.console.warn = warn;\n",
       "    window.console.error = error;\n",
       "    window.addEventListener(\"error\", on_error, false);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.create_session = function (app_name, session_id, ws_url) {\n",
       "    var s;\n",
       "    s = new JsSession(app_name, session_id, ws_url);\n",
       "    this._session_count = _pyfunc_op_add(this._session_count, 1);\n",
       "    this[\"s\" + this._session_count] = s;\n",
       "    this.sessions[session_id] = s;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype._handle_error = function (evt) {\n",
       "    var i, msg, session, session_needle, short, stack, stub10_seq, stub11_itr, stub12_seq, stub13_itr, stub14_seq, stub6_seq, stub7_itr, stub8_seq, stub9_itr, x;\n",
       "    msg = short = evt.message;\n",
       "    if ((!_pyfunc_truthy(window.evt))) {\n",
       "        window.evt = evt;\n",
       "    }\n",
       "    if ((_pyfunc_truthy(evt.error) && _pyfunc_truthy(evt.error.stack))) {\n",
       "        stack = _pymeth_splitlines.call(evt.error.stack);\n",
       "        session_needle = \"?session_id=\" + this.id;\n",
       "        for (i = 0; i < stack.length; i += 1) {\n",
       "            stack[i] = _pymeth_replace.call(_pymeth_replace.call(stack[i], \"@\", \" @ \"), session_needle, \"\");\n",
       "        }\n",
       "        stub6_seq = [evt.message, \"_pyfunc_op_error\"];\n",
       "        if ((typeof stub6_seq === \"object\") && (!Array.isArray(stub6_seq))) { stub6_seq = Object.keys(stub6_seq);}\n",
       "        for (stub7_itr = 0; stub7_itr < stub6_seq.length; stub7_itr += 1) {\n",
       "            x = stub6_seq[stub7_itr];\n",
       "            if (_pyfunc_op_contains(x, stack[0])) {\n",
       "                _pymeth_pop.call(stack, 0);\n",
       "            }\n",
       "        }\n",
       "        for (i = 0; i < stack.length; i += 1) {\n",
       "            stub8_seq = [\"_process_actions\", \"_process_reactions\", \"_process_calls\"];\n",
       "            if ((typeof stub8_seq === \"object\") && (!Array.isArray(stub8_seq))) { stub8_seq = Object.keys(stub8_seq);}\n",
       "            for (stub9_itr = 0; stub9_itr < stub8_seq.length; stub9_itr += 1) {\n",
       "                x = stub8_seq[stub9_itr];\n",
       "                if ((_pyfunc_op_contains((\"Loop.\" + x), stack[i]))) {\n",
       "                    stack = stack.slice(0,i);\n",
       "                    break;\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        stub12_seq = _pyfunc_reversed(_pyfunc_range(0, stack.length, 1));\n",
       "        if ((typeof stub12_seq === \"object\") && (!Array.isArray(stub12_seq))) { stub12_seq = Object.keys(stub12_seq);}\n",
       "        for (stub13_itr = 0; stub13_itr < stub12_seq.length; stub13_itr += 1) {\n",
       "            i = stub12_seq[stub13_itr];\n",
       "            stub10_seq = [\"flx_action \"];\n",
       "            if ((typeof stub10_seq === \"object\") && (!Array.isArray(stub10_seq))) { stub10_seq = Object.keys(stub10_seq);}\n",
       "            for (stub11_itr = 0; stub11_itr < stub10_seq.length; stub11_itr += 1) {\n",
       "                x = stub10_seq[stub11_itr];\n",
       "                if ((_pyfunc_truthy(stack[i]) && _pymeth_count.call(stack[i], x))) {\n",
       "                    _pymeth_pop.call(stack, i);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        msg = _pyfunc_op_add(msg, \"\\n\" + _pymeth_join.call(\"\\n\", stack));\n",
       "    } else if ((_pyfunc_truthy(evt.message) && _pyfunc_truthy(evt.lineno))) {\n",
       "        msg = _pyfunc_op_add(msg, \"\\nIn \" + evt.filename + \":\" + evt.lineno + \"\");\n",
       "    }\n",
       "    evt.preventDefault();\n",
       "    window.console.ori_error(msg);\n",
       "    stub14_seq = this.sessions;\n",
       "    for (session in stub14_seq) {\n",
       "        if (!stub14_seq.hasOwnProperty(session)){ continue; }\n",
       "        session = stub14_seq[session];\n",
       "        session.send_command(\"ERROR\", short);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "JsSession = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "JsSession.prototype._base_class = Object;\n",
       "JsSession.prototype.__name__ = \"JsSession\";\n",
       "\n",
       "JsSession.prototype.__init__ = function (app_name, id, ws_url) {\n",
       "    var config, err, jconfig;\n",
       "    ws_url = (ws_url === undefined) ? null: ws_url;\n",
       "    this.app = null;\n",
       "    this.app_name = app_name;\n",
       "    this.id = id;\n",
       "    this.status = 1;\n",
       "    this.ws_url = ws_url;\n",
       "    this._component_counter = 0;\n",
       "    this._disposed_ob = ({_disposed: true});\n",
       "    if ((!_pyfunc_truthy(this.id))) {\n",
       "        jconfig = window.document.getElementById(\"jupyter-config-data\");\n",
       "        if (_pyfunc_truthy(jconfig)) {\n",
       "            try {\n",
       "                config = JSON.parse(jconfig.innerText);\n",
       "                this.id = config.flexx_session_id;\n",
       "                this.app_name = config.flexx_app_name;\n",
       "            } catch(err_4) {\n",
       "                {\n",
       "                    err = err_4;\n",
       "                    console.log(err);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    this._init_time = _pyfunc_time();\n",
       "    this._pending_commands = [];\n",
       "    this._asset_count = 0;\n",
       "    this._ws = null;\n",
       "    this.last_msg = null;\n",
       "    this.instances = ({});\n",
       "    this.instances_to_check_size = ({});\n",
       "    if ((!_pyfunc_truthy(window.flexx.is_exported))) {\n",
       "        this.init_socket();\n",
       "    }\n",
       "    window.addEventListener(\"resize\", this._check_size_of_objects, false);\n",
       "    window.setInterval(this._check_size_of_objects, 1000);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.exit = function () {\n",
       "    if (_pyfunc_truthy(this._ws)) {\n",
       "        this._ws.close();\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.send_command = function () {\n",
       "    var bb, command, err;\n",
       "    command = Array.prototype.slice.call(arguments);\n",
       "    if ((this._ws !== null)) {\n",
       "        try {\n",
       "            bb = serializer.encode(command);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                console.log(\"Command that failed to encode:\");\n",
       "                console.log(command);\n",
       "                throw err;\n",
       "            }\n",
       "        }\n",
       "        this._ws.send(bb);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.instantiate_component = function (module, cname, id, args, kwargs, active_components) {\n",
       "    var Cls, ac, c, m, stub15_seq, stub16_itr, stub17_seq, stub18_itr;\n",
       "    c = _pymeth_get.call(this.instances, id, null);\n",
       "    if (((c !== null) && (c._disposed === false))) {\n",
       "        return c;\n",
       "    }\n",
       "    m = window.flexx.require(module);\n",
       "    Cls = m[cname];\n",
       "    kwargs[\"flx_session\"] = this;\n",
       "    kwargs[\"flx_id\"] = id;\n",
       "    active_components = _pyfunc_truthy(active_components) || [];\n",
       "    stub15_seq = active_components;\n",
       "    if ((typeof stub15_seq === \"object\") && (!Array.isArray(stub15_seq))) { stub15_seq = Object.keys(stub15_seq);}\n",
       "    for (stub16_itr = 0; stub16_itr < stub15_seq.length; stub16_itr += 1) {\n",
       "        ac = stub15_seq[stub16_itr];\n",
       "        ac.__enter__();\n",
       "    }\n",
       "    try {\n",
       "        c = new Cls({flx_args: args, flx_kwargs: kwargs});\n",
       "    } finally {\n",
       "        stub17_seq = _pyfunc_reversed(active_components);\n",
       "        if ((typeof stub17_seq === \"object\") && (!Array.isArray(stub17_seq))) { stub17_seq = Object.keys(stub17_seq);}\n",
       "        for (stub18_itr = 0; stub18_itr < stub17_seq.length; stub18_itr += 1) {\n",
       "            ac = stub17_seq[stub18_itr];\n",
       "            ac.__exit__();\n",
       "        }\n",
       "    }\n",
       "    return c;\n",
       "};\n",
       "\n",
       "JsSession.prototype._register_component = function (c, id) {\n",
       "    id = (id === undefined) ? null: id;\n",
       "    if ((this.app === null)) {\n",
       "        this.app = c;\n",
       "    }\n",
       "    if ((id === null)) {\n",
       "        this._component_counter = _pyfunc_op_add(this._component_counter, 1);\n",
       "        id = (_pyfunc_op_add((c.__name__ + \"_\"), _pyfunc_str(this._component_counter))) + \"js\";\n",
       "    }\n",
       "    c._id = id;\n",
       "    c._uid = _pyfunc_op_add((this.id + \"_\"), id);\n",
       "    this.instances[c._id] = c;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._unregister_component = function (c) {\n",
       "    _pymeth_pop.call(this.instances_to_check_size, c.id, null);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.get_component_instance = function (id) {\n",
       "    if (_pyfunc_op_equals(id, \"body\")) {\n",
       "        return window.document.body;\n",
       "    } else {\n",
       "        return _pymeth_get.call(this.instances, id, null);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.init_socket = function () {\n",
       "    var WebSocket, address, err_2, on_ws_close, on_ws_error, on_ws_message, on_ws_open, proto, ws;\n",
       "    WebSocket = window.WebSocket;\n",
       "    if ((WebSocket === undefined)) {\n",
       "        window.document.body.textContent = \"Browser does not support WebSockets\";\n",
       "        throw \"FAIL: need websocket\";\n",
       "    }\n",
       "    if ((!_pyfunc_truthy(this.ws_url))) {\n",
       "        proto = \"ws\";\n",
       "        if (_pyfunc_op_equals(window.location.protocol, \"https:\")) {\n",
       "            proto = \"wss\";\n",
       "        }\n",
       "        address = window.location.hostname;\n",
       "        if (_pyfunc_truthy(window.location.port)) {\n",
       "            address = _pyfunc_op_add(address, \":\" + window.location.port);\n",
       "        }\n",
       "        this.ws_url = \"\" + proto + \"://\" + address + \"/flexx/ws/\" + this.app_name + \"\";\n",
       "    }\n",
       "    this.ws_url = _pymeth_replace.call(this.ws_url, \"0.0.0.0\", window.location.hostname);\n",
       "    this._ws = ws = new WebSocket(this.ws_url);\n",
       "    ws.binaryType = \"arraybuffer\";\n",
       "    this.status = 2;\n",
       "    on_ws_open = (function flx_on_ws_open (evt) {\n",
       "        window.console.info(\"Socket opened with session id \" + this.id);\n",
       "        this.send_command(\"HI_FLEXX\", this.id);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_message = (function flx_on_ws_message (evt) {\n",
       "        var msg;\n",
       "        msg = _pyfunc_truthy(evt.data) || evt;\n",
       "        if ((this._pending_commands === null)) {\n",
       "            this._receive_raw_command(msg);\n",
       "        } else {\n",
       "            if ((this._pending_commands.length == 0)) {\n",
       "                window.setTimeout(this._process_commands, 0);\n",
       "            }\n",
       "            this._pending_commands.push(msg);\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_close = (function flx_on_ws_close (evt) {\n",
       "        var msg;\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "        msg = \"Lost connection with server\";\n",
       "        if ((_pyfunc_truthy(evt) && _pyfunc_truthy(evt.reason))) {\n",
       "            msg = _pyfunc_op_add(msg, \": \" + evt.reason + \" (\" + evt.code + \")\");\n",
       "        }\n",
       "        if ((!_pyfunc_truthy(window.flexx.is_notebook))) {\n",
       "            window.document.body.textContent = msg;\n",
       "        } else {\n",
       "            window.console.info(msg);\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_error = function (evt) {\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "        window.console.error(\"Socket error\");\n",
       "        return null;\n",
       "    };\n",
       "\n",
       "    ws.onopen = on_ws_open;\n",
       "    ws.onmessage = on_ws_message;\n",
       "    ws.onclose = on_ws_close;\n",
       "    ws.onerror = on_ws_error;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._process_commands = function () {\n",
       "    var command, err, msg;\n",
       "    while ((this._pending_commands !== null) && (this._pending_commands.length > 0)) {\n",
       "        msg = _pymeth_pop.call(this._pending_commands, 0);\n",
       "        try {\n",
       "            command = this._receive_raw_command(msg);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                window.setTimeout(this._process_commands, 0);\n",
       "                throw err;\n",
       "            }\n",
       "        }\n",
       "        if (_pyfunc_op_equals(command[0], \"DEFINE\")) {\n",
       "            this._asset_count = _pyfunc_op_add(this._asset_count, 1);\n",
       "            if ((_pyfunc_op_equals((this._asset_count % 3), 0))) {\n",
       "                if (this._pending_commands.length) {\n",
       "                    window.setTimeout(this._process_commands, 0);\n",
       "                }\n",
       "                break;\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_raw_command = function (msg) {\n",
       "    return this._receive_command(serializer.decode(msg));\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_command = function (command) {\n",
       "    var address, args, c, cmd, code, el, id, kind, name, ob, stub19_, stub20_, x;\n",
       "    cmd = command[0];\n",
       "    if (_pyfunc_op_equals(cmd, \"PING\")) {\n",
       "        window.setTimeout(this.send_command, 10, \"PONG\", command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INIT_DONE\")) {\n",
       "        window.flexx.spin(null);\n",
       "        while (this._pending_commands.length) {\n",
       "            this._receive_raw_command(_pymeth_pop.call(this._pending_commands, 0));\n",
       "        }\n",
       "        this._pending_commands = null;\n",
       "    } else if (_pyfunc_op_equals(cmd, \"PRINT\")) {\n",
       "        (_pyfunc_truthy(window.console.ori_log) || window.console.log)(command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"EXEC\")) {\n",
       "        eval(command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"EVAL\")) {\n",
       "        x = null;\n",
       "        if ((command.length == 2)) {\n",
       "            x = eval(command[1]);\n",
       "        } else if ((command.length == 3)) {\n",
       "            x = eval(_pyfunc_op_add(((\"this.instances.\" + command[1]) + \".\"), command[2]));\n",
       "        }\n",
       "        console.log(_pyfunc_str(x));\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INVOKE\")) {\n",
       "        stub19_ = command.slice(1);\n",
       "        id = stub19_[0];name = stub19_[1];args = stub19_[2];\n",
       "        ob = _pymeth_get.call(this.instances, id, null);\n",
       "        if ((ob === null)) {\n",
       "            console.warn(\"Cannot invoke \" + id + \".\" + name + \"; session does not know it (anymore).\");\n",
       "        } else if ((ob._disposed === true)) {\n",
       "        } else {\n",
       "            ob[name].apply(ob, args);\n",
       "        }\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INSTANTIATE\")) {\n",
       "        this.instantiate_component.apply(this, command.slice(1));\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DISPOSE\")) {\n",
       "        id = command[1];\n",
       "        c = _pymeth_get.call(this.instances, id, null);\n",
       "        if (((c !== null) && (c._disposed === false))) {\n",
       "            c._dispose();\n",
       "        }\n",
       "        this.send_command(\"DISPOSE_ACK\", command[1]);\n",
       "        _pymeth_pop.call(this.instances, id, null);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DISPOSE_ACK\")) {\n",
       "        _pymeth_pop.call(this.instances, command[1], null);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DEFINE\")) {\n",
       "        stub20_ = command.slice(1);\n",
       "        kind = stub20_[0];name = stub20_[1];code = stub20_[2];\n",
       "        window.flexx.spin();\n",
       "        address = _pyfunc_op_add((window.location.protocol + \"//\"), (_pymeth_split.call(this.ws_url, \"/\")[2]));\n",
       "        code = _pyfunc_op_add(code, \"\\n//# sourceURL=\" + address + \"/flexx/assets/shared/\" + name + \"\\n\");\n",
       "        if (_pyfunc_op_equals(kind, \"JS-EVAL\")) {\n",
       "            eval(code);\n",
       "        } else if (_pyfunc_op_equals(kind, \"JS\")) {\n",
       "            el = window.document.createElement(\"script\");\n",
       "            el.id = name;\n",
       "            el.innerHTML = code;\n",
       "            window.flexx.asset_node.appendChild(el);\n",
       "        } else if (_pyfunc_op_equals(kind, \"CSS\")) {\n",
       "            el = window.document.createElement(\"style\");\n",
       "            el.type = \"text/css\";\n",
       "            el.id = name;\n",
       "            el.innerHTML = code;\n",
       "            window.flexx.asset_node.appendChild(el);\n",
       "        } else {\n",
       "            window.console.error((_pyfunc_op_add(((\"Dont know how to DEFINE \" + name) + (\" with \\\"\")), kind)) + (\"\\\".\"));\n",
       "        }\n",
       "    } else if (_pyfunc_op_equals(cmd, \"OPEN\")) {\n",
       "        window.win1 = window.open(command[1], \"new\", \"chrome\");\n",
       "    } else {\n",
       "        window.console.error(((\"Invalid command: \\\"\") + cmd) + (\"\\\"\"));\n",
       "    }\n",
       "    return command;\n",
       "};\n",
       "\n",
       "JsSession.prototype.call_after_roundtrip = function (callback) {\n",
       "    var args, ping_to_schedule_at;\n",
       "    args = Array.prototype.slice.call(arguments, 1);\n",
       "    ping_to_schedule_at = this._ping_counter + 1;\n",
       "    if (((this._ping_calls.length == 0) || ((this._ping_calls[this._ping_calls.length -1][0]) < ping_to_schedule_at))) {\n",
       "        window.setTimeout(this._send_ping, 0);\n",
       "    }\n",
       "    this._ping_calls.push([ping_to_schedule_at, callback, args]);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._send_ping = function () {\n",
       "    this._ping_counter = _pyfunc_op_add(this._ping_counter, 1);\n",
       "    this.send_command(\"PING\", this._ping_counter);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_pong = function (count) {\n",
       "    var _, args, callback, stub21_;\n",
       "    while ((this._ping_calls.length > 0) && (((this._ping_calls[0][0]) <= count))) {\n",
       "        stub21_ = _pymeth_pop.call(this._ping_calls, 0);\n",
       "        _ = stub21_[0];callback = stub21_[1];args = stub21_[2];\n",
       "        window.setTimeout.apply(window, [].concat([callback, 0], args));\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.keep_checking_size_of = function (ob, check) {\n",
       "    check = (check === undefined) ? true: check;\n",
       "    if (_pyfunc_truthy(check)) {\n",
       "        this.instances_to_check_size[ob.id] = ob;\n",
       "    } else {\n",
       "        _pymeth_pop.call(this.instances_to_check_size, ob.id, null);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._check_size_of_objects = function () {\n",
       "    var ob, stub22_seq;\n",
       "    stub22_seq = this.instances_to_check_size;\n",
       "    for (ob in stub22_seq) {\n",
       "        if (!stub22_seq.hasOwnProperty(ob)){ continue; }\n",
       "        ob = stub22_seq[ob];\n",
       "        if ((ob._disposed === false)) {\n",
       "            ob.check_real_size();\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "{ /* if this_is_js() */\n",
       "window.flexx = new Flexx();\n",
       "bsdf = flexx.require('bsdf');\n",
       "serializer = new bsdf.BsdfSerializer();\n",
       "window.flexx.serializer = serializer;\n",
       "}\n",
       "\n",
       "return {Flexx: Flexx, JsSession: JsSession, bsdf: bsdf, serializer: serializer};\n",
       "});\n",
       "\n",
       "\n",
       "/* ======================= flexx.app._component2 ========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "\n",
       "\n",
       "flexx.define(\"flexx.app._component2\", [\"pscript-std.js\", \"flexx.event.js\", \"flexx.app._clientcore\"], function (_py, event, flexx$app$_clientcore) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_getattr = _py._pyfunc_getattr, _pyfunc_hasattr = _py._pyfunc_hasattr, _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_op_parse_kwargs = _py._pyfunc_op_parse_kwargs, _pyfunc_setattr = _py._pyfunc_setattr, _pyfunc_truthy = _py._pyfunc_truthy;\n",
       "\n",
       "var _pymeth_append = _py._pymeth_append, _pymeth_get = _py._pymeth_get, _pymeth_keys = _py._pymeth_keys, _pymeth_pop = _py._pymeth_pop;\n",
       "\n",
       "var serializer = flexx$app$_clientcore.serializer;\n",
       "\n",
       "var serializer = flexx$app$_clientcore.serializer;\n",
       "\n",
       "var logger = event.logger;\n",
       "\n",
       "var loop = event.loop;\n",
       "\n",
       "var Component = event.Component;\n",
       "\n",
       "var LocalProperty = event.LocalProperty;\n",
       "\n",
       "var Property = event.Property;\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "var LocalProperty;\n",
       "LocalProperty = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "LocalProperty.prototype = Object.create(Property.prototype);\n",
       "LocalProperty.prototype._base_class = Property.prototype;\n",
       "LocalProperty.prototype.__name__ = \"LocalProperty\";\n",
       "\n",
       "\n",
       "\n",
       "var BaseAppComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "BaseAppComponent.prototype = Object.create(Component.prototype);\n",
       "BaseAppComponent.prototype._base_class = Component.prototype;\n",
       "BaseAppComponent.prototype.__name__ = \"BaseAppComponent\";\n",
       "var $BaseAppComponent = BaseAppComponent.prototype;\n",
       "\n",
       "$BaseAppComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$BaseAppComponent.__properties__ = []\n",
       "$BaseAppComponent.__actions__ = []\n",
       "$BaseAppComponent.__emitters__ = []\n",
       "$BaseAppComponent.__reactions__ = []\n",
       "\n",
       "$BaseAppComponent._comp_init_app_component = function (property_values) {\n",
       "    var active, custom_id, err_2, session;\n",
       "    _pymeth_pop.call(property_values, \"flx_is_app\", null);\n",
       "    custom_id = _pymeth_pop.call(property_values, \"flx_id\", null);\n",
       "    this._session = null;\n",
       "    session = _pymeth_pop.call(property_values, \"flx_session\", null);\n",
       "    if ((session !== null)) {\n",
       "        this._session = session;\n",
       "    } else {\n",
       "        active = loop.get_active_components();\n",
       "        active = ((active.length > 1))? (active[active.length -2]) : (null);\n",
       "        if ((active !== null)) {\n",
       "            this._session = active._session;\n",
       "        } else if ((!\"this_is_js()\")) {\n",
       "        }\n",
       "    }\n",
       "    if ((this._session === null)) {\n",
       "        throw _pyfunc_op_error('RuntimeError', (\"\" + (_pyfunc_truthy(custom_id) || this._id) + \" needs a session!\"));\n",
       "    }\n",
       "    this._session._register_component(this, custom_id);\n",
       "    this._root = this._session.app;\n",
       "    return custom_id === null;\n",
       "};\n",
       "\n",
       "\n",
       "var LocalComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "LocalComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "LocalComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "LocalComponent.prototype.__name__ = \"LocalComponent\";\n",
       "var $LocalComponent = LocalComponent.prototype;\n",
       "\n",
       "$LocalComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$LocalComponent.__properties__ = []\n",
       "$LocalComponent.__actions__ = []\n",
       "$LocalComponent.__emitters__ = []\n",
       "$LocalComponent.__reactions__ = []\n",
       "$LocalComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$LocalComponent._comp_init_property_values = function (property_values) {\n",
       "    this._LocalComponent__event_types_at_proxy = [];\n",
       "    this._comp_init_app_component(property_values);\n",
       "    this._has_proxy = _pymeth_pop.call(property_values, \"flx_has_proxy\", false);\n",
       "    (BaseAppComponent.prototype._comp_init_property_values).call(this, property_values);\n",
       "    { /* if this_is_js() */\n",
       "    this._event_listeners = [];\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._ensure_proxy_instance = function (include_props) {\n",
       "    var name, props, stub1_seq, stub2_itr;\n",
       "    include_props = (include_props === undefined) ? true: include_props;\n",
       "    if (((this._has_proxy === false) && (this._disposed === false))) {\n",
       "        if ((this._session.status > 0)) {\n",
       "            props = ({});\n",
       "            if (_pyfunc_truthy(include_props)) {\n",
       "                stub1_seq = this.__proxy_properties__;\n",
       "                if ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "                for (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "                    name = stub1_seq[stub2_itr];\n",
       "                    props[name] = _pyfunc_getattr(this, name);\n",
       "                }\n",
       "            }\n",
       "            this._session.send_command(\"INSTANTIATE\", this.__jsmodule__, Object.getPrototypeOf(this).__name__, this._id, [], props);\n",
       "            this._has_proxy = true;\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent.emit = function (type, info) {\n",
       "    var ev, isprop;\n",
       "    info = (info === undefined) ? null: info;\n",
       "    ev = (BaseAppComponent.prototype.emit).call(this, type, info);\n",
       "    isprop = _pyfunc_op_contains(type, this.__proxy_properties__);\n",
       "    if (((this._has_proxy === true) && (this._session.status > 0))) {\n",
       "        if (_pyfunc_truthy(_pyfunc_truthy(isprop) || _pyfunc_op_contains(type, this._LocalComponent__event_types_at_proxy))) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_emit_at_proxy\", [ev]);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._dispose = function () {\n",
       "    var was_disposed;\n",
       "    was_disposed = this._disposed;\n",
       "    (BaseAppComponent.prototype._dispose).call(this);\n",
       "    this._has_proxy = false;\n",
       "    if (((was_disposed === false) && (this._session !== null))) {\n",
       "        this._session._unregister_component(this);\n",
       "        if ((this._session.status > 0)) {\n",
       "            this._session.send_command(\"DISPOSE\", this._id);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._flx_set_has_proxy = function (has_proxy) {\n",
       "    this._has_proxy = has_proxy;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._flx_set_event_types_at_proxy = function (event_types) {\n",
       "    this._LocalComponent__event_types_at_proxy = event_types;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var ProxyComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ProxyComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "ProxyComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "ProxyComponent.prototype.__name__ = \"ProxyComponent\";\n",
       "var $ProxyComponent = ProxyComponent.prototype;\n",
       "\n",
       "$ProxyComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$ProxyComponent.__properties__ = []\n",
       "$ProxyComponent.__actions__ = [\"_emit_at_proxy\"]\n",
       "$ProxyComponent.__emitters__ = []\n",
       "$ProxyComponent.__reactions__ = []\n",
       "$ProxyComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$ProxyComponent.__init__ = function () {\n",
       "    var err_2, init_args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        init_args = arguments[0].flx_args;\n",
       "    } else {init_args = Array.prototype.slice.call(arguments);}\n",
       "    { /* if this_is_js() */\n",
       "    if (!(init_args.length == 0)) { throw _pyfunc_op_error('AssertionError', \"init_args.length == 0\");}\n",
       "    if ((!_pyfunc_op_contains(\"flx_id\", kwargs))) {\n",
       "        throw _pyfunc_op_error('RuntimeError', \"Cannot instantiate a PyComponent from JS.\");\n",
       "    }\n",
       "    (BaseAppComponent.prototype.__init__).call(this, {flx_args: [], flx_kwargs: kwargs});\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._comp_init_property_values = function (property_values) {\n",
       "    var local_inst, props2set;\n",
       "    local_inst = this._comp_init_app_component(property_values);\n",
       "    props2set = (_pyfunc_truthy(local_inst))? (({})) : (property_values);\n",
       "    (BaseAppComponent.prototype._comp_init_property_values).call(this, props2set);\n",
       "    { /* if this_is_js() */\n",
       "    if (!(_pyfunc_op_equals((_pymeth_keys.call(property_values).length), 0))) { throw _pyfunc_op_error('AssertionError', \"_pyfunc_op_equals((_pymeth_keys.call(property_values).length), 0)\");}\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._comp_apply_property_values = function (values) {\n",
       "    var name, stub1_seq, stub2_itr, stub3_tgt, value;\n",
       "    stub1_seq = values;\n",
       "    if ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "    for (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "        stub3_tgt = stub1_seq[stub2_itr];\n",
       "        name = stub3_tgt[0]; value = stub3_tgt[1];\n",
       "        _pyfunc_setattr(this, ((\"_\" + name) + \"_value\"), value);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._proxy_action = function (name) {\n",
       "    var args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        name = arguments[0].flx_args[0];\n",
       "        args = arguments[0].flx_args.slice(1);\n",
       "    } else {args = Array.prototype.slice.call(arguments, 1);}\n",
       "    if (!(!_pyfunc_truthy(kwargs))) { throw _pyfunc_op_error('AssertionError', \"!_pyfunc_truthy(kwargs)\");}\n",
       "    this._session.send_command(\"INVOKE\", this._id, name, args);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._proxy_emitter = function (name) {\n",
       "    var args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        name = arguments[0].flx_args[0];\n",
       "        args = arguments[0].flx_args.slice(1);\n",
       "    } else {args = Array.prototype.slice.call(arguments, 1);}\n",
       "    { /* if this_is_js() */\n",
       "    logger.error(\"Cannot use emitters of a PyComponent in JS.\");\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._mutate = function () {\n",
       "    var args, err_1, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        args = arguments[0].flx_args;\n",
       "    } else {args = Array.prototype.slice.call(arguments);}\n",
       "    throw _pyfunc_op_error('RuntimeError', \"Cannot mutate properties from a proxy class.\");\n",
       "    serializer;\n",
       "    BsdfComponentExtension;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._registered_reactions_hook = function () {\n",
       "    var event_types;\n",
       "    event_types = (BaseAppComponent.prototype._registered_reactions_hook).call(this);\n",
       "    try {\n",
       "        if (((this._disposed === false) && (this._session.status > 0))) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_flx_set_event_types_at_proxy\", [event_types]);\n",
       "        }\n",
       "    } finally {\n",
       "        return event_types;\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._emit_at_proxy = function _emit_at_proxy (ev) {\n",
       "    if ((!\"this_is_js()\")) {\n",
       "    }\n",
       "    if ((_pyfunc_op_contains(ev.type, this.__properties__) && _pyfunc_hasattr(ev, \"mutation\"))) {\n",
       "        if (_pyfunc_op_equals(ev.mutation, \"set\")) {\n",
       "            (BaseAppComponent.prototype._mutate).call(this, ev.type, ev.new_value);\n",
       "        } else {\n",
       "            (BaseAppComponent.prototype._mutate).call(this, ev.type, ev.objects, ev.mutation, ev.index);\n",
       "        }\n",
       "    } else {\n",
       "        this.emit(ev.type, ev);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "$ProxyComponent._emit_at_proxy.nobind = true;\n",
       "\n",
       "$ProxyComponent.dispose = function () {\n",
       "    var err_1;\n",
       "    { /* if this_is_js() */\n",
       "    throw _pyfunc_op_error('RuntimeError', \"Cannot dispose a PyComponent from JS.\");\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._dispose = function () {\n",
       "    var was_disposed;\n",
       "    was_disposed = this._disposed;\n",
       "    (BaseAppComponent.prototype._dispose).call(this);\n",
       "    if (((was_disposed === false) && (this._session !== null))) {\n",
       "        this._session._unregister_component(this);\n",
       "        if ((this._session.status > 0)) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_flx_set_has_proxy\", [false]);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var StubComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "StubComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "StubComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "StubComponent.prototype.__name__ = \"StubComponent\";\n",
       "var $StubComponent = StubComponent.prototype;\n",
       "\n",
       "$StubComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$StubComponent.__properties__ = []\n",
       "$StubComponent.__actions__ = []\n",
       "$StubComponent.__emitters__ = []\n",
       "$StubComponent.__reactions__ = []\n",
       "$StubComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$StubComponent.__init__ = function (session, id) {\n",
       "    (BaseAppComponent.prototype.__init__).call(this);\n",
       "    this._session = session;\n",
       "    this._id = id;\n",
       "    this._uid = _pyfunc_op_add((session.id + \"_\"), id);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var JsComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "JsComponent.prototype = Object.create(LocalComponent.prototype);\n",
       "JsComponent.prototype._base_class = LocalComponent.prototype;\n",
       "JsComponent.prototype.__name__ = \"JsComponent\";\n",
       "var $JsComponent = JsComponent.prototype;\n",
       "\n",
       "$JsComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$JsComponent.__properties__ = []\n",
       "$JsComponent.__actions__ = []\n",
       "$JsComponent.__emitters__ = []\n",
       "$JsComponent.__reactions__ = []\n",
       "$JsComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "$JsComponent.__proxy_properties__ = []\n",
       "\n",
       "$JsComponent._addEventListener = function (node, type, callback, capture) {\n",
       "    capture = (capture === undefined) ? false: capture;\n",
       "    node.addEventListener(type, callback, capture);\n",
       "    _pymeth_append.call(this._event_listeners, [node, type, callback, capture]);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$JsComponent._dispose = function () {\n",
       "    var callback, capture, err, node, stub1_, type;\n",
       "    (LocalComponent.prototype._dispose).call(this);\n",
       "    while (this._event_listeners.length > 0) {\n",
       "        try {\n",
       "            stub1_ = this._event_listeners.pop();\n",
       "            node = stub1_[0];type = stub1_[1];callback = stub1_[2];capture = stub1_[3];\n",
       "            node.removeEventListener(type, callback, capture);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                console.log(err);\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "\n",
       "var PyComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "PyComponent.prototype = Object.create(ProxyComponent.prototype);\n",
       "PyComponent.prototype._base_class = ProxyComponent.prototype;\n",
       "PyComponent.prototype.__name__ = \"PyComponent\";\n",
       "var $PyComponent = PyComponent.prototype;\n",
       "\n",
       "$PyComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$PyComponent.__properties__ = []\n",
       "$PyComponent.__actions__ = [\"_emit_at_proxy\"]\n",
       "$PyComponent.__emitters__ = []\n",
       "$PyComponent.__reactions__ = []\n",
       "$PyComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "\n",
       "var BsdfComponentExtension = {name: \"flexx.app.component\",\n",
       "    match: function (s, c) {\n",
       "        return c instanceof BaseAppComponent;\n",
       "    },\n",
       "    encode: function (s, c) {\n",
       "        if (_pyfunc_truthy(c instanceof JsComponent)) {\n",
       "            c._ensure_proxy_instance();\n",
       "        }\n",
       "        return {session_id:c._session.id, id:c._id};\n",
       "    },\n",
       "    decode: function (s, d) {\n",
       "        var c, session;\n",
       "        c = null;\n",
       "        session = _pymeth_get.call(window.flexx.sessions, d[\"session_id\"], null);\n",
       "        if ((session === null)) {\n",
       "            session = {id:d[\"session_id\"]};\n",
       "            c = new StubComponent(session, d[\"id\"]);\n",
       "        } else {\n",
       "            c = session.get_component_instance(d[\"id\"]);\n",
       "            if ((c === null)) {\n",
       "                logger.warn(\"Using stub component for \" + d[\"id\"] + \".\");\n",
       "                c = new StubComponent(session, d[\"id\"]);\n",
       "            }\n",
       "        }\n",
       "        return c;\n",
       "    }};\n",
       "serializer.add_extension(BsdfComponentExtension);\n",
       "\n",
       "\n",
       "return {JsComponent: JsComponent, LocalProperty: LocalProperty, PyComponent: PyComponent};\n",
       "});\n",
       "\n",
       "</script><script>\n",
       "            flexx.is_notebook = true;\n",
       "            flexx.is_exported = !flexx.is_live_notebook;\n",
       "            /* If Phosphor is already loaded, disable our Phosphor CSS. */\n",
       "            if (window.jupyter && window.jupyter.lab) {\n",
       "                document.getElementById('phosphor-all.css').disabled = true;\n",
       "            }\n",
       "            flexx.init();\n",
       "            flexx.create_session(\"__default__\", \"7iCzwC1zpt7nLyj5bHfnZNaS\", \"ws://localhost:49192/flexx/ws/__default__\");\n",
       "            </script><i>Flexx is ready for use</i>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%gui asyncio\n",
    "from flexx import flx\n",
    "flx.init_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Twente temperature demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='flx-container' id='Twente_2_container' />"
      ],
      "text/plain": [
       "<JsComponent 'Twente_2' at 0x1aa0f9864a8>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "var bb64 =  flexx.require(\"bb64\");\n",
       "function cmd(c) {flexx.s1._receive_command(flexx.serializer.decode(bb64.decode(c)));}\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxRmbGV4eC51aS5fd2lkZ2V0LmNzc3P9lwMAAAAAAAAvKiA9PT09PT09PT09PT09PT09PT09PT09PT09PSBmbGV4eC51aS5fd2lkZ2V0ID09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCi8qIEF1dG9nZW5lcmF0ZWQgY29kZSBmcm9tIEZsZXh4LiBDb2RlIFN1YmplY3QgdG8gdGhlIEJTRC0yLWNsYXVzZSBsaWNlbnNlLiAqLwoKCgoKCiAgICAuZmx4LVdpZGdldCB7CiAgICAgICAgYm94LXNpemluZzogYm9yZGVyLWJveDsKICAgICAgICBvdmVyZmxvdzogaGlkZGVuOwogICAgICAgIHBvc2l0aW9uOiByZWxhdGl2ZTsgIC8qIGhlbHBzIHdpdGggYWJzb2x1dGUgcG9zaXRpb25pbmcgb2YgY29udGVudCAqLwogICAgfQogICAgCiAgICAvKiBpbiBhIG5vdGVib29rIG9yIG90aGVyd2lzZSBlbWJlZGRlZCBpbiBjbGFzc2ljIEhUTUwgKi8KICAgIC5mbHgtY29udGFpbmVyIHsKICAgICAgICBtaW4taGVpZ2h0OiAyMHB4OwogICAgfQogICAgCiAgICAvKiBNYWluIHdpZGdldCB0byBmaWxsIHRoZSB3aG9sZSBwYWdlICovCiAgICAuZmx4LW1haW4td2lkZ2V0IHsKICAgICAgIHBvc2l0aW9uOiBhYnNvbHV0ZTsKICAgICAgIGxlZnQ6IDA7CiAgICAgICByaWdodDogMDsKICAgICAgIHdpZHRoOiAxMDAlOwogICAgICAgdG9wOiAwOwogICAgICAgYm90dG9tOiAwOwogICAgICAgaGVpZ2h0OiAxMDAlOwogICAgfQogICAgCiAgICAvKiB0byBwb3NpdGlvbiBjaGlsZHJlbiBhYnNvbHV0ZSAqLwogICAgLmZseC1hYnMtY2hpbGRyZW4gPiAuZmx4LVdpZGdldCB7CiAgICAgICAgcG9zaXRpb246IGFic29sdXRlOwogICAgfQogICAgCiAgICAvKiBGaXggaXNzdWUgZmxleGJveCA+IFdpZGdldCA+IGxheW91dCBvbiBDaHJvbWUgKi8KICAgIC5mbHgtV2lkZ2V0Om5vdCguZmx4LUxheW91dCkgPiAuZmx4LUxheW91dCB7CiAgICAgICAgcG9zaXRpb246IGFic29sdXRlOwogICAgfQogICAg\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxxmbGV4eC51aS5sYXlvdXRzLl9sYXlvdXQuY3Nzc/3PAQAAAAAAAC8qID09PT09PT09PT09PT09PT09PT09PT0gZmxleHgudWkubGF5b3V0cy5fbGF5b3V0ID09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogQXV0b2dlbmVyYXRlZCBjb2RlIGZyb20gRmxleHguIENvZGUgU3ViamVjdCB0byB0aGUgQlNELTItY2xhdXNlIGxpY2Vuc2UuICovCgoKCgogICAgCiAgICBib2R5IHsKICAgICAgICBtYXJnaW46IDA7CiAgICAgICAgcGFkZGluZzogMDsKICAgIH0KICAgIAogICAgLmZseC1MYXlvdXQgewogICAgICAgIC8qIHNpemluZyBvZiB3aWRnZXRzL2xheW91dHMgaW5zaWRlIGxheW91dCBpcyBkZWZpbmVkIHBlciBsYXlvdXQgKi8KICAgICAgICB3aWR0aDogMTAwJTsKICAgICAgICBoZWlnaHQ6IDEwMCU7CiAgICAgICAgbWFyZ2luOiAwOwogICAgICAgIHBhZGRpbmc6IDA7CiAgICAgICAgYm9yZGVyLXNwYWNpbmc6IDA7CiAgICAgICAgYm9yZGVyOiAwOwogICAgfQogICAgCiAgICA=\");\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxxmbGV4eC51aS53aWRnZXRzLl9jYW52YXMuY3Nzc/0yAgAAAAAAAC8qID09PT09PT09PT09PT09PT09PT09PT0gZmxleHgudWkud2lkZ2V0cy5fY2FudmFzID09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogQXV0b2dlbmVyYXRlZCBjb2RlIGZyb20gRmxleHguIENvZGUgU3ViamVjdCB0byB0aGUgQlNELTItY2xhdXNlIGxpY2Vuc2UuICovCgoKCgogICAgLmZseC1DYW52YXNXaWRnZXQgewogICAgICAgIG1pbi13aWR0aDogNTBweDsKICAgICAgICBtaW4taGVpZ2h0OiA1MHB4OwogICAgICAgIC13ZWJraXQtdXNlci1zZWxlY3Q6IG5vbmU7CiAgICAgICAgLW1vei11c2VyLXNlbGVjdDogbm9uZTsKICAgICAgICAtbXMtdXNlci1zZWxlY3Q6IG5vbmU7CiAgICAgICAgdXNlci1zZWxlY3Q6IG5vbmU7CiAgICB9CiAgICAuZmx4LUNhbnZhc1dpZGdldCA+IGNhbnZhcyB7CiAgICAgICAgLyogU2V0IHBvc2l0aW9uIHRvIGFic29sdXRlIHNvIHRoYXQgdGhlIGNhbnZhcyBpcyBub3QgZ29pbmcKICAgICAgICAgKiB0byBiZSBmb3JjaW5nIGEgc2l6ZSBvbiB0aGUgY29udGFpbmVyIGRpdi4gKi8KICAgICAgICBwb3NpdGlvbjogYWJzb2x1dGU7CiAgICB9CiAgICA=\");\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxtmbGV4eC51aS53aWRnZXRzLl9ncm91cC5jc3Nz/aABAAAAAAAALyogPT09PT09PT09PT09PT09PT09PT09PSBmbGV4eC51aS53aWRnZXRzLl9ncm91cCA9PT09PT09PT09PT09PT09PT09PT09PSovCgovKiBBdXRvZ2VuZXJhdGVkIGNvZGUgZnJvbSBGbGV4eC4gQ29kZSBTdWJqZWN0IHRvIHRoZSBCU0QtMi1jbGF1c2UgbGljZW5zZS4gKi8KCgoKCiAgICAKICAgIC5mbHgtR3JvdXBXaWRnZXQgewogICAgICAgIG1hcmdpbjogMDsKICAgICAgICBwYWRkaW5nOiA1cHg7CiAgICAgICAgYm9yZGVyOiAycHggc29saWQgI2NjYzsKICAgICAgICBib3JkZXItcmFkaXVzOiAzcHg7CiAgICB9CiAgICAuZmx4LUdyb3VwV2lkZ2V0ID4gLmZseC1MYXlvdXQgewogICAgICAgIHdpZHRoOiBjYWxjKDEwMCUgLSAxMHB4KTsKICAgICAgICBoZWlnaHQ6IGNhbGMoMTAwJSAtIDEwcHgpOwogICAgfQogICAgCiAgICA=\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxtmbGV4eC51aS53aWRnZXRzLl9sYWJlbC5jc3Nz/W8BAAAAAAAALyogPT09PT09PT09PT09PT09PT09PT09PSBmbGV4eC51aS53aWRnZXRzLl9sYWJlbCA9PT09PT09PT09PT09PT09PT09PT09PSovCgovKiBBdXRvZ2VuZXJhdGVkIGNvZGUgZnJvbSBGbGV4eC4gQ29kZSBTdWJqZWN0IHRvIHRoZSBCU0QtMi1jbGF1c2UgbGljZW5zZS4gKi8KCgoKCiAgICAgICAgLmZseC1MYWJlbCB7CiAgICAgICAgICAgIGJvcmRlcjogMHB4IHNvbGlkICM0NTQ7CiAgICAgICAgICAgIHVzZXItc2VsZWN0OiB0ZXh0OwogICAgICAgICAgICAtbW96LXVzZXItc2VsZWN0OiB0ZXh0OwogICAgICAgICAgICAtd2Via2l0LXVzZXItc2VsZWN0OiB0ZXh0OwogICAgICAgICAgICAtbXMtdXNlci1zZWxlY3Q6IHRleHQ7CiAgICAgICAgfQ==\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcyBmbGV4eC51aS53aWRnZXRzLl9wbG90d2lkZ2V0LmNzc3PVLyogPT09PT09PT09PT09PT09PT09PT0gZmxleHgudWkud2lkZ2V0cy5fcGxvdHdpZGdldCA9PT09PT09PT09PT09PT09PT09PSovCgovKiBBdXRvZ2VuZXJhdGVkIGNvZGUgZnJvbSBGbGV4eC4gQ29kZSBTdWJqZWN0IHRvIHRoZSBCU0QtMi1jbGF1c2UgbGljZW5zZS4gKi8KCgoKLmZseC1QbG90V2lkZ2V0IHttaW4td2lkdGg6IDMwMHB4OyBtaW4taGVpZ2h0OiAyMDBweDt9\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMHSlMtRVZBTHMaZmxleHgudWkud2lkZ2V0cy5fZ3JvdXAuanNz/fQKAAAAAAAALyogPT09PT09PT09PT09PT09PT09PT09PSBmbGV4eC51aS53aWRnZXRzLl9ncm91cCA9PT09PT09PT09PT09PT09PT09PT09PSovCgovKiBBdXRvZ2VuZXJhdGVkIGNvZGUgZnJvbSBGbGV4eC4gQ29kZSBTdWJqZWN0IHRvIHRoZSBCU0QtMi1jbGF1c2UgbGljZW5zZS4gKi8KCgoKZmxleHguZGVmaW5lKCJmbGV4eC51aS53aWRnZXRzLl9ncm91cCIsIFsicHNjcmlwdC1zdGQuanMiLCAiZmxleHgudWkuX3dpZGdldCJdLCBmdW5jdGlvbiAoX3B5LCBmbGV4eCR1aSRfd2lkZ2V0KSB7CgoidXNlIHN0cmljdCI7Cgp2YXIgX3B5ZnVuY19vcF9pbnN0YW50aWF0ZSA9IF9weS5fcHlmdW5jX29wX2luc3RhbnRpYXRlOwoKdmFyIF9weW1ldGhfYXBwZW5kID0gX3B5Ll9weW1ldGhfYXBwZW5kOwoKdmFyIFdpZGdldCA9IGZsZXh4JHVpJF93aWRnZXQuV2lkZ2V0OwoKCgoKCnZhciBHcm91cFdpZGdldCA9IGZ1bmN0aW9uICgpIHsKICAgIF9weWZ1bmNfb3BfaW5zdGFudGlhdGUodGhpcywgYXJndW1lbnRzKTsKfQpHcm91cFdpZGdldC5wcm90b3R5cGUgPSBPYmplY3QuY3JlYXRlKFdpZGdldC5wcm90b3R5cGUpOwpHcm91cFdpZGdldC5wcm90b3R5cGUuX2Jhc2VfY2xhc3MgPSBXaWRnZXQucHJvdG90eXBlOwpHcm91cFdpZGdldC5wcm90b3R5cGUuX19uYW1lX18gPSAiR3JvdXBXaWRnZXQiOwp2YXIgJEdyb3VwV2lkZ2V0ID0gR3JvdXBXaWRnZXQucHJvdG90eXBlOwoKJEdyb3VwV2lkZ2V0Ll9fYXR0cmlidXRlc19fID0gWyJpZCIsICJyb290IiwgInNlc3Npb24iLCAidWlkIl0KJEdyb3VwV2lkZ2V0Ll9fcHJvcGVydGllc19fID0gWyJjYXB0dXJlX21vdXNlIiwgImNoaWxkcmVuIiwgImNvbnRhaW5lciIsICJjc3NfY2xhc3MiLCAiZmxleCIsICJpY29uIiwgInBhcmVudCIsICJzaXplIiwgInNpemVfbWluX21heCIsICJ0YWJpbmRleCIsICJ0aXRsZSJdCiRHcm91cFdpZGdldC5fX2FjdGlvbnNfXyA9IFsiX2NoZWNrX21pbl9tYXhfc2l6ZSIsICJhcHBseV9zdHlsZSIsICJjaGVja19yZWFsX3NpemUiLCAic2V0X2NhcHR1cmVfbW91c2UiLCAic2V0X2NvbnRhaW5lciIsICJzZXRfY3NzX2NsYXNzIiwgInNldF9mbGV4IiwgInNldF9pY29uIiwgInNldF9wYXJlbnQiLCAic2V0X3RhYmluZGV4IiwgInNldF90aXRsZSJdCiRHcm91cFdpZGdldC5fX2VtaXR0ZXJzX18gPSBbImtleV9kb3duIiwgImtleV9wcmVzcyIsICJrZXlfdXAiLCAibW91c2VfZG93biIsICJtb3VzZV9tb3ZlIiwgIm1vdXNlX3VwIiwgIm1vdXNlX3doZWVsIl0KJEdyb3VwV2lkZ2V0Ll9fcmVhY3Rpb25zX18gPSBbIl9XaWRnZXRfX2NvbnRhaW5lcl9jaGFuZ2VkIiwgIl9XaWRnZXRfX2Nzc19jbGFzc19jaGFuZ2VkIiwgIl9XaWRnZXRfX2ljb25fY2hhbmdlZCIsICJfV2lkZ2V0X19taW5fbWF4X3NpemVfbWF5X2hhdmVfY2hhbmdlZCIsICJfV2lkZ2V0X19yZW5kZXIiLCAiX1dpZGdldF9fc2l6ZV9tYXlfaGF2ZV9jaGFuZ2VkIiwgIl9XaWRnZXRfX3RpdGxlX2NoYW5nZWQiLCAiX1dpZGdldF9fdXBkYXRlX3RhYmluZGV4IiwgIl90aXRsZV9jaGFuZ2VkIl0KJEdyb3VwV2lkZ2V0Ll9fanNtb2R1bGVfXyA9ICJmbGV4eC51aS53aWRnZXRzLl9ncm91cCIKJEdyb3VwV2lkZ2V0Ll9fcHJveHlfcHJvcGVydGllc19fID0gWyJjYXB0dXJlX21vdXNlIiwgImNvbnRhaW5lciIsICJjc3NfY2xhc3MiLCAiZmxleCIsICJwYXJlbnQiLCAic2l6ZSIsICJzaXplX21pbl9tYXgiLCAidGFiaW5kZXgiLCAidGl0bGUiXQoKJEdyb3VwV2lkZ2V0Ll9jcmVhdGVfZG9tID0gZnVuY3Rpb24gKCkgewogICAgdmFyIG5vZGU7CiAgICBub2RlID0gd2luZG93LmRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImZpZWxkc2V0Iik7CiAgICB0aGlzLl9sZWdlbmQgPSB3aW5kb3cuZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgibGVnZW5kIik7CiAgICBub2RlLmFwcGVuZENoaWxkKHRoaXMuX2xlZ2VuZCk7CiAgICByZXR1cm4gbm9kZTsKfTsKCiRHcm91cFdpZGdldC5fcmVuZGVyX2RvbSA9IGZ1bmN0aW9uICgpIHsKICAgIHZhciBub2Rlcywgc3R1YjFfc2VxLCBzdHViMl9pdHIsIHdpZGdldDsKICAgIG5vZGVzID0gW3RoaXMuX2xlZ2VuZF07CiAgICBzdHViMV9zZXEgPSB0aGlzLmNoaWxkcmVuOwogICAgaWYgKCh0eXBlb2Ygc3R1YjFfc2VxID09PSAib2JqZWN0IikgJiYgKCFBcnJheS5pc0FycmF5KHN0dWIxX3NlcSkpKSB7IHN0dWIxX3NlcSA9IE9iamVjdC5rZXlzKHN0dWIxX3NlcSk7fQogICAgZm9yIChzdHViMl9pdHIgPSAwOyBzdHViMl9pdHIgPCBzdHViMV9zZXEubGVuZ3RoOyBzdHViMl9pdHIgKz0gMSkgewogICAgICAgIHdpZGdldCA9IHN0dWIxX3NlcVtzdHViMl9pdHJdOwogICAgICAgIF9weW1ldGhfYXBwZW5kLmNhbGwobm9kZXMsIHdpZGdldC5vdXRlcm5vZGUpOwogICAgfQogICAgcmV0dXJuIG5vZGVzOwp9OwoKJEdyb3VwV2lkZ2V0Ll90aXRsZV9jaGFuZ2VkID0gZnVuY3Rpb24gKCkgewogICAgdmFyIGV2ZW50czsKICAgIGV2ZW50cyA9IEFycmF5LnByb3RvdHlwZS5zbGljZS5jYWxsKGFyZ3VtZW50cyk7CiAgICB0aGlzLl9sZWdlbmQudGV4dENvbnRlbnQgPSAoIlx1MDBhMCIgKyB0aGlzLnRpdGxlKSArICJcdTAwYTAiOwogICAgcmV0dXJuIG51bGw7Cn07CiRHcm91cFdpZGdldC5fdGl0bGVfY2hhbmdlZC5ub2JpbmQgPSB0cnVlOwokR3JvdXBXaWRnZXQuX3RpdGxlX2NoYW5nZWQuX21vZGUgPSAibm9ybWFsIgokR3JvdXBXaWRnZXQuX3RpdGxlX2NoYW5nZWQuX2Nvbm5lY3Rpb25fc3RyaW5ncyA9IFsidGl0bGUiXQoKCgpyZXR1cm4ge0dyb3VwV2lkZ2V0OiBHcm91cFdpZGdldH07Cn0pOwo=\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMHSlMtRVZBTHMbZmxleHhhbXBsZXMuZGVtb3MudHdlbnRlLmpzc/2vKwAAAAAAAC8qID09PT09PT09PT09PT09PT09PT09PT0gZmxleHhhbXBsZXMuZGVtb3MudHdlbnRlID09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogQXV0b2dlbmVyYXRlZCBjb2RlIGZyb20gRmxleHguIENvZGUgU3ViamVjdCB0byB0aGUgQlNELTItY2xhdXNlIGxpY2Vuc2UuICovCgoKCmZsZXh4LmRlZmluZSgiZmxleHhhbXBsZXMuZGVtb3MudHdlbnRlIiwgWyJwc2NyaXB0LXN0ZC5qcyIsICJmbGV4eC51aS53aWRnZXRzLl9zbGlkZXIiLCAiZmxleHgudWkud2lkZ2V0cy5fcGxvdHdpZGdldCIsICJmbGV4eC51aS53aWRnZXRzLl9sYWJlbCIsICJmbGV4eC51aS53aWRnZXRzLl9ncm91cCIsICJmbGV4eC51aS53aWRnZXRzLl9kcm9wZG93biIsICJmbGV4eC51aS5sYXlvdXRzLl9odiIsICJmbGV4eC51aS5fd2lkZ2V0Il0sIGZ1bmN0aW9uIChfcHksIGZsZXh4JHVpJHdpZGdldHMkX3NsaWRlciwgZmxleHgkdWkkd2lkZ2V0cyRfcGxvdHdpZGdldCwgZmxleHgkdWkkd2lkZ2V0cyRfbGFiZWwsIGZsZXh4JHVpJHdpZGdldHMkX2dyb3VwLCBmbGV4eCR1aSR3aWRnZXRzJF9kcm9wZG93biwgZmxleHgkdWkkbGF5b3V0cyRfaHYsIGZsZXh4JHVpJF93aWRnZXQpIHsKCiJ1c2Ugc3RyaWN0IjsKCnZhciBfcHlmdW5jX2ludCA9IF9weS5fcHlmdW5jX2ludCwgX3B5ZnVuY19vcF9hZGQgPSBfcHkuX3B5ZnVuY19vcF9hZGQsIF9weWZ1bmNfb3BfZXF1YWxzID0gX3B5Ll9weWZ1bmNfb3BfZXF1YWxzLCBfcHlmdW5jX29wX2luc3RhbnRpYXRlID0gX3B5Ll9weWZ1bmNfb3BfaW5zdGFudGlhdGUsIF9weWZ1bmNfcmFuZ2UgPSBfcHkuX3B5ZnVuY19yYW5nZTsKCnZhciBfcHltZXRoX2FwcGVuZCA9IF9weS5fcHltZXRoX2FwcGVuZDsKCnZhciBmbHgkV2lkZ2V0ID0gZmxleHgkdWkkX3dpZGdldC5XaWRnZXQ7Cgp2YXIgV2lkZ2V0ID0gZmxleHgkdWkkX3dpZGdldC5XaWRnZXQ7Cgp2YXIgZmx4JEhGaXggPSBmbGV4eCR1aSRsYXlvdXRzJF9odi5IRml4OwoKdmFyIGZseCRWQm94ID0gZmxleHgkdWkkbGF5b3V0cyRfaHYuVkJveDsKCnZhciBmbHgkQ29tYm9Cb3ggPSBmbGV4eCR1aSR3aWRnZXRzJF9kcm9wZG93bi5Db21ib0JveDsKCnZhciBmbHgkR3JvdXBXaWRnZXQgPSBmbGV4eCR1aSR3aWRnZXRzJF9ncm91cC5Hcm91cFdpZGdldDsKCnZhciBmbHgkTGFiZWwgPSBmbGV4eCR1aSR3aWRnZXRzJF9sYWJlbC5MYWJlbDsKCnZhciBmbHgkUGxvdFdpZGdldCA9IGZsZXh4JHVpJHdpZGdldHMkX3Bsb3R3aWRnZXQuUGxvdFdpZGdldDsKCnZhciBmbHgkU2xpZGVyID0gZmxleHgkdWkkd2lkZ2V0cyRfc2xpZGVyLlNsaWRlcjsKCnZhciBkYXRhID0gW1szLjUsIDEuOSwgMS4xLCAtMS4xLCAtMC4xLCAxLjcsIDMuMiwgMS42LCAxLjIsIDIuMSwgMS40LCAzLjEsIC02LjMsIC0wLjEsIDIuNCwgLTAuMywgMy4yLCAwLjcsIDMuNywgLTAuNCwgMi4yLCAtMC4zLCAyLjMsIDUuMSwgNi4yLCAyLjYsIDIuMiwgMi43LCAtMy45LCAtMC44LCAxLjYsIDAuMywgNS43LCAyLjMsIC00LjYsIDEuNiwgLTQuMCwgNS44LCA0LjEsIDUuMCwgMi45LCAyLjIsIDQuMiwgNC40LCAyLjcsIC0xLjYsIC0xLjcsIDQuMywgNC41LCAzLjcsIDIuMiwgMy45LCAxLjYsIDIuNywgNC4zLCAwLjQsIDYuMSwgNS45LCAwLjEsIC0xLjcsIDIuNywgMy42LCAxLjUsIDQuOCwgMy40LCAzLjQsIDAuMl0sIFszLjUsIDIuMCwgMS41LCAtMS4wLCAtMC41LCAtNy4xLCA0LjksIDMuMiwgMC43LCAyLjUsIDYuMSwgMi4xLCAtMy44LCAyLjgsIDEuMSwgMy43LCA0LjgsIDEuMywgLTAuNywgMC40LCAzLjIsIDMuNCwgMi4zLCA0LjIsIDIuNywgMS45LCA0LjUsIDAuMiwgLTIuMiwgMy44LCAwLjksIDIuMywgMC4wLCAxLjQsIC0xLjQsIC00LjYsIDEuNywgNC4yLCA0LjgsIDcuMywgLTAuOSwgNC43LCAxLjIsIDAuNiwgNi4wLCAtMS4wLCA1LjgsIDUuNywgMi42LCA1LjIsIDMuNywgNi41LCAwLjcsIDQuMCwgMS40LCAxLjgsIDUuNCwgNC43LCAyLjYsIDAuOSwgMy42LCAwLjEsIDAuOSwgNi40LCAyLjYsIDMuOSwgNC40XSwgWzMuNCwgNC4zLCA0LjcsIDUuNywgMS42LCA1LjAsIDguMCwgMS41LCA3LjIsIDUuNSwgNy4xLCAxLjQsIDQuNSwgMi4zLCAzLjcsIDQuNiwgNi40LCA1LjksIDEuMywgMi4xLCAyLjMsIDYuMSwgNC45LCA1LjUsIDQuMywgMi4yLCA2LjgsIDYuMSwgNC4xLCAzLjgsIDguMSwgNS4wLCA1LjYsIDMuMywgMy41LCA0LjUsIDEuMywgNC4zLCA3LjcsIDcuOSwgOC4zLCA2LjQsIDUuMSwgNy4wLCA0LjYsIDIuMywgNy4yLCA2LjcsIDYuNiwgNi4zLCA0LjIsIDYuNCwgNi44LCA1LjMsIDUuOCwgMy4yLCA3LjQsIDUuMywgNS41LCA1LjgsIDUuMiwgNy43LCAxLjIsIDguMSwgNS43LCA0LjksIDguNV0sIFs3LjQsIDEwLjcsIDkuMSwgNi41LCA4LjIsIDUuMCwgOC4zLCA2LjIsIDEwLjMsIDguOCwgMTAuNCwgOC4wLCA5LjEsIDkuMSwgNy42LCA4LjcsIDcuMCwgOS41LCA3LjcsIDUuNiwgNy44LCA3LjEsIDUuNCwgOC41LCA2LjksIDcuMSwgNi4wLCA2LjcsIDcuMywgNy40LCA4LjcsIDcuMSwgOC45LCA3LjEsIDguMSwgNi44LCAxMC4zLCA4LjEsIDYuNSwgOC40LCA4LjEsIDguMywgMTEuMiwgOC4xLCA4LjksIDguOSwgNy4wLCA5LjAsIDkuNywgMTAuMiwgNy45LCA4LjksIDkuMywgMTAuMywgMTAuMiwgOC41LCAxMi41LCA4LjMsIDEyLjUsIDkuMywgMTIuNCwgOC4yLCA4LjIsIDExLjgsIDguNywgOC4yLCA3LjldLCBbMTIuMCwgMTIuOSwgMTMuMywgMTIuOCwgMTAuMCwgMTIuNywgMTAuMiwgMTIuOSwgMTMuMSwgMTMuMCwgMTAuNiwgOS45LCAxMS4yLCAxNC4zLCAxMS43LCAxMy41LCAxMi44LCAxMC42LCAxMi45LCAxMi41LCAxMy44LCAxMS42LCAxMS45LCAxMS4yLCAxMC44LCAxMi45LCAxMS43LCAxMi4xLCAxMS42LCAxMS41LCAxMy44LCAxMi4yLCAxMS4xLCAxMC4wLCAxMy4yLCAxMy43LCA5LjksIDE0LjQsIDEzLjgsIDEzLjgsIDkuNywgMTUuNCwgMTQuMiwgMTIuMywgMTIuNCwgMTAuNiwgMTIuNCwgMTQuNCwgMTMuNSwgMTQuNSwgMTQuMCwgMTMuNSwgMTMuNCwgMTEuNiwgMTIuNSwgMTQuMywgMTMuOSwgMTUuMCwgMTMuNywgMTAuMCwgMTMuOCwgMTQuNSwgMTEuNiwgMTIuNywgMTIuMCwgMTQuNCwgMTQuOV0sIFsxNS40LCAxNC45LCAxNi4yLCAxNS42LCAxNC42LCAxMy4wLCAxNi42LCAxNC44LCAxNi40LCAxNi4xLCAxNS43LCAxMy41LCAxNS44LCAxNS42LCAxNS4wLCAxNy4xLCAxNC42LCAxNS41LCAxNC41LCAxNy4wLCAxMy44LCAxMy43LCAxNi4wLCAxNC4zLCAxNC43LCAxNy4zLCAxNC4zLCAxNC41LCAxNS4wLCAxNC41LCAxNC43LCAxNi4xLCAxNS45LCAxMi45LCAxMy4xLCAxNi4wLCAxMy43LCAxNC41LCAxNS45LCAxNS4xLCAxMi42LCAxNy4wLCAxNS4yLCAxNS4xLCAxNC41LCAxNS4xLCAxNS43LCAxNS41LCAxNC45LCAxNi4wLCAxNC43LCAxNi43LCAxNy45LCAxNS4yLCAxNi4yLCAxNi44LCAxNy40LCAxNi40LCAxNS4zLCAxNi40LCAxNi4yLCAxNC41LCAxNS40LCAxNS43LCAxNS4zLCAxNy4xLCAxNy45XSwgWzE2LjksIDE3LjIsIDE3LjAsIDE0LjIsIDE3LjksIDE2LjYsIDE3LjYsIDE2LjgsIDE5LjIsIDE1LjMsIDE1LjIsIDE0LjUsIDE2LjUsIDE2LjksIDE0LjcsIDE1LjUsIDE4LjEsIDE2LjEsIDE3LjUsIDE1LjQsIDE3LjAsIDE3LjIsIDE3LjEsIDE0LjcsIDE3LjYsIDE4LjgsIDE2LjEsIDE1LjAsIDE1LjAsIDE1LjMsIDE2LjMsIDE4LjYsIDE5LjEsIDE1LjAsIDE2LjUsIDE2LjIsIDE2LjMsIDE2LjAsIDE3LjgsIDE2LjEsIDE4LjgsIDE4LjIsIDE1LjcsIDIxLjMsIDIwLjAsIDE2LjEsIDE3LjMsIDE1LjksIDE4LjgsIDE1LjIsIDE4LjMsIDE3LjQsIDE4LjUsIDE2LjUsIDE3LjYsIDIyLjIsIDE2LjksIDE4LjAsIDE3LjgsIDIwLjQsIDE1LjgsIDE2LjksIDE4LjgsIDE5LjUsIDE4LjQsIDE4LjEsIDE4LjBdLCBbMTcuMSwgMTcuMywgMTYuNywgMTYuMCwgMTguMSwgMTQuMCwgMTUuNiwgMTcuNywgMTguMCwgMTUuNSwgMTUuOCwgMTUuMiwgMTUuMywgMTYuMSwgMTUuMiwgMTUuOCwgMTYuMywgMTYuOCwgMTYuOCwgMTYuNSwgMTcuMSwgMTUuMSwgMTcuNiwgMTYuNCwgMTkuNSwgMTcuMCwgMTUuOCwgMTQuNywgMTUuMSwgMTYuNiwgMTYuNCwgMTYuOSwgMTcuNCwgMTYuOCwgMTUuMCwgMTUuMSwgMTUuNSwgMTYuNiwgMTcuMSwgMTguMiwgMTcuMywgMTguMCwgMTQuNiwgMTcuNCwgMTguNywgMTcuNSwgMjAuMSwgMTYuMCwgMTcuMiwgMTYuOSwgMTguMywgMTguNiwgMTkuMywgMTguOCwgMTUuNywgMTUuOSwgMTYuOCwgMTcuMywgMTguMiwgMTYuNCwgMTYuOCwgMTguNCwgMTcuOSwgMTUuNywgMTguNSwgMTcuNSwgMTcuMl0sIFsxNS41LCAxMS4xLCAxNC4wLCAxMy44LCAxNC42LCAxNC42LCAxMi40LCAxNS43LCAxNS42LCAxMy4zLCAxNy4yLCAxMi43LCAxMy43LCAxNC4yLCAxMy4xLCAxMy40LCAxNC4xLCAxNC4yLCAxMy43LCAxMy42LCAxMi41LCAxMC44LCAxNC41LCAxMi45LCAxNC44LCAxMy40LCAxMi42LCAxMy42LCAxMi41LCAxNC42LCAxNC44LCAxNi4wLCAxMy40LCAxMi40LCAxMy4yLCAxMC41LCAxNC41LCAxMy45LCAxNS40LCAxMi4yLCAxNC43LCAxNC4zLCAxMi41LCAxMy4zLCAxMy42LCAxMS41LCAxMy40LCAxNC40LCAxNy43LCAxNS4wLCAxMi44LCAxMy45LCAxMy45LCAxNC45LCAxNS4yLCAxNy43LCAxMy4zLCAxMy4xLCAxNC40LCAxMi42LCAxNS4yLCAxMy40LCAxMy44LCAxNS4zLCAxMy4yLCAxNy4xLCAxMy41XSwgWzguNSwgOC4wLCAxMS41LCAxMS42LCA5LjIsIDkuNCwgMTAuNywgMTAuOSwgMTEuMSwgMTAuNywgMTEuNCwgMTAuNCwgOS4xLCA3LjgsIDkuOCwgMTEuMSwgMTEuNiwgMTEuMSwgMTEuNSwgOS45LCA5LjcsIDguMiwgOC4zLCA2LjQsIDcuNywgMTAuNywgMTEuNCwgMTEuMCwgOS42LCA4LjcsIDguNSwgMTEuMiwgOS40LCAxMC45LCA5LjcsIDEwLjksIDEwLjQsIDEwLjQsIDEyLjIsIDExLjksIDkuNCwgNy4zLCA4LjYsIDguNiwgMTIuNCwgOS45LCA4LjksIDkuMCwgMTAuMSwgMTEuMSwgMTQuMCwgOC42LCA2LjYsIDExLjAsIDEyLjksIDEzLjYsIDkuMywgOS43LCA5LjMsIDkuNSwgMTAuNiwgOS42LCAxMS44LCAxMy4yLCA5LjQsIDguOSwgMTIuNl0sIFs4LjIsIDIuMywgNy4xLCA2LjUsIDUuOCwgNC42LCA2LjAsIDUuNCwgNS4yLCA3LjMsIDQuNSwgMy45LCA4LjEsIDUuOCwgMS45LCAzLjgsIDQuNywgNS4wLCA2LjAsIDcuMiwgNC42LCA1LjMsIDQuOSwgNi4yLCA0LjUsIDYuMSwgNi4xLCA2LjYsIDQuNSwgNC4yLCA2LjAsIDcuNiwgNS40LCA3LjMsIDEuNywgNy43LCA2LjEsIDUuMywgNS4wLCA1LjQsIDUuMCwgNy40LCAxLjUsIDguNywgNS41LCA1LjIsIDUuNywgMi45LCA1LjksIDcuNywgNi4xLCA3LjEsIDcuOCwgNS40LCA2LjEsIDguOCwgNi4xLCA2LjIsIDkuNCwgNS4yLCA2LjAsIDYuNCwgNS45LCA4LjAsIDkuMSwgNC44LCA2LjNdLCBbNC40LCAxLjAsIDQuOCwgNS4xLCA0LjIsIDQuOSwgMi40LCA0LjQsIDMuOSwgMi42LCAwLjgsIC0xLjQsIC0xLjUsIDIuMCwgMy44LCAzLjYsIDIuNSwgLTAuNywgLTIuNSwgMS44LCA1LjAsIDMuMiwgMi4zLCA2LjYsIDIuMywgMC43LCA0LjIsIDEuMywgNC42LCAyLjksIC0xLjAsIDMuMSwgMi43LCAzLjUsIDUuMiwgNC4xLCAzLjgsIDUuNSwgNC40LCAzLjUsIDMuMiwgMy4zLCA0LjQsIDQuOCwgLTEuNiwgLTAuNiwgNC4xLCAzLjUsIDQuMSwgNC42LCAyLjEsIDEuNiwgMy4zLCAyLjcsIDMuMywgNi4yLCAzLjEsIDEuOCwgMS43LCAtMi43LCA1LjUsIDQuMSwgNS41LCA0LjEsIDkuMiwgNC4xLCA0LjJdLCBbOS43LCA4LjYsIDkuOCwgOC44LCA4LjYsIDcuOSwgOS43LCA5LjMsIDEwLjIsIDkuNCwgOS43LCA3LjgsIDcuNiwgOC45LCA4LjMsIDkuMiwgOS43LCA4LjgsIDguNSwgOC41LCA5LjEsIDguNSwgOS4wLCA5LjMsIDkuMywgOS4yLCA5LjMsIDguNywgNy44LCA4LjUsIDkuMSwgOS43LCA5LjYsIDguNiwgNy44LCA4LjUsIDguMywgOS45LCAxMC40LCAxMC40LCA5LjEsIDEwLjIsIDkuMCwgMTAuMSwgOS44LCA3LjgsIDkuNywgOS44LCAxMC41LCAxMC41LCA5LjksIDEwLjMsIDkuOSwgOS45LCAxMC4xLCAxMC44LCAxMC43LCAxMC4xLCAxMC4wLCA4LjUsIDEwLjMsIDkuOCwgOS40LCAxMS4zLCAxMC41LCAxMC4yLCAxMC41XV07CnZhciBtb250aHMgPSBbIkphbiIsICJGZWIiLCAiTWFyIiwgIkFwciIsICJNYXkiLCAiSnVuIiwgIkp1bCIsICJBdWciLCAiU2VwIiwgIk9jdCIsICJOb3YiLCAiRGVjIiwgInRvdGFsIl07CnZhciB5ZWFycyA9IFsxOTUxLCAxOTUyLCAxOTUzLCAxOTU0LCAxOTU1LCAxOTU2LCAxOTU3LCAxOTU4LCAxOTU5LCAxOTYwLCAxOTYxLCAxOTYyLCAxOTYzLCAxOTY0LCAxOTY1LCAxOTY2LCAxOTY3LCAxOTY4LCAxOTY5LCAxOTcwLCAxOTcxLCAxOTcyLCAxOTczLCAxOTc0LCAxOTc1LCAxOTc2LCAxOTc3LCAxOTc4LCAxOTc5LCAxOTgwLCAxOTgxLCAxOTgyLCAxOTgzLCAxOTg0LCAxOTg1LCAxOTg2LCAxOTg3LCAxOTg4LCAxOTg5LCAxOTkwLCAxOTkxLCAxOTkyLCAxOTkzLCAxOTk0LCAxOTk1LCAxOTk2LCAxOTk3LCAxOTk4LCAxOTk5LCAyMDAwLCAyMDAxLCAyMDAyLCAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3LCAyMDA4LCAyMDA5LCAyMDEwLCAyMDExLCAyMDEyLCAyMDEzLCAyMDE0LCAyMDE1LCAyMDE2LCAyMDE3XTsKCgoKdmFyIFR3ZW50ZSA9IGZ1bmN0aW9uICgpIHsKICAgIF9weWZ1bmNfb3BfaW5zdGFudGlhdGUodGhpcywgYXJndW1lbnRzKTsKfQpUd2VudGUucHJvdG90eXBlID0gT2JqZWN0LmNyZWF0ZShXaWRnZXQucHJvdG90eXBlKTsKVHdlbnRlLnByb3RvdHlwZS5fYmFzZV9jbGFzcyA9IFdpZGdldC5wcm90b3R5cGU7ClR3ZW50ZS5wcm90b3R5cGUuX19uYW1lX18gPSAiVHdlbnRlIjsKdmFyICRUd2VudGUgPSBUd2VudGUucHJvdG90eXBlOwoKJFR3ZW50ZS5fX2F0dHJpYnV0ZXNfXyA9IFsiaWQiLCAicm9vdCIsICJzZXNzaW9uIiwgInVpZCJdCiRUd2VudGUuX19wcm9wZXJ0aWVzX18gPSBbImNhcHR1cmVfbW91c2UiLCAiY2hpbGRyZW4iLCAiY29udGFpbmVyIiwgImNzc19jbGFzcyIsICJmbGV4IiwgImljb24iLCAicGFyZW50IiwgInNpemUiLCAic2l6ZV9taW5fbWF4IiwgInRhYmluZGV4IiwgInRpdGxlIl0KJFR3ZW50ZS5fX2FjdGlvbnNfXyA9IFsiX2NoZWNrX21pbl9tYXhfc2l6ZSIsICJhcHBseV9zdHlsZSIsICJjaGVja19yZWFsX3NpemUiLCAic2V0X2NhcHR1cmVfbW91c2UiLCAic2V0X2NvbnRhaW5lciIsICJzZXRfY3NzX2NsYXNzIiwgInNldF9mbGV4IiwgInNldF9pY29uIiwgInNldF9wYXJlbnQiLCAic2V0X3RhYmluZGV4IiwgInNldF90aXRsZSJdCiRUd2VudGUuX19lbWl0dGVyc19fID0gWyJrZXlfZG93biIsICJrZXlfcHJlc3MiLCAia2V5X3VwIiwgIm1vdXNlX2Rvd24iLCAibW91c2VfbW92ZSIsICJtb3VzZV91cCIsICJtb3VzZV93aGVlbCJdCiRUd2VudGUuX19yZWFjdGlvbnNfXyA9IFsiX1dpZGdldF9fY29udGFpbmVyX2NoYW5nZWQiLCAiX1dpZGdldF9fY3NzX2NsYXNzX2NoYW5nZWQiLCAiX1dpZGdldF9faWNvbl9jaGFuZ2VkIiwgIl9XaWRnZXRfX21pbl9tYXhfc2l6ZV9tYXlfaGF2ZV9jaGFuZ2VkIiwgIl9XaWRnZXRfX3JlbmRlciIsICJfV2lkZ2V0X19zaXplX21heV9oYXZlX2NoYW5nZWQiLCAiX1dpZGdldF9fdGl0bGVfY2hhbmdlZCIsICJfV2lkZ2V0X191cGRhdGVfdGFiaW5kZXgiLCAiX3VwZGF0ZV9wbG90Il0KJFR3ZW50ZS5fX2pzbW9kdWxlX18gPSAiZmxleHhhbXBsZXMuZGVtb3MudHdlbnRlIgokVHdlbnRlLl9fcHJveHlfcHJvcGVydGllc19fID0gWyJjYXB0dXJlX21vdXNlIiwgImNvbnRhaW5lciIsICJjc3NfY2xhc3MiLCAiZmxleCIsICJwYXJlbnQiLCAic2l6ZSIsICJzaXplX21pbl9tYXgiLCAidGFiaW5kZXgiLCAidGl0bGUiXQoKJFR3ZW50ZS5pbml0ID0gZnVuY3Rpb24gKCkgewogICAgdmFyIHN0dWIxX2NvbnRleHQsIHN0dWIyX2Vyciwgc3R1YjNfY29udGV4dCwgc3R1YjRfZXJyLCBzdHViNV9jb250ZXh0LCBzdHViNl9lcnIsIHN0dWI3X2NvbnRleHQsIHN0dWI4X2VycjsKICAgIHN0dWIxX2NvbnRleHQgPSAobmV3IGZseCRIRml4KCkpOwogICAgc3R1YjFfY29udGV4dC5fX2VudGVyX18oKTsKICAgIHRyeSB7CiAgICAgICAgbmV3IGZseCRXaWRnZXQoe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge2ZsZXg6IDF9fSk7CiAgICAgICAgc3R1YjNfY29udGV4dCA9IChuZXcgZmx4JFZCb3goe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge2ZsZXg6IDAsIHN0eWxlOiAibWluLXdpZHRoOjIwMHB4In19KSk7CiAgICAgICAgc3R1YjNfY29udGV4dC5fX2VudGVyX18oKTsKICAgICAgICB0cnkgewogICAgICAgICAgICBzdHViNV9jb250ZXh0ID0gKG5ldyBmbHgkR3JvdXBXaWRnZXQoe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge3RpdGxlOiAiUGxvdCBvcHRpb25zIn19KSk7CiAgICAgICAgICAgIHN0dWI1X2NvbnRleHQuX19lbnRlcl9fKCk7CiAgICAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICAgICBuZXcgZmx4JExhYmVsKHtmbHhfYXJnczogW10sIGZseF9rd2FyZ3M6IHt0ZXh0OiAiTW9udGgifX0pOwogICAgICAgICAgICAgICAgdGhpcy5tb250aCA9IG5ldyBmbHgkQ29tYm9Cb3goe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge29wdGlvbnM6IG1vbnRocywgc2VsZWN0ZWRfaW5kZXg6IDEyLCBzdHlsZTogIndpZHRoOiAxMDAlIn19KTsKICAgICAgICAgICAgICAgIHRoaXMuc21vb3RoaW5nX2xhYmVsID0gbmV3IGZseCRMYWJlbCh7Zmx4X2FyZ3M6IFtdLCBmbHhfa3dhcmdzOiB7dGV4dDogIlNtb290aGluZyJ9fSk7CiAgICAgICAgICAgICAgICB0aGlzLnNtb290aGluZyA9IG5ldyBmbHgkU2xpZGVyKHtmbHhfYXJnczogW10sIGZseF9rd2FyZ3M6IHttYXg6IDIwLCBzdGVwOiAyLCB0ZXh0OiAie3ZhbHVlfSBzYW1wbGVzIn19KTsKICAgICAgICAgICAgfSBjYXRjaChlcnJfMykgIHsgc3R1YjZfZXJyPWVycl8zOyB9CiAgICAgICAgICAgIGlmIChzdHViNl9lcnIpIHsgaWYgKCFzdHViNV9jb250ZXh0Ll9fZXhpdF9fKHN0dWI2X2Vyci5uYW1lIHx8ICJlcnJvciIsIHN0dWI2X2VyciwgbnVsbCkpIHsgdGhyb3cgc3R1YjZfZXJyOyB9CiAgICAgICAgICAgIH0gZWxzZSB7IHN0dWI1X2NvbnRleHQuX19leGl0X18obnVsbCwgbnVsbCwgbnVsbCk7IH0KICAgICAgICAgICAgbmV3IGZseCRXaWRnZXQoe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge2ZsZXg6IDN9fSk7CiAgICAgICAgfSBjYXRjaChlcnJfMikgIHsgc3R1YjRfZXJyPWVycl8yOyB9CiAgICAgICAgaWYgKHN0dWI0X2VycikgeyBpZiAoIXN0dWIzX2NvbnRleHQuX19leGl0X18oc3R1YjRfZXJyLm5hbWUgfHwgImVycm9yIiwgc3R1YjRfZXJyLCBudWxsKSkgeyB0aHJvdyBzdHViNF9lcnI7IH0KICAgICAgICB9IGVsc2UgeyBzdHViM19jb250ZXh0Ll9fZXhpdF9fKG51bGwsIG51bGwsIG51bGwpOyB9CiAgICAgICAgc3R1YjdfY29udGV4dCA9IChuZXcgZmx4JFZCb3goe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge2ZsZXg6IDR9fSkpOwogICAgICAgIHN0dWI3X2NvbnRleHQuX19lbnRlcl9fKCk7CiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgdGhpcy5wbG90ID0gbmV3IGZseCRQbG90V2lkZ2V0KHtmbHhfYXJnczogW10sIGZseF9rd2FyZ3M6IHtmbGV4OiAxLCB4ZGF0YTogeWVhcnMsIHlyYW5nZTogWy01LCAyMF0sIHRpdGxlOiAiQXZlcmFnZSBtb250aGx5IHRlbXBlcmF0dXJlIiwgeGxhYmVsOiAieWVhciIsIHlsYWJlbDogInRlbXBlcmF0dXJlIChcdTAwYjBDKSJ9fSk7CiAgICAgICAgfSBjYXRjaChlcnJfMikgIHsgc3R1YjhfZXJyPWVycl8yOyB9CiAgICAgICAgaWYgKHN0dWI4X2VycikgeyBpZiAoIXN0dWI3X2NvbnRleHQuX19leGl0X18oc3R1YjhfZXJyLm5hbWUgfHwgImVycm9yIiwgc3R1YjhfZXJyLCBudWxsKSkgeyB0aHJvdyBzdHViOF9lcnI7IH0KICAgICAgICB9IGVsc2UgeyBzdHViN19jb250ZXh0Ll9fZXhpdF9fKG51bGwsIG51bGwsIG51bGwpOyB9CiAgICAgICAgbmV3IGZseCRXaWRnZXQoe2ZseF9hcmdzOiBbXSwgZmx4X2t3YXJnczoge2ZsZXg6IDF9fSk7CiAgICB9IGNhdGNoKGVycl8xKSAgeyBzdHViMl9lcnI9ZXJyXzE7IH0KICAgIGlmIChzdHViMl9lcnIpIHsgaWYgKCFzdHViMV9jb250ZXh0Ll9fZXhpdF9fKHN0dWIyX2Vyci5uYW1lIHx8ICJlcnJvciIsIHN0dWIyX2VyciwgbnVsbCkpIHsgdGhyb3cgc3R1YjJfZXJyOyB9CiAgICB9IGVsc2UgeyBzdHViMV9jb250ZXh0Ll9fZXhpdF9fKG51bGwsIG51bGwsIG51bGwpOyB9CiAgICByZXR1cm4gbnVsbDsKfTsKCiRUd2VudGUuX3VwZGF0ZV9wbG90ID0gZnVuY3Rpb24gKCkgewogICAgdmFyIGksIGosIG4sIHNtMiwgc21vb3RoaW5nLCB2YWwsIHl5MSwgeXkyOwogICAgc21vb3RoaW5nID0gdGhpcy5zbW9vdGhpbmcudmFsdWU7CiAgICB5eTEgPSBkYXRhW3RoaXMubW9udGguc2VsZWN0ZWRfaW5kZXhdOwogICAgeXkyID0gW107CiAgICBzbTIgPSBfcHlmdW5jX2ludCgoc21vb3RoaW5nIC8gMikpOwogICAgZm9yIChpID0gMDsgaSA8IHl5MS5sZW5ndGg7IGkgKz0gMSkgewogICAgICAgIHZhbCA9IDA7CiAgICAgICAgbiA9IDA7CiAgICAgICAgZm9yIChqID0gTWF0aC5tYXgoMCwgKGkgLSBzbTIpKTsgaiA8IE1hdGgubWluKHl5MS5sZW5ndGgsIChfcHlmdW5jX29wX2FkZChpLCBzbTIpICsgMSkpOyBqICs9IDEpIHsKICAgICAgICAgICAgdmFsID0gX3B5ZnVuY19vcF9hZGQodmFsLCB5eTFbal0pOwogICAgICAgICAgICBuID0gX3B5ZnVuY19vcF9hZGQobiwgMSk7CiAgICAgICAgfQogICAgICAgIGlmIChfcHlmdW5jX29wX2VxdWFscyhuLCAwKSkgewogICAgICAgICAgICBfcHltZXRoX2FwcGVuZC5jYWxsKHl5MiwgeXkxW2ldKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBfcHltZXRoX2FwcGVuZC5jYWxsKHl5MiwgKHZhbCAvIG4pKTsKICAgICAgICB9CiAgICB9CiAgICB0aGlzLnBsb3Quc2V0X2RhdGEodGhpcy5wbG90LnhkYXRhLCB5eTIpOwogICAgcmV0dXJuIG51bGw7Cn07CiRUd2VudGUuX3VwZGF0ZV9wbG90Lm5vYmluZCA9IHRydWU7CiRUd2VudGUuX3VwZGF0ZV9wbG90Ll9tb2RlID0gImF1dG8iCgoKCnJldHVybiB7VHdlbnRlOiBUd2VudGUsIGRhdGE6IGRhdGEsIG1vbnRoczogbW9udGhzLCB5ZWFyczogeWVhcnN9Owp9KTsK\");\n",
       "cmd(\"QlNERgIBbAdzC0lOU1RBTlRJQVRFcxhmbGV4eGFtcGxlcy5kZW1vcy50d2VudGVzBlR3ZW50ZXMIVHdlbnRlXzJsAG0CBXN0eWxlcwxoZWlnaHQ6MzAwcHgNZmx4X2hhc19wcm94eXlsAA==\");\n",
       "cmd(\"QlNERgIBbARzBklOVk9LRXMIVHdlbnRlXzJzDXNldF9jb250YWluZXJsAXMSVHdlbnRlXzJfY29udGFpbmVy\");"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from flexxamples.demos.twente import Twente\n",
    "t = Twente(style='height:300px')\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splines app"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='flx-container' id='Splines_3_container' />"
      ],
      "text/plain": [
       "<JsComponent 'Splines_3' at 0x1aa0f91deb8>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "var bb64 =  flexx.require(\"bb64\");\n",
       "function cmd(c) {flexx.s1._receive_command(flexx.serializer.decode(bb64.decode(c)));}\n",
       "cmd(\"QlNERgIBbARzBkRFRklORXMDQ1NTcxxmbGV4eC51aS53aWRnZXRzLl9idXR0b24uY3Nzc/14BQAAAAAAAC8qID09PT09PT09PT09PT09PT09PT09PT0gZmxleHgudWkud2lkZ2V0cy5fYnV0dG9uID09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogQXV0b2dlbmVyYXRlZCBjb2RlIGZyb20gRmxleHguIENvZGUgU3ViamVjdCB0byB0aGUgQlNELTItY2xhdXNlIGxpY2Vuc2UuICovCgoKCgoKICAgIC5mbHgtQmFzZUJ1dHRvbiB7CiAgICAgICAgbWluLWhlaWdodDogMTZweDsKICAgICAgICB3aGl0ZS1zcGFjZTogbm93cmFwOwogICAgICAgIHBhZGRpbmc6IDAuMmVtIDAuNGVtOwogICAgICAgIGJvcmRlci1yYWRpdXM6IDNweDsKICAgICAgICBjb2xvcjogIzMzMzsKICAgIH0KICAgIC5mbHgtQmFzZUJ1dHRvbiwgLmZseC1CYXNlQnV0dG9uID4gaW5wdXQgewogICAgICAgIG1hcmdpbjogMnB4OyAvKiByb29tIGZvciBvdXRsaW5lICovCiAgICB9CiAgICAuZmx4LUJhc2VCdXR0b246Zm9jdXMsIC5mbHgtQmFzZUJ1dHRvbiA+IGlucHV0OmZvY3VzICB7CiAgICAgICAgb3V0bGluZTogbm9uZTsKICAgICAgICBib3gtc2hhZG93OiAwcHggMHB4IDNweCAxcHggcmdiYSgwLCAxMDAsIDIwMCwgMC43KTsKICAgIH0KICAgIAogICAgLmZseC1CdXR0b24sIC5mbHgtVG9nZ2xlQnV0dG9uewogICAgICAgIGJhY2tncm91bmQ6ICNlOGU4ZTg7CiAgICAgICAgYm9yZGVyOiAxcHggc29saWQgI2NjYzsKICAgICAgICB0cmFuc2l0aW9uOiBiYWNrZ3JvdW5kIDAuM3M7CiAgICB9CiAgICAuZmx4LUJ1dHRvbjpob3ZlciwgLmZseC1Ub2dnbGVCdXR0b246aG92ZXIgewogICAgICAgIGJhY2tncm91bmQ6ICNlOGVhZmY7CiAgICB9CiAgICAKICAgIC5mbHgtVG9nZ2xlQnV0dG9uIHsKICAgICAgICB0ZXh0LWFsaWduOiBsZWZ0OwogICAgfQogICAgLmZseC1Ub2dnbGVCdXR0b24uZmx4LWNoZWNrZWQgewogICAgICAgIGJhY2tncm91bmQ6ICNlOGVhZmY7CiAgICB9CiAgICAuZmx4LVRvZ2dsZUJ1dHRvbjo6YmVmb3JlIHsKICAgICAgICBjb250ZW50OiAnXDI2MTBcMDBhMCAnOwogICAgfQogICAgLmZseC1Ub2dnbGVCdXR0b24uZmx4LWNoZWNrZWQ6OmJlZm9yZSB7CiAgICAgICAgY29udGVudDogJ1wyNjExXDAwYTAgJzsKICAgIH0KICAgIAogICAgLmZseC1SYWRpb0J1dHRvbiA+IGlucHV0LCAuZmx4LUNoZWNrQm94ID4gaW5wdXR7CiAgICAgICAgbWFyZ2luLWxlZnQ6IDAuM2VtOwogICAgICAgIG1hcmdpbi1yaWdodDogMC4zZW07CiAgICB9CiAgICAKICAgIC5mbHgtUmFkaW9CdXR0b24gPiBpbnB1dCwgLmZseC1DaGVja0JveCA+IGlucHV0IHsKICAgICAgICBjb2xvcjogIzMzMzsKICAgIH0KICAgIC5mbHgtUmFkaW9CdXR0b246aG92ZXIgPiBpbnB1dCwgLmZseC1DaGVja0JveDpob3ZlciA+IGlucHV0IHsKICAgICAgICBjb2xvcjogIzAzNjsKICAgIH0KCiAgICAKICAgIAoKCgoKCgoK\");\n",
       "cmd(\"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\");\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbAdzC0lOU1RBTlRJQVRFcxlmbGV4eGFtcGxlcy5kZW1vcy5zcGxpbmVzcwdTcGxpbmVzcwlTcGxpbmVzXzNsAG0CBXN0eWxlcwxoZWlnaHQ6MzAwcHgNZmx4X2hhc19wcm94eXlsAA==\");\n",
       "cmd(\"QlNERgIBbARzBklOVk9LRXMJU3BsaW5lc18zcw1zZXRfY29udGFpbmVybAFzE1NwbGluZXNfM19jb250YWluZXI=\");"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from flexxamples.demos.splines import Splines\n",
    "splines = Splines(style='height:300px')\n",
    "splines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}